@nowcrew/daemon 0.6.98-beta.6 → 0.6.98-beta.8

package/dist/runtimes/observation-mapper.js

@@ -0,0 +1,314 @@
+import { createHash } from "node:crypto";
+const record = (raw) => raw !== null && typeof raw === "object" ? raw : {};
+const string = (raw) => typeof raw === "string" && raw.length > 0 ? raw : undefined;
+const list = (raw) => Array.isArray(raw) ? raw : [];
+const boundedId = (raw) => {
+    const value = string(raw);
+    return value && value.length <= 150 ? value : undefined;
+};
+function usage(raw) {
+    const value = record(raw);
+    const pairs = {
+        inputTokens: value.input_tokens ?? value.inputTokens ?? value.input,
+        outputTokens: value.output_tokens ?? value.outputTokens ?? value.output,
+        cacheReadTokens: value.cache_read_input_tokens ?? value.cachedInputTokens ?? value.cachedReadTokens ?? value.cacheRead ?? record(value.cache).read,
+        cacheCreationTokens: value.cache_creation_input_tokens ?? value.cachedWriteTokens ?? value.cacheWrite ?? record(value.cache).write,
+        reasoningTokens: value.reasoning_tokens ?? value.reasoningTokens ?? value.reasoning,
+        costUsd: value.total_cost_usd ?? value.costUsd ?? record(value.cost).total,
+    };
+    const entries = Object.entries(pairs).filter(([, v]) => typeof v === "number" && Number.isFinite(v) && v >= 0);
+    return entries.length ? Object.fromEntries(entries) : undefined;
+}
+const errorStatus = (raw) => ["failed", "error", "cancelled", "interrupted", "aborted"].includes(String(raw)) ? "error" : "ok";
+/** 原始事件的轻量投影；状态仅属于一次短命 runtime attempt，不从日志邻接猜父子关系。 */
+export function createObservationMapper(runtime, capture, prefix = "run") {
+    let eventIndex = 0;
+    let nativeSessionId;
+    let nativeTurnId;
+    let textBuffer = "";
+    let thoughtBuffer = "";
+    let bufferedText = false;
+    let bufferedThought = false;
+    let bufferTruncated = false;
+    const started = new Map();
+    const emit = (fields) => capture.observe({
+        ...(nativeSessionId ? { nativeSessionId } : {}), ...(nativeTurnId ? { nativeTurnId } : {}), ...fields,
+    });
+    const id = (native) => `${prefix}:${native}`.slice(0, 200);
+    const event = (name, fields = {}) => {
+        emit({ observationId: id(`event:${++eventIndex}`), type: "event", phase: "event", name, ...fields });
+    };
+    const tool = (native, phase, name, fields = {}) => {
+        const callId = boundedId(native);
+        const key = callId ? id(`tool:${callId}`) : undefined;
+        const knownName = key ? started.get(key) : undefined;
+        // pending/running 等状态更新不重置开始时间，缓存仅限一次短命 attempt。
+        if (phase === "start" && knownName !== undefined)
+            return;
+        if (key && phase === "start" && started.size < 20_000)
+            started.set(key, name);
+        const hasStart = key !== undefined && started.has(key);
+        emit({ observationId: key ?? id(`tool-unpaired:${++eventIndex}`), type: "tool", phase: key ? phase : "event",
+            name: phase === "end" && knownName !== undefined ? knownName : name,
+            ...(callId ? { nativeCallId: callId } : {}),
+            ...(!callId ? { unavailable: ["native_call_id", "paired_duration"] }
+                : phase === "end" && !hasStart ? { unavailable: ["start_time"] } : {}), ...fields });
+    };
+    const flush = () => {
+        if (bufferedText)
+            event("model.output", { output: textBuffer, ...(bufferTruncated ? { truncated: true } : {}) });
+        if (bufferedThought)
+            event("model.reasoning", { output: thoughtBuffer, ...(bufferTruncated ? { truncated: true } : {}) });
+        textBuffer = "";
+        thoughtBuffer = "";
+        bufferedText = false;
+        bufferedThought = false;
+        bufferTruncated = false;
+    };
+    const buffer = (value, thought) => {
+        const text = typeof value === "string" ? value : "";
+        if (thought) {
+            bufferedThought = true;
+            thoughtBuffer += text;
+        }
+        else {
+            bufferedText = true;
+            textBuffer += text;
+        }
+        if (textBuffer.length > 8192 || thoughtBuffer.length > 8192)
+            bufferTruncated = true;
+        const clip = (value) => value.slice(0, value.charCodeAt(8191) >= 0xd800 && value.charCodeAt(8191) <= 0xdbff ? 8191 : 8192);
+        textBuffer = clip(textBuffer);
+        thoughtBuffer = clip(thoughtBuffer);
+    };
+    const totals = (raw, scope, name = "runtime.usage") => {
+        const measured = usage(raw);
+        if (measured)
+            event(name, { usage: measured, usageScope: scope });
+    };
+    const codex = (method, raw) => {
+        nativeSessionId = boundedId(raw.threadId) ?? boundedId(record(raw.thread).id) ?? nativeSessionId;
+        nativeTurnId = boundedId(raw.turnId) ?? boundedId(record(raw.turn).id) ?? nativeTurnId;
+        if (method === "thread/tokenUsage/updated") {
+            const explicitTurn = boundedId(raw.turnId);
+            const explicitSession = boundedId(raw.threadId);
+            for (const source of ["last", "total"]) {
+                const measured = usage(record(raw.tokenUsage)[source]);
+                if (!measured)
+                    continue;
+                const owner = source === "last" && explicitTurn ? `turn:${explicitTurn}`
+                    : explicitSession ? `thread:${explicitSession}` : undefined;
+                event(`runtime.usage.${source}`, { usage: measured,
+                    ...(owner ? { observationId: id(`usage:${source}:${owner}`) } : {}),
+                    ...(source === "last" && explicitTurn ? { parentObservationId: id(`turn:${explicitTurn}`) } : {}),
+                    nativeTurnId: explicitTurn,
+                    unavailable: ["usage_scope", "provider_request_id", ...(owner ? [] : ["native_usage_owner"])],
+                });
+            }
+            return;
+        }
+        if (method === "turn/started" || method === "turn/completed") {
+            const turn = record(raw.turn);
+            emit({ observationId: id(`turn:${nativeTurnId ?? ++eventIndex}`), type: "agent",
+                phase: method === "turn/started" ? "start" : "end", name: "agent.turn",
+                ...(method === "turn/completed" ? { status: errorStatus(turn.status), output: record(turn.error).message } : {}),
+                unavailable: ["provider_request_id", "per_generation_input", "per_generation_usage"] });
+            return;
+        }
+        if (method !== "item/started" && method !== "item/completed")
+            return;
+        const item = record(raw.item);
+        const itemType = String(item.type ?? "unknown");
+        const phase = method === "item/started" ? "start" : "end";
+        const explicitTurn = boundedId(raw.turnId);
+        const turnParent = explicitTurn ? { parentObservationId: id(`turn:${explicitTurn}`) } : {};
+        if (["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange", "webSearch", "collabAgentToolCall"].includes(itemType)) {
+            const native = boundedId(item.id);
+            const name = itemType === "mcpToolCall" ? `mcp.${String(item.tool ?? "tool")}` : itemType;
+            tool(native, phase, name.slice(0, 200), {
+                ...turnParent,
+                ...(phase === "start" ? { input: item.arguments ?? item.command ?? item.prompt ?? item.changes } : {
+                    output: item.result ?? item.aggregatedOutput ?? item.error ?? item.agentsStates ?? item.changes,
+                    status: itemType === "commandExecution" && typeof item.exitCode === "number" && item.exitCode !== 0
+                        ? "error" : errorStatus(item.status),
+                }),
+            });
+            if (itemType === "collabAgentToolCall" && phase === "end") {
+                for (const childId of list(item.receiverThreadIds)) {
+                    const child = boundedId(childId);
+                    if (child && native)
+                        emit({ observationId: id(`child:${createHash("sha256").update(JSON.stringify([native, child])).digest("hex")}`), parentObservationId: id(`tool:${native}`),
+                            type: "agent", phase: "event", name: "agent.delegated", nativeSessionId: child,
+                            unavailable: ["child_internal_events", "child_start_time", "child_end_time"] });
+                }
+            }
+            return;
+        }
+        if (phase !== "end")
+            return;
+        const nativeItem = boundedId(item.id);
+        const itemIdentity = { ...turnParent, ...(nativeItem ? { observationId: id(`item:${nativeItem}`) } : {}) };
+        if (itemType === "agentMessage")
+            event("model.output", { output: item.text, ...itemIdentity });
+        else if (itemType === "reasoning")
+            event("model.reasoning", {
+                output: item.summary ?? item.content ?? item.text, ...itemIdentity,
+                ...(!item.summary && !item.content && !item.text ? { unavailable: ["reasoning_content"] } : {}),
+            });
+    };
+    const claude = (raw) => {
+        nativeSessionId = boundedId(raw.session_id) ?? nativeSessionId;
+        const message = record(raw.message);
+        const messageId = boundedId(message.id) ?? boundedId(raw.uuid);
+        const parent = boundedId(raw.parent_tool_use_id);
+        const parentFields = parent ? { parentObservationId: id(`tool:${parent}`) } : {};
+        if (raw.type === "assistant") {
+            for (const [blockIndex, value] of list(message.content).entries()) {
+                const block = record(value);
+                const identity = messageId ? { observationId: id(`message:${messageId}:block:${blockIndex}`) } : {};
+                if (block.type === "tool_use")
+                    tool(block.id, "start", String(block.name ?? "tool").slice(0, 200), { input: block.input, ...parentFields });
+                if (block.type === "text")
+                    event("model.output", { output: block.text, ...parentFields, ...identity });
+                if (block.type === "thinking" || block.type === "redacted_thinking")
+                    event("model.reasoning", {
+                        ...(string(block.thinking) ? { output: block.thinking } : { unavailable: ["reasoning_content"] }), ...parentFields, ...identity,
+                    });
+            }
+            const measured = usage(message.usage);
+            if (measured)
+                event("model.response", { usage: measured, usageScope: "generation",
+                    ...(messageId ? { observationId: id(`message:${messageId}:usage`) } : {}),
+                    ...(string(message.model) ? { model: String(message.model) } : {}),
+                    unavailable: ["request_start_time", "provider_request_id", ...(messageId ? [] : ["native_message_id"])], ...parentFields });
+        }
+        else if (raw.type === "user") {
+            for (const value of list(message.content)) {
+                const block = record(value);
+                if (block.type === "tool_result")
+                    tool(block.tool_use_id, "end", "tool.result", {
+                        output: block.content, status: block.is_error === true ? "error" : "ok", ...parentFields,
+                    });
+            }
+        }
+        else if (raw.type === "system" && boundedId(raw.task_id)) {
+            const task = String(raw.task_id);
+            const callId = boundedId(raw.tool_use_id);
+            emit({ observationId: id(`task:${task}`), type: "agent", name: "agent.delegated",
+                phase: raw.subtype === "task_started" ? "start" : raw.subtype === "task_notification" ? "end" : "event",
+                ...(callId ? { parentObservationId: id(`tool:${callId}`) } : {}), output: raw.summary,
+                ...(raw.status ? { status: errorStatus(raw.status) } : {}) });
+        }
+        else if (raw.type === "result") {
+            totals({ ...record(raw.usage), total_cost_usd: raw.total_cost_usd }, "execution");
+            event("agent.result", { status: raw.is_error === true ? "error" : "ok", output: raw.result });
+        }
+    };
+    const acp = (raw) => {
+        nativeSessionId = boundedId(raw.sessionId) ?? nativeSessionId;
+        const update = raw.update ? record(raw.update) : raw;
+        const kind = update.sessionUpdate;
+        if (kind === "agent_message_chunk" || kind === "agent_thought_chunk") {
+            const part = record(update.content);
+            if (part.type === "text")
+                buffer(part.text, kind === "agent_thought_chunk");
+        }
+        else if (kind === "tool_call" || kind === "tool_call_update") {
+            flush();
+            const complete = ["completed", "failed"].includes(String(update.status));
+            const name = string(update.kind) ? `tool.${update.kind}` : "tool.result";
+            if (kind === "tool_call" && !complete)
+                tool(update.toolCallId, "start", name, { input: update.rawInput });
+            if (complete)
+                tool(update.toolCallId, "end", name, {
+                    input: update.rawInput, output: update.rawOutput ?? update.content, status: errorStatus(update.status),
+                });
+        }
+        else if (raw.type === "nowwork.acp.result") {
+            flush();
+            totals(raw.usage, "turn");
+            event("agent.result", { status: raw.stopReason === "end_turn" ? "ok" : "error", unavailable: ["per_generation_input", "per_generation_usage", "provider_request_id"] });
+        }
+    };
+    const openCode = (raw) => {
+        nativeSessionId = boundedId(raw.sessionID) ?? nativeSessionId;
+        const part = record(raw.part);
+        if (raw.type === "tool_use") {
+            const state = record(part.state);
+            if (state.status === "running" || state.status === "pending")
+                tool(part.callID, "start", String(part.tool ?? "tool"), { input: state.input });
+            if (state.status === "completed" || state.status === "error")
+                tool(part.callID, "end", String(part.tool ?? "tool"), {
+                    input: state.input, output: state.output ?? state.error, status: errorStatus(state.status),
+                });
+        }
+        else if (raw.type === "step_start" || raw.type === "step_finish") {
+            const measured = usage({ ...record(part.tokens), costUsd: part.cost });
+            event(String(raw.type), { ...(measured ? { usage: measured, usageScope: "generation" } : {}),
+                unavailable: ["provider_request_id", "request_start_time", "per_generation_input"] });
+        }
+        else if (raw.type === "text" || raw.type === "reasoning") {
+            event(raw.type === "text" ? "model.output" : "model.reasoning", { output: part.text });
+        }
+        else if (raw.type === "error")
+            event("runtime.error", { status: "error", output: raw.error });
+    };
+    const pi = (raw) => {
+        if (raw.type === "session")
+            nativeSessionId = boundedId(raw.id) ?? nativeSessionId;
+        const assistant = record(raw.assistantMessageEvent);
+        if (raw.type === "message_update" && ["text_end", "thinking_end"].includes(String(assistant.type))) {
+            event(assistant.type === "text_end" ? "model.output" : "model.reasoning", { output: assistant.content });
+        }
+        else if (raw.type === "tool_execution_start") {
+            tool(raw.toolCallId, "start", String(raw.toolName ?? "tool"), { input: raw.args });
+        }
+        else if (raw.type === "tool_execution_end") {
+            tool(raw.toolCallId, "end", String(raw.toolName ?? "tool.result"), { output: raw.result, status: raw.isError === true ? "error" : "ok" });
+        }
+        else if (raw.type === "message_end" && record(raw.message).role === "assistant") {
+            const message = record(raw.message);
+            const measured = usage(message.usage);
+            event("model.response", { ...(measured ? { usage: measured, usageScope: "generation" } : {}),
+                ...(string(message.model) ? { model: String(message.model) } : {}),
+                unavailable: ["provider_request_id", "request_start_time", "per_generation_input"] });
+        }
+        else if (raw.type === "error" || raw.type === "agent_error")
+            event("runtime.error", { status: "error", output: raw.error });
+    };
+    return {
+        enabled: capture.enabled,
+        context(input, unavailable = []) {
+            if (!capture.enabled)
+                return;
+            try {
+                event("context.input", { input, inputBytes: Buffer.byteLength(typeof input === "string" ? input : JSON.stringify(input)),
+                    ...(unavailable.length ? { unavailable: [...unavailable] } : {}) });
+            }
+            catch {
+                event("capture.unsupported", { unavailable: ["input_context"] });
+            }
+        },
+        observe(raw, method) {
+            if (!capture.enabled)
+                return;
+            try {
+                const value = record(raw);
+                if (runtime === "codex")
+                    codex(method ?? "", value);
+                else if (runtime === "claude")
+                    claude(value);
+                else if (runtime === "opencode")
+                    openCode(value);
+                else if (runtime === "pi")
+                    pi(value);
+                else
+                    acp(value);
+            }
+            catch {
+                event("capture.unsupported", { unavailable: ["invalid_runtime_event"] });
+            }
+        },
+        finish: flush,
+    };
+}

