Codify for VS Code

The whole Codify workflow, inside the editor. Everything is driven by the cg binary — the extension holds no state and never parses specs or code itself, so it cannot disagree with the CLI.

Code navigation from the graph

The extension runs cg lsp and speaks the Language Server Protocol to it, so every language Codify indexes gets real editor support with no compiler, no toolchain, and no project configuration:

That last row is the point. Scope drift shows up as a squiggle at the moment of the edit — for you and for whatever agent is working alongside you — instead of waiting for someone to run a command. It is a warning, never an error: Codify advises, and only --strict enforces.

Turn it off with codify.languageServer if you want the task board alone.

Task board

A "Codify" container in the activity bar, with two views.

Tasks shows the active feature's plan the way Codify sees it:

• Tasks grouped by dependency wave, with per-wave progress and status icons. The next eligible task is marked; implemented tasks are shown as qualification pending rather than done.
• Expanding a task reveals its verification data from cg spec trace: declared symbols with resolved location, kind and reference count; touched-path patterns with whether a matching change exists; the commits tagged with the task; and the memories written under it.
• Inline actions run the real workflow — start, mark implemented, complete. cg spec done is refused when verify_cmd or the graph checks fail, with the failing checks shown in the Codify output and a deliberately awkward, modal "Force done anyway" escape hatch.
• In parallel mode, tasks show who holds their lease, and claim/release actions appear.

Memory lists recent decisions, constraints and facts, grouped by type, with the task each was written under. Add one from anywhere with Codify: Remember a Decision — if a file is open, it is anchored to that file automatically.

The agent view

The Codify sidebar has an Agent view — a persistent chat with Claude Code or Codex, always there, no task required. The extension speaks the Agent Client Protocol to the agent's ACP adapter (claude-code-acp or the maintained @agentclientprotocol/codex-acp). A lightweight connection on view open discovers past sessions; a working session starts when you send or restore one. Every working session runs in the workspace with Codify's own MCP server injected (cg mcp), so the agent has the full graph, spec, and memory toolset without any per-repo MCP config. A provider picker in the header switches between Codex, Claude Code, and a Custom ACP command for the next chat; the choice is remembered per workspace. The ⚙ gear next to it (also Codify: Configure Agent Provider) is a quick pick that switches provider, edits each adapter's launch command in place, or opens the codify.acp settings. The ＋ New Agent Chat button on the view resets to a fresh session.

The Past sessions selector merges compact workspace history remembered by the extension with the adapter's ACP session/list results. Titles are cleaned before they are shown: harness prefixes such as Claude Code's local-command caveat are stripped, a /clear session is titled by its command, and a session that begins with a context-compaction summary is titled ↻ continued: <what the work was about>, since Claude Code opens a new session file at every compaction. Selecting one uses session/load for transcript replay, or session/resume when the adapter only supports context restoration; that limitation is stated inline. Refresh asks the selected adapter again. Adapters without session lifecycle support leave locally known entries visible but never claim that history was restored.

The session bar shows the connected adapter and injected codify MCP server. Agent-provided ACP modes and session options appear as native controls, so Codex and Claude Code can expose their own plan/agent mode, model, or reasoning choices without extension-specific wiring. The bar also follows agent-generated session titles and context-window usage. Agent-native slash commands join the composer palette; collisions are namespaced as /agent-<name> so commands such as Codify's /review always keep their meaning.

The view streams replies and collapsed thinking, renders each tool call as an expandable card — kind badge and colour, status tick, elapsed time, the raw input, locations, and diffs — tracks the plan, and surfaces permission requests as buttons — allow once, always, reject — answered inline, never in a modal. Sub-agents (Claude Code Task calls, ACP agent tool kinds, or any delegation-shaped call) get their own card showing the delegated prompt, and the tools they run nest underneath with a running count. A compact activity line keeps the current turn, tool totals, sub-agents, plan progress, permissions, and queued follow-ups visible even when their detailed cards are collapsed; beneath it a tool timeline draws one dot per call this turn (pulsing while running, green or red when finished; click one to jump to its card) and a now line names the call in flight. When the turn ends, a summary pill states whether it completed, how many tools ran and failed, how many sub-agents were used, how many files were touched, and how long it took. Context-window usage is drawn as a bar that turns amber past 70% and red past 90%. File reads and writes requested over ACP are workspace-scoped; paths outside the root are refused. Stop cancels the in-flight turn (session/cancel), while messages typed during work are visibly queued for the next turn.

