@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

package/dist/worker/console/chat/session-store.js

@@ -12,12 +12,21 @@
  */
 import path from "node:path";
 import { readdir, rm } from "node:fs/promises";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
 import { projectOperationForChat } from "./chat-event-store.js";
 import { scrubSecrets } from "./explore-tools.js";
 import { hashDeferredTurnPayload, parseDeferredTurns, } from "./deferred-turn.js";
+/** True only for a durable session that has never received user work. */
+export function isBlankChatSession(record) {
+    return (record.state === "active" &&
+        !record.title &&
+        !record.displayTitle &&
+        record.messages.length === 0 &&
+        record.toolInvocations.length === 0 &&
+        (record.deferredTurns?.length ?? 0) === 0);
+}
 const CHAT_TITLE_MAX_CHARS = 80;
 /** Safe, one-line bounded title used for placeholders and model output. */
 export function cleanChatTitle(value) {
@@ -38,6 +47,16 @@ export function cleanChatTitle(value) {
 function recordPath(appData, sessionId) {
     return path.join(appData.chats, `${sessionId}.json`);
 }
+/** True when `sessionFile` lives inside this store's dedicated Pi JSONL dir. */
+export function isConsoleOwnedSessionFile(appData, sessionFile) {
+    const value = sessionFile?.trim();
+    if (!value)
+        return false;
+    const root = path.resolve(appData.chatSessions);
+    const target = path.resolve(value);
+    const relative = path.relative(root, target);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 export class ChatSessionStore {
     appData;
     options;
@@ -81,6 +100,9 @@ export class ChatSessionStore {
             ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
             ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
             ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
+            ...(typeof raw.telemetrySessionId === "string" && raw.telemetrySessionId
+                ? { telemetrySessionId: raw.telemetrySessionId }
+                : {}),
             ...(typeof raw.workspaceId === "string" && raw.workspaceId
                 ? { workspaceId: raw.workspaceId }
                 : {}),
@@ -165,6 +187,7 @@ export class ChatSessionStore {
             const now = new Date().toISOString();
             const record = {
                 ...source,
+                telemetrySessionId: undefined,
                 sessionId: input.targetSessionId,
                 state: "active",
                 ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
@@ -179,6 +202,19 @@ export class ChatSessionStore {
             return record;
         });
     }
+    /** Atomically backfill the per-conversation simulated identity on first use. */
+    async ensureTelemetrySessionId(sessionId, createId) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return undefined;
+            if (record.telemetrySessionId)
+                return record.telemetrySessionId;
+            record.telemetrySessionId = createId();
+            await this.persist(record);
+            return record.telemetrySessionId;
+        });
+    }
     async rename(sessionId, title) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -237,8 +273,14 @@ export class ChatSessionStore {
             const record = await this.get(sessionId);
             if (!record)
                 return false;
+            const sessionFile = record.sessionFile;
             await rm(recordPath(this.appData, sessionId), { force: true });
             this.options.onRecordChange?.(sessionId, undefined);
+            // Record first, then best-effort JSONL unlink. Final consistency is
+            // "both gone" — a leftover JSONL is harmless, a leftover record is not.
+            if (isConsoleOwnedSessionFile(this.appData, sessionFile) && sessionFile) {
+                await rm(sessionFile, { force: true }).catch(() => undefined);
+            }
             return true;
         });
     }

package/dist/worker/console/chat/shortcuts.js

@@ -42,6 +42,13 @@ export const SHORTCUTS = [
         source: "operator",
     },
 ];
