DGC releases

DGC 0.39.0

2026-09-15T00:00:00Z

The backend no longer stops mid-turn on its own. Commands the agent ran shared dgc serve's command pipe; a Node tool such as npm switched that pipe to non-blocking, the next read came back empty, and serve took it for the editor closing and ended the turn as Stopped. dgc serve now keeps a private copy of its pipe and every command it runs reads from an empty input. If the backend ever does stop during a turn, the editor names the cause and offers Continue.; Model requests that hang are noticed. After 45 seconds without progress DGC says it is still waiting, a request that stays silent is retried, and a request that never recovers fails with the model and endpoint named, instead of waiting out a 30-minute socket timeout. Long silent reasoning and a local model that is still loading are not mistaken for a stall.; Background monitors. When you ask it to watch or wait for something, the agent can start a long-running command with the monitor tool, keep working, and hear about each line it prints: between tool calls while a turn runs, and as a short turn of its own when the chat is idle. /monitors lists and stops them, wake-ups pause after ten in a row without a message from you, and a wake turn never runs a step that needs your approval outside auto mode. A command started with bash in the background now tells the model once when it exits.; Token usage is counted on this machine, per model and per day: /usage in DGC, dgc usage on the command line, and Settings → Token Usage in the editor. Sessions on OpenAI-compatible endpoints such as Ollama's /v1 no longer record zero tokens, so goal token budgets advance, and a request that ended without a usage report is counted as unmetered rather than as free.; Versioned installs. Each release installs into its own directory and the dgc launcher switches to it in one step, so a failed download leaves the working version in place. dgc update --rollback returns to the previous version, a custom install location is remembered, dgc doctor reports the installation and what an update would change, and the installer never extracts over a git checkout.; The checklist can be cleared while a turn runs, and the model is told once that it was cleared. The trust screen draws the /// mark as one block instead of a zig-zag, and dgc -p --output-format json no longer tells a script to type /todo clear.; Security: the artifact server never publishes dot-files, secret files or a project's source. A page served from a project root publishes only the files it links, a page in its own folder publishes that folder's web files, and pages inside dot folders are refused. The server answers only to this machine's own addresses, so a website cannot reach it through DNS rebinding, and stopping an artifact needs a token.; Continue survives a killed backend: a running turn is saved at each step, and a turn cut off by the backend's shutdown is offered Continue.; Browser screenshots reach the model from the first turn. A fresh backend did not know its model could see images until the model was changed, so screenshots never arrived.; In full-auto, asking DGC to let you choose now opens the options picker for that request. Where the picker cannot open (a sub-agent, a turn a monitor started, dgc -p), the model is told why and lists the options instead.

DGC 0.38.1

2026-09-13T00:00:00Z

The task list has one owner. The todo tool replaced the tool context's list while the agent kept a stale copy, so a new chat could inherit the previous chat's unfinished tasks and a standing goal could accept a completion report over pending work. The context list is canonical now; a replacement is validated as a whole — bounded, row-indexed errors, common status synonyms accepted, over-long text truncated — so a malformed local-model call cannot erase a plan; task text passes session redaction; and a new blocked status lets the model park a step honestly instead of pretending it is pending or done.; Finishing with open todos is a visible notice, not a failure. After its two reminders DGC completes the turn and names what remains (blocked steps excluded) rather than ending the turn as an error: a hard stop there would have paused every standing goal at each cycle boundary, made dgc -p exit 1 for finished work, and failed every later turn of a resumed session that still carried an old list. A standing goal whose only open steps are blocked now ends as blocked with those steps named. /todo clear drops a list the model left behind, and the clear is persisted.; Editor protocol v12, shipped together with extension 0.23.0: history snapshots carry the checklist, so a resumed or reloaded editor shows the same tasks the backend enforces (the rewind path included), and a clear_todos command backs the editor's Clear button. Also: the offscreen renderer respects the terminal height under TERM=dumb, and the response-cadence instructions that a token-budget squeeze had silently removed are back. And /bg light (alias /bg white), a readable light terminal mode with live switching; default stays inherit.

