@tea-agent/loop-agent 0.39.0-beta.4 → 0.39.0-beta.6

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -58,7 +58,7 @@ function clearEmptyAssistant(setMessages, assistantId) {
 export function useChatStream(params) {
     const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
     const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
-    const { setInput, setPendingImages } = composer;
+    const { setInput, setPendingImages, recordHistory } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
             return;
@@ -393,7 +393,7 @@ export function useChatStream(params) {
             setInput("");
             setPendingImages([]);
             setError(null);
-            showNotice(existing ? "已更新停止后发送的消息" : "已排队，将在上一轮停止后自动发送");
+            showNotice(existing ? "已更新排队消息" : "已排队，将在当前回合结束后自动发送");
         };
         const acceptDispatched = () => {
             setDeferredTurn(null);
@@ -430,7 +430,7 @@ export function useChatStream(params) {
                 }
                 if (body.deferredTurn)
                     setDeferredTurn(body.deferredTurn);
-                if (body.error?.code !== "TURN_NOT_STOPPING") {
+                if (body.error?.code !== "TURN_NOT_ACTIVE") {
                     setError(body.error?.message ??
                         `待发送消息未被服务端接受（HTTP ${response.status}）`);
                     return { action: "handled" };
@@ -495,7 +495,9 @@ export function useChatStream(params) {
         showNotice,
         fetchSessionState,
     ]);
-    const cancelDeferredTurn = useCallback(async () => {
+    /** DELETE the queued turn; "restore" moves its text back into the composer,
+     *  "discard" drops it entirely (2026-08-23 queue chip actions). */
+    const requestDeferredTurnDelete = useCallback(async (mode) => {
         const activeSession = refs.sessionRef.current;
         const deferred = thread.deferredTurn;
         if (!activeSession || !deferred)
@@ -519,10 +521,15 @@ export function useChatStream(params) {
                 return;
             }
             setDeferredTurn(null);
-            setInput(body.deferredTurn?.text ?? "");
-            setPendingImages(body.deferredTurn?.images ?? []);
+            if (mode === "restore") {
+                setInput(body.deferredTurn?.text ?? "");
+                setPendingImages(body.deferredTurn?.images ?? []);
+                showNotice("待发送消息已移回输入框");
+            }
+            else {
+                showNotice("已删除排队消息");
+            }
             setError(null);
-            showNotice("待发送消息已移回输入框");
         }
         catch (error) {
             setError(error instanceof Error ? error.message : String(error));
@@ -537,6 +544,8 @@ export function useChatStream(params) {
         setError,
         showNotice,
     ]);
+    const cancelDeferredTurn = useCallback(() => requestDeferredTurnDelete("restore"), [requestDeferredTurnDelete]);
+    const discardDeferredTurn = useCallback(() => requestDeferredTurnDelete("discard"), [requestDeferredTurnDelete]);
     const sendPrompt = useCallback(async (text, images) => {
         const initialSession = refs.sessionRef.current;
         if (!initialSession || (!text.trim() && images.length === 0))
@@ -548,10 +557,14 @@ export function useChatStream(params) {
         });
         const clientRequestId = requestId("chat-submit");
         if (route.action === "hold") {
-            if (turnPhaseFromOwnership(ownership) === "stopping")
+            const phase = turnPhaseFromOwnership(ownership);
+            if (phase === "stopping")
                 showNotice("正在确认上一轮停止状态，当前消息已保留");
+            else if (phase === "running")
+                showNotice("正在确认当前回合状态，当前消息已保留");
             return;
         }
+        recordHistory?.(text);
         if (route.action === "queue-deferred") {
             const deferred = await queueDeferredTurn({
                 text,
@@ -721,6 +734,7 @@ export function useChatStream(params) {
         setTurnPhase,
         setStreamingAssistantId,
         queueDeferredTurn,
+        recordHistory,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -969,5 +983,11 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, cancelDeferredTurn, openEventsStream };
+    return {
+        sendPrompt,
+        handleStop,
+        cancelDeferredTurn,
+        discardDeferredTurn,
+        openEventsStream,
+    };
 }

package/dist/worker/console/static-src/operator-chat/useComposer.js

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } f
 import { filterSlashCommands, mergeSlashCommands, } from "../../chat/shortcuts.js";
 import { confirmationToken } from "./format.js";
 import { clampShortcutIndex } from "./slash-palette-nav.js";
+import { createInputHistoryState, navigateInputHistory, recordInputHistoryEntry, resetInputHistoryBrowsing, } from "./input-history.js";
 import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
 /** Composer state: input text, @file palette, image attachments, /shortcuts,
  *  IME composition guards, auto-grow and server-side draft sync. */
@@ -31,6 +32,8 @@ export function useComposer(params) {
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
     const textareaRef = useRef(null);
+    /** Arrow-key input history; unsent drafts survive history browsing. */
+    const historyRef = useRef(createInputHistoryState());
     /** Active session generation for /commands; bumped immediately on switch (AC-2). */
     const commandsSessionRef = useRef(sessionId);
     const commandsGenerationRef = useRef(0);
@@ -38,6 +41,33 @@ export function useComposer(params) {
         setInput(value);
         setShortcutOpen(value.startsWith("/"));
         setShortcutIndex(0);
+        // Manual typing edits a recalled entry in place → back to present draft.
+        historyRef.current = resetInputHistoryBrowsing(historyRef.current);
+    }, []);
+    /** Recall an earlier input via ↑/↓; returns true when the key was consumed. */
+    const navigateHistory = useCallback((direction) => {
+        const textarea = textareaRef.current;
+        const decision = navigateInputHistory(historyRef.current, direction, {
+            text: input,
+            caretStart: textarea?.selectionStart ?? input.length,
+            caretEnd: textarea?.selectionEnd ?? input.length,
+        });
+        if (!decision.handled)
+            return false;
+        historyRef.current = decision.state;
+        setInput(decision.text);
+        const caret = decision.text.length;
+        queueMicrotask(() => {
+            const el = textareaRef.current;
+            if (el && el.value === decision.text) {
+                el.setSelectionRange(caret, caret);
+            }
+        });
+        return true;
+    }, [input, setInput]);
+    /** Record a submitted text into history (consecutive duplicates collapse). */
+    const recordHistory = useCallback((text) => {
+        historyRef.current = recordInputHistoryEntry(historyRef.current, text);
     }, []);
     // Immediate invalidation on A→B even when B palette never opens (AC-2).
     useLayoutEffect(() => {
@@ -234,6 +264,8 @@ export function useComposer(params) {
         input,
         setInput,
         handleInputChange,
+        navigateHistory,
+        recordHistory,
         fileOptions,
         pendingImages,
         setPendingImages,

package/dist/worker/console/static-src/pages/tasks/run-id-resolution.js

@@ -0,0 +1,79 @@
+/**
+ * Pure decision core for the TasksPage run-id resolver (2026-08-23).
+ *
+ * Extracted from the React effect so the full lifecycle — wizard first run,
+ * rerun dispatch, task switch, foreign shared selection, baseline-gated
+ * lookup — is unit-testable as state transitions without mounting React.
+ */
+export function initialRunResolutionState() {
+    return { baseline: null, ownedRunId: "", pendingSelection: "" };
+}
+export function observeRunResolution(state, input) {
+    const firstObservation = state.task === undefined;
+    const taskChanged = !firstObservation && state.task !== input.task;
+    const dispatchChanged = !firstObservation && state.dispatch !== input.dispatchId;
+    const next = {
+        ...state,
+        task: input.task,
+        dispatch: input.dispatchId,
+        pendingSelection: "",
+    };
+    if (taskChanged) {
+        next.baseline = null;
+        next.ownedRunId = "";
+        return { state: next, observation: { action: "reset-selection" } };
+    }
+    if (dispatchChanged) {
+        next.ownedRunId = "";
+        if (input.selectedRunId) {
+            next.baseline = input.selectedRunId;
+            return { state: next, observation: { action: "invalidate-selection" } };
+        }
+        // Nothing shown yet: keep the existing baseline and keep probing.
+    }
+    const selected = input.selectedRunId;
+    if (selected && selected !== next.ownedRunId) {
+        next.pendingSelection = selected;
+        return { state: next, observation: { action: "verify-ownership" } };
+    }
+    return {
+        state: next,
+        observation: { action: selected ? "idle" : "probe" },
+    };
+}
+export function markBaselineUnknown(state) {
+    return { ...state, baseline: null };
+}
+export function applyBaselineSnapshot(state, dagRunId) {
+    return { ...state, baseline: dagRunId ?? "" };
+}
+/** Accept an observeLink lookup: only a run of this task that differs from
+ *  the pre-dispatch baseline may be adopted — never the previous run, and
+ *  never anything while the baseline is still unknown. */
+export function applyRunLookup(state, outcome) {
+    if (!outcome.ok || !outcome.dagRunId) {
+        return { state, acceptedRunId: null };
+    }
+    if (state.baseline === null || outcome.dagRunId === state.baseline) {
+        return { state, acceptedRunId: null };
+    }
+    return {
+        state: { ...state, ownedRunId: outcome.dagRunId },
+        acceptedRunId: outcome.dagRunId,
+    };
+}
+/** Apply an authoritative ownership answer for the pending selection.
+ *  `clearSelection` tells the adapter to drop the shared selection and
+ *  snapshot a fresh baseline; owning marks it as resolver-owned. */
+export function applyOwnership(state, owns) {
+    if (owns) {
+        return {
+            state: { ...state, ownedRunId: state.pendingSelection, pendingSelection: "" },
+            clearSelection: false,
+        };
+    }
+    return {
+        state: { ...state, ownedRunId: "", pendingSelection: "", baseline: null },
+        clearSelection: true,
+    };
+}

package/dist/worker/console/static-src/pages/tasks/run-ownership-verify.js

@@ -0,0 +1,23 @@
+/**
+ * Ownership re-check backoff for an unverified shared DAG-run selection
+ * (2026-08-23): a transient candidates-lookup failure must neither leave
+ * another task's run displayed indefinitely (waiting for a state change
+ * that may never come) nor hammer the API.
+ */
+const OWNERSHIP_RETRY_DELAYS_MS = [
+    2_000, 2_000, 4_000, 4_000, 8_000, 8_000, 15_000, 15_000, 30_000, 30_000,
+];
+/** `owns`: true = same task, false = foreign task, null = check unavailable. */
+export function planOwnershipVerification(owns, attempt) {
+    if (owns === true)
+        return { kind: "own" };
+    if (owns === false)
+        return { kind: "clear" };
+    const delayMs = OWNERSHIP_RETRY_DELAYS_MS[attempt];
+    return delayMs === undefined
+        ? { kind: "give-up" }
+        : { kind: "retry", delayMs };
+}
+/** Total bounded re-verification window before giving up (keeps the last
+ *  selection; the next state change restarts verification). */
+export const OWNERSHIP_RETRY_WINDOW_MS = OWNERSHIP_RETRY_DELAYS_MS.reduce((total, delay) => total + delay, 0);

package/dist/worker/console/static-src/pages/tasks/run-panel-progress.js

@@ -0,0 +1,110 @@
+/**
+ * Pure projection from a DAG run detail payload (GET /api/dag-runs/:id) into
+ * the structured run progress shown on the wizard RunPanel: node counts,
+ * current node + elapsed time, failure pointer, and stall signal. The panel
+ * used to show only a raw SSE log tail — node/phase information drowned in
+ * log noise during 20-40 minute runs.
+ */
+export function classifyRunProgressNodeStatus(raw) {
+    const status = (raw ?? "").trim().toLowerCase();
+    if (!status)
+        return "pending";
+    if (status.includes("running") || status === "in_progress" || status === "active") {
+        return "running";
+    }
+    if (status.includes("fail") || status.includes("error") || status === "blocked") {
+        return "failed";
+    }
+    if (status.includes("finish") ||
+        status.includes("success") ||
+        status === "done" ||
+        status === "ok") {
+        return "finished";
+    }
+    if (status.includes("skip"))
+        return "skipped";
+    return "pending";
+}
+function toProgressNode(node) {
+    const nodeId = String(node.nodeId ?? node.id ?? "").trim();
+    return {
+        nodeId,
+        label: String((node.label ?? node.name ?? nodeId) || "未命名节点"),
+        status: String(node.status ?? ""),
+        rank: typeof node.rank === "string" ? node.rank : undefined,
+        startedAt: typeof node.startedAt === "string" ? node.startedAt : undefined,
+        durationMs: typeof node.durationMs === "number" ? node.durationMs : undefined,
+        errorPreview: typeof node.errorPreview === "string" ? node.errorPreview : undefined,
+    };
+}
+function elapsedSince(iso, now) {
+    if (!iso)
+        return null;
+    const started = Date.parse(iso);
+    if (Number.isNaN(started))
+        return null;
+    const elapsed = now - started;
+    return elapsed >= 0 ? elapsed : null;
+}
+export function summarizeRunProgress(dag, now = Date.now()) {
+    if (!dag) {
+        return {
+            total: 0,
+            finished: 0,
+            running: null,
+            failed: null,
+            terminal: false,
+            effectiveStatus: null,
+            stalled: false,
+            currentNodeElapsedMs: null,
+            runElapsedMs: null,
+        };
+    }
+    const rawNodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+    const nodes = rawNodes.map(toProgressNode);
+    const classes = nodes.map((node) => classifyRunProgressNodeStatus(node.status));
+    const finished = classes.filter((cls) => cls === "finished" || cls === "skipped").length;
+    const runningIndex = classes.indexOf("running");
+    const running = runningIndex >= 0 ? nodes[runningIndex] : null;
+    const failedIndex = classes.indexOf("failed");
+    const failed = failedIndex >= 0 ? nodes[failedIndex] : null;
+    const effectiveStatus = String(dag.effectiveStatus ??
+        dag.status ??
+        "").toLowerCase();
+    const terminal = TERMINAL_RUN_PROGRESS_STATUSES.has(effectiveStatus);
+    const runStartedAt = typeof dag.startedAt === "string" ? dag.startedAt : undefined;
+    const runDurationMs = typeof dag.durationMs === "number" ? dag.durationMs : undefined;
+    return {
+        total: nodes.length,
+        finished,
+        running,
+        failed,
+        terminal,
+        effectiveStatus: effectiveStatus || null,
+        stalled: effectiveStatus === "running-suspected-stall",
+        currentNodeElapsedMs: running?.durationMs ?? elapsedSince(running?.startedAt, now),
+        runElapsedMs: terminal
+            ? (runDurationMs ?? elapsedSince(runStartedAt, now))
+            : elapsedSince(runStartedAt, now),
+    };
+}
+const TERMINAL_RUN_PROGRESS_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+export function formatDurationMs(ms) {
+    if (ms == null || !Number.isFinite(ms) || ms < 0)
+        return "—";
+    const totalSeconds = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours} 时 ${minutes} 分`;
+    if (minutes > 0)
+        return `${minutes} 分 ${seconds} 秒`;
+    return `${seconds} 秒`;
+}

package/dist/worker/materialize/harness-task-lineage.js

@@ -129,11 +129,14 @@ export async function resolveRevisionDigestsForTaskSpec(input) {
     };
 }
 /** Union TaskSpec allowed_paths with workflow-owned write roots. */
-export function expandAllowedPathsForWorkflow(workflow, allowedPaths) {
+export function expandAllowedPathsForWorkflow(workflow, allowedPaths, options) {
     const extras = workflow === "backend-test"
         ? ["testcase/**", "docs/test-reports/**"]
         : workflow === "frontend-test"
-            ? ["testcase/frontend/**", "docs/test-reports/**"]
+            ? [
+                `${options?.frontendTestRoot ?? "testcase/frontend"}/**`,
+                "docs/test-reports/**",
+            ]
             : [];
     return Array.from(new Set([...allowedPaths, ...extras]));
 }

package/dist/worker/observability/read-model.js

@@ -1483,6 +1483,9 @@ function mergeDagRun(existing, incoming) {
         computeDurationMs(startedAt, finishedAt);
     return {
         dagRunId: incoming.dagRunId,
+        ...((incoming.taskId ?? existing.taskId)
+            ? { taskId: incoming.taskId ?? existing.taskId }
+            : {}),
         status: incoming.status ?? existing.status,
         lifecycle: incoming.lifecycle ?? existing.lifecycle,
         executionMode: incoming.executionMode ?? existing.executionMode,
@@ -1914,8 +1917,10 @@ async function parseDagStateFile(statePath, now) {
             }
             : undefined;
         const failureCategory = readString(parsed, "failureCategory");
+        const boundTaskId = await readRunSpecTaskBinding(runSpecPath);
         return {
             dagRunId,
+            ...(boundTaskId ? { taskId: boundTaskId } : {}),
             status,
             ...(lifecycle ? { lifecycle } : {}),
             ...(executionMode ? { executionMode } : {}),
@@ -2435,6 +2440,23 @@ async function safeReadJson(filePath) {
         return undefined;
     return parsed;
 }
+/** Task binding for a DAG run from run.json — same precedence as
+ *  console/resolve-dag-run-for-task (taskContractBinding → sourceBinding →
+ *  Hybrid DAG title). */
+async function readRunSpecTaskBinding(runSpecPath) {
+    const parsed = await safeReadJson(runSpecPath);
+    if (!parsed)
+        return undefined;
+    const binding = parsed.taskContractBinding;
+    const source = parsed.sourceBinding;
+    const fromBinding = (typeof binding?.taskId === "string" && binding.taskId.trim()) ||
+        (typeof source?.taskId === "string" && source.taskId.trim());
+    if (fromBinding)
+        return fromBinding;
+    const title = typeof parsed.title === "string" ? parsed.title.trim() : "";
+    const hybrid = /^Hybrid DAG:\s*(.+)$/i.exec(title);
+    return hybrid?.[1]?.trim() || undefined;
+}
 function safeParseJson(raw) {
     try {
         const parsed = JSON.parse(raw);

package/dist/workflows/dag/dynamic-runtime/loop-until.js

@@ -76,7 +76,7 @@ export async function executeDynamicLoopUntil(input) {
             bodyIdMap,
         }));
         for (const child of children) {
-            assertValidMaterializedDagTask(child);
+            assertValidMaterializedDagTask(child, input.spec);
             if (!input.tasksById.has(child.id)) {
                 input.tasksById.set(child.id, child);
                 input.spec.tasks.push(child);

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -170,7 +170,7 @@ export async function executeDynamicMapExpansion(input) {
         nodeId,
     }));
     for (const child of children) {
-        assertValidMaterializedDagTask(child);
+        assertValidMaterializedDagTask(child, input.spec);
     }
     const writeSetConflicts = collectDynamicChildWriteSetConflicts(children);
     if (writeSetConflicts.length > 0) {

package/dist/workflows/dag/failure-category.js

@@ -1,130 +1,9 @@
 import { z } from "zod";
-export const dagNormalizedFailureCategorySchema = z.enum([
-    "success",
-    "validation",
-    "executor",
-    "write-guard",
-    "timeout",
-    "auth",
-    "human-required",
-    "human-rejected",
-    "shell-command",
-    "static-error",
-    "decision-envelope",
-    "skipped",
-    "unknown",
-]);
+import { DAG_NORMALIZED_FAILURE_CATEGORY_VALUES } from "../../shared/dag-failure-category.js";
+// The pure classification core lives in src/shared/dag-failure-category.ts so
+// the Operator Console projection can normalize raw CLI categories without
+// importing the workflows kernel (console/workflows boundary test). This
+// module keeps the schema surface for the DAG kernel's existing consumers.
+export { isDagFailureCategory, normalizeDagFailureCategory, } from "../../shared/dag-failure-category.js";
+export const dagNormalizedFailureCategorySchema = z.enum(DAG_NORMALIZED_FAILURE_CATEGORY_VALUES);
 export const DAG_NORMALIZED_FAILURE_CATEGORIES = dagNormalizedFailureCategorySchema.options;
-const RAW_TO_NORMALIZED = {
-    success: "success",
-    "write-guard": "write-guard",
-    timeout: "timeout",
-    // Clean implementer stall with zero writes — still a timeout class for report,
-    // but retryable under WRITER_TRANSPORT_RETRY_POLICY.
-    "writer-clean-timeout": "timeout",
-    "missing-api-key": "auth",
-    auth: "auth",
-    "human-rejected": "human-rejected",
-    "human-required": "human-required",
-    "decision-envelope-invalid": "decision-envelope",
-    "nonzero-exit": "shell-command",
-    "spawn-error": "shell-command",
-    "test-timeout": "timeout",
-    "static-error": "static-error",
-    "invalid-output": "validation",
-    "structured-output-truncated": "validation",
-    "output-too-large": "validation",
-    "structured-repair-exhausted": "validation",
-    "governance-blocked": "validation",
-    "path-violation": "validation",
-    "empty-output": "validation",
-    "verify-failure": "validation",
-    "test-failure": "validation",
-    "verification-plan-stale": "validation",
-    network: "executor",
-    quota: "executor",
-    "rate-limit": "executor",
-    unavailable: "executor",
-    // Deterministic capability/policy refusal: missing verified launcher JS
-    // entry, capability allowlist rejection, or missing bounded write tool
-    // profile. These are environment/config defects the operator repairs
-    // before rerunning; classify as executor so recovery recommends
-    // rerun-after-fix WITHOUT forcing a human-decision gate on
-    // standaloneTaskRerun (run-failed same-task rerun).
-    "tool-policy": "executor",
-    unknown: "unknown",
-};
-function isFinishedStatus(status) {
-    return status === "FINISHED" || status === "finished";
-}
-function isInProgressStatus(status) {
-    return (status === "PENDING" ||
-        status === "RUNNING" ||
-        status === "pending" ||
-        status === "running");
-}
-function isFailureStatus(status) {
-    return (status === "ERROR" ||
-        status === "failed" ||
-        status === "partial_failed");
-}
-function mapRawCategory(raw) {
-    const direct = RAW_TO_NORMALIZED[raw];
-    if (direct)
-        return direct;
-    const lower = raw.toLowerCase();
-    if (lower.includes("timeout"))
-        return "timeout";
-    if (lower.includes("validation") ||
-        lower.includes("invalid") ||
-        lower.includes("verification-plan-stale") ||
-        lower.includes("plan-stale"))
-        return "validation";
-    if (lower.includes("auth") || lower.includes("api-key"))
-        return "auth";
-    if (lower.includes("write-guard") || lower.includes("write_guard"))
-        return "write-guard";
-    if (lower.includes("decision-envelope") || lower.includes("decision_envelope"))
-        return "decision-envelope";
-    if (lower.includes("human-rejected"))
-        return "human-rejected";
-    if (lower.includes("human-required"))
-        return "human-required";
-    if (lower.includes("static-error"))
-        return "static-error";
-    if (lower.includes("nonzero-exit") ||
-        lower.includes("spawn-error") ||
-        lower.includes("shell"))
-        return "shell-command";
-    return undefined;
-}
-export function isDagFailureCategory(value) {
-    return DAG_NORMALIZED_FAILURE_CATEGORIES.includes(value);
-}
-export function normalizeDagFailureCategory(raw, status) {
-    if (status === "SKIPPED") {
-        return "skipped";
-    }
-    if (raw !== undefined) {
-        const mapped = mapRawCategory(raw);
-        if (mapped) {
-            if (mapped === "success") {
-                return isFinishedStatus(status) ? "success" : "unknown";
-            }
-            return mapped;
-        }
-    }
-    if (raw === undefined && isFinishedStatus(status)) {
-        return "success";
-    }
-    if (isInProgressStatus(status)) {
-        return "unknown";
-    }
-    if (isFailureStatus(status)) {
-        return "unknown";
-    }
-    if (raw === "success" && isFinishedStatus(status)) {
-        return "success";
-    }
-    return "unknown";
-}

package/dist/workflows/dag/frontend-design-policy.js

@@ -26,6 +26,11 @@ export function checkUiDesignCoverage(contract) {
     const findings = [];
     const purposes = new Set((contract.uiComponentChoices ?? []).map((choice) => choice.purpose));
     const hasStyling = Boolean(contract.stylingStrategy?.trim());
+    // Reuse of an existing component/pattern covers behavioural interactions
+    // without forcing one uiComponentChoices row per interaction: the model
+    // should not enumerate every click/hover on a reused Button. Only
+    // interactions with no reuse and no explicit purpose are flagged.
+    const hasReuseChoice = (contract.uiComponentChoices ?? []).some((choice) => choice.decision === "reuse-existing");
     for (const state of contract.uiStates) {
         if (!state.applicable)
             continue;
@@ -39,13 +44,13 @@ export function checkUiDesignCoverage(contract) {
         }
     }
     for (const interaction of contract.interactions) {
-        if (!purposes.has(interaction.name)) {
-            findings.push({
-                code: "ui-design-coverage-missing",
-                message: `interaction "${interaction.name}" has no matching uiComponentChoices.purpose`,
-                path: interaction.name,
-            });
-        }
+        if (purposes.has(interaction.name) || hasReuseChoice)
+            continue;
+        findings.push({
+            code: "ui-design-coverage-missing",
+            message: `interaction "${interaction.name}" has no matching uiComponentChoices.purpose and no reuse-existing choice covering it`,
+            path: interaction.name,
+        });
     }
     return findings;
 }