+export const SDD_BINGO_SHORTCUT = {
+    command: "/sdd-bingo",
+    label: "sdd-bingo",
+    description: "SDD数据对齐",
+    action: "sdd-bingo",
+    source: "operator",
+};
 /** Pi Web commands with real browser-equivalent behavior (UI-11). */
 export const WEB_SLASH_COMMANDS = [
     {
@@ -98,7 +105,7 @@ export function resolveShortcut(input) {
     const token = input.trim().split(/\s+/, 1)[0]?.toLowerCase();
     if (!token?.startsWith("/"))
         return undefined;
-    const local = [...SHORTCUTS, ...WEB_SLASH_COMMANDS].find((shortcut) => shortcut.command === token);
+    const local = [...SHORTCUTS, ...WEB_SLASH_COMMANDS, SDD_BINGO_SHORTCUT].find((shortcut) => shortcut.command === token);
     if (local)
         return { command: local.command, action: local.action };
     return { command: token, action: "unknown" };
@@ -116,7 +123,7 @@ export function workspaceForShortcut(action) {
  * Merge Operator, Web, and dynamic Session commands with conflict dedupe.
  * Priority: operator/web > extension > skill > prompt. /reload is single-card.
  */
-export function mergeSlashCommands(dynamic = []) {
+export function mergeSlashCommands(dynamic = [], capabilities = {}) {
     const byName = new Map();
     const upsert = (item) => {
         const key = normalizeCommandName(item.command);
@@ -149,6 +156,15 @@ export function mergeSlashCommands(dynamic = []) {
             action: item.action,
         });
     }
+    if (capabilities.sddBingo) {
+        upsert({
+            command: SDD_BINGO_SHORTCUT.command,
+            label: SDD_BINGO_SHORTCUT.label,
+            description: SDD_BINGO_SHORTCUT.description,
+            source: SDD_BINGO_SHORTCUT.source,
+            action: SDD_BINGO_SHORTCUT.action,
+        });
+    }
     for (const item of dynamic) {
         const command = normalizeCommandName(item.command);
         if (!command)

package/dist/worker/console/chat/user-questions.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";
 function questionFile(root, sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
     return path.join(root, `${safe}.json`);

package/dist/worker/console/console-update-runtime.js

@@ -4,7 +4,7 @@ import { createNpmUpdateClient } from "../../shared/update/npm-client.js";
 import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
 import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
 import { performConsoleUpdateAndInit, } from "./console-update-and-init.js";
-import { TERMINAL_OPERATION_STATES } from "./operation-store.js";
+import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
 export function createConsoleUpdateExecutor(input) {
     return async (channel) => {
         const currentVersion = readPackageVersion(input.packageRoot);

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/frontend-human-decision-adapter.js

@@ -0,0 +1,19 @@
+import { parseFrontendHumanDecisionProjection } from "../../workflows/dag/frontend-human-decision.js";
+/** Worker/Console persistence seam. Canonical validation and freshness remain in the workflow service. */
+export function createFrontendHumanDecisionAdapter(store) {
+    return {
+        async load(operationId) {
+            const record = await store.get(operationId);
+            if (!record || record.revision === undefined || !record.frontendHumanDecision)
+                return undefined;
+            return { revision: record.revision, projection: parseFrontendHumanDecisionProjection(record.frontendHumanDecision) };
+        },
+        materialize(input) {
+            return store.materializeFrontendHumanDecision(input);
+        },
+        consume(input) {
+            return store.consumeFrontendHumanDecision(input);
+        },
+        initializeSplit: store.initializeFrontendHumanApprovedSplit.bind(store),
+    };
+}

package/dist/worker/console/frontend-split-operation-adapter.js

@@ -0,0 +1,20 @@
+import { FrontendSplitOrchestrator, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
+/** Worker/Console boundary adapter. All orchestration policy remains canonical. */
+export function createFrontendSplitOperationAdapter(dependencies) {
+    const ports = {
+        load: async (operationId) => {
+            const record = await dependencies.store.get(operationId);
+            return record?.frontendSplit === undefined ? undefined : frontendSplitProjectionSchema.parse(record.frontendSplit);
+        },
+        compareAndSwap: (input) => dependencies.store.compareAndSwapFrontendSplit(input),
+        materialize: async (request) => {
+            const result = await dependencies.materializer.materialize(request);
+            return { taskId: result.taskId, operationId: result.operationId };
+        },
+        schedule: dependencies.schedule,
+        auditStale: dependencies.auditStale,
+        loadChildCloseoutFacts: (input) => dependencies.store.loadChildCloseoutFacts(input),
+        settleAggregate: (input) => dependencies.store.settleFrontendSplitAggregate({ ...input, prepareAggregate: dependencies.prepareAggregate }),
+    };
+    return new FrontendSplitOrchestrator(ports);
+}

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,17 @@ 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 { createFrontendSplitOperationAdapter } from "./frontend-split-operation-adapter.js";
+export { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+export { FrontendSplitTaskMaterializer } from "../materialize/frontend-split-task-materializer.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: