@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

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

@@ -0,0 +1,48 @@
+import { projectDeferredTurnSummaries, projectDeferredTurnSummary, } from "./deferred-turn.js";
+/**
+ * Process-wide Session baseline, mirroring DSH's independent session.list.
+ * Full records stay in their fingerprint-isolated stores; this catalog only
+ * removes repeated filesystem discovery and resolves Session ownership.
+ */
+export class ChatSessionCatalog {
+    entries = new Map();
+    upsert(record, ownerWorkspaceId) {
+        const workspaceId = ownerWorkspaceId?.trim() || record.workspaceId?.trim();
+        const existing = this.entries.get(record.sessionId);
+        if (existing &&
+            existing.repoFingerprint !== record.repoFingerprint) {
+            throw new Error(`chat session catalog conflict: ${record.sessionId} belongs to multiple repositories`);
+        }
+        this.entries.set(record.sessionId, {
+            sessionId: record.sessionId,
+            repoFingerprint: record.repoFingerprint,
+            repoRootDisplay: record.repoRootDisplay,
+            state: record.state,
+            ...(record.title !== undefined ? { title: record.title } : {}),
+            ...(record.displayTitle !== undefined
+                ? { displayTitle: record.displayTitle }
+                : {}),
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+            ...(record.modelProvider !== undefined
+                ? { modelProvider: record.modelProvider }
+                : {}),
+            ...(record.modelId !== undefined ? { modelId: record.modelId } : {}),
+            ...(record.thinkingLevel !== undefined
+                ? { thinkingLevel: record.thinkingLevel }
+                : {}),
+            deferredTurn: projectDeferredTurnSummary(record.deferredTurns?.[0]),
+            deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
+            ...(workspaceId ? { workspaceId } : {}),
+        });
+    }
+    remove(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    get(sessionId) {
+        return this.entries.get(sessionId);
+    }
+    list() {
+        return [...this.entries.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+}

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

@@ -156,6 +156,102 @@ export function deriveChatSessionTelemetry(events) {
 export function billedInputTokens(usage) {
     return usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
 }
+export function deriveChatTurnTelemetry(events) {
+    const byTurn = new Map();
+    const turnOf = (turnId) => {
+        let entry = byTurn.get(turnId);
+        if (!entry) {
+            entry = {
+                turnId,
+                steps: 0,
+                llmMs: 0,
+                toolMs: 0,
+                toolCalls: 0,
+                samples: [],
+            };
+            byTurn.set(turnId, entry);
+        }
+        return entry;
+    };
+    const toolStarts = new Map();
+    for (const event of events) {
+        const at = eventTime(event);
+        const turn = turnOf(event.turnId);
+        if (event.kind === "usage") {
+            const sample = usageSample(event.data);
+            if (sample)
+                turn.samples.push(sample);
+            continue;
+        }
+        if (event.kind === "user_message") {
+            if (turn.startedAt === undefined && at !== undefined)
+                turn.startedAt = at;
+            continue;
+        }
+        if (event.kind === "agent_start") {
+            if (at !== undefined)
+                turn.stepStart = at;
+            continue;
+        }
+        if (event.kind === "tool_call") {
+            turn.toolCalls += 1;
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                toolStarts.set(`${event.turnId}\u0000${toolCallId}`, at);
+            }
+            continue;
+        }
+        if (event.kind === "tool_result") {
+            const toolCallId = event.data.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId && at !== undefined) {
+                const key = `${event.turnId}\u0000${toolCallId}`;
+                const startedAt = toolStarts.get(key);
+                if (startedAt !== undefined && at >= startedAt) {
+                    turn.toolMs += at - startedAt;
+                }
+                toolStarts.delete(key);
+                // Next assistant step within the same turn starts after this tool.
+                turn.stepStart = at;
+            }
+            continue;
+        }
+        if (event.kind !== "message_end")
+            continue;
+        turn.steps += 1;
+        const recorded = stepTiming(event.data);
+        if (recorded?.llmMs !== undefined)
+            turn.llmMs += recorded.llmMs;
+        else if (at !== undefined &&
+            turn.stepStart !== undefined &&
+            at >= turn.stepStart) {
+            turn.llmMs += at - turn.stepStart;
+        }
+        if (recorded?.ttftMs !== undefined) {
+            turn.ttftMs = (turn.ttftMs ?? 0) + recorded.ttftMs;
+        }
+        if (recorded?.decodeMs !== undefined &&
+            recorded.decodeMs > 0 &&
+            recorded.outputTokens !== undefined) {
+            turn.decodeMs = (turn.decodeMs ?? 0) + recorded.decodeMs;
+            turn.decodeTokens = (turn.decodeTokens ?? 0) + recorded.outputTokens;
+        }
+        turn.stepStart = undefined;
+    }
+    return [...byTurn.values()].map((entry) => ({
+        turnId: entry.turnId,
+        steps: entry.steps,
+        llmMs: entry.llmMs,
+        toolMs: entry.toolMs,
+        toolCalls: entry.toolCalls,
+        ...(entry.ttftMs !== undefined ? { ttftMs: entry.ttftMs } : {}),
+        ...(entry.decodeMs !== undefined ? { decodeMs: entry.decodeMs } : {}),
+        ...(entry.decodeTokens !== undefined
+            ? { decodeTokens: entry.decodeTokens }
+            : {}),
+        usage: aggregateUsage(entry.samples),
+        ...(entry.startedAt !== undefined ? { startedAt: entry.startedAt } : {}),
+    }));
+}
 export function cacheHitPercent(usage) {
     const billed = billedInputTokens(usage);
     return billed > 0 ? Math.round((usage.cacheReadTokens / billed) * 100) : null;

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

@@ -12,7 +12,7 @@
  */
 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";
@@ -40,14 +40,20 @@ function recordPath(appData, sessionId) {
 }
 export class ChatSessionStore {
     appData;
+    options;
     /**
      * Per-session write lock. Each mutating op chains onto the previous one so
      * concurrent appendMessage / recordToolInvocation calls do not lose updates
      * via last-write-wins on the same JSON record.
      */
     writeChains = new Map();
-    constructor(appData) {
+    constructor(appData, options = {}) {
         this.appData = appData;
+        this.options = options;
+    }
+    async persist(record) {
+        await writeSecureJson(recordPath(this.appData, record.sessionId), record);
+        this.options.onRecordChange?.(record.sessionId, record);
     }
     /** Read + migrate legacy V1 records into the V2 in-memory shape. */
     async get(sessionId) {
@@ -147,7 +153,7 @@ export class ChatSessionStore {
                 messages: [],
                 toolInvocations: [],
             };
-            await writeSecureJson(recordPath(this.appData, input.sessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -169,7 +175,7 @@ export class ChatSessionStore {
                 messages: structuredClone(source.messages),
                 toolInvocations: structuredClone(source.toolInvocations),
             };
-            await writeSecureJson(recordPath(this.appData, input.targetSessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -180,7 +186,7 @@ export class ChatSessionStore {
                 throw new Error(`chat session not found: ${sessionId}`);
             record.title = title.trim().slice(0, 160) || undefined;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -195,7 +201,7 @@ export class ChatSessionStore {
                 return undefined;
             record.title = cleaned;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -211,7 +217,7 @@ export class ChatSessionStore {
             if (selection.thinkingLevel !== undefined)
                 record.thinkingLevel = selection.thinkingLevel;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -222,7 +228,7 @@ export class ChatSessionStore {
                 throw new Error(`chat session not found: ${sessionId}`);
             record.state = state;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return record;
         });
     }
@@ -232,6 +238,7 @@ export class ChatSessionStore {
             if (!record)
                 return false;
             await rm(recordPath(this.appData, sessionId), { force: true });
+            this.options.onRecordChange?.(sessionId, undefined);
             return true;
         });
     }
@@ -285,7 +292,7 @@ export class ChatSessionStore {
             record.deferredTurn = queue[0];
             record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = now;
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return { ok: true, deferredTurn, idempotent: false };
         });
     }
@@ -313,7 +320,7 @@ export class ChatSessionStore {
             record.deferredTurn = queue[0];
             record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = next.updatedAt;
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return { ok: true, deferredTurn: next };
         });
     }
@@ -335,7 +342,7 @@ export class ChatSessionStore {
             record.deferredTurn = queue[0];
             record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = next.updatedAt;
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return next;
         });
     }
@@ -356,7 +363,7 @@ export class ChatSessionStore {
             record.deferredTurn = queue[0];
             record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return { ok: true, deferredTurn: existing };
         });
     }
@@ -373,7 +380,7 @@ export class ChatSessionStore {
             record.deferredTurn = queue[0];
             record.deferredQueueRevision = (record.deferredQueueRevision ?? 0) + 1;
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return { deferredTurn: existing, clearedRevision: existing.revision + 1 };
         });
     }
