@nowcrew/daemon 0.6.88-beta.7 → 0.6.88-beta.9

package/dist/runtimes/claude-thread-runner.js

@@ -0,0 +1,266 @@
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { prepareThreadDelivery, ThreadDeliveryColdStartRequired } from "../thread-input-delivery.js";
+const InputSchema = z.object({ bin: z.string().min(1), args: z.array(z.string()),
+    wakePrompt: z.string().min(1), sessionId: z.string().min(1).optional(), resume: z.boolean() }).strict();
+class PreflightError extends Error {
+}
+function hookCommand(path, nonce) {
+    const source = import.meta.url.endsWith(".ts");
+    const hook = fileURLToPath(new URL(`./claude-session-start-hook.${source ? "ts" : "js"}`, import.meta.url));
+    const args = [process.execPath, ...(source
+            ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href] : []), hook, path, nonce];
+    const quote = process.platform === "win32"
+        ? (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '\\"')}"`
+        : (value) => `'${value.replaceAll("'", "'\\''")}'`;
+    return args.map(quote).join(" ");
+}
+function sessionArgs(args, sessionId, resume) {
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === "--resume" || args[index] === "--session-id") {
+            index += 1;
+            continue;
+        }
+        result.push(args[index]);
+    }
+    return [...result, resume ? "--resume" : "--session-id", sessionId];
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+    // A process can fail before its caller starts awaiting the next phase.
+    void promise.catch(() => undefined);
+    return { promise, resolve, reject };
+}
+async function bounded(promise, milliseconds, label) {
+    let timer;
+    try {
+        return await Promise.race([promise, new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(label)), milliseconds);
+            })]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function attempt(input, sessionId, resume, options) {
+    const proofDir = await mkdtemp(join(tmpdir(), "nowwork-claude-session-"));
+    const proofPath = join(proofDir, "proof.json");
+    const nonce = randomUUID();
+    const settings = { hooks: { SessionStart: [{ matcher: "startup|resume", hooks: [{ type: "command",
+                            command: hookCommand(proofPath, nonce), timeout: 15 }] }] } };
+    const env = options.env ?? process.env;
+    const output = options.output ?? (event => { process.stdout.write(`${JSON.stringify(event)}\n`); });
+    const child = spawn(input.bin, [...sessionArgs(input.args, sessionId, resume),
+        "--input-format", "stream-json", "--replay-user-messages", "--settings", JSON.stringify(settings)], 
+    // The existing execution supervisor owns the process group / Windows Job.
+    // Never create a detached native group: its forced cancellation may kill this
+    // wrapper before our local TERM grace expires, so all descendants must remain
+    // reachable by the supervisor's final tree-wide kill.
+    { cwd: process.cwd(), env, stdio: ["pipe", "pipe", "pipe"], detached: false });
+    const initialized = deferred();
+    const accepted = deferred();
+    const closed = deferred();
+    const initId = randomUUID();
+    const userId = randomUUID();
+    let submitted = false;
+    let cancelled = false;
+    let sawResult = false;
+    let exitObserved = false;
+    let acknowledged = false;
+    let delivery;
+    const pendingAgents = new Set();
+    let processing = Promise.resolve();
+    let failure;
+    const fail = (error) => { failure ??= error; initialized.reject(error); accepted.reject(error); };
+    const send = (event) => new Promise((resolve, reject) => {
+        if (!child.stdin || child.stdin.destroyed) {
+            reject(new Error("claude_input_closed"));
+            return;
+        }
+        child.stdin.write(`${JSON.stringify(event)}\n`, error => error ? reject(error) : resolve());
+    });
+    const nativeAlive = () => child.pid !== undefined && child.exitCode === null && child.signalCode === null;
+    const waitStopped = async () => {
+        const deadline = Date.now() + 1_000;
+        while (nativeAlive() && Date.now() < deadline)
+            await new Promise(resolve => setTimeout(resolve, 20));
+        return !nativeAlive();
+    };
+    let stopPromise;
+    const stop = () => stopPromise ??= (async () => {
+        if (!nativeAlive())
+            return;
+        // This is only local native-process cleanup (including preflight recovery),
+        // not proof that its descendants exited. Do not signal the inherited group:
+        // that would also kill this wrapper and prevent safe cold recovery. The
+        // supervisor retains ownership and verifies whole-tree exit on completion.
+        child.kill("SIGTERM");
+        if (await waitStopped())
+            return;
+        child.kill("SIGKILL");
+        if (!await waitStopped())
+            throw new Error("claude_stop_failed");
+    })();
+    const onSignal = () => { cancelled = true; fail(new Error("claude_thread_cancelled")); void stop().catch(fail); };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+    child.stdin?.on("error", error => fail(error));
+    child.once("error", error => { fail(error); closed.resolve(1); exitObserved = true; });
+    child.once("close", code => {
+        exitObserved = true;
+        closed.resolve(code ?? 1);
+        if (!submitted)
+            fail(new Error("claude_exited_before_session_ready"));
+    });
+    // Diagnostics may contain provider secrets or prompts. The parent receives a
+    // stable phase error, never raw third-party stderr or preflight result text.
+    child.stderr?.resume();
+    const lines = child.stdout ? createInterface({ input: child.stdout }) : null;
+    lines?.on("line", line => {
+        processing = processing.then(async () => {
+            if (failure)
+                return;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                throw new Error("claude_invalid_stream_json");
+            }
+            if (event.type === "control_response") {
+                const response = event.response;
+                if (response?.request_id === initId) {
+                    if (response.subtype !== "success")
+                        throw new Error("claude_initialize_rejected");
+                    initialized.resolve();
+                }
+                return;
+            }
+            if (event.type === "control_request") {
+                const request = event.request;
+                await send({ type: "control_response", response: request?.subtype === "can_use_tool"
+                        ? { subtype: "success", request_id: event.request_id,
+                            response: { behavior: "deny", message: "Interactive approval is unavailable in this execution." } }
+                        : { subtype: "error", request_id: event.request_id, error: "Unsupported Claude control request" } });
+                return;
+            }
+            if (!submitted) {
+                if (event.type === "result")
+                    throw new Error("claude_session_preflight_failed");
+                return; // Startup hooks and old replay events are not business output.
+            }
+            if (event.type === "system" && event.subtype === "init" && event.session_id !== sessionId) {
+                throw new Error("claude_actual_session_mismatch");
+            }
+            if (!acknowledged && event.type === "user" && event.uuid === userId && event.session_id === sessionId) {
+                await delivery.commit();
+                acknowledged = true;
+                accepted.resolve();
+            }
+            if (event.type === "system" && typeof event.task_id === "string") {
+                if (event.subtype === "task_started" && ["local_agent", "local_workflow"].includes(String(event.task_type))) {
+                    pendingAgents.add(event.task_id);
+                    sawResult = false;
+                }
+                else if (event.subtype === "task_notification")
+                    pendingAgents.delete(event.task_id);
+                else if (event.subtype === "task_updated" && event.patch && typeof event.patch === "object"
+                    && ["completed", "failed", "killed", "stopped"].includes(String(event.patch.status)))
+                    pendingAgents.delete(event.task_id);
+            }
+            // Like the official SDK, leave control input open while delegated agent
+            // work is outstanding; background shells must not hold it open forever.
+            if (event.type === "result")
+                sawResult = pendingAgents.size === 0;
+            output(event);
+        }).catch(error => { fail(error instanceof Error ? error : new Error("claude_event_failed")); void stop().catch(fail); });
+    });
+    try {
+        try {
+            await send({ type: "control_request", request_id: initId, request: { subtype: "initialize" } });
+            await bounded(initialized.promise, options.initializeTimeoutMs ?? 30_000, "claude_initialize_timeout");
+            const proof = JSON.parse(await readFile(proofPath, "utf8"));
+            if (proof.nonce !== nonce || proof.sessionId !== sessionId || proof.source !== (resume ? "resume" : "startup")) {
+                throw new Error("claude_session_proof_mismatch");
+            }
+            if (cancelled || failure)
+                throw failure ?? new Error("claude_thread_cancelled");
+        }
+        catch (error) {
+            if (cancelled)
+                throw error;
+            throw new PreflightError("claude_native_session_unconfirmed");
+        }
+        delivery = await (options.prepareDelivery ?? prepareThreadDelivery)({ env, resumed: resume, sessionId, wakePrompt: input.wakePrompt });
+        if (cancelled || failure)
+            throw failure ?? new Error("claude_thread_cancelled");
+        if (resume)
+            output({ type: "nowwork.native_resume", runtime: "claude", session_id: sessionId });
+        submitted = true;
+        await send({ type: "user", session_id: "", uuid: userId, parent_tool_use_id: null,
+            message: { role: "user", content: delivery.prompt } });
+        await bounded(accepted.promise, options.ackTimeoutMs ?? 30_000, "claude_user_message_not_acknowledged");
+        // Keep stdin open for control requests until the model result has arrived.
+        while (!sawResult && !exitObserved && !failure)
+            await new Promise(resolve => setTimeout(resolve, 10));
+        if (failure)
+            throw failure;
+        child.stdin?.end();
+        const code = await closed.promise;
+        await processing;
+        if (failure)
+            throw failure;
+        if (!sawResult)
+            throw new Error("claude_result_missing");
+        return code;
+    }
+    finally {
+        process.off("SIGTERM", onSignal);
+        process.off("SIGINT", onSignal);
+        try {
+            await stop();
+        }
+        finally {
+            lines?.close();
+            await rm(proofDir, { recursive: true, force: true });
+        }
+    }
+}
+export async function runClaudeThread(input, options = {}) {
+    const sessionId = input.sessionId ?? randomUUID();
+    try {
+        return await attempt(input, sessionId, input.resume, options);
+    }
+    catch (error) {
+        // The failed attempt never received a business user turn or entered its
+        // model/tool loop. Native startup hooks may run again on cold recovery.
+        if (!input.resume || !(error instanceof PreflightError || error instanceof ThreadDeliveryColdStartRequired))
+            throw error;
+        return attempt(input, randomUUID(), false, options);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    let raw = "";
+    for await (const chunk of process.stdin) {
+        raw += String(chunk);
+        if (Buffer.byteLength(raw) > 8 * 1024 * 1024)
+            throw new Error("claude_thread_input_too_large");
+    }
+    runClaudeThread(InputSchema.parse(JSON.parse(raw))).then(code => { process.exitCode = code; }).catch(error => {
+        const message = error instanceof Error ? error.message : "";
+        const reason = /^claude_[a-z_]+$/u.test(message) || message.startsWith("Thread input delivery failed:")
+            ? message : "claude_thread_contract_failed";
+        process.stderr.write(`Claude thread runner failed: ${reason}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/runtimes/claude.js

@@ -2,7 +2,9 @@
  * Claude Code runtime 适配:print + stream-json 模式,headless 驱动。
  */
 import { realpath } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { posix, win32 } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
 // Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
@@ -276,11 +278,28 @@ export function buildClaudeArgs(input) {
     args.push(input.wakePrompt);
     return args;
 }
+export function buildClaudeLaunch(input) {
+    const args = buildClaudeArgs(input);
+    if (!input.env.CREW_THREAD_ROOT?.trim())
+        return { command: input.bin, args, cwd: input.cwd, env: input.env };
+    const source = import.meta.url.endsWith(".ts");
+    return { command: process.execPath,
+        args: [...(source ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href] : []),
+            fileURLToPath(new URL(`./claude-thread-runner.${source ? "ts" : "js"}`, import.meta.url))],
+        cwd: input.cwd, env: input.env,
+        stdinText: JSON.stringify({ bin: input.bin, args: args.slice(0, -1), wakePrompt: input.wakePrompt,
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}), resume: input.resume === true }) };
+}
 export function spawnClaude(input) {
+    const launch = buildClaudeLaunch(input);
     // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
-    return spawn(input.bin, buildClaudeArgs(input), {
-        cwd: input.cwd,
-        env: input.env,
-        stdio: ["ignore", "pipe", "pipe"],
+    const child = spawn(launch.command, [...launch.args], {
+        cwd: launch.cwd, env: launch.env,
+        stdio: [launch.stdinText === undefined ? "ignore" : "pipe", "pipe", "pipe"],
     });
+    if (launch.stdinText !== undefined) {
+        child.stdin?.on("error", () => undefined);
+        child.stdin?.end(launch.stdinText);
+    }
+    return child;
 }

package/dist/runtimes/codex-app-server-runner.js

@@ -9,6 +9,7 @@ import { signalSupervisorTree } from "../execution-supervisor.js";
 import { assertCodexCollaborationVersion, assertCodexNativeWorkspaceVersion, assertCodexProjectWorkspaceResponse, assertCodexSkillsListResponse, boundedCodexPlan, codexProjectWorkspaceUnsupported, } from "./codex-contract.js";
 import { decideTurnRetry, itemMakesTurnUnsafe } from "./codex-turn-retry.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
+import { prepareThreadDelivery, ThreadDeliveryColdStartRequired } from "../thread-input-delivery.js";
 const RunnerInputSchema = z.object({
     systemPrompt: z.string().min(1),
     wakePrompt: z.string().min(1),
@@ -440,7 +441,7 @@ async function stopChildTree(child) {
         throw new Error(`Codex app-server process tree ${child.pid ?? "unknown"} did not exit`);
     }
 }
-async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs) {
+async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs, resumeEventSessionId) {
     const attemptStartedAt = Date.now();
     const child = spawn(bin, codexAppServerArgs({
         ...(input.projectRootMarkers === undefined ? {} : { projectRootMarkers: input.projectRootMarkers }),
@@ -589,6 +590,10 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         }
         logStage(activeStage, "ok", attempt, stageStartedAt);
         threadId = thread.thread.id;
+        if (input.resume) {
+            if (!input.sessionId || threadId !== input.sessionId)
+                throw new Error("native_resume_session_mismatch");
+        }
         if (announcedThreadId !== threadId) {
             announcedThreadId = threadId;
             await jsonLine({ type: "thread.started", thread_id: threadId });
@@ -603,6 +608,15 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
                 throw codexProjectWorkspaceUnsupported();
             }
         }
+        activeStage = "thread_context";
+        stageStartedAt = Date.now();
+        const delivery = await prepareThreadDelivery({ env: process.env, resumed: input.resume,
+            sessionId: threadId, wakePrompt: input.wakePrompt });
+        // Publish cross-execution resume only after context preparation succeeds; a
+        // missing prior cursor can still cause a fresh session before any business turn.
+        if (input.resume && threadId === resumeEventSessionId)
+            await jsonLine({ type: "nowwork.native_resume", session_id: threadId });
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         firstProgress = startFirstProgressWatchdog(() => {
             completionReject(new Error("Codex produced no semantic progress within the startup window"));
             void cancel();
@@ -612,7 +626,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         const started = await rpc.request("turn/start", {
             threadId,
             input: [
-                { type: "text", text: input.wakePrompt, text_elements: [] },
+                { type: "text", text: delivery.prompt, text_elements: [] },
                 ...(input.imagePaths ?? []).map((path) => ({ type: "localImage", path })),
             ],
             ...(input.reasoning === undefined || input.reasoning === "default"
@@ -622,8 +636,11 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
                 sandboxPolicy: { type: "workspaceWrite", networkAccess: true },
             } : {}),
         });
-        logStage(activeStage, "ok", attempt, stageStartedAt);
+        if (!started || typeof started.turn?.id !== "string" || !started.turn.id)
+            throw new Error("invalid_turn_start_response");
         turnId = started.turn.id;
+        await delivery.commit();
+        logStage(activeStage, "ok", attempt, stageStartedAt);
         activeStage = "turn_complete";
         stageStartedAt = Date.now();
         const completed = await completion;
@@ -656,9 +673,15 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
             initializeTimedOut: false,
             ...(retryReason === undefined ? {} : { retryReason }),
             unsafeToRetry: turnHasUnsafeSideEffect || collabStartedMissing,
+            deliveredSessionId: threadId,
         };
     }
     catch (error) {
+        if (error instanceof ThreadDeliveryColdStartRequired && activeStage === "thread_context"
+            && turnId === null && !turnHasUnsafeSideEffect) {
+            logStage(activeStage, "error", attempt, stageStartedAt, "recovery=restart_cold_before_turn");
+            return { code: 1, initializeTimedOut: false, unsafeToRetry: false, restartCold: true };
+        }
         const initializeTimedOut = error instanceof CodexRpcTimeoutError && error.method === "initialize";
         if (initializeTimedOut) {
             const tail = stderr.redactedTail();
@@ -692,8 +715,19 @@ export async function runCodexAppServer(bin, options = {}) {
     const turnRetryDelayMs = options.turnRetryDelayMs ?? TRANSIENT_TURN_RETRY_DELAY_MS;
     let initializeTimeouts = 0;
     let turnRetries = 0;
+    let coldRestarted = false;
+    let attemptInput = input;
+    const resumeEventSessionId = input.resume ? input.sessionId : undefined;
     for (let attempt = 1;; attempt += 1) {
-        const result = await runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs);
+        const result = await runCodexAppServerAttempt(bin, attemptInput, attempt, initializeTimeoutMs, resumeEventSessionId);
+        if (result.restartCold) {
+            if (coldRestarted)
+                return result.code;
+            coldRestarted = true;
+            const { sessionId: _oldSessionId, ...freshInput } = input;
+            attemptInput = { ...freshInput, resume: false };
+            continue;
+        }
         if (result.initializeTimedOut) {
             initializeTimeouts += 1;
             if (initializeTimeouts >= MAX_INITIALIZE_ATTEMPTS)
@@ -703,6 +737,11 @@ export async function runCodexAppServer(bin, options = {}) {
         }
         const decision = decideTurnRetry(result, turnRetries, MAX_TRANSIENT_TURN_RETRIES);
         if (decision.kind === "retry") {
+            // The accepted turn is already in the native transcript. Keep its session
+            // and committed thread cursor so a safe retry cannot inject full history twice.
+            if (process.env.CREW_THREAD_ROOT && result.deliveredSessionId) {
+                attemptInput = { ...input, resume: true, sessionId: result.deliveredSessionId };
+            }
             const delayMs = turnRetryDelayMs * TRANSIENT_TURN_RETRY_BACKOFF_FACTOR ** turnRetries;
             turnRetries += 1;
             process.stderr.write(`[codex-app-server] stage=retry status=start attempt=${attempt + 1} elapsed_ms=0 reason=${decision.reason}\n`);

package/dist/runtimes/kimi-acp-runner.js

@@ -6,6 +6,7 @@ import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { PROTOCOL_VERSION, RequestError, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { augmentedPath } from "../runtime-path.js";
+import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
 const ERROR_MESSAGE_CAP = 2_000;
@@ -255,14 +256,17 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
         await stopChild(child);
     }
 }
-export async function runKimiAcp(options) {
+export async function runKimiAcp(requestedOptions) {
+    // Until this adapter verifies native restoration, thread-bound runs are cold.
+    const options = process.env.CREW_THREAD_ROOT ? { ...requestedOptions, resume: false } : requestedOptions;
     const provider = options.provider ?? "kimi";
     const displayName = providerDisplayName(provider);
     const permission = options.effectivePermission ?? "full_access";
     if (provider === "deepseek-harness" && options.resume) {
         throw new Error("DeepSeek Harness ACP does not support session resume");
     }
-    const prompt = await readPrompt();
+    const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
+        sessionId: "unverified-cold-acp", wakePrompt: await readPrompt() })).prompt;
     const child = spawn(options.bin, providerArgs(provider, options.configPath), {
         cwd: process.cwd(),
         env: providerEnv(provider, permission),

package/dist/runtimes/opencode-runner.js

@@ -4,6 +4,7 @@ import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
+import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
 const ERROR_CAP = 2_000;
 async function readPrompt() {
@@ -86,7 +87,12 @@ async function runAttempt(options, prompt) {
     return { code: 0, staleSession: false };
 }
 export async function runOpenCode(options) {
-    const prompt = await readPrompt();
+    const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
+        sessionId: "unverified-cold-opencode", wakePrompt: await readPrompt() })).prompt;
+    if (process.env.CREW_THREAD_ROOT) {
+        const { sessionId: _unverified, ...coldOptions } = options;
+        return (await runAttempt(coldOptions, prompt)).code;
+    }
     const first = await runAttempt(options, prompt);
     if (!first.staleSession)
         return first.code;

package/dist/serve.js

@@ -1090,15 +1090,14 @@ export function serve(config, opts = {}) {
                 const ackHint = `\n**协作礼仪:决定接手后,先用 \`${sendCmd}\` 在该任务线程说一声你来跟进**——用日常语言带上你对问题的理解或打算先查什么,不要写"我接 task #N"这类内部编号;写不出实质内容就不单发,并进第一条实质进展,但不要长时间闷头干活把线程空着。`;
                 // 图片/文件附件:crew message read 会在消息下列出附件及其 id;图片需下载后用 Read 工具查看,才能真正"看到"内容。
                 const attHint = `\n若消息带图片/文件附件(read 会列出 id),用 \`crew attachment get <id>\` 下载到本地,图片再用 Read 工具打开查看后再处理。`;
-                // 线程隔离:有 threadId 时用 `crew thread read` 只读本线程(避免被其他线程消息干扰);
-                // 顶层消息(无 threadId)用 `crew message read` 读整个频道。
-                const readCmd = threadId
-                    ? `crew thread read`
-                    : `crew message read --channel ${msg.channelId}`;
+                // 启动上下文由执行层交付;legacy 提示词也不能要求模型补读或退回频道历史。
+                const contextHint = threadId
+                    ? "直接依据程序交付的本线程上下文与新消息处理,无需启动补读历史。"
+                    : "没有线程锚点,只处理明确来信或请求补充当前任务线程,不读取频道历史猜测。";
                 const wakeText = scheduled
                     ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy, scheduled.externalNotificationPolicy)
                     : (msg.wake?.content
-                        ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
+                        ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n${contextHint}${reasonHint}${ackHint}${threadHint}${attHint}`
                         : undefined);
                 const wakeOrigin = scheduled ? undefined : msg.wake?.origin;
                 const guarded = await runWithOriginDecisionGuard(wakeOrigin, async (attempt) => {
@@ -1124,8 +1123,8 @@ export function serve(config, opts = {}) {
                             },
                         } : {}),
                         ...(wakeOrigin ? { wakeOrigin, originDecisionAttempt: attempt } : {}),
-                        // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
-                        ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
+                        // legacy wake.threadId 已由 Server 归一到线程根;与普通触发消息 id 分开透传。
+                        ...(!scheduled && threadId ? { threadId, wakeMessageId: threadId } : {}),
                         ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
                         ...(attemptWake ? { wake: attemptWake } : {}),
                     }, reportActivity, reportConsole, {

package/dist/session.js

@@ -24,6 +24,10 @@ export async function readSession(runDir) {
         if (typeof o.sessionId !== "string" || !o.sessionId)
             return null;
         return {
+            ...(typeof o.runtime === "string" ? { runtime: o.runtime } : {}),
+            ...(typeof o.threadRoot === "string" ? { threadRoot: o.threadRoot } : {}),
+            ...(Number.isSafeInteger(o.threadContextSeq) && o.threadContextSeq >= 0 ? { threadContextSeq: o.threadContextSeq } : {}),
+            ...(typeof o.threadHistoryComplete === "boolean" ? { threadHistoryComplete: o.threadHistoryComplete } : {}),
             sessionId: o.sessionId,
             lastRunAt: typeof o.lastRunAt === "number" ? o.lastRunAt : 0,
             turns: typeof o.turns === "number" ? o.turns : 0,

package/dist/supervised-runtime.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from "node:url";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
-import { buildClaudeArgs } from "./runtimes/claude.js";
+import { buildClaudeLaunch } from "./runtimes/claude.js";
 import { DEEPSEEK_HARNESS_CONFIG_ENV, deepSeekHarnessConfigPath, } from "./runtimes/deepseek-harness.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 export function supervisorLaunch(request) {
@@ -13,23 +13,18 @@ export function supervisorLaunch(request) {
     };
     if (request.runtime === "claude") {
         const additionalDirectories = request.claudeAdditionalDirectories;
-        return {
-            command: request.bin,
-            args: buildClaudeArgs({
-                ...common,
-                bin: request.bin,
-                cwd: request.cwd,
-                env: request.env,
-                systemPromptPath: request.systemPromptPath,
-                ...(additionalDirectories === undefined ? {} : { additionalDirectories }),
-                ...(request.sessionId === undefined ? {} : {
-                    sessionId: request.sessionId,
-                    resume: request.resume,
-                }),
-            }),
+        return buildClaudeLaunch({
+            ...common,
+            bin: request.bin,
             cwd: request.cwd,
             env: request.env,
-        };
+            systemPromptPath: request.systemPromptPath,
+            ...(additionalDirectories === undefined ? {} : { additionalDirectories }),
+            ...(request.sessionId === undefined ? {} : {
+                sessionId: request.sessionId,
+                resume: request.resume,
+            }),
+        });
     }
     if (request.runtime === "codex") {
         return {