@nowcrew/daemon 0.5.11 → 0.5.13

package/dist/runner.js

@@ -1,255 +1,108 @@
-/**
- * Agent 运行编排:换令牌 → 备 workspace → spawn runtime → 归一化事件流。
- */
-import { createInterface } from "node:readline";
-import { writeFile } from "node:fs/promises";
-import { delimiter, join } from "node:path";
+/** Legacy agent orchestration around the business-neutral local executor. */
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
 import { mintAgentToken } from "./token.js";
-import { prepareWorkspace, rotateAgentSession } from "./workspace.js";
-import { buildSystemPrompt, buildWakePrompt, capWorkLogForInject } from "./prompt.js";
-import { spawnClaude } from "./runtimes/claude.js";
-import { spawnCodex } from "./runtimes/codex.js";
-import { applyProviderEnv, providerFingerprint } from "./provider-env.js";
-import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { normalizeEvent, parseLine, extractFinalText, extractRunMeta } from "./normalize.js";
-import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
-import { toConsoleLines } from "./console.js";
-import { dslog } from "./slog.js";
-import { deliverScheduledReport } from "./scheduled-report.js";
-// 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
-const MEMORY_INJECT_CAP = 6000;
+import { buildSystemPrompt, buildWakePrompt, capMemoryForInject, capWorkLogForInject } from "./prompt.js";
+import { deliverScheduledReport, } from "./scheduled-report.js";
+import { executeLocal } from "./local-executor.js";
+import { ReasoningSchema } from "./execution-protocol.js";
+import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decision.js";
+export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
     claiming: "📌", crew: "⚙️", tool: "🛠️", tool_result: "↩️", done: "✅", error: "❌",
 };
-export async function runAgent(config, input, onActivity = defaultPrint, 
-// 终端透传:每条 stream-json 事件除归一化为状态活动外,再产出 console 行供前端终端窗口渲染。
-onConsole = () => { }) {
-    // 1) 用机器令牌换 per-launch agent 令牌
-    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, input.wakeMessageId);
-    const cfg = cred.config ?? {};
-    const runtime = cfg.runtime ?? config.runtimeBin;
-    const currentModel = cfg.model ?? null;
-    // provider 配置指纹:custom 配置变更后旧会话不可 --resume(见 provider-env.ts)
-    const providerFp = providerFingerprint(runtime, cfg);
-    // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
-    //    先 prepare 拿到 memory/workLog,再 build 系统提示词(注入记忆索引)写入。
-    const ws = await prepareWorkspace({
-        agentsRoot: config.agentsRoot,
-        handle: input.handle,
-        cliPath: config.cliPath,
-        ...(input.taskKey ? { taskKey: input.taskKey } : {}),
-        // 仅在首次创建 MEMORY.md 时,用 agent 的 description 种子化 ## Role
-        ...(cred.config?.description ? { description: cred.config.description } : {}),
-    });
-    // session resume:同任务有历史会话且仍在缓存窗口内 → spawn 时 --resume 复用上下文(省 token)。
-    // 关:CREW_RESUME=off;超 warm 窗口 → 冷启动(避免 cache miss 重写更贵);读取容错(损坏 → 当首轮)。
-    const supportsNativeResume = runtime === "claude";
-    const prior = config.resume && supportsNativeResume ? await readSession(ws.runDir) : null;
-    // 会话身份唯一来源:workspace 的确定性 uuid(ws.agentSessionId)。HEAD 的 warm-window + 开关
-    // 只决定「是否续用」:既有会话(sessionResume)且仍在缓存窗口内 → --resume;否则冷启动。
-    const resuming = supportsNativeResume && ws.sessionResume &&
-        pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel, config.sessionBudgetTokens, config.sessionMaxTurns, providerFp) != null;
-    // 预算轮换判定(仅为留痕/提示区分原因):不带预算参数也会续 → 本次冷启动是预算导致的主动轮换
-    const rotatedForBudget = !resuming && supportsNativeResume && ws.sessionResume &&
-        pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel, 0, 0, providerFp) != null;
-    // soft 预算:仍在续用但上下文已接近 hard 阈值 → 本轮提醒 agent 把现状蒸馏进 work-log(为轮换做准备)
-    const nearBudget = resuming && isNearBudget(prior, config.sessionSoftTokens);
-    // 既有会话但本轮不续用 → 轮换出新 uuid 冷启动(避免 --session-id 撞已存在会话)。
-    const rotated = !!(ws.agentSessionId && ws.sessionResume && !resuming);
-    const launchSessionId = rotated ? await rotateAgentSession(ws.runDir) : ws.agentSessionId;
-    // resume 决策是「会话为什么没续上/为什么重开」的直接证据,把判定依据全量留痕
-    dslog("session.resume_decision", resuming ? "续用上轮会话 (--resume)" : "冷启动新会话", {
-        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
-        task_key: input.taskKey, runtime, model: currentModel,
-        resuming, rotated, session_id: launchSessionId,
-        prior_session_id: prior?.sessionId ?? null,
-        prior_age_ms: prior ? Date.now() - prior.lastRunAt : null,
-        warm_ms: config.resumeWarmMs,
-        decision_reason: !supportsNativeResume ? "runtime_no_resume"
-            : !config.resume ? "resume_disabled"
-                : !ws.sessionResume ? "first_run"
-                    : resuming ? (nearBudget ? "warm_resume_near_budget" : "warm_resume")
-                        : prior?.lastExitOk === false ? "prior_run_crashed"
-                            : rotatedForBudget ? "rotated_for_budget"
-                                : "warm_window_expired_or_model_changed",
-        prior_context_tokens: prior?.contextTokens ?? null,
-        prior_last_exit_ok: prior?.lastExitOk ?? null,
-        budget_tokens: config.sessionBudgetTokens,
+function runtimeName(value) {
+    if (value === "claude" || value === "codex" || value === "kimi")
+        return value;
+    throw new Error(`unsupported runtime: ${value}`);
+}
+export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }) {
+    const credential = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, {
+        ...(input.wakeMessageId ? { wakeThreadRoot: input.wakeMessageId } : {}),
+        ...(input.wakeContextUpToSeq === undefined ? {} : { wakeContextUpToSeq: input.wakeContextUpToSeq }),
+        ...(input.runId ? { agentRunId: input.runId } : {}),
     });
-    const systemPrompt = buildSystemPrompt({
+    const providerConfig = credential.config ?? {};
+    const runtime = runtimeName(providerConfig.runtime ?? config.runtimeBin);
+    const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
+    const baseWake = input.wake ?? buildWakePrompt(input.channelId);
+    const executionId = input.runId ?? `legacy-${randomUUID()}`;
+    const originDecisionFileName = input.wakeOrigin === "wecom"
+        ? `.origin-decision-${executionId}.json`
+        : null;
+    const local = await executeLocal({
+        executionId,
         handle: input.handle,
         channelId: input.channelId,
-        agentId: cred.agentId,
-        homeDir: ws.dir,
-        productName: config.productName,
-        ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
-        // 只注入 MEMORY.md 的索引/角色部分(截断),避免上下文膨胀;明细让 agent 按需读 notes/。
-        memory: ws.memory.length > MEMORY_INJECT_CAP
-            ? ws.memory.slice(0, MEMORY_INJECT_CAP) + "\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md 或 notes/)"
-            : ws.memory,
-        // resume 时进度已在对话历史里,省去重喂 work-log(resume 省 token 的主要来源);首轮才注入。
-        // 注入截断(防随文件膨胀):全文仍在盘上,超限时保头尾、提示按需 Read。
-        ...(resuming ? {} : { workLog: capWorkLogForInject(ws.workLog) }),
-    });
-    await writeFile(ws.systemPromptPath, systemPrompt, "utf8");
-    // 3) spawn runtime,注入 PATH(crew wrapper)、凭证 env、以及 agent 运行时配置
-    //    provider=custom → BYOC(ANTHROPIC_BASE_URL/API_KEY);model → --model;
-    //    reasoning → 原生思考强度(claude --effort / codex -c model_reasoning_effort= /
-    //    kimi KIMI_MODEL_THINKING_EFFORT env;档位白名单在各 runtime 适配器里,白名单外不传)。
-    // resume 时提示 agent 上下文已在,无需从头重读频道(配合不注入 work-log,进一步省 token)。
-    const baseWake = input.wake ?? buildWakePrompt(input.channelId);
-    const distillHint = nearBudget
-        ? `\n(注意:本会话上下文已接近预算,稍后将轮换重启。本轮结束前,把当前状态——阶段/关键结论/下一步/卡点/关键文件路径——完整更新到 $CREW_TASK_LOG,下轮将以它为基础继续。)`
-        : "";
-    const wakePrompt = resuming
-        ? `(继续之前的会话:频道历史与你的进度已在上下文里,不必从头重读;要新消息用 \`crew message read --channel ${input.channelId}\` 增量拉即可。)${distillHint}\n\n${baseWake}`
-        : rotatedForBudget
-            ? `(上下文已轮换:之前的会话过大已重启。你的 work-log 已注入系统提示词末尾,以它为基础继续;频道/线程历史用 crew 命令按需拉取,不必全量重读。)\n\n${baseWake}`
-            : baseWake;
-    const baseEnv = {
-        ...process.env,
-        // 用户自定义 env(表单 ENVIRONMENT VARIABLES):先合入,可覆盖继承的 shell 环境;
-        // 但 PATH/CREW_*/XDG_* 及下方由表单生成的值(ANTHROPIC_*/思考强度)在其后合入,始终以系统为准。
-        ...sanitizeEnvVars(cfg.envVars),
-        PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
-        CREW_SERVER_URL: config.serverUrl,
-        CREW_TOKEN: cred.token,
-        CREW_CHANNEL: input.channelId,
-        // 共享持久记忆 home(MEMORY.md/notes 在此;cwd 是本任务隔离目录)+ 本任务 work-log 路径
-        CREW_HOME: ws.dir,
-        CREW_TASK_LOG: ws.workLogPath,
-        // 唤醒锚点消息 id:有则 `crew task create` 把任务锚定到这条触发消息(讨论与任务锚点统一),
-        // 而非另发一条标题消息当锚点(那会让点开 task 的 thread 永远为空)。
-        ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
-        // per-agent 凭证隔离:XDG 指向本 agent 独立目录(gh/gcloud 等 CLI 的 token 不互相串)。
-        // 不覆盖 HOME(否则会破坏 claude 自身的 ~/.claude 鉴权);常用 CLI 也单独点名隔离。
-        XDG_CONFIG_HOME: join(ws.homeDir, ".config"),
-        XDG_DATA_HOME: join(ws.homeDir, ".local", "share"),
-        XDG_CACHE_HOME: join(ws.homeDir, ".cache"),
-        GH_CONFIG_DIR: join(ws.homeDir, ".config", "gh"),
-        CLOUDSDK_CONFIG: join(ws.homeDir, ".config", "gcloud"),
-        // provider custom(BYOC)端点/密钥注入移至下方 applyProviderEnv(含全局残留清理与配置目录隔离)
-        // reasoning → kimi 无对应 CLI 参数,走 KIMI_MODEL_THINKING_EFFORT env(kimi-code 0.23.0,
-        // 值域 low/medium/high/xhigh/max);claude/codex 改走各自 spawn 原生参数(见下),不再注 env。
-        ...(runtime === "kimi" && cfg.reasoning && KIMI_EFFORT_LEVELS.includes(cfg.reasoning)
-            ? { KIMI_MODEL_THINKING_EFFORT: cfg.reasoning }
-            : {}),
-        // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
-        ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
-        ...(input.scheduled ? { CREW_SCHEDULE_OUTPUT_POLICY: input.scheduled.outputPolicy } : {}),
-    };
-    // provider custom = BYOC:剔除全局 ANTHROPIC_*/Bedrock 残留 + 按鉴权方式注入端点与密钥,
-    // 与机器全局 Claude 登录态/配置互不干扰(细节见 provider-env.ts)。
-    const childEnv = applyProviderEnv(baseEnv, runtime, cfg, ws.homeDir);
-    const child = runtime === "claude"
-        ? spawnClaude({
-            bin: runtime,
-            cwd: ws.runDir, // 本任务隔离工作目录(并行运行互不干扰)
-            systemPromptPath: ws.systemPromptPath,
-            wakePrompt,
-            dangerous: config.dangerous,
-            ...(currentModel ? { model: currentModel } : {}),
-            ...(cfg.reasoning ? { reasoning: cfg.reasoning } : {}),
-            // 一线程一会话(唯一会话机制):首轮/冷启动 --session-id 固定 uuid,warm 续轮 --resume 续上。
-            ...(launchSessionId ? { sessionId: launchSessionId, resume: resuming } : {}),
-            env: childEnv,
-        })
-        : runtime === "codex"
-            ? spawnCodex({
-                bin: runtime,
-                cwd: ws.runDir,
-                wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
-                dangerous: config.dangerous,
-                ...(currentModel ? { model: currentModel } : {}),
-                ...(cfg.reasoning ? { reasoning: cfg.reasoning } : {}),
-                env: childEnv,
-            })
-            : runtime === "kimi"
-                ? spawnKimi({
-                    bin: runtime,
-                    cwd: ws.runDir,
-                    // kimi 与 codex 一样没有 system prompt 参数,拼在 wake prompt 前;
-                    // -p 模式固定 auto 权限,dangerous 无对应 flag(见 runtimes/kimi.ts)。
-                    wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
-                    ...(currentModel ? { model: currentModel } : {}),
-                    env: childEnv,
-                })
-                : (() => {
-                    throw new Error(`unsupported runtime: ${runtime}`);
-                })();
-    // 记下 OS 进程号:排查「进程被谁杀的/是否 OOM」时可与系统日志对齐
-    dslog("run.spawned", `${runtime} 进程已拉起 (pid ${child.pid})`, {
-        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
-        task_key: input.taskKey, runtime, model: currentModel,
-        os_pid: child.pid ?? null, session_id: launchSessionId, resume: resuming,
-    });
-    // 4) 逐行解析 stdout → 归一化 → 回调;顺带抓 session_id(记 lastRunAt 供 warm-window)+ token usage(度量)
-    const activities = [];
-    // 身份是本轮下发的 launchSessionId;仍兜底采 claude 自报的 session_id(理应一致)。
-    let sessionId = launchSessionId;
-    let usage;
-    let observedModel = currentModel;
-    let finalText = null;
-    let sentViaCrew = false;
-    const rl = createInterface({ input: child.stdout });
-    rl.on("line", (line) => {
-        const evt = parseLine(line);
-        if (!evt)
-            return;
-        const meta = extractRunMeta(evt);
-        if (meta.sessionId)
-            sessionId = meta.sessionId;
-        if (meta.usage)
-            usage = meta.usage;
-        if (meta.model)
-            observedModel = meta.model;
-        for (const a of normalizeEvent(evt)) {
-            if (a.kind === "sending")
-                sentViaCrew = true;
-            activities.push(a);
-            onActivity(a);
-        }
-        const extracted = extractFinalText(evt);
-        if (extracted)
-            finalText = extracted;
-        // 同一事件再透传为终端 console 行(独立于状态活动,内容不压缩)。
-        for (const c of toConsoleLines(evt))
-            onConsole(c);
-    });
-    // stderr 除透传本地终端外,再留一段尾部:runtime 启动即崩(如 codex 拒跑)时,
-    // 这是唯一的错误线索,要随 error 活动上送,否则失败对 server/web 完全不可见。
-    let stderrTail = "";
-    child.stderr.on("data", (d) => {
-        process.stderr.write(d);
-        stderrTail = (stderrTail + String(d)).slice(-STDERR_TAIL_CAP);
-    });
-    const { exitCode, spawnError, terminationSignal } = await awaitExit(child);
-    // spawn 本身失败(如 PATH 里没有 runtime 二进制)没有 stderr,把错误并入尾部供上报。
-    const errorTail = [
-        stderrTail.trim(),
-        spawnError,
-        terminationSignal ? `terminated by ${terminationSignal}` : undefined,
-    ].filter(Boolean).join(" ").trim();
-    const finish = exitActivity(runtime, exitCode, errorTail);
-    if (finish) {
-        activities.push(finish);
-        onActivity(finish);
-        if (finish.kind === "error")
-            onConsole({ stream: "error", text: `✖ ${finish.detail ?? finish.label}` });
-    }
-    if (!input.scheduled && (runtime === "codex" || runtime === "kimi") && exitCode === 0 && !sentViaCrew && finalText) {
-        // force:兜底回帖锚定本轮触发消息的线程,语义上必须送达;不 force 时 agent(-p 单发不跑
-        // crew read)游标落后,回帖会被 freshness hold 成 draft(202)而永远不可见。
-        const sent = await sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
-            content: finalText,
+        ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        ...(input.wakeMessageId === undefined ? {} : { wakeMessageId: input.wakeMessageId }),
+        systemPrompt: ({ workspace, resuming }) => buildSystemPrompt({
+            handle: input.handle,
+            channelId: input.channelId,
+            agentId: credential.agentId,
+            homeDir: workspace.dir,
+            productName: config.productName,
+            ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
+            ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
+            memory: capMemoryForInject(workspace.memory),
+            ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
+        }),
+        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;
+        },
+        runtime: {
+            name: runtime,
+            ...(providerConfig.model ? { model: providerConfig.model } : {}),
+            ...(reasoning.success ? { reasoning: reasoning.data } : {}),
+        },
+        effectivePermission: config.dangerous ? "full_access" : "workspace_write",
+        captureFinal: true,
+        launch: {
+            serverUrl: config.serverUrl,
+            token: credential.token,
+            agentId: credential.agentId,
+            agentsRoot: config.agentsRoot,
+            cliPath: config.cliPath,
+            providerConfig,
+            ...(providerConfig.description ? { description: providerConfig.description } : {}),
+            systemEnv: {
+                ...(providerConfig.fastMode ? { CREW_FAST_MODE: "1" } : {}),
+                ...(input.scheduled ? { CREW_SCHEDULE_OUTPUT_POLICY: input.scheduled.outputPolicy } : {}),
+                ...(originDecisionFileName ? {
+                    CREW_WAKE_ORIGIN: "wecom",
+                    CREW_ORIGIN_DECISION_FILE: originDecisionFileName,
+                } : {}),
+            },
+        },
+        session: {
+            enabled: config.resume,
+            warmMs: config.resumeWarmMs,
+            budgetTokens: config.sessionBudgetTokens,
+            softTokens: config.sessionSoftTokens,
+            maxTurns: config.sessionMaxTurns,
+        },
+    }, { onActivity, onConsole });
+    const activities = [...local.activities];
+    if (!input.scheduled && (runtime === "codex" || runtime === "kimi")
+        && local.exitCode === 0 && !local.sentViaCrew && local.finalText) {
+        const sent = await sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
+            content: local.finalText,
             force: true,
             ...(input.wakeMessageId ? { thread: input.wakeMessageId } : {}),
         });
         if (sent.delivered) {
-            const a = { kind: "sending", label: "发消息", detail: `${runtime} final answer fallback` };
-            activities.push(a);
-            onActivity(a);
+            const activity = { kind: "sending", label: "发消息", detail: `${runtime} final answer fallback` };
+            activities.push(activity);
+            onActivity(activity);
         }
         else if (sent.status === 202) {
             process.stderr.write(`${runtime} fallback reply was held as draft (HTTP 202) — not visible in channel\n`);
@@ -258,134 +111,89 @@ onConsole = () => { }) {
             process.stderr.write(`${runtime} fallback send failed (HTTP ${sent.status})\n`);
         }
     }
-    // 5) 落盘 session(下次同任务可 --resume),并打印本轮 token 用量(度量 resume 真省与否)
-    if (config.resume && supportsNativeResume && sessionId) {
-        // turns 只在续用时累加,轮换/新会话从 1 重计(否则 maxTurns 兜底会让之后每轮都轮换)。
-        // contextTokens = 本轮实测上下文体量;本轮无 usage 时续用轮保留上轮值(会话仍在),新会话清零。
-        const contextTokens = usage
-            ? usage.inputTokens + usage.cacheReadTokens + usage.cacheCreationTokens
-            : (resuming ? prior?.contextTokens : undefined);
-        await writeSession(ws.runDir, {
-            sessionId,
-            lastRunAt: Date.now(),
-            turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
-            model: currentModel,
-            providerFingerprint: providerFp,
-            // 非零退出(崩溃/超窗/被杀)标记本会话不健康 → 下轮 pickResumeId 强制冷启动,不再续这个坏会话。
-            lastExitOk: exitCode === 0,
-            ...(contextTokens != null ? { contextTokens } : {}),
-        });
-    }
-    if (usage) {
-        const u = usage;
-        process.stdout.write(`📊 tokens: in=${u.inputTokens} out=${u.outputTokens} cache_read=${u.cacheReadTokens} cache_create=${u.cacheCreationTokens}` +
-            `${u.costUsd != null ? ` cost=$${u.costUsd.toFixed(4)}` : ""} ${resuming ? "(resumed)" : rotatedForBudget ? "(rotated: budget)" : "(fresh)"}\n`);
+    if (local.usage) {
+        const usage = local.usage;
+        process.stdout.write(`📊 tokens: in=${usage.inputTokens} out=${usage.outputTokens} cache_read=${usage.cacheReadTokens} cache_create=${usage.cacheCreationTokens}`
+            + `${usage.costUsd != null ? ` cost=$${usage.costUsd.toFixed(4)}` : ""} ${local.resumed ? "(resumed)" : "(fresh)"}\n`);
     }
-    // 所有可能抛错的本地收尾完成后再投递，避免“报告已发出但随后落盘失败”被 serve catch
-    // 当成另一轮失败再次通知。deliverScheduledReport 自身吞掉网络异常并返回可持久化 outcome。
     const report = input.scheduled
         ? await deliverScheduledReport({
             policy: input.scheduled.outputPolicy,
             title: input.scheduled.title,
-            exitCode,
-            finalText,
-            errorMessage: errorTail || null,
-            send: (content) => sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
+            exitCode: local.exitCode,
+            finalText: local.finalText,
+            errorMessage: local.errorMessage,
+            send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
                 content,
                 force: true,
             }),
         })
         : undefined;
