muonroi-cli 1.8.4 → 1.9.0

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

@@ -19,6 +19,35 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:net";
 // ---------------------------------------------------------------------------
+// Internal: teardown-safe stream error guards
+// ---------------------------------------------------------------------------
+/**
+ * Attach `'error'` listeners to both transport streams so a broken-pipe write
+ * (EPIPE / UV_EPIPE -4047 on Windows) or a peer reset (ECONNRESET) during
+ * process teardown is logged and swallowed instead of surfacing as an
+ * *uncaught* stream error that crashes the whole vitest worker.
+ *
+ * Root cause of the flake: when the child is killed in `afterAll`, an in-flight
+ * `inWrite.write()` (driver sendKey/sendType) or a half-open `outRead` races the
+ * child's death. A WritableStream with no `'error'` listener rethrows EPIPE as
+ * an unhandled exception — under full-suite load this reliably reproduces on
+ * `events.spec.ts` and fails the file even though every assertion passed.
+ *
+ * Logging (not silent swallow) satisfies the No-Silent-Catch rule — teardown
+ * broken-pipe is expected, but a mid-test error still gets a diagnostic line.
+ */
+function attachStreamErrorGuards(inWrite, outRead) {
+    const guard = (label) => (err) => {
+        // EPIPE / ECONNRESET / ERR_STREAM_DESTROYED are all normal teardown races.
+        const code = err?.code ?? "unknown";
+        if (code !== "EPIPE" && code !== "ECONNRESET" && code !== "ERR_STREAM_DESTROYED") {
+            console.error(`[test-spawn] ${label} stream error (${code}): ${err?.message}`);
+        }
+    };
+    inWrite.on("error", guard("inWrite"));
+    outRead.on("error", guard("outRead"));
+}
+// ---------------------------------------------------------------------------
 // Internal: Windows named-pipe transport
 // ---------------------------------------------------------------------------
 function makePipeName(role) {
@@ -143,6 +172,7 @@ async function spawnWindows(args, opts) {
         outServer.close();
     };
     proc.once("exit", cleanup);
+    attachStreamErrorGuards(inSocket, outSocket);
     return {
         proc,
         inWrite: inSocket, // host writes commands → child reads on MUONROI_HARNESS_IN_PIPE
@@ -161,6 +191,7 @@ function spawnPosix(args, opts) {
     const proc = spawn("bun", ["run", ...args], spawnOptions);
     const outRead = proc.stdio[3];
     const inWrite = proc.stdio[4];
+    attachStreamErrorGuards(inWrite, outRead);
     return { proc, inWrite, outRead, cleanup: () => { } };
 }
 // ---------------------------------------------------------------------------

package/dist/src/chat/chat-keychain.d.ts

@@ -1,26 +1,21 @@
 /**
  * src/chat/chat-keychain.ts
  *
- * Chat-service keychain loader with env-var fallback.
- * Parallel module to src/mcp/mcp-keychain.ts but keyed by ChatSecretId
- * (chat services like Discord, Slack) instead of MCP servers.
- *
- * Priority: OS keychain (keytar) > environment variable > null.
- * On CLI startup, hydrateChatEnvFromKeychain() populates process.env from
- * keychain for any chat secret not already set in env.
+ * Chat-service secret store, keyed by ChatSecretId (Discord, Slack). Backed by
+ * the env-store (`.env` file + process.env + Windows registry mirror) — the OS
+ * keychain (keytar) has been removed. Reads come straight from process.env.
  */
 export type ChatSecretId = "discord-token" | "discord-guild-id" | "slack-token" | "slack-team-id";
 export declare function setChatSecret(id: ChatSecretId, value: string): Promise<boolean>;
 export declare function getChatSecret(id: ChatSecretId): Promise<string | null>;
 export declare function deleteChatSecret(id: ChatSecretId): Promise<boolean>;
 /**
- * List all stored chat secret IDs.
- * Note: This only returns secrets stored in OS keychain, not those in env.
+ * List all stored chat secret IDs (those present in the environment).
  */
 export declare function listChatSecrets(): Promise<ChatSecretId[]>;
 /**
- * On CLI startup, populate process.env from keychain for any chat secret
- * not already set in env. Allows downstream code (chat/factory.ts) to
- * remain env-based without code changes.
+ * Retained for boot compatibility (index.ts). Chat secrets now live in the
+ * environment (loaded from the env-store at startup), so there is nothing to
+ * hydrate — this is a no-op.
  */
 export declare function hydrateChatEnvFromKeychain(): Promise<void>;

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

@@ -1,22 +1,12 @@
 /**
  * src/chat/chat-keychain.ts
  *
- * Chat-service keychain loader with env-var fallback.
- * Parallel module to src/mcp/mcp-keychain.ts but keyed by ChatSecretId
- * (chat services like Discord, Slack) instead of MCP servers.
- *
- * Priority: OS keychain (keytar) > environment variable > null.
- * On CLI startup, hydrateChatEnvFromKeychain() populates process.env from
- * keychain for any chat secret not already set in env.
+ * Chat-service secret store, keyed by ChatSecretId (Discord, Slack). Backed by
+ * the env-store (`.env` file + process.env + Windows registry mirror) — the OS
+ * keychain (keytar) has been removed. Reads come straight from process.env.
  */
+import { clearEnvVar, persistEnvVar } from "../providers/env-store.js";
 import { redactor } from "../utils/redactor.js";
-const KEYCHAIN_SERVICE = "muonroi-cli";
-const ACCOUNT_BY_CHAT = {
-    "discord-token": "chat-discord-token",
-    "discord-guild-id": "chat-discord-guild-id",
-    "slack-token": "chat-slack-token",
-    "slack-team-id": "chat-slack-team-id",
-};
 const ENV_BY_CHAT = {
     "discord-token": "MUONROI_DISCORD_TOKEN",
     "discord-guild-id": "MUONROI_DISCORD_GUILD_ID",
@@ -24,107 +14,50 @@ const ENV_BY_CHAT = {
     "slack-team-id": "MUONROI_SLACK_TEAM_ID",
 };
 const MIN_LEN = 8; // guild IDs are short (18-19 digits); tokens ~70 chars. Use 8 as floor.
-async function loadKeytar() {
-    try {
-        return (await import("keytar"));
-    }
-    catch {
-        return null;
-    }
+function isTokenSecret(id) {
+    return id === "discord-token" || id === "slack-token";
 }
 export async function setChatSecret(id, value) {
     if (!value || value.length < MIN_LEN) {
         throw new Error(`Value for chat secret '${id}' is too short (< ${MIN_LEN} chars).`);
     }
-    const kt = await loadKeytar();
-    if (!kt?.setPassword)
-        return false;
-    // Enroll token values in redactor, but not IDs (they are not secrets)
-    if (id === "discord-token" || id === "slack-token") {
+    if (isTokenSecret(id))
         redactor.enrollSecret(value);
-    }
-    try {
-        await kt.setPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id], value);
-        return true;
-    }
-    catch (err) {
-        // Runtime backend failure (e.g. Linux without libsecret or no active secret service).
-        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
-            console.error(`[chat-keychain] setPassword backend error for ${id}:`, err?.message || err);
-        }
-        return false;
-    }
+    persistEnvVar(ENV_BY_CHAT[id], value);
+    return true;
 }
 export async function getChatSecret(id) {
-    const kt = await loadKeytar();
-    if (kt) {
-        try {
-            const v = await kt.getPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
-            if (v && v.length >= MIN_LEN) {
-                // Enroll in redactor only for token values
-                if (id === "discord-token" || id === "slack-token") {
-                    redactor.enrollSecret(v);
-                }
-                return v;
-            }
-        }
-        catch {
-            /* keytar backend failure → fall through to env */
-        }
-    }
     const envKey = process.env[ENV_BY_CHAT[id]];
     if (envKey && envKey.length >= MIN_LEN) {
-        // Enroll in redactor only for token values
-        if (id === "discord-token" || id === "slack-token") {
+        if (isTokenSecret(id))
             redactor.enrollSecret(envKey);
-        }
         return envKey;
     }
     return null;
 }
 export async function deleteChatSecret(id) {
-    const kt = await loadKeytar();
-    if (!kt?.deletePassword)
-        return false;
-    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;
-    }
+    const had = !!process.env[ENV_BY_CHAT[id]];
+    clearEnvVar(ENV_BY_CHAT[id]);
+    return had;
 }
 /**
- * List all stored chat secret IDs.
- * Note: This only returns secrets stored in OS keychain, not those in env.
+ * List all stored chat secret IDs (those present in the environment).
  */
 export async function listChatSecrets() {
     const ids = ["discord-token", "discord-guild-id", "slack-token", "slack-team-id"];
     const stored = [];
     for (const id of ids) {
-        const v = await getChatSecret(id);
-        if (v) {
+        if (await getChatSecret(id))
             stored.push(id);
-        }
     }
     return stored;
 }
 /**
- * On CLI startup, populate process.env from keychain for any chat secret
- * not already set in env. Allows downstream code (chat/factory.ts) to
- * remain env-based without code changes.
+ * Retained for boot compatibility (index.ts). Chat secrets now live in the
+ * environment (loaded from the env-store at startup), so there is nothing to
+ * hydrate — this is a no-op.
  */
 export async function hydrateChatEnvFromKeychain() {
-    const ids = ["discord-token", "discord-guild-id", "slack-token", "slack-team-id"];
-    for (const id of ids) {
-        const envName = ENV_BY_CHAT[id];
-        if (process.env[envName])
-            continue; // env wins
-        const v = await getChatSecret(id);
-        if (v)
-            process.env[envName] = v;
-    }
+    // Intentional no-op: env-store already populated process.env at startup.
 }
 //# sourceMappingURL=chat-keychain.js.map

