@nowcrew/daemon 0.6.104 → 0.6.106

package/dist/external-output.js

@@ -42,6 +42,16 @@ function classifyMarkerTag(body) {
         kind: resemblesExternalAnswerTag(name) ? "suspicious" : "other",
     };
 }
+function isUnfinishedAnswerTag(value) {
+    const body = value.slice(1).trim().replace(/^\//u, "");
+    if (classifyMarkerTag(body).kind !== "other")
+        return true;
+    const name = body.toLowerCase().replace(/[_\-\s]/gu, "").replace(/^now+ork/u, "nowork");
+    // A bare '<' or ordinary comparison is not a protocol replacement. Wait until
+    // the prefix identifies the external-answer namespace before rejecting it.
+    return name.length >= "noworkext".length
+        && [CANONICAL_EXTERNAL_ANSWER_TAG, "nowwebexternalanswerplaceholder"].some(tag => tag.startsWith(name));
+}
 function nextMarkerTag(value, from) {
     let cursor = from;
     while (cursor < value.length) {
@@ -97,96 +107,113 @@ function parseExternalAnswerText(value) {
         return { kind: "plain", text: value.trim() };
     return { kind: "marked", text: sections.join("").trim() };
 }
-/**
- * 跨 chunk 的契约标签解码器:push() 在合法闭合后返回完整标签块(供 answerStream 转发);
- * 同时记住整轮里**最后一个完整闭合**的标签块(`lastClosedBlock`),供完结时作为契约答案——
- * 只有闭合了的块才算数:半截块(被工具调用拆开的前半段)与叙述里提到的开标签
- * ("我会把结论包在 <marker> 里,先去跑测试")都不会被当成答案(review of a027bf15, C1)。
- * 所有 runtime 的文本都经此解码器(local-executor 事件循环),因此"后到者胜"在
- * 覆盖式与增量式 runtime 上语义一致。
- */
 export class ExternalAnswerDecoder {
-    state = "outside";
     pending = "";
     block = "";
+    depth = 0;
+    opening = null;
+    invalid = null;
     closed = null;
-    rejected = false;
+    ambiguous = false;
+    revision = 0;
+    rejection = null;
     push(text) {
-        if (!text)
-            return [];
         const output = [];
-        this.consume(this.pending + text, output);
+        this.consume(text, output);
         return output;
     }
+    /** 消息/轮次边界不允许把未闭合的新答案接到下一条消息里。 */
     finish() {
+        if (this.depth > 0)
+            this.reject(this.invalid ?? "incomplete_block");
+        else if (this.pending && isUnfinishedAnswerTag(this.pending))
+            this.reject("incomplete_block");
         this.pending = "";
-        this.state = "outside";
-        this.block = "";
+        this.resetBlock();
         return [];
     }
-    /** 整轮里最后一个完整闭合的标签块(已 trim);没有闭合过任何块则为 null。 */
-    get lastClosedBlock() {
-        return this.rejected ? null : this.closed;
+    get lastClosedBlock() { return this.ambiguous ? null : this.closed; }
+    /** 保留诊断候选,不代表它仍可交付。 */
+    get lastValidClosedBlock() { return this.closed; }
+    get selectionRevision() { return this.revision; }
+    get isAmbiguous() { return this.ambiguous; }
+    get rejectionReason() { return this.rejection; }
+    reject(reason) {
+        this.ambiguous = true;
+        this.rejection = reason;
+        this.revision += 1;
+    }
+    resetBlock() {
+        this.block = "";
+        this.depth = 0;
+        this.opening = null;
+        this.invalid = null;
+    }
+    marker(body, output) {
+        const tag = classifyMarkerTag(body);
+        if (tag.kind === "other") {
+            if (this.depth > 0)
+                this.block += `<${body}>`;
+            return;
+        }
+        const name = body.trim().replace(/^\//u, "").trim().toLowerCase();
+        if (!tag.closing) {
+            if (this.depth === 0) {
+                this.opening = { kind: tag.kind, name };
+                this.invalid = tag.kind === "suspicious" ? "malformed_marker" : null;
+            }
+            else {
+                this.invalid = "nested_marker";
+            }
+            this.depth += 1;
+            return;
+        }
+        if (this.depth === 0) {
+            this.reject("unexpected_close");
+            return;
+        }
+        if (tag.kind === "suspicious" && this.opening?.kind === "known") {
+            this.invalid = "malformed_marker";
+        }
+        this.depth -= 1;
+        if (this.depth > 0)
+            return;
+        const completed = this.block.trim();
+        // 仅精确的空占位块是无内容的尾声。带正文、错配或嵌套的替换仍须拒绝旧答案。
+        const emptyPlaceholder = this.invalid === "malformed_marker"
+            && completed === ""
+            && this.opening?.name === "nowweb_external_answer_placeholder"
+            && name === this.opening.name;
+        if (emptyPlaceholder) {
+            this.rejection = "empty_placeholder";
+        }
+        else if (this.invalid !== null) {
+            this.reject(this.invalid);
+        }
+        else if (completed) {
+            this.closed = completed;
+            this.ambiguous = false;
+            this.revision += 1;
+            output.push(completed);
+        }
+        this.resetBlock();
     }
     consume(value, output) {
-        this.pending = "";
-        const appendInside = (text) => {
-            if (!text)
-                return;
-            this.block += text;
-        };
         for (const character of value) {
             if (this.pending) {
                 this.pending += character;
                 if (character === ">") {
-                    const body = this.pending.slice(1, -1);
-                    const tag = classifyMarkerTag(body);
-                    if (tag.kind === "known" && body.length <= MAX_MARKER_TAG_LENGTH) {
-                        if (tag.closing && this.state === "inside") {
-                            const completed = this.block.trim();
-                            if (completed) {
-                                this.closed = completed;
-                                output.push(completed);
-                            }
-                            this.block = "";
-                            this.state = "outside";
-                        }
-                        else if (!tag.closing && this.state === "outside") {
-                            this.block = "";
-                            this.state = "inside";
-                        }
-                        else if (!tag.closing && this.state === "inside") {
-                            // 嵌套答案标记说明模型正在讨论协议或混入了思考文本;
-                            // 不要把内层短片段误当成最终答案。
-                            this.rejected = true;
-                            this.block = "";
-                            this.state = "outside";
-                        }
-                        else {
-                            this.rejected = true;
-                            this.block = "";
-                            this.state = tag.closing ? "outside" : "inside";
-                        }
-                    }
-                    else if (tag.kind === "suspicious" || tag.kind === "known") {
-                        this.rejected = true;
-                        this.block = "";
-                        this.state = "outside";
-                    }
-                    else if (this.state === "inside") {
-                        appendInside(this.pending);
-                    }
+                    this.marker(this.pending.slice(1, -1), output);
                     this.pending = "";
                 }
                 else if (this.pending.length > MAX_MARKER_TAG_LENGTH + 2) {
                     const tag = classifyMarkerTag(this.pending.slice(1));
-                    if (tag.kind === "suspicious" || tag.kind === "known") {
-                        this.rejected = true;
-                        this.block = "";
-                        this.state = "outside";
+                    if (tag.kind !== "other") {
+                        this.reject("overlong_marker");
+                        this.invalid = "overlong_marker";
                     }
-                    else if (this.state === "inside") {
-                        appendInside(this.pending);
+                    else if (this.depth > 0) {
+                        this.block += this.pending;
                     }
                     this.pending = "";
                 }
@@ -194,8 +221,8 @@ export class ExternalAnswerDecoder {
             else if (character === "<") {
                 this.pending = character;
             }
-            else if (this.state === "inside") {
-                appendInside(character);
+            else if (this.depth > 0) {
+                this.block += character;
             }
         }
     }

package/dist/local-executor.js

@@ -14,7 +14,7 @@ import { spawnKimi } from "./runtimes/kimi.js";
 import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report-uploader.js";
 import { reportDeliveryContext } from "./cloud-report-receipt.js";
-import { extractFinalText, isIncrementalTextEvent, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
+import { extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { NativeThreadContext, isolateMaintenanceSession } from "./native-thread-context.js";
 import { prepareThreadDelivery } from "./thread-input-delivery.js";
@@ -25,7 +25,8 @@ import { providerErrorFromExit } from "./provider-error.js";
 import { createConsoleFormatter } from "./console-formatter.js";
 import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
 export { withLocalExecutionFacts, } from "./local-execution-prompt.js";
-import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
+import { stripExternalAnswerMarkers } from "./external-output.js";
+import { RuntimeAnswerCollector } from "./runtime-answer-collector.js";
 import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
 import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
@@ -691,14 +692,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         let sessionId = launchSessionId;
         let usage;
         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();
+        const answers = new RuntimeAnswerCollector(runtime.name);
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
         const consoleFormatter = createConsoleFormatter(runtime.name);
         let runtimeReady = false;
@@ -816,13 +811,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 activities.push(activity);
                 callbacks.onActivity?.(activity);
             }
-            const extracted = extractFinalText(event);
-            if (extracted) {
-                finalText = isIncrementalTextEvent(event) ? `${finalText ?? ""}${extracted}` : extracted;
-            }
-            for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
+            for (const text of answers.observe(event))
                 callbacks.onExternalOutput?.(text);
-            }
             for (const chunk of consoleFormatter.format(event)) {
                 callbacks.onConsole?.(chunk);
             }
@@ -969,13 +959,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 await writeFile(legacyCwdMarker, "1", "utf8");
             }
         }
-        const externalAnswer = runtime.name === "pi"
-            ? externalOutput.lastClosedBlock
-            : externalOutput.lastClosedBlock
-                ?? (finalText === null ? null : extractExternalAnswer(finalText));
-        const reportFinalText = runtime.name === "pi" && externalAnswer === null
-            ? null
-            : finalText;
+        const { finalText: reportFinalText, externalAnswer, diagnostics } = answers.finish();
+        dslog("execution.answer_extracted", "执行答案提取已完成", {
+            execution_id: input.executionId, runtime: runtime.name, capture_final: input.captureFinal,
+            ...diagnostics,
+        });
         const cloudReportResult = exitCode === 0
             ? await deliverCloudReports({
                 facts: cloudReportUpload, ...reportRoots, before: reportSnapshot, finalText: reportFinalText,

package/dist/runtime-answer-collector.js

@@ -0,0 +1,184 @@
+import { createHash } from "node:crypto";
+import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
+import { extractFinalText, isIncrementalTextEvent, normalizeEvent } from "./normalize.js";
+const TOOL_BOUNDARIES = new Set(["tool", "tool_result", "reading", "sending", "claiming", "checking", "crew"]);
+/** 每次短命 execution 的文本归一化;不调度重试、不保存跨轮状态、不读取工具输出。 */
+export class RuntimeAnswerCollector {
+    runtime;
+    stream = new ExternalAnswerDecoder();
+    streamRevision = 0;
+    rawFinalText = null;
+    startNewTextSegment = false;
+    selected = null;
+    source = "none";
+    blocked = false;
+    allowUnclosedFinal = false;
+    incompleteFinalCandidate = null;
+    resultSeen = false;
+    snapshotCount = 0;
+    rawResultLength = 0;
+    snapshotTextLength = 0;
+    seenSnapshots = new Set();
+    lastSnapshot = null;
+    rejection = null;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    observe(value) {
+        const event = (value ?? {});
+        // 主进程 stdout 同时携带 Task 子 agent 事件,它们不能覆盖主会话结果。
+        if (this.runtime === "claude" && event.parent_tool_use_id != null)
+            return [];
+        if (normalizeEvent(value).some(activity => TOOL_BOUNDARIES.has(activity.kind))) {
+            this.finishStreamMessage();
+            this.allowUnclosedFinal = false;
+            this.startNewTextSegment = true;
+        }
+        if (this.runtime === "claude" && event.type === "stream_event"
+            && (event.event?.type === "message_start" || event.event?.type === "message_stop"
+                || event.event?.type === "content_block_stop")) {
+            this.finishStreamMessage();
+        }
+        if (this.runtime === "claude" && event.type === "assistant") {
+            this.observeSnapshot(event);
+            return [];
+        }
+        const completedText = event.type === "result"
+            || (event.type === "item.completed" && event.item?.type === "agent_message")
+            || (event.type === undefined && event.role === "assistant");
+        if (completedText)
+            this.finishStreamMessage();
+        if (event.type === "result") {
+            this.resultSeen = true;
+            this.rawResultLength = typeof event.result === "string" ? event.result.length : 0;
+        }
+        const extracted = extractFinalText(value);
+        if (event.event?.delta?.type === "text_delta")
+            this.allowUnclosedFinal = false;
+        if (extracted) {
+            this.allowUnclosedFinal = completedText;
+            this.rawFinalText = isIncrementalTextEvent(value) && !this.startNewTextSegment
+                ? `${this.rawFinalText ?? ""}${extracted}` : extracted;
+            this.startNewTextSegment = false;
+        }
+        const output = decodeExternalOutputEvent(this.runtime, value, this.stream);
+        this.syncStream();
+        if (completedText && extracted) {
+            this.finishStreamMessage();
+            this.observeFinalResult(extracted);
+        }
+        return output;
+    }
+    finish() {
+        this.finishStreamMessage();
+        const fallback = this.rawFinalText === null ? null : extractExternalAnswer(this.rawFinalText);
+        // 只在最后一条完整 final 事件上沿用未闭合尾标记兼容,过程中的开标签不成候选。
+        if (this.blocked && this.allowUnclosedFinal && this.rejection === "incomplete_block"
+            && this.incompleteFinalCandidate !== null && this.runtime !== "pi") {
+            this.selected = this.incompleteFinalCandidate;
+            this.source = "final_result";
+            this.blocked = false;
+        }
+        const externalAnswer = this.blocked ? null
+            : this.selected ?? (this.runtime === "pi" ? null : fallback);
+        const finalText = this.blocked || (this.runtime === "pi" && externalAnswer === null)
+            ? null : this.rawFinalText;
+        return {
+            finalText,
+            externalAnswer,
+            diagnostics: {
+                result_seen: this.resultSeen,
+                assistant_snapshot_count: this.snapshotCount,
+                assistant_snapshot_text_length: this.snapshotTextLength,
+                raw_result_length: this.rawResultLength,
+                raw_final_text_length: this.rawFinalText?.length ?? 0,
+                final_text_length: finalText === null ? 0 : stripExternalAnswerMarkers(finalText).length,
+                external_answer_length: externalAnswer?.length ?? 0,
+                retained_candidate_length: this.stream.lastValidClosedBlock?.length ?? 0,
+                answer_source: externalAnswer ? this.source
+                    : finalText !== null && stripExternalAnswerMarkers(finalText) ? "final_result" : "none",
+                answer_rejection_reason: this.rejection ?? this.stream.rejectionReason,
+                answer_ambiguous: this.blocked,
+            },
+        };
+    }
+    finishStreamMessage() {
+        this.stream.finish();
+        this.syncStream();
+    }
+    syncStream() {
+        if (this.stream.selectionRevision === this.streamRevision)
+            return;
+        this.streamRevision = this.stream.selectionRevision;
+        this.applyCandidate(this.stream, "stream");
+    }
+    applyCandidate(decoder, source) {
+        if (decoder.rejectionReason !== null)
+            this.rejection = decoder.rejectionReason;
+        if (decoder.isAmbiguous) {
+            this.selected = null;
+            this.source = "none";
+            this.blocked = true;
+        }
+        else if (decoder.lastClosedBlock !== null) {
+            this.selected = decoder.lastClosedBlock;
+            this.source = source;
+            this.blocked = false;
+        }
+    }
+    observeSnapshot(event) {
+        this.allowUnclosedFinal = false;
+        const blocks = event.message?.content;
+        if (!Array.isArray(blocks)) {
+            this.finishStreamMessage();
+            return;
+        }
+        const texts = blocks.flatMap((block) => block.type === "text" && typeof block.text === "string"
+            ? [block.text] : []);
+        if (texts.length === 0) {
+            this.finishStreamMessage();
+            return;
+        }
+        // 快照只在完成时做权威候选,不再次喂入流式解码器或再次发送 text_delta。
+        const text = JSON.stringify(texts);
+        if (this.lastSnapshot?.id === event.message?.id && this.lastSnapshot?.text === text)
+            return;
+        if (event.message?.id) {
+            const key = `${event.message.id}:${createHash("sha256").update(text).digest("hex")}`;
+            if (this.seenSnapshots.has(key))
+                return;
+            this.seenSnapshots.add(key);
+            if (this.seenSnapshots.size > 128)
+                this.seenSnapshots.delete(this.seenSnapshots.values().next().value);
+        }
+        this.lastSnapshot = { id: event.message?.id, text };
+        this.snapshotCount += 1;
+        this.snapshotTextLength += texts.reduce((sum, item) => sum + item.length, 0);
+        this.finishStreamMessage();
+        for (const item of texts) {
+            const decoder = new ExternalAnswerDecoder();
+            decoder.push(item);
+            decoder.finish();
+            this.applyCandidate(decoder, "assistant_snapshot");
+        }
+    }
+    observeFinalResult(text) {
+        const decoder = new ExternalAnswerDecoder();
+        decoder.push(text);
+        decoder.finish();
+        // 兼容单一 final 块的尾标记截断;已有旧答案后又开始替换时不能拼旧结论回退。
+        this.incompleteFinalCandidate = decoder.rejectionReason === "incomplete_block"
+            && decoder.lastValidClosedBlock === null ? extractExternalAnswer(text) : null;
+        if (decoder.lastClosedBlock !== null) {
+            this.selected = decoder.lastClosedBlock;
+            this.source = "final_result";
+            this.blocked = false;
+            return;
+        }
+        this.applyCandidate(decoder, "final_result");
+        if (!decoder.isAmbiguous && stripExternalAnswerMarkers(text)) {
+            // 权威 result 的普通正文可独立交付,不能回退到已被后续输出否定的旧候选。
+            this.blocked = false;
+        }
+    }
+}

package/package.json

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