+    const originDecisionPath = originDecisionFileName
+        ? join(local.workspaceRunDir, originDecisionFileName)
+        : null;
+    const originDecision = originDecisionPath ? await readOriginDecisionFile(originDecisionPath) : null;
+    if (originDecisionPath)
+        await resetOriginDecisionFile(originDecisionPath);
     return {
-        exitCode,
+        exitCode: local.exitCode,
         activities,
-        model: observedModel,
+        model: local.model,
         runtime,
-        resumed: resuming,
-        sessionId,
-        errorMessage: errorTail || null,
-        ...(usage ? { usage } : {}),
+        resumed: local.resumed,
+        sessionId: local.sessionId,
+        errorMessage: local.errorMessage,
+        ...(local.usage ? { usage: local.usage } : {}),
         ...(report ? { report } : {}),
+        ...(input.wakeOrigin === "wecom" ? {
+            originDecision: originDecision?.decision ?? "missing",
+            ...(originDecision?.decision === "silent" && originDecision.reason
+                ? { originDecisionReason: originDecision.reason }
+                : {}),
+        } : {}),
     };
 }
-/** runAgent 在 workspace/spawn 等前置阶段抛错时的可见失败兜底。 */
 export async function reportScheduledStartFailure(config, input) {
-    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle);
+    const credential = await mintAgentToken(config.serverUrl, config.machineToken, input.handle);
     return deliverScheduledReport({
         policy: input.scheduled.outputPolicy,
         title: input.scheduled.title,
         exitCode: -1,
         finalText: null,
         errorMessage: input.errorMessage,
-        send: (content) => sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
+        send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
             content,
             force: true,
         }),
     });
 }