DGC 0.38.0

2026-09-13T00:00:00Z

/diff: every changed file, its counts and its diff, live under the transcript. The focus pane gains a second occupant beside /files: a read-only view of the working tree against HEAD — staged and untracked files included — with +/− line counts per file, the set summed in the header, and a unified diff with new-side line numbers. It re-reads Git every two seconds while open, so the model's edits appear as they land, and it never writes, stages or runs a shell command.; Lines you select in a diff become part of your next prompt. Space starts a selection, Enter attaches it to the composer as a fenced diff block headed by the file and line range, and a takes the whole hunk — so "why did you change these two lines?" quotes exactly those two lines and nothing else about the file enters the model's context. Wide terminals show the list and the diff side by side; narrow ones swap between them with Tab.; Two documentation pages join the guide: Diff pane, and Checkpoints & rewind — the restore points DGC has taken before every edit all along, /rewind for code and conversation, the editor's Undo, and /branch, written up as one feature. /diff also appears in the keyboard cheatsheet and the slash-command reference; /diff PATH opens straight into one file.

DGC 0.37.3

2026-09-13T00:00:00Z

The backend keeps its own crash log. An editor gets dgc serve's stderr on a pipe and may do nothing with it — DGC's own extension dropped every byte of it — and an ACP or third-party front-end owes us nothing at all, so a backend that dies unattended left no evidence anywhere. `dgc serve` now writes ~/.dgc/logs/serve.log itself: start, exit reason, command failures with tracebacks, and a full stack dump of every thread on a segfault, abort or SIGTERM — the deaths that produce no Python traceback at all.; Reopening a session no longer pastes your own goal back at you. The agent writes scaffolding into the transcript so the MODEL reads it — the standing-goal reminder, which embeds the entire objective, and the open-todo nudge. Those are user-role messages, so replaying a restored session rendered them as chat bubbles: the whole goal spec appeared as a prompt nobody sent.; Scrolling back into the compacted archive is bounded by frame size, not just by row count. A page was clamped to 200 rows of up to 20,000 characters each — about 4MB before JSON escaping, and past the protocol's 4MB frame ceiling once real transcript punctuation is escaped. An over-ceiling page was reduced to an empty one, so scrolling past the summary showed nothing. Pages now fill to a byte budget and report exactly where they stopped, so the next page resumes there.

DGC 0.37.2

2026-09-12T00:00:00Z

The backend can no longer emit a frame that gets it killed. A protocol event larger than the 4MB ceiling is refused by the editor as a protocol violation, and nothing measured the WIRE size before sending: a screenshot is capped at 4MB of PNG, which is about 5.6MB once base64 and JSON-escaped, so any screenshot over 3MB breached it. Frames are now bounded at the writer, and a batch of screenshots is split into frames that fit rather than sent as one oversized event.; An event too large to send keeps its envelope instead of being replaced wholesale. A frame carrying a correlation id is a question, not a notification — replacing an approval request with a generic error left the editor nothing to answer and the turn waiting on a decision that could never arrive.

DGC 0.37.1

2026-09-12T00:00:00Z

DGC is now open source under the Apache License 2.0, replacing PolyForm Noncommercial. It may be used commercially, inside a company and on client work with no separate agreement, and the licence grants the patent rights contributors hold in the work. Its obligations are the ordinary ones: keep the licence and copyright notice with copies, and state significant changes.; A standing goal that DGC has stopped retrying is marked blocked rather than left active. Leaving it active was a lie the clock told — the goal card kept counting while nothing was running and nothing was going to run. Blocked stops the clock and carries the reason into the goal review.

DGC 0.37.0

2026-09-12T00:00:00Z