Text the harness injected into the user role during a replayed session (the local-command caveat, <command-name> blocks, and compaction summaries) never becomes a user bubble: commands appear as a one-line note, and a compaction summary collapses into a labelled note whose text can still be opened. Replies render as safe markdown — headings, emphasis, nested and task lists, tables, quotes, inline code, and fenced code blocks with a copy button and the language on the rail. Any file path the agent mentions (src/graph.c, editors/vscode/acp.js:42) opens at that line, tool locations do the same, and web links open through VS Code rather than navigating the webview. The context bars, transcript, cards, permissions, and composer reflow for a narrow sidebar and use a centered reading width in a wide editor panel. The composer grows with your message, and ↑ recalls what you sent before.

Codify commands in the chat

A Codify toolbar sits above the transcript: brief, next, status, review, check, guard, changes, and remember are one click each, and once a task is attached, implemented, done, and handoff appear beside them. done runs the real cg spec done qualification; its output card is marked green or red and a refusal is left open and handed to the agent to fix. Type / for the command palette. Each one runs the real cg verb in the workspace, shows the output as a collapsible card, and hands the same output to the agent as context with a short instruction — so the agent works from the graph rather than from a guess.

/brief, /next, /review, /check and /task are also one-click chips on the empty chat.

Working tasks in the view

The board drives the same chat. Start Agent Session on Task (task node or palette) runs the whole pickup into the Agent view:

1. In parallel mode the task is claimed first (cg spec claim <id> --agent vscode-acp-<n>), then started. A claim someone else holds is refused, not stolen.
2. A resume packet is generated with cg resume --task <id> --prompt (degrading to the session brief on an older cg) and sent as the opening prompt.
3. The view's header shows the task id, title, and live board status while the agent works it.

If the view already has a chat going, you choose: replace it (with the usual handoff/release offer for an attached task) or open beside — an editor panel running a second concurrent session. When any session ends with its task not yet qualified, the extension offers to record a handoff or release the claim — the same discipline as the terminal path.

If the adapter is missing or fails to start (auth methods, when the agent reports them, are named in the error), any claim is released and the extension offers the terminal session as the fallback. Set codify.agent.interface: "terminal" to route task starts to a seeded terminal (codify: <driver> <id>) instead of the view.

The rest of the lifecycle:

When a session's terminal closes — or a headless run exits — with the task not yet done or implemented, the extension offers to release the claim so the task returns to the frontier. While any tracked session exists, the board refreshes on a 3-second poll in addition to watching .codegraph/graph.db, so work done by agents outside the editor shows up without a manual refresh. Tasks with a live claim show $(person) plus the agent name; $(terminal) marks tasks with a tracked terminal session and $(comment-discussion) marks tasks with a live agent panel in this window.

The rest of the workflow

Click the status bar item, or run Codify: Actions…, for one menu covering the whole loop:

Reports open as rendered markdown previews rather than console dumps.

A second status bar item appears only when edits have drifted outside the current task's scope, listing the files. It is advisory; clicking it shows the detail.

kvx editing

Beyond syntax highlighting:

• Go to definition on a requires entry jumps to that task; on a reqs entry, to the requirement it satisfies; on a concrete touches path, to the file.
• Completion offers the keys a task section actually understands — with what each one does — and real task ids when completing requires.
• Hover on any key explains what the spec engine does with it.
• Outline lists every requirement, design section and task, with titles.

Requirements

• cg on PATH, or set codify.binaryPath.
• npx for the default Codex ACP launcher, or set codify.acp.codexCommand to an installed ACP adapter.
• For the task board: a workspace containing spec/workflow.kvx.
• For code navigation: a workspace with .codegraph/ — run cg init.

Neither is required for the other. kvx highlighting works everywhere.

Settings

Install

No build step and no dependencies — the extension is plain JavaScript, including its Language Server client. vsce package needs no npm install.

cd editors/vscode
npx @vscode/vsce package        # produces codify-1.2.0.vsix
code --install-extension codify-1.2.0.vsix --force

The Marketplace identity is SidioraLabs.codify. In a Remote SSH, WSL, or container window, install the VSIX on the remote extension host, not only the local UI side. The Agent header shows the running version (for example v1.2.0), so a stale host is immediately visible after reload.

For development, open editors/vscode/ in VS Code and press F5.

Note on other kvx extensions

If another extension also claims the .kvx extension (for example a grammar for a different kvx dialect), VS Code lets the last-installed one win. This grammar targets the Ion spec dialect that Codify parses: [section] headers, key = "value", lists, and quote-toggled comments.