@nowcrew/daemon 0.6.102 → 0.6.103

package/dist/project-skills/serve-capability.js

@@ -0,0 +1,28 @@
+import { WebSocket } from "ws";
+import { daemonCapabilityBindings, } from "../machine-info.js";
+import { prepareProjectSkillConnectionCapabilities, } from "./capability.js";
+export function createProjectSkillConnectionCapabilityProvider(input) {
+    return async () => daemonCapabilityBindings(input.platform, await prepareProjectSkillConnectionCapabilities(input));
+}
+export function createProjectSkillMachineHelloPublisher(input) {
+    let latest = null;
+    let latestSocket = null;
+    const republish = () => {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+            return;
+        const hello = input.effective(latest, input.status());
+        try {
+            latestSocket.send(JSON.stringify(hello));
+            input.onSent(hello);
+        }
+        catch { /* 非 OPEN,忽略 */ }
+    };
+    return Object.freeze({
+        publish: (hello, socket) => {
+            latest = hello;
+            latestSocket = socket;
+            republish();
+        },
+        republish,
+    });
+}

package/dist/project-skills/serve-startup.js

@@ -0,0 +1,37 @@
+import { createExecutionJournal } from "../execution-journal.js";
+import { reconcileExecutionJournal } from "../execution-recovery.js";
+import { dslog, flushSlog } from "../slog.js";
+export async function initializeProjectSkillProtectedExecutionJournal(input) {
+    return input.startup.initializeAfterLeaseProtection(input.config.agentsRoot, async (snapshot) => {
+        input.protectedExecutionIds.clear();
+        for (const executionId of snapshot)
+            input.protectedExecutionIds.add(executionId);
+        const journal = input.injectedJournal ?? createExecutionJournal(input.config.agentsRoot, {
+            protectedExecutionIds: () => input.protectedExecutionIds,
+            onOperationTiming: (event) => {
+                if (event.operation !== "mark_runtime_ready"
+                    && event.queueWaitMs < 250
+                    && event.operationMs < 250)
+                    return;
+                dslog("execution.journal_operation", "execution journal 操作完成", {
+                    level: event.outcome === "succeeded" ? "INFO" : "ERROR",
+                    execution_id: event.executionId,
+                    operation: event.operation,
+                    outcome: event.outcome,
+                    queue_wait_ms: event.queueWaitMs,
+                    operation_ms: event.operationMs,
+                    total_ms: event.queueWaitMs + event.operationMs,
+                });
+            },
+        });
+        await reconcileExecutionJournal(journal, {
+            agentsRoot: input.config.agentsRoot,
+            serverUrl: input.config.serverUrl,
+            ...(input.profileName === undefined ? {} : { profileName: input.profileName }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
+        });
+        return journal;
+    });
+}

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/codex-home-migration-cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { migrateCodexHome } from "./codex-home-migration.js";
+const { values } = parseArgs({
+    args: process.argv.slice(2),
+    strict: true,
+    options: {
+        "agent-home": { type: "string" },
+        "source-home": { type: "string" },
+        "backup-root": { type: "string" },
+        yes: { type: "boolean", default: false },
+    },
+});
+function required(value, name) {
+    if (!value?.trim())
+        throw new Error(`Missing --${name}`);
+    return value;
+}
+if (!values.yes)
+    throw new Error("Refusing Codex home migration without --yes");
+const result = await migrateCodexHome({
+    agentHome: required(values["agent-home"], "agent-home"),
+    sourceHome: required(values["source-home"], "source-home"),
+    backupRoot: required(values["backup-root"], "backup-root"),
+});
+process.stdout.write(`${result.status}${result.backupDir ? ` backup=${result.backupDir}` : ""}\n`);

package/dist/runtimes/codex-home-migration.js

@@ -0,0 +1,112 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { lstat, mkdir, readlink, rename, rm, symlink, unlink, } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { atomicPrivateWrite } from "../atomic-private-write.js";
+import { defaultCodexHome, materializeDefaultCodexHome } from "./codex-home.js";
+const execFileAsync = promisify(execFile);
+const SQLITE_FILES = ["state_5.sqlite", "state_5.sqlite-wal", "state_5.sqlite-shm"];
+const MARKER_NAME = ".codex-home-migration.json";
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function assertNoOpenSqliteFiles(codexHome) {
+    for (const name of SQLITE_FILES) {
+        const path = join(codexHome, name);
+        if (!(await exists(path)))
+            continue;
+        try {
+            const result = await execFileAsync("lsof", ["-t", "--", path], { encoding: "utf8" });
+            if (result.stdout.trim()) {
+                throw new Error(`Codex SQLite file is still open: ${path}`);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 1)
+                continue;
+            if (code === "ENOENT")
+                throw new Error("lsof is required to verify Codex home quiescence");
+            throw error;
+        }
+    }
+}
+async function symlinkTarget(path) {
+    try {
+        const info = await lstat(path);
+        if (!info.isSymbolicLink())
+            return null;
+        return await readlink(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function migrateCodexHome(input, dependencies = {}) {
+    const agentHome = resolve(input.agentHome);
+    const sourceHome = resolve(input.sourceHome);
+    const backupRoot = resolve(input.backupRoot);
+    const codexHome = defaultCodexHome(agentHome);
+    const sessions = join(codexHome, "sessions");
+    const index = join(codexHome, "session_index.jsonl");
+    const expectedSessions = resolve(sourceHome, "sessions");
+    const expectedIndex = resolve(sourceHome, "session_index.jsonl");
+    const marker = join(codexHome, MARKER_NAME);
+    const sessionLink = await symlinkTarget(sessions);
+    const indexLink = await symlinkTarget(index);
+    if (sessionLink === null && indexLink === null && await exists(marker)) {
+        return { status: "already-migrated" };
+    }
+    if (sessionLink === null || indexLink === null) {
+        throw new Error("Refusing migration: Codex home is not in the complete legacy symlink layout");
+    }
+    if (resolve(codexHome, sessionLink) !== expectedSessions || resolve(codexHome, indexLink) !== expectedIndex) {
+        throw new Error("Refusing migration: legacy symlinks do not point to the configured source home");
+    }
+    await (dependencies.ensureQuiesced ?? assertNoOpenSqliteFiles)(codexHome);
+    const stamp = (dependencies.now ?? (() => new Date()))().toISOString().replaceAll(/[^0-9]/g, "").slice(0, 14);
+    const backupDir = join(backupRoot, `${stamp}-${dependencies.id?.() ?? randomUUID()}`);
+    await mkdir(backupDir, { recursive: true, mode: 0o700 });
+    await symlink(sessionLink, join(backupDir, "sessions"), "dir");
+    await symlink(indexLink, join(backupDir, "session_index.jsonl"), "file");
+    const moved = [];
+    try {
+        for (const name of SQLITE_FILES) {
+            const current = join(codexHome, name);
+            if (await exists(current)) {
+                await rename(current, join(backupDir, name));
+                moved.push(name);
+            }
+        }
+        await materializeDefaultCodexHome(agentHome, sourceHome);
+        await atomicPrivateWrite(marker, JSON.stringify({
+            version: 1,
+            migrated_at: new Date().toISOString(),
+            source_home: sourceHome,
+            backup_dir: backupDir,
+        }) + "\n");
+        return { status: "migrated", backupDir };
+    }
+    catch (error) {
+        for (const name of moved.reverse()) {
+            await rename(join(backupDir, name), join(codexHome, name)).catch(() => undefined);
+        }
+        await rm(sessions, { recursive: true, force: true });
+        await unlink(index).catch(() => undefined);
+        await symlink(sessionLink, sessions, "dir").catch(() => undefined);
+        await symlink(indexLink, index, "file").catch(() => undefined);
+        throw error;
+    }
+}
+export const codexHomeMigrationMarkerName = MARKER_NAME;