@love-moon/ai-sdk 0.16.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @love-moon/ai-sdk
 
+## 0.17.1
+
+### Patch Changes
+
+- 7e92c0f: When a task's model quota runs out ("You've hit your session limit · resets
+  1:20am"), fire no longer stops there. It reads the reset time, schedules a
+  one-off Conductor scheduled message to continue a minute or few after the
+  reset, and posts a single notice. Messages that arrive while waiting are queued
+  and handed to the resume turn together instead of each failing with another
+  "处理失败". The resume shows up in the task's scheduled-message list, where it
+  can be canceled. This also covers a quota hit while Claude works on its own
+  between user turns: ai-sdk now reports such a background turn that ends in an
+  error result (or a process exit after it) as a failed turn.
+
+## 0.17.0
+
+### Patch Changes
+
+- d088b31: Claude tasks keep one Claude process per session, with its input left open
+  between turns, instead of starting a new one-shot process for every turn.
+  Background subagents now run to completion: before, claude killed them 10
+  minutes after the main agent's turn ended, so long multi-agent tasks went quiet
+  until the user sent another message. When they finish, Claude's follow-up reply
+  is posted to the chat without waiting for a user message. Subagent narration is
+  no longer posted as a task reply.
+- 79ca552: Claude no longer switches to `acceptEdits` mode when the daemon runs as root.
+  That fallback looked like it worked, but in a headless task it silently refused
+  every shell command (ssh, rsync, ...) and every read outside the project. Claude
+  now keeps `bypassPermissions` everywhere. As root without `IS_SANDBOX=1`, the
+  chat shows a warning right after "session started" telling you to add
+  `envs: { IS_SANDBOX: "1" }` to the conductor config (or run the daemon as a
+  regular user). Terminal tasks print the same hint. An `IS_SANDBOX` set in config
+  `envs` now also reaches terminal (PTY) claude tasks. `conductor config` always
+  writes `--dangerously-skip-permissions` for claude.
+- ccbfeeb: Kimi Code tasks no longer kill background subagents after 12 minutes. `kimi -p`
+  stays silent while it waits for a task it launched with `run_in_background`,
+  and the session's idle deadline used to treat that silence as a stuck turn and
+  terminate kimi together with the task. Once a turn launches a background task,
+  the deadline now waits for kimi to exit on its own.
+
 ## 0.16.0
 
 ### Patch Changes

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
 export { PROVIDER_MEDIA_CAPABILITIES } from "./media-adapters.js";
 export { summarizeTurnUsage } from "./turn-usage.js";
 export { createAiSession, RemoteAiSession } from "./client.js";
-export { isClaudeRootPermissionRestricted, resolveClaudeCommandForRoot, resolveClaudePermissionPolicy } from "./providers/claude-agent-sdk-session.js";
+export { isClaudeRootPermissionRestricted, buildClaudeRootSandboxNotice, claudeCommandNeedsRootSandbox, resolveClaudePermissionPolicy } from "./providers/claude-agent-sdk-session.js";
 export { appendContextFilesToPrompt, normalizeContextFiles } from "./context-files.js";
 export { assertMediaCapabilities, fileMediaToBase64, fileMediaToDataUri, normalizeMediaInputs, resolveTurnMedia } from "./media-input.js";
 export { GOAL_STATUSES, TERMINAL_GOAL_STATUSES, isGoalStatus, isTerminalGoalStatus } from "./shared.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { createAiSession, RemoteAiSession } from "./client.js";
 export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
 export { PROVIDER_MEDIA_CAPABILITIES } from "./media-adapters.js";
-export { isClaudeRootPermissionRestricted, resolveClaudeCommandForRoot, resolveClaudePermissionPolicy, } from "./providers/claude-agent-sdk-session.js";
+export { isClaudeRootPermissionRestricted, buildClaudeRootSandboxNotice, claudeCommandNeedsRootSandbox, resolveClaudePermissionPolicy, } from "./providers/claude-agent-sdk-session.js";
 export { appendContextFilesToPrompt, normalizeContextFiles } from "./context-files.js";
 export { summarizeTurnUsage } from "./turn-usage.js";
 export { assertMediaCapabilities, fileMediaToBase64, fileMediaToDataUri, normalizeMediaInputs, resolveTurnMedia, } from "./media-input.js";

package/dist/providers/claude-agent-sdk-session.d.ts

@@ -2,10 +2,11 @@ export function isClaudeRootPermissionRestricted(env?: NodeJS.ProcessEnv): boole
 export function resolveClaudePermissionPolicy(options?: {}, env?: NodeJS.ProcessEnv): {
     permissionMode: string;
     allowDangerouslySkipPermissions: boolean;
-    downgradedFrom: string;
+    rootSandboxRequired: boolean;
     invalidMode: any;
 };
