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

package/dist/runtime-tool-update-controller.js

@@ -0,0 +1,151 @@
+import { RuntimeToolRequestSchema, RuntimeToolResponseSchema } from "./runtime-tool-update-protocol.js";
+const finalStates = new Set(["completed", "failed", "unknown", "cancelled"]);
+const phaseRank = (state) => ({ queued: 0, preflight: 1, installing: 2, verifying: 3, completed: 4, failed: 4, unknown: 4, cancelled: 4 })[state];
+function advancesProgress(previous, next) {
+    if (finalStates.has(previous.state) || finalStates.has(next.state)
+        || next.operationId !== previous.operationId || JSON.stringify(next.targets) !== JSON.stringify(previous.targets)
+        || next.currentIndex < previous.currentIndex || next.currentIndex >= previous.targets.length
+        || (next.currentIndex === previous.currentIndex && phaseRank(next.state) < phaseRank(previous.state)))
+        return false;
+    return previous.items.every((item, index) => {
+        const candidate = next.items[index];
+        if (!candidate || candidate.runtime !== item.runtime)
+            return false;
+        return finalStates.has(item.state) ? candidate.state === item.state && candidate.errorCode === item.errorCode
+            : phaseRank(candidate.state) >= phaseRank(item.state);
+    });
+}
+export function createRuntimeToolUpdateController(deps) {
+    const entries = new Map();
+    let current = null;
+    let stopped = false;
+    let orphaned = false;
+    const now = deps.now ?? Date.now;
+    const date = () => new Date(now()).toISOString();
+    const wait = deps.wait ?? (() => new Promise(resolve => setTimeout(resolve, 500)));
+    const fail = (error) => ({ ok: false, error });
+    const result = (data) => ({ ok: true, data });
+    const set = (entry, patch) => { entry.operation = { ...entry.operation, ...patch, updatedAt: date() }; };
+    async function execute(entry) {
+        const deadline = now() + 10 * 60_000;
+        let acceptingProgress = false;
+        let lease = null;
+        try {
+            while (!stopped && entry.operation.state === "queued" && now() < deadline && !lease) {
+                lease = await deps.acquire();
+                if (!lease)
+                    await wait();
+            }
+            if (entry.operation.state === "cancelled")
+                return;
+            if (!lease || stopped || now() >= deadline) {
+                set(entry, { state: "failed", errorCode: "runtime_busy" });
+                return;
+            }
+            set(entry, { state: "preflight" });
+            // Mark unsafe before spawning: an exception or lost response cannot authorize another writer.
+            entry.processStopped = false;
+            acceptingProgress = true;
+            const output = await deps.run(entry.request, raw => {
+                if (!acceptingProgress)
+                    return;
+                const parsed = RuntimeToolResponseSchema.safeParse(raw);
+                if (parsed.success && parsed.data.operation && advancesProgress(entry.operation, parsed.data.operation))
+                    entry.operation = parsed.data.operation;
+            }, lease.protectProcessGroup);
+            acceptingProgress = false;
+            const data = RuntimeToolResponseSchema.parse(output.data);
+            entry.processStopped = output.processStopped;
+            if (!data.operation || data.operation.operationId !== entry.operation.operationId
+                || JSON.stringify(data.operation.targets) !== JSON.stringify(entry.request.targets)
+                || data.operation.currentIndex < entry.operation.currentIndex || !finalStates.has(data.operation.state))
+                throw new Error("operation_mismatch");
+            entry.operation = data.operation;
+            if (!entry.processStopped)
+                set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        catch {
+            acceptingProgress = false;
+            set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        finally {
+            acceptingProgress = false;
+            // Retain the barrier if process-group termination could not be proved.
+            if (entry.processStopped) {
+                try {
+                    await lease?.release();
+                }
+                catch {
+                    entry.processStopped = false;
+                    set(entry, { state: "unknown", errorCode: "operation_unknown" });
+                }
+            }
+        }
+    }
+    return {
+        async handle(raw) {
+            const parsed = RuntimeToolRequestSchema.safeParse(raw);
+            if (!parsed.success || stopped)
+                return fail("invalid_request");
+            const request = parsed.data;
+            if (request.action === "inspect") {
+                try {
+                    const data = RuntimeToolResponseSchema.parse((await deps.run(request)).data);
+                    return data.snapshot ? result(data) : fail("inspection_failed");
+                }
+                catch {
+                    return fail("inspection_failed");
+                }
+            }
+            const entry = entries.get(request.operationId);
+            if (request.action === "start") {
+                if (entry)
+                    return result({ operation: entry.operation });
+                if (orphaned || [...entries.values()].some(x => x.operation.state === "unknown"))
+                    return fail("operation_unknown");
+                if (current)
+                    return fail("runtime_busy");
+                if (entries.size >= 100)
+                    return fail("operation_limit");
+                if (new Set(request.targets.map(t => t.installation.runtime)).size !== request.targets.length)
+                    return fail("invalid_request");
+                const operation = { operationId: request.operationId, state: "queued", currentIndex: 0, targets: request.targets,
+                    items: request.targets.map(t => ({ runtime: t.installation.runtime, state: "queued", errorCode: null })), updatedAt: date(), errorCode: null };
+                const next = { operation, request, processStopped: true };
+                entries.set(request.operationId, next);
+                current = execute(next).finally(() => { current = null; });
+                return result({ operation });
+            }
+            if (!entry) {
+                orphaned = true;
+                return fail("operation_unknown");
+            }
+            if (request.action === "status")
+                return result({ operation: entry.operation });
+            if (request.action === "cancel") {
+                if (entry.operation.state !== "queued")
+                    return fail("already_started");
+                set(entry, { state: "cancelled", items: entry.operation.items.map(x => ({ ...x, state: "cancelled" })) });
+                return result({ operation: entry.operation });
+            }
+            if (!entry.processStopped || current)
+                return fail("operation_unknown");
+            try {
+                const output = await deps.run({ action: "inspect", runner: entry.request.runner });
+                const snapshot = RuntimeToolResponseSchema.parse(output.data).snapshot;
+                if (!snapshot || !output.processStopped)
+                    return fail("operation_unknown");
+                const matches = entry.operation.targets.every(target => snapshot.tools.some(tool => tool.runtime === target.installation.runtime
+                    && tool.version === target.targetVersion && tool.path === target.installation.path && tool.source === target.installation.source
+                    && tool.prefix === target.installation.prefix && tool.brewPath === target.installation.brewPath && tool.automatic));
+                set(entry, { state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed", snapshot,
+                    items: entry.operation.items.map(x => ({ ...x, state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed" })) });
+                return result({ operation: entry.operation, snapshot });
+            }
+            catch {
+                return fail("inspection_failed");
+            }
+        },
+        async stop() { stopped = true; await current; },
+    };
+}

package/dist/runtime-tool-update-protocol.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const RUNTIME_TOOL_UPDATES_CAPABILITY = "runtime_tool_updates_v1";
+const boundedPath = z.string().min(1).max(4096);
+export const RuntimeToolRunnerSchema = z.object({ releaseId: z.string().regex(/^[a-f0-9]{64}$/), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+export const RuntimeToolInstallationSchema = z.object({
+    runtime: z.enum(["codex", "claude"]), path: boundedPath, realPath: boundedPath,
+    version: z.string().max(100).nullable(), source: z.enum(["npm", "homebrew", "native", "unknown"]),
+    nodeVersion: z.string().max(100).nullable(), nodePath: boundedPath.nullable(), npmPath: boundedPath.nullable(), prefix: boundedPath.nullable(),
+    brewPath: boundedPath.nullable(), brewKind: z.enum(["formula", "cask"]).nullable(), brewName: z.enum(["codex", "claude-code"]).nullable(),
+    fingerprint: z.string().regex(/^[a-f0-9]{64}$/), alternatives: z.array(boundedPath).max(32), automatic: z.boolean(), reason: z.string().max(100).nullable(),
+}).strict();
+export const RuntimeToolSnapshotSchema = z.object({ checkedAt: z.string().datetime(), tools: z.array(RuntimeToolInstallationSchema).max(2) }).strict();
+export const RuntimeToolTargetSchema = z.object({ installation: RuntimeToolInstallationSchema, targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/).max(100) }).strict();
+export const RuntimeToolStateSchema = z.enum(["queued", "preflight", "installing", "verifying", "completed", "failed", "unknown", "cancelled"]);
+export const RuntimeToolOperationSchema = z.object({ operationId: z.string().uuid(), state: RuntimeToolStateSchema, currentIndex: z.number().int().min(0).max(2),
+    targets: z.array(RuntimeToolTargetSchema).min(1).max(2), items: z.array(z.object({ runtime: z.enum(["codex", "claude"]), state: RuntimeToolStateSchema, errorCode: z.string().max(100).nullable() }).strict()).max(2),
+    updatedAt: z.string().datetime(), errorCode: z.string().max(100).nullable(), snapshot: RuntimeToolSnapshotSchema.optional(),
+}).strict();
+export const RuntimeToolRequestSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("inspect"), runner: RuntimeToolRunnerSchema }).strict(),
+    z.object({ action: z.literal("start"), operationId: z.string().uuid(), targets: z.array(RuntimeToolTargetSchema).min(1).max(2), runner: RuntimeToolRunnerSchema }).strict(),
+    ...["status", "cancel", "verify"].map(action => z.object({ action: z.literal(action), operationId: z.string().uuid() }).strict()),
+]);
+export const RuntimeToolResponseSchema = z.object({ snapshot: RuntimeToolSnapshotSchema.optional(), operation: RuntimeToolOperationSchema.optional() }).strict();

package/dist/runtime-tool-update-serve.js

@@ -0,0 +1,54 @@
+import { prepareDaemonRestart } from "./daemon-updater.js";
+import { createRuntimeToolUpdateController } from "./runtime-tool-update-controller.js";
+import { augmentedPath } from "./runtime-path.js";
+import { runRuntimeToolBridge } from "./runtime-tool-update-bridge.js";
+export async function acquireRuntimeToolLease(localSlots, host) {
+    const local = await prepareDaemonRestart({ localSlots });
+    if (!local.ok)
+        return null;
+    try {
+        const shared = await host.tryAcquireExclusiveExecution();
+        if (!shared) {
+            await local.release();
+            return null;
+        }
+        let released = false;
+        return { protectProcessGroup: async (pid) => {
+                if (!shared.protectProcessGroup)
+                    throw new Error("lease protection unavailable");
+                await shared.protectProcessGroup(pid);
+            }, async release() { if (released)
+                return; await shared.release(); await local.release(); released = true; } };
+    }
+    catch (error) {
+        await local.release();
+        throw error;
+    }
+}
+export function createServeRuntimeToolUpdates(config, localSlots, host, acquireEnv, refresh) {
+    const controller = createRuntimeToolUpdateController({ acquire: () => acquireRuntimeToolLease(localSlots, host),
+        run: async (request, progress, protectProcessGroup) => {
+            const result = await runRuntimeToolBridge(config, request, async () => {
+                const env = await acquireEnv();
+                return { ...env, PATH: augmentedPath(env, {}, process.platform, "append") };
+            }, progress, { ...(protectProcessGroup ? { protectProcessGroup } : {}) });
+            if (request.action === "start" && result.processStopped)
+                refresh();
+            return result;
+        } });
+    return {
+        handle(raw, send) {
+            if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "runtime-tools:operation")
+                return false;
+            const { reqId, type: _type, ...request } = raw;
+            if (typeof reqId === "string") {
+                if (process.platform !== "linux" && process.platform !== "darwin")
+                    send({ type: "fs:result", reqId, ok: false, error: "unsupported_platform" });
+                else
+                    void controller.handle(request).then(result => send({ type: "fs:result", reqId, ...result })).catch(() => send({ type: "fs:result", reqId, ok: false, error: "operation_unknown" }));
+            }
+            return true;
+        },
+        stop: controller.stop,
+    };
+}

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"]);
+    }
+}