@tea-agent/loop-agent 0.39.0-beta.5 → 0.39.0-beta.7

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/backend-test-case-coverage-analysis.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { resolveBackendTestManifestModules, backendManifestStatusFinding } from "./backend-test-markdown-workflow.js";
 import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
@@ -659,10 +660,18 @@ async function markdownModuleFiles(workspaceRoot, layout) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
     const dir = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
     const entries = await readdir(dir, { withFileTypes: true });
-    return entries
+    const all = entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md") && entry.name.toLowerCase() !== "readme.md")
         .map((entry) => path.join(dir, entry.name))
         .sort();
+    // Current-round Markdown scope is the README Module Index manifest: unmanifested
+    // legacy .md files must not enter Case/coverage/partition statistics. Workspaces
+    // without a Module Index fall back to the whole directory (prior behaviour).
+    const manifest = await resolveBackendTestManifestModules(workspaceRoot, resolved);
+    if (manifest.manifestStatus !== "valid")
+        return [];
+    const declaredAbs = new Set(manifest.declaredMdFiles.map((rel) => path.join(workspaceRoot, ...rel.split("/")).toLowerCase()));
+    return all.filter((file) => declaredAbs.has(file.toLowerCase())).sort();
 }
 async function parseMarkdownCases(workspaceRoot, layout) {
     const result = [];
@@ -874,6 +883,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
     findings.push(...coverageScope.findings);
     const matrix = parseCoverageMatrix(readme);
     findings.push(...matrix.findings);
+    const manifest = await resolveBackendTestManifestModules(input.workspaceRoot, layout);
+    // Fail closed on README Module Index entries declared but never materialized.
+    if (manifest.declaredMissing.length > 0) {
+        findings.push(`declared Markdown module is missing (Module Index): ${manifest.declaredMissing.join(", ")}`);
+    }
+    // Fail closed on every non-valid Module Index state: without a valid unique
+    // Module Index the current round must not re-scan historical `.md` files.
+    if (manifest.manifestStatus !== "valid") {
+        findings.push(backendManifestStatusFinding(manifest.manifestStatus, manifest.moduleIndexHeadingCount));
+    }
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     for (const file of await markdownModuleFiles(input.workspaceRoot, layout)) {
         const markdown = await readFile(file, "utf8");
@@ -1109,6 +1128,15 @@ export async function analyzeBackendTestCaseCoverage(input) {
         "",
         facts.status,
         "",
+        `- Manifest scope: ${manifest.manifestStatus === "valid" ? "declared-modules" : `fails-closed:${manifest.manifestStatus}`} (declared-missing=${manifest.declaredMissing.length}, unmanifested-advisory=${manifest.unmanifested.length}, module-index-heading-count=${manifest.moduleIndexHeadingCount})`,
+        "",
+        "## Unmanifested Markdown Modules",
+        "",
+        "- Advisory: existing .md files not declared by the README Module Index are excluded from Case/coverage/partition statistics for this round.",
+        ...(manifest.unmanifested.length > 0
+            ? manifest.unmanifested.map((item) => `- ${item}`)
+            : ["- None"]),
+        "",
         "## Coverage Scope",
         "",
         `- Change Classification: ${facts.coverageScope.changeClassification}`,