@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

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,17 +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 { 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 { 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: