specrails-desktop 2.30.2 → 2.31.0

package/server/dist/spending.js

@@ -20,7 +20,7 @@ const ALL_SURFACES = [
 function emptyBySurface() {
     const out = {};
     for (const s of ALL_SURFACES)
-        out[s] = { count: 0, costUsd: 0 };
+        out[s] = { count: 0, costUsd: 0, unpricedCount: 0 };
     return out;
 }
 /**
@@ -200,17 +200,30 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
       COALESCE(SUM(COALESCE(tokens_in, 0) + COALESCE(tokens_out, 0)
                    + COALESCE(tokens_cache_read, 0) + COALESCE(tokens_cache_create, 0)), 0) AS totalTokens,
       COUNT(*) AS totalRuns,
+      COUNT(total_cost_usd) AS pricedRuns,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpricedRuns,
+      SUM(CASE WHEN tokens_in IS NOT NULL OR tokens_out IS NOT NULL
+                    OR tokens_cache_read IS NOT NULL OR tokens_cache_create IS NOT NULL
+               THEN 1 ELSE 0 END) AS usageReportedRuns,
+      SUM(CASE WHEN tokens_in IS NULL AND tokens_out IS NULL
+                    AND tokens_cache_read IS NULL AND tokens_cache_create IS NULL
+               THEN 1 ELSE 0 END) AS usageUnavailableRuns,
       SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed,
+      SUM(CASE WHEN status = 'success' AND total_cost_usd IS NULL THEN 1 ELSE 0 END) AS successfulUnpriced,
       AVG(CASE WHEN status = 'success' THEN total_cost_usd END) AS avgCost
     FROM ai_invocations WHERE ${where.sql}
   `).get(...where.params);
     // prev period
     const prevWhere = buildWhere(projectId, filters, { from: range.prevFrom, to: range.prevTo });
     const prevRow = db.prepare(`
-    SELECT COALESCE(SUM(total_cost_usd), 0) AS totalCost
+    SELECT
+      COALESCE(SUM(total_cost_usd), 0) AS totalCost,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpricedRuns
     FROM ai_invocations WHERE ${prevWhere.sql}
   `).get(...prevWhere.params);
-    const deltaPct = prevRow.totalCost > 0
+    const deltaPct = (summaryRow.unpricedRuns ?? 0) === 0
+        && (prevRow.unpricedRuns ?? 0) === 0
+        && prevRow.totalCost > 0
         ? ((summaryRow.totalCost - prevRow.totalCost) / prevRow.totalCost) * 100
         : null;
     // byModel (top 10) + per-mode dominant models — one GROUP BY model, surface
@@ -225,21 +238,37 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
       model, surface,
       COUNT(*) AS cnt,
       COALESCE(SUM(total_cost_usd), 0) AS cost,
-      COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estCost
+      COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estCost,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpriced
     FROM ai_invocations WHERE ${where.sql} AND model IS NOT NULL
     GROUP BY provider, model, surface
   `).all(...where.params);
     const modelTotals = new Map();
     for (const r of modelRows) {
-        const key = `${r.provider}${r.model}`;
-        const agg = modelTotals.get(key) ?? { provider: r.provider, model: r.model, cnt: 0, cost: 0, est: 0 };
+        const key = `${r.provider}\0${r.model}`;
+        const agg = modelTotals.get(key) ?? {
+            provider: r.provider,
+            model: r.model,
+            cnt: 0,
+            cost: 0,
+            est: 0,
+            unpriced: 0,
+        };
         agg.cnt += r.cnt;
         agg.cost += r.cost ?? 0;
         agg.est += r.estCost ?? 0;
+        agg.unpriced += r.unpriced ?? 0;
         modelTotals.set(key, agg);
     }
     const byModel = Array.from(modelTotals.values())
-        .map((t) => ({ provider: t.provider, model: t.model, count: t.cnt, costUsd: t.cost, estimatedCostUsd: t.est }))
+        .map((t) => ({
+        provider: t.provider,
+        model: t.model,
+        count: t.cnt,
+        costUsd: t.cost,
+        estimatedCostUsd: t.est,
+        ...(t.unpriced > 0 ? { unpricedCount: t.unpriced } : {}),
+    }))
         .sort((a, b) => b.costUsd - a.costUsd)
         .slice(0, 10);
     // dominantModel is the most-frequent model per surface (provider-agnostic —
@@ -247,11 +276,11 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     const dominantBySurface = new Map();
     const dominantTally = new Map();
     for (const r of modelRows) {
-        const k = `${r.surface}${r.model}`;
+        const k = `${r.surface}\0${r.model}`;
         dominantTally.set(k, (dominantTally.get(k) ?? 0) + r.cnt);
     }
     for (const [k, cnt] of dominantTally.entries()) {
-        const sep = k.indexOf('');
+        const sep = k.indexOf('\0');
         const surface = k.slice(0, sep);
         const model = k.slice(sep + 1);
         const cur = dominantBySurface.get(surface);
@@ -262,7 +291,11 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     // calendar day (BUG-ANALYTICS-21): the client passes its local offset so
     // "today" lines up with the user's wall clock; offset 0 ⇒ legacy UTC days.
     const dayRows = db.prepare(`
-    SELECT ${dayBucketExpr(tzOffset)} AS day, surface, COALESCE(SUM(total_cost_usd), 0) AS cost
+    SELECT
+      ${dayBucketExpr(tzOffset)} AS day,
+      surface,
+      COALESCE(SUM(total_cost_usd), 0) AS cost,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpriced
     FROM ai_invocations WHERE ${where.sql}
     GROUP BY day, surface
   `).all(...where.params);
@@ -279,7 +312,7 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     const dayMap = new Map();
     for (const day of days) {
         dayMap.set(day, {
-            date: day, jobsCostUsd: 0, quickCostUsd: 0, exploreCostUsd: 0, aiEditCostUsd: 0, smashCostUsd: 0, fileSummaryCostUsd: 0, loopCostUsd: 0, totalCostUsd: 0,
+            date: day, jobsCostUsd: 0, quickCostUsd: 0, exploreCostUsd: 0, aiEditCostUsd: 0, smashCostUsd: 0, fileSummaryCostUsd: 0, loopCostUsd: 0, totalCostUsd: 0, unpricedCount: 0,
         });
     }
     for (const r of dayRows) {
@@ -302,8 +335,13 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
         else if (r.surface === 'loop')
             entry.loopCostUsd += c;
         entry.totalCostUsd += c;
+        entry.unpricedCount = (entry.unpricedCount ?? 0) + (r.unpriced ?? 0);
     }
     const dailyTimeline = Array.from(dayMap.values());
+    for (const day of dailyTimeline) {
+        if ((day.unpricedCount ?? 0) === 0)
+            delete day.unpricedCount;
+    }
     // byMode (Quick vs Explore) — one GROUP BY surface query for both modes;
     // dominant models come from modelRows and sparklines from dayRows, which
     // already carry exactly these aggregates (H24: previously 3 extra queries
@@ -320,8 +358,11 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
       COUNT(DISTINCT ticket_id) AS ticketsCreated,
       COALESCE(SUM(total_cost_usd), 0) AS totalCost,
       COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estCost,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpricedRuns,
       COALESCE(SUM(CASE WHEN status = 'success' AND ticket_id IS NOT NULL THEN total_cost_usd ELSE 0 END), 0) AS specCostSum,
       COUNT(DISTINCT CASE WHEN status = 'success' AND ticket_id IS NOT NULL THEN ticket_id END) AS specCount,
+      COUNT(DISTINCT CASE WHEN status = 'success' AND ticket_id IS NOT NULL
+                               AND total_cost_usd IS NULL THEN ticket_id END) AS unpricedSpecCount,
       AVG(CASE WHEN status = 'success' THEN duration_ms END) AS avgDur
     FROM ai_invocations WHERE ${where.sql} AND surface IN ('quick-spec', 'explore-spec')
     GROUP BY surface
@@ -333,7 +374,12 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     const byMode = ['quick-spec', 'explore-spec'].map((surface) => {
         const modeKey = surface === 'quick-spec' ? 'quick' : 'explore';
         const r = modeAggBySurface.get(surface);
-        const avgCostPerSpec = r && r.specCount > 0 ? r.specCostSum / r.specCount : null;
+        // A partial average over only providers that report cost is worse than no
+        // average: it looks authoritative while silently excluding Kimi. Preserve
+        // unavailable until every successful ticket in the denominator is priced.
+        const avgCostPerSpec = r && r.specCount > 0 && r.unpricedSpecCount === 0
+            ? r.specCostSum / r.specCount
+            : null;
         const sparkline = days.map((d) => costByDaySurface.get(`${d}|${surface}`) ?? 0);
         return {
             mode: modeKey,
@@ -341,6 +387,7 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
             ticketsCreated: r?.ticketsCreated ?? 0,
             totalCostUsd: r?.totalCost ?? 0,
             estimatedCostUsd: r?.estCost ?? 0,
+            ...((r?.unpricedRuns ?? 0) > 0 ? { unpricedCount: r?.unpricedRuns ?? 0 } : {}),
             avgCostPerSpec,
             avgDurationMs: r?.avgDur ?? null,
             dominantModel: dominantBySurface.get(surface)?.model ?? null,
@@ -396,7 +443,12 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     }
     // topTickets (cross-surface aggregation)
     const ticketRows = db.prepare(`
-    SELECT ticket_id, surface, COUNT(*) AS cnt, COALESCE(SUM(total_cost_usd), 0) AS cost
+    SELECT
+      ticket_id,
+      surface,
+      COUNT(*) AS cnt,
+      COALESCE(SUM(total_cost_usd), 0) AS cost,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpriced
     FROM ai_invocations WHERE ${where.sql}
     GROUP BY ticket_id, surface
   `).all(...where.params);
@@ -409,6 +461,7 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
                 ticketTitle: null,
                 totalCostUsd: 0,
                 totalRuns: 0,
+                unpricedCount: 0,
                 bySurface: emptyBySurface(),
                 isUnattributed: r.ticket_id === null ? true : undefined,
             });
@@ -416,12 +469,23 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
         const entry = ticketMap.get(key);
         entry.bySurface[r.surface].count += r.cnt;
         entry.bySurface[r.surface].costUsd += r.cost ?? 0;
+        entry.bySurface[r.surface].unpricedCount =
+            (entry.bySurface[r.surface].unpricedCount ?? 0) + (r.unpriced ?? 0);
         entry.totalRuns += r.cnt;
         entry.totalCostUsd += r.cost ?? 0;
+        entry.unpricedCount = (entry.unpricedCount ?? 0) + (r.unpriced ?? 0);
     }
     const topTickets = Array.from(ticketMap.values())
         .sort((a, b) => b.totalCostUsd - a.totalCostUsd)
         .slice(0, 10);
+    for (const ticket of topTickets) {
+        if ((ticket.unpricedCount ?? 0) === 0)
+            delete ticket.unpricedCount;
+        for (const bucket of Object.values(ticket.bySurface)) {
+            if ((bucket.unpricedCount ?? 0) === 0)
+                delete bucket.unpricedCount;
+        }
+    }
     // BUG-ANALYTICS-18/36: resolve committed-ticket titles + deleted state via the
     // injected store reader so the card (and the summary-CSV / modal consumers
     // built on this same shape) show names instead of "Deleted ticket #N". Without
@@ -440,14 +504,20 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     // (H24: previously a dedicated query re-scanned the same rows).
     const surfaceTotals = new Map();
     for (const r of ticketRows) {
-        const agg = surfaceTotals.get(r.surface) ?? { cnt: 0, cost: 0 };
+        const agg = surfaceTotals.get(r.surface) ?? { cnt: 0, cost: 0, unpriced: 0 };
         agg.cnt += r.cnt;
         agg.cost += r.cost ?? 0;
+        agg.unpriced += r.unpriced ?? 0;
         surfaceTotals.set(r.surface, agg);
     }
     const bySurface = ALL_SURFACES.map((s) => {
         const t = surfaceTotals.get(s);
-        return { surface: s, count: t?.cnt ?? 0, costUsd: t?.cost ?? 0 };
+        return {
+            surface: s,
+            count: t?.cnt ?? 0,
+            costUsd: t?.cost ?? 0,
+            ...((t?.unpriced ?? 0) > 0 ? { unpricedCount: t?.unpriced ?? 0 } : {}),
+        };
     });
     // tracking start (project's first invocation)
     const trackingRow = db.prepare(`
@@ -461,6 +531,14 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
     SELECT
       COALESCE(provider, 'claude') AS provider,
       COUNT(*) AS cnt,
+      COUNT(total_cost_usd) AS priced,
+      SUM(CASE WHEN total_cost_usd IS NULL THEN 1 ELSE 0 END) AS unpriced,
+      SUM(CASE WHEN tokens_in IS NOT NULL OR tokens_out IS NOT NULL
+                    OR tokens_cache_read IS NOT NULL OR tokens_cache_create IS NOT NULL
+               THEN 1 ELSE 0 END) AS usageReported,
+      SUM(CASE WHEN tokens_in IS NULL AND tokens_out IS NULL
+                    AND tokens_cache_read IS NULL AND tokens_cache_create IS NULL
+               THEN 1 ELSE 0 END) AS usageUnavailable,
       COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 0 THEN total_cost_usd ELSE 0 END), 0) AS authoritativeCost,
       COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estimatedCost
     FROM ai_invocations WHERE ${where.sql}
@@ -472,17 +550,32 @@ function getSpending(db, projectId, filters = {}, resolveTitle) {
         count: r.cnt,
         costUsd: r.authoritativeCost,
         estimatedCostUsd: r.estimatedCost,
+        pricedCount: r.priced,
+        unpricedCount: r.unpriced ?? 0,
+        usageReportedCount: r.usageReported ?? 0,
+        usageUnavailableCount: r.usageUnavailable ?? 0,
     }));
     return {
         summary: {
             totalCostUsd: summaryRow.totalCost,
             totalEstimatedCostUsd: summaryRow.totalEstimatedCost,
-            totalTokens: summaryRow.totalTokens,
+            totalTokens: (summaryRow.usageReportedRuns ?? 0) > 0
+                ? summaryRow.totalTokens
+                : summaryRow.totalRuns > 0
+                    ? null
+                    : 0,
             totalRuns: summaryRow.totalRuns,
+            pricedRuns: summaryRow.pricedRuns,
+            unpricedRuns: summaryRow.unpricedRuns ?? 0,
+            usageReportedRuns: summaryRow.usageReportedRuns ?? 0,
+            usageUnavailableRuns: summaryRow.usageUnavailableRuns ?? 0,
+            prevUnpricedRuns: prevRow.unpricedRuns ?? 0,
             failureRate: summaryRow.totalRuns > 0 ? (summaryRow.failed ?? 0) / summaryRow.totalRuns : 0,
             prevTotalCostUsd: prevRow.totalCost,
             deltaPct,
-            avgCostPerRun: summaryRow.avgCost,
+            avgCostPerRun: (summaryRow.successfulUnpriced ?? 0) > 0
+                ? null
+                : summaryRow.avgCost,
         },
         bySurface,
         byModel,

package/server/dist/util/cli-prompt.js

@@ -1,5 +1,5 @@
 "use strict";
-// Centralized claude/codex spawn wrapper.
+// Centralized AI CLI spawn wrapper.
 //
 // Why this exists:
 //
@@ -19,7 +19,12 @@
 // The helpers below detect multi-line argv values on Windows,
 // reroute them through child stdin (claude reads stdin when
 // `-p`/`--print` has no positional argument; codex `exec -` does the
-// equivalent), and call spawnCli. POSIX is unchanged byte-for-byte.
+// equivalent), and call spawnCli. Kimi's required `-p <prompt>` has no stdin
+// equivalent, so its Windows npm shim is unwrapped and its JavaScript entry is
+// launched with Node directly. POSIX is unchanged byte-for-byte.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.appendCodexHeadroomRelayOverride = appendCodexHeadroomRelayOverride;
 exports.transformClaudeArgsForWindows = transformClaudeArgsForWindows;
@@ -28,7 +33,11 @@ exports.ensureStdinPipe = ensureStdinPipe;
 exports.spawnClaude = spawnClaude;
 exports.spawnCodex = spawnCodex;
 exports.spawnGemini = spawnGemini;
+exports.parseNpmCmdShimEntry = parseNpmCmdShimEntry;
+exports.spawnKimi = spawnKimi;
 exports.spawnAiCli = spawnAiCli;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const win_spawn_1 = require("./win-spawn");
 const headroom_routing_1 = require("../headroom-routing");
 const process_admission_1 = require("../process-admission");
@@ -149,7 +158,10 @@ function ensureStdinPipe(stdio) {
     }
     if (Array.isArray(stdio)) {
         return [
-            stdio[0] === 'ignore' ? 'pipe' : (stdio[0] ?? 'pipe'),
+            // The transformed prompt always travels on fd 0. `inherit`,
+            // `overlapped`, numeric fds, and streams leave child.stdin null just as
+            // `ignore` does, so every array form must be upgraded unconditionally.
+            'pipe',
             stdio[1] ?? 'pipe',
             stdio[2] ?? 'pipe',
         ];
@@ -252,10 +264,133 @@ function spawnGemini(args, options = {}) {
     }
     return (0, win_spawn_1.spawnCli)('gemini', args, { ...options, env });
 }
+/**
+ * Extract the JavaScript entry from a standard npm-generated Windows `.cmd`
+ * launcher. npm writes the target as `%dp0%\<package path>.mjs %*`; resolving
+ * that path lets us bypass cmd.exe while preserving the exact argv payload.
+ */
+function parseNpmCmdShimEntry(shimPath, contents) {
+    const match = contents.match(/%dp0%[\\/]([^"\r\n]*?\.(?:mjs|cjs|js))["']?\s+%\*/i);
+    if (!match?.[1])
+        return null;
+    return node_path_1.default.win32.join(node_path_1.default.win32.dirname(shimPath), match[1]);
+}
+/**
+ * Spawn Kimi in daemon-free prompt mode.
+ *
+ * Kimi 0.27 requires `-p <prompt>` and cannot itself read that prompt from
+ * stdin. On Windows, a native executable receives argv directly. For npm's
+ * `.cmd` shim, launch a tiny Node bootstrap that reads the complete prompt from
+ * stdin, restores it into process.argv at the `-p` value slot, then imports the
+ * generated JavaScript entry. This bypasses both cmd.exe newline reparsing and
+ * CreateProcess's ~32K command-line ceiling without changing Kimi semantics.
+ * A non-standard or unreadable command shim fails closed.
+ */
+const KIMI_WINDOWS_ARGV_SAFE_CHARS = 30_000;
+const KIMI_WINDOWS_STDIN_BOOTSTRAP = [
+    'const fs=require("node:fs");',
+    'const {pathToFileURL}=require("node:url");',
+    'const entry=process.argv[1];',
+    'const slot=Number(process.argv[2]);',
+    'const args=process.argv.slice(3);',
+    'args[slot]=fs.readFileSync(0,"utf8");',
+    'process.argv=[process.execPath,entry,...args];',
+    'import(pathToFileURL(entry).href).catch((error)=>{console.error(error);process.exitCode=1;});',
+].join('');
+function kimiPromptValueIndex(args) {
+    const flagIndex = args.indexOf('-p');
+    return flagIndex >= 0 && flagIndex + 1 < args.length ? flagIndex + 1 : -1;
+}
+function estimatedWindowsArgvChars(binary, args) {
+    return binary.length + 1 + args.reduce((total, arg) => total + arg.length + 3, 0);
+}
+function spawnKimi(args, options = {}) {
+    (0, process_admission_1.assertProcessAdmission)();
+    if (!isWin())
+        return (0, win_spawn_1.spawnCli)('kimi', args, options);
+    /* c8 ignore start -- Windows-only branch; unit tests force process.platform */
+    const resolved = (0, win_spawn_1.resolveWindowsBinary)('kimi');
+    const extension = node_path_1.default.win32.extname(resolved).toLowerCase();
+    if (extension !== '.cmd' && extension !== '.bat') {
+        const promptIndex = kimiPromptValueIndex(args);
+        if (promptIndex >= 0 &&
+            estimatedWindowsArgvChars(resolved, args) > KIMI_WINDOWS_ARGV_SAFE_CHARS) {
+            throw new Error(`kimi_windows_native_prompt_too_large:${args[promptIndex].length}: ` +
+                'the native Kimi executable cannot receive this prompt within the Windows ' +
+                'CreateProcess limit; install the npm Kimi Code CLI shim or shorten the prompt.');
+        }
+        return (0, win_spawn_1.spawnCli)(resolved, args, options);
+    }
+    let entry;
+    try {
+        entry = parseNpmCmdShimEntry(resolved, (0, node_fs_1.readFileSync)(resolved, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`unsupported_kimi_windows_shim:${resolved}:` +
+            (error instanceof Error ? error.message : String(error)));
+    }
+    if (!entry) {
+        throw new Error(`unsupported_kimi_windows_shim:${resolved}`);
+    }
+    const localNode = node_path_1.default.win32.join(node_path_1.default.win32.dirname(resolved), 'node.exe');
+    const nodeBinary = (0, node_fs_1.existsSync)(localNode) ? localNode : 'node';
+    const promptIndex = kimiPromptValueIndex(args);
+    if (promptIndex < 0) {
+        return (0, win_spawn_1.spawnCli)(nodeBinary, [entry, ...args], options);
+    }
+    const prompt = args[promptIndex];
+    const forwardedArgs = [...args];
+    // Preserve the exact argv shape for Kimi; the bootstrap replaces only this
+    // placeholder after reading stdin. The real prompt never reaches
+    // CreateProcess, cmd.exe, environment variables, or a temporary file.
+    forwardedArgs[promptIndex] = '';
+    const spawnOptions = {
+        ...options,
+        stdio: ensureStdinPipe(options.stdio),
+    };
+    const child = (0, win_spawn_1.spawnCli)(nodeBinary, [
+        '-e',
+        KIMI_WINDOWS_STDIN_BOOTSTRAP,
+        entry,
+        String(promptIndex),
+        ...forwardedArgs,
+    ], spawnOptions);
+    if (!child.stdin) {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* best-effort */ }
+        throw new Error('kimi_windows_bootstrap_stdin_unavailable');
+    }
+    // A short-lived bootstrap can exit before the buffered write settles.
+    // Without an error listener, the resulting EPIPE is an unhandled EventEmitter
+    // error and can terminate Desktop itself. Broken pipes are already reflected
+    // by the child's terminal status; log any different transport failure.
+    child.stdin.on('error', (error) => {
+        if (error.code === 'EPIPE')
+            return;
+        console.error('[cli-prompt] Kimi Windows prompt transport failed:', error);
+        // A failed transport must never leave the bootstrap free to invoke Kimi
+        // with an empty or partial prompt. Managers will observe the terminated
+        // child through their normal lifecycle/error path.
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* best-effort */ }
+    });
+    try {
+        child.stdin.end(prompt);
+    }
+    catch (error) {
+        if (error?.code !== 'EPIPE')
+            throw error;
+    }
+    return child;
+    /* c8 ignore stop */
+}
 /**
  * Convenience: dispatch on binary name. Use when callsite picks the
- * binary dynamically (claude vs codex vs gemini). Anything else routes through
- * the underlying spawnCli unchanged.
+ * binary dynamically. Anything else routes through the underlying spawnCli.
  */
 function spawnAiCli(binary, args, options = {}) {
     (0, process_admission_1.assertProcessAdmission)();
@@ -265,5 +400,7 @@ function spawnAiCli(binary, args, options = {}) {
         return spawnCodex(args, options);
     if (binary === 'gemini')
         return spawnGemini(args, options);
+    if (binary === 'kimi')
+        return spawnKimi(args, options);
     return (0, win_spawn_1.spawnCli)(binary, args, options);
 }

package/server/dist/util/stream-display.js

@@ -14,6 +14,52 @@ exports.extractDisplayText = extractDisplayText;
  */
 function extractDisplayText(event) {
     const type = event.type;
+    // ── Kimi `--output-format stream-json` ────────────────────────────────
+    // Kimi assistant frames are role-discriminated (no top-level `type`) and
+    // can contain both narration and OpenAI-shaped function calls in one line.
+    if (!type && event.role === 'assistant') {
+        const parts = [];
+        const content = event.content;
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content.map((part) => {
+                    if (typeof part === 'string')
+                        return part;
+                    if (!part || typeof part !== 'object')
+                        return '';
+                    const candidate = part;
+                    return typeof candidate.text === 'string' ? candidate.text : '';
+                }).join('')
+                : '';
+        if (text)
+            parts.push(text);
+        const toolCalls = Array.isArray(event.tool_calls) ? event.tool_calls : [];
+        for (const call of toolCalls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            const fn = call.function;
+            if (!fn || typeof fn !== 'object')
+                continue;
+            const record = fn;
+            const name = typeof record.name === 'string' ? record.name : '<unnamed>';
+            const rawArgs = record.arguments;
+            let args;
+            if (typeof rawArgs === 'string') {
+                args = rawArgs;
+            }
+            else {
+                try {
+                    args = JSON.stringify(rawArgs ?? {});
+                }
+                catch {
+                    args = String(rawArgs ?? '');
+                }
+            }
+            parts.push(`[tool: ${name}] ${args.slice(0, 120)}`);
+        }
+        return parts.join('\n') || null;
+    }
     // ── Claude `--output-format stream-json` ───────────────────────────────
     if (type === 'assistant') {
         const content = event.message;