package/dist/runtimes/opencode-runner.js

@@ -6,6 +6,8 @@ import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 const ERROR_CAP = 2_000;
 async function readPrompt() {
     process.stdin.setEncoding("utf8");
@@ -25,7 +27,8 @@ export function isOpenCodeSessionNotFound(message) {
     return /(?:session|conversation).*(?:not found|does not exist|unknown|invalid)|(?:not found|unknown|invalid).*(?:session|conversation)/iu
         .test(message);
 }
-async function runAttempt(options, prompt) {
+async function runAttempt(options, prompt, capture, attempt) {
+    const observer = createObservationMapper("opencode", capture, `attempt:${attempt}`);
     const cwd = process.cwd();
     const child = spawn(options.bin, buildOpenCodeArgs({ cwd, ...options }), {
         cwd,
@@ -37,6 +40,7 @@ async function runAttempt(options, prompt) {
     }
     child.stderr.pipe(process.stderr, { end: false });
     const childExit = once(child, "close");
+    observer.context({ prompt });
     child.stdin.end(prompt);
     const decoder = createOpenCodeEventDecoder();
     const lines = createInterface({ input: child.stdout });
@@ -50,6 +54,7 @@ async function runAttempt(options, prompt) {
         catch {
             continue;
         }
+        observer.observe(event);
         for (const normalized of decoder.push(event)) {
             const type = normalized.type;
             const semantic = type === "opencode.text_delta"
@@ -87,17 +92,26 @@ async function runAttempt(options, prompt) {
     return { code: 0, staleSession: false };
 }
 export async function runOpenCode(options) {
+    const capture = createRuntimeObservationCapture("opencode");
+    try {
+        return await runOpenCodeObserved(options, capture);
+    }
+    finally {
+        capture.finish();
+    }
+}
+async function runOpenCodeObserved(options, capture) {
     const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
         sessionId: "unverified-cold-opencode", wakePrompt: await readPrompt() })).prompt;
     if (process.env.CREW_THREAD_ROOT) {
         const { sessionId: _unverified, ...coldOptions } = options;
-        return (await runAttempt(coldOptions, prompt)).code;
+        return (await runAttempt(coldOptions, prompt, capture, 1)).code;
     }
-    const first = await runAttempt(options, prompt);
+    const first = await runAttempt(options, prompt, capture, 1);
     if (!first.staleSession)
         return first.code;
     const { sessionId: _staleSessionId, ...freshOptions } = options;
-    return (await runAttempt(freshOptions, prompt)).code;
+    return (await runAttempt(freshOptions, prompt, capture, 2)).code;
 }
 function optionsFromArgv(argv) {
     const { values } = parseArgs({

package/dist/runtimes/pi-runner.js

@@ -6,11 +6,24 @@ import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildPiArgs, createPiEventDecoder } from "./pi.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 async function readInput() { process.stdin.setEncoding("utf8"); let text = ""; for await (const chunk of process.stdin)
     text += String(chunk); return JSON.parse(text); }
 async function emit(event) { if (process.stdout.write(`${JSON.stringify(event)}\n`))
     return; await once(process.stdout, "drain"); }
 export async function runPi(bin) {
+    const capture = createRuntimeObservationCapture("pi");
+    const observer = createObservationMapper("pi", capture);
+    try {
+        return await runPiObserved(bin, observer);
+    }
+    finally {
+        observer.finish();
+        capture.finish();
+    }
+}
+async function runPiObserved(bin, observer) {
     const input = await readInput();
     // Pi 不持久化原生会话，每轮都须在启动模型前补齐当前线程快照。
     const delivery = await prepareThreadDelivery({
@@ -27,11 +40,14 @@ export async function runPi(bin) {
     let inputError;
     child.stdin.on("error", error => { inputError = error; });
     // Pi print 模式读取 stdin；完整线程历史不能塞进受长度限制的 argv。
+    observer.context({ systemPrompt: input.systemPrompt, prompt: delivery.prompt });
     child.stdin.end(delivery.prompt);
     const decoder = createPiEventDecoder();
     for await (const line of createInterface({ input: child.stdout })) {
         try {
-            for (const event of decoder.push(JSON.parse(line)))
+            const raw = JSON.parse(line);
+            observer.observe(raw);
+            for (const event of decoder.push(raw))
                 await emit(event);
         }
         catch { }
@@ -40,6 +56,7 @@ export async function runPi(bin) {
     if (inputError)
         throw new Error(`Pi prompt delivery failed: ${inputError.message}`);
     const result = decoder.finish();
+    await emit(result.event);
     if (!result.ok) {
         process.stderr.write(`${result.error}\n`);
         return 1;

package/dist/runtimes/pi.js

@@ -3,6 +3,23 @@ export function buildPiArgs(options) {
         ...(options.model ? ["--model", options.model] : []),
         ...(options.reasoning && options.reasoning !== "default" ? ["--thinking", options.reasoning] : [])];
 }
+const TOOL_ARG_KEYS = ["command", "path", "file_path", "pattern", "url"];
+function toolTitle(name, args) {
+    const arg = TOOL_ARG_KEYS.map(key => args?.[key]).find((value) => typeof value === "string" && !!value.trim());
+    return arg ? `${name}(${arg.trim()})` : name;
+}
+function toolResultText(result) {
+    return (result?.content ?? []).map(item => item.type === "text" && typeof item.text === "string" ? item.text : "")
+        .filter(Boolean).join("\n");
+}
+function addUsage(total, next) {
+    if (!next)
+        return total;
+    return {
+        input: (total?.input ?? 0) + (next.input ?? 0), output: (total?.output ?? 0) + (next.output ?? 0),
+        cacheRead: (total?.cacheRead ?? 0) + (next.cacheRead ?? 0), cacheWrite: (total?.cacheWrite ?? 0) + (next.cacheWrite ?? 0),
+    };
+}
 // 保留稳定的原因标识供 server 本地化；不要用 token 数量猜测结束原因。
 function failureReason(message) {
     const reason = message?.stopReason;
@@ -15,7 +32,17 @@ export function createPiEventDecoder() {
     let lastAssistant = null;
     let assistantOpen = false;
     let sawTurnEnd = false;
+    let turnUsageCounted = false;
     let usage;
+    // 正常 stop 可为空（任务可能要求静默）；length/error/aborted 或停在工具轮都必须明确失败。
+    const runFailure = () => error ?? (assistantOpen
+        ? "pi_runtime_failed: incomplete"
+        : failureReason(lastAssistant)
+            ?? (!sawTurnEnd || lastAssistant?.stopReason === "toolUse" ? "pi_runtime_failed: incomplete" : null));
+    const normalizedUsage = () => usage ? { usage: {
+            input_tokens: usage.input ?? 0, output_tokens: usage.output ?? 0,
+            cache_read_input_tokens: usage.cacheRead ?? 0, cache_creation_input_tokens: usage.cacheWrite ?? 0,
+        } } : {};
     return {
         push(raw) {
             const e = (raw ?? {});
@@ -24,8 +51,10 @@ export function createPiEventDecoder() {
                 sessionId = e.id;
                 out.push({ type: "thread.started", thread_id: e.id });
             }
-            if (e.type === "turn_start")
+            if (e.type === "turn_start") {
                 sawTurnEnd = false;
+                turnUsageCounted = false;
+            }
             if ((e.type === "message_start" || e.type === "message_update") && e.message?.role === "assistant") {
                 assistantOpen = true;
                 sawTurnEnd = false;
@@ -38,34 +67,39 @@ export function createPiEventDecoder() {
             if (e.type === "message_update" && ae?.type === "thinking_delta" && typeof ae.delta === "string") {
                 out.push({ type: "pi.thinking_delta", text: ae.delta });
             }
-            if (e.type === "message_update" && typeof ae?.type === "string" && /tool(call|_call)/iu.test(ae.type)) {
-                out.push({ type: "pi.tool_call", ...(ae.name ? { title: ae.name } : {}) });
+            // delta 逐 token 到达，console 只消费块结束事件，避免一个 token 一行。
+            if (e.type === "message_update" && ae?.type === "text_end" && ae.content?.trim()) {
+                out.push({ type: "pi.text", text: ae.content.trim() });
+            }
+            if (e.type === "message_update" && ae?.type === "thinking_end" && ae.content?.trim()) {
+                out.push({ type: "pi.thinking", text: ae.content.trim() });
+            }
+            if (e.type === "tool_execution_start" && typeof e.toolName === "string") {
+                out.push({ type: "pi.tool_call", title: toolTitle(e.toolName, e.args) });
+            }
+            if (e.type === "tool_execution_end") {
+                out.push({ type: "pi.tool_result", content: toolResultText(e.result), is_error: e.isError === true });
             }
             if (e.type === "message_end" && e.message?.role === "assistant") {
                 lastAssistant = e.message;
-                usage = e.message.usage;
+                usage = addUsage(usage, e.message.usage);
+                turnUsageCounted = true;
                 assistantOpen = false;
                 sawTurnEnd = false;
             }
             if (e.type === "turn_end") {
-                // 原生 turn_end 自带本轮消息，不能把工具调用轮的结束当成整次执行成功。
+                // turn_end 只是 Pi 内部一轮：工具调用后会继续，provider 出错还会自动重试（agent_end.willRetry）。
                 if (e.message?.role === "assistant") {
                     lastAssistant = e.message;
-                    usage = e.message.usage;
+                    if (!turnUsageCounted)
+                        usage = addUsage(usage, e.message.usage);
                     assistantOpen = false;
                 }
                 else if (e.message) {
                     lastAssistant = null;
                 }
                 sawTurnEnd = true;
-                const normalizedUsage = usage ? { usage: {
-                        input_tokens: usage.input ?? 0, output_tokens: usage.output ?? 0,
-                        cache_read_input_tokens: usage.cacheRead ?? 0, cache_creation_input_tokens: usage.cacheWrite ?? 0,
-                    } } : {};
-                const failure = failureReason(lastAssistant);
-                out.push(failure
-                    ? { type: "result", is_error: true, result: failure, ...normalizedUsage }
-                    : { type: "turn.completed", ...normalizedUsage });
+                turnUsageCounted = false;
             }
             if (e.type === "error" || e.type === "agent_error") {
                 error = typeof e.error === "string" ? e.error : (e.error?.message ?? "Pi error");
@@ -74,12 +108,12 @@ export function createPiEventDecoder() {
             return out;
         },
         finish() {
-            // 正常 stop 可为空（任务可能要求静默）；length/error/aborted 必须明确失败。
-            const failure = error ?? (assistantOpen
-                ? "pi_runtime_failed: incomplete"
-                : failureReason(lastAssistant)
-                    ?? (!sawTurnEnd || lastAssistant?.stopReason === "toolUse" ? "pi_runtime_failed: incomplete" : null));
-            return { ok: failure === null, ...(failure ? { error: failure } : {}), finalText, sessionId, usage };
+            // 终态只在 stdout 结束后产出一次：重试/中断都以最终状态为准，usage 覆盖所有已完成轮次。
+            const failure = runFailure();
+            const event = failure
+                ? { type: "result", is_error: true, result: failure, ...normalizedUsage() }
+                : { type: "turn.completed", ...normalizedUsage() };
+            return { ok: failure === null, ...(failure ? { error: failure } : {}), finalText, sessionId, usage, event };
         },
     };
 }

package/dist/serve.js

@@ -48,6 +48,7 @@ import { initializedProjectSkillsReconciler } from "./project-skills/initialized
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 import { probeRuntimeHealth } from "./runtime-health.js";
 import { createServeMarketplace } from "./marketplace-serve.js";
+import { createServeRuntimeToolUpdates } from "./runtime-tool-update-serve.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
 import { bindStorageServerIdentity, createStorageIdentityAdmission, } from "./storage-serve-adapter.js";
@@ -122,7 +123,7 @@ export function serve(config, opts = {}) {
             catch { /* reconnect/timeout reconciliation handles a lost status frame */ }
         },
     });
-    const marketplace = createServeMarketplace(config, localSlots, hostCoordinator);
+    const marketplace = createServeMarketplace(config, localSlots, hostCoordinator, async () => ({ ...(await machineRuntime.provider.acquire()).env }));
     const storageIdentityAdmission = createStorageIdentityAdmission(opts.storageRuntime);
     const projectionCoordinator = createAgentProjectionCoordinator();
     const { projectRegistry, projectWorkspaceRegistry, projectDependencyProvisioner } = createProjectRegistryWiring(config.agentsRoot, opts.execution?.dependencies);
@@ -210,6 +211,7 @@ export function serve(config, opts = {}) {
         onError: (code, context) => dslog("execution.runtime_detection_failed", "机器环境或 runtime 探测失败", { level: "ERROR", error_code: code, ...context }),
     });
     machineRuntime.prewarm();
+    const runtimeToolUpdates = createServeRuntimeToolUpdates(config, localSlots, hostCoordinator, async () => ({ ...(await machineRuntime.provider.acquire()).env }), () => machineRuntime.refresh());
     const initializedProjectSkills = initializedProjectSkillsReconciler(() => projectSkillsController.ensureScanned(), projectSkillsReconciler);
     const configuredCapabilities = opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform);
     const prepareCapabilities = async () => daemonCapabilityBindings(process.platform, [...configuredCapabilities, ...await managedDaemonCapabilities(updateEligibility)]);
@@ -842,6 +844,12 @@ export function serve(config, opts = {}) {
                 }
                 return;
             }
+            const runtimeUpdateSocket = ws;
+            if (runtimeToolUpdates.handle(msg, frame => { try {
+                runtimeUpdateSocket?.send(JSON.stringify(frame));
+            }
+            catch { /* Server reconciles via status. */ } }))
+                return;
             if (marketplace.handle(msg, frame => { try {
                 ws?.send(JSON.stringify(frame));
             }
@@ -1326,6 +1334,7 @@ export function serve(config, opts = {}) {
                 webSocketClosed,
                 updateController.drain(),
                 marketplace.stop(),
+                runtimeToolUpdates.stop(),
                 executionFrameQueue,
                 ...executionRuns.values(),
                 ...[...legacyRuns.values()].map((run) => run.done),

package/dist/token.js

@@ -1,3 +1,4 @@
+import { parseObservabilityPolicy } from "./runtime-observation.js";
 export async function mintAgentToken(serverUrl, machineToken, handle, displayName, options = {}, fetchImpl = fetch) {
     const res = await fetchImpl(`${serverUrl}/daemon/agents/token`, {
         method: "POST",
@@ -19,5 +20,7 @@ export async function mintAgentToken(serverUrl, machineToken, handle, displayNam
     if (!res.ok || !body?.success || !body.data) {
         throw new Error(`换取 agent 令牌失败 (HTTP ${res.status}): ${body?.error?.message ?? ""}`);
     }
-    return body.data;
+    const { observability: rawPolicy, ...credential } = body.data;
+    const observability = options.executionId ? parseObservabilityPolicy(rawPolicy) : undefined;
+    return { ...credential, ...(observability ? { observability } : {}) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.98-beta.6",
+  "version": "0.6.98-beta.8",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,13 +18,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "0.4.17",
@@ -46,5 +39,12 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:release-critical": "vitest run test/automatic-daemon-installer.test.ts test/automatic-install-target.test.ts test/automatic-service-migration.test.ts test/computer-cli.test.ts test/computer-service.test.ts test/computer-setup-client.test.ts test/computer-setup-orchestration.test.ts test/computer-setup.test.ts test/daemon-release-version.test.ts test/daemon-update-controller.test.ts test/daemon-update-eligibility.test.ts test/daemon-updater.test.ts test/execution-protocol.test.ts test/machine-info.test.ts --maxWorkers=2 --minWorkers=1",
+    "typecheck": "tsc --noEmit"
   }
-}
+}