@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

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/init-runtime-activity.js

@@ -0,0 +1,26 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { buildGlobalSnapshot } from "./read-model.js";
+/**
+ * Read-only runtime guard shared by Console maintenance and init-surface
+ * writes. Worker activity remains owned by the Observe projection so both
+ * callers use one canonical liveness interpretation.
+ */
+export async function readInitRuntimeActivity(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const activeDagRoot = path.join(resolvedRoot, ".harness", "dag-runs", "active");
+    const entries = await readdir(activeDagRoot, { withFileTypes: true }).catch(() => []);
+    const activeDagRunIds = entries
+        .filter((entry) => entry.isDirectory() && entry.name !== ".gitkeep")
+        .map((entry) => entry.name)
+        .sort();
+    const snapshot = await buildGlobalSnapshot({ repoRoot: resolvedRoot });
+    return {
+        activeDagRunIds,
+        activeWorkerBatches: snapshot.health.worker.activeBatches,
+        activeWorkerTasks: snapshot.health.worker.activeTasks,
+        ...(snapshot.projectionError
+            ? { workerProjectionError: snapshot.projectionError.message }
+            : {}),
+    };
+}

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/worker/observe/node-input.js

@@ -2,7 +2,8 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { namedShellHandlers } from "./shell-handler-keys.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -30,9 +31,11 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         summary: null,
         dependency: null,
         prompt: null,
+        promptCandidates: [],
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
+        piExtensionRunFacts: null,
         warnings,
     };
 }
@@ -137,7 +140,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -216,6 +219,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
             failFast: typeof shellRaw.failFast === "boolean" ? shellRaw.failFast : null,
             gates: shellGateNames(shellRaw),
+            handlers: namedShellHandlers(shellRaw),
         }
         : null;
     const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"
@@ -264,10 +268,12 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             maxBytes: promptBody.maxBytes,
             source: promptSource,
         },
+        promptCandidates,
         executorInput: {
             kind,
             skills,
             modelHint: resolveModelHint(spec, task),
+            piExtensions: redactStringList(task.piExtensions),
             shell,
             static: staticBlock,
         },
@@ -284,9 +290,155 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
         },
         promptFingerprint: fingerprint,
+        piExtensionRunFacts,
         warnings,
     };
 }
+async function loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings) {
+    const stateResolved = resolveDagRunArtifact(repoRoot, dagRunId, ["state.json"]);
+    if (!stateResolved.ok)
+        return [];
+    let state;
+    try {
+        state = JSON.parse(await readFile(stateResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        warnings.push("state.json could not be read for failed prompt candidates.");
+        return [];
+    }
+    const nodes = state.nodes && typeof state.nodes === "object" && !Array.isArray(state.nodes)
+        ? state.nodes
+        : null;
+    const node = nodes?.[nodeId] &&
+        typeof nodes[nodeId] === "object" &&
+        !Array.isArray(nodes[nodeId])
+        ? nodes[nodeId]
+        : null;
+    if (!node)
+        return [];
+    const failedAttempts = new Set();
+    if (Array.isArray(node.attempts)) {
+        for (const entry of node.attempts) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            if (record.ok === false &&
+                typeof record.attempt === "number" &&
+                Number.isSafeInteger(record.attempt) &&
+                record.attempt > 0) {
+                failedAttempts.add(record.attempt);
+            }
+        }
+    }
+    if (node.status === "ERROR" &&
+        typeof node.currentAttempt === "number" &&
+        Number.isSafeInteger(node.currentAttempt) &&
+        node.currentAttempt > 0) {
+        failedAttempts.add(node.currentAttempt);
+    }
+    const candidates = [];
+    for (const attempt of [...failedAttempts].sort((a, b) => a - b)) {
+        const fileName = `prompt-candidate-attempt-${attempt}.json`;
+        const artifact = path.posix.join(nodeId, fileName);
+        const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, fileName]);
+        if (!resolved.ok) {
+            warnings.push(`Failed prompt candidate missing for attempt ${attempt}.`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+            if (raw.schemaVersion !== 1 ||
+                raw.attempt !== attempt ||
+                typeof raw.failureCategory !== "string" ||
+                typeof raw.prompt !== "string" ||
+                typeof raw.truncated !== "boolean" ||
+                typeof raw.maxBytes !== "number" ||
+                !Number.isSafeInteger(raw.maxBytes) ||
+                raw.maxBytes < 1 ||
+                raw.maxBytes > NODE_INPUT_PREVIEW_MAX_BYTES ||
+                typeof raw.sha256 !== "string" ||
+                !/^([a-f0-9]{64})$/.test(raw.sha256)) {
+                throw new Error("invalid candidate schema");
+            }
+            const prompt = truncatedField(raw.prompt, raw.maxBytes);
+            candidates.push({
+                attempt,
+                failureCategory: redactSecrets(raw.failureCategory),
+                prompt: prompt.text,
+                truncated: raw.truncated || prompt.truncated,
+                maxBytes: raw.maxBytes,
+                sha256Prefix: raw.sha256.slice(0, 12),
+                artifact,
+            });
+        }
+        catch {
+            warnings.push(`Failed prompt candidate is invalid for attempt ${attempt}.`);
+        }
+    }
+    return candidates;
+}
+/**
+ * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
+ * 2026-08-22 R2). Returns null when the node declares no piExtensions
+ * (no expected artifact). Never throws: unreadable/corrupt artifacts degrade
+ * to parseError stubs so the node-input endpoint stays 200.
+ */
+async function loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declared, warnings) {
+    if (declared.length === 0)
+        return null;
+    const artifact = path.posix.join(nodeId, "pi-extensions.json");
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "pi-extensions.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous pi-extensions.json lifecycle copies.");
+        }
+        return {
+            artifact,
+            exists: false,
+            requested: [...declared],
+            resolved: [],
+            missing: [],
+        };
+    }
+    const empty = {
+        artifact,
+        exists: false,
+        requested: [...declared],
+        resolved: [],
+        missing: [],
+    };
+    try {
+        const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+        const resolvedList = Array.isArray(raw.resolved) ? raw.resolved : [];
+        const missingList = Array.isArray(raw.missing) ? raw.missing : [];
+        const projected = resolvedList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            packageName: redactSecrets(String(entry.packageName ?? "")),
+            version: redactSecrets(String(entry.version ?? "")),
+        }));
+        const missingProjected = missingList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            reason: redactSecrets(String(entry.reason ?? "")),
+        }));
+        return {
+            artifact,
+            exists: true,
+            requested: redactStringList(raw.requested ?? declared),
+            resolved: projected,
+            missing: missingProjected,
+        };
+    }
+    catch {
+        return { ...empty, parseError: "read-failed" };
+    }
+}
 async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
     const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
     if (!resolved.ok) {
@@ -415,8 +567,13 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
     }
     const warnings = [];
     const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    const declaredPiExtensions = Array.isArray(task.piExtensions)
+        ? task.piExtensions.filter((item) => typeof item === "string")
+        : [];
+    const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
+    const promptCandidates = await loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {