@nowcrew/daemon 0.6.102 → 0.6.103

package/dist/runtimes/codex-home.js

@@ -0,0 +1,236 @@
+import { chmod, copyFile, lstat, mkdir, open, readdir, readlink, rename, rm, symlink, unlink, link, writeFile, } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+const PRIVATE_CODEX_HOME = ".codex";
+export function defaultCodexHome(homeDir) {
+    return resolve(homeDir, PRIVATE_CODEX_HOME);
+}
+async function linkIfMissing(source, target) {
+    try {
+        await lstat(target);
+        return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    try {
+        await lstat(source);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    try {
+        await symlink(source, target, "file");
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+function isBelow(root, candidate) {
+    const child = relative(root, candidate);
+    return child !== "" && child !== ".." && !child.startsWith(`..${sep}`) && !child.startsWith(sep);
+}
+async function isExactSymlink(target, expectedSource) {
+    const linkTarget = await readlink(target);
+    return resolve(dirname(target), linkTarget) === resolve(expectedSource);
+}
+async function ensurePrivateSessions(target, legacySource) {
+    try {
+        const current = await lstat(target);
+        if (current.isSymbolicLink()) {
+            if (legacySource === undefined || !(await isExactSymlink(target, legacySource))) {
+                throw new Error(`Refusing to replace unexpected Codex sessions symlink: ${target}`);
+            }
+            const replacement = `${target}.private-${process.pid}-${Math.random().toString(36).slice(2)}`;
+            const legacyBackup = `${target}.legacy-${process.pid}-${Math.random().toString(36).slice(2)}`;
+            try {
+                await mkdir(replacement, { mode: 0o700 });
+                await rename(target, legacyBackup);
+                try {
+                    await rename(replacement, target);
+                }
+                catch (error) {
+                    await rename(legacyBackup, target).catch(() => undefined);
+                    throw error;
+                }
+            }
+            finally {
+                await rm(replacement, { recursive: true, force: true }).catch(() => undefined);
+                await rm(legacyBackup, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        else if (!current.isDirectory()) {
+            throw new Error(`Codex sessions target is not a directory: ${target}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await mkdir(target, { mode: 0o700 });
+    }
+    await chmod(target, 0o700);
+}
+async function atomicCopyFile(source, target, mode) {
+    const parent = dirname(target);
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    const temporary = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+        await copyFile(source, temporary, constants.COPYFILE_EXCL);
+        await chmod(temporary, mode);
+        try {
+            await link(temporary, target);
+            return true;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            return false;
+        }
+    }
+    finally {
+        await unlink(temporary).catch(() => undefined);
+    }
+}
+async function ensurePrivateIndex(target, source) {
+    let current;
+    try {
+        current = await lstat(target);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (current?.isSymbolicLink()) {
+        if (source === undefined || !(await isExactSymlink(target, source))) {
+            throw new Error(`Refusing to replace unexpected Codex session index symlink: ${target}`);
+        }
+        const replacement = `${target}.private-${process.pid}-${Math.random().toString(36).slice(2)}`;
+        const legacyBackup = `${target}.legacy-${process.pid}-${Math.random().toString(36).slice(2)}`;
+        try {
+            try {
+                await lstat(source);
+                await copyFile(source, replacement, constants.COPYFILE_EXCL);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                await writeFile(replacement, "", { encoding: "utf8", flag: "wx" });
+            }
+            await chmod(replacement, 0o600);
+            await rename(target, legacyBackup);
+            try {
+                await rename(replacement, target);
+            }
+            catch (error) {
+                await rename(legacyBackup, target).catch(() => undefined);
+                throw error;
+            }
+        }
+        finally {
+            await rm(replacement, { force: true }).catch(() => undefined);
+            await rm(legacyBackup, { force: true }).catch(() => undefined);
+        }
+        current = undefined;
+    }
+    if (current !== undefined && !current.isFile()) {
+        throw new Error(`Codex session index target is not a regular file: ${target}`);
+    }
+    if (current !== undefined) {
+        await chmod(target, 0o600);
+        return;
+    }
+    if (source !== undefined) {
+        try {
+            await lstat(source);
+            if (await atomicCopyFile(source, target, 0o600))
+                return;
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const handle = await open(target, "wx", 0o600).catch((error) => {
+        if (error.code === "EEXIST")
+            return null;
+        throw error;
+    });
+    await handle?.close();
+}
+async function findRollout(root, sessionId) {
+    const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    });
+    const matches = [];
+    for (const entry of entries) {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findRollout(path, sessionId);
+            if (nested !== null)
+                matches.push(nested);
+        }
+        else if (entry.isFile() && entry.name.includes(sessionId)) {
+            matches.push(path);
+        }
+    }
+    if (matches.length > 1)
+        throw new Error(`Multiple Codex rollout files match session ${sessionId}`);
+    return matches[0] ?? null;
+}
+async function hydrateResumeRollout(sourceSessions, privateSessions, sessionId) {
+    if (sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+        throw new Error("Invalid Codex resume session id");
+    }
+    const sourcePath = await findRollout(sourceSessions, sessionId);
+    if (sourcePath === null)
+        return;
+    const relativePath = relative(sourceSessions, sourcePath);
+    const destination = resolve(privateSessions, relativePath);
+    if (!isBelow(resolve(privateSessions), destination)) {
+        throw new Error("Codex resume rollout escaped the private sessions directory");
+    }
+    let existing;
+    try {
+        existing = await lstat(destination);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (existing !== undefined) {
+        if (!existing.isFile() || existing.isSymbolicLink()) {
+            throw new Error(`Refusing to replace existing Codex rollout: ${destination}`);
+        }
+        return;
+    }
+    const mode = (await lstat(sourcePath)).mode & 0o777;
+    await atomicCopyFile(sourcePath, destination, mode);
+}
+/** Isolate Codex high-volume state per Agent while preserving auth and exact resume. */
+export async function materializeDefaultCodexHome(agentHome, sourceHome, resumeSessionId) {
+    const codexHome = defaultCodexHome(agentHome);
+    await mkdir(codexHome, { recursive: true, mode: 0o700 });
+    await chmod(codexHome, 0o700);
+    const source = sourceHome === undefined ? null : resolve(sourceHome);
+    if (source !== null && source !== codexHome) {
+        await Promise.all([
+            linkIfMissing(join(source, "auth.json"), join(codexHome, "auth.json")),
+            linkIfMissing(join(source, "config.toml"), join(codexHome, "config.toml")),
+        ]);
+    }
+    const sourceSessions = source === null || source === codexHome ? undefined : join(source, "sessions");
+    await ensurePrivateSessions(join(codexHome, "sessions"), sourceSessions);
+    const sourceIndex = source === null || source === codexHome ? undefined : join(source, "session_index.jsonl");
+    await ensurePrivateIndex(join(codexHome, "session_index.jsonl"), sourceIndex);
+    if (sourceSessions !== undefined && resumeSessionId) {
+        await hydrateResumeRollout(sourceSessions, join(codexHome, "sessions"), resumeSessionId);
+    }
+    return codexHome;
+}

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,
+    };
+}