copilot-reverse 0.0.1

package/GUIDE.md

@@ -0,0 +1,142 @@
+# copilot-reverse — User Guide
+
+**Use the Copilot subscription you already pay for as a local Claude Code / Codex backend.**
+No new API keys. No per-token bills. One terminal app.
+
+```
+  ┌─────────────┐        ┌──────────────────┐        ┌─────────────┐
+  │ Claude Code │ ─────▶ │  copilot-reverse  │ ─────▶ │   Copilot   │
+  │   / Codex   │  local │  (your machine)   │  proxy │  (your sub) │
+  └─────────────┘        └──────────────────┘        └─────────────┘
+```
+
+---
+
+## 60-second start
+
+```bash
+npx copilot-reverse
+```
+
+1. It asks you to log in to GitHub (device code — paste a code in your browser). One time only.
+2. The terminal app launches. You'll see a prompt and a status bar.
+3. In the app, type:
+   ```
+   /setup-claude
+   ```
+   Pick a model (e.g. **claude-opus-4.8 (1M)**), choose **global**, done.
+4. Open a **new** terminal and run `claude`. It's now talking to Copilot through copilot-reverse. 🎉
+
+That's it. Codex users: run `/setup-codex` instead.
+
+Here's the app itself — a prompt, a live status bar, and slash-command autocomplete:
+
+```text
+ ✳ copilot-reverse                                                       worker: ready
+
+ Type a message to chat with the assistant, or /help for commands.
+╭─────────────────────────────────────────────────────────────────────────────────────╮
+│ › /setup                                                                              │
+╰─────────────────────────────────────────────────────────────────────────────────────╯
+  ❯ /setup-claude   print Claude Code config
+    /setup-codex    print Codex/OpenAI config
+    /setup-status   show configured endpoints
+    ↑↓ navigate · tab complete · enter run
+ model claude-opus-4.8  ·  daemon ready  ·  claude u:✓ p:○  codex u:✓ p:○  ·  /help
+```
+
+---
+
+## What can I do in the app?
+
+Just **talk to it** — it understands plain English and will do the work for you:
+
+> *"list models"* → shows every model + its context window
+> *"set up claude"* → configures Claude Code
+> *"is the worker healthy?"* → runs a health check
+> *"why did my last request fail?"* → shows the error
+
+Prefer commands? Type `/` to see them all. The essentials:
+
+| Command | What it does |
+|---|---|
+| `/setup-claude` · `/setup-codex` | Point Claude Code / Codex at copilot-reverse |
+| `/model` | Switch the chat model (1M-context models marked) |
+| `/status` · `/doctor` | Is everything healthy? |
+| `/logs` · `/metrics` | What ran, what failed, and why |
+| `/dashboard` | Open a live web dashboard in your browser |
+| `/report` | File a pre-filled bug report (diagnostics only — no prompts) |
+| `/reset-claude` · `/reset-codex` | Undo setup, restore original config |
+| `/help` · `/quit` | List commands · exit |
+
+### The live dashboard
+
+`/dashboard` opens a self-refreshing web view of everything happening through the proxy — worker
+health, request volume, and (most useful) recent **errors with their real messages**:
+
+![copilot-reverse dashboard](images/dashboard.png)
+
+---
+
+## Connect your own tools
+
+Already have something that speaks OpenAI or Anthropic? Point it here:
+
+- **OpenAI-compatible:** `http://127.0.0.1:7891/v1`
+- **Anthropic-compatible:** `http://127.0.0.1:7891`
+
+Any API key value works locally (it's your machine). Example:
+
+```bash
+export ANTHROPIC_BASE_URL=http://127.0.0.1:7891
+export ANTHROPIC_API_KEY=local
+claude
+```
+
+---
+
+## The status bar, decoded
+
+The bottom line of the app (see the screenshot above) tells you everything at a glance:
+
+```text
+model claude-opus-4.8  ·  daemon ready  ·  claude u:✓ p:○  codex u:○ p:○  ·  /help
+```
+
+- **worker / daemon** — green `ready` means the proxy is up and self-healing.
+- **claude u:✓ p:○** — Claude Code is configured at the **u**ser (global) level, not in this **p**roject. Read live from your real config files.
+
+---
+
+## Troubleshooting
+
+**"context 100%" or `/compact` fails in Claude Code**
+Re-run `/setup-claude` and pick a **1M** model (e.g. `claude-opus-4.8 (1M)`). copilot-reverse writes
+the right context-window hint so the client stops assuming a small window. Then restart Claude Code.
+
+**"GitHub login expired"**
+Your Copilot session lapsed. Restart copilot-reverse — it'll prompt you to log in again.
+
+**A request failed and I don't know why**
+Type `/logs` (or ask *"why did that fail?"*). Every failure is captured with its real upstream
+message. Still stuck? `/report` opens a pre-filled GitHub issue with diagnostics — **never** your
+prompt content.
+
+**Want to undo everything**
+`/reset-claude` and `/reset-codex` remove exactly the keys copilot-reverse added and leave the rest
+of your config untouched.
+
+---
+
+## Good to know
+
+- **Your data stays local.** The app proxies between your editor and Copilot on `127.0.0.1`. Your
+  GitHub token lives only in `~/.copilot-reverse/creds.json` on your own disk.
+- **It heals itself.** If the proxy crashes, the supervisor restarts it with backoff and records why.
+- **Unofficial endpoints.** This uses community-documented Copilot endpoints with *your own*
+  subscription. It may break if GitHub changes them — that's the trade-off for not needing extra keys.
+
+---
+
+Questions or bugs? Use `/report` from inside the app, or open an issue on
+[GitHub](https://github.com/wangcansunking/copilot-reverse). Happy hacking. 🚀

package/README.md

@@ -0,0 +1,60 @@
+# copilot-reverse
+
+Interactive terminal app that turns your GitHub Copilot subscription into local
+OpenAI- and Anthropic-compatible endpoints, with a self-healing daemon and a
+built-in assistant.
+
+> **New here? Read the [User Guide](GUIDE.md) — a 60-second start, no jargon.**
+
+> **Disclaimer:** The GitHub Copilot integration uses community-documented,
+> unofficial endpoints, for use with your own Copilot subscription only. It may
+> break if GitHub changes these endpoints.
+
+![copilot-reverse dashboard](images/dashboard.png)
+
+## Quick start
+
+```bash
+npx copilot-reverse      # device-code login, then the TUI launches
+```
+
+In the TUI: `/help`, `/doctor`, `/setup-claude`, `/setup-codex`, `/metrics`, or
+just talk to the assistant in natural language.
+
+Point clients at:
+- OpenAI: `http://127.0.0.1:7891/v1`
+- Anthropic: `http://127.0.0.1:7891`
+
+## Architecture (M1)
+
+- **TUI** (Ink) — the `copilot-reverse` process: REPL + slash commands + claude-agent-sdk
+  assistant (which dogfoods copilot-reverse's own Anthropic endpoint).
+- **Supervisor** (:7890) — control API + SQLite + self-healing worker supervision.
+- **Worker** (:7891) — OpenAI `/v1/chat/completions` + Anthropic `/v1/messages`
+  → Copilot, with tool-use translation both ways.
+
+## Development
+
+Requires Node >=20.
+
+```bash
+npm install && npm test && npm run build
+```
+
+### End-to-end tests
+
+The [`e2e/`](e2e/) folder holds cross-module end-to-end scenarios (real worker + supervisor +
+TUI wiring, fake Copilot provider). The case catalog is [`e2e/cases.md`](e2e/cases.md) and the
+latest run is [`e2e/RESULTS.md`](e2e/RESULTS.md).
+
+**Every code change must keep the full e2e suite green.** `npm test` runs it (the suite is
+included in the default vitest run); `npm run test:e2e` runs only the e2e cases. After a change,
+re-run and update `e2e/RESULTS.md`.
+
+### Test notes
+
+- **TUI input tests** (`tests/tui/app.test.tsx`): the test waits ~30 ms after
+  `render()` before writing to `stdin`. This is not flakiness padding — Ink's
+  `useInput` subscribes to stdin asynchronously after mount, so writes issued in
+  the same tick as `render()` are dropped. The delay lets the subscription
+  attach; assertions are otherwise unchanged.

package/dist/cli/auth.js

@@ -0,0 +1,9 @@
+import { requestDeviceCode, pollForToken } from "../providers/copilot/auth.js";
+import { writeGhToken } from "../shared/creds.js";
+export async function runDeviceLogin(dir, fetchFn = fetch, log = console.log) {
+    const code = await requestDeviceCode(fetchFn);
+    log(`\nOpen ${code.verification_uri} and enter code: ${code.user_code}\n`);
+    const token = await pollForToken(code.device_code, code.interval * 1000, fetchFn);
+    writeGhToken(token, dir);
+    log("GitHub authorization complete.");
+}

package/dist/cli/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import React from "react";
+import { render } from "ink";
+import { Command } from "commander";
+import { App } from "../tui/app.js";
+import { buildRegistry } from "../tui/slash/commands.js";
+import { DaemonClient } from "../tui/daemon-client.js";
+import { runDeviceLogin } from "./auth.js";
+import { probeSupervisor } from "../daemon/lifecycle.js";
+import { startSupervisor } from "../supervisor/index.js";
+import { runAssistantTurn } from "../tui/assistant/runtime.js";
+import { makeOnChat } from "../tui/assistant/on-chat.js";
+import { readGhToken } from "../shared/creds.js";
+import { readClientSetup, writeClientSetup } from "../shared/client-setup.js";
+import { readChatModel, writeChatModel } from "../shared/prefs.js";
+import { CopilotTokenStore, isCopilotTokenValid } from "../providers/copilot/token.js";
+import { fetchCopilotModels, fetchModelLimits } from "../providers/copilot/models.js";
+import { applyClaude, applyCodex, resetClaude, resetCodex, CLAUDE_ENV_KEYS, CODEX_ENV_KEYS } from "../tui/setup/apply.js";
+import { readClientStatus } from "../tui/setup/status.js";
+import { applyCodexToml } from "../tui/setup/codex-toml.js";
+import { claudeCopilotReverseEnv } from "../tui/setup/clients.js";
+import { dataDir } from "../shared/paths.js";
+import { defaultConfig } from "../shared/config.js";
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+const DEFAULT_MODEL = "gpt-4o"; // a valid Copilot model id; pass-through routing uses it as-is
+// Conservative context budget that drives the assistant's auto-compaction. Sized below the
+// common Copilot prompt window (gpt-4o ≈ 128K) so the engine compacts before the upstream
+// rejects an over-long turn. TODO: read each model's real max_prompt_tokens from /models.
+const DEFAULT_MAX_INPUT_TOKENS = 110_000;
+async function launchTui() {
+    const cfg = defaultConfig();
+    const existingToken = readGhToken(dataDir());
+    if (!existingToken) {
+        console.log("No GitHub login found — starting device-code login.");
+        await runDeviceLogin(dataDir());
+    }
+    else if (!(await isCopilotTokenValid(existingToken))) {
+        console.log("GitHub login expired — re-authenticating.");
+        await runDeviceLogin(dataDir());
+    }
+    // Run the daemon IN-PROCESS — no separate console window pops up. Reuse one if already running.
+    let stopSupervisor;
+    if (!(await probeSupervisor())) {
+        process.stdout.write("starting copilot-reverse…\n");
+        stopSupervisor = startSupervisor().stop;
+        for (let i = 0; i < 60 && !(await probeSupervisor()); i++)
+            await delay(100);
+    }
+    const base = `http://${cfg.bindHost}:${cfg.supervisorPort}`;
+    const client = new DaemonClient(base);
+    const workerBase = `http://${cfg.bindHost}:${cfg.workerPort}`;
+    const endpoint = { host: cfg.bindHost, port: cfg.workerPort, apiKey: "copilot-reverse-local" };
+    let app;
+    const quit = () => { stopSupervisor?.(); app?.unmount(); process.exit(0); };
+    // Restore a client's config: strip copilot-reverse's keys from BOTH scopes and clear the HUD flag.
+    const resetClient = async (clientKind) => {
+        const fn = clientKind === "claude" ? resetClaude : resetCodex;
+        const keys = clientKind === "claude" ? CLAUDE_ENV_KEYS : CODEX_ENV_KEYS;
+        const results = ["global", "project"].map((scope) => fn(scope, keys));
+        writeClientSetup(dataDir(), { ...readClientSetup(dataDir()), [clientKind]: false });
+        const lines = results
+            .filter((r) => r.changed.length)
+            .map((r) => `removed ${r.changed.join(", ")} from ${r.path}`);
+        return lines.length ? lines : [`no copilot-reverse ${clientKind} config found to remove`];
+    };
+    const registry = buildRegistry({ client, quit }, endpoint, {
+        dashboardUrl: `http://${cfg.bindHost}:${cfg.supervisorPort}/`,
+        reportRepo: cfg.reportRepo,
+        appVersion: "0.0.1",
+        platform: `${process.platform} node-${process.version}`,
+        resetClient,
+    });
+    // Filled in below once we have a token; the assistant prefers a model's real window over the default.
+    const modelLimits = {};
+    const tokenStore = new CopilotTokenStore(readGhToken(dataDir()));
+    const loadModels = async () => {
+        const token = await tokenStore.get();
+        const [ids, limits] = await Promise.all([fetchCopilotModels(token), fetchModelLimits(token)]);
+        Object.assign(modelLimits, limits); // so the picker shows windows and auto-compaction is sized
+        return ids;
+    };
+    // Pull each model's real context window in the background too, in case the picker never opens.
+    void tokenStore.get().then((t) => fetchModelLimits(t)).then((m) => Object.assign(modelLimits, m)).catch(() => { });
+    // Apply a client's config (shared by the /setup wizard and the assistant's setup_* tools).
+    // For Claude Code we also write the selected model's real context window so the client doesn't
+    // assume the default 200K (which makes a 1M model read "context 100%" far too early). For Codex
+    // we write BOTH a .env (legacy) and ~/.codex/config.toml (the native Codex config, with the
+    // model's context window) so either Codex setup style works.
+    const applyClient = (clientKind, scope, model) => {
+        if (clientKind === "claude") {
+            const r = applyClaude(scope, claudeCopilotReverseEnv(workerBase, "copilot-reverse-local", model, modelLimits[model]));
+            writeClientSetup(dataDir(), { ...readClientSetup(dataDir()), claude: true });
+            return r;
+        }
+        const r = applyCodex(scope, { OPENAI_BASE_URL: `${workerBase}/v1`, OPENAI_API_KEY: "copilot-reverse-local", OPENAI_MODEL: model });
+        applyCodexToml({ baseUrl: `${workerBase}/v1`, model, contextWindow: modelLimits[model] });
+        writeClientSetup(dataDir(), { ...readClientSetup(dataDir()), codex: true });
+        return r;
+    };
+    const setup = { apply: async (clientKind, scope, model) => applyClient(clientKind, scope, model) };
+    const onChat = makeOnChat({
+        client, workerBaseUrl: workerBase, apiKey: "copilot-reverse-local", model: DEFAULT_MODEL,
+        maxInputTokens: DEFAULT_MAX_INPUT_TOKENS, modelLimits,
+        listModels: loadModels,
+        setupClient: async (c, s, m) => applyClient(c, s, m),
+    }, (c, p, print, abort) => runAssistantTurn(c, p, print, undefined, abort));
+    const persistedModel = readChatModel(dataDir());
+    app = render(React.createElement(App, {
+        registry,
+        title: "copilot-reverse",
+        initialModel: persistedModel ?? DEFAULT_MODEL,
+        statusSource: () => client.status(),
+        readStatus: () => readClientStatus(),
+        modelLimits,
+        onChat,
+        loadModels,
+        setup,
+        info: {
+            openai: `${workerBase}/v1`,
+            anthropic: workerBase,
+            supervisorPort: cfg.supervisorPort,
+            workerPort: cfg.workerPort,
+            dataDir: dataDir(),
+        },
+        onModelChange: (m) => writeChatModel(dataDir(), m),
+        pickModelOnStart: !persistedModel,
+    }));
+}
+const program = new Command();
+program.name("copilot-reverse").description("copilot-reverse: interactive Copilot proxy").version("0.0.1");
+program.command("login").description("GitHub device-code login").action(() => runDeviceLogin(dataDir()));
+program.action(() => { void launchTui(); });
+program.parseAsync(process.argv);

package/dist/core/anthropic-inbound.js

@@ -0,0 +1,63 @@
+// The Anthropic `system` field may be a plain string or an array of text blocks (the Claude Code
+// SDK sends blocks with cache_control). Flatten either shape to a string — otherwise it stringifies
+// to "[object Object]" and the model gets garbage instructions.
+function systemText(system) {
+    if (!system)
+        return "";
+    if (typeof system === "string")
+        return system;
+    return system.filter((b) => b.type === "text" && b.text != null).map((b) => b.text).join("");
+}
+function blocksToCanonical(content) {
+    if (typeof content === "string")
+        return content ? [{ type: "text", text: content }] : [];
+    const out = [];
+    for (const b of content) {
+        if (b.type === "text" && b.text != null)
+            out.push({ type: "text", text: b.text });
+        else if (b.type === "image" && b.source) {
+            // Anthropic image: base64 (media_type + data) or a url source. Normalize to a data URL.
+            const dataUrl = b.source.type === "url" && b.source.url
+                ? b.source.url
+                : `data:${b.source.media_type ?? "image/png"};base64,${b.source.data ?? ""}`;
+            out.push({ type: "image", dataUrl });
+        }
+        else if (b.type === "tool_use")
+            out.push({ type: "tool_use", id: b.id, name: b.name, input: b.input });
+        else if (b.type === "tool_result")
+            out.push({ type: "tool_result", toolUseId: b.tool_use_id, content: typeof b.content === "string" ? b.content : JSON.stringify(b.content) });
+    }
+    return out;
+}
+export function anthropicRequestToCanonical(req) {
+    const messages = [];
+    const sys = systemText(req.system);
+    if (sys)
+        messages.push({ role: "system", content: [{ type: "text", text: sys }] });
+    for (const m of req.messages) {
+        const content = blocksToCanonical(m.content);
+        const isToolResult = content.some((b) => b.type === "tool_result");
+        messages.push({ role: isToolResult ? "tool" : m.role, content });
+    }
+    return {
+        model: req.model, stream: Boolean(req.stream), temperature: req.temperature, maxTokens: req.max_tokens,
+        // Keep only custom tools with a real JSON-Schema. Anthropic server-side tools (web_search,
+        // bash, computer, …) arrive with a `type` and no `input_schema`; forwarding them produces an
+        // invalid tool the model can't fulfil, and the client hangs forever waiting for a tool_result.
+        tools: req.tools
+            ?.filter((t) => t.input_schema != null && typeof t.input_schema === "object")
+            .map((t) => ({ name: t.name, description: t.description, parameters: t.input_schema })),
+        messages,
+    };
+}
+export function canonicalToAnthropicResponse(r) {
+    const content = r.content.map((b) => b.type === "text" ? { type: "text", text: b.text } :
+        b.type === "tool_use" ? { type: "tool_use", id: b.id, name: b.name, input: b.input } :
+            { type: "text", text: "" });
+    const stop = r.finishReason === "tool_use" ? "tool_use" : r.finishReason === "length" ? "max_tokens" : "end_turn";
+    return {
+        id: r.id, type: "message", role: "assistant", model: r.model,
+        content, stop_reason: stop, stop_sequence: null,
+        usage: { input_tokens: r.usage.promptTokens, output_tokens: r.usage.completionTokens },
+    };
+}

package/dist/core/canonical.js

@@ -0,0 +1,6 @@
+export function textContent(s) {
+    return [{ type: "text", text: s }];
+}
+export function joinText(blocks) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+}

package/dist/core/fuzzy.js

@@ -0,0 +1,35 @@
+// Fuzzy model matching (agent-maestro v2.6.0): clients send ids like `claude-opus-4-8` or
+// `claude-opus-4-8-20251101`, but Copilot advertises `claude-opus-4.8`. Map the request to the
+// closest available model by Jaccard similarity over normalized tokens, so a near-miss id doesn't
+// pass straight through and 404. Date stamps (6+ digit runs) are dropped before comparing.
+function tokenize(id) {
+    return new Set(id.toLowerCase()
+        .replace(/\b\d{6,}\b/g, " ") // strip date/version stamps like 20251101
+        .replace(/[-_.]+/g, " ")
+        .split(/\s+/)
+        .filter(Boolean));
+}
+function jaccard(a, b) {
+    if (!a.size && !b.size)
+        return 0;
+    let inter = 0;
+    for (const x of a)
+        if (b.has(x))
+            inter++;
+    return inter / (a.size + b.size - inter);
+}
+export function bestModelMatch(requested, available, threshold = 0.6) {
+    if (available.includes(requested))
+        return requested;
+    const rt = tokenize(requested);
+    let best = null;
+    let bestScore = 0;
+    for (const m of available) {
+        const s = jaccard(rt, tokenize(m));
+        if (s > bestScore) {
+            bestScore = s;
+            best = m;
+        }
+    }
+    return bestScore >= threshold ? best : null;
+}

package/dist/core/openai-inbound.js

@@ -0,0 +1,83 @@
+import { joinText } from "./canonical.js";
+// OpenAI content may be a plain string or an array of text parts (clients that split long
+// system/user prompts do this). Collapse text parts to a single string.
+function textOf(content) {
+    if (Array.isArray(content))
+        return content.map((p) => (typeof p === "string" ? p : p?.text ?? "")).join("");
+    return content ?? "";
+}
+// Extract any image_url parts as canonical image blocks (vision support).
+function imagesOf(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .filter((p) => typeof p !== "string" && p?.type === "image_url" && !!p.image_url?.url)
+        .map((p) => ({ type: "image", dataUrl: p.image_url.url }));
+}
+function msgToCanonical(m) {
+    const role = (["system", "user", "assistant", "tool"].includes(m.role) ? m.role : "user");
+    const content = [];
+    if (m.role === "tool" && m.tool_call_id) {
+        content.push({ type: "tool_result", toolUseId: m.tool_call_id, content: textOf(m.content) });
+    }
+    else {
+        const text = textOf(m.content);
+        if (text)
+            content.push({ type: "text", text });
+        content.push(...imagesOf(m.content));
+        for (const tc of m.tool_calls ?? []) {
+            content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) });
+        }
+    }
+    return { role, content };
+}
+function safeJson(s) { try {
+    return JSON.parse(s);
+}
+catch {
+    return {};
+} }
+export function openaiRequestToCanonical(req) {
+    return {
+        model: req.model,
+        stream: Boolean(req.stream),
+        temperature: req.temperature,
+        maxTokens: req.max_tokens,
+        tools: req.tools?.map((t) => ({ name: t.function.name, description: t.function.description, parameters: t.function.parameters })),
+        messages: req.messages.map(msgToCanonical),
+    };
+}
+export function canonicalToOpenAIResponse(r) {
+    const toolCalls = r.content
+        .filter((b) => b.type === "tool_use")
+        .map((b, i) => ({ index: i, id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input) } }));
+    return {
+        id: r.id, object: "chat.completion", created: 0, model: r.model,
+        choices: [{
+                index: 0,
+                message: { role: "assistant", content: joinText(r.content) || null, ...(toolCalls.length ? { tool_calls: toolCalls } : {}) },
+                finish_reason: r.finishReason === "tool_use" ? "tool_calls" : r.finishReason,
+            }],
+        usage: { prompt_tokens: r.usage.promptTokens, completion_tokens: r.usage.completionTokens, total_tokens: r.usage.promptTokens + r.usage.completionTokens },
+    };
+}
+export function canonicalChunkToOpenAISSE(chunk, id, model) {
+    if (chunk.done) {
+        // Emit a final usage chunk (OpenAI stream_options.include_usage shape) before [DONE].
+        if (chunk.usage) {
+            const u = { prompt_tokens: chunk.usage.promptTokens, completion_tokens: chunk.usage.completionTokens, total_tokens: chunk.usage.promptTokens + chunk.usage.completionTokens };
+            const usageChunk = { id, object: "chat.completion.chunk", created: 0, model, choices: [], usage: u };
+            return `data: ${JSON.stringify(usageChunk)}\n\ndata: [DONE]\n\n`;
+        }
+        return "data: [DONE]\n\n";
+    }
+    let delta = {};
+    if (chunk.kind === "text")
+        delta = { content: chunk.delta };
+    else if (chunk.kind === "tool_use_start")
+        delta = { tool_calls: [{ index: chunk.index, id: chunk.id, type: "function", function: { name: chunk.name, arguments: "" } }] };
+    else if (chunk.kind === "tool_use_delta")
+        delta = { tool_calls: [{ index: chunk.index, function: { arguments: chunk.argsDelta } }] };
+    const payload = { id, object: "chat.completion.chunk", created: 0, model, choices: [{ index: 0, delta, finish_reason: null }] };
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}

