@nowcrew/daemon 0.6.103-beta.1 → 0.6.104

package/dist/execution-runner.js

@@ -709,9 +709,11 @@ export async function runExecution(config, input, dependencies) {
                     catch { /* best-effort activity omitted when its envelope cannot fit */ }
                 },
             } : {}),
-            ...(spec.reporting.streamConsole ? {
+            ...(spec.reporting.streamConsole || credential.observability ? {
                 onConsole: (chunk) => {
-                    if (firstOutputTimer !== undefined) {
+                    if (!spec.reporting.streamConsole && chunk.payload?.kind !== "agent_observation")
+                        return;
+                    if (chunk.payload?.kind !== "agent_observation" && firstOutputTimer !== undefined) {
                         clearTimeout(firstOutputTimer);
                         firstOutputTimer = undefined;
                     }
@@ -859,6 +861,7 @@ export async function runExecution(config, input, dependencies) {
             return appendAgentMemoryContext(base, recalledMemory, Math.max(Buffer.byteLength(base, "utf8"), baseSystemPromptBudget - (context.reservedPromptBytes ?? 0)));
         };
         const localInput = {
+            ...(credential.observability ? { observability: credential.observability } : {}),
             executionId: spec.executionId,
             handle: spec.agent.handle,
             channelId: spec.context.channelId,

package/dist/local-executor.js

@@ -46,6 +46,7 @@ import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace,
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
 import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
 import { localMemoryV2Environment } from "./config.js";
+import { observationEnvironment, safeRuntimeObservation } from "./runtime-observation.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -592,7 +593,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 systemPromptPath: workspace.systemPromptPath,
                 systemPrompt: effectiveSystemPrompt,
                 wakePrompt,
-                env: runtimeEnv,
+                env: observationEnvironment(runtimeEnv, input.observability),
                 effectivePermission: input.effectivePermission,
                 ...(launchModel === undefined ? {} : { model: launchModel }),
                 ...(launchReasoning === undefined ? {} : { reasoning: launchReasoning }),
@@ -787,6 +788,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const event = parseLine(line);
             if (!event)
                 return;
+            if (typeof event === "object" && "type" in event && event.type === "nowwork.observation") {
+                const payload = safeRuntimeObservation(event.observation, input.observability);
+                if (payload)
+                    callbacks.onConsole?.({ stream: "system", text: "", payload });
+                return;
+            }
             nativeThreadContext?.observe(event);
             localMemoryTelemetry?.observe(event);
             if (isRuntimeReadyEvent(runtime.name, event))

package/dist/runtime-observation.js

@@ -0,0 +1,219 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const OBSERVABILITY_ENV = "NOWWORK_OBSERVABILITY_POLICY";
+export const ObservabilityPolicySchema = z.object({
+    version: z.literal(1), captureId: z.string().min(1).max(128),
+    contentMode: z.enum(["metadata", "redacted"]),
+}).strict();
+const Id = z.string().min(1).max(200);
+const Count = z.number().int().nonnegative().safe();
+export const RuntimeObservationSchema = z.object({
+    kind: z.literal("agent_observation"), version: z.literal(1), captureId: z.string().min(1).max(128),
+    sourceEventIndex: z.number().int().positive().safe(),
+    runtime: z.enum(["codex", "claude", "kimi", "hermes", "deepseek-harness", "opencode", "pi"]),
+    observationId: Id, parentObservationId: Id.optional(), nativeSessionId: Id.optional(),
+    nativeTurnId: Id.optional(), nativeCallId: Id.optional(),
+    type: z.enum(["agent", "tool", "generation", "event", "span", "retriever"]),
+    phase: z.enum(["start", "end", "event"]), name: z.string().min(1).max(200),
+    observedAt: z.string().datetime({ offset: true }), status: z.enum(["ok", "error"]).optional(),
+    input: z.string().max(8192).optional(), output: z.string().max(8192).optional(), inputBytes: Count.optional(), outputBytes: Count.optional(), model: z.string().min(1).max(200).optional(),
+    usage: z.object({ inputTokens: Count.optional(), outputTokens: Count.optional(), cacheReadTokens: Count.optional(),
+        cacheCreationTokens: Count.optional(), reasoningTokens: Count.optional(), costUsd: z.number().finite().nonnegative().optional() }).strict().optional(),
+    usageScope: z.enum(["generation", "turn", "execution"]).optional(),
+    unavailable: z.array(z.string().min(1).max(120)).max(30).optional(), truncated: z.boolean().optional(),
+    expectedCount: z.number().int().nonnegative().safe().optional(), dropped: z.number().int().nonnegative().safe().optional(),
+}).strict().superRefine((event, ctx) => {
+    if (event.name === "capture.summary") {
+        if (event.phase !== "event" || event.type !== "event" || event.expectedCount === undefined
+            || event.sourceEventIndex !== event.expectedCount + 1)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Invalid capture summary" });
+    }
+    else if (event.expectedCount !== undefined || event.dropped !== undefined) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Only capture summary carries counts" });
+    }
+});
+export function parseObservabilityPolicy(raw) {
+    const parsed = ObservabilityPolicySchema.safeParse(raw);
+    return parsed.success ? parsed.data : undefined;
+}
+export function observationPolicyFromEnvironment(env) {
+    try {
+        return parseObservabilityPolicy(JSON.parse(env[OBSERVABILITY_ENV] ?? "null"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 最后应用，清掉继承/用户配置中的同名变量，旧执行默认关闭。 */
+export function observationEnvironment(env, policy) {
+    const clean = Object.fromEntries(Object.entries(env).filter(([key]) => key.toUpperCase() !== OBSERVABILITY_ENV));
+    const parsed = parseObservabilityPolicy(policy);
+    return parsed ? { ...clean, [OBSERVABILITY_ENV]: JSON.stringify(parsed) } : clean;
+}
+const REDACTED = "[REDACTED]";
+// 与 Server 保持相同的边界规则；原 env/spec 不能先进入本地 journal 再由 Server 清洗。
+const normalizeKey = (key) => key.toLowerCase().replace(/[^a-z0-9]/gu, "");
+const forbiddenContainer = (key) => /^(?:env|envvars|runtimeenv|childenv|inheritedenv|environmentvariables|processenv|environmentplan|spec|executionspec|runtimeconfig|providerconfig)$/u.test(normalizeKey(key));
+const sensitiveKey = (key) => /(?:apikey|accesskey(?:id)?|secretkey|secret|password|passwd|token|authorization|cookie|credential|privatekey|signature)$/u.test(normalizeKey(key))
+    || /^(?:key|sig|session|auth|authkey|authstring)$/u.test(normalizeKey(key));
+function clip(value, limit) {
+    const end = value.charCodeAt(limit - 1);
+    return value.slice(0, end >= 0xd800 && end <= 0xdbff ? limit - 1 : limit);
+}
+function cleanUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (url.username || url.password) {
+            url.username = REDACTED;
+            url.password = "";
+        }
+        for (const name of [...url.searchParams.keys()]) {
+            if (sensitiveKey(name) || /^(?:code|ticket|sessionid|sas)$/iu.test(name) || /^(?:x-amz-|x-oss-|x-goog-)/iu.test(name))
+                url.searchParams.set(name, REDACTED);
+        }
+        if (url.hash && /(?:token|secret|password|credential|key|signature)/iu.test(url.hash))
+            url.hash = REDACTED;
+        return url.toString();
+    }
+    catch {
+        return REDACTED;
+    }
+}
+export function redactObservationText(value) {
+    const urls = [];
+    const text = value.replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s<>"'`]+/giu, raw => {
+        const index = urls.push(cleanUrl(raw)) - 1;
+        return `__NOWWORK_TRACE_URL_${index}__`;
+    });
+    return text
+        .replace(/-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----[\s\S]*?-----END (?:[A-Z ]+ )?PRIVATE KEY-----/gu, REDACTED)
+        .replace(/\b(?:sk|pk)[-_]lf[-_][A-Za-z0-9_-]+\b/gu, REDACTED)
+        .replace(/\b(?:sk[-_][A-Za-z0-9_-]{6,}|gh[pousr]_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,}|npm_[A-Za-z0-9]{12,})\b/gu, REDACTED)
+        .replace(/\b(authorization\s*[:=]\s*)(?:(?:bearer|basic)\s+)?[^\r\n,;]+/giu, `$1${REDACTED}`)
+        .replace(/((?:[A-Za-z0-9_]*(?:api[_-]?key|access[_-]?key|secret|password|passwd|token|cookie|credential|signature)|\b(?:key|session))\s*["']?\s*[:=]\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;}]+)/giu, `$1${REDACTED}`)
+        .replace(/(\/\/[^\s"'`]+\/:_auth(?:token)?\s*=)\s*[^\s"'`]+/giu, `$1${REDACTED}`)
+        .replace(/__NOWWORK_TRACE_URL_(\d+)__/gu, (_match, index) => urls[Number(index)] ?? REDACTED);
+}
+function safeIdentity(value) {
+    // 含敏感值的 ID 用稳定别名，不能把不同调用都改成同一个 [REDACTED]。
+    return redactObservationText(value) === value ? value : `redacted-id:${createHash("sha256").update(value).digest("hex")}`;
+}
+function content(value) {
+    let truncated = false;
+    let remaining = 2000;
+    const visit = (item, depth) => {
+        if (--remaining < 0 || depth > 12) {
+            truncated = true;
+            return "[TRUNCATED]";
+        }
+        if (typeof item === "string") {
+            const text = redactObservationText(item);
+            if (text.length > 8192)
+                truncated = true;
+            return clip(text, 8192);
+        }
+        if (item === null || typeof item === "number" || typeof item === "boolean")
+            return item;
+        if (Array.isArray(item)) {
+            if (item.length > 100)
+                truncated = true;
+            return item.slice(0, 100).map(child => visit(child, depth + 1));
+        }
+        if (typeof item === "object") {
+            const entries = Object.entries(item);
+            if (entries.length > 100)
+                truncated = true;
+            return Object.fromEntries(entries.slice(0, 100).map(([key, child]) => [redactObservationText(key), forbiddenContainer(key) || sensitiveKey(key)
+                    || (normalizeKey(key) === "environment" && typeof child === "object") ? REDACTED : visit(child, depth + 1)]));
+        }
+        return String(item);
+    };
+    let structured = value;
+    if (typeof value === "string" && /^[\s]*[\[{]/u.test(value)) {
+        try {
+            structured = JSON.parse(value);
+        }
+        catch { /* 不是完整JSON则走文本清洗 */ }
+    }
+    const safe = visit(structured, 0);
+    const text = typeof safe === "string" ? safe : JSON.stringify(safe);
+    return { text: clip(text, 8192), truncated: truncated || text.length > 8192 };
+}
+/** 校验与本地内容策略在进入现有 telemetry journal 前再执行一次。 */
+export function safeRuntimeObservation(raw, policy) {
+    if (!policy)
+        return undefined;
+    const result = RuntimeObservationSchema.safeParse(raw);
+    if (!result.success || result.data.captureId !== policy.captureId)
+        return undefined;
+    const { input, output, ...metadata } = result.data;
+    const cleanMetadata = { ...metadata, name: redactObservationText(metadata.name),
+        ...(metadata.model ? { model: redactObservationText(metadata.model) } : {}),
+        ...(metadata.unavailable ? { unavailable: metadata.unavailable.map(value => clip(redactObservationText(value), 120)) } : {}),
+        ...Object.fromEntries(["observationId", "parentObservationId", "nativeSessionId", "nativeTurnId", "nativeCallId"]
+            .flatMap(key => metadata[key] === undefined ? [] : [[key, safeIdentity(metadata[key])]])),
+    };
+    const inputContent = policy.contentMode === "redacted" && input !== undefined ? content(input) : undefined;
+    const outputContent = policy.contentMode === "redacted" && output !== undefined ? content(output) : undefined;
+    const safe = policy.contentMode === "metadata" ? cleanMetadata : {
+        ...cleanMetadata,
+        ...(inputContent ? { input: inputContent.text } : {}),
+        ...(outputContent ? { output: outputContent.text } : {}),
+        ...(inputContent?.truncated || outputContent?.truncated ? { truncated: true } : {}),
+    };
+    const checked = RuntimeObservationSchema.safeParse(safe);
+    return checked.success && Buffer.byteLength(JSON.stringify(checked.data)) <= 24 * 1024 ? checked.data : undefined;
+}
+/** 仅短命 runner 使用；不持久化、不联网、不影响业务事件流。 */
+export function createRuntimeObservationCapture(runtime, env = process.env, emit = event => { process.stdout.write(`${JSON.stringify(event)}\n`); }) {
+    const policy = observationPolicyFromEnvironment(env);
+    let index = 0;
+    let dropped = 0;
+    let finished = false;
+    const send = (fields, summary = false) => {
+        if (!policy || finished)
+            return;
+        if (!summary && index >= 20_000) {
+            dropped += 1;
+            return;
+        }
+        try {
+            const { input, output, ...metadata } = fields;
+            const bytes = (value) => Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value));
+            const inputText = policy.contentMode === "redacted" && input !== undefined ? content(input) : undefined;
+            const outputText = policy.contentMode === "redacted" && output !== undefined ? content(output) : undefined;
+            let candidate = {
+                ...metadata, kind: "agent_observation", version: 1, captureId: policy.captureId,
+                runtime, sourceEventIndex: index + 1, observedAt: fields.observedAt ?? new Date().toISOString(),
+                ...(input === undefined ? {} : { inputBytes: bytes(input) }), ...(output === undefined ? {} : { outputBytes: bytes(output) }),
+                ...(inputText ? { input: inputText.text } : {}), ...(outputText ? { output: outputText.text } : {}),
+                ...(inputText?.truncated || outputText?.truncated ? { truncated: true } : {}),
+            };
+            if (Buffer.byteLength(JSON.stringify(candidate)) > 24 * 1024) {
+                candidate = { ...candidate, ...(inputText ? { input: clip(inputText.text, 1500) } : {}),
+                    ...(outputText ? { output: clip(outputText.text, 1500) } : {}), truncated: true };
+            }
+            const safe = safeRuntimeObservation(candidate, policy);
+            if (!safe) {
+                dropped += 1;
+                return;
+            }
+            index += 1;
+            emit({ type: "nowwork.observation", observation: safe });
+        }
+        catch {
+            dropped += 1; /* 诊断永远不改变 runtime 结果 */
+        }
+    };
+    return {
+        enabled: policy !== undefined,
+        observe: fields => send(fields),
+        finish() {
+            if (finished)
+                return;
+            send({ observationId: "capture.summary", type: "event", phase: "event", name: "capture.summary",
+                expectedCount: index, dropped, ...(index === 0 ? { unavailable: ["runtime_events"] } : {}) }, true);
+            finished = true;
+        },
+    };
+}

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

@@ -0,0 +1,55 @@
+/** 无线程 Claude 的短命观察桥：保留原命令/参数，不引入线程或原生会话约束。 */
+import { createInterface } from "node:readline";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
+import { observeClaudeContext } from "./observation-context.js";
+const Input = z.object({ bin: z.string().min(1), args: z.array(z.string()) }).strict();
+export async function runClaudeObservation(bin, args) {
+    const capture = createRuntimeObservationCapture("claude");
+    const observer = createObservationMapper("claude", capture);
+    await observeClaudeContext(observer, args, args.at(-1) ?? "");
+    const child = spawn(bin, [...args], { cwd: process.cwd(), env: process.env, stdio: ["ignore", "pipe", "pipe"], detached: false });
+    const stopped = new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+    void stopped.catch(() => undefined);
+    const cancel = () => { child.kill("SIGTERM"); };
+    process.once("SIGTERM", cancel);
+    process.once("SIGINT", cancel);
+    try {
+        if (!child.stdout || !child.stderr)
+            throw new Error("Claude observation runner requires output streams");
+        child.stderr.pipe(process.stderr, { end: false });
+        for await (const line of createInterface({ input: child.stdout })) {
+            try {
+                observer.observe(JSON.parse(line));
+            }
+            catch { /* 原非 JSON 输出仍透传 */ }
+            process.stdout.write(`${line}\n`);
+        }
+        return await stopped;
+    }
+    finally {
+        observer.finish();
+        capture.finish();
+        process.off("SIGTERM", cancel);
+        process.off("SIGINT", cancel);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    let raw = "";
+    for await (const chunk of process.stdin) {
+        raw += String(chunk);
+        if (Buffer.byteLength(raw) > 8 * 1024 * 1024)
+            throw new Error("Claude observation input too large");
+    }
+    const input = Input.parse(JSON.parse(raw));
+    runClaudeObservation(input.bin, input.args).then(code => { process.exitCode = code; }).catch(() => {
+        process.stderr.write("Claude observation runner failed\n");
+        process.exitCode = 1;
+    });
+}

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

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

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.103-beta.1",
+  "version": "0.6.104",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",