@nowcrew/daemon 0.6.72 → 0.6.74

package/dist/external-output.js

@@ -8,9 +8,19 @@ function retainedMarkerPrefix(value, marker) {
     }
     return 0;
 }
+/**
+ * 跨 chunk 的契约标签流式解码器:push() 逐段返回标签内文本(供 answerStream 实时转发);
+ * 同时记住整轮里**最后一个完整闭合**的标签块(`lastClosedBlock`),供完结时作为契约答案——
+ * 只有闭合了的块才算数:半截块(被工具调用拆开的前半段)与叙述里提到的开标签
+ * ("我会把结论包在 <marker> 里,先去跑测试")都不会被当成答案(review of a027bf15, C1)。
+ * 所有 runtime 的文本都经此解码器(local-executor 事件循环),因此"后到者胜"在
+ * 覆盖式与增量式 runtime 上语义一致。
+ */
 export class ExternalAnswerDecoder {
     state = "outside";
     pending = "";
+    block = "";
+    closed = null;
     push(text) {
         if (!text)
             return [];
@@ -21,16 +31,32 @@ export class ExternalAnswerDecoder {
     finish() {
         this.pending = "";
         this.state = "outside";
+        this.block = "";
         return [];
     }
+    /** 整轮里最后一个完整闭合的标签块(已 trim);没有闭合过任何块则为 null。 */
+    get lastClosedBlock() {
+        return this.closed;
+    }
     consume(value, output) {
         this.pending = "";
         const marker = this.state === "outside" ? EXTERNAL_ANSWER_OPEN : EXTERNAL_ANSWER_CLOSE;
         const markerAt = value.indexOf(marker);
         if (markerAt >= 0) {
-            if (this.state === "inside" && markerAt > 0)
-                output.push(value.slice(0, markerAt));
-            this.state = this.state === "outside" ? "inside" : "outside";
+            if (this.state === "inside") {
+                const head = value.slice(0, markerAt);
+                if (head)
+                    output.push(head);
+                const completed = `${this.block}${head}`.trim();
+                if (completed)
+                    this.closed = completed;
+                this.block = "";
+                this.state = "outside";
+            }
+            else {
+                this.block = "";
+                this.state = "inside";
+            }
             const remaining = value.slice(markerAt + marker.length);
             if (remaining)
                 this.consume(remaining, output);
@@ -39,14 +65,18 @@ export class ExternalAnswerDecoder {
         const retained = retainedMarkerPrefix(value, marker);
         const safe = retained > 0 ? value.slice(0, -retained) : value;
         this.pending = retained > 0 ? value.slice(-retained) : "";
-        if (this.state === "inside" && safe)
+        if (this.state === "inside" && safe) {
             output.push(safe);
+            this.block += safe;
+        }
     }
 }
 export function decodeExternalOutputEvent(runtime, event, decoder) {
     if (runtime === "claude") {
         const candidate = (event ?? {});
         const delta = candidate.event?.delta;
+        if (candidate.parent_tool_use_id != null)
+            return [];
         if (candidate.type !== "stream_event"
             || candidate.event?.type !== "content_block_delta"
             || delta?.type !== "text_delta"

package/dist/list-models.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isWin } from "./platform.js";
+import { listClaudeModels } from "./runtimes/claude-models.js";
 import { listHermesModels } from "./runtimes/hermes-models.js";
 const execFileRaw = promisify(execFile);
 const MODEL_PROBE_TIMEOUT_MS = 8_000;
@@ -14,6 +15,8 @@ const execFileP = (bin, args) => execFileRaw(bin, args, {
 });
 export async function listRuntimeModels(runtime, options = {}) {
     switch (runtime) {
+        case "claude":
+            return listClaudeModels();
         case "codex":
             return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
         case "cursor":

package/dist/local-executor.js

@@ -27,42 +27,11 @@ import { ProjectProjectionError, } from "./project-skills/reconciler.js";
 import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
 import { projectSkillRuntimeDirectories, redactProjectSkillRuntimeRootText, redactProjectSkillRuntimeRootValue, } from "./project-skills/runtime-launch.js";
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
-import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
+import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
-function memoryPruneFileFactFields(fileFacts) {
-    const fields = {};
-    for (const [label, fact] of Object.entries(fileFacts)) {
-        fields[`${label}_exists`] = fact.exists;
-        fields[`${label}_size`] = fact.size;
-        fields[`${label}_mtime_ms`] = fact.mtime_ms;
-        fields[`${label}_sha256`] = fact.sha256;
-        fields[`${label}_hash_skipped_reason`] = fact.hash_skipped_reason;
-        fields[`${label}_error`] = fact.error;
-        fields[`${label}_markdown_heading_count`] = fact.markdown_heading_count;
-        fields[`${label}_lessons_reference_count`] = fact.lessons_reference_count;
-        fields[`${label}_same_as_shared_path`] = fact.same_as_shared_path;
-    }
-    return fields;
-}
-function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
-    return memoryPruneFileFactFields(fileFacts);
-}
-function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
-    const errorCode = error?.code;
-    dslog("memory_prune.diagnostics_failed", "长期记忆收尾诊断失败", {
-        level: "WARN",
-        execution_id: input.executionId,
-        agent_handle: input.handle,
-        task_key: input.taskKey,
-        prune_trace_id: traceId,
-        diagnostics_phase: phase,
-        error_name: error instanceof Error ? error.name : "unknown",
-        error_code: errorCode,
-    });
-}
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -732,6 +701,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         let observedModel = currentModel;
         let finalText = null;
         let sentViaCrew = false;
+        // 契约答案解码器:除了给 answerStream 实时转发,还记住整轮最后一个**闭合**的标签块。
+        // finalText 只保留"最后一条"助手消息,模型打完 <nowwork_external_answer> 标签后若又干了
+        // 别的(如顺手 git commit),收尾消息会覆盖 finalText,只从 finalText 提取就把已履约的
+        // 结论整段丢掉——server 回落 finalText 后频道里只剩无标签的尾声
+        // (incident: 2026-09-02, boss-alarm 排查结论未投递)。所有 runtime 的文本都喂给它。
         const externalOutput = new ExternalAnswerDecoder();
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
         const consoleFormatter = createConsoleFormatter();
@@ -1011,8 +985,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             finalText: input.captureFinal && finalText !== null
                 ? stripExternalAnswerMarkers(finalText)
                 : null,
-            externalAnswer: input.captureFinal && finalText !== null
-                ? extractExternalAnswer(finalText)
+            // 契约答案 = 整轮最后一个闭合的标签块(六个 runtime 语义一致的"后到者胜",半截块与
+            // 叙述里的开标签不算数);从未闭合过时才回落到对 finalText 的宽容提取,保住"收尾被
+            // 截断"这一老兜底。解码器存的是原文,这里补脱敏。注意这放宽了"externalAnswer 非空
+            // ⇒ finalText 非空"的旧不变式;是否上报仍由 execution-runner 按 exitCode===0 把关。
+            externalAnswer: input.captureFinal
+                ? (externalOutput.lastClosedBlock !== null
+                    ? redactProjectSkillRuntimeRootText(externalOutput.lastClosedBlock, activeProjectSkillRuntimeRoot)
+                    : finalText !== null ? extractExternalAnswer(finalText) : null)
                 : null,
             sentViaCrew,
         };

package/dist/memory-prune-diagnostics.js

@@ -3,6 +3,7 @@ import { createReadStream } from "node:fs";
 import { lstat, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
+import { dslog } from "./slog.js";
 const TRACE_PATTERN = /\[memory-prune trace_id=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]/i;
 export const MEMORY_PRUNE_HASH_LIMIT_BYTES = 10 * 1024 * 1024;
 export const MEMORY_PRUNE_NOTES_MANIFEST_LIMIT = 128;
@@ -391,3 +392,35 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
         outcome = "no_files_changed";
     return { outcome, ...facts };
 }
+// —— 收尾诊断的 SLS 字段拍平与失败日志(自 local-executor 迁入,签名用结构子集避免类型回环) ——
+function memoryPruneFileFactFields(fileFacts) {
+    const fields = {};
+    for (const [label, fact] of Object.entries(fileFacts)) {
+        fields[`${label}_exists`] = fact.exists;
+        fields[`${label}_size`] = fact.size;
+        fields[`${label}_mtime_ms`] = fact.mtime_ms;
+        fields[`${label}_sha256`] = fact.sha256;
+        fields[`${label}_hash_skipped_reason`] = fact.hash_skipped_reason;
+        fields[`${label}_error`] = fact.error;
+        fields[`${label}_markdown_heading_count`] = fact.markdown_heading_count;
+        fields[`${label}_lessons_reference_count`] = fact.lessons_reference_count;
+        fields[`${label}_same_as_shared_path`] = fact.same_as_shared_path;
+    }
+    return fields;
+}
+export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
+    return memoryPruneFileFactFields(fileFacts);
+}
+export function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
+    const errorCode = error?.code;
+    dslog("memory_prune.diagnostics_failed", "长期记忆收尾诊断失败", {
+        level: "WARN",
+        execution_id: input.executionId,
+        agent_handle: input.handle,
+        task_key: input.taskKey,
+        prune_trace_id: traceId,
+        diagnostics_phase: phase,
+        error_name: error instanceof Error ? error.name : "unknown",
+        error_code: errorCode,
+    });
+}

package/dist/runtimes/claude-models.js

@@ -0,0 +1,123 @@
+/**
+ * claude 模型清单探测:上报 CLI 族别名(fable/opus/sonnet/haiku,恒指本机已装版本的最新
+ * 对应模型),并把每个别名解析成具体模型 id 放进展示名——用户反馈"只写 latest 根本不知道
+ * 实际是什么模型"。
+ *
+ * 解析方式:claude 没有模型枚举命令,但 `--print` 会话启动时的 `system/init` 事件明文携带
+ * 解析后的 `model`(2.1.258 实测 opus→claude-opus-5、fable→claude-fable-5-1)。探测把
+ * ANTHROPIC_BASE_URL 指向本机不可达端口(零 API 调用、零 token),`--setting-sources=`
+ * 关掉用户 hooks/项目配置,读到 init 行即 SIGKILL。结果按 CLI 版本缓存:只有全部别名都
+ * 解析成功才缓存,失败的下次请求重试。
+ */
+import { execFile, spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { createInterface } from "node:readline";
+import { promisify } from "node:util";
+import { isWin } from "../platform.js";
+const execFileP = promisify(execFile);
+const PROBE_TIMEOUT_MS = 8_000;
+// 本机丢弃端口:连不上也无所谓,init 事件在任何网络请求之前就已输出。
+const UNROUTABLE_API_BASE = "http://127.0.0.1:9";
+const CLAUDE_ALIASES = [
+    ["fable", "Fable"],
+    ["sonnet", "Sonnet"],
+    ["opus", "Opus"],
+    ["haiku", "Haiku"],
+];
+const DEFAULT_ALIAS = "sonnet";
+const cacheByVersion = new Map();
+/** "2.1.258 (Claude Code)" → "2.1.258";空/异常输出 → ""。 */
+export function normalizeClaudeVersion(raw) {
+    return raw.replace(/\s*\(Claude Code\)\s*$/, "").trim();
+}
+export async function listClaudeModels(deps = defaultDeps) {
+    const version = normalizeClaudeVersion(await deps.probeVersion());
+    const cached = version ? cacheByVersion.get(version) : undefined;
+    if (cached)
+        return cached;
+    const resolved = await Promise.all(CLAUDE_ALIASES.map(async ([alias]) => {
+        try {
+            return await deps.resolveAlias(alias);
+        }
+        catch {
+            return null;
+        }
+    }));
+    const suffix = version ? ` · Claude Code ${version}` : "";
+    const models = CLAUDE_ALIASES.map(([alias, name], index) => {
+        const concrete = resolved[index];
+        return {
+            id: alias,
+            label: `${name} (latest${concrete ? `: ${concrete}` : ""})${suffix}`,
+            ...(alias === DEFAULT_ALIAS ? { default: true } : {}),
+        };
+    });
+    if (version && resolved.every((model) => model !== null))
+        cacheByVersion.set(version, models);
+    return models;
+}
+/** 仅测试用:清空版本缓存。 */
+export function resetClaudeModelCache() {
+    cacheByVersion.clear();
+}
+async function probeVersion() {
+    const { stdout } = await execFileP("claude", ["--version"], {
+        shell: isWin(),
+        timeout: PROBE_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+    });
+    return stdout;
+}
+function resolveAlias(alias) {
+    return new Promise((resolve) => {
+        const child = spawn("claude", [
+            "--model", alias,
+            "--print", "--output-format", "stream-json", "--verbose",
+            "--setting-sources=",
+            "ping",
+        ], {
+            cwd: tmpdir(),
+            env: {
+                ...process.env,
+                ANTHROPIC_BASE_URL: UNROUTABLE_API_BASE,
+                CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+            },
+            shell: isWin(),
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { /* 已退出 */ }
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(null), PROBE_TIMEOUT_MS);
+        child.on("error", () => finish(null));
+        child.on("exit", () => finish(null));
+        const lines = createInterface({ input: child.stdout });
+        lines.on("line", (line) => {
+            const model = initModelOf(line);
+            if (model !== null)
+                finish(model);
+        });
+    });
+}
+/** stream-json 一行 → system/init 事件里的 model;其他行返回 null。 */
+export function initModelOf(line) {
+    try {
+        const event = JSON.parse(line);
+        if (event.type !== "system" || event.subtype !== "init")
+            return null;
+        return typeof event.model === "string" && event.model.trim() ? event.model.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+const defaultDeps = { probeVersion, resolveAlias };

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

@@ -31,6 +31,7 @@ const ERROR_MESSAGE_CAP = 2_000;
 const STDERR_TAIL_CAP = 1_200;
 const STDERR_LINE_CAPTURE_CAP = 1_200;
 const STDERR_LINE_OMITTED = "[stderr line omitted: exceeded capture limit]\n";
+const API_RETRY_DETAIL_CAP = 240;
 const MAX_INITIALIZE_ATTEMPTS = 2;
 // 模型网关瞬态故障(过载/限流)导致 turn 失败时,整轮重试(15s→45s 递进退避):codex 自身
 // 的重试窗口只有 ~10-30s,网关过载往往持续数分钟,这里再兜一层,否则 agent 直接失败
@@ -188,6 +189,21 @@ function logStage(stage, status, attempt, startedAt, detail) {
     process.stderr.write(`[codex-app-server] stage=${stage} status=${status} attempt=${attempt}`
         + ` elapsed_ms=${Date.now() - startedAt}${suffix}\n`);
 }
+function logApiRetry(turnAttempt, apiRetryAttempt, detail, secrets) {
+    const safeDetail = detail === undefined
+        ? undefined
+        : safeErrorMessage(detail, secrets).slice(0, API_RETRY_DETAIL_CAP);
+    process.stderr.write(`[codex-app-server] stage=api_retry status=retry attempt=${apiRetryAttempt}`
+        + ` turn_attempt=${turnAttempt}`
+        + (safeDetail === undefined ? "" : ` error=${JSON.stringify(safeDetail)}`)
+        + "\n");
+}
+function logApiRetrySummary(turnAttempt, apiRetryCount) {
+    if (apiRetryCount === 0)
+        return;
+    process.stderr.write(`[codex-app-server] stage=api_retry status=summary turn_attempt=${turnAttempt}`
+        + ` api_retry_count=${apiRetryCount}\n`);
+}
 function jsonLine(event) {
     if (process.stdout.write(`${JSON.stringify(event)}\n`))
         return Promise.resolve();
@@ -445,6 +461,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
     let threadId = null;
     let announcedThreadId = null;
     let turnId = null;
+    let apiRetryCount = 0;
     let turnHasUnsafeSideEffect = false;
     const startedItemIds = new Set();
     let lastUsage;
@@ -489,10 +506,17 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         }
         if (method === "turn/completed")
             completionResolve(params);
-        if (method === "error" && params.willRetry === false) {
-            const detail = params.error?.message;
-            if (detail)
-                process.stderr.write(sanitizeCodexDiagnostic(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`, secrets));
+        if (method === "error") {
+            const notification = (params !== null && typeof params === "object" ? params : {});
+            const detail = notification.error?.message;
+            if (notification.willRetry === true) {
+                apiRetryCount += 1;
+                logApiRetry(attempt, apiRetryCount, detail, secrets);
+            }
+            else if (notification.willRetry === false && detail) {
+                process.stderr.write(sanitizeCodexDiagnostic(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}`
+                    + ` turn_attempt=${attempt} api_retry_count=${apiRetryCount}\n`, secrets));
+            }
         }
     }, completionReject, secrets);
     let treeStopPromise = null;
@@ -608,10 +632,12 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
                 },
             }),
         });