A standing goal survives a turn that stops on its own. The point of a goal is that work continues without someone watching, but the loop guard ending a turn ended the goal with it — nothing ran until a person pressed Resume. DGC now restarts the goal itself, carrying the reason forward so the model changes approach instead of reissuing the call that failed, and caps consecutive restarts at two: if changing approach twice does not help, a person needs to look rather than DGC spending the context window retrying.; Settings you are allowed to change mid-turn now actually change. An editor saves the whole settings form, so the one value you moved arrives surrounded by two dozen untouched ones — and the mid-turn gate rejected the save on a neighbour. Raising the context window during a run was refused because `subagent_api_mode` came along for the ride. Only a value that would really move the execution route waits for the turn to end now.; An image sent to a model that cannot read images no longer strands the run: the image is dropped for that request with a note the model can act on, instead of failing the turn and leaving the attachment in history where every resume failed the same way.; A blocked repeat hands back the result it already had. Refusing a repeated tool call with “you already got this” is useless once compaction has dropped the result — re-reading is then the rational move and refusing deadlocks the turn.; Editor protocol v11: the editor can page back into what compaction archived, so scrolling up past the summary shows the turns rather than stopping at it.

DGC 0.36.1

2026-09-12T00:00:00Z

Ollama cloud models work again. Selecting one and taking a turn failed with “Ollama response returned malformed JSON”, which made every cloud model unusable. A local Ollama labels a streaming response application/x-ndjson; the cloud serves the same newline-delimited stream as application/json — the identical header it uses for a single object — so the header cannot decide the shape. The body is read once and its shape decides; a body that is genuinely malformed still fails loudly.; A resumed chat no longer opens with a summary you never wrote. Compaction hands the model its own history back as a user message and an acknowledgement, which is how a long run stays inside its window — but the editor rendered those as chat, so a resumed goal looked as though it had restarted. They are one quiet marker now, with the summary behind a disclosure, which is also the honest reason scrolling up stops where it does.

DGC 0.36.0

2026-09-12T00:00:00Z

Resuming a standing goal continues the work instead of replaying it. The objective used to be re-submitted as a fresh prompt, so text you wrote days ago reappeared in the chat and the model read it as a new request. Every frontend now asks the backend to resume, and the backend reactivates the goal and tells the model to pick up the first unfinished step.; A reopened session keeps its checklist. Todos were held in memory only, so closing the editor lost what was done, what was in progress and what was still pending — exactly what a resumed goal needs. They are saved with the session now and restored with it.; Asking for a new chat while a turn is running starts one. It used to be refused outright; it now cancels the run, waits for it to actually stop, and then resets, so the abandoned turn cannot write into the new session.; Editor protocol v10 adds resume_goal and labels a resumed turn, so the panel can show what happened rather than inventing a user message.

DGC 0.35.0

2026-09-11T00:00:00Z

A browser tool, so the agent can look at a page that has to actually run — a deployed site, a local dev server, anything JavaScript builds. It opens a URL, reads the page as roles and names it can act on, finds elements, clicks and types with real input events, and reports console messages and failed network responses. It drives a Chrome you already have over the DevTools Protocol, so DGC still ships three dependencies and never downloads a browser.; The page is read from the DOM rather than the accessibility tree. That is not a detail: content-visibility drops off-screen sections from the accessibility tree entirely, so a snapshot built the obvious way silently misses content that is plainly there — measured on this project's own changelog, where text present twice was reported zero times.; Screenshots reach both of you. The model sees the image when it accepts image input, and DGC checks rather than assumes; the editor panel shows it in the conversation as a thumbnail that expands in place and then opens full size.; There is no operation for running arbitrary JavaScript in a page, and there is a test that fails if one ever appears. Navigation is permission-gated per host, page content comes back marked untrusted, and each session browses in a throwaway profile that never sees your real cookies or logged-in sessions.; Finished tool activity now reads as a sentence — “Read 3 files and searched code” rather than a tally of function names.

DGC 0.34.0

2026-09-11T00:00:00Z

