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

package/dist/task/source-prepare/prepare.js

@@ -5,9 +5,6 @@ import { ContractMutationError, applyTaskContract, logicalRevisionForState, obse
 import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskContractPaths } from "../contract/paths.js";
 import { loadTaskConfig } from "../runtime.js";
-import { discoverFrontendProjectCapability, resolveFrontendSpecRootAliases, } from "../frontend-project-capability.js";
-import { classifyTaskDemand } from "../task-demand-routing.js";
-import { DEFAULT_FRONTEND_SPEC_ROOTS, extractDeclaredFrontendSpecRoots, } from "../../shared/openspec-spec.js";
 import { buildPrepareDraft } from "./build-draft.js";
 import { hasBlockingGaps, hasBlockingRisks, isFreshLegacyUnversioned, listPrepareGaps, appendLedgerGaps, } from "./completeness.js";
 import { detectProductArtifactMeta, isIntakeSoftGapCode, } from "./artifact-meta.js";
@@ -684,7 +681,7 @@ export async function prepareTaskSource(input) {
             facts = importedFacts ?? mergedSupplemental;
         }
     }
-    let built = buildPrepareDraft({
+    const built = buildPrepareDraft({
         taskId,
         existingTaskConfig,
         baseDraft,
@@ -692,91 +689,6 @@ export async function prepareTaskSource(input) {
         flags: input.flags,
         references,
     });
-    // Resolve an implicit frontend workflow before the first managed contract is
-    // projected. Explicit taskKind (including explicit standard) remains a hard
-    // contract; only a standard task with strong source/path/project evidence may
-    // be promoted here. This keeps task.json, contract.json, and the first DAG
-    // generation on the same workflow without a later hash-changing re-projection.
-    if (built.draft.taskKind === "standard" &&
-        !built.draft.taskKindExplicit) {
-        const routingRequirement = [
-            ...(sourceIntegrity?.documents ?? [])
-                .map((document) => document.content)
-                .filter((content) => Boolean(content?.trim())),
-            ...(input.intent.kind === "facts" && input.intent.text
-                ? [input.intent.text]
-                : []),
-            built.draft.requirement.objective,
-            ...built.draft.requirement.scope,
-            ...built.draft.requirement.acceptanceCriteria.map((item) => item.text),
-        ].join("\n");
-        let frontendProject;
-        try {
-            frontendProject = await discoverFrontendProjectCapability(repoRoot);
-        }
-        catch {
-            // Capability discovery is advisory for routing. A failed probe must not
-            // turn an otherwise valid standard contract preparation into an error.
-        }
-        const classification = classifyTaskDemand({
-            title: built.draft.title,
-            requirementMarkdown: routingRequirement,
-            allowedPaths: built.draft.constraints.allowedPaths,
-            frontendProject: frontendProject
-                ? {
-                    framework: frontendProject.framework,
-                    evidencePaths: frontendProject.evidencePaths,
-                }
-                : undefined,
-        });
-        if (classification.kind === "frontend") {
-            built = buildPrepareDraft({
-                taskId,
-                existingTaskConfig,
-                baseDraft,
-                facts,
-                flags: {
-                    ...input.flags,
-                    taskKind: "frontend-implementation",
-                },
-                references,
-            });
-        }
-    }
-    // A user can explicitly name a non-default normative directory in the task
-    // prompt (for example “规范目录 `design-system`”). Freeze that root into
-    // the managed task config before the DAG exists; normal DAG selection consumes
-    // the already-resolved task kind instead of mutating task.json later.
-    if (built.draft.taskKind === "frontend-implementation") {
-        // An imported PRD is materialized under sourceIntegrity rather than copied
-        // into intent.text. Use both inputs so a `--prd` invocation can declare a
-        // task-owned spec root just like supplemental free-form text can.
-        const sourceText = [
-            ...(sourceIntegrity?.documents ?? []).flatMap((document) => document.content ? [document.content] : []),
-            ...(input.intent.kind === "facts" && input.intent.text
-                ? [input.intent.text]
-                : []),
-        ].join("\n");
-        const inferredRoots = extractDeclaredFrontendSpecRoots(sourceText);
-        if (inferredRoots.length > 0) {
-            const current = existingTaskConfig?.frontendOpenspec;
-            const configuredRoots = current?.specRoots ?? [...DEFAULT_FRONTEND_SPEC_ROOTS];
-            // Include roots declared by this source before resolving physical-target
-            // aliases. A newly declared root may itself be a symlink (for example
-            // `project-specs -> .../ai_doc`), so resolving aliases against only the
-            // previous config cannot map `ai_doc/rules.md` back to project-specs.
-            const provisionalRoots = [
-                ...new Set([...configuredRoots, ...inferredRoots]),
-            ].sort();
-            const aliases = await resolveFrontendSpecRootAliases(repoRoot, provisionalRoots);
-            const aliasMap = new Map(aliases.map(({ alias, logicalRoot }) => [alias, logicalRoot]));
-            built.draft.frontendOpenspec = {
-                policy: current?.policy ?? "cited",
-                specRoots: [...new Set([...configuredRoots, ...inferredRoots.map((root) => aliasMap.get(root) ?? root)])].sort(),
-                requiredReadPaths: current?.requiredReadPaths ?? [],
-            };
-        }
-    }
     const { gaps, risks } = listPrepareGaps({
         draft: built.draft,
         state,

package/dist/task/source-prepare/semantic-intake.js

@@ -457,12 +457,8 @@ async function buildPrompt(input) {
         "Do NOT invent product behavior that is not supported by the documents.",
         "You MAY recommend an optional engineering block when the repo layout hint supports it:",
         "- allowedPaths / forbiddenPaths as minimal precise globs (e.g. source/packages/**/*.test.ts)",
-        "- verifyCommands as real package scripts (e.g. pnpm -C source test); when acceptance criteria name a specific test file to run (e.g. 定向 vitest（test/.../xxx.test.ts）), emit the corresponding targeted command as its own entry (e.g. npx vitest run test/.../xxx.test.ts) instead of only the full-suite script — targeted commands are what a frontend implementation plan maps to behavior verification targets",
-        "- taskKind when clearly implied, choosing from {standard / frontend-implementation / frontend-test / backend-test / knowledge-sync}:",
-        "  - frontend-implementation: the deliverable is a frontend component/page/UI feature (even when it ships with its own tests)",
-        "  - frontend-test: the deliverable is a browser/UI automation test suite for EXISTING functionality (no implementation work)",
-        "  - backend-test: pytest/backend test suite; standard: general repo implementation",
-        "  A task that IMPLEMENTS a component and adds tests for it is frontend-implementation, never frontend-test.",
+        "- verifyCommands as real package scripts (e.g. pnpm -C source test)",
+        "- taskKind when clearly implied (backend-test / frontend-test / standard / …)",
         "Prefer smallest correct write boundary; do not invent product paths that are not in the layout hint.",
         "Do NOT rewrite or suggest editing the original PRD files.",
         "Prefer explicit text; use provenance derived for rephrasing; use inferred only when clearly implied — if you must invent ACs, leave acceptanceCriteria empty so the system can stop for clarification.",

package/dist/task/source-references.js

@@ -22,18 +22,6 @@ function slugifyName(value) {
         .replace(/-{2,}/g, "-");
     return slug || "requirement";
 }
-/** Stable identity of a manifest document for change detection. Timestamps and
- * byte sizes are excluded: identical content re-imported later must not appear
- * "changed" (the canonical hash includes manifest bytes). */
-function documentIdentity(doc) {
-    return `${doc.role}|${doc.name}|${doc.materializedPath}|${doc.sha256}`;
-}
-function sameDocumentSet(left, right) {
-    if (left.length !== right.length)
-        return false;
-    const rightIds = new Set(right.map(documentIdentity));
-    return left.every((doc) => rightIds.has(documentIdentity(doc)));
-}
 function ensureUniqueReferenceName(existing, baseName, extension) {
     const used = new Set(existing);
     const candidate = `${baseName}${extension}`;
@@ -161,19 +149,10 @@ export async function importPrdDocument(input) {
     const documents = [...(existingManifest?.documents ?? [])].filter((entry) => entry.materializedPath !== materializedRelativePath);
     documents.push(document);
     documents.sort((left, right) => left.materializedPath.localeCompare(right.materializedPath));
-    // Keep `updatedAt` stable across re-imports of the same content: the
-    // canonical contract hash includes the manifest bytes, so a fresh
-    // timestamp on every identical re-import would make the observed
-    // canonical hash drift and fail task verification. Only bump it when the
-    // document set actually changed (a new/changed materialized file).
-    const documentSetChanged = !existingManifest ||
-        !sameDocumentSet(existingManifest.documents, documents);
     const manifest = {
         schemaVersion: 1,
         taskId: input.taskId,
-        updatedAt: documentSetChanged
-            ? importedAt
-            : (existingManifest?.updatedAt ?? importedAt),
+        updatedAt: importedAt,
         documents,
     };
     await writeSourceManifest(paths.sourceDir, manifest);

package/dist/task/task-demand-routing.js

@@ -76,6 +76,7 @@ const SPECIAL_TEMPLATE_BY_TASK_KIND = {
     "frontend-implementation": "frontend-implementation",
     "frontend-test": "frontend-test-dag",
     "backend-test": "backend-test-dag",
+    "backend-test-analysis": "backend-test-analysis-dag",
     "knowledge-sync": "knowledge-sync-dag",
     "knowledge-graph-bootstrap": "knowledge-graph-bootstrap-dag",
 };
@@ -83,6 +84,7 @@ const TASK_KIND_ROUTING_REASON = {
     "frontend-implementation": 'taskKind "frontend-implementation" selects the dedicated frontend DAG template',
     "frontend-test": 'taskKind "frontend-test" selects the dedicated frontend test DAG template',
     "backend-test": 'taskKind "backend-test" selects the dedicated backend test DAG template',
+    "backend-test-analysis": 'taskKind "backend-test-analysis" selects the read-only backend test analysis DAG template',
     "knowledge-sync": 'taskKind "knowledge-sync" selects the dedicated knowledge-sync DAG template',
     "knowledge-graph-bootstrap": 'taskKind "knowledge-graph-bootstrap" selects the dedicated knowledge-graph bootstrap DAG template',
 };
@@ -90,6 +92,7 @@ const SPECIAL_REQUESTED_TEMPLATES = new Set([
     "frontend-implementation",
     "frontend-test-dag",
     "backend-test-dag",
+    "backend-test-analysis-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",
 ]);

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

@@ -19,8 +19,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import path from "node:path";
-import { ensureSecureDir, writeSecureJsonSync, } from "../app-data.js";
-import { isTerminalOperationState, } from "../operation-store.js";
+import { ensureSecureDir, writeSecureJsonSync, } from "../../../infrastructure/console/app-data.js";
+import { isTerminalOperationState, } from "../../../infrastructure/console/operation-store.js";
 import { scrubSecrets } from "./explore-tools.js";
 const OPERATION_PREVIEW_MAX_CHARS = 1200;
 function boundedRedactedText(value, maxChars = OPERATION_PREVIEW_MAX_CHARS) {

package/dist/worker/console/chat/pi-runtime.js

@@ -67,10 +67,11 @@ export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are General Operator Chat.",
     "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes.",
     "No harness and asked to init: `loop-agent init instructions --repo-root .`, then `loop-agent init --repo-root . --profile full --merge`; verify with doctor, inspect and docs audit. Updates: `loop-agent init upgrade --repo-root . --json` until stable; `loop-agent init check-update` is read-only.",
-    "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait with 60s → 90s → 120s → 180s backoff; reset to 60s on state change; 30-60s re-checks when stall suspected. Every operationWait continuation MUST use afterSeq=previous nextSeq (recommendedNextCall); never reuse older cursors. Heartbeats: not meaningful progress. Run id 20260829-slug ≠ task id 2026-08-29-slug.",
-    "On failure consume terminal runSummary first. If progress exists, wait; else dagReport then dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun (node rerun only: reruns the failed subgraph, keeps prior successes). If plan ineligible (unsafe-shell subgraph, binding/workspace drift): Worker Failed → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume. Run-failed task without open gate is terminal: do not re-advance a run-failed task. Before run start, two identical lifecycleState/blocker/revision/DAG-hash observations mean no progress: stop and report after one bounded probe; never loop identical bash/read/grep. Auto-approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait at 60s → 90s → 120s → 180s; reset to 60s on state change; 30-60s re-checks when stall suspected. operationWait MUST use afterSeq=previous nextSeq (recommendedNextCall). Heartbeats: not meaningful progress. Run id ≠ task id.",
+    "Failure: terminal runSummary first. With progress wait; else dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun: reruns the failed subgraph, keeps prior successes. Ineligible: Worker → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume; do not re-advance a run-failed task. Pre-run identical state twice: stop and report; never loop identical bash/read/grep. Approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
     "Iterate toward the goal in bounded rounds: first summarize the previous round's error in one line, fix its root cause — not the symptom — then rerun the failed node with a fresh plan. Never resubmit an unchanged fix; after two rounds failing the same way, stop and report evidence and remaining routes.",
     "Continue until success, user stop, or no safe recovery remains; then stop and report failure/evidence. Never create a new task for a transient failure or replace repair-pi with direct edits.",
+    "Narrate long-DAG progress briefly at start, meaningful phase changes/findings, verification failure/recovery, prolonged quiet and terminal state: say what finished and what is next. Never narrate unchanged operationWait polls or heartbeats, or claim beyond structured facts.",
 ].join("\n");
 /** Compose the inspectable system prompt actually injected into Operator Chat. */
 export function composeOperatorChatSystemPrompt(input) {

package/dist/worker/console/chat/resource-preferences-store.js

@@ -7,7 +7,7 @@
  */
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync } from "node:fs";
-import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 export const RESOURCE_PREFERENCES_SCHEMA_VERSION = 1;
 export class ResourcePreferencesError extends Error {
     code;

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

@@ -34,14 +34,14 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { makeHumanGateCard, } from "./human-gate-card.js";
 import { ContractApplyReceiptStore } from "./contract-apply-receipt-store.js";
 import { projectTaskContext } from "./context-panel.js";
-import { deriveChatSessionTelemetry } from "./session-stats.js";
+import { deriveChatSessionTelemetry, deriveChatTurnTelemetry } from "./session-stats.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
 import { openSseResponse, writeSseEvent } from "../operation-sse.js";
 import { buildTodoCompactionInstructions, projectCurrentTodos } from "./todos.js";
 import { buildGoalCompactionInstructions, buildGoalContinuationContext, } from "./goals.js";
 import { classifyGoalRoundAdmission, } from "./goal-round-driver.js";
-import { isTerminalOperationState } from "../operation-store.js";
+import { isTerminalOperationState } from "../../../infrastructure/console/operation-store.js";
 /**
  * Reattach the durable event-ring order to session-store rows. The session
  * store remains the content authority; the ring only supplies chronology.
@@ -99,8 +99,16 @@ export function projectStoredMessagesWithEventOrder(messages, events) {
         }
         return {
             ...message,
-            ...(start ? { eventSeq: start.seq, turnId: start.turnId } : {}),
-            ...(finish ? { finishedSeq: finish.seq } : {}),
+            ...(start
+                ? {
+                    eventSeq: start.seq,
+                    turnId: start.turnId,
+                    startedAt: start.at,
+                }
+                : {}),
+            ...(finish
+                ? { finishedSeq: finish.seq, finishedAt: finish.at }
+                : {}),
         };
     });
 }
@@ -828,6 +836,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
+        turnTelemetry: deriveChatTurnTelemetry(snapshot),
         contextPressure: typeof deps.runtime.getContextPressureTelemetry === "function"
             ? deps.runtime.getContextPressureTelemetry(sessionId)
             : undefined,

package/dist/worker/console/chat/semantic-activity.js

@@ -296,13 +296,6 @@ function operationIdFromArgs(args) {
     const operationId = record?.operationId;
     return typeof operationId === "string" && operationId ? operationId : undefined;
 }
-function maxWaitSeconds(args) {
-    const record = parseJsonRecord(args);
-    const raw = record?.maxWaitMs;
-    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
-        return undefined;
-    return Math.max(1, Math.round(raw / 1000));
-}
 function activityRefForTool(tool) {
     // Plan A (2026-08-16): server backfills operationId on the persisted tool
     // entry (and live tool_result frames carry it in the result payload), so
@@ -313,6 +306,17 @@ function activityRefForTool(tool) {
         operationIdFromArgs(tool.resultText);
     return operationId ? `operation:${operationId}` : `tool:${tool.id}`;
 }
+export function dagProgressActivityForTool(tool) {
+    if (tool.toolName !== "operationWait")
+        return undefined;
+    const activityRef = activityRefForTool(tool);
+    if (!activityRef.startsWith("operation:"))
+        return undefined;
+    return {
+        id: `dag-progress:${activityRef}`,
+        activityRef,
+    };
+}
 function semanticKindForStatus(status) {
     if (status === "running")
         return "progress";
@@ -377,14 +381,11 @@ function nodeActivityFromMessages(messages, id, activityRef) {
 function operationWaitActivity(tool) {
     const activityRef = activityRefForTool(tool);
     const id = `activity:${tool.id}`;
-    const seconds = maxWaitSeconds(tool.args);
     if (tool.status === "running") {
         return {
             id,
             kind: "progress",
-            title: seconds
-                ? `正在等待新的执行进展，最长等待时间 ${seconds} 秒`
-                : "正在等待新的执行进展",
+            title: "正在等待新的执行进展",
             activityRef,
         };
     }

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

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

@@ -2,7 +2,7 @@
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
-import { semanticActivityForTool, } from "./semantic-activity.js";
+import { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
 function emptyGroup(key) {
     return {
         key,
@@ -72,14 +72,22 @@ export function hydrateSessionThread(raw) {
                 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,
+                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
@@ -118,6 +126,11 @@ function flushToolBuffer(processItems, buffer) {
         return;
     const sorted = sortToolsStable(buffer);
     for (const tool of sorted) {
+        const dagProgress = dagProgressActivityForTool(tool);
+        if (dagProgress) {
+            processItems.push({ kind: "dag-progress", progress: dagProgress });
+            continue;
+        }
         const activity = semanticActivityForTool(tool);
         if (activity) {
             processItems.push({ kind: "activity", activity });
@@ -127,6 +140,17 @@ function flushToolBuffer(processItems, buffer) {
         }
     }
 }
+function collapseDagProgressItems(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (item.kind !== "dag-progress")
+            return true;
+        if (seen.has(item.progress.activityRef))
+            return false;
+        seen.add(item.progress.activityRef);
+        return true;
+    });
+}
 function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
     let buffer = [];
     for (const block of blocks) {
@@ -201,7 +225,7 @@ function fillProcessDetails(group) {
     const orphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
     if (orphans.length > 0)
         flushToolBuffer(processItems, orphans);
-    group.processItems = processItems;
+    group.processItems = collapseDagProgressItems(processItems);
     if (!finalAssistant)
         return;
     if (blocks.length === 0) {

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);