muonroi-cli 1.7.2 → 1.8.1

package/dist/packages/agent-harness-core/src/event-filter.js

@@ -22,6 +22,7 @@ export const LIFECYCLE_PRESET = new Set([
     "llm-done",
     "council-step",
     "council-speaker",
+    "council-turn-length",
     "askcard-open",
     "askcard-answered",
     "askcard-cancel",

package/dist/packages/agent-harness-core/src/event-redact.js

@@ -54,6 +54,14 @@ const ALLOWED_FIELDS = {
         round: "pass",
         correlationId: "pass",
     },
+    "council-turn-length": {
+        role: "pass",
+        round: "pass",
+        charCount: "pass",
+        wordCount: "pass",
+        model: "pass",
+        correlationId: "pass",
+    },
     "askcard-open": {
         questionId: "pass",
         question: 300, // cap to 300 chars, then scrub

package/dist/packages/agent-harness-core/src/mcp-server.d.ts

@@ -46,6 +46,22 @@ export declare function validateStartArgs(args: string[]): {
     bad: string;
 };
 export declare function sanitizeEnv(env: Record<string, string>): Record<string, string>;
+/**
+ * Opt-in extra cwd roots for tui.start, layered ON TOP of the default
+ * {home, repo-root} allowlist. The posture stays deny-by-default: only roots an
+ * operator has explicitly listed are added. Two union sources:
+ *
+ *   1. env `MUONROI_HARNESS_EXTRA_ROOTS` — a path list separated by the OS path
+ *      separator (";" on win32, ":" elsewhere) and/or commas.
+ *   2. `<REPO_ROOT>/.muonroi-harness-roots.json` — `{ "roots": string[] }`.
+ *
+ * Rationale: the drive-harness needs to dogfood sibling ecosystem repos (e.g.
+ * `D:\sources\Core\*`) that live outside both home and the muonroi-cli checkout.
+ * Without an explicit opt-in those cwds are rejected, which blocks real-task
+ * evaluation. Clean checkouts have neither the env nor the (gitignored) config
+ * file, so behaviour is identical to the original home+repo-only boundary.
+ */
+export declare function loadExtraRoots(): string[];
 export declare function validateCwd(cwd: string): {
     ok: true;
 } | {

package/dist/packages/agent-harness-core/src/mcp-server.js

@@ -11,7 +11,7 @@
  *   fd 3/4, named pipes, WebSocket, …). The consumer (muonroi-cli) provides the
  *   spawn implementation via createMcpHarnessServer({ spawn }).
  */
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -50,6 +50,51 @@ export function sanitizeEnv(env) {
     return out;
 }
 const REPO_ROOT = process.cwd();
+/**
+ * Opt-in extra cwd roots for tui.start, layered ON TOP of the default
+ * {home, repo-root} allowlist. The posture stays deny-by-default: only roots an
+ * operator has explicitly listed are added. Two union sources:
+ *
+ *   1. env `MUONROI_HARNESS_EXTRA_ROOTS` — a path list separated by the OS path
+ *      separator (";" on win32, ":" elsewhere) and/or commas.
+ *   2. `<REPO_ROOT>/.muonroi-harness-roots.json` — `{ "roots": string[] }`.
+ *
+ * Rationale: the drive-harness needs to dogfood sibling ecosystem repos (e.g.
+ * `D:\sources\Core\*`) that live outside both home and the muonroi-cli checkout.
+ * Without an explicit opt-in those cwds are rejected, which blocks real-task
+ * evaluation. Clean checkouts have neither the env nor the (gitignored) config
+ * file, so behaviour is identical to the original home+repo-only boundary.
+ */
+export function loadExtraRoots() {
+    const roots = [];
+    const envVal = process.env.MUONROI_HARNESS_EXTRA_ROOTS;
+    if (envVal) {
+        // Split on the OS path separator or commas. On win32 the separator is ";"
+        // (not ":") so drive letters like "D:\..." stay intact.
+        const listSep = process.platform === "win32" ? ";" : ":";
+        for (const part of envVal.split(new RegExp(`[${listSep},]`))) {
+            const trimmed = part.trim();
+            if (trimmed)
+                roots.push(trimmed);
+        }
+    }
+    const cfgPath = resolve(REPO_ROOT, ".muonroi-harness-roots.json");
+    if (existsSync(cfgPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(cfgPath, "utf8"));
+            if (Array.isArray(parsed.roots)) {
+                for (const r of parsed.roots) {
+                    if (typeof r === "string" && r.trim())
+                        roots.push(r.trim());
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[harness/mcp-server] failed to parse ${cfgPath}: ${err?.message}`);
+        }
+    }
+    return roots;
+}
 export function validateCwd(cwd) {
     let real;
     try {
@@ -58,16 +103,22 @@ export function validateCwd(cwd) {
     catch {
         return { ok: false, reason: "cwd does not exist or unreadable" };
     }
-    const home = realpathSync(homedir());
-    const root = realpathSync(REPO_ROOT);
     const sep = process.platform === "win32" ? "\\" : "/";
-    if (real === home || real.startsWith(home + sep)) {
-        return { ok: true };
+    const allowedRoots = [realpathSync(homedir()), realpathSync(REPO_ROOT)];
+    for (const extra of loadExtraRoots()) {
+        try {
+            allowedRoots.push(realpathSync(extra));
+        }
+        catch (err) {
+            console.error(`[harness/mcp-server] extra cwd root unresolved, skipping: ${extra} (${err?.message})`);
+        }
     }
-    if (real === root || real.startsWith(root + sep)) {
-        return { ok: true };
+    for (const root of allowedRoots) {
+        if (real === root || real.startsWith(root + sep)) {
+            return { ok: true };
+        }
     }
-    return { ok: false, reason: "cwd escapes home and repo root" };
+    return { ok: false, reason: "cwd escapes home, repo root, and configured extra roots" };
 }
 export function validateMockLlmPath(value) {
     const resolved = isAbsolute(value) ? value : resolve(REPO_ROOT, value);
@@ -255,7 +306,34 @@ export function registerAsyncTools(server, getDriver, deps) {
     });
     server.registerTool("tui.last_event", {
         description: "Return the most recent event of the given kind (null if none).",
-        inputSchema: { kind: z.enum(["toast", "stream.delta"]) },
+        // Full protocol event set (minus the idle sentinel) so an external agent can
+        // observe lifecycle events — council/sprint/route/askcard, not just toasts.
+        // The Driver accepts any kind; this enum is the MCP-boundary validation.
+        inputSchema: {
+            kind: z.enum([
+                "toast",
+                "stream.delta",
+                "llm-token",
+                "llm-done",
+                "council-step",
+                "council-speaker",
+                "council-turn-length",
+                "askcard-open",
+                "askcard-answered",
+                "askcard-cancel",
+                "sprint-stage",
+                "sprint-halt",
+                "sprint-plan-committed",
+                "route-decision",
+                "steer-inject",
+                "usage",
+                "grounding-flag",
+                "ee-timeout",
+                "ee-error",
+                "stream-retry",
+                "disconnect",
+            ]),
+        },
     }, async ({ kind }) => {
         const d = getDriver();
         if (!d)
@@ -353,7 +431,7 @@ export function createMcpHarnessServer({ spawn }) {
         }
         if (!finalArgs.includes("--agent-mode"))
             finalArgs.push("--agent-mode");
-        const entry = process.cwd() + "/src/index.ts";
+        const entry = `${process.cwd()}/src/index.ts`;
         // Delegate to the injected spawn implementation — the core package has no
         // knowledge of the concrete transport (fd 3/4, named pipes, WebSocket …).
         let spawnResult;

package/dist/packages/agent-harness-core/src/protocol.d.ts

@@ -73,6 +73,21 @@ export type LiveEvent = {
     round?: number;
     /** Correlation ID linking this speaker event to the enclosing council run. */
     correlationId: string;
+} | {
+    t: "event";
+    kind: "council-turn-length";
+    /** Council role label (e.g. "architect"); matches council-speaker.role. */
+    role: string;
+    /** Debate round: 0 = opening statements, 1+ = discussion rounds. */
+    round: number;
+    /** Full character count of the speaker's output (trimmed; never truncated). */
+    charCount: number;
+    /** Word count of the speaker's output (whitespace-split, empties dropped). */
+    wordCount: number;
+    /** The speaker's model id, for per-model thrift attribution. */
+    model: string;
+    /** Correlation ID tying turns to the enclosing council run (= sessionId). */
+    correlationId: string;
 } | {
     t: "event";
     kind: "askcard-open";

package/dist/packages/agent-harness-core/src/selector.js

@@ -1,4 +1,4 @@
-const FLAGS = new Set(["focus", "selected", "disabled"]);
+const _FLAGS = new Set(["focus", "selected", "disabled"]);
 export function parseSelector(input) {
     // First, split by child combinator >>
     const childCombinatorRegex = /\s*>>\s*/;
@@ -146,7 +146,7 @@ function readField(node, key) {
         return node.state;
     if (key.startsWith("props.")) {
         const dot = key.slice("props.".length);
-        return (node.props ?? {})[dot];
+        return node.props?.[dot];
     }
     return undefined;
 }

package/dist/packages/agent-harness-core/src/transports/sidechannel.js

@@ -1,6 +1,6 @@
 const MAX_BYTES = 1024 * 1024; // 1 MiB
 function serialize(msg) {
-    const line = JSON.stringify(msg) + "\n";
+    const line = `${JSON.stringify(msg)}\n`;
     if (Buffer.byteLength(line, "utf8") > MAX_BYTES) {
         throw new Error(`sidechannel message exceeds 1 MiB cap`);
     }

package/dist/packages/agent-harness-opentui/src/agent-mode.js

@@ -17,8 +17,8 @@
  */
 import { createReadStream, createWriteStream } from "node:fs";
 import { createEventFilter } from "@muonroi/agent-harness-core/event-filter";
-import { createIdleDetector } from "@muonroi/agent-harness-core/idle";
 import { redactEvent } from "@muonroi/agent-harness-core/event-redact";
+import { createIdleDetector } from "@muonroi/agent-harness-core/idle";
 import { createLineSplitter, createSidechannelWriter } from "@muonroi/agent-harness-core/transports/sidechannel";
 import { installOpenTUIHarness } from "./install.js";
 import { createSemanticRegistry } from "./reconciler-hook.js";

package/dist/packages/agent-harness-opentui/src/install.js

@@ -41,7 +41,7 @@ export function installOpenTUIHarness(opts) {
         if (frame === null)
             return; // dedup — no change
         try {
-            opts.transport.send(JSON.stringify(frame) + "\n");
+            opts.transport.send(`${JSON.stringify(frame)}\n`);
             opts.onFrame?.(frame);
         }
         catch {

package/dist/src/__test-stubs__/vitest-setup.js

@@ -3,6 +3,10 @@
  * Any module that transitively imports db.ts will resolve to this stub.
  */
 import { vi } from "vitest";
+// vitest 2+ removed vi.mocked(). This shim restores it for the 93+ call sites across the
+// codebase without a codemod. Safe no-op: vi.mocked(item) just returns item (typed cast).
+// @ts-expect-error — vi.mocked is intentionally absent from vitest 4 types.
+vi.mocked ??= ((item, _options) => item);
 // @opentui/react is a pre-bundled CJS package that requires 'react-reconciler/constants'
 // without the .js extension — this fails in the vitest ESM environment. None of the unit
 // tests exercise OpenTUI hooks directly (those are covered by E2E harness specs), so mocking

package/dist/src/agent-harness/__tests__/mock-model.spec.js

@@ -5,9 +5,11 @@
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { APICallError } from "@ai-sdk/provider";
 import { generateObject, stepCountIs, streamText, tool } from "ai";
 import { afterAll, describe, expect, it } from "vitest";
 import { z } from "zod";
+import { humanizeApiError } from "../../orchestrator/error-utils.js";
 import { createMockModel, loadMockModelFromDir, textOnlyStream, toolCallStream } from "../mock-model.js";
 // biome-ignore lint/suspicious/noExplicitAny: streamText result generic is provider-specific
 async function drainStream(result) {
@@ -188,6 +190,58 @@ describe("loadMockModelFromDir", () => {
         });
         expect(object).toEqual({ ok: true, label: "built" });
     });
+    it("constructs an APICallError from a structured error fixture (drives the humanizeApiError 5xx branch)", async () => {
+        // A pure-JSON fixture cannot otherwise build an APICallError (it arrives as
+        // a plain string). buildFixtureError() in mock-model.ts upgrades a structured
+        // `error` object carrying a statusCode into a real APICallError so harness/
+        // unit specs can exercise the orchestrator's status-aware 5xx path.
+        const dir = mkFixtureDir({
+            provider: "mock",
+            modelId: "mock-gpt",
+            stream: [
+                [
+                    { type: "stream-start", warnings: [] },
+                    {
+                        type: "error",
+                        error: {
+                            apiCallError: true,
+                            statusCode: 500,
+                            message: "AI_APICallError: Request failed",
+                            responseBody: JSON.stringify({ code: 60000, message: "Request failed: Unknown error." }),
+                            url: "https://api.siliconflow.cn/v1/chat/completions",
+                            isRetryable: true,
+                        },
+                    },
+                    {
+                        type: "finish",
+                        finishReason: { unified: "error", raw: null },
+                        usage: {
+                            inputTokens: { total: 0, noCache: 0, cacheRead: null, cacheWrite: null },
+                            outputTokens: { total: 0, text: 0, reasoning: null },
+                        },
+                    },
+                ],
+            ],
+        });
+        const handle = await loadMockModelFromDir(dir);
+        expect(handle).not.toBeNull();
+        const r = streamText({ model: handle.model, prompt: "hi" });
+        let errPart = null;
+        for await (const part of r.fullStream) {
+            if (part.type === "error")
+                errPart = part;
+        }
+        expect(errPart).not.toBeNull();
+        expect(APICallError.isInstance(errPart?.error)).toBe(true);
+        expect((errPart?.error).statusCode).toBe(500);
+        // The 5xx branch must surface the canned actionable text + (HTTP 500) and
+        // SUPPRESS the opaque provider body (the SiliconFlow "Unknown error" mask).
+        const msg = humanizeApiError(errPart?.error);
+        expect(msg).toContain("HTTP 500");
+        expect(msg.toLowerCase()).toContain("try again later");
+        expect(msg).not.toContain("Unknown error");
+        expect(msg).not.toContain("Request failed");
+    });
     it("supports multi-round stream arrays from the fixture file", async () => {
         const dir = mkFixtureDir({
             provider: "mock",

package/dist/src/agent-harness/mock-model.d.ts

@@ -22,7 +22,7 @@
  *   const calls = handle.calls; // LanguageModelV3CallOptions[]
  *   expect(calls[0].maxOutputTokens).toBeUndefined();
  */
-import type { LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import { type LanguageModelV3CallOptions, type LanguageModelV3StreamPart } from "@ai-sdk/provider";
 import { MockLanguageModelV3 } from "ai/test";
 export type StreamChunks = LanguageModelV3StreamPart[];
 export interface MockModelFixture {

package/dist/src/agent-harness/mock-model.js

@@ -22,6 +22,7 @@
  *   const calls = handle.calls; // LanguageModelV3CallOptions[]
  *   expect(calls[0].maxOutputTokens).toBeUndefined();
  */
+import { APICallError } from "@ai-sdk/provider";
 import { simulateReadableStream } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 function isNestedArray(v) {
@@ -71,7 +72,7 @@ export function createMockModel(fx) {
             const text = generates.length > 0 ? generates[Math.min(genIdx, generates.length - 1)] : "{}";
             genIdx += 1;
             if (process.env.MUONROI_DEBUG_MOCK_MODEL === "1") {
-                process.stderr.write(`[mock-model] doGenerate #${genIdx} → ${text.length} chars\n`);
+                process.stderr.write(`[mock-model] doGenerate #${genIdx} → ${text.length} chars\nCALLER:\n${new Error().stack}\n`);
             }
             return {
                 content: [{ type: "text", text }],
@@ -198,14 +199,150 @@ export function toolCallStream(opts) {
  * string payloads here so the rest of the pipeline sees a uniform shape.
  */
 function normalizeStreamChunks(chunks) {
-    return chunks.map((c) => {
-        if (c && c.type === "error") {
-            const raw = c.error;
-            const err = raw instanceof Error ? raw : new Error(typeof raw === "string" ? raw : "mock LLM error");
-            return { ...c, error: err };
+    const normalized = chunks.map((c) => {
+        if (!c)
+            return c;
+        const part = c;
+        if (part.type === "error") {
+            const raw = part.error;
+            return { ...part, error: buildFixtureError(raw) };
+        }
+        if (part.type === "text-delta") {
+            const delta = part.delta ?? part.textDelta ?? part.text ?? "";
+            const id = part.id ?? "txt-0";
+            return { ...part, id, delta };
+        }
+        if (part.type === "reasoning-delta") {
+            const delta = part.delta ?? part.textDelta ?? part.text ?? "";
+            const id = part.id ?? "reasoning-0";
+            return { ...part, id, delta };
         }
         return c;
     });
+    const result = [];
+    const textIds = new Set();
+    const reasoningIds = new Set();
+    for (const part of normalized) {
+        if (!part)
+            continue;
+        const p = part;
+        if (p.type === "text-delta") {
+            textIds.add(p.id ?? "txt-0");
+        }
+        else if (p.type === "reasoning-delta") {
+            reasoningIds.add(p.id ?? "reasoning-0");
+        }
+    }
+    const seenTextStart = new Set();
+    const seenTextEnd = new Set();
+    const seenReasoningStart = new Set();
+    const seenReasoningEnd = new Set();
+    for (const part of normalized) {
+        if (!part)
+            continue;
+        const p = part;
+        if (p.type === "text-start") {
+            seenTextStart.add(p.id);
+        }
+        else if (p.type === "text-end") {
+            seenTextEnd.add(p.id);
+        }
+        else if (p.type === "reasoning-start") {
+            seenReasoningStart.add(p.id);
+        }
+        else if (p.type === "reasoning-end") {
+            seenReasoningEnd.add(p.id);
+        }
+    }
+    const firstTextDeltaIdx = new Map();
+    const lastTextDeltaIdx = new Map();
+    const firstReasoningDeltaIdx = new Map();
+    const lastReasoningDeltaIdx = new Map();
+    for (let i = 0; i < normalized.length; i++) {
+        const p = normalized[i];
+        if (!p)
+            continue;
+        if (p.type === "text-delta") {
+            const id = p.id ?? "txt-0";
+            if (!firstTextDeltaIdx.has(id))
+                firstTextDeltaIdx.set(id, i);
+            lastTextDeltaIdx.set(id, i);
+        }
+        else if (p.type === "reasoning-delta") {
+            const id = p.id ?? "reasoning-0";
+            if (!firstReasoningDeltaIdx.has(id))
+                firstReasoningDeltaIdx.set(id, i);
+            lastReasoningDeltaIdx.set(id, i);
+        }
+    }
+    for (let i = 0; i < normalized.length; i++) {
+        const p = normalized[i];
+        if (!p) {
+            result.push(p);
+            continue;
+        }
+        if (p.type === "text-delta") {
+            const id = p.id ?? "txt-0";
+            if (firstTextDeltaIdx.get(id) === i && !seenTextStart.has(id)) {
+                result.push({ type: "text-start", id });
+            }
+        }
+        else if (p.type === "reasoning-delta") {
+            const id = p.id ?? "reasoning-0";
+            if (firstReasoningDeltaIdx.get(id) === i && !seenReasoningStart.has(id)) {
+                result.push({ type: "reasoning-start", id });
+            }
+        }
+        if (p.type === "finish") {
+            const usage = p.usage ?? buildUsage(10, 10);
+            result.push({ ...p, usage });
+        }
+        else {
+            result.push(p);
+        }
+        if (p.type === "text-delta") {
+            const id = p.id ?? "txt-0";
+            if (lastTextDeltaIdx.get(id) === i && !seenTextEnd.has(id)) {
+                result.push({ type: "text-end", id });
+            }
+        }
+        else if (p.type === "reasoning-delta") {
+            const id = p.id ?? "reasoning-0";
+            if (lastReasoningDeltaIdx.get(id) === i && !seenReasoningEnd.has(id)) {
+                result.push({ type: "reasoning-end", id });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Turn a fixture `error` payload into the right runtime shape:
+ * - an `APICallError` when the payload is an object carrying a `statusCode`
+ *   (or `apiCallError: true`), so harness specs can exercise the orchestrator's
+ *   status-aware paths (humanizeApiError 5xx canned text, summarizeApiErrorForLog
+ *   forensics, retry classifier). `APICallError.isInstance` duck-types on a
+ *   shared marker, so constructing it here satisfies the `isInstance` checks in
+ *   error-utils.ts. A pure JSON fixture cannot otherwise build one (it would
+ *   arrive as a plain string).
+ * - a plain `Error` for string payloads (the common transient-message case).
+ */
+function buildFixtureError(raw) {
+    if (raw instanceof Error)
+        return raw;
+    if (raw && typeof raw === "object") {
+        const o = raw;
+        if (o.apiCallError === true || typeof o.statusCode === "number") {
+            return new APICallError({
+                message: o.message ?? `mock API error${o.statusCode ? ` (HTTP ${o.statusCode})` : ""}`,
+                url: o.url ?? "https://mock.invalid/v1/chat/completions",
+                requestBodyValues: {},
+                statusCode: o.statusCode,
+                responseBody: o.responseBody,
+                isRetryable: o.isRetryable,
+            });
+        }
+    }
+    return new Error(typeof raw === "string" ? raw : "mock LLM error");
 }
 export async function loadMockModelFromDir(dir) {
     // Diagnostic logging path. Without these messages, every failure mode

package/dist/src/agent-harness/test-spawn.js

@@ -131,7 +131,9 @@ async function spawnWindows(args, opts) {
         await waitForHandshake(outSocket, timeoutMs);
     }
     catch (err) {
-        proc.kill();
+        if (proc && typeof proc.kill === "function") {
+            proc.kill();
+        }
         inServer.close();
         outServer.close();
         throw err;

package/dist/src/chat/chat-keychain.js

@@ -86,7 +86,15 @@ export async function deleteChatSecret(id) {
     const kt = await loadKeytar();
     if (!kt?.deletePassword)
         return false;
-    return kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
+    try {
+        return await kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
+    }
+    catch (err) {
+        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
+            console.error(`[chat-keychain] deletePassword backend error for ${id}:`, err?.message || err);
+        }
+        return false;
+    }
 }
 /**
  * List all stored chat secret IDs.

package/dist/src/cli/cost-forensics.js

@@ -11,6 +11,7 @@
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { getDatabase } from "../storage/db.js";
+import { getSessionChain } from "../storage/index.js";
 import { selectSessionExperience } from "../storage/session-experience-store.js";
 function resolveSessionId(prefix) {
     const rows = getDatabase()
@@ -42,24 +43,26 @@ export function collectCostForensics(sessionId) {
     const session = db.prepare(`SELECT id, model, created_at FROM sessions WHERE id = ?`).get(sessionId);
     if (!session)
         throw new Error(`Session not found: ${sessionId}`);
+    const chain = getSessionChain(sessionId);
+    const placeholders = chain.map(() => "?").join(",");
     const rows = db
         .prepare(`
     SELECT id, source, model, message_seq, input_tokens, output_tokens,
            cache_read_tokens, cache_creation_tokens, cost_micros, created_at,
            provider_options_shape
     FROM usage_events
-    WHERE session_id = ?
+    WHERE session_id IN (${placeholders})
     ORDER BY id ASC
   `)
-        .all(sessionId);
+        .all(...chain);
     const counts = db
         .prepare(`
     SELECT event_type, COUNT(*) AS c
     FROM interaction_logs
-    WHERE session_id = ?
+    WHERE session_id IN (${placeholders})
     GROUP BY event_type
   `)
-        .all(sessionId);
+        .all(...chain);
     const countMap = new Map(counts.map((r) => [r.event_type, r.c]));
     const events = rows.map((r) => ({
         id: r.id,

package/dist/src/cli/keys.d.ts

@@ -15,8 +15,8 @@
  *   keys delete <provider>        — remove a stored key
  *   keys import-bw [providers]    — pull from Bitwarden vault, store in keychain
  *   keys cleanup-settings         — strip plaintext keys from user-settings.json
- *   keys login <provider>         — OAuth login (openai, google)
- *   keys logout <provider>        — OAuth logout (openai, google)
+ *   keys login <provider>         — OAuth login (openai, google/agy)
+ *   keys logout <provider>        — OAuth logout (openai, google/agy)
  */
 import { type ChatSecretId } from "../chat/chat-keychain.js";
 export interface KeysSetOptions {