-export function resolveClaudeCommandForRoot(commandLine: any, env?: NodeJS.ProcessEnv): string;
+export function claudeCommandNeedsRootSandbox(commandLine: any, env?: NodeJS.ProcessEnv): boolean;
+export function buildClaudeRootSandboxNotice({ configFile }?: {}): string;
 export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     static capabilities: Readonly<{
         goal: true;
@@ -45,7 +46,10 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     lastReplyTarget: string;
     manualResumeReady: boolean;
     currentTurn: {
-        abortController: AbortController;
+        abortController: null;
+        liveQuery: null;
+        onProgress: null;
+        settle: null;
         suppressReply: boolean;
         compactMetadata: null;
         compactError: string;
@@ -56,7 +60,27 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
         query: null;
         resultMessage: null;
         terminalWorkingStatusEmitted: boolean;
+        usageBase: null;
         usageByMessageId: Map<any, any>;
+        uuid: string;
+    } | null;
+    liveQuery: {
+        abortController: AbortController;
+        backgroundTurn: null;
+        ended: boolean;
+        input: {
+            push(message: any): boolean;
+            close: () => void;
+            [Symbol.asyncIterator](): {
+                next: () => Promise<any>;
+                return: () => Promise<{
+                    value: undefined;
+                    done: boolean;
+                }>;
+            };
+        };
+        query: null;
+        usageBase: null;
     } | null;
     lastResult: any;
     rateLimitInfo: any;
@@ -69,9 +93,10 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     permissionPolicy: {
         permissionMode: string;
         allowDangerouslySkipPermissions: boolean;
-        downgradedFrom: string;
+        rootSandboxRequired: boolean;
         invalidMode: any;
     };
+    notices: string[];
     writeLog(message: any): void;
     trace(message: any): void;
     get threadId(): any;
@@ -103,6 +128,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
                 image: "native";
             }>;
         };
+        notices: string[];
     };
     getSessionInfo(): {
         backend: string;
@@ -165,6 +191,65 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
         onProgress: any;
     }): Promise<void>;
     interruptCurrentTurn(): Promise<boolean>;
+    createTurnState({ suppressReply, onProgress }?: {
+        suppressReply?: boolean | undefined;
+        onProgress?: null | undefined;
+    }): {
+        abortController: null;
+        liveQuery: null;
+        onProgress: null;
+        settle: null;
+        suppressReply: boolean;
+        compactMetadata: null;
+        compactError: string;
+        conversationReset: string;
+        emittedAssistantMessage: boolean;
+        fullText: string;
+        items: never[];
+        query: null;
+        resultMessage: null;
+        terminalWorkingStatusEmitted: boolean;
+        usageBase: null;
+        usageByMessageId: Map<any, any>;
+        uuid: string;
+    };
+    /**
+     * One claude process per session, fed through a prompt stream that stays
+     * open between turns. A one-shot string prompt closes claude's input at once,
+     * and claude then kills background subagents 10 minutes after the main
+     * agent's turn ends (CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS). Kept open, the
+     * subagents run to completion and claude starts its own follow-up turn on
+     * their notifications.
+     */
+    ensureLiveQuery(sdkModule: any): {
+        abortController: AbortController;
+        backgroundTurn: null;
+        ended: boolean;
+        input: {
+            push(message: any): boolean;
+            close: () => void;
+            [Symbol.asyncIterator](): {
+                next: () => Promise<any>;
+                return: () => Promise<{
+                    value: undefined;
+                    done: boolean;
+                }>;
+            };
+        };
+        query: null;
+        usageBase: null;
+    };
+    closeLiveQuery(liveQuery: any): void;
+    settleTurn(turn: any, error: any, resultMessage?: null): void;
+    pumpLiveQuery(liveQuery: any): Promise<void>;
+    /**
+     * Routes the long-lived query's output. A result ends the pending turn when it
+     * echoes that turn's user message uuid (or echoes none while no follow-up turn
+     * of claude's own is running); everything else is a background turn, e.g.
+     * claude answering a finished subagent's notification between user turns.
+     */
+    dispatchLiveMessage(liveQuery: any, message: any): Promise<void>;
+    finishBackgroundTurn(backgroundTurn: any, resultMessage: any, failure?: null): Promise<void>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

package/dist/providers/claude-agent-sdk-session.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { CLAUDE_AGENT_SDK_VARIANT as CLAUDE_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { appendContextFilesToPrompt } from "../context-files.js";
@@ -7,24 +8,89 @@ import { emitLog, extractLongFlagFromCommandLine, getBoundedEnvInt, isGoalStatus
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+// How long an interrupted turn of the long-lived query may take to report its
+// result before the process is torn down instead.
+const INTERRUPT_GRACE_MS = 10 * 1000;
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const PERMISSION_MODES = new Set(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk"]);
 const DEFAULT_PERMISSION_MODE = "bypassPermissions";
-// Auto ("accept edits") mode: the strongest mode claude allows as root.
-const ROOT_PERMISSION_MODE = "acceptEdits";
 function waitForever() {
     return new Promise(() => { });
 }
-async function* buildClaudeInput(promptText, media) {
-    yield {
+function buildClaudeUserMessage(promptText, media, uuid) {
+    return {
         type: "user",
         message: {
             role: "user",
-            content: buildClaudeContent(promptText, media),
+            content: media.length ? buildClaudeContent(promptText, media) : promptText,
         },
         parent_tool_use_id: null,
+        ...(uuid ? { uuid } : {}),
     };
 }
+async function* buildClaudeInput(promptText, media) {
+    yield buildClaudeUserMessage(promptText, media);
+}
+/**
+ * The prompt stream of a long-lived query. It stays open between turns: claude
+ * only winds a print-mode process down (killing background subagents after its
+ * wait ceiling) once its input is closed.
+ */
+function createInputQueue() {
+    const buffer = [];
+    let waiter = null;
+    let closed = false;
+    const finish = () => {
+        closed = true;
+        if (waiter) {
+            const resolve = waiter;
+            waiter = null;
+            resolve({ value: undefined, done: true });
+        }
+    };
+    return {
+        push(message) {
+            if (closed) {
+                return false;
+            }
+            if (waiter) {
+                const resolve = waiter;
+                waiter = null;
+                resolve({ value: message, done: false });
+            }
+            else {
+                buffer.push(message);
+            }
+            return true;
+        },
+        close: finish,
+        [Symbol.asyncIterator]() {
+            return {
+                next: () => {
+                    if (buffer.length) {
+                        return Promise.resolve({ value: buffer.shift(), done: false });
+                    }
+                    if (closed) {
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise((resolve) => {
+                        waiter = resolve;
+                    });
+                },
+                return: () => {
+                    finish();
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+            };
+        },
+    };
+}
+function resultUserMessageUuids(resultMessage) {
+    if (Array.isArray(resultMessage?.user_message_uuids)) {
+        return resultMessage.user_message_uuids;
+    }
+    return resultMessage?.user_message_uuid ? [resultMessage.user_message_uuid] : [];
+}
 function createTurnError(message, extras = {}) {
     const error = new Error(message);
     for (const [key, value] of Object.entries(extras)) {
@@ -52,11 +118,27 @@ function sumStreamedUsage(usageByMessageId, base = null) {
     return total;
 }
 /**
- * A finished turn's usage. A turn that waits on background tasks emits one result per
- * segment, and `usage` covers only the last one; `modelUsage` accumulates every API call
- * the query's process made (all segments and subagents), so prefer its sum.
+ * A finished turn's usage. `usage` covers only the main loop's last segment, while
+ * `modelUsage` accumulates every API call the query's process made (all segments,
+ * subagents and earlier turns of a long-lived query), so prefer its sum minus `base`,
+ * the total at the end of the previous turn.
  */
-function resultUsage(resultMessage) {
+function resultUsage(resultMessage, base = null) {
+    const total = modelUsageTotal(resultMessage);
+    if (!total) {
+        return resultMessage.usage ? { ...resultMessage.usage } : null;
+    }
+    // /clear resets the running total; a total below its base starts over.
+    if (!base || Object.keys(base).some((key) => !(total[key] >= base[key]))) {
+        return total;
+    }
+    const delta = {};
+    for (const [key, value] of Object.entries(total)) {
+        delta[key] = value - base[key];
+    }
+    return delta;
+}
+function modelUsageTotal(resultMessage) {
     const total = {};
     for (const entry of Object.values(resultMessage.modelUsage || {})) {
         for (const [from, to] of [
@@ -71,10 +153,7 @@ function resultUsage(resultMessage) {
             }
         }
     }
-    if (Object.keys(total).length) {
-        return total;
-    }
-    return resultMessage.usage ? { ...resultMessage.usage } : null;
+    return Object.keys(total).length ? total : null;
 }
 function normalizeClaudeBackend(backend) {
     const normalized = String(backend || "").trim().toLowerCase();
@@ -110,71 +189,76 @@ function normalizePermissionMode(value) {
 // Two different env idioms in that one line, and both are load-bearing:
 // IS_SANDBOX is a *strict* `=== "1"` compare, while CLAUDE_CODE_BUBBLEWRAP goes
 // through claude's loose truthy parser (`1|true|yes|on`, trimmed+lowercased).
-// Do not "helpfully" accept IS_SANDBOX=true here — being more permissive than
-// the gate keeps bypassPermissions and just moves the failure into claude,
-// which is the exact bug we are fixing.
+// Do not "helpfully" accept IS_SANDBOX=true here — claude would still refuse,
+// and the user would get no hint telling them why.
+//
+// Values are compared the way claude will see them: spawn stringifies env, so
+// YAML `IS_SANDBOX: 1` (a number from config `envs:`) reaches claude as "1"
+// and passes its gate. `true` becomes "true" and still does not.
 export function isClaudeRootPermissionRestricted(env = process.env) {
     if (typeof process.getuid !== "function" || process.getuid() !== 0) {
         return false;
     }
-    if (env?.IS_SANDBOX === "1") {
+    if (String(env?.IS_SANDBOX ?? "") === "1") {
         return false;
     }
     const bubblewrap = String(env?.CLAUDE_CODE_BUBBLEWRAP ?? "").trim().toLowerCase();
     return !["1", "true", "yes", "on"].includes(bubblewrap);
 }
-// Root installs (docker, CI, bare VPS) would otherwise fail every turn, so fall
-// back to the closest usable mode instead of dying.
+// The configured mode is used as-is, including on root. We used to downgrade
+// bypassPermissions -> acceptEdits for root, but a headless session has no one
+// to approve prompts, so acceptEdits silently denied every Bash command and
+// every read outside cwd: the task "ran" and could do nothing. Instead we keep
+// the mode and flag `rootSandboxRequired` so the caller can tell the user to
+// opt in with IS_SANDBOX=1 (or run as a regular user).
 export function resolveClaudePermissionPolicy(options = {}, env = process.env) {
-    const requested = normalizePermissionMode(options.permissionMode);
+    const permissionMode = normalizePermissionMode(options.permissionMode);
     // A configured value we don't recognize still falls back to the default (a
     // typo must never take the session down), but the caller reports it so the
     // user finds out their config line is doing nothing.
     const rawMode = typeof options.permissionMode === "string" ? options.permissionMode.trim() : "";
     const invalidMode = rawMode && !PERMISSION_MODES.has(rawMode) ? rawMode : "";
-    if (!isClaudeRootPermissionRestricted(env)) {
-        return {
-            permissionMode: requested,
-            allowDangerouslySkipPermissions: requested === DEFAULT_PERMISSION_MODE || options.allowDangerouslySkipPermissions === true,
-            downgradedFrom: "",
-            invalidMode,
-        };
-    }
-    const permissionMode = requested === DEFAULT_PERMISSION_MODE ? ROOT_PERMISSION_MODE : requested;
+    const rootRestricted = isClaudeRootPermissionRestricted(env);
+    const bypass = permissionMode === DEFAULT_PERMISSION_MODE;
     return {
         permissionMode,
-        allowDangerouslySkipPermissions: false,
-        downgradedFrom: permissionMode === requested ? "" : requested,
+        // A non-bypass mode the user picked on purpose never needs the escape
+        // flag, and as root it would only trip claude's gate.
+        allowDangerouslySkipPermissions: bypass || (options.allowDangerouslySkipPermissions === true && !rootRestricted),
+        rootSandboxRequired: bypass && rootRestricted,
         invalidMode,
     };
 }
-// The PTY / tool-preset path in the daemon hands a configured allow_cli_list
-// command straight to a shell, so it never reaches the session class above and
-// never sees resolveClaudePermissionPolicy. Rewrite the command string there
-// too, or a root box keeps failing in terminal tasks after the SDK path is fixed.
-export function resolveClaudeCommandForRoot(commandLine, env = process.env) {
+// True when a configured claude command line would hit claude's root gate:
+// it asks for bypass (the flag, or `--permission-mode bypassPermissions`) and
+// the process env doesn't opt out.
+export function claudeCommandNeedsRootSandbox(commandLine, env = process.env) {
     const command = typeof commandLine === "string" ? commandLine : "";
-    if (!command.trim() || !isClaudeRootPermissionRestricted(env)) {
-        return command;
-    }
-    // Also drop a valueless `--permission-mode` (end of string, or immediately
-    // followed by another flag). Without this the append branch below would emit
-    // `--permission-mode --permission-mode acceptEdits`, and claude reads the
-    // flag name as the mode and `acceptEdits` as a positional prompt.
-    const stripped = command
-        .replace(/\s*--dangerously-skip-permissions(?=\s|$)/g, "")
-        .replace(/\s*--permission-mode=(?=\s|$)/g, "")
-        .replace(/\s*--permission-mode(?=\s+-|\s*$)/g, "")
-        .trim();
-    const configuredMode = extractLongFlagFromCommandLine(stripped, "permission-mode");
-    if (!configuredMode) {
-        return `${stripped} --permission-mode ${ROOT_PERMISSION_MODE}`;
-    }
-    if (configuredMode === DEFAULT_PERMISSION_MODE) {
-        return stripped.replace(/(--permission-mode[=\s]+)bypassPermissions(?=\s|$)/, `$1${ROOT_PERMISSION_MODE}`);
-    }
-    // Any other configured mode is already root-safe; leave it verbatim.
-    return stripped;
+    if (!command.trim()) {
+        return false;
+    }
+    const bypass = /(^|\s)--dangerously-skip-permissions(?=\s|$)/.test(command)
+        || extractLongFlagFromCommandLine(command, "permission-mode") === DEFAULT_PERMISSION_MODE;
+    return bypass && isClaudeRootPermissionRestricted(env);
+}
+// User-facing hint shown in the task chat (and the PTY terminal) when claude
+// is about to be started as root in bypass mode without IS_SANDBOX=1.
+export function buildClaudeRootSandboxNotice({ configFile } = {}) {
+    const configPath = typeof configFile === "string" && configFile.trim()
+        ? configFile.trim()
+        : "~/.conductor/config.yaml";
+    return [
+        "⚠️ 当前 conductor 以 root 用户运行 claude。Claude Code 禁止 root 使用 bypassPermissions（--dangerously-skip-permissions），本会话的请求会直接失败。",
+        "",
+        `如果这台机器是隔离环境（容器 / 虚机），请在 ${configPath} 中加入下面的配置，然后重启 daemon：`,
+        "",
+        "```yaml",
+        "envs:",
+        "  IS_SANDBOX: \"1\"",
+        "```",
+        "",
+        "注意值必须是 1（写成 1 或 \"1\" 都可以），写成 true / yes 不生效。设置后 claude 会以 root 身份直接执行命令、不再请求确认；如果不是隔离环境，建议改用普通用户运行 daemon。",
+    ].join("\n");
 }
 function normalizeText(value) {
     return typeof value === "string" ? value : "";
@@ -315,6 +399,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         this.lastReplyTarget = "";
         this.manualResumeReady = Boolean(this.sessionId);
         this.currentTurn = null;
+        this.liveQuery = null;
         this.lastResult = null;
         this.rateLimitInfo = null;
         this.currentTurnStatus = null;
@@ -340,9 +425,15 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 + `using ${this.permissionPolicy.permissionMode} instead `
                 + `(valid: ${[...PERMISSION_MODES].join(", ")})`);
         }
-        if (this.permissionPolicy.downgradedFrom) {
-            this.trace(`permission mode ${this.permissionPolicy.downgradedFrom} -> ${this.permissionPolicy.permissionMode} `
-                + `(claude rejects ${this.permissionPolicy.downgradedFrom} as root; set IS_SANDBOX=1 to keep it)`);
+        // Shown to the user by fire as a chat message (see getSnapshot().notices):
+        // claude will refuse to start, and a daemon log line alone is invisible.
+        this.notices = [];
+        if (this.permissionPolicy.rootSandboxRequired) {
+            this.trace("WARN running as root without IS_SANDBOX=1; claude will refuse bypassPermissions "
+                + "(set envs.IS_SANDBOX: \"1\" in the conductor config, or run as a regular user)");
+            this.notices.push(buildClaudeRootSandboxNotice({
+                configFile: options.configFile || this.env.CONDUCTOR_CONFIG || process.env.CONDUCTOR_CONFIG,
+            }));
         }
     }
     writeLog(message) {
@@ -381,6 +472,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
             capabilities: this.getCapabilities(),
+            notices: [...this.notices],
         };
     }
     getSessionInfo() {
@@ -461,6 +553,8 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             status_done_line: payload?.status_done_line,
             reply_preview: payload?.reply_preview,
             thread_id: this.sessionId || undefined,
+            // A turn claude ran on its own, between user turns (see dispatchLiveMessage).
+            ...(payload?.background === true ? { background: true } : {}),
         };
         this.updateCurrentTurnStatus(normalized);
         const snapshot = this.getCurrentTurnStatus();
@@ -839,7 +933,8 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                         noteToolStarted(currentTurn, block.id, block.name, block.input);
                     }
                 }
-                const text = extractAssistantText(message.message);
+                // Subagent narration (parent_tool_use_id set) is not a reply to the user.
+                const text = message.parent_tool_use_id ? "" : extractAssistantText(message.message);
                 if (!text) {
                     return;
                 }
@@ -893,6 +988,26 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         if (!currentTurn) {
             return false;
         }
+        const { liveQuery } = currentTurn;
+        if (liveQuery) {
+            // The interrupted turn reports its own result; tear the process down only
+            // if it does not, so a stuck CLI cannot hold the turn open.
+            try {
+                await liveQuery.query.interrupt?.();
+            }
+            catch {
+                // best effort
+            }
+            if (this.currentTurn === currentTurn) {
+                const timer = setTimeout(() => {
+                    if (this.currentTurn === currentTurn) {
+                        this.closeLiveQuery(liveQuery);
+                    }
+                }, INTERRUPT_GRACE_MS);
+                timer.unref?.();
+            }
+            return true;
+        }
         try {
             await currentTurn.query?.interrupt?.();
         }
@@ -913,6 +1028,168 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         }
         return true;
     }
+    createTurnState({ suppressReply = false, onProgress = null } = {}) {
+        return {
+            abortController: null,
+            liveQuery: null,
+            onProgress,
+            settle: null,
+            suppressReply,
+            compactMetadata: null,
+            compactError: "",
+            conversationReset: "",
+            emittedAssistantMessage: false,
+            fullText: "",
+            items: [],
+            query: null,
+            resultMessage: null,
+            terminalWorkingStatusEmitted: false,
+            usageBase: null,
+            usageByMessageId: new Map(),
+            uuid: "",
+        };
+    }
+    /**
+     * One claude process per session, fed through a prompt stream that stays
+     * open between turns. A one-shot string prompt closes claude's input at once,
+     * and claude then kills background subagents 10 minutes after the main
+     * agent's turn ends (CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS). Kept open, the
+     * subagents run to completion and claude starts its own follow-up turn on
+     * their notifications.
+     */
+    ensureLiveQuery(sdkModule) {
+        if (this.liveQuery && !this.liveQuery.ended) {
+            return this.liveQuery;
+        }
+        const abortController = new AbortController();
+        const liveQuery = {
+            abortController,
+            backgroundTurn: null,
+            ended: false,
+            input: createInputQueue(),
+            query: null,
+            usageBase: null,
+        };
+        liveQuery.query = sdkModule.query({
+            prompt: liveQuery.input,
+            options: this.buildSdkOptions(abortController),
+        });
+        this.liveQuery = liveQuery;
+        void this.pumpLiveQuery(liveQuery);
+        return liveQuery;
+    }
+    closeLiveQuery(liveQuery) {
+        liveQuery.ended = true;
+        if (this.liveQuery === liveQuery) {
+            this.liveQuery = null;
+        }
+        liveQuery.input.close();
+        try {
+            liveQuery.abortController.abort();
+        }
+        catch {
+            // best effort
+        }
+        try {
+            liveQuery.query?.close?.();
+        }
+        catch {
+            // best effort
+        }
+    }
+    settleTurn(turn, error, resultMessage = null) {
+        const settle = turn.settle;
+        turn.settle = null;
+        settle?.(error, resultMessage);
+    }
+    async pumpLiveQuery(liveQuery) {
+        let failure = null;
+        try {
+            for await (const message of liveQuery.query) {
+                await this.dispatchLiveMessage(liveQuery, message);
+            }
+        }
+        catch (error) {
+            failure = error;
+        }
+        this.closeLiveQuery(liveQuery);
+        const turn = this.currentTurn;
+        if (turn?.liveQuery === liveQuery && turn.settle) {
+            this.settleTurn(turn, failure, turn.resultMessage);
+        }
+        else if (failure && !this.closeRequested) {
+            this.trace(`claude process ended between turns: ${failure?.message || failure}`);
+        }
+        const backgroundTurn = liveQuery.backgroundTurn;
+        liveQuery.backgroundTurn = null;
+        if (backgroundTurn) {
+            await this.finishBackgroundTurn(backgroundTurn, null, failure);
+        }
+        else if (failure && !this.closeRequested && !this.currentTurn) {
+            // The process died after a background turn's result, e.g. an error
+            // result (quota hit) makes claude exit right after reporting it. No turn
+            // is left to own the failure, so report it as a background one.
+            await this.emitWorkingStatus({
+                phase: "turn_failed",
+                status_done_line: failure?.message || String(failure),
+                reply_in_progress: false,
+                background: true,
+            });
+        }
+    }
+    /**
+     * Routes the long-lived query's output. A result ends the pending turn when it
+     * echoes that turn's user message uuid (or echoes none while no follow-up turn
+     * of claude's own is running); everything else is a background turn, e.g.
+     * claude answering a finished subagent's notification between user turns.
+     */
+    async dispatchLiveMessage(liveQuery, message) {
+        const turn = this.currentTurn?.liveQuery === liveQuery && this.currentTurn.settle ? this.currentTurn : null;
+        const backgroundTurn = liveQuery.backgroundTurn;
+        if (message?.type !== "result") {
+            const target = backgroundTurn || turn || (liveQuery.backgroundTurn = this.createTurnState());
+            await this.handleSdkMessage(message, target, { onProgress: target.onProgress });
+            return;
+        }
+        liveQuery.backgroundTurn = null;
+        const uuids = resultUserMessageUuids(message);
+        if (turn && (uuids.length ? uuids.includes(turn.uuid) : !backgroundTurn)) {
+            // A background turn that folded the user's message in ends as this turn.
+            if (backgroundTurn?.emittedAssistantMessage) {
+                turn.emittedAssistantMessage = true;
+            }
+            await this.handleSdkMessage(message, turn, { onProgress: turn.onProgress });
+            liveQuery.usageBase = modelUsageTotal(message) || liveQuery.usageBase;
+            this.settleTurn(turn, null, message);
+            return;
+        }
+        const target = backgroundTurn || this.createTurnState();
+        await this.handleSdkMessage(message, target, {});
+        await this.finishBackgroundTurn(target, message);
+    }
+    async finishBackgroundTurn(backgroundTurn, resultMessage, failure = null) {
+        // An error result (e.g. "You've hit your session limit") can carry subtype
+        // "success"; `is_error` is what marks it.
+        const errorResult = Boolean(resultMessage && (resultMessage.subtype !== "success" || resultMessage.is_error === true));
+        const failed = Boolean(failure) || errorResult;
+        const text = normalizeText(resultMessage?.result);
+        // An error result's text still reaches the chat, as it always has.
+        if (!failure && resultMessage?.subtype === "success" && text && !backgroundTurn.emittedAssistantMessage) {
+            await this.emitAssistantMessage(text);
+        }
+        // A pending user turn owns the working status.
+        if (this.currentTurn) {
+            return;
+        }
+        await this.emitTerminalWorkingStatus(backgroundTurn, failed
+            ? {
+                phase: "turn_failed",
+                status_done_line: failure?.message ||
+                    (resultMessage?.is_error === true && text ? text : extractResultErrorMessage(resultMessage)),
+                background: true,
+            }
+            : { phase: "turn_completed", status_done_line: "claude finished", background: true });
+    }
     async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
@@ -942,31 +1219,24 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         if (!suppressReply) {
             this.history.push({ role: "user", content: promptText });
         }
-        const abortController = new AbortController();
-        const currentTurn = {
-            abortController,
-            suppressReply,
-            compactMetadata: null,
-            compactError: "",
-            conversationReset: "",
-            emittedAssistantMessage: false,
-            fullText: "",
-            items: [],
-            query: null,
-            resultMessage: null,
-            terminalWorkingStatusEmitted: false,
-            usageByMessageId: new Map(),
-        };
+        // Structured output is fixed when the process starts, so a jsonSchema turn
+        // runs on a one-shot query of its own.
+        const oneShot = Boolean(jsonSchema && typeof jsonSchema === "object");
+        const abortController = oneShot ? new AbortController() : null;
+        const currentTurn = this.createTurnState({ suppressReply, onProgress });
+        currentTurn.abortController = abortController;
         this.currentTurn = currentTurn;
         this.markTurnStartedStatus();
-        const closeGuard = this.createCloseGuard(() => {
-            abortController.abort();
-            currentTurn.query?.close?.();
-        });
-        const turnTimeoutGuard = this.createTurnTimeoutGuard(() => {
-            abortController.abort();
+        const stopTurn = () => {
+            if (currentTurn.liveQuery) {
+                this.closeLiveQuery(currentTurn.liveQuery);
+                return;
+            }
+            abortController?.abort();
             currentTurn.query?.close?.();
-        });
+        };
+        const closeGuard = this.createCloseGuard(stopTurn);
+        const turnTimeoutGuard = this.createTurnTimeoutGuard(stopTurn);
         const previousOutputFormat = this.options.outputFormat;
         if (jsonSchema && typeof jsonSchema === "object") {
             this.options.outputFormat = { type: "json_schema", schema: jsonSchema };
@@ -977,28 +1247,45 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 reply_in_progress: true,
                 status_line: "claude is working",
             }, onProgress);
-            const query = sdkModule.query({
-                prompt: media.length ? buildClaudeInput(effectivePrompt, media) : effectivePrompt,
-                options: this.buildSdkOptions(abortController),
-            });
-            currentTurn.query = query;
-            const resultMessage = await Promise.race([
-                (async () => {
+            let turnResult;
+            if (oneShot) {
+                const query = sdkModule.query({
+                    prompt: media.length ? buildClaudeInput(effectivePrompt, media) : effectivePrompt,
+                    options: this.buildSdkOptions(abortController),
+                });
+                currentTurn.query = query;
+                turnResult = (async () => {
                     for await (const message of query) {
                         await this.handleSdkMessage(message, currentTurn, { onProgress });
                     }
                     return currentTurn.resultMessage;
-                })(),
-                closeGuard.promise,
-                turnTimeoutGuard.promise,
-            ]);
+                })();
+            }
+            else {
+                turnResult = new Promise((resolve, reject) => {
+                    currentTurn.settle = (error, message) => (error ? reject(error) : resolve(message));
+                });
+                const liveQuery = this.ensureLiveQuery(sdkModule);
+                currentTurn.liveQuery = liveQuery;
+                currentTurn.query = liveQuery.query;
+                currentTurn.usageBase = liveQuery.usageBase;
+                currentTurn.uuid = randomUUID();
+                if (!liveQuery.input.push(buildClaudeUserMessage(effectivePrompt, media, currentTurn.uuid))) {
+                    this.settleTurn(currentTurn, createTurnError("Claude process input is closed", { reason: "process_exited" }));
+                }
+            }
+            turnResult.catch(() => { });
+            const resultMessage = await Promise.race([turnResult, closeGuard.promise, turnTimeoutGuard.promise]);
             if (!resultMessage) {
                 throw createTurnError("Claude query ended without a result message", {
                     reason: "missing_result",
                 });
             }
-            if (resultMessage.subtype !== "success") {
-                const errorMessage = extractResultErrorMessage(resultMessage);
+            // An error result (e.g. "You've hit your session limit") can carry subtype
+            // "success"; `is_error` is what marks it.
+            if (resultMessage.subtype !== "success" || resultMessage.is_error === true) {
+                const errorText = resultMessage.is_error === true ? normalizeText(resultMessage.result) : "";
+                const errorMessage = errorText || extractResultErrorMessage(resultMessage);
                 this.maybeEmitAuthRequired(errorMessage, errorMessage);
                 await this.emitTerminalWorkingStatus(currentTurn, {
                     phase: "turn_failed",
@@ -1012,7 +1299,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                         ? [...resultMessage.permission_denials]
                         : [],
                     // A failed turn still spent tokens.
-                    usage: resultUsage(resultMessage),
+                    usage: resultUsage(resultMessage, currentTurn.usageBase),
                 });
             }
             const structuredOutput = jsonSchema && resultMessage.structured_output && typeof resultMessage.structured_output === "object"
@@ -1037,7 +1324,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             }, onProgress);
             return {
                 text: responseText,
-                usage: resultUsage(resultMessage),
+                usage: resultUsage(resultMessage, currentTurn.usageBase),
                 items: currentTurn.items,
                 events: [],
                 provider: this.backend,
@@ -1059,7 +1346,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             // A failed turn still spent tokens; an interrupted query ends without a
             // (final) result, so fall back to the last result plus what streamed since.
             const usage = error?.usage ??
-                sumStreamedUsage(currentTurn.usageByMessageId, currentTurn.resultMessage ? resultUsage(currentTurn.resultMessage) : null);
+                sumStreamedUsage(currentTurn.usageByMessageId, currentTurn.resultMessage ? resultUsage(currentTurn.resultMessage, currentTurn.usageBase) : null);
             if (error?.reason === "turn_timeout") {
                 await this.interruptCurrentTurn();
             }
@@ -1094,11 +1381,14 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             }
             closeGuard.cleanup();
             turnTimeoutGuard.cleanup();
-            try {
-                currentTurn.query?.close?.();
-            }
-            catch {
-                // best effort
+            currentTurn.settle = null;
+            if (oneShot) {
+                try {
+                    currentTurn.query?.close?.();
+                }
+                catch {
+                    // best effort
+                }
             }
         }
     }
@@ -1272,7 +1562,12 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         }
         this.closeRequested = true;
         this.flushCloseWaiters();
-        await this.interruptCurrentTurn();
+        if (!this.currentTurn?.liveQuery) {
+            await this.interruptCurrentTurn();
+        }
+        if (this.liveQuery) {
+            this.closeLiveQuery(this.liveQuery);
+        }
         this.closed = true;
     }
 }

package/dist/providers/kimi-print-session.js

@@ -157,6 +157,13 @@ function quoteShellArg(value) {
     }
     return `'${normalized.replace(/'/g, `'\\''`)}'`;
 }
+// Kimi Code reports a detached launch (`Agent`/`Bash` with run_in_background)
+// with these metadata lines; the task's completion later wakes the main agent
+// inside the same `kimi -p` process.
+function isBackgroundTaskLaunch(content) {
+    const text = normalizeTextContent(content);
+    return /^task_id: /m.test(text) && /^automatic_notification: true$/m.test(text);
+}
 function normalizeTextContent(content) {
     if (typeof content === "string") {
         return content;
@@ -633,7 +640,9 @@ export class KimiPrintSession extends EventEmitter {
                         if (currentTurn.settled) {
                             return;
                         }
-                        if (Date.now() - lastActivityAt < this.turnDeadlineMs) {
+                        // `kimi -p` stays silent while it waits for background tasks it
+                        // launched; killing it on idle would kill those tasks too.
+                        if (Date.now() - lastActivityAt < this.turnDeadlineMs || currentTurn.backgroundTaskLaunched) {
                             scheduleTurnDeadline();
                             return;
                         }
@@ -700,6 +709,10 @@ export class KimiPrintSession extends EventEmitter {
                     }
                     if (role === "tool") {
                         noteToolFinished(currentTurn, payload.tool_call_id);
+                        if (!currentTurn.backgroundTaskLaunched && isBackgroundTaskLaunch(payload.content)) {
+                            currentTurn.backgroundTaskLaunched = true;
+                            this.trace("background task launched; turn idle deadline suspended until kimi exits");
+                        }
                         void this.emitWorkingStatus({
                             phase: "command_execution",
                             reply_in_progress: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.16.0"
+    "@love-moon/chat-web": "^0.17.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "77239b9"
+  "gitCommitId": "e3dbbad"
 }