+        logApiRetrySummary(attempt, apiRetryCount);
         if (completed.turn?.status === "completed")
             return { code: 0, initializeTimedOut: false, unsafeToRetry: false };
         const detail = completed.turn?.error?.message ?? `turn status ${completed.turn?.status ?? "unknown"}`;
-        process.stderr.write(sanitizeCodexDiagnostic(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`, secrets));
+        process.stderr.write(sanitizeCodexDiagnostic(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}`
+            + ` turn_attempt=${attempt} api_retry_count=${apiRetryCount}\n`, secrets));
         const status = completed.turn?.status;
         const retryReason = cancelling ? undefined
             : status === "interrupted" ? "collab_interrupted"
@@ -633,7 +659,8 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         else {
             logStage(activeStage, "error", attempt, stageStartedAt);
         }
-        process.stderr.write(`Codex app-server execution failed: ${safeErrorMessage(error, secrets)}\n`);
+        process.stderr.write(`Codex app-server execution failed: ${safeErrorMessage(error, secrets)}`
+            + ` turn_attempt=${attempt} api_retry_count=${apiRetryCount}\n`);
         return { code: 1, initializeTimedOut, unsafeToRetry: false };
     }
     finally {

package/dist/storage-manifest.js

@@ -324,6 +324,15 @@ async function* scanSourceEntries(input) {
                 type = "file";
             else if (stat.isSymbolicLink())
                 type = "symlink";
+            // Host-local runtime and credential trees are intentionally excluded from
+            // the migration. Do not descend into them: their contents are volatile,
+            // never copied, and would otherwise make the source digest drift between
+            // preflight and apply.
+            if (stat.isDirectory()
+                && transformation === undefined
+                && (classifiedReason === "local_runtime" || classifiedReason === "credential_material")) {
+                continue;
+            }
             if (stat.isDirectory())
                 pending.push(path);
             if (exclusion !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.72",
+  "version": "0.6.74",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",