feat(agent): add GitHub Copilot as an in-app agent backend

[SSKUltra]

What this adds

A third agent backend — GitHub Copilot — alongside api and codex, driven in-app through the official @github/copilot-sdk.

Today Copilot users can only reach OpenChatCut from the outside, over the external MCP endpoint. That path is deliberately narrow: only draft-safe read/edit tools are exposed, tool calls round-trip through the broker into the browser, and the conversation lives in the user's terminal rather than in the editor's chat. This gives Copilot the same first-class, in-app treatment Codex already has.

Why the SDK rather than MCP or --acp

@github/copilot-sdk is a close analogue of the codex app-server integration, so server/copilot/ mirrors server/codex/ deliberately:

	Codex	Copilot
Transport	codex app-server --listen stdio://	SDK over JSON-RPC (spawns the CLI)
Host tools	pushed per turn	defineTool() with in-process handlers
Isolated home	CODEX_HOME	baseDirectory → COPILOT_HOME
Approval	host responds to tool RPCs	onPermissionRequest
Streaming	text/thinking/tool deltas	same, mapped onto the existing event union

copilot --acp was considered and rejected: ACP has no per-turn tool injection, so it would have required running a separate MCP server for the editor's own tools — reintroducing exactly the indirection this removes.

Design decisions worth reviewing

Tools are the entire surface. availableTools is restricted to custom tools, so the agent has no shell, filesystem, web or MCP access, and any permission request is rejected as a filter escape rather than prompted. Verified by asking it to run ls, read ~/.zshrc and fetch a URL: zero tool calls, and it enumerated only the OpenChatCut tools it had.

Capabilities come from the runtime, not the bundled catalog. Copilot reports exact per-model limits, so resolveCopilotModelCapabilities() uses those and records them as exact rather than estimated. Models are attributed to their upstream provider (claude-* → anthropic, grok-* → xai) so capability overrides and vision-model selection keep working. Models without tool support are hidden, since every editing flow needs tool calls.

Tool failures return a typed ToolResultObject. Throwing collapses to a generic "Tool execution failed" and strips the diagnostic. With the typed failure the model receives the real reason verbatim — confirmed by returning Unknown clip: clip-zzz and seeing it echoed back.

__images are handed over as binary attachments, matching the Codex backend's inputImage handling, so view_asset_frames contact sheets stay viewable instead of being stringified into the prompt. Verified with a synthetic sheet (red left half, blue right half) that the model described correctly.

The turn uses an idle timeout, not a wall-clock cap. A long multi-shot edit streams continuously for many minutes and must not be killed for elapsed time. It is suspended while a host tool is in flight, bounded by the broker's own maximum so a never-settled call cannot hang the turn.

Auth stays with the CLI. Users run copilot login; OpenChatCut never sees the credential. The settings pane is read-only status plus model/effort selection, and session state is isolated under ~/.openchatcut/copilot so in-app runs never disturb the user's own ~/.copilot.

Second commit: durable agent edits

While building this I hit a failure worth fixing independently — it is backend-agnostic and affects api and codex equally.

A run applied a long sequence of edits, verified them by rendering frames, and wrote a confident summary while none of the work was durable. The server could not tell: the editor answered "success" and the tool result carried no durability information, unlike the external MCP path which does track baseRevision.

The editor now reports { revision, pending, failed } with each tool result, derived from state SaveCoordinator already keeps, and executeBrowserTool fails mutating tools when the editor's writes are settled-failed. The distinctions matter as much as the check:

• reads never fail on a save error — the agent still has to read state to report the problem
• a pending save is not a failure — autosave debounces 500ms and normally settles after the tool returns, so treating pending as loss would fail nearly every edit
• a missing signal is unknown, not failed — an older editor keeps working

Project writes are also flushed at terminal settle, including failed and cancelled runs, which is exactly when the last edits used to be stranded inside the debounce window.

Happy to split this into its own PR if you'd prefer — it shares store-types.ts and routes.ts with the first commit, so it would need to land second.

Testing

server/copilot/copilot-agent.verify.ts and server/agent-runs/editor-persistence.verify.ts, both registered in verify:server-runs and git-tracked (the verify-gate-coverage and verify-registration invariants both catch omissions here — they caught mine).

Coverage: turn parsing (saved model/effort fallback, explicit-null suppression, tool-name validation, duplicate rejection), provider attribution incl. unknown-vendor fallback, capabilities from runtime vs. estimate vs. user override, the version gate, and the full mutating/read × durable/pending/failed/missing decision table.

Local gates on this branch, rebased onto current main:

npm run lint            ✅
npm test                ✅  171 segments
npm run verify:agent-skill  ✅
tsc -b + vite build     ✅

Acceptance evidence

Live against a real Copilot subscription:

GET /api/copilot/status  → installed, supported, authenticated
GET /api/copilot/models  → 19 models, e.g. claude-sonnet-5
                           ctx=1000000 in=936000 out=64000
                           efforts=[low, medium, high, xhigh, max]
POST /api/copilot/turn   → tool-start read_timeline {}
                           tool-start set_item_timing {"itemId":"clip-b","durationInFrames":540}
                           events: thinking-delta, context-usage, tool-start/end, text-delta, done

Driven against the real generated tool catalog, the model produced schema-valid arguments unaided (computing 600 − 60 = 540 frames at 30fps).

Notes for the maintainer

• New dependency: @github/copilot-sdk. The CLI itself is discovered rather than bundled (OPENCHATCUT_COPILOT_PATH overrides), so it is not a hard install requirement.
• Two new non-secret keystore names: COPILOT_MODEL, COPILOT_REASONING_EFFORT, registered in MODEL_ROUTING_NAMES in keystore.verify.ts.
• English and Italian dictionary entries added; verify:i18n passes. Russian was not required by the coverage checks.

[SSKUltra]

Added the real Copilot mark, replacing the placeholders.

Settings previously fell back to a GH monogram, and the composer model picker and toolbar used the GitHub octocat — which identifies GitHub, not Copilot.

The mark is vendored from @primer/octicons (MIT, published by GitHub) and normalised to this repo's icon shape: 24x24 viewBox, 1em sizing, fill="currentColor" so it follows the active skin the same way the OpenAI ring does. The header comment in vendorIcons.tsx now records octicons alongside the existing lobehub / simple-icons provenance, and the monogram fallback is removed.

The composer imports the asset directly rather than reusing VendorIcon: that component is settings-only today, so importing it would pull every vendored SVG into the chat bundle for a single icon. This matches how the codex entry already imports its own PNG.

Gates re-run on the updated branch: lint ✅ · npm test (171 segments) ✅ · verify:agent-skill ✅ · tsc -b + vite build ✅. Confirmed the mark ships in the built bundle (dist/assets/copilot-*.js).