/branch (or /fork) continues a conversation in a new chat and leaves the one you came from exactly where it was. Everything so far comes with you — the transcript, the standing goal, the todos, the recovery points — so trying a second approach costs you nothing and does not overwrite the first. The editor offers the same thing under a finished answer.; Editor protocol v8 adds fork_session, so an editor can branch a chat through the same backend that runs it. A branch that cannot be saved is not a branch: the session identity is restored rather than left pointing at a file nothing ever wrote.; A documentation page for the editor: what the panel does, what a finished turn gives you, and how to keep the CLI and the extension in step.

DGC 0.33.1

2026-09-10T00:00:00Z

A standing goal is stated to the model in full once per context — and again after a compaction, which starts a fresh one — instead of being repeated on every turn. Restating it each turn charged the context window for the whole objective again and again: a 4,000-character goal cost about a third of a 32k window after ten turns and four fifths after twenty-five. An extra goal turn now costs about a hundred tokens rather than two thousand.; Because the objective no longer repeats, the length limit is a share of the window rather than a fixed number: a quarter of your context, leaving three quarters for the work. A 32k session allows about 32,000 characters where it allowed 4,000, and a 128k one about 131,000 — raise the context size and the allowance rises with it. A refused objective now says how long it actually is and what this session allows, and gives the text back to the composer instead of discarding it behind a message that expires. A goal restored from a saved session is no longer silently shortened either.; Picking a command that takes an argument — /goal, /notes, /files, /copy — now attaches it to the composer as a chip and waits for you to type, instead of firing the moment you select it; a command that takes nothing still runs immediately. Skills already worked this way, and a resolved /command or $skill now fills as a chip so it reads as an attachment rather than part of the sentence.

DGC 0.33.0

2026-09-10T00:00:00Z

Context notes: DGC now keeps a searchable trace of what a project has already learned, and it outlives the context window. A command that failed, an edit that did not apply, a test suite that passed — each is recorded as the work happens, by the harness rather than the model, so it behaves the same on every local endpoint. The notes are per project, so a run spread over days accumulates one trace.; The point of keeping them is not to have them. After a compaction — the moment this history used to be lost — a bounded digest of requirements, decisions and recent failures rides into the fresh context, and when a step touches a file that has failed before, that history is attached to the result the agent reads. An agent that cannot see its own failed attempts repeats them; now it can.; Read the trace yourself with /notes, /notes , or dgc notes from a shell; the agent searches it with a read-only notes tool that is allowed in plan mode. Notes are bounded, redacted like a saved session, and off with /notes off. They are not the /recall archive, which stays your raw scrollback and still never re-enters the model's context.

DGC 0.32.0

2026-09-10T00:00:00Z

