@nowcrew/daemon 0.6.88-beta.2 → 0.6.88-beta.20

package/dist/provider-env.js

@@ -10,7 +10,6 @@
  */
 import { join } from "node:path";
 import { DEEPSEEK_CODEX_KEY_ENV, deepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
-import { DEEPSEEK_HARNESS_CONFIG_ENV } from "./runtimes/deepseek-harness.js";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -96,9 +95,9 @@ export function applyProviderEnv(base, runtime, cfg, homeDir, deepSeekHomeOverri
     }
     return env;
 }
-const deepSeekHarnessMachineOwnedKey = (key) => (key.startsWith("DEEPSEEK_")
-    || key === DEEPSEEK_HARNESS_CONFIG_ENV
-    || key.startsWith("DSH_"));
+const deepSeekHarnessMachineOwnedKey = (key) => (key.toUpperCase().startsWith("DEEPSEEK_")
+    || key.toUpperCase().startsWith("NOWCREW_DEEPSEEK_HARNESS_")
+    || key.toUpperCase().startsWith("DSH_"));
 /** Agent env remains available to tools, but cannot replace Harness process policy or credentials. */
 export function applyDeepSeekHarnessMachineEnv(base, machineEnv) {
     const env = { ...base };

package/dist/runner.js

@@ -11,6 +11,7 @@ import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decisi
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 import { launchSupervisedRuntime } from "./supervised-runtime.js";
 import { awaitWithCancellation, } from "./runtime-cancellation.js";
+import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 export { awaitExit, exitActivity } from "./local-executor.js";
 export { sanitizeEnvVars } from "./runtime-env.js";
 const ICON = {
@@ -23,8 +24,13 @@ function runtimeName(value) {
     throw new Error(`unsupported runtime: ${value}`);
 }
 export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
+    const threadId = input.scheduled ? undefined : input.threadId;
+    const taskAnchor = threadId ?? input.wakeMessageId;
+    // Old servers have no typed maintenance purpose. A legacy marker can only
+    // reduce native-session reuse; it never grants maintenance permissions.
+    const suppressNativeSession = parseMemoryPruneTraceId(input.wake ?? "") !== null;
     const credential = await awaitWithCancellation((dependencies.mintAgentToken ?? mintAgentToken)(config.serverUrl, config.machineToken, input.handle, input.displayName, {
-        ...(input.wakeMessageId ? { wakeThreadRoot: input.wakeMessageId } : {}),
+        ...(threadId ? { wakeThreadRoot: threadId } : {}),
         ...(input.wakeContextUpToSeq === undefined ? {} : { wakeContextUpToSeq: input.wakeContextUpToSeq }),
         ...(input.runId ? { agentRunId: input.runId } : {}),
     }), dependencies.cancellation);
@@ -45,11 +51,13 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         handle: input.handle,
         channelId: input.channelId,
         ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-        ...(input.wakeMessageId === undefined ? {} : { wakeMessageId: input.wakeMessageId }),
+        ...(threadId === undefined ? {} : { threadId,
+            ...(!suppressNativeSession ? { resumeKey: threadId } : {}) }),
+        ...(taskAnchor === undefined ? {} : { wakeMessageId: taskAnchor }),
         systemPrompt: ({ workspace, resuming }) => buildSystemPrompt({
             handle: input.handle,
             channelId: input.channelId,
-            ...(input.wakeMessageId ? { wakeMessageId: input.wakeMessageId } : {}),
+            ...(threadId ? { wakeMessageId: threadId } : {}),
             agentId: credential.agentId,
             homeDir: workspace.dir,
             productName: config.productName,
@@ -64,17 +72,8 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
             localMemoryV2Enabled,
         }),
-        wakePrompt: ({ resuming, rotatedForBudget, nearBudget }) => {
-            const distillHint = nearBudget
-                ? "\n(注意:本会话上下文已接近预算,稍后将轮换重启。本轮结束前,把当前状态——阶段/关键结论/下一步/卡点/关键文件路径——完整更新到 $CREW_TASK_LOG,下轮将以它为基础继续。)"
-                : "";
-            if (resuming) {
-                return `(继续之前的会话:频道历史与你的进度已在上下文里,不必从头重读;要新消息用 \`crew message read --channel ${input.channelId}\` 增量拉即可。)${distillHint}\n\n${baseWake}`;
-            }
-            return rotatedForBudget
-                ? `(上下文已轮换:之前的会话过大已重启。你的 work-log 已注入系统提示词末尾,以它为基础继续;频道/线程历史用 crew 命令按需拉取,不必全量重读。)\n\n${baseWake}`
-                : baseWake;
-        },
+        // Native adapters, not a launch-intent prompt, choose history versus delta.
+        wakePrompt: () => baseWake,
         runtime: {
             name: runtime,
             ...(providerConfig.model ? { model: providerConfig.model } : {}),
@@ -107,7 +106,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             },
         },
         session: {
-            enabled: config.resume,
+            enabled: config.resume && !suppressNativeSession,
             warmMs: config.resumeWarmMs,
             budgetTokens: config.sessionBudgetTokens,
             softTokens: config.sessionSoftTokens,

package/dist/runtime-probe.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { executableRuntimes } from "./runtime-capabilities.js";
 export function conservativeExecutionRuntimes(installed) {
     return executableRuntimes(installed)
@@ -7,16 +9,43 @@ export function createRuntimeProbeCoordinator() {
     const abort = new AbortController();
     const flights = new Map();
     return {
-        detect(installed, detector) {
+        detect(installed, detector, connectionId) {
             const key = [...installed].sort().join("\0");
             const existing = flights.get(key);
-            if (existing)
-                return existing;
-            const pending = detector(installed, abort.signal).catch((error) => {
+            const probeId = existing?.probeId ?? randomUUID();
+            const fields = { probe_id: probeId, connection_id: connectionId, installed_runtimes: JSON.stringify(installed) };
+            dslog("runtime_probe.request", "请求 runtime 执行能力探测", fields);
+            if (existing) {
+                dslog("runtime_probe.cache_hit", "复用 runtime 探测结果", { ...fields, cache_state: existing.state });
+                return existing.promise;
+            }
+            const startedAt = Date.now();
+            const complete = (outcome, executionRuntimes) => {
+                dslog("runtime_probe.complete", "runtime 探测聚合结束", {
+                    ...fields, outcome, duration_ms: Date.now() - startedAt, aborted: abort.signal.aborted,
+                    ...(executionRuntimes === undefined ? {} : { execution_runtimes: JSON.stringify(executionRuntimes) }),
+                });
+            };
+            let detection;
+            try {
+                detection = detector(installed, abort.signal, probeId);
+            }
+            catch (error) {
+                complete("threw");
+                throw error;
+            }
+            const pending = detection.then((result) => {
+                const flight = flights.get(key);
+                if (flight)
+                    flights.set(key, { ...flight, state: "resolved" });
+                complete("resolved", result);
+                return result;
+            }, (error) => {
                 flights.delete(key);
+                complete("threw");
                 throw error;
             });
-            flights.set(key, pending);
+            flights.set(key, { promise: pending, probeId, state: "pending" });
             return pending;
         },
         stop() {

package/dist/runtimes/acp-probe-transport.js

@@ -0,0 +1,69 @@
+import { Readable as NodeReadable } from "node:stream";
+import { ReadableStream, WritableStream } from "node:stream/web";
+/** Probe-only counters. Never retain/log chunks, JSON-RPC params, stderr or env values. */
+export class AcpProbeTransport {
+    elapsed;
+    initializeRequestedMs;
+    initializeResponseMs;
+    firstStdinWriteMs;
+    firstStdoutMs;
+    stdinBytesWritten = 0;
+    stdoutBytes = 0;
+    stdoutEnded = false;
+    constructor(elapsed) {
+        this.elapsed = elapsed;
+    }
+    initializeRequested() { this.initializeRequestedMs = this.elapsed(); }
+    initializeResponse() { this.initializeResponseMs = this.elapsed(); }
+    fields() {
+        return {
+            initialize_requested_ms: this.initializeRequestedMs,
+            initialize_response_ms: this.initializeResponseMs,
+            first_stdin_write_ms: this.firstStdinWriteMs,
+            first_stdout_ms: this.firstStdoutMs,
+            stdin_bytes_written: this.stdinBytesWritten,
+            stdout_bytes: this.stdoutBytes,
+            stdout_ended: this.stdoutEnded,
+        };
+    }
+    /** A write callback confirms acceptance by the pipe, NOT receipt by the agent. */
+    writable(stdin) {
+        return new WritableStream({
+            start: (controller) => { stdin.once("error", (error) => controller.error(error)); },
+            write: (chunk) => new Promise((resolve, reject) => {
+                stdin.write(chunk, (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    this.firstStdinWriteMs ??= this.elapsed();
+                    this.stdinBytesWritten += chunk.byteLength;
+                    resolve();
+                });
+            }),
+            close: () => new Promise((resolve, reject) => {
+                stdin.end((error) => error ? reject(error) : resolve());
+            }),
+            abort: () => { stdin.destroy(); },
+        });
+    }
+    /** Observe before NDJSON decoding, without adding a competing 'data' listener. */
+    readable(stdout) {
+        const reader = NodeReadable.toWeb(stdout).getReader();
+        return new ReadableStream({
+            pull: async (controller) => {
+                const item = await reader.read();
+                if (item.done) {
+                    this.stdoutEnded = true;
+                    controller.close();
+                    return;
+                }
+                const chunk = item.value;
+                this.firstStdoutMs ??= this.elapsed();
+                this.stdoutBytes += chunk.byteLength;
+                controller.enqueue(chunk);
+            },
+            cancel: (reason) => reader.cancel(reason),
+        });
+    }
+}

package/dist/runtimes/claude-session-start-hook.js

@@ -0,0 +1,24 @@
+import { writeFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+/** Called by Claude itself before its first user turn. Never reads a transcript. */
+export async function writeClaudeSessionProof(path, nonce, raw) {
+    if (!isAbsolute(path) || !/^[a-f0-9-]{36}$/u.test(nonce))
+        throw new Error("invalid_claude_proof_destination");
+    const input = JSON.parse(raw);
+    if (input.hook_event_name !== "SessionStart" || !["startup", "resume"].includes(String(input.source))
+        || typeof input.session_id !== "string" || !input.session_id)
+        throw new Error("invalid_claude_session_start");
+    await writeFile(path, JSON.stringify({ nonce, source: input.source, sessionId: input.session_id }), { flag: "wx", mode: 0o600 });
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        bytes += Buffer.byteLength(chunk);
+        if (bytes > 64 * 1024)
+            throw new Error("claude_session_start_too_large");
+        chunks.push(Buffer.from(chunk));
+    }
+    await writeClaudeSessionProof(process.argv[2] ?? "", process.argv[3] ?? "", Buffer.concat(chunks).toString("utf8"));
+}

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`);