@tea-agent/loop-agent 0.39.3 → 0.40.0-beta.2

package/dist/worker/console/chat/turn-process.js

@@ -53,6 +53,9 @@ export function hydrateSessionThread(raw) {
                 role: "assistant",
                 text: item.text,
                 createdAt,
+                ...(item.kind === "provider-error" && item.providerError
+                    ? { kind: item.kind, providerError: item.providerError }
+                    : {}),
                 ...(content && content.length > 0 ? { content } : {}),
             });
             flushPendingToAssistant(item.id);
@@ -154,9 +157,23 @@ function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolI
 function fillProcessDetails(group) {
     const usedToolIds = new Set();
     const processItems = [];
-    const prior = group.assistants.slice(0, -1);
-    const finalAssistant = group.assistants.at(-1);
-    for (const assistant of prior) {
+    const lastAssistant = group.assistants.at(-1);
+    const finalAssistant = lastAssistant?.kind === "provider-error" ? undefined : lastAssistant;
+    const finalIndex = finalAssistant
+        ? group.assistants.lastIndexOf(finalAssistant)
+        : -1;
+    for (const [index, assistant] of group.assistants.entries()) {
+        if (index === finalIndex)
+            continue;
+        if (assistant.kind === "provider-error" && assistant.providerError) {
+            emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
+            appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+            processItems.push({
+                kind: "provider-error",
+                error: assistant.providerError,
+            });
+            continue;
+        }
         emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
         appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
     }
@@ -292,55 +309,3 @@ export function selectRecentTurnGroups(groups, limit) {
         return [...groups];
     return groups.slice(-limit);
 }
-export function processGroupSummary(tools, options) {
-    const count = tools.length;
-    const thinkingCount = options?.thinkingCount ?? 0;
-    const textCount = options?.textCount ?? 0;
-    const activityCount = options?.activityCount ?? 0;
-    const stepCount = thinkingCount + textCount + activityCount + count;
-    const errorCount = tools.filter((t) => t.status === "error").length +
-        (options?.activityErrorCount ?? 0);
-    const runningCount = tools.filter((t) => t.status === "running").length +
-        (options?.activityRunningCount ?? 0);
-    const parts = [`处理详情 · ${stepCount} 步`];
-    if (count > 0)
-        parts.push(`${count} 工具`);
-    if (activityCount > 0)
-        parts.push(`${activityCount} 进展`);
-    if (errorCount > 0)
-        parts.push(`${errorCount} 出错`);
-    else if (runningCount > 0)
-        parts.push("运行中");
-    return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
-}
-/** Summary over rendered process items. */
-export function summarizeProcessItems(items) {
-    const tools = [];
-    let thinkingCount = 0;
-    let textCount = 0;
-    let activityCount = 0;
-    let activityErrorCount = 0;
-    let activityRunningCount = 0;
-    for (const item of items) {
-        if (item.kind === "thinking")
-            thinkingCount += 1;
-        else if (item.kind === "text")
-            textCount += 1;
-        else if (item.kind === "activity") {
-            activityCount += 1;
-            if (item.activity.kind === "error")
-                activityErrorCount += 1;
-            else if (item.activity.kind === "progress")
-                activityRunningCount += 1;
-        }
-        else
-            tools.push(item.tool);
-    }
-    return processGroupSummary(tools, {
-        thinkingCount,
-        textCount,
-        activityCount,
-        activityErrorCount,
-        activityRunningCount,
-    });
-}

package/dist/worker/console/chat/user-questions.js

@@ -0,0 +1,266 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+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`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new Error("ask_user_question requires 1-20 questions");
+    }
+    const ids = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw))
+            throw new Error(`question ${index + 1} must be an object`);
+        const id = typeof raw.id === "string" ? raw.id.trim() : "";
+        const question = typeof raw.question === "string" ? raw.question.trim() : "";
+        if (!id || !question)
+            throw new Error(`question ${index + 1} requires id and question`);
+        if (ids.has(id))
+            throw new Error(`duplicate question id: ${id}`);
+        ids.add(id);
+        const options = raw.options === undefined ? undefined : normalizeOptions(raw.options, id);
+        return {
+            id,
+            question,
+            ...(typeof raw.header === "string" && raw.header.trim()
+                ? { header: raw.header.trim().slice(0, 80) }
+                : {}),
+            ...(typeof raw.detail === "string" && raw.detail.trim()
+                ? { detail: raw.detail.trim().slice(0, 4000) }
+                : {}),
+            ...(options ? { options } : {}),
+            ...(raw.multi_select === true ? { multiSelect: true } : {}),
+        };
+    });
+}
+function normalizeOptions(value, questionId) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 12) {
+        throw new Error(`question ${questionId} options must contain 1-12 items`);
+    }
+    const labels = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw) || typeof raw.label !== "string" || !raw.label.trim()) {
+            throw new Error(`question ${questionId} option ${index + 1} requires a label`);
+        }
+        const label = raw.label.trim();
+        if (labels.has(label))
+            throw new Error(`duplicate option label: ${label}`);
+        labels.add(label);
+        return {
+            label,
+            ...(typeof raw.description === "string" && raw.description.trim()
+                ? { description: raw.description.trim().slice(0, 300) }
+                : {}),
+        };
+    });
+}
+function normalizeAnswer(value, questions) {
+    if (!isRecord(value) || !Array.isArray(value.answers))
+        throw new Error("answers must be an array");
+    const byId = new Map(questions.map((question) => [question.id, question]));
+    const seen = new Set();
+    const answers = value.answers.map((raw) => {
+        if (!isRecord(raw) || typeof raw.id !== "string")
+            throw new Error("answer id is required");
+        const id = raw.id.trim();
+        const question = byId.get(id);
+        if (!question || seen.has(id))
+            throw new Error(`answer does not match question: ${id}`);
+        seen.add(id);
+        const selected = Array.isArray(raw.selected)
+            ? raw.selected.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const allowed = new Set((question.options ?? []).map((option) => option.label));
+        if (selected.some((item) => !allowed.has(item)))
+            throw new Error(`answer contains an unknown option for ${id}`);
+        if (!question.multiSelect && selected.length > 1)
+            throw new Error(`question ${id} accepts one option`);
+        const custom = typeof raw.custom === "string" ? raw.custom.trim().slice(0, 4000) : "";
+        return { id, selected, ...(custom ? { custom } : {}) };
+    });
+    if (seen.size !== questions.length)
+        throw new Error("every question requires an answer or skip entry");
+    return { answers };
+}
+export class UserQuestionRegistry {
+    root;
+    pending = new Map();
+    /** Serialize first-write and resolve/cancel writes for one session. */
+    persistence = new Map();
+    waiters = new Map();
+    turnIds = new Map();
+    listeners = new Set();
+    constructor(root) {
+        this.root = root;
+    }
+    setTurn(sessionId, turnId) {
+        this.turnIds.set(sessionId, turnId);
+    }
+    clearTurn(sessionId) {
+        this.turnIds.delete(sessionId);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async get(sessionId) {
+        const memory = this.pending.get(sessionId);
+        if (memory?.status === "pending")
+            return structuredClone(memory);
+        const disk = await readJsonIfExists(questionFile(this.root, sessionId));
+        if (disk?.status === "pending") {
+            this.pending.set(sessionId, disk);
+            return structuredClone(disk);
+        }
+        return undefined;
+    }
+    async ask(input) {
+        const questions = normalizeQuestions(input.questions);
+        if (input.signal?.aborted)
+            throw new Error("USER_QUESTION_ABORTED");
+        if (await this.get(input.sessionId))
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        // Two tool calls can finish the disk lookup in the same turn. Re-check the
+        // in-memory lease after that await so only the first one can publish.
+        if (this.pending.get(input.sessionId)?.status === "pending") {
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        }
+        const now = new Date().toISOString();
+        const question = {
+            schemaVersion: 1,
+            requestId: `question_${randomBytes(12).toString("hex")}`,
+            sessionId: input.sessionId,
+            toolCallId: input.toolCallId,
+            ...(this.turnIds.get(input.sessionId) ? { turnId: this.turnIds.get(input.sessionId) } : {}),
+            questions,
+            createdAt: now,
+            updatedAt: now,
+            status: "pending",
+            version: 1,
+        };
+        this.pending.set(input.sessionId, question);
+        // Register the waiter before the first persistence await. A turn abort can
+        // arrive while the request is being written; registering afterwards leaves
+        // cancel() with nobody to reject and the tool promise would hang forever.
+        let persisted = false;
+        let abortRequested = false;
+        const waiting = new Promise((resolve, reject) => {
+            const onAbort = () => {
+                abortRequested = true;
+                if (persisted) {
+                    void this.cancel(input.sessionId, question.requestId, "TURN_ABORTED").catch(reject);
+                }
+            };
+            this.waiters.set(input.sessionId, {
+                resolve: (answer) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    resolve(answer);
+                },
+                reject: (error) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    reject(error);
+                },
+            });
+            if (input.signal?.aborted)
+                onAbort();
+            else
+                input.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            await this.persist(input.sessionId, question);
+            persisted = true;
+            if (abortRequested) {
+                await this.cancel(input.sessionId, question.requestId, "TURN_ABORTED");
+                return waiting;
+            }
+            this.emit({ type: "requested", question });
+        }
+        catch (error) {
+            const waiter = this.waiters.get(input.sessionId);
+            this.pending.delete(input.sessionId);
+            this.waiters.delete(input.sessionId);
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (waiter) {
+                waiter.reject(failure);
+                return waiting;
+            }
+            throw failure;
+        }
+        return waiting;
+    }
+    async answer(sessionId, requestId, rawAnswer) {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const answer = normalizeAnswer(rawAnswer, current.questions);
+        const resolved = {
+            ...current,
+            status: "resolved",
+            answer,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, resolved);
+        this.emit({ type: "resolved", question: resolved });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.resolve(answer);
+        return resolved;
+    }
+    async cancel(sessionId, requestId, reason = "USER_CANCELLED") {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const cancelled = {
+            ...current,
+            status: "cancelled",
+            cancelReason: reason,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, cancelled);
+        this.emit({ type: "cancelled", question: cancelled });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.reject(new Error(reason));
+        return cancelled;
+    }
+    async cancelForSession(sessionId, reason = "SESSION_DISPOSED") {
+        const current = await this.get(sessionId);
+        if (current)
+            await this.cancel(sessionId, current.requestId, reason);
+    }
+    emit(change) {
+        for (const listener of this.listeners) {
+            try {
+                listener(change);
+            }
+            catch { /* observers never break the waiter */ }
+        }
+    }
+    async persist(sessionId, question) {
+        const write = writeSecureJson(questionFile(this.root, sessionId), question);
+        this.persistence.set(sessionId, write);
+        try {
+            await write;
+        }
+        finally {
+            if (this.persistence.get(sessionId) === write) {
+                this.persistence.delete(sessionId);
+            }
+        }
+    }
+}

package/dist/worker/console/chat/workspace-landing.js

@@ -1,5 +1,70 @@
 export const ACTIVE_CHAT_SESSION_STORAGE_KEY = "loop-console.operator-chat.active-session.v1";
+export const ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY = "loop-console.operator-chat.active-session-by-workspace.v1";
 export const DEFAULT_LANDING_STORAGE_KEY = "loop-console.operator-chat.default-landing.v1";
+function readWorkspaceSessionMap(storage) {
+    try {
+        const parsed = JSON.parse(storage.getItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY) ?? "{}");
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return Object.fromEntries(Object.entries(parsed).filter((entry) => Boolean(entry[0].trim()) &&
+            typeof entry[1] === "string" &&
+            Boolean(entry[1].trim())));
+    }
+    catch {
+        return {};
+    }
+}
+/** Resolve the selected Chat session from client state. The workspace map is
+ * authoritative; the former global key is only a safe, server-validated
+ * migration fallback for users upgrading from the single-selection layout. */
+export function readActiveChatSessionId(storage, workspaceId) {
+    const scope = workspaceId?.trim();
+    if (scope) {
+        const map = readWorkspaceSessionMap(storage);
+        const scoped = map[scope]?.trim();
+        if (scoped)
+            return scoped;
+        // Once the map exists, an absent workspace means "no selected session";
+        // never fall back to another workspace's global legacy selection.
+        if (Object.keys(map).length > 0)
+            return null;
+    }
+    return storage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)?.trim() || null;
+}
+/** Remember the active session for its owning workspace while retaining the
+ * global key for existing non-Chat consumers that refer to the visible session. */
+export function rememberActiveChatSession(storage, workspaceId, sessionId) {
+    const id = sessionId.trim();
+    if (!id)
+        return;
+    storage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, id);
+    const scope = workspaceId?.trim();
+    if (!scope)
+        return;
+    const map = readWorkspaceSessionMap(storage);
+    map[scope] = id;
+    storage.setItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY, JSON.stringify(map));
+}
+/** Forget one workspace's invalid/deleted selection without disturbing the
+ * last session remembered for any other workspace. */
+export function forgetActiveChatSession(storage, workspaceId, sessionId) {
+    const scope = workspaceId?.trim();
+    if (scope) {
+        const map = readWorkspaceSessionMap(storage);
+        if (!sessionId || map[scope] === sessionId)
+            delete map[scope];
+        if (Object.keys(map).length > 0) {
+            storage.setItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY, JSON.stringify(map));
+        }
+        else {
+            storage.removeItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY);
+        }
+    }
+    const global = storage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)?.trim();
+    if (!sessionId || global === sessionId) {
+        storage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+    }
+}
 function configuredLanding(value) {
     const normalized = value?.trim().toLowerCase();
     if (normalized === "chat")
@@ -28,6 +93,20 @@ function readWorkspaceParams(query) {
         ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
         ...(read("featureId") ? { featureId: read("featureId") } : {}),
         ...(read("intent") ? { intent: read("intent") } : {}),
+        ...(read("workspaceId") ? { workspaceId: read("workspaceId") } : {}),
+        ...(read("sessionId") ? { sessionId: read("sessionId") } : {}),
+    };
+}
+export function resolveLegacyWorkspaceSelection(location, knownWorkspaceIds) {
+    const parsed = parseConsoleRoute(location);
+    const requested = parsed?.workspaceId?.trim();
+    if (parsed && requested && !knownWorkspaceIds.includes(requested)) {
+        return { status: "unknown-workspace", workspaceId: requested };
+    }
+    return {
+        status: "ok",
+        workspace: parsed?.workspace ?? resolveDefaultLanding({ location }),
+        params: parsed ?? {},
     };
 }
 /** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */

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