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

package/dist/runtimes/claude-thread-runner.js

@@ -8,6 +8,9 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import spawn from "cross-spawn";
 import { z } from "zod";
 import { prepareThreadDelivery, ThreadDeliveryColdStartRequired } from "../thread-input-delivery.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
+import { observeClaudeContext } from "./observation-context.js";
 const InputSchema = z.object({ bin: z.string().min(1), args: z.array(z.string()),
     wakePrompt: z.string().min(1), sessionId: z.string().min(1).optional(), resume: z.boolean() }).strict();
 class PreflightError extends Error {
@@ -52,7 +55,7 @@ async function bounded(promise, milliseconds, label) {
         clearTimeout(timer);
     }
 }
-async function attempt(input, sessionId, resume, options) {
+async function attempt(input, sessionId, resume, options, observer) {
     const proofDir = await mkdtemp(join(tmpdir(), "nowwork-claude-session-"));
     const proofPath = join(proofDir, "proof.json");
     const nonce = randomUUID();
@@ -182,6 +185,7 @@ async function attempt(input, sessionId, resume, options) {
             // work is outstanding; background shells must not hold it open forever.
             if (event.type === "result")
                 sawResult = pendingAgents.size === 0;
+            observer.observe(event);
             output(event);
         }).catch(error => { fail(error instanceof Error ? error : new Error("claude_event_failed")); void stop().catch(fail); });
     });
