@tea-agent/loop-agent 0.41.0 → 0.42.0-next.1

package/dist/worker/console/context-transfer-diagnostics.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import { appendFile, chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { assertSafeAppDataPath, readJsonIfExists, writeSecureJson, } from "../../infrastructure/console/app-data.js";
+const diagnosticWriteChains = new Map();
+function serializeDiagnostic(filePath, operation) {
+    const previous = diagnosticWriteChains.get(filePath) ?? Promise.resolve();
+    const next = previous.then(operation, operation);
+    diagnosticWriteChains.set(filePath, next.then(() => undefined, () => undefined));
+    return next;
+}
+function diagnosticsPath(appData) {
+    const repoNamespace = path.dirname(appData.operations);
+    return assertSafeAppDataPath(repoNamespace, path.join(repoNamespace, "context-transfer-diagnostics.json"));
+}
+function safeNonNegative(value) {
+    return Number.isFinite(value) && (value ?? 0) >= 0 ? Math.round(value ?? 0) : 0;
+}
+function safeReasonCode(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().slice(0, 96);
+    return /^[A-Za-z0-9_.-]+$/.test(normalized) ? normalized : "UNCLASSIFIED";
+}
+export async function recordContextTransferDiagnostic(input) {
+    const filePath = diagnosticsPath(input.appData);
+    return serializeDiagnostic(filePath, async () => {
+        const current = (await readJsonIfExists(filePath)) ?? {
+            schemaVersion: 1,
+            updatedAt: (input.now ?? new Date()).toISOString(),
+            counters: [],
+        };
+        const dimensions = {
+            outcome: input.dimensions.outcome,
+            ...(input.dimensions.target ? { target: input.dimensions.target } : {}),
+            ...(input.dimensions.profile ? { profile: input.dimensions.profile } : {}),
+            ...(input.dimensions.diffKind ? { diffKind: input.dimensions.diffKind } : {}),
+            ...(safeReasonCode(input.dimensions.reasonCode)
+                ? { reasonCode: safeReasonCode(input.dimensions.reasonCode) }
+                : {}),
+        };
+        const key = JSON.stringify({ event: input.event, ...dimensions });
+        const existing = current.counters.find((counter) => JSON.stringify({ event: counter.event, ...dimensionsFromCounter(counter) }) === key);
+        if (existing) {
+            existing.count += 1;
+            existing.bytes += safeNonNegative(input.dimensions.bytes);
+            existing.durationMs += safeNonNegative(input.dimensions.durationMs);
+            existing.affectedNodeCount += safeNonNegative(input.dimensions.affectedNodeCount);
+            existing.importedNodeCount += safeNonNegative(input.dimensions.importedNodeCount);
+        }
+        else {
+            current.counters.push({
+                event: input.event,
+                ...dimensions,
+                count: 1,
+                bytes: safeNonNegative(input.dimensions.bytes),
+                durationMs: safeNonNegative(input.dimensions.durationMs),
+                affectedNodeCount: safeNonNegative(input.dimensions.affectedNodeCount),
+                importedNodeCount: safeNonNegative(input.dimensions.importedNodeCount),
+            });
+        }
+        current.updatedAt = (input.now ?? new Date()).toISOString();
+        await writeSecureJson(filePath, current);
+        return current;
+    });
+}
+function dimensionsFromCounter(counter) {
+    return {
+        outcome: counter.outcome,
+        ...(counter.target ? { target: counter.target } : {}),
+        ...(counter.profile ? { profile: counter.profile } : {}),
+        ...(counter.diffKind ? { diffKind: counter.diffKind } : {}),
+        ...(counter.reasonCode ? { reasonCode: counter.reasonCode } : {}),
+    };
+}
+export async function readContextTransferDiagnostics(appData) {
+    return readJsonIfExists(diagnosticsPath(appData));
+}
+/**
+ * Append-only lifecycle event log for context-transfer mutations
+ * (exec-plan observability: context_export.* / artifact_revision.* /
+ * artifact_rerun.*). Events carry ids, counts, bytes, duration and reason
+ * codes only — never prompt text, artifact content, secret finding values or
+ * host absolute paths. The Console emits only stages it truly observes;
+ * CLI-kernel-internal stages (capture, secret scan, adapters) stay in the
+ * kernel's own evidence.
+ */
+export const CONTEXT_TRANSFER_EVENT_LOG_LIMIT = 512;
+const CONTEXT_TRANSFER_EVENT_NAME_PATTERN = /^(?:context_export|artifact_revision|artifact_rerun)\.[a-z][a-z_]{0,47}$/;
+const CONTEXT_TRANSFER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+export async function recordContextTransferEvent(input) {
+    const at = (input.now ?? new Date()).toISOString();
+    if (!CONTEXT_TRANSFER_EVENT_NAME_PATTERN.test(input.event)) {
+        return { recorded: false, total: 0 };
+    }
+    const fields = input.fields ?? {};
+    const entry = {
+        schemaVersion: 1,
+        at,
+        event: input.event,
+        ...sanitizeLifecycleFields(fields),
+    };
+    const filePath = lifecycleEventsPath(input.appData);
+    return serializeDiagnostic(filePath, async () => {
+        await appendLifecycleEvent(filePath, entry);
+        const total = await countLifecycleEvents(filePath);
+        if (total > CONTEXT_TRANSFER_EVENT_LOG_LIMIT) {
+            await trimLifecycleEvents(filePath, CONTEXT_TRANSFER_EVENT_LOG_LIMIT);
+            return { recorded: true, total: CONTEXT_TRANSFER_EVENT_LOG_LIMIT };
+        }
+        return { recorded: true, total };
+    });
+}
+export async function readContextTransferEvents(appData) {
+    const filePath = lifecycleEventsPath(appData);
+    const raw = await readFile(filePath, "utf8").catch(() => "");
+    const events = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed &&
+                typeof parsed === "object" &&
+                parsed.schemaVersion === 1 &&
+                typeof parsed.event === "string") {
+                events.push(parsed);
+            }
+        }
+        catch {
+            // A torn final line after a crash must not break readers.
+        }
+    }
+    return events;
+}
+function lifecycleEventsPath(appData) {
+    const repoNamespace = path.dirname(appData.operations);
+    return assertSafeAppDataPath(repoNamespace, path.join(repoNamespace, "context-transfer-events.jsonl"));
+}
+function safeLifecycleId(value) {
+    if (!value)
+        return undefined;
+    return CONTEXT_TRANSFER_ID_PATTERN.test(value) ? value : undefined;
+}
+function sanitizeLifecycleFields(fields) {
+    return {
+        ...(safeLifecycleId(fields.runId) ? { runId: fields.runId } : {}),
+        ...(safeLifecycleId(fields.nodeId) ? { nodeId: fields.nodeId } : {}),
+        ...(safeLifecycleId(fields.exportId) ? { exportId: fields.exportId } : {}),
+        ...(safeLifecycleId(fields.revisionId)
+            ? { revisionId: fields.revisionId }
+            : {}),
+        ...(safeLifecycleId(fields.operationId)
+            ? { operationId: fields.operationId }
+            : {}),
+        ...(fields.profile === "redacted" || fields.profile === "raw"
+            ? { profile: fields.profile }
+            : {}),
+        ...(fields.target === "generic" ||
+            fields.target === "pi-session" ||
+            fields.target === "pi-handoff" ||
+            fields.target === "readable"
+            ? { target: fields.target }
+            : {}),
+        ...(fields.bytes !== undefined
+            ? { bytes: safeNonNegative(fields.bytes) }
+            : {}),
+        ...(fields.durationMs !== undefined
+            ? { durationMs: safeNonNegative(fields.durationMs) }
+            : {}),
+        ...(safeReasonCode(fields.reasonCode)
+            ? { reasonCode: safeReasonCode(fields.reasonCode) }
+            : {}),
+    };
+}
+async function appendLifecycleEvent(filePath, entry) {
+    await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    await appendFile(filePath, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+    await chmod(filePath, 0o600).catch(() => undefined);
+}
+async function countLifecycleEvents(filePath) {
+    const raw = await readFile(filePath, "utf8").catch(() => "");
+    let total = 0;
+    for (const line of raw.split("\n")) {
+        if (line.trim())
+            total += 1;
+    }
+    return total;
+}
+async function trimLifecycleEvents(filePath, limit) {
+    const raw = await readFile(filePath, "utf8").catch(() => "");
+    const lines = raw.split("\n").filter((line) => line.trim());
+    const kept = lines.slice(-limit);
+    const tmp = `${filePath}.${randomBytes(8).toString("hex")}.tmp`;
+    await writeFile(tmp, `${kept.join("\n")}\n`, { mode: 0o600, flag: "wx" });
+    await rename(tmp, filePath);
+    await chmod(filePath, 0o600).catch(() => undefined);
+}

package/dist/worker/console/dag-confirmation.js

@@ -1,6 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
-import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
+import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "../../infrastructure/console/app-data.js";
 import { confirmationPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "./human-gate-token.js";
 export const ALL_CONFIRMATION_CHALLENGES = [
     "source",

package/dist/worker/console/dag-execution-receipt.js

@@ -20,7 +20,7 @@ import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
-import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
+import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "../../infrastructure/console/app-data.js";
 import { hashDagBytes, } from "./dag-confirmation.js";
 /**
  * Structured verification command patterns for the G2 autonomous-execution

package/dist/worker/console/doctor.js

@@ -6,7 +6,7 @@ import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
 import { preflightTargetRepo } from "../preflight.js";
 import { probePiReadiness, } from "./pi-readiness.js";
 import { DEFAULT_OBSERVE_BASE_URL, OBSERVE_START_COMMAND, probeAndClassifyObserve, } from "./observe-health-match.js";
-import { repoFingerprintV1 } from "./repo-fingerprint.js";
+import { repoFingerprintV1 } from "../../infrastructure/console/repo-fingerprint.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { defaultObserveStaticDir, ROUTES } from "../observe/routes.js";
 import { deriveObserveRouteCapabilities } from "../observe/health.js";

package/dist/worker/console/draft-store.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
+import { readJsonIfExists, sha256Json, writeSecureJson, } from "../../infrastructure/console/app-data.js";
 /**
  * 从任意上游载荷安全投影 ledger 摘要（未知形状丢弃，绝不抛错、绝不信任字段外的数据）。
  * 供 DraftStore / prd-intake-bridge 把 prepare/advance 结果中的 ledger 摘要带入草稿。

package/dist/worker/console/human-gate-token.js

@@ -85,7 +85,7 @@ export function verifyHumanGateToken(presented, expected, secret, now = new Date
  * invalidates the token (defense against drift-then-confirm).
  */
 import { createHash } from "node:crypto";
-import { sha256Utf8 } from "./app-data.js";
+import { sha256Utf8 } from "../../infrastructure/console/app-data.js";
 export function confirmationPayloadHash(b) {
     const canonical = [
         `dag=${b.dagSha256}`,

package/dist/worker/console/index.js

@@ -3,14 +3,14 @@ export { buildOperatorSurfaceHealthV1 } from "./operator-surface-health.js";
 export { runConsoleDoctor, formatConsoleDoctorHuman } from "./doctor.js";
 export { isLoopbackHost } from "./loopback.js";
 export { shouldOpenConsoleBrowser, normalizeConsoleBrowserUrl, openSystemBrowser, maybeOpenConsoleBrowser, } from "./open-browser.js";
-export { repoFingerprintV1, normalizeWorktreeRealpath, } from "./repo-fingerprint.js";
+export { repoFingerprintV1, normalizeWorktreeRealpath, } from "../../infrastructure/console/repo-fingerprint.js";
 export { buildObserveDeepLink } from "./observe-link.js";
 export { classifyObserveHealth, probeAndClassifyObserve, capabilityForObserveTarget, OBSERVE_START_COMMAND, DEFAULT_OBSERVE_BASE_URL, } from "./observe-health-match.js";
 export { allowedRecoveryCtas, classifyRecoveryFact, partitionRecoveryCtas, recoveryMatrixInvariants, } from "./recovery-cta.js";
 export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateTool, assertOfficialToolAllowed, listOfficialTools, OFFICIAL_DENIED_TOOL_IDS, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./resource-loader.js";
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
-export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";
-export { OperationStore } from "./operation-store.js";
+export { openConsoleAppData, defaultConsoleAppDataRoot } from "../../infrastructure/console/app-data.js";
+export { OperationStore } from "../../infrastructure/console/operation-store.js";
 export { createOperationEventStore } from "./operation-sse.js";
 export { DagConfirmationStore } from "./dag-confirmation.js";
 export { DraftStore } from "./draft-store.js";

package/dist/worker/console/interview/assessment.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 import { computeDraftSha256, } from "../draft-store.js";
 function assessmentPath(appData, assessmentId) {
     return path.join(appData.assessments, `${assessmentId}.json`);

package/dist/worker/console/interview/session.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 import { createInterviewResourceLoader, } from "./tools.js";
 function sessionPath(appData, sessionId) {
     return path.join(appData.interviews, `${sessionId}.json`);

package/dist/worker/console/operation-runner.js

@@ -1,6 +1,14 @@
-import { clipPreview, } from "./operation-store.js";
+import { clipPreview, } from "../../infrastructure/console/operation-store.js";
 import { stateEvent } from "./operation-sse.js";
 import { extractTrustedRunFacts } from "./operation-run-facts.js";
+/** Swallow-all invoker so observers can never break the state path. */
+function notifySettled(deps, operation, state, info) {
+    if (!deps.onSettled)
+        return;
+    void Promise.resolve()
+        .then(() => deps.onSettled?.(operation, state, info))
+        .catch(() => undefined);
+}
 /**
  * Execute a queued operation via LoopAgentClient (or inject).
  * Timeout without proven exit → needs-reconcile (never Cancel).
@@ -42,6 +50,7 @@ export async function runOperation(operationId, deps) {
             artifactName: `operation-${operationId}`,
             expectJson: true,
             timeoutMs: deps.defaultTimeoutMs,
+            env: deps.env,
             onSpawn: (info) => {
                 // Chain onto the per-operation write lock; never fire-and-forget a
                 // rejected update (unhandled rejection can crash Console on Windows).
@@ -119,6 +128,10 @@ export async function runOperation(operationId, deps) {
             message: finished.errorMessage,
             state: "needs-reconcile",
         });
+        notifySettled(deps, finished, "needs-reconcile", {
+            ok: false,
+            errorCode: finished.errorCode,
+        });
     }
     return finished;
 }
@@ -169,9 +182,10 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
         // Supervisory timeout without classified CLI timeout → needs-reconcile
         // Only mark timed-out when we have a machine timeout result after exit.
         const state = result.exitCode !== null ? "timed-out" : "needs-reconcile";
-        const updated = await deps.store.update(operationId, {
+        const finishedAt = new Date().toISOString();
+        const patch = {
             state,
-            finishedAt: new Date().toISOString(),
+            finishedAt,
             artifactRefs,
             stdoutPreview: previewStdout,
             stderrPreview: previewStderr,
@@ -186,7 +200,15 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
                     ...(runFacts.runSummary ? { runSummary: runFacts.runSummary } : {}),
                 }
                 : {}),
+        };
+        const current = await deps.store.get(operationId);
+        if (!current)
+            throw new Error(`operation not found: ${operationId}`);
+        await deps.beforeTerminal?.({ ...current, ...patch }, state, {
+            ok: false,
+            errorCode: patch.errorCode,
         });
+        const updated = await deps.store.update(operationId, patch);
         stateEvent(deps.events, updated, state, updated.errorMessage);
         if (runFacts) {
             appendSafeResultEvent(deps, operationId, state, {
@@ -202,6 +224,10 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
                 data: { ok: false, exitCode: result.exitCode },
             });
         }
+        notifySettled(deps, updated, state, {
+            ok: false,
+            errorCode: updated.errorCode,
+        });
         return updated;
     }
     const envelope = coerceEnvelope(result);
@@ -210,7 +236,7 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
     const processOk = envelope?.ok === true || (result.ok && result.exitCode === 0);
     const ok = processOk && !businessBlock;
     const state = ok ? "succeeded" : "failed";
-    const updated = await deps.store.update(operationId, {
+    const patch = {
         state,
         finishedAt: new Date().toISOString(),
         artifactRefs,
@@ -238,9 +264,20 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
                 ...(runFacts.runSummary ? { runSummary: runFacts.runSummary } : {}),
             }
             : {}),
+    };
+    if (!operation)
+        throw new Error(`operation not found: ${operationId}`);
+    await deps.beforeTerminal?.({ ...operation, ...patch }, state, {
+        ok,
+        errorCode: patch.errorCode,
     });
+    const updated = await deps.store.update(operationId, patch);
     stateEvent(deps.events, updated, state, updated.errorMessage);
     appendSafeResultEvent(deps, operationId, state, { ok, exitCode: result.exitCode }, runFacts);
+    notifySettled(deps, updated, state, {
+        ok,
+        errorCode: updated.errorCode,
+    });
     if (ok && operation?.action === "dagRequestInterrupt") {
         await projectInterruptRequestOntoTarget(operation, result.json, deps);
     }
@@ -300,6 +337,10 @@ export function scheduleOperation(operationId, deps) {
         })
             .then((updated) => {
             stateEvent(deps.events, updated, "needs-reconcile", message);
+            notifySettled(deps, updated, "needs-reconcile", {
+                ok: false,
+                errorCode: updated.errorCode,
+            });
         })
             .catch(() => {
             // A failed canonical store update cannot be represented safely.

package/dist/worker/console/operation-sse.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import path from "node:path";
-import { ensureSecureDir, writeSecureJsonSync } from "./app-data.js";
+import { ensureSecureDir, writeSecureJsonSync } from "../../infrastructure/console/app-data.js";
 const DEFAULT_MAX_EVENTS = 1000;
 function safeOperationId(operationId) {
     return operationId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);

package/dist/worker/console/operation-wait.js

@@ -1,5 +1,5 @@
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
-import { isTerminalOperationState, } from "./operation-store.js";
+import { isTerminalOperationState, } from "../../infrastructure/console/operation-store.js";
 /**
  * P2: read-only event-driven long poll on the canonical operation event ring
  * (2026-08-13 Operator Chat long-run supervision). Server contract bounds:

package/dist/worker/console/operator-actions.js

@@ -4,13 +4,14 @@ import { DAG_RERUN_PROMPT_OVERRIDE_ENV, isDagRerunPromptOverrideEnabled, MAX_DAG
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
-import { stageUtf8Text } from "./app-data.js";
+import { stageUtf8Text } from "../../infrastructure/console/app-data.js";
 import { ALL_CONFIRMATION_CHALLENGES, hashDagBytes, } from "./dag-confirmation.js";
 import { capabilityForObserveTarget, DEFAULT_OBSERVE_BASE_URL, OBSERVE_START_COMMAND, probeAndClassifyObserve, } from "./observe-health-match.js";
 import { buildInspectDeepLink, buildObserveDeepLink, } from "./observe-link.js";
 import { resolveLatestDagRunIdForTask } from "./resolve-dag-run-for-task.js";
-import { repoFingerprintV1 } from "./repo-fingerprint.js";
+import { repoFingerprintV1 } from "../../infrastructure/console/repo-fingerprint.js";
 import { scheduleOperation, } from "./operation-runner.js";
+import { recordContextTransferEvent } from "./context-transfer-diagnostics.js";
 import { readinessGateFailure, } from "./pi-readiness.js";
 import { validatePiModelMatrixTiers, writePiModelMatrix, } from "./harness-pi-model-matrix.js";
 import { isAssessmentFreshForDraft } from "./interview/assessment.js";
@@ -481,7 +482,7 @@ async function buildPromptOverrideCliArgs(ctx, overrides) {
     }
     return args;
 }
-async function acceptOperation(ctx, input) {
+export async function acceptOperation(ctx, input) {
     const created = await ctx.operations.create({
         clientRequestId: input.clientRequestId,
         action: input.action,
@@ -517,12 +518,55 @@ async function acceptOperation(ctx, input) {
             },
         };
     }
+    if (input.onAdmitted) {
+        try {
+            await input.onAdmitted(created.operation);
+        }
+        catch {
+            // Lifecycle observation must never block admission.
+        }
+    }
+    if (input.prepare) {
+        try {
+            await input.prepare();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const preparedFailure = input.prepareFailure?.(error);
+            await ctx.operations.update(created.operation.operationId, {
+                state: "failed",
+                startedAt: created.operation.createdAt,
+                finishedAt: new Date().toISOString(),
+                errorCode: preparedFailure?.errorCode ?? "INVALID_INPUT",
+                errorMessage: message,
+            });
+            return {
+                kind: "error",
+                status: preparedFailure?.status ?? 400,
+                body: preparedFailure?.body ?? operatorFailed({
+                    command: input.action,
+                    outcome: "blocked",
+                    code: "INVALID_INPUT",
+                    message,
+                }),
+            };
+        }
+    }
+    const transferObserver = contextTransferSettledObserver(ctx, input.action, input.actionParams);
     const runnerDeps = {
         store: ctx.operations,
         events: ctx.events,
         client: ctx.client,
         repoRoot: ctx.repoRoot,
+        env: { ...process.env, LOOP_CONSOLE_APP_DATA: ctx.appData.root },
         runCommand: ctx.runCommand,
+        beforeTerminal: input.beforeTerminal,
+        onSettled: async (operation, state, info) => {
+            // Diagnostics are best-effort and must not prevent authoritative Worker
+            // settlement from running.
+            await Promise.resolve(transferObserver?.(operation, state, info)).catch(() => undefined);
+            await input.onSettled?.(operation, state, info);
+        },
     };
     scheduleOperation(created.operation.operationId, runnerDeps);
     return {
@@ -536,6 +580,63 @@ async function acceptOperation(ctx, input) {
         },
     };
 }
+/**
+ * Map artifact revision / rerun operation outcomes onto the append-only
+ * context-transfer lifecycle event log. Only stages the Console truly
+ * observes (admission + settle) are recorded; CLI-kernel-internal stages
+ * stay in the kernel. Unknown actions emit nothing.
+ */
+function contextTransferSettledObserver(ctx, action, actionParams) {
+    if (action !== "artifactRevisionStage" &&
+        action !== "artifactRevisionPlan" &&
+        action !== "artifactRevisionExecute") {
+        return undefined;
+    }
+    const strParam = (key) => {
+        const value = actionParams[key];
+        return typeof value === "string" ? value.trim() : undefined;
+    };
+    const baseFields = {
+        runId: strParam("runId"),
+        nodeId: strParam("nodeId"),
+        revisionId: strParam("revisionId"),
+    };
+    return (operation, state, info) => {
+        let event;
+        if (action === "artifactRevisionStage") {
+            event = info.ok ? "artifact_revision.validated" : "artifact_revision.rejected";
+        }
+        else if (action === "artifactRevisionPlan") {
+            event = info.ok ? "artifact_rerun.plan_created" : "artifact_rerun.blocked";
+        }
+        else if (state === "needs-reconcile") {
+            event = "artifact_rerun.needs_reconcile";
+        }
+        else {
+            event = info.ok ? "artifact_rerun.finished" : "artifact_rerun.failed";
+        }
+        // The stage CLI assigns the revision id; it only exists in the settle
+        // result, never in admission params.
+        let resultRevisionId;
+        const resultRevision = operation.result
+            ?.revision;
+        if (resultRevision && typeof resultRevision === "object") {
+            resultRevisionId = resultRevision.revisionId;
+        }
+        return recordContextTransferEvent({
+            appData: ctx.appData,
+            event,
+            fields: {
+                ...baseFields,
+                ...(typeof resultRevisionId === "string"
+                    ? { revisionId: resultRevisionId }
+                    : {}),
+                operationId: operation.operationId,
+                ...(info.ok ? {} : { reasonCode: info.errorCode ?? "INTERNAL_ERROR" }),
+            },
+        }).catch(() => undefined);
+    };
+}
 async function acceptConsoleUpdateAndInit(ctx, clientRequestId, channel) {
     if (!ctx.consoleUpdateExecutor) {
         return {

package/dist/worker/console/operator-surface-health.js

@@ -1,5 +1,5 @@
 import { deriveObserveRouteCapabilities, resolveObservePackageIdentity, } from "../observe/health.js";
-import { repoFingerprintV1 } from "./repo-fingerprint.js";
+import { repoFingerprintV1 } from "../../infrastructure/console/repo-fingerprint.js";
 export function buildOperatorSurfaceHealthV1(input) {
     const { packageName, packageVersion } = resolveObservePackageIdentity();
     const snapshotAvailable = input.routes.some((route) => route.method === "GET" && route.pattern.test("/api/snapshot"));