dgc -p for scripts. Piped input joins the prompt (git diff | dgc -p "review this"; -p - reads it whole), --output-format json streams the dgc serve events and ends with one result object (ok, text, session_id, usage), --output FILE saves the answer and --print-session-id gives you the id for --resume. A -p run never waits on a menu: a tool that would ask is denied with the exact --allow-tool rule to pre-approve, and a plan is reported rather than executed. --add-dir, --allow-tool and --sandbox on|off|read-only apply to that run only.; The classic REPL runs your subscription too, and the terminal explains itself. dgc --classic now runs a connected Claude, Codex, Qwen, Kimi or Copilot subscription’s turns (it used to fall back to the native model silently), and every front-end shares one delegated-turn path. A fresh install’s first failure says what to do in dgc doctor’s words instead of a raw 404 or Connection refused; /trust and dgc trust list every trusted folder and revoke one, and the gate warns before trusting your home directory; the welcome screen shows its tip at last.; A composer and a transcript that behave. A paste of five lines or more collapses to [Pasted text #1 +N lines] and expands when sent; past answers and diffs reflow when the terminal is resized instead of staying wrapped at the old width. Editor protocol v7 lets VS Code and Cursor approve against a step’s summary and diff and deny with a note (extension 0.18.0).

DGC 0.31.1

2026-09-10T00:00:00Z

Close two holes a side-by-side with Claude Code and Codex found. A cloned repository’s .dgc/permissions.json was in force before the trust gate ran, and under dgc -p the gate never runs at all; a project’s own rules now load only once its folder is trusted, and the gate says so. dgc update --help piped the installer into bash instead of printing help; every subcommand now answers --help before anything runs, and flags given with -p, such as --model, apply to that run only instead of silently becoming your default.; Text gets out. Ctrl+Y or /copy puts the last reply on your system clipboard through the terminal (OSC 52, so it works over SSH and inside tmux); /copy code takes the last code block, /copy N an earlier reply and /copy all the whole conversation. /export writes the session as Markdown outside the project tree (also dgc export ID), /select hands the mouse to your terminal for drag-select, and /mouse off remembers that. During a turn, a command that has to wait, such as /model, is refused visibly instead of being sent to the model as a prompt.; A quieter, clearer screen. An idle DGC no longer repaints twelve times a second, which cost a quarter of a core, and the streaming answer is re-parsed at most every 80 ms. A file read folds to one line with its length, a failed step says so on its header and shows its output in readable text, long output keeps its head and its tail so a test runner’s verdict stays visible, diffs carry their +/− count, tabs render as indentation, and the header shows the working directory and branch. (0.31.1 corrects a Python 3.10/3.11 syntax error in that renderer; the 0.31.0 tag was never served by the site.)

DGC 0.30.3

2026-09-09T00:00:00Z

Stop a redraw costing the whole session. Every stored transcript entry was re-parsed into display fragments on every frame, so one keystroke paid for the entire scrollback and the terminal grew slower the longer you worked. Entries are now reused until something they are derived from changes, the cursor marker splits only the entry on its line, and lines are counted once while the frame is assembled. On a 200-turn session a frame fell from about 130 ms to under 5 ms.; Show command and skill tokens as commands while you type. A trailing /goal, /plan, /review or /init is applied as a verb to the text before it, so “Set this as your /goal” ran the goal command instead of sending that sentence, which read as the prompt being silently truncated. Only names that actually resolve are marked, so paths and ordinary words stay plain.; Keep an active standing goal on a row above the composer with its objective, state and work time, the same view the editor already had. Document /copy, which hands the mouse back to your terminal so you can select and copy transcript text, and Shift+drag, which does it without leaving scroll mode.

DGC 0.30.2

2026-09-09T00:00:00Z

Fix a /files explorer case where the project itself could be thrown away: from the parent listing the cursor sits on the project folder, and one d sent the whole project to the trash without asking. The explorer now refuses to trash, delete, rename, or move the project root or any folder above it, in every permission mode.; Keep focus-pane frames exactly as tall as the pane when a file name, breadcrumb, or status carries a control or line-separator character. Such characters are neutralised wherever the renderer places pane text, so a strangely named file can no longer push a row out of the frame.; Wait for a killed tool's whole process group to exit, bounded, before reporting the kill complete, so a grandchild process that ignored the polite signal cannot outlive the tool that spawned it.

DGC 0.30.1

2026-09-09T00:00:00Z

Add /files: a file explorer in the focus pane under the transcript — Miller columns, previews, copy/cut/paste, rename, trash with undo, Enter inserts @path — while the agent keeps working. Writes follow the permission mode and stay inside the project.; Show a calibrated turn ETA range in the status line, per-project and measured (/eta stats); /notify pings the terminal when a turn finishes. Promote the hidden arcade's pane into a shared focus-pane host.; Fix the /files natural sort raising when a folder mixes digit-leading and letter-leading names; the focus pane now closes itself on an occupant error instead of taking the transcript down. Test suite runs hermetically with a canonical temporary HOME.

DGC 0.29.2

2026-09-08T00:00:00Z

Browse skills and change permission mode during active turns; recheck pending approvals while preserving explicit ask/deny rules and workspace trust.; Steer native editor turns with text, images and selected context; keep queued and unapplied follow-ups recoverable. Classic CLI Enter steers and Tab queues.; Keep native human decisions pending until reply or Stop; add grouped question review and custom Other answers without defaulting unanswered choices.

DGC 0.29.1

2026-09-07T00:00:00Z

Record private, bounded before/after snapshots for native and subscription chat runs, separate from Git status.; Persist chat reviews across resume, handle partial or cancelled runs and rewind, and exclude pre-existing edits and changes made between runs.

DGC 0.29.0

2026-09-06T00:00:00Z

Inline commands and exact skill selection, 22 bundled skills, portable packages, and shared plan, review and project-guide workflows.; MCP server management and bounded resource/prompt snapshots work across terminal, editor and durable goals.; Correct native completion and cancellation, reliable subscription startup, clean terminal file links, macOS change inspection and closed command output pipes.

DGC 0.28.0

2026-09-06T00:00:00Z

Durable goals continue on native and subscription routes, with pause, resume, review, token budgets and saved completion evidence.; Shared response guidance, safer delegated streaming and protocol v6 keep CLI and editor behavior aligned.; Safer loop/refactor skills preserve existing user work; the new UI review skill supports real interface audits.

DGC 0.27.0

2026-09-06T00:00:00Z

DGC Ultra coordinates deeper reasoning and bounded parallel agents through one explicit profile.; Long native turns keep useful progress visible while bounded finalization guarantees a user-facing answer or an explicit saved-progress error.; Editor sessions gain persistent thread titles, action-oriented standing goals, and acknowledgement-driven artifact controls.

DGC 0.26.4

2026-09-04T00:00:00Z

User-cancelled streams now remain cancelled when provider socket shutdown appears as a clean end-of-stream.; Partial tool calls from cancelled generations remain non-executable and cannot enter automatic incomplete-stream recovery.; Provider terminal markers take precedence over late cancellation, preserving already-completed responses.

DGC 0.26.3

2026-09-04T00:00:00Z

macOS code intelligence and session resume now share one protected system-alias identity.; Repository-controlled and user-owned symlink paths remain outside that narrow compatibility rule.; Package CI verifies the release archive beside its basename-scoped checksum file.

DGC 0.26.2

2026-09-04T00:00:00Z

macOS workspaces now accept protected system path aliases while repository-controlled symlinks remain blocked.; Clean source checkouts generate deterministic runtime SBOMs without importing or executing package code.; Python 3.10 and subscription preflight release gates are now deterministic across CI runners.

DGC 0.26.1

2026-09-04T00:00:00Z

Audited model routing keeps native and subscription modes explicit and consistent.; Provider and MCP credentials are now endpoint-bound and fail closed; older unbound CLI keys may need to be entered once again.; Release provenance, public-site inventory, and deployment gates bind published bytes to reviewed source.

DGC 0.26.0

2026-09-03T00:00:00Z

A refined full-screen terminal experience for long-running agent work.; Smoother concurrent TUI rendering while an agent keeps working.; Release archives rebuilt and verified against the published source.

DGC 0.25.1

2026-09-03T00:00:00Z

Correct context budgeting when a resumed session stored the 32k default.; Resume behavior now preserves the configured model window exactly.; Site and release manifests promoted from the same verified bytes.

DGC 0.25.0

2026-09-02T00:00:00Z

Standing goals, autonomous verification gates, and continuation handoffs.; Persistent Python code-action mode and scrubbed training export.; A structured VS Code/Cursor surface for goals, tools, diffs, and plans.

DGC 0.21.1

2026-08-29T00:00:00Z

Follow-up reliability fixes after the 0.21 security release.; Tighter provider and session edge-case handling.; Published checksums and reproducible release metadata.

DGC 0.21.0

2026-08-27T00:00:00Z

OS sandboxing and canonical workspace confinement.; Expanded permission rules, hooks, MCP, and tool-output boundaries.; Security-focused hardening across the terminal and editor protocols.

DGC 0.20.8

2026-08-23T00:00:00Z

Local and OpenAI-compatible provider setup from one CLI.; Permission modes, plan review, artifacts, sessions, and model switching.; A stable baseline for subsequent reliability and interface releases.