package/dist/core/tokens.js

@@ -0,0 +1,22 @@
+// A rough char/4 token estimate over a canonical request — message text plus tool schemas.
+// It is not a model-exact tokenizer, but it is positive and monotonic in input size, which is
+// enough to back /v1/messages/count_tokens so clients (Claude Code) can time auto-compaction.
+// Mirrors agent-maestro's pragmatic "estimate then calibrate" approach to token counting.
+export function estimateTokens(req) {
+    let chars = 0;
+    for (const m of req.messages) {
+        chars += m.role.length;
+        for (const b of m.content) {
+            if (b.type === "text")
+                chars += b.text.length;
+            else if (b.type === "tool_use")
+                chars += b.name.length + JSON.stringify(b.input ?? {}).length;
+            else if (b.type === "tool_result")
+                chars += b.content.length;
+        }
+    }
+    for (const t of req.tools ?? []) {
+        chars += t.name.length + (t.description?.length ?? 0) + JSON.stringify(t.parameters ?? {}).length;
+    }
+    return Math.max(1, Math.ceil(chars / 4));
+}

package/dist/daemon/lifecycle.js

@@ -0,0 +1,32 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
+import { defaultConfig } from "../shared/config.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function ensureDaemon(opts) {
+    if (await opts.probe())
+        return "already-running";
+    opts.spawn();
+    for (let i = 0; i < opts.retries; i++) {
+        await sleep(opts.delayMs);
+        if (await opts.probe())
+            return "started";
+    }
+    throw new Error("daemon did not become healthy in time");
+}
+// Real implementations wired by the CLI/TUI.
+export function spawnSupervisor() {
+    const entry = join(dirname(fileURLToPath(import.meta.url)), "..", "supervisor", "index.js");
+    const child = nodeSpawn(process.execPath, [entry], { detached: true, stdio: "ignore" });
+    child.unref();
+}
+export async function probeSupervisor(fetchFn = fetch) {
+    const cfg = defaultConfig();
+    try {
+        const res = await fetchFn(`http://${cfg.bindHost}:${cfg.supervisorPort}/api/status`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}