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

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

@@ -1,6 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { parseAssistantContent } from "../../chat/assistant-content.js";
-import { buildTurnProcessGroups } from "../../chat/turn-process.js";
+import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { taskContextUnchanged } from "./format.js";
 const EMPTY_USAGE = {
@@ -32,6 +31,8 @@ export function useChatThread(params) {
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [streaming, setStreaming] = useState(false);
+    const [turnPhase, setTurnPhase] = useState("idle");
+    const [deferredTurn, setDeferredTurn] = useState(null);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
@@ -45,6 +46,8 @@ export function useChatThread(params) {
         setHumanGateCards,
         setArtifactCards,
         setStreaming,
+        setTurnPhase,
+        setDeferredTurn,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -121,9 +124,7 @@ export function useChatThread(params) {
         }, 350);
         return () => window.clearTimeout(timer);
     }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
-    const visibleMessages = useMemo(() => messages
-        .filter((m) => m.role !== "system" || showSystemInMessages)
-        .slice(-historyLimit), [messages, showSystemInMessages, historyLimit]);
+    const timelineMessages = useMemo(() => messages.filter((m) => m.role !== "system" || showSystemInMessages), [messages, showSystemInMessages]);
     useEffect(() => {
         const onVisibility = () => {
             if (!document.hidden)
@@ -158,12 +159,30 @@ export function useChatThread(params) {
             statusKind,
         };
     }, [toolCalls]);
-    const turnGroups = useMemo(() => buildTurnProcessGroups({
-        messages: visibleMessages,
+    const turnGroups = useMemo(() => {
+        const all = buildTurnProcessGroups({
+            messages: timelineMessages,
+            toolCalls,
+            streaming,
+            activeAssistantId: streamingAssistantId,
+        });
+        return selectRecentTurnGroups(all, historyLimit);
+    }, [
+        timelineMessages,
         toolCalls,
         streaming,
-        activeAssistantId: streamingAssistantId,
-    }), [visibleMessages, toolCalls, streaming, streamingAssistantId]);
+        streamingAssistantId,
+        historyLimit,
+    ]);
+    const visibleMessages = useMemo(() => {
+        const next = [];
+        for (const group of turnGroups) {
+            if (group.user)
+                next.push(group.user);
+            next.push(...group.assistants);
+        }
+        return next;
+    }, [turnGroups]);
     /** Reset all session-scoped projections before adopting a fresh session. */
     const resetForNewSession = useCallback(() => {
         setMessages([]);
@@ -175,6 +194,8 @@ export function useChatThread(params) {
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
         setStreaming(false);
+        setTurnPhase("idle");
+        setDeferredTurn(null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -192,6 +213,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(next.streaming);
+        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setDeferredTurn(next.deferredTurn ?? null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -213,6 +236,8 @@ export function useChatThread(params) {
             const activeTurnId = body.session.activeTurnId ?? null;
             refs.activeTurnIdRef.current = activeTurnId;
             refs.streamingRef.current = Boolean(activeTurnId);
+            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            setDeferredTurn(body.session.deferredTurn ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -220,18 +245,9 @@ export function useChatThread(params) {
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
-            setMessages((body.session.messages ?? [])
-                .filter((message) => message.role === "user" || message.role === "assistant")
-                .map((message) => {
-                const content = parseAssistantContent(message.content);
-                return {
-                    id: message.id,
-                    role: message.role,
-                    text: message.text,
-                    createdAt: Date.parse(message.at) || Date.now(),
-                    ...(content && content.length > 0 ? { content } : {}),
-                };
-            }));
+            const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            setMessages(hydrated.messages);
+            setToolCalls(hydrated.toolCalls);
             setStreamingAssistantId(null);
             return true;
         }
@@ -240,7 +256,15 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setStreamingAssistantId]);
+    }, [
+        origin,
+        refs,
+        setMessages,
+        setToolCalls,
+        setStreamingAssistantId,
+        setTurnPhase,
+        setDeferredTurn,
+    ]);
     return {
         messages,
         setMessages,
@@ -259,6 +283,10 @@ export function useChatThread(params) {
         usage,
         streaming,
         setStreaming,
+        turnPhase,
+        setTurnPhase,
+        deferredTurn,
+        setDeferredTurn,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,

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/operator-chat/useRepoBrowser.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 /** Left-rail repo tree + file preview tabs state. */
 export function useRepoBrowser(params) {
@@ -9,6 +9,8 @@ export function useRepoBrowser(params) {
     const [previews, setPreviews] = useState([]);
     const [activePreviewPath, setActivePreviewPath] = useState(null);
     const [previewLoading, setPreviewLoading] = useState(false);
+    const expandedDirsRef = useRef(new Set());
+    expandedDirsRef.current = expandedDirs;
     const loadTree = useCallback(async (directory = "") => {
         try {
             setTreeError(null);
@@ -28,6 +30,28 @@ export function useRepoBrowser(params) {
     useEffect(() => {
         void loadTree();
     }, [loadTree]);
+    /** pi-web parity: re-fetch the root + every expanded directory. Bump
+     *  `refreshTick` to trigger; cached entries are NOT reused, so newly
+     *  created/deleted files appear without a manual refresh. */
+    const [refreshTick, setRefreshTick] = useState(0);
+    const refreshTree = useCallback(() => {
+        setRefreshTick((tick) => tick + 1);
+    }, []);
+    useEffect(() => {
+        const dirs = ["", ...expandedDirsRef.current];
+        for (const dir of dirs)
+            void loadTree(dir);
+    }, [loadTree, refreshTick]);
+    // Also refresh when the tab regains focus: external tools (editor, git,
+    // CLI) may have changed the tree while the console was hidden.
+    useEffect(() => {
+        const onVisibility = () => {
+            if (!document.hidden)
+                refreshTree();
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+    }, [refreshTree]);
     const openPreview = useCallback(async (file) => {
         setPreviewLoading(true);
         try {
@@ -116,6 +140,7 @@ export function useRepoBrowser(params) {
         previewLoading,
         setPreviews,
         loadTree,
+        refreshTree,
         openPreview,
         closePreview,
         toggleDir,

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/loop-agent/loop-agent-client.js

@@ -292,9 +292,13 @@ function assertControllerIdentityUnchangedBeforeSpawn(identity) {
     }
 }
 function controllerIdentityDriftError(message, cause) {
-    return new Error(`controller identity changed before spawn: ${message}`, {
-        cause,
-    });
+    // Preserve the raw drift detail verbatim; the actionable suffix serves
+    // every consumer surface — operation errorMessage, SSE events, and agent/
+    // API callers that never reach the UI translation layer — with the exact
+    // recovery step: the running Console holds a stale controller fingerprint
+    // after rebuilds or commits touching fingerprint-scoped paths
+    // (package.json, bin/**, dist/**, skills/**).
+    return new Error(`controller identity changed before spawn: ${message}. Fix: restart the Console process so it re-resolves the current build, then retry the operation; avoid rebuilding or committing fingerprint-scoped files (package.json, bin/**, dist/**, skills/**) mid-session.`, { cause });
 }
 /**
  * Detect whether loopAgentBin is a Node-like executable and baseArgs

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