pikiloom 0.4.43 → 0.4.44

package/dist/agent/kernel-bridge.js

@@ -243,7 +243,15 @@ export async function kernelStream(opts) {
     const u = result.usage || snapshot.usage || {};
     return {
         ok: !!result.ok,
-        message: (result.text || snapshot.text || '').trim() || (finalError ?? '(no output)'),
+        // Empty-text fallback (mirrors the legacy driver): a clean turn with no prose reads
+        // "(no textual response)", not "(no output)" (which the kernel path used to show for every
+        // textless turn — including a background-launch turn that intentionally ends without prose).
+        // A turn that settled while work keeps running in the background gets an explicit note.
+        message: (result.text || snapshot.text || '').trim()
+            || finalError
+            || (result.stopReason === 'background'
+                ? 'Work is now running in the background — I’ll report back here once it finishes. (Send any message to check on it.)'
+                : result.ok ? '(no textual response)' : '(no output)'),
         thinking: (result.reasoning || snapshot.reasoning || '').trim() || null,
         plan: toPikiloomPlan(snapshot.plan),
         sessionId: finalSessionId,

package/dist/bot/commands.js

@@ -3,6 +3,8 @@ import fs from 'node:fs';
 import { fmtTokens, fmtUptime, fmtBytes } from './bot.js';
 import { getProjectSkillPaths, normalizeClaudeModelId, sessionListDisplayTitle, listAllMcpExtensions, listSkills as listAllSkills, } from '../agent/index.js';
 import { getDriver } from '../agent/driver.js';
+import { accountAgentSupported, listAccounts, getActiveAccountId, probeAccountUsage, getCachedAccountUsage, } from '../agent/accounts.js';
+import { withTimeoutFallback } from '../core/utils.js';
 import { effortOptionsFor } from '../core/config/runtime-config.js';
 import { getActiveProfile, getProvider } from '../model/index.js';
 import { buildWelcomeIntro, buildSkillCommandName, indexSkillsByCommand, SKILL_CMD_PREFIX } from './menu.js';
@@ -421,16 +423,53 @@ export async function getModelsListData(bot, chatId) {
         effort: buildEffortData(bot, cs.agent, currentModel),
     };
 }
+// On-demand usage probe per agent. Bounded so `/status` stays snappy: each live probe falls
+// back to the driver's cached value (and each account to its last-probed value) on timeout.
+const USAGE_PROBE_TIMEOUT_MS = 2_500;
+// Mirror the dashboard's top-right usage view for IM `/status`: every installed agent's usage,
+// and for account-capable agents each account's own quota with the active one marked. The plain
+// per-agent `getUsageLive` only ever reads the keychain default login, so without the per-account
+// probes `/status` would always report the default account's numbers, never the selected one.
+export async function getUsageOverview(bot, chatId) {
+    const currentAgent = bot.chat(chatId).agent;
+    const installed = bot.fetchAgents().agents.filter(a => a.installed);
+    const agents = await Promise.all(installed.map(async (info) => {
+        const agent = info.agent;
+        const model = bot.modelForAgent(agent);
+        const driver = getDriver(agent);
+        const cached = driver.getUsage({ agent, model });
+        const usage = driver.getUsageLive
+            ? await withTimeoutFallback(driver.getUsageLive({ agent, model }).catch(() => cached), USAGE_PROBE_TIMEOUT_MS, cached)
+            : cached;
+        const accounts = [];
+        if (accountAgentSupported(agent)) {
+            const recs = listAccounts(agent);
+            if (recs.length) {
+                const activeId = getActiveAccountId(agent);
+                const usages = await Promise.all(recs.map(rec => withTimeoutFallback(probeAccountUsage(agent, rec.id).catch(() => getCachedAccountUsage(agent, rec.id)), USAGE_PROBE_TIMEOUT_MS, getCachedAccountUsage(agent, rec.id))));
+                recs.forEach((rec, i) => accounts.push({
+                    id: rec.id, label: rec.label, active: rec.id === activeId, usage: usages[i],
+                }));
+                accounts.push({ id: null, label: 'Default login', active: activeId === null, usage });
+            }
+        }
+        return { agent, label: agentDisplayLabel(agent), isCurrent: agent === currentAgent, usage, accounts };
+    }));
+    return { agents };
+}
 export async function getStatusDataAsync(bot, chatId) {
     const d = bot.getStatusData(chatId);
-    const driver = getDriver(d.agent);
-    const usage = driver.getUsageLive
-        ? await driver.getUsageLive({ agent: d.agent, model: d.model }).catch(() => d.usage)
-        : d.usage;
+    const usageOverview = await getUsageOverview(bot, chatId);
+    // Surface the identity that is actually selected: the active account's quota when one is
+    // bound, else the agent's native/default-login usage (matches the dashboard ring).
+    const current = usageOverview.agents.find(a => a.isCurrent);
+    const activeAccount = current?.accounts.find(a => a.active);
+    const usage = (activeAccount?.usage?.ok ? activeAccount.usage : null) ?? current?.usage ?? d.usage;
     return {
         ...d,
         running: d.running ? { prompt: d.running.prompt, startedAt: d.running.startedAt } : null,
         usage,
+        usageOverview,
         git: readGitStatus(d.workdir),
     };
 }

package/dist/bot/render-shared.js

@@ -93,35 +93,41 @@ export function trimActivityForPreview(text, maxChars = 900) {
         return tail.join('\n');
     return [ellipsis, ...tail].join('\n');
 }
-function rawUsageLine(parts) {
-    return parts.filter(part => !!part && String(part).trim()).join(' ');
+// Compact "5h 42% · 7d 18%" summary of a usage snapshot (matches the dashboard bars and the
+// `/agents` account rows), or a short reason when no quota numbers are available.
+export function formatUsageWindowsSummary(usage) {
+    if (!usage || !usage.ok)
+        return 'unavailable';
+    const parts = usage.windows
+        .filter(w => w.usedPercent != null)
+        .map(w => `${w.label} ${Math.round(w.usedPercent)}%`);
+    if (parts.length)
+        return parts.join(' · ');
+    return usage.status ? `status=${usage.status}` : 'no data';
 }
-export function buildProviderUsageLines(usage) {
+// Multi-agent / multi-account usage block for `/status`, mirroring the dashboard's top-right
+// view: each installed agent that has usage, and for account-capable agents every account's own
+// quota with the active one marked (●). Returns [] when nothing has usage so callers can skip the
+// section entirely. Leading blank + bold header follow the same shape callers already render.
+export function buildUsageOverviewLines(overview) {
+    const shown = overview.agents.filter(a => (a.usage?.ok && a.usage.windows.length) || a.accounts.length);
+    if (!shown.length)
+        return [];
     const lines = [
         { text: '', bold: false },
         { text: 'Provider Usage', bold: true },
     ];
-    if (!usage.ok) {
-        lines.push({ text: `  Unavailable: ${usage.error || 'No recent usage data found.'}` });
-        return lines;
-    }
-    if (usage.capturedAt) {
-        const capturedAtMs = Date.parse(usage.capturedAt);
-        if (Number.isFinite(capturedAtMs)) {
-            lines.push({ text: `  Updated: ${fmtUptime(Math.max(0, Date.now() - capturedAtMs))} ago` });
+    for (const agent of shown) {
+        lines.push({ text: `${agent.label}${agent.isCurrent ? ' (current)' : ''}`, bold: true });
+        if (agent.accounts.length) {
+            for (const account of agent.accounts) {
+                const mark = account.active ? '●' : '○';
+                lines.push({ text: `  ${mark} ${account.label}: ${formatUsageWindowsSummary(account.usage)}` });
+            }
+        }
+        else {
+            lines.push({ text: `  ${formatUsageWindowsSummary(agent.usage)}` });
         }
-    }
-    if (!usage.windows.length) {
-        lines.push({ text: `  ${usage.status ? `status=${usage.status}` : 'No window data'}` });
-        return lines;
-    }
-    for (const window of usage.windows) {
-        const details = rawUsageLine([
-            window.usedPercent != null ? `${window.usedPercent}% used` : null,
-            window.status ? `status=${window.status}` : null,
-            window.resetAfterSeconds != null ? `resetAfterSeconds=${window.resetAfterSeconds}` : null,
-        ]);
-        lines.push({ text: `  ${window.label}: ${details || 'No details'}` });
     }
     return lines;
 }

package/dist/channels/dingtalk/bot.js

@@ -7,6 +7,7 @@ import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { buildUsageOverviewLines } from '../../bot/render-shared.js';
 import { DingtalkChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -209,6 +210,8 @@ export class DingtalkBot extends Bot {
         ];
         if (d.running)
             lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
+        for (const line of buildUsageOverviewLines(d.usageOverview))
+            lines.push(line.text);
         await ctx.reply(lines.join('\n'));
     }
     async cmdHost(ctx) {

package/dist/channels/discord/bot.js

@@ -7,6 +7,7 @@ import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { buildUsageOverviewLines } from '../../bot/render-shared.js';
 import { DiscordChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -201,6 +202,8 @@ export class DiscordBot extends Bot {
         ];
         if (d.running)
             lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
+        for (const line of buildUsageOverviewLines(d.usageOverview))
+            lines.push(line.text);
         await ctx.reply(lines.join('\n'));
     }
     async cmdHost(ctx) {

package/dist/channels/feishu/render.js

@@ -1,7 +1,7 @@
 import { encodeCommandAction } from '../../bot/command-ui.js';
 import { fmtUptime, fmtTokens, fmtBytes, formatGitStatusLine } from '../../bot/bot.js';
 import { summarizePromptForStatus } from '../../bot/commands.js';
-import { footerStatusSymbol, formatFooterParts, trimActivityForPreview, buildProviderUsageLines, extractFinalReplyData, extractStreamPreviewData, } from '../../bot/render-shared.js';
+import { footerStatusSymbol, formatFooterParts, trimActivityForPreview, buildUsageOverviewLines, extractFinalReplyData, extractStreamPreviewData, } from '../../bot/render-shared.js';
 export { dispatchImageBlocks } from '../../bot/render-shared.js';
 import { currentHumanLoopQuestion, humanLoopAnsweredCount, isHumanLoopAwaitingText, isHumanLoopQuestionAnswered, summarizeHumanLoopAnswer, } from '../../bot/human-loop.js';
 import path from 'node:path';
@@ -432,12 +432,8 @@ export function renderStatus(d) {
     if (d.running) {
         lines.push(`**Running:** ${fmtUptime(Date.now() - d.running.startedAt)} - ${summarizePromptForStatus(d.running.prompt)}`);
     }
-    const usageLines = buildProviderUsageLines(d.usage);
-    if (usageLines.length > 1) {
-        lines.push('');
-        for (const line of usageLines) {
-            lines.push(line.text);
-        }
+    for (const line of buildUsageOverviewLines(d.usageOverview)) {
+        lines.push(line.bold && line.text ? `**${line.text}**` : line.text);
     }
     lines.push('', '**Bot Usage**', `  Turns: ${d.stats.totalTurns}`);
     if (d.stats.totalInputTokens || d.stats.totalOutputTokens) {

package/dist/channels/slack/bot.js

@@ -7,6 +7,7 @@ import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { buildUsageOverviewLines } from '../../bot/render-shared.js';
 import { SlackChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -210,6 +211,8 @@ export class SlackBot extends Bot {
         ];
         if (d.running)
             lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
+        for (const line of buildUsageOverviewLines(d.usageOverview))
+            lines.push(line.text);
         await ctx.reply(lines.join('\n'));
     }
     async cmdHost(ctx) {

package/dist/channels/telegram/bot.js

@@ -12,7 +12,7 @@ import { buildAgentsCommandView, buildModelsCommandView, buildModeCommandView, b
 import { buildSwitchWorkdirView, buildWorkspacesView, resolveRegisteredPath } from './directory.js';
 import { LivePreview } from './live-preview.js';
 import { registerProcessRuntime, buildRestartCommand, requestProcessRestart, } from '../../core/process-control.js';
-import { buildInitialPreviewHtml, buildHumanLoopPromptHtml, buildAnsweredHumanLoopPromptHtml, buildStreamPreviewHtml, buildFinalReplyRender, dispatchImageBlocks, escapeHtml, formatMenuLines, formatProviderUsageLines, renderCommandNoticeHtml, renderCommandSelectionHtml, renderCommandSelectionKeyboard, renderSessionTurnHtml, truncateMiddle, unpackCallbackData, } from './render.js';
+import { buildInitialPreviewHtml, buildHumanLoopPromptHtml, buildAnsweredHumanLoopPromptHtml, buildStreamPreviewHtml, buildFinalReplyRender, dispatchImageBlocks, escapeHtml, formatMenuLines, formatUsageOverviewLines, renderCommandNoticeHtml, renderCommandSelectionHtml, renderCommandSelectionKeyboard, renderSessionTurnHtml, truncateMiddle, unpackCallbackData, } from './render.js';
 import { currentHumanLoopQuestion, humanLoopOptionSelected } from '../../bot/human-loop.js';
 import { TelegramChannel } from './channel.js';
 import { splitText, supportsChannelCapability } from '../base.js';
@@ -344,7 +344,7 @@ export class TelegramBot extends Bot {
         if (d.running) {
             lines.push(`<b>Running:</b> ${fmtUptime(Date.now() - d.running.startedAt)} - ${escapeHtml(summarizePromptForStatus(d.running.prompt))}`);
         }
-        lines.push(...formatProviderUsageLines(d.usage), '', '<b>Bot Usage</b>', `  Turns: ${d.stats.totalTurns}`);
+        lines.push(...formatUsageOverviewLines(d.usageOverview), '', '<b>Bot Usage</b>', `  Turns: ${d.stats.totalTurns}`);
         if (d.stats.totalInputTokens || d.stats.totalOutputTokens) {
             lines.push(`  In: ${fmtTokens(d.stats.totalInputTokens)}  Out: ${fmtTokens(d.stats.totalOutputTokens)}`);
             if (d.stats.totalCachedTokens)

package/dist/channels/telegram/render.js

@@ -1,6 +1,6 @@
 import { encodeCommandAction } from '../../bot/command-ui.js';
 import { currentHumanLoopQuestion, humanLoopAnsweredCount, isHumanLoopAwaitingText, isHumanLoopQuestionAnswered, summarizeHumanLoopAnswer, } from '../../bot/human-loop.js';
-import { footerStatusSymbol, formatFooterParts, trimActivityForPreview, buildProviderUsageLines, extractFinalReplyData, extractStreamPreviewData, parseGfmTable, } from '../../bot/render-shared.js';
+import { footerStatusSymbol, formatFooterParts, trimActivityForPreview, buildUsageOverviewLines, extractFinalReplyData, extractStreamPreviewData, parseGfmTable, } from '../../bot/render-shared.js';
 export { dispatchImageBlocks } from '../../bot/render-shared.js';
 export function escapeHtml(t) {
     return t.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
@@ -308,8 +308,8 @@ function formatFinalFooterHtml(status, agent, elapsedMs, contextPercent, decorat
     const primary = escapeHtml(`${footerStatusSymbol(status)} ${parts.identity}`);
     return `${primary}\n<i>${escapeHtml(parts.runtime)}</i>`;
 }
-export function formatProviderUsageLines(usage) {
-    return buildProviderUsageLines(usage).map(line => line.bold ? `<b>${escapeHtml(line.text)}</b>` : escapeHtml(line.text));
+export function formatUsageOverviewLines(overview) {
+    return buildUsageOverviewLines(overview).map(line => line.bold ? `<b>${escapeHtml(line.text)}</b>` : escapeHtml(line.text));
 }
 export function buildInitialPreviewHtml(agent, modelOrWaiting, effortOrQueuePosition, waitingArg = false, queuePositionArg = 0) {
     let model = null;

package/dist/channels/wecom/bot.js

@@ -7,6 +7,7 @@ import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { buildUsageOverviewLines } from '../../bot/render-shared.js';
 import { WeComChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -217,6 +218,8 @@ export class WeComBot extends Bot {
         ];
         if (d.running)
             lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
+        for (const line of buildUsageOverviewLines(d.usageOverview))
+            lines.push(line.text);
         await ctx.reply(lines.join('\n'));
     }
     async cmdHost(ctx) {

package/dist/channels/weixin/bot.js

@@ -9,6 +9,7 @@ import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, handleGoalCommand, } from '../../bot/commands.js';
+import { buildUsageOverviewLines } from '../../bot/render-shared.js';
 import { WeixinChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -254,6 +255,8 @@ export class WeixinBot extends Bot {
         if (d.running) {
             lines.push(`Running: ${fmtUptime(Date.now() - d.running.startedAt)}`);
         }
+        for (const line of buildUsageOverviewLines(d.usageOverview))
+            lines.push(line.text);
         await ctx.reply(lines.join('\n'));
     }
     async cmdHost(ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.43",
+  "version": "0.4.44",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/drivers/claude.d.ts

@@ -30,6 +30,15 @@ export declare function claudeUsageOf(s: ClaudeUsageState): UniversalUsage;
 export declare function claudeContextWindowFromModel(model: unknown): number | null;
 export declare function claudeEffectiveContextWindow(advertised: number | null): number | null;
 export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent) => void): void;
+export declare function claudeBgHoldCapMs(): number;
+export declare function isTerminalTaskStatus(status: unknown): boolean;
+export declare function trackClaudeBackgroundTask(ev: any, s: any): void;
+export declare function pendingClaudeBackgroundTasks(s: any): number;
+export type ClaudeResultSettleDecision = 'settle' | 'hold';
+export declare function decideClaudeResultSettle(input: {
+    hasError: boolean;
+    pendingBackground: number;
+}): ClaudeResultSettleDecision;
 export declare function claudeUserMessage(text: string, attachments?: string[]): string;
 export declare function emitClaudeImages(blocks: any[], s: any, emit: (e: DriverEvent) => void): void;
 export declare function todoWriteToPlan(input: any): UniversalPlan | null;

package/packages/kernel/dist/drivers/claude.js

@@ -30,10 +30,14 @@ export class ClaudeDriver {
     }
     run(input, ctx) {
         const steerable = !!input.steerable;
-        // Image attachments must ride a stream-json user message (text-only stdin can't carry images),
-        // so enable that input mode whenever there are attachments, not just for mid-turn steering.
-        const useStreamJson = steerable || !!input.attachments?.length;
-        const args = ['-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
+        // Always drive Claude over a stream-json stdin and keep that stdin OPEN for the whole turn.
+        // That open stdin is what lets Claude's native "launch detached background work → end the
+        // turn → wake itself up and report when the work finishes" flow play out: it only happens
+        // while stdin stays open (with it closed, Claude exits at the first `result` and the wake-up
+        // — and any in-process background agent/workflow — is lost). Image attachments also need the
+        // stream-json user message (a plain text stdin can't carry images). `--replay-user-messages`
+        // + registerSteer remain the only mid-turn-steer-specific bits.
+        const args = ['-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--input-format', 'stream-json'];
         if (input.model)
             args.push('--model', input.model);
         if (input.effort)
@@ -46,8 +50,6 @@ export class ClaudeDriver {
             args.push('--mcp-config', input.mcpConfigPath);
         if (input.permissionMode)
             args.push('--permission-mode', input.permissionMode); // parity: keep bypass/accept-edits on the kernel path
-        if (useStreamJson)
-            args.push('--input-format', 'stream-json');
         if (steerable)
             args.push('--replay-user-messages'); // parity: mid-turn steer
         if (input.extraArgs?.length)
@@ -64,26 +66,54 @@ export class ClaudeDriver {
             taskList: new Map(),
             taskOrder: [],
             pendingTaskCreates: new Map(),
+            // run_in_background lifecycle: task ids seen as started vs. reached a terminal status.
+            bgStarted: new Set(), bgTerminal: new Set(),
         };
         return new Promise((resolve) => {
             let child;
             let settled = false;
-            const finish = (r) => {
+            let holdCapTimer = null;
+            const usageOf = () => this.usage(state);
+            const clearHoldCap = () => { if (holdCapTimer) {
+                clearTimeout(holdCapTimer);
+                holdCapTimer = null;
+            } };
+            // kill=true SIGTERMs immediately — fast exit, used once nothing is left running in the
+            // background (a normal turn, or a wake-up turn after every background task finished).
+            // kill=false only ends stdin and lets Claude shut down on its own, so any still-running
+            // detached background work survives a clean exit (a hard kill mid-flight is exactly what
+            // tore the background — and the wake-up — down before). A leak-guard SIGTERM is the backstop.
+            const finish = (r, kill = true) => {
                 if (settled)
                     return;
                 settled = true;
+                clearHoldCap();
                 try {
                     child?.stdin?.end();
                 }
                 catch { /* ignore */ }
-                if (steerable) {
-                    try {
-                        child?.kill('SIGTERM');
+                if (!child.killed && child.exitCode == null) {
+                    if (kill) {
+                        try {
+                            child.kill('SIGTERM');
+                        }
+                        catch { /* ignore */ }
+                    }
+                    else {
+                        const guard = setTimeout(() => { try {
+                            child?.kill('SIGTERM');
+                        }
+                        catch { /* ignore */ } }, CLAUDE_EXIT_LEAK_GUARD_MS);
+                        if (typeof guard.unref === 'function')
+                            guard.unref();
                     }
-                    catch { /* ignore */ }
-                } // replay mode keeps the process alive past the turn
+                }
                 resolve(r);
             };
+            const settleResult = (opts = {}) => finish({
+                ok: !state.error, text: state.text, reasoning: state.reasoning || undefined,
+                error: state.error, stopReason: opts.stopReason ?? state.stopReason, sessionId: state.sessionId, usage: usageOf(),
+            }, opts.kill ?? true);
             try {
                 child = spawn(this.bin, args, { cwd: input.workdir, env: { ...process.env, ...(input.env || {}) }, stdio: ['pipe', 'pipe', 'pipe'] });
             }
@@ -110,14 +140,17 @@ export class ClaudeDriver {
                     }
                 });
             }
-            const usageOf = () => this.usage(state);
             let buf = '';
             let stderr = '';
             child.stdout.on('data', (chunk) => {
+                if (settled)
+                    return; // ignore the process's post-settle shutdown chatter
                 buf += chunk.toString('utf8');
                 const lines = buf.split('\n');
                 buf = lines.pop() || '';
                 for (const line of lines) {
+                    if (settled)
+                        return;
                     const trimmed = line.trim();
                     if (!trimmed)
                         continue;
@@ -129,32 +162,42 @@ export class ClaudeDriver {
                         continue;
                     }
                     handleClaudeEvent(ev, state, ctx.emit);
-                    if (steerable && ev.type === 'result') {
-                        // In replay mode the turn ends on `result` but the process lingers; settle now.
-                        finish({ ok: !state.error, text: state.text, reasoning: state.reasoning || undefined, error: state.error, stopReason: state.stopReason, sessionId: state.sessionId, usage: usageOf() });
+                    if (ev.type !== 'result')
+                        continue;
+                    const hasError = !!ev.is_error || (Array.isArray(ev.errors) && ev.errors.length > 0) || !!state.error;
+                    const pending = pendingClaudeBackgroundTasks(state);
+                    if (decideClaudeResultSettle({ hasError, pendingBackground: pending }) === 'hold') {
+                        // Background work is still running: do NOT end the turn here. Keep stdin open so Claude
+                        // wakes itself up and streams a follow-up turn reporting the finished work — we settle
+                        // on THAT result (pending back to 0). A cap bounds the wait so a never-completing daemon
+                        // (e.g. a dev server) eventually settles (graceful, no kill) instead of holding forever.
+                        if (!holdCapTimer) {
+                            holdCapTimer = setTimeout(() => { if (!settled)
+                                settleResult({ stopReason: 'background', kill: false }); }, claudeBgHoldCapMs());
+                            if (typeof holdCapTimer.unref === 'function')
+                                holdCapTimer.unref();
+                        }
+                        continue;
                     }
+                    settleResult();
                 }
             });
             child.stderr.on('data', (c) => { stderr += c.toString('utf8'); });
             child.on('error', (err) => finish({ ok: false, text: state.text, error: `claude spawn error: ${err.message}`, stopReason: 'error' }));
             child.on('close', (code) => {
+                if (settled)
+                    return;
                 if (ctx.signal.aborted) {
-                    finish({ ok: false, text: state.text, reasoning: state.reasoning, error: 'Interrupted by user.', stopReason: 'interrupted', sessionId: state.sessionId, usage: usageOf() });
+                    finish({ ok: false, text: state.text, reasoning: state.reasoning, error: 'Interrupted by user.', stopReason: 'interrupted', sessionId: state.sessionId, usage: usageOf() }, false);
                     return;
                 }
                 const ok = !state.error && code === 0;
-                finish({ ok, text: state.text, reasoning: state.reasoning || undefined, error: state.error || (ok ? null : `claude exited ${code}${stderr ? `: ${stderr.slice(0, 300)}` : ''}`), stopReason: state.stopReason, sessionId: state.sessionId, usage: usageOf() });
+                finish({ ok, text: state.text, reasoning: state.reasoning || undefined, error: state.error || (ok ? null : `claude exited ${code}${stderr ? `: ${stderr.slice(0, 300)}` : ''}`), stopReason: state.stopReason, sessionId: state.sessionId, usage: usageOf() }, false);
             });
             try {
-                if (useStreamJson) {
-                    child.stdin.write(claudeUserMessage(input.prompt, input.attachments) + '\n');
-                    if (!steerable)
-                        child.stdin.end(); // single turn; steer mode keeps stdin open for replay
-                }
-                else {
-                    child.stdin.write(input.prompt);
-                    child.stdin.end();
-                }
+                // Send the prompt as a stream-json user message and keep stdin OPEN (do not end it here):
+                // closing it makes Claude exit at the first `result`, before any background task finishes.
+                child.stdin.write(claudeUserMessage(input.prompt, input.attachments) + '\n');
             }
             catch { /* ignore */ }
         });
@@ -228,6 +271,7 @@ export function handleClaudeEvent(ev, s, emit) {
         return;
     }
     if (t === 'system') {
+        trackClaudeBackgroundTask(ev, s);
         if (ev.session_id && ev.session_id !== s.sessionId) {
             s.sessionId = ev.session_id;
             emit({ type: 'session', sessionId: ev.session_id });
@@ -442,6 +486,62 @@ export function handleClaudeEvent(ev, s, emit) {
         return;
     }
 }
+// ── run_in_background lifecycle (background → wake-up) ───────────────────────────────────
+// Claude streams a structured lifecycle for detached background work as `system` sub-events:
+//   { subtype:'task_started',      task_id, tool_use_id, description }   ← launched
+//   { subtype:'task_updated',      task_id, patch:{ status } }           ← progress / terminal
+//   { subtype:'task_notification', task_id, status }                     ← terminal (completed/killed/…)
+// A task counts as pending from task_started until a terminal task_updated/task_notification.
+// While any are pending the driver keeps the turn alive instead of ending it at `result`, so
+// Claude's own background→wake-up turn (which reports the finished work) can stream in. Pure +
+// exported for hermetic testing.
+// How long, with no settle, to keep holding a turn open for a background task to finish and
+// trigger Claude's wake-up turn, before giving up (so a never-completing daemon doesn't hang
+// the turn forever). Override with PIKILOOM_CLAUDE_BG_HOLD_MS.
+const CLAUDE_BG_HOLD_CAP_DEFAULT_MS = 10 * 60_000;
+export function claudeBgHoldCapMs() {
+    const raw = Number(process.env.PIKILOOM_CLAUDE_BG_HOLD_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_BG_HOLD_CAP_DEFAULT_MS;
+}
+// After we settle a held turn gracefully (stdin closed, no kill), force-kill the lingering
+// process only if it hasn't exited on its own within this window. Backstop against leaks.
+const CLAUDE_EXIT_LEAK_GUARD_MS = 15_000;
+export function isTerminalTaskStatus(status) {
+    return /^(complete|done|success|succeed|finish|kill|fail|error|stop|cancel|abort|timed?_?out|timeout)/i
+        .test(String(status ?? '').trim());
+}
+export function trackClaudeBackgroundTask(ev, s) {
+    const subtype = ev?.subtype;
+    if (subtype !== 'task_started' && subtype !== 'task_updated' && subtype !== 'task_notification')
+        return;
+    const id = String(ev?.task_id ?? ev?.tool_use_id ?? '').trim();
+    if (!id)
+        return;
+    if (subtype === 'task_started') {
+        (s.bgStarted ||= new Set()).add(id);
+        return;
+    }
+    if (isTerminalTaskStatus(ev?.patch?.status ?? ev?.status))
+        (s.bgTerminal ||= new Set()).add(id);
+}
+export function pendingClaudeBackgroundTasks(s) {
+    const started = s?.bgStarted;
+    if (!started?.size)
+        return 0;
+    const terminal = s?.bgTerminal;
+    let n = 0;
+    for (const id of started)
+        if (!terminal?.has(id))
+            n++;
+    return n;
+}
+// At a `result` event: settle the turn normally, unless background work is still running
+// (then hold the process open for the wake-up). Errors always settle.
+export function decideClaudeResultSettle(input) {
+    if (input.hasError)
+        return 'settle';
+    return input.pendingBackground > 0 ? 'hold' : 'settle';
+}
 // Claude vision input formats (matches the legacy driver / Anthropic API: png, jpeg, gif, webp).
 const CLAUDE_IMAGE_MIME = {
     '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',

package/packages/kernel/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { SessionStore, CoreSessionRecord, ModelResolver, ModelInjection, To
 export type { LoomIO, PromptInput, Surface, SurfaceCapabilities, Plugin, SpawnContribution, } from './contracts/surface.js';
 export { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, AutoCancelInteractionHandler, DeferToTerminalInteractionHandler, NoopCatalog, defaultBaseDir, } from './ports/defaults.js';
 export { EchoDriver } from './drivers/echo.js';
-export { ClaudeDriver } from './drivers/claude.js';
+export { ClaudeDriver, isTerminalTaskStatus, trackClaudeBackgroundTask, pendingClaudeBackgroundTasks, decideClaudeResultSettle, claudeBgHoldCapMs, type ClaudeResultSettleDecision, } from './drivers/claude.js';
 export { CodexDriver } from './drivers/codex.js';
 export { GeminiDriver } from './drivers/gemini.js';
 export { AcpDriver, type AcpDriverConfig } from './drivers/acp.js';

package/packages/kernel/dist/index.js

@@ -19,7 +19,7 @@ export { attachTui } from './runtime/tui.js';
 export { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, AutoCancelInteractionHandler, DeferToTerminalInteractionHandler, NoopCatalog, defaultBaseDir, } from './ports/defaults.js';
 // Drivers & surfaces (also available via subpath exports)
 export { EchoDriver } from './drivers/echo.js';
-export { ClaudeDriver } from './drivers/claude.js';
+export { ClaudeDriver, isTerminalTaskStatus, trackClaudeBackgroundTask, pendingClaudeBackgroundTasks, decideClaudeResultSettle, claudeBgHoldCapMs, } from './drivers/claude.js';
 export { CodexDriver } from './drivers/codex.js';
 export { GeminiDriver } from './drivers/gemini.js';
 export { AcpDriver } from './drivers/acp.js';