@@ -207,6 +211,7 @@ async function attempt(input, sessionId, resume, options) {
         if (resume)
             output({ type: "nowwork.native_resume", runtime: "claude", session_id: sessionId });
         submitted = true;
+        await observeClaudeContext(observer, input.args, delivery.prompt);
         await send({ type: "user", session_id: "", uuid: userId, parent_tool_use_id: null,
             message: { role: "user", content: delivery.prompt } });
         await bounded(accepted.promise, options.ackTimeoutMs ?? 30_000, "claude_user_message_not_acknowledged");
@@ -237,16 +242,25 @@ async function attempt(input, sessionId, resume, options) {
     }
 }
 export async function runClaudeThread(input, options = {}) {
+    const capture = createRuntimeObservationCapture("claude", options.env ?? process.env, options.output);
+    try {
+        return await runClaudeObserved(input, options, capture);
+    }
+    finally {
+        capture.finish();
+    }
+}
+async function runClaudeObserved(input, options, capture) {
     const sessionId = input.sessionId ?? randomUUID();
     try {
-        return await attempt(input, sessionId, input.resume, options);
+        return await attempt(input, sessionId, input.resume, options, createObservationMapper("claude", capture, "attempt:1"));
     }
     catch (error) {
         // The failed attempt never received a business user turn or entered its
         // model/tool loop. Native startup hooks may run again on cold recovery.
         if (!input.resume || !(error instanceof PreflightError || error instanceof ThreadDeliveryColdStartRequired))
             throw error;
-        return attempt(input, randomUUID(), false, options);
+        return attempt(input, randomUUID(), false, options, createObservationMapper("claude", capture, "attempt:2"));
     }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/dist/runtimes/claude.js

@@ -7,6 +7,7 @@ import { posix, win32 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
+import { observationPolicyFromEnvironment } from "../runtime-observation.js";
 // Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
 // 白名单外的值(含 "default" 与 codex 专属档)回落 CLAUDE_DEFAULT_EFFORT,脏数据不影响启动。
 export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -280,14 +281,15 @@ export function buildClaudeArgs(input) {
 }
 export function buildClaudeLaunch(input) {
     const args = buildClaudeArgs(input);
-    if (!input.env.CREW_THREAD_ROOT?.trim())
+    const thread = Boolean(input.env.CREW_THREAD_ROOT?.trim());
+    if (!thread && !observationPolicyFromEnvironment(input.env))
         return { command: input.bin, args, cwd: input.cwd, env: input.env };
     const source = import.meta.url.endsWith(".ts");
     return { command: process.execPath,
         args: [...(source ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href] : []),
-            fileURLToPath(new URL(`./claude-thread-runner.${source ? "ts" : "js"}`, import.meta.url))],
+            fileURLToPath(new URL(`./${thread ? "claude-thread-runner" : "claude-observation-runner"}.${source ? "ts" : "js"}`, import.meta.url))],
         cwd: input.cwd, env: input.env,
-        stdinText: JSON.stringify({ bin: input.bin, args: args.slice(0, -1), wakePrompt: input.wakePrompt,
+        stdinText: JSON.stringify(!thread ? { bin: input.bin, args } : { bin: input.bin, args: args.slice(0, -1), wakePrompt: input.wakePrompt,
             ...(input.sessionId ? { sessionId: input.sessionId } : {}), resume: input.resume === true }) };
 }
 export function spawnClaude(input) {

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

@@ -11,6 +11,8 @@ import { decideTurnRetry, itemMakesTurnUnsafe } from "./codex-turn-retry.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { prepareThreadDelivery, ThreadDeliveryColdStartRequired } from "../thread-input-delivery.js";
 import { codexExecutionPolicyArgs } from "./codex-execution-policy.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 const RunnerInputSchema = z.object({
     systemPrompt: z.string().min(1),
     wakePrompt: z.string().min(1),
@@ -443,7 +445,8 @@ async function stopChildTree(child) {
         throw new Error(`Codex app-server process tree ${child.pid ?? "unknown"} did not exit`);
     }
 }
-async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs, resumeEventSessionId) {
+async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs, resumeEventSessionId, capture) {
+    const observer = createObservationMapper("codex", capture, `attempt:${attempt}`);
     const attemptStartedAt = Date.now();
     const child = spawn(bin, codexAppServerArgs({
         ...(input.projectRootMarkers === undefined ? {} : { projectRootMarkers: input.projectRootMarkers }),
@@ -483,6 +486,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
     let firstProgress = startFirstProgressWatchdog(() => undefined);
     firstProgress.stop();
     const rpc = new CodexRpcClient(child, input.effectivePermission, async (method, params) => {
+        observer.observe(params, method);
         if (method === "thread/tokenUsage/updated") {
             lastUsage = params.tokenUsage;
         }
@@ -625,6 +629,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
         });
         activeStage = "model_init";
         stageStartedAt = Date.now();
+        observer.context({ systemPrompt: input.systemPrompt, prompt: delivery.prompt });
         const started = await rpc.request("turn/start", {
             threadId,
             input: [
@@ -712,6 +717,15 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
     }
 }
 export async function runCodexAppServer(bin, options = {}) {
+    const capture = createRuntimeObservationCapture("codex");
+    try {
+        return await runCodexObserved(bin, options, capture);
+    }
+    finally {
+        capture.finish();
+    }
+}
+async function runCodexObserved(bin, options, capture) {
     const input = await readRunnerInput();
     const initializeTimeoutMs = Math.min(options.initializeTimeoutMs ?? INITIALIZE_RPC_TIMEOUT_MS, INITIALIZE_RPC_TIMEOUT_MS);
     const turnRetryDelayMs = options.turnRetryDelayMs ?? TRANSIENT_TURN_RETRY_DELAY_MS;
@@ -721,7 +735,7 @@ export async function runCodexAppServer(bin, options = {}) {
     let attemptInput = input;
     const resumeEventSessionId = input.resume ? input.sessionId : undefined;
     for (let attempt = 1;; attempt += 1) {
-        const result = await runCodexAppServerAttempt(bin, attemptInput, attempt, initializeTimeoutMs, resumeEventSessionId);
+        const result = await runCodexAppServerAttempt(bin, attemptInput, attempt, initializeTimeoutMs, resumeEventSessionId, capture);
         if (result.restartCold) {
             if (coldRestarted)
                 return result.code;

package/dist/runtimes/deepseek-harness-runner.js

@@ -11,6 +11,8 @@ import { deepSeekHarnessLaunch } from "./deepseek-harness-launch.js";
 import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
 import { mapAcpUpdate } from "./kimi-acp-runner.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 const absolutePath = z.string().refine(isAbsolute, "must be an absolute path");
 export const HarnessInputSchema = z
     .object({
@@ -45,6 +47,17 @@ async function settleWithin(promise, ms) {
     }
 }
 export async function runHarness(input, bin, patchPath) {
+    const capture = createRuntimeObservationCapture("deepseek-harness");
+    const observer = createObservationMapper("deepseek-harness", capture);
+    try {
+        return await runHarnessObserved(input, bin, patchPath, observer);
+    }
+    finally {
+        observer.finish();
+        capture.finish();
+    }
+}
+async function runHarnessObserved(input, bin, patchPath, observer) {
     const delivery = await prepareThreadDelivery({
         env: process.env,
         resumed: false,
@@ -115,6 +128,7 @@ export async function runHarness(input, bin, patchPath) {
         .onNotification(methods.client.session.update, async ({ params }) => {
         if (params.sessionId !== sessionId)
             return;
+        observer.observe(params);
         for (const event of mapAcpUpdate("deepseek-harness", params.update))
             await emit(event);
     });
@@ -141,6 +155,7 @@ export async function runHarness(input, bin, patchPath) {
                 throw new Error("Harness session unavailable");
             await emit({ type: "thread.started", thread_id: sessionId });
             stage = "prompt";
+            observer.context({ systemPrompt: input.systemPrompt, prompt: delivery.prompt });
             const response = await ctx.request(methods.agent.session.prompt, {
                 sessionId,
                 prompt: [{ type: "text", text: delivery.prompt }],
@@ -155,6 +170,7 @@ export async function runHarness(input, bin, patchPath) {
             }
             return response;
         });
+        observer.observe({ type: "nowwork.acp.result", sessionId, ...result });
         const usage = result.usage;
         if (!cancelled)
             await emit({

package/dist/runtimes/kimi-acp-runner.js

@@ -12,6 +12,8 @@ import { augmentedPath } from "../runtime-path.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { startFirstProgressWatchdog } from "./progress-watchdog.js";
 import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 const ERROR_MESSAGE_CAP = 2_000;
 // macOS launchd cold-starts ACP runtimes materially slower than an interactive
 // shell. DeepSeek Harness was measured at ~4.4s before returning initialize
@@ -322,6 +324,18 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     }
 }
 export async function runKimiAcp(requestedOptions) {
+    const provider = requestedOptions.provider ?? "kimi";
+    const capture = createRuntimeObservationCapture(provider);
+    const observer = createObservationMapper(provider, capture);
+    try {
+        return await runKimiObserved(requestedOptions, observer, capture);
+    }
+    finally {
+        observer.finish();
+        capture.finish();
+    }
+}
+async function runKimiObserved(requestedOptions, observer, capture) {
     // Until this adapter verifies native restoration, thread-bound runs are cold.
     const options = process.env.CREW_THREAD_ROOT ? { ...requestedOptions, resume: false } : requestedOptions;
     const provider = options.provider ?? "kimi";
@@ -364,6 +378,7 @@ export async function runKimiAcp(requestedOptions) {
     const app = client({ name: `nowcrew-daemon-${provider}` })
         .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params, permission))
         .onNotification(methods.client.session.update, async ({ params }) => {
+        observer.observe(params);
         acpSemanticProgress = true;
         firstProgress.observe();
         for (const event of mapAcpUpdate(provider, params.update))
@@ -433,6 +448,7 @@ export async function runKimiAcp(requestedOptions) {
                 progressTimedOut = true;
                 void cancel();
             });
+            observer.context({ prompt });
             return nextContext.request(methods.agent.session.prompt, {
                 sessionId,
                 prompt: [{ type: "text", text: prompt }],
@@ -443,6 +459,7 @@ export async function runKimiAcp(requestedOptions) {
             process.stderr.write(`${displayName} produced no semantic progress within the startup window\n`);
             return 1;
         }
+        observer.observe({ type: "nowwork.acp.result", sessionId, ...result });
         const usage = result.usage;
         await jsonLine({
             type: "turn.completed",
@@ -464,6 +481,8 @@ export async function runKimiAcp(requestedOptions) {
             return 1;
         }
         if (provider === "kimi" && !acpSemanticProgress && isKimiAuthenticationRequired(error)) {
+            capture.observe({ observationId: "fallback", type: "event", phase: "event", name: "capture.unsupported",
+                unavailable: ["kimi_legacy_fallback_events"] });
             firstProgress.stop();
             await stopChild(child);
             process.stderr.write("Kimi ACP requires account login; falling back to configured CLI provider transport\n");

package/dist/runtimes/observation-context.js

@@ -0,0 +1,18 @@
+import { readFile } from "node:fs/promises";
+/** 只观察实际发给 runtime 的 prompt；不读取配置、环境变量或凭据文件。 */
+export async function observeClaudeContext(observer, args, prompt) {
+    if (!observer.enabled)
+        return;
+    const at = args.indexOf("--append-system-prompt-file");
+    const path = at >= 0 ? args[at + 1] : undefined;
+    if (!path) {
+        observer.context({ prompt }, ["system_prompt"]);
+        return;
+    }
+    try {
+        observer.context({ systemPrompt: await readFile(path, "utf8"), prompt });
+    }
+    catch {
+        observer.context({ prompt }, ["system_prompt"]);
+    }
+}

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({