@tea-agent/loop-agent 0.41.0-next.3 → 0.41.1-beta.0

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

@@ -175,8 +175,11 @@ export function splitDocumentIntoFragments(doc) {
         const explicitSectionAc = matchExplicitAcHeading(lastHeadingSegment);
         const sectionKind = classifySectionHeading(section.headingPath);
         const effectiveKind = explicitSectionAc ? "acceptance" : sectionKind;
+        // V4 显式 AC 标题行已在下方入口 emit（explicitSectionAc 分支）；正文循环
+        // 必须从标题行的下一行开始，否则同一标题行会被正文循环的 heading 分支
+        // 再次 emit，产生结构性 duplicate（每个 AC 标题式片段出现两次）。
         const bodyStart = section.headingPath
-            ? section.startLine + (explicitSectionAc ? 0 : 1)
+            ? section.startLine + 1
             : section.startLine;
         const bodyEnd = section.endLine;
         const bodyLines = lines.slice(Math.max(0, bodyStart - 1), Math.min(bodyEnd, lines.length));
@@ -438,14 +441,17 @@ export function buildFragmentInventory(input) {
             disposition = "non-goal";
         }
         else {
-            const executable = EXECUTABLE_HINT_RE.test(text);
-            disposition = executable ? "unresolved" : "context-only";
-            if (disposition === "unresolved") {
-                reason = "executable fragment outside recognized requirement/acceptance section";
-            }
-            else {
-                reason = "context-only fragment; excluded from canonical requirement coverage";
-            }
+            // Non-goal/constraint/acceptance/objective sections are classified
+            // above. An "other" section (背景 / 概述 / 说明 …) is contextual
+            // description, not an executable requirement: even when it mentions
+            // implementation verbs ("需要", "渲染", "组件"), it must not be
+            // promoted to a high-risk unresolved executable fragment — that
+            // blocks PRDs whose 背景 prose happens to use such words (merge
+            // regression: "需要一个小组件" was flagged executable via 需要).
+            // Explicit AC ids are already handled by the branches above, so
+            // this branch is always contextual.
+            disposition = "context-only";
+            reason = "context-only fragment; excluded from canonical requirement coverage";
         }
         const priorId = seenText.get(text);
         if (priorId) {

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

@@ -5,6 +5,9 @@ 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";
@@ -681,7 +684,7 @@ export async function prepareTaskSource(input) {
             facts = importedFacts ?? mergedSupplemental;
         }
     }
-    const built = buildPrepareDraft({
+    let built = buildPrepareDraft({
         taskId,
         existingTaskConfig,
         baseDraft,
@@ -689,6 +692,91 @@ 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,8 +457,12 @@ 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)",
-        "- taskKind when clearly implied (backend-test / frontend-test / standard / …)",
+        "- 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.",
         "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,6 +22,18 @@ 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}`;
@@ -149,10 +161,19 @@ 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: importedAt,
+        updatedAt: documentSetChanged
+            ? importedAt
+            : (existingManifest?.updatedAt ?? importedAt),
         documents,
     };
     await writeSourceManifest(paths.sourceDir, manifest);

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

@@ -67,11 +67,10 @@ 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 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.",
+    "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.",
     "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/routes.js

@@ -34,7 +34,7 @@ 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, deriveChatTurnTelemetry } from "./session-stats.js";
+import { deriveChatSessionTelemetry } 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";
@@ -99,16 +99,8 @@ export function projectStoredMessagesWithEventOrder(messages, events) {
         }
         return {
             ...message,
-            ...(start
-                ? {
-                    eventSeq: start.seq,
-                    turnId: start.turnId,
-                    startedAt: start.at,
-                }
-                : {}),
-            ...(finish
-                ? { finishedSeq: finish.seq, finishedAt: finish.at }
-                : {}),
+            ...(start ? { eventSeq: start.seq, turnId: start.turnId } : {}),
+            ...(finish ? { finishedSeq: finish.seq } : {}),
         };
     });
 }
