@tea-agent/loop-agent 0.40.0-next.8 → 0.40.0

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

@@ -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,17 +68,31 @@ export function hydrateSessionThread(raw) {
             continue;
         }
         if (item.role === "tool") {
+            if (item.turnId)
+                turnId = item.turnId;
             if (!turnId)
                 turnId = `restored-tool-${item.id}`;
+            // Prefer event-ring timestamps (tool_call at → tool_result at) so
+            // refreshed sessions keep real elapsed durations instead of 0ms.
+            const startedAtMs = item.startedAt ? Date.parse(item.startedAt) : NaN;
+            const finishedAtMs = item.finishedAt ? Date.parse(item.finishedAt) : NaN;
             const entry = {
                 id: item.toolCallId || item.id,
                 toolName: item.toolName || "tool",
                 status: item.isError === true ? "error" : "ok",
                 resultText: item.text,
                 result: item.text,
-                createdAt,
-                finishedAt: createdAt,
-                turnId,
+                createdAt: Number.isFinite(startedAtMs)
+                    ? startedAtMs
+                    : createdAt,
+                finishedAt: Number.isFinite(finishedAtMs)
+                    ? finishedAtMs
+                    : createdAt,
+                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 +216,8 @@ function fillProcessDetails(group) {
         group.answer = finalAssistant;
         return;
     }
+    if (split.answerBlocks.length === 0)
+        return;
     const answerText = joinAssistantText(split.answerBlocks);
     group.answer = {
         ...finalAssistant,
@@ -207,7 +229,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/dag-execution-receipt.js

@@ -176,8 +176,26 @@ export function deriveEligibilityFactsFromDagSpec(input) {
     }));
     const allWriteSetEntries = writers.flatMap((writer) => writer.writeSet);
     const broadWriteSetRisk = allWriteSetEntries.some(isBroadWriteSetEntry);
-    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => [...stringList(task.forbiddenPaths), ...input.forbiddenPaths].some((forbidden) => pathMatchesPattern(entry, forbidden) ||
-        pathMatchesPattern(forbidden, entry))));
+    const taskForbidden = input.forbiddenPaths.map(normalizePathEntry);
+    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => {
+        const normalizedEntry = normalizePathEntry(entry);
+        return stringList(task.forbiddenPaths).some((forbidden) => {
+            const normalizedForbidden = normalizePathEntry(forbidden);
+            const isTaskGlobal = taskForbidden.includes(normalizedForbidden);
+            if (isTaskGlobal) {
+                // Task-level forbidden paths are hard global boundaries. A broad
+                // writer that could include one is not autonomously eligible.
+                return (pathMatchesPattern(normalizedEntry, normalizedForbidden) ||
+                    pathMatchesPattern(normalizedForbidden, normalizedEntry));
+            }
+            // Node-local forbidden paths may intentionally carve a narrower
+            // child (for example md/README.md) out of a broader writer
+            // writeSet. That exclusion is enforced by the runtime write guard.
+            // It is a conflict only when the writer entry itself is wholly
+            // inside the forbidden boundary.
+            return pathMatchesPattern(normalizedEntry, normalizedForbidden);
+        });
+    }));
     const hasStructuredVerification = tasks.some((task) => {
         if (task.executor !== "shell" || !task.shell)
             return false;

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

@@ -1148,14 +1148,14 @@ export async function dispatchOperatorAction(ctx, req) {
             if (usesUnifiedSurface) {
                 const inspectPath = target
                     ? buildInspectDeepLink(consoleOrigin, target).slice(consoleOrigin.length)
-                    : "/inspect/#/";
+                    : "/#/inspect";
                 return {
                     kind: "sync",
                     status: 200,
                     body: operatorSucceeded("observeLink", {
                         url: target
                             ? buildInspectDeepLink(consoleOrigin, target)
-                            : `${consoleOrigin.replace(/\/+$/, "")}/inspect/#/`,
+                            : `${consoleOrigin.replace(/\/+$/, "")}/#/inspect`,
                         inspectPath,
                         status: "same-origin",
                         requiredCapability: requiredCapability ?? null,
@@ -1641,9 +1641,10 @@ export async function dispatchOperatorAction(ctx, req) {
                 broadWriteSetRisk: typeof reviewPacket.broadWriteSetRisk === "boolean"
                     ? reviewPacket.broadWriteSetRisk
                     : derivedFacts.broadWriteSetRisk,
-                forbiddenOverlapRisk: typeof reviewPacket.forbiddenOverlapRisk === "boolean"
-                    ? reviewPacket.forbiddenOverlapRisk
-                    : derivedFacts.forbiddenOverlapRisk,
+                // Always use the staged DAG + live task boundary derivation here.
+                // The generation review packet lacks task-boundary scope and can
+                // mistake a narrower node-local exclusion for a global overlap.
+                forbiddenOverlapRisk: derivedFacts.forbiddenOverlapRisk,
                 hasStructuredVerification: packetShellVerification,
             };
             const assessment = assessAutonomousExecutionEligibility(eligibility);
@@ -1816,6 +1817,18 @@ export async function dispatchOperatorAction(ctx, req) {
             const taskIdError = taskIdInputError(taskId);
             if (taskIdError)
                 return invalid(action, taskIdError);
+            // Optional write-set gate approval: the token is the server-issued
+            // `<gate-id>:sha256:<hex>` that `task status` reports in
+            // gate.approveCommand. Forwarded as --approve-gate so an operator can
+            // complete the human approval through the Console operation path
+            // instead of dropping to a raw terminal. This dispatch already sits
+            // behind the Console mutation gate (boot cookie + confirmation
+            // header), so it carries the same authority as typing the CLI flag.
+            const approveGateRaw = str(p.approveGate);
+            if (approveGateRaw &&
+                !/^[A-Za-z0-9._-]+:sha256:[0-9a-f]{64}$/.test(approveGateRaw)) {
+                return invalid(action, "approveGate must look like <gate-id>:sha256:<64-hex> (copy the token from task status gate.approveCommand)");
+            }
             const args = ["task", "advance", taskId];
             const title = str(p.title);
             if (title)
@@ -1829,6 +1842,8 @@ export async function dispatchOperatorAction(ctx, req) {
             const profile = str(p.profile);
             if (profile)
                 args.push("--profile", profile);
+            if (approveGateRaw)
+                args.push("--approve-gate", approveGateRaw);
             appendEngineeringCliArgs(args, parseEngineeringBoundaryFromParams(p));
             args.push("--json");
             return acceptOperation(ctx, {

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

@@ -27,7 +27,11 @@ export function encodeInspectHash(selection) {
     }
 }
 export function buildInspectPath(selection) {
-    return `/inspect/${selection ? encodeInspectHash(selection) : "#/"}`;
+    if (!selection)
+        return "/#/inspect";
+    const hash = encodeInspectHash(selection);
+    const internal = hash.startsWith("#") ? hash.slice(1) : hash;
+    return `/#/inspect${internal}`;
 }
 export function buildInspectUrl(origin, selection) {
     const base = origin.trim().replace(/\/+$/, "");
@@ -99,7 +103,7 @@ export function selectionFromObserveLinkTarget(target) {
 export function normalizeLegacyConsoleDagHash(pathnameAndHash) {
     const [pathname, hash = ""] = pathnameAndHash.split("#", 2);
     if ((pathname === "/" || pathname === "") && /^\/dag\/[^/]+$/.test(hash)) {
-        return `/inspect/#${hash}`;
+        return `/#/inspect${hash}`;
     }
     return pathnameAndHash;
 }