package/dist/src/cli/config/screen-providers.js

@@ -9,7 +9,7 @@ import { A, captureKey, divider, enterRawMode, hiddenPrompt, maskKey } from "./t
  * until their integration is hardened — the router can still target them
  * programmatically. To re-expose one, add its id here.
  */
-const VISIBLE_PROVIDERS = ["deepseek", "siliconflow"];
+const VISIBLE_PROVIDERS = ["deepseek", "zai", "opencode-go", "xai"];
 const ALL_PROVIDERS = [...VISIBLE_PROVIDERS, "ollama"];
 void KEYCHAIN_PROVIDER_IDS;
 async function loadRows() {

package/dist/src/cli/cost-forensics.d.ts

@@ -35,6 +35,16 @@ export interface CostForensicsSummary {
     totalCostUsd: number;
     cacheHitRatio: number;
     peakSingleCallInput: number;
+    /**
+     * Peak FRESH (uncached) input on any single usage event — `max(input -
+     * cacheRead)`. This is the cap-escape discriminator: `task`/`council` rows
+     * store `totalUsage` AGGREGATED across a streamText call's internal steps, so
+     * a high `peakSingleCallInput` on those sources is usually cached-prefix reuse
+     * across steps (high cache hit), NOT a single call that breached the cap. A
+     * genuine cold cap-escape sends >cap FRESH tokens in one call, which shows up
+     * here regardless of source.
+     */
+    peakSingleCallFresh: number;
     events: CostForensicsRow[];
     /** Anti-mù counters for this session (null when none recorded). */
     experience: SessionExperienceCounts | null;

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

@@ -83,6 +83,7 @@ export function collectCostForensics(sessionId) {
     let totalCacheCreation = 0;
     let totalCostMicros = 0;
     let peakSingleCallInput = 0;
+    let peakSingleCallFresh = 0;
     for (const e of events) {
         totalInput += e.inputTokens;
         totalOutput += e.outputTokens;
@@ -91,6 +92,9 @@ export function collectCostForensics(sessionId) {
         totalCostMicros += e.costMicros;
         if (e.inputTokens > peakSingleCallInput)
             peakSingleCallInput = e.inputTokens;
+        const fresh = Math.max(0, e.inputTokens - e.cacheReadTokens);
+        if (fresh > peakSingleCallFresh)
+            peakSingleCallFresh = fresh;
     }
     const cacheable = totalInput;
     const cacheHitRatio = cacheable > 0 ? totalCacheRead / cacheable : 0;
@@ -106,6 +110,7 @@ export function collectCostForensics(sessionId) {
         totalCostUsd: totalCostMicros / 1_000_000,
         cacheHitRatio,
         peakSingleCallInput,
+        peakSingleCallFresh,
         events,
         experience: selectSessionExperience(sessionId),
     };
@@ -159,7 +164,8 @@ export function printCostForensics(summary, opts = {}) {
     w(`Total output tokens: ${formatNum(summary.totalOutput)}`);
     w(`Cache read tokens:   ${formatNum(summary.totalCacheRead)} (${formatPct(summary.cacheHitRatio)} of input)`);
     w(`Cache create tokens: ${formatNum(summary.totalCacheCreation)}`);
-    w(`Peak single call:    ${formatNum(summary.peakSingleCallInput)} input`);
+    w(`Peak single call:    ${formatNum(summary.peakSingleCallInput)} input ` +
+        `(${formatNum(summary.peakSingleCallFresh)} fresh)`);
     w(`Estimated cost:      $${summary.totalCostUsd.toFixed(4)}`);
     // Cache-cadence diagnostic — surface fast-loop prompt-cache latency loss.
     const cadence = computeCacheCadence(summary.events);
@@ -199,8 +205,17 @@ export function printCostForensics(summary, opts = {}) {
     }
     // Acceptance hints — surface anomalies relative to Phase A/B/C targets.
     const anomalies = [];
-    if (summary.peakSingleCallInput > 80_000) {
-        anomalies.push(`peak single-call input ${formatNum(summary.peakSingleCallInput)} > 80,000 — sub-agent cap may not have kicked in (Phase B target breach)`);
+    // Phase B breach = a single call that sent >80K FRESH (uncached) tokens.
+    // Use FRESH, not raw input: `task`/`council` usage rows store `totalUsage`
+    // aggregated across a streamText call's internal steps, so a high raw input
+    // there is normally cached-prefix reuse across steps (high cache hit), NOT a
+    // cold cap breach. Evidence: session 6f17a13c1591 peaked at 378,613 raw input
+    // but only 54,389 fresh (324,224 cache-read) — aggregate reuse, no breach.
+    if (summary.peakSingleCallFresh > 80_000) {
+        anomalies.push(`peak single-call FRESH input ${formatNum(summary.peakSingleCallFresh)} > 80,000 — sub-agent cap may not have kicked in (Phase B target breach)`);
+    }
+    else if (summary.peakSingleCallInput > 80_000) {
+        anomalies.push(`peak single-call input ${formatNum(summary.peakSingleCallInput)} > 80,000 but only ${formatNum(summary.peakSingleCallFresh)} FRESH — aggregate multi-step reuse (task/council totalUsage), NOT a cap breach`);
     }
     if (summary.events.some((e) => e.messageSeq === null && e.source === "message")) {
         anomalies.push(`some 'message' events have NULL message_seq — Phase A5 message write-ahead bypassed (check persistMessageWriteAhead wiring)`);

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

@@ -7,7 +7,7 @@
  * Format (JSON):
  *   { v:1, kdf:"scrypt", salt:hex, iv:hex, tag:hex, ct:base64 }
  *
- * Plaintext payload (JSON): { providers: { deepseek: "sk-...", siliconflow: "sf-..." } }
+ * Plaintext payload (JSON): { providers: { deepseek: "sk-...", xai: "xai-..." } }
  *
  * Crypto:
  *   - scrypt(passphrase, salt, 32) → 256-bit key

package/dist/src/cli/keys-bundle.js

@@ -7,7 +7,7 @@
  * Format (JSON):
  *   { v:1, kdf:"scrypt", salt:hex, iv:hex, tag:hex, ct:base64 }
  *
- * Plaintext payload (JSON): { providers: { deepseek: "sk-...", siliconflow: "sf-..." } }
+ * Plaintext payload (JSON): { providers: { deepseek: "sk-...", xai: "xai-..." } }
  *
  * Crypto:
  *   - scrypt(passphrase, salt, 32) → 256-bit key

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

@@ -1,62 +1,27 @@
 /**
  * `muonroi-cli keys` subcommand group.
  *
- * Manages provider API keys via the OS keychain (Windows Credential Manager,
- * macOS Keychain, libsecret on Linux via keytar). Keys are read by the CLI through the
- * keychain → env → settings.json priority chain in providers/keychain.ts.
- *
- * On Linux without libsecret + an active secret service (gnome-keyring etc.),
- * or in headless sessions, keychain writes return false and callers fall back
- * to advising environment variables (which are still honored at runtime).
+ * Manages provider API keys via the env-store. Keys are read by the CLI through
+ * the env-store → env → settings.json priority chain in providers/keychain.ts.
  *
  * Subcommands:
- *   keys set <provider>           — interactive prompt, stores in keychain
+ *   keys set <provider>           — interactive prompt, stores the key
  *   keys list                     — show masked keys currently stored
  *   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/agy)
- *   keys logout <provider>        — OAuth logout (openai, google/agy)
+ *   keys export <file>            — export keys to an encrypted portable bundle
+ *   keys import <file>            — import an encrypted bundle
+ *   keys login <provider>         — OAuth login (openai, xai)
+ *   keys logout <provider>        — OAuth logout (openai, xai)
  */
 import { type ChatSecretId } from "../chat/chat-keychain.js";
-export interface KeysSetOptions {
-    bw?: boolean;
-    itemPrefix?: string;
-}
-export declare function runKeysSet(provider: string, options?: KeysSetOptions): Promise<void>;
-export declare function runMcpKeysSet(id: string, options?: KeysSetOptions): Promise<void>;
+export type KeysSetOptions = Record<string, never>;
+export declare function runKeysSet(provider: string, _options?: KeysSetOptions): Promise<void>;
+export declare function runMcpKeysSet(id: string, _options?: KeysSetOptions): Promise<void>;
 export declare function runKeysList(): Promise<void>;
 export declare function runKeysDelete(provider: string): Promise<void>;
 export declare function runKeysExport(filePath: string): Promise<void>;
 export declare function runKeysImport(filePath: string): Promise<void>;
-interface BwImportOptions {
-    providers?: string[];
-    itemPrefix?: string;
-}
-export declare function runKeysImportBw(opts?: BwImportOptions): Promise<void>;
-interface McpBwImportOptions {
-    keys?: string[];
-    itemPrefix?: string;
-}
-/**
- * Import MCP secrets (e.g. Tavily) from a Bitwarden vault into the OS
- * keychain via mcp-keychain. Vault items are expected at `<prefix><id>` —
- * default prefix `muonroi-cli/`. The key value is read from the item's
- * notes field, mirroring the provider import-bw flow.
- */
-export declare function runMcpImportBw(opts?: McpBwImportOptions): Promise<void>;
 export declare function runChatKeySet(id: ChatSecretId, value: string): Promise<void>;
-interface ChatBwImportOptions {
-    ids?: ChatSecretId[];
-    itemPrefix?: string;
-}
-/**
- * Import chat secrets (discord-token, discord-guild-id, slack-token, slack-team-id)
- * from a Bitwarden vault into the OS keychain. Vault items are expected at
- * `<prefix><id>` — default prefix `muonroi-cli/chat-`. The value is read from
- * the item's notes field, mirroring the provider/MCP import-bw flow.
- */
-export declare function runChatImportBw(opts?: ChatBwImportOptions): Promise<void>;
 /**
  * `muonroi-cli keys login <provider>`
  *
@@ -74,5 +39,3 @@ export declare function runKeysLogin(provider: string): Promise<void>;
  * through the OAuth registry — no provider branching.
  */
 export declare function runKeysLogout(provider: string): Promise<void>;
-export declare function runKeysCleanupSettings(): Promise<void>;
-export {};