@@ -392,7 +399,7 @@ export class ChatSessionStore {
                 record.displayTitle = cleanChatTitle(stored.text);
             }
             record.updatedAt = stored.at;
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
             return stored;
         });
     }
@@ -403,7 +410,7 @@ export class ChatSessionStore {
                 return;
             record.toolInvocations.push({ ...entry, at: new Date().toISOString() });
             record.updatedAt = new Date().toISOString();
-            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            await this.persist(record);
         });
     }
 }
@@ -501,10 +508,12 @@ export async function runChatTurn(options) {
             },
         };
     }
-    const userMessage = await store.appendMessage(sessionId, { role: "user", text });
-    const afterUserMessage = await store.get(sessionId);
-    if (afterUserMessage)
-        await options.onUserMessagePersisted?.(afterUserMessage, userMessage);
+    if (options.persistUserMessage !== false) {
+        const userMessage = await store.appendMessage(sessionId, { role: "user", text });
+        const afterUserMessage = await store.get(sessionId);
+        if (afterUserMessage)
+            await options.onUserMessagePersisted?.(afterUserMessage, userMessage);
+    }
     let turnError;
     // Collect persistence promises so runChatTurn does not resolve before the
     // chat history / audit trail is durably written (also makes the outcome

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

@@ -44,6 +44,13 @@ export const SHORTCUTS = [
 ];
 /** Pi Web commands with real browser-equivalent behavior (UI-11). */
 export const WEB_SLASH_COMMANDS = [
+    {
+        command: "/goal",
+        label: "持续目标",
+        description: "创建或编辑一个跨多个回合持续推进的目标",
+        action: "goal",
+        source: "web",
+    },
     {
         command: "/compact",
         label: "压缩上下文",

package/dist/worker/console/chat/sift-bridge.js

@@ -0,0 +1 @@
+export { createSiftBridgeState, parseSiftBridgeConfig, compressProviderPayload, executeSiftRetrieve, housekeepSiftStash, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, SIFT_POLICY_VERSION, } from "../../../shared/pi-context-pressure/sift-bridge.js";

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

@@ -34,17 +34,21 @@ export function hydrateSessionThread(raw) {
     for (const item of raw) {
         const createdAt = Date.parse(item.at) || Date.now();
         if (item.role === "user") {
-            turnId = `restored-${item.id}`;
+            turnId = item.turnId ?? `restored-${item.id}`;
             pendingTools = [];
             messages.push({
                 id: item.id,
                 role: "user",
                 text: item.text,
                 createdAt,
+                ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
+                ...(item.turnId ? { turnId: item.turnId } : {}),
             });
             continue;
         }
         if (item.role === "assistant") {
+            if (item.turnId)
+                turnId = item.turnId;
             if (!turnId)
                 turnId = `restored-${item.id}`;
             const content = parseAssistantContent(item.content);
@@ -53,6 +57,8 @@ export function hydrateSessionThread(raw) {
                 role: "assistant",
                 text: item.text,
                 createdAt,
+                ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
+                ...(item.turnId ? { turnId: item.turnId } : {}),
                 ...(item.kind === "provider-error" && item.providerError
                     ? { kind: item.kind, providerError: item.providerError }
                     : {}),
@@ -62,6 +68,8 @@ export function hydrateSessionThread(raw) {
             continue;
         }
         if (item.role === "tool") {
+            if (item.turnId)
+                turnId = item.turnId;
             if (!turnId)
                 turnId = `restored-tool-${item.id}`;
             const entry = {
@@ -72,7 +80,11 @@ export function hydrateSessionThread(raw) {
                 result: item.text,
                 createdAt,
                 finishedAt: createdAt,
-                turnId,
+                turnId: item.turnId ?? turnId,
+                ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
+                ...(item.finishedSeq === undefined
+                    ? {}
+                    : { finishedSeq: item.finishedSeq }),
                 ...(item.operationId ? { operationId: item.operationId } : {}),
             };
             toolCalls.push(entry);
@@ -196,6 +208,8 @@ function fillProcessDetails(group) {
         group.answer = finalAssistant;
         return;
     }
+    if (split.answerBlocks.length === 0)
+        return;
     const answerText = joinAssistantText(split.answerBlocks);
     group.answer = {
         ...finalAssistant,
@@ -207,7 +221,22 @@ function fillProcessDetails(group) {
  * Build user → process → answer groups for the message timeline.
  */
 export function buildTurnProcessGroups(input) {
-    const visible = input.messages.filter((m) => m.role === "user" || m.role === "assistant");
+    const visible = input.messages
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .sort((a, b) => {
+        if (a.eventSeq !== undefined &&
+            b.eventSeq !== undefined &&
+            a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        if (a.eventSeq !== undefined && b.eventSeq === undefined)
+            return 1;
+        if (a.eventSeq === undefined && b.eventSeq !== undefined)
+            return -1;
+        return 0;
+    });
     const groups = [];
     let current = null;
     const startGroup = (key) => {

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",