-/** 随 error 活动上送的 stderr 尾部上限。 */
-const STDERR_TAIL_CAP = 2000;
-/**
- * 等待子进程结束。必须监听 error:spawn 失败(如 PATH 里没有该 runtime 的二进制)时
- * Node 只发 error 不发 close——不监听会以未处理异常炸掉整个 daemon 进程,
- * 且 close 永不触发导致本轮永久挂起。取先到的事件为准。
- */
-export function awaitExit(child) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const settle = (r) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(r);
-        };
-        child.on("error", (e) => settle({ exitCode: -1, spawnError: e.message }));
-        child.on("close", (code, signal) => settle(code === null
-            ? { exitCode: 128, terminationSignal: signal ?? "unknown" }
-            : { exitCode: code }));
-    });
-}
-/**
- * 进程退出 → 收尾活动。codex/kimi 非零退出必须显式报 error(它们失败时往往一条事件都没吐,
- * 不报就会被 serve 的「本轮结束」伪装成成功);exitCode -1 是 awaitExit 的 spawn 失败哨兵,
- * 任何 runtime 都报(spawn 失败连事件流都没有);kimi 正常退出补 done(其 stream 无轮次结束事件);
- * codex 正常退出与 claude 均返回 null(终态由 turn.completed / result 事件负责)。
- */
-export function exitActivity(runtime, exitCode, stderrTail) {
-    if ((runtime === "codex" || runtime === "kimi" || exitCode === -1) && exitCode !== 0) {
-        return {
-            kind: "error",
-            label: "运行出错",
-            detail: `${runtime} exited with code ${exitCode}${stderrTail ? `: ${stderrTail}` : ""}`,
-        };
-    }
-    if (runtime === "kimi" && exitCode === 0)
-        return { kind: "done", label: "本轮结束" };
-    return null;
-}
-function defaultPrint(a) {
-    const icon = ICON[a.kind] ?? "·";
-    const detail = a.detail ? `  ${a.detail.replace(/\s+/g, " ").slice(0, 120)}` : "";
-    process.stdout.write(`${icon} ${a.label}${detail}\n`);
+export function mergeRunAgentResults(results) {
+    const final = results[results.length - 1];
+    if (!final)
+        throw new Error("cannot merge empty run results");
+    const usages = results.flatMap((result) => result.usage ? [result.usage] : []);
+    const usage = usages.length > 0 ? {
+        inputTokens: usages.reduce((sum, item) => sum + item.inputTokens, 0),
+        outputTokens: usages.reduce((sum, item) => sum + item.outputTokens, 0),
+        cacheReadTokens: usages.reduce((sum, item) => sum + item.cacheReadTokens, 0),
+        cacheCreationTokens: usages.reduce((sum, item) => sum + item.cacheCreationTokens, 0),
+        ...(usages.some((item) => item.costUsd != null)
+            ? { costUsd: usages.reduce((sum, item) => sum + (item.costUsd ?? 0), 0) }
+            : {}),
+    } : undefined;
+    return {
+        ...final,
+        activities: results.flatMap((result) => result.activities),
+        ...(usage ? { usage } : {}),
+    };
 }
-// daemon 侧兜底(server 已校验,这里防旧数据/绕过):只接受合法 key 的 string 值,CREW_ 前缀保留给系统。
-const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-export function sanitizeEnvVars(raw) {
-    if (!raw)
-        return {};
-    const out = {};
-    for (const [k, v] of Object.entries(raw)) {
-        if (typeof v !== "string")
-            continue;
-        if (!ENV_KEY_RE.test(k) || k.toUpperCase().startsWith("CREW_"))
-            continue;
-        out[k] = v;
-    }
-    return out;
+function defaultPrint(activity) {
+    const icon = ICON[activity.kind] ?? "·";
+    const detail = activity.detail ? `  ${activity.detail.replace(/\s+/g, " ").slice(0, 120)}` : "";
+    process.stdout.write(`${icon} ${activity.label}${detail}\n`);
 }
-/** exported for tests */
 export async function sendAgentMessage(serverUrl, token, channelId, body) {
-    const res = await fetch(`${serverUrl}/agent/channels/${encodeURIComponent(channelId)}/messages`, {
+    const response = await fetch(`${serverUrl}/agent/channels/${encodeURIComponent(channelId)}/messages`, {
         method: "POST",
         headers: {
             authorization: `Bearer ${token}`,
@@ -393,7 +201,5 @@ export async function sendAgentMessage(serverUrl, token, channelId, body) {
         },
         body: JSON.stringify(body),
     });
-    // 只有 201(sent)算送达;202 表示被 freshness hold 成 draft——消息没有出现在频道里,
-    // 不能当成功(把 202 当成功正是 kimi/codex fallback 回帖丢失的根因)。
-    return { delivered: res.status === 201, status: res.status };
+    return { delivered: response.status === 201, status: response.status };
 }

package/dist/runtimes/claude.js

@@ -23,8 +23,16 @@ export function buildClaudeArgs(input) {
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }
-    if (input.dangerous)
+    if (input.effectivePermission === undefined) {
+        if (input.dangerous)
+            args.push("--dangerously-skip-permissions");
+    }
+    else if (input.effectivePermission === "full_access") {
         args.push("--dangerously-skip-permissions");
+    }
+    else {
+        args.push("--permission-mode", input.effectivePermission === "sandboxed" ? "plan" : "acceptEdits");
+    }
     args.push(input.wakePrompt);
     return args;
 }

package/dist/runtimes/codex.js

@@ -16,16 +16,32 @@ export function buildCodexArgs(input) {
     if (input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)) {
         args.push("-c", `model_reasoning_effort=${input.reasoning}`);
     }
-    if (input.dangerous)
+    if (input.effectivePermission === "sandboxed")
+        args.push("--sandbox", "read-only");
+    else if (input.effectivePermission === "workspace_write")
+        args.push("--sandbox", "workspace-write");
+    else if (input.effectivePermission === "full_access" || (input.effectivePermission === undefined && input.dangerous)) {
         args.push("--dangerously-bypass-approvals-and-sandbox");
-    args.push(input.wakePrompt);
+    }
+    // `-` instructs codex exec to read the prompt from stdin. Keeping the complete prompt out of argv
+    // avoids Windows' command-line length limit when a thread carries a large wake context.
+    args.push("-");
     return args;
 }
 export function spawnCodex(input) {
-    // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
-    return spawn(input.bin, buildCodexArgs(input), {
+    // stdio 固定 pipe/pipe/pipe;cross-spawn 类型不带该细化,断言之。
+    const child = spawn(input.bin, buildCodexArgs(input), {
         cwd: input.cwd,
         env: input.env,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: ["pipe", "pipe", "pipe"],
     });
+    // Decode at the pipe boundary so split multi-byte characters are buffered correctly before
+    // readline, stderr forwarding, activity reporting, and websocket JSON serialization consume them.
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    // Codex may exit before consuming a large prompt (for example on config/auth failure). In that
+    // case the pipe can emit EPIPE; the child exit code and stderr remain the authoritative failure.
+    child.stdin.on("error", () => undefined);
+    child.stdin.end(input.wakePrompt);
+    return child;
 }

package/dist/runtimes/kimi.js

@@ -14,6 +14,9 @@ import spawn from "cross-spawn";
 // 由 runner 经 KIMI_MODEL_THINKING_EFFORT env 注入;白名单外的值不注。
 export const KIMI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 export function buildKimiArgs(input) {
+    if (input.effectivePermission !== undefined && input.effectivePermission !== "full_access") {
+        throw new Error(`Kimi prompt mode cannot enforce ${input.effectivePermission} permission`);
+    }
     const args = ["--output-format", "stream-json"];
     if (input.model)
         args.push("--model", input.model);