@@ -836,7 +828,6 @@ 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,6 +296,13 @@ 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
@@ -306,17 +313,6 @@ 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";
@@ -381,11 +377,14 @@ 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: "正在等待新的执行进展",
+            title: seconds
+                ? `正在等待新的执行进展，最长等待时间 ${seconds} 秒`
+                : "正在等待新的执行进展",
             activityRef,
         };
     }

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

@@ -156,102 +156,6 @@ 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/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 { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
+import { semanticActivityForTool, } from "./semantic-activity.js";
 function emptyGroup(key) {
     return {
         key,
@@ -72,22 +72,14 @@ 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: Number.isFinite(startedAtMs)
-                    ? startedAtMs
-                    : createdAt,
-                finishedAt: Number.isFinite(finishedAtMs)
-                    ? finishedAtMs
-                    : createdAt,
+                createdAt,
+                finishedAt: createdAt,
                 turnId: item.turnId ?? turnId,
                 ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
                 ...(item.finishedSeq === undefined
@@ -126,11 +118,6 @@ 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 });
@@ -140,17 +127,6 @@ 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) {
@@ -225,7 +201,7 @@ function fillProcessDetails(group) {
     const orphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
     if (orphans.length > 0)
         flushToolBuffer(processItems, orphans);
-    group.processItems = collapseDagProgressItems(processItems);
+    group.processItems = processItems;
     if (!finalAssistant)
         return;
     if (blocks.length === 0) {

package/dist/worker/console/frontend-human-decision-adapter.js

@@ -0,0 +1,19 @@
+import { parseFrontendHumanDecisionProjection } from "../../workflows/dag/frontend-human-decision.js";
+/** Worker/Console persistence seam. Canonical validation and freshness remain in the workflow service. */
+export function createFrontendHumanDecisionAdapter(store) {
+    return {
+        async load(operationId) {
+            const record = await store.get(operationId);
+            if (!record || record.revision === undefined || !record.frontendHumanDecision)
+                return undefined;
+            return { revision: record.revision, projection: parseFrontendHumanDecisionProjection(record.frontendHumanDecision) };
+        },
+        materialize(input) {
+            return store.materializeFrontendHumanDecision(input);
+        },
+        consume(input) {
+            return store.consumeFrontendHumanDecision(input);
+        },
+        initializeSplit: store.initializeFrontendHumanApprovedSplit.bind(store),
+    };
+}

package/dist/worker/console/frontend-split-operation-adapter.js

@@ -0,0 +1,20 @@
+import { FrontendSplitOrchestrator, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
+/** Worker/Console boundary adapter. All orchestration policy remains canonical. */
+export function createFrontendSplitOperationAdapter(dependencies) {
+    const ports = {
+        load: async (operationId) => {
+            const record = await dependencies.store.get(operationId);
+            return record?.frontendSplit === undefined ? undefined : frontendSplitProjectionSchema.parse(record.frontendSplit);
+        },
+        compareAndSwap: (input) => dependencies.store.compareAndSwapFrontendSplit(input),
+        materialize: async (request) => {
+            const result = await dependencies.materializer.materialize(request);
+            return { taskId: result.taskId, operationId: result.operationId };
+        },
+        schedule: dependencies.schedule,
+        auditStale: dependencies.auditStale,
+        loadChildCloseoutFacts: (input) => dependencies.store.loadChildCloseoutFacts(input),
+        settleAggregate: (input) => dependencies.store.settleFrontendSplitAggregate({ ...input, prepareAggregate: dependencies.prepareAggregate }),
+    };
+    return new FrontendSplitOrchestrator(ports);
+}

package/dist/worker/console/index.js

@@ -11,6 +11,9 @@ export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateT
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";
 export { OperationStore } from "./operation-store.js";
+export { createFrontendSplitOperationAdapter } from "./frontend-split-operation-adapter.js";
+export { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+export { FrontendSplitTaskMaterializer } from "../materialize/frontend-split-task-materializer.js";
 export { createOperationEventStore } from "./operation-sse.js";
 export { DagConfirmationStore } from "./dag-confirmation.js";
 export { DraftStore } from "./draft-store.js";