@tea-agent/loop-agent 0.9.0 → 0.10.0

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

@@ -4,6 +4,9 @@ import path from "node:path";
 import { truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "./events.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
+import { assessDagRunLiveness, assessDagRunRecoveryEligibility, deriveDagRunEffectiveStatus, } from "../../workflows/dag/lifecycle.js";
+import { parseDagSpec, resolveModelForTask, } from "../../workflows/dag/types.js";
+import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
 const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
 export async function buildGlobalSnapshot(options) {
@@ -18,7 +21,7 @@ export async function buildGlobalSnapshot(options) {
             loadLedgerBatches(repoRoot),
             loadStateRecords(repoRoot),
             loadFailureHandoffs(repoRoot),
-            loadDagRuns(repoRoot),
+            loadDagRuns(repoRoot, now()),
         ]);
         const taskMap = new Map();
         for (const state of states) {
@@ -41,7 +44,8 @@ export async function buildGlobalSnapshot(options) {
             ...batch,
             tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
         }));
-        const health = computeHealth(batches, tasks);
+        const health = computeHealth(batches, tasks, dagRuns);
+        const { features, projectionWarnings } = await loadFeatureDecisionModels(repoRoot);
         return {
             schemaVersion: 1,
             generatedAt: now().toISOString(),
@@ -49,12 +53,31 @@ export async function buildGlobalSnapshot(options) {
             batches,
             tasks,
             dagRuns,
+            features,
+            projectionWarnings,
             health,
         };
     }
-    catch {
+    catch (error) {
         const now = options.now ?? (() => new Date());
-        return emptySnapshot(path.resolve(options.repoRoot), now);
+        const safeNow = () => {
+            try {
+                return now();
+            }
+            catch {
+                return new Date();
+            }
+        };
+        let repoRoot;
+        try {
+            repoRoot = path.resolve(options.repoRoot);
+        }
+        catch {
+            repoRoot = String(options.repoRoot ?? "");
+        }
+        const snapshot = emptySnapshot(repoRoot, safeNow);
+        snapshot.projectionError = sanitizeProjectionError(error);
+        return snapshot;
     }
 }
 function emptySnapshot(repoRoot, now) {
@@ -72,6 +95,25 @@ function emptySnapshot(repoRoot, now) {
             staleCount: 0,
             timeoutRiskCount: 0,
             failuresCount: 0,
+            dag: {
+                activeRuns: 0,
+                runningNodes: 0,
+                pendingNodes: 0,
+                pausedRuns: 0,
+                failedRuns: 0,
+                staleRuns: 0,
+                interruptedRuns: 0,
+                inconsistentRuns: 0,
+                attentionRuns: 0,
+            },
+            worker: {
+                activeTasks: 0,
+                activeBatches: 0,
+                quietCount: 0,
+                staleCount: 0,
+                timeoutRiskCount: 0,
+                failuresCount: 0,
+            },
         },
     };
 }
@@ -369,15 +411,168 @@ function summarizeTasks(tasks) {
     }
     return { total: tasks.length, succeeded, failed, reused };
 }
-function computeHealth(batches, tasks) {
-    return {
-        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status)).length,
+function computeHealth(batches, tasks, dagRuns) {
+    const worker = {
         activeTasks: tasks.filter((t) => ACTIVE_TASK_STATUSES.has(t.status)).length,
+        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status)).length,
         quietCount: tasks.filter((t) => t.liveness === "quiet").length,
         staleCount: tasks.filter((t) => t.status === "stale").length,
         timeoutRiskCount: tasks.filter((t) => t.liveness === "timeout-risk").length,
         failuresCount: tasks.filter((t) => t.status === "failed").length,
     };
+    const dag = computeDagHealth(dagRuns);
+    return {
+        // Flat aliases retained for back-compat; mirror worker.* plus activeBatches.
+        activeBatches: worker.activeBatches,
+        activeTasks: worker.activeTasks,
+        quietCount: worker.quietCount,
+        staleCount: worker.staleCount,
+        timeoutRiskCount: worker.timeoutRiskCount,
+        failuresCount: worker.failuresCount,
+        dag,
+        worker,
+    };
+}
+const ACTIVE_EFFECTIVE_STATUSES = new Set([
+    "running",
+    "running-quiet",
+    "remote-unknown",
+    "pending",
+]);
+const TERMINAL_RUN_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+/**
+ * Server-side mirror of app.js isDagRunActive. Derives DAG-run activeness from
+ * already-loaded DagRunSummary facts without touching app.js or new files.
+ */
+function isDagRunActiveForHealth(dag) {
+    if (dag.effectiveStatus && ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
+        return true;
+    }
+    // Only "unknown" (and absent) means liveness evidence is insufficient;
+    // it must NOT override raw lifecycle/status/node facts. Every other concrete
+    // effectiveStatus is authoritative-non-active and short-circuits to false.
+    if (dag.effectiveStatus && dag.effectiveStatus !== "unknown")
+        return false;
+    const status = (dag.status ?? "").toLowerCase();
+    if ((dag.lifecycle ?? "").toLowerCase() === "paused")
+        return false;
+    if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase()))
+        return false;
+    if (TERMINAL_RUN_STATUSES.has(status))
+        return false;
+    if (["running", "pending", "started"].includes(status))
+        return true;
+    return (dag.nodes ?? []).some((node) => isNodeStatusActive(node.status));
+}
+function isNodeStatusActive(status) {
+    const normalized = (status ?? "").toLowerCase();
+    if (["finished", "completed", "succeeded", "done", "error", "failed", "skipped", "partial_failed"].includes(normalized)) {
+        return false;
+    }
+    return true;
+}
+function computeDagHealth(dagRuns) {
+    let activeRuns = 0;
+    let runningNodes = 0;
+    let pendingNodes = 0;
+    let pausedRuns = 0;
+    let failedRuns = 0;
+    let staleRuns = 0;
+    let interruptedRuns = 0;
+    let inconsistentRuns = 0;
+    let attentionRuns = 0;
+    for (const dag of dagRuns) {
+        const active = isDagRunActiveForHealth(dag);
+        if (active) {
+            activeRuns++;
+            for (const node of dag.nodes ?? []) {
+                const status = (node.status ?? "").toLowerCase();
+                if (status === "running" || status === "started")
+                    runningNodes++;
+                if (status === "pending" || status === "queued")
+                    pendingNodes++;
+            }
+        }
+        const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+        const liveness = (dag.liveness ?? "").toLowerCase();
+        if (lifecycle === "paused")
+            pausedRuns++;
+        if (dag.effectiveStatus === "failed")
+            failedRuns++;
+        if (liveness === "stale" || liveness === "orphaned")
+            staleRuns++;
+        if (dag.effectiveStatus === "interrupted")
+            interruptedRuns++;
+        if (dag.stateConsistent === false)
+            inconsistentRuns++;
+        if (lifecycle !== "completed"
+            && (lifecycle === "paused"
+                || liveness === "stale"
+                || liveness === "orphaned"
+                || dag.effectiveStatus === "interrupted"
+                || dag.effectiveStatus === "remote-unknown"
+                || dag.stateConsistent === false)) {
+            attentionRuns++;
+        }
+    }
+    return {
+        activeRuns,
+        runningNodes,
+        pendingNodes,
+        pausedRuns,
+        failedRuns,
+        staleRuns,
+        interruptedRuns,
+        inconsistentRuns,
+        attentionRuns,
+    };
+}
+/**
+ * Whitelist a short safe projection-failure message. Never expose stack frames,
+ * absolute paths, env values, or secrets. Mirrors the bare catch that previously
+ * silently returned a zero-shape snapshot.
+ */
+function sanitizeProjectionError(error) {
+    const fallback = "投影失败 (projection failed)";
+    const at = new Date().toISOString();
+    if (!error || typeof error !== "object") {
+        return { message: fallback, at };
+    }
+    let name;
+    let message;
+    try {
+        name = typeof error.name === "string"
+            ? error.name
+            : undefined;
+        message = typeof error.message === "string"
+            ? error.message
+            : undefined;
+    }
+    catch {
+        return { message: fallback, at };
+    }
+    const candidate = message ?? name;
+    if (!candidate) {
+        return { message: fallback, at };
+    }
+    // Reject anything that looks like a stack frame, an absolute path, or a secret.
+    const raw = String(candidate);
+    if (raw.includes("\n")
+        || /\bat \S+/i.test(raw)
+        || /[A-Za-z]:\\/.test(raw)
+        || raw.includes("/Users/")
+        || raw.includes("/home/")
+        || /SECRET|TOKEN|PASSWORD|API_KEY/i.test(raw)) {
+        return { message: name ? `${name}: 投影失败` : fallback, at };
+    }
+    const trimmed = raw.trim().slice(0, 200);
+    return { message: trimmed || fallback, at };
 }
 function mergeArtifactRefs(existing, incoming) {
     if (!incoming)
@@ -643,11 +838,11 @@ async function loadFailureHandoffs(repoRoot) {
     }
     return handoffs;
 }
-async function loadDagRuns(repoRoot) {
+async function loadDagRuns(repoRoot, now) {
     const byId = new Map();
     const statePaths = await findStateJsonFiles(path.join(repoRoot, ".harness", "dag-runs"));
     for (const statePath of statePaths) {
-        const summary = await parseDagStateFile(statePath);
+        const summary = await parseDagStateFile(statePath, now);
         if (summary)
             byId.set(summary.dagRunId, mergeDagRun(byId.get(summary.dagRunId), summary));
     }
@@ -670,6 +865,11 @@ function mergeDagRun(existing, incoming) {
     return {
         dagRunId: incoming.dagRunId,
         status: incoming.status ?? existing.status,
+        lifecycle: incoming.lifecycle ?? existing.lifecycle,
+        liveness: incoming.liveness ?? existing.liveness,
+        effectiveStatus: incoming.effectiveStatus ?? existing.effectiveStatus,
+        stateConsistent: incoming.stateConsistent ?? existing.stateConsistent,
+        recoveryEligibility: incoming.recoveryEligibility ?? existing.recoveryEligibility,
         title: incoming.title ?? existing.title,
         startedAt,
         finishedAt,
@@ -849,7 +1049,7 @@ async function walkForStateJson(dir, results) {
         // skip
     }
 }
-async function parseDagStateFile(statePath) {
+async function parseDagStateFile(statePath, now) {
     try {
         if (!existsSync(statePath))
             return undefined;
@@ -858,6 +1058,10 @@ async function parseDagStateFile(statePath) {
         if (!parsed)
             return undefined;
         const runDir = path.dirname(statePath);
+        const lifecycleName = path.basename(path.dirname(runDir));
+        const lifecycle = lifecycleName === "active" || lifecycleName === "paused" || lifecycleName === "completed"
+            ? lifecycleName
+            : undefined;
         const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
         const status = readString(parsed, "status");
         const title = readString(parsed, "title");
@@ -866,11 +1070,30 @@ async function parseDagStateFile(statePath) {
         const durationMs = computeDurationMs(startedAt, finishedAt);
         const ranks = readStringMatrix(parsed, "ranks");
         const rankByNode = buildRankIndex(ranks);
-        const nodes = parseDagNodes(parsed, rankByNode);
-        const edges = await parseDagEdges(path.join(runDir, "run.json"), nodes);
+        const runSpecPath = path.join(runDir, "run.json");
+        const modelByNode = await loadDagNodeModels(runSpecPath);
+        const nodes = parseDagNodes(parsed, rankByNode, modelByNode);
+        const edges = await parseDagEdges(runSpecPath, nodes);
+        const state = parsed;
+        const liveness = assessDagRunLiveness({ state, now });
+        const effectiveStatus = lifecycle
+            ? deriveDagRunEffectiveStatus({ lifecycle, state, liveness: liveness.status })
+            : "unknown";
+        const stateConsistent = lifecycle === undefined
+            ? false
+            : !((lifecycle === "paused" && state.status !== "paused")
+                || (lifecycle === "completed" && !["finished", "failed", "partial_failed", "superseded", "abandoned"].includes(state.status)));
+        const recoveryEligibility = lifecycle
+            ? assessDagRunRecoveryEligibility({ lifecycle, state, liveness: liveness.status })
+            : undefined;
         return {
             dagRunId,
             status,
+            ...(lifecycle ? { lifecycle } : {}),
+            liveness: liveness.status,
+            effectiveStatus,
+            stateConsistent,
+            ...(recoveryEligibility ? { recoveryEligibility } : {}),
             ...(title ? { title } : {}),
             ...(startedAt ? { startedAt } : {}),
             ...(finishedAt ? { finishedAt } : {}),
@@ -924,7 +1147,25 @@ function buildRankIndex(ranks) {
     }
     return index;
 }
-function parseDagNodes(parsed, rankByNode) {
+async function loadDagNodeModels(runPath) {
+    const models = new Map();
+    const raw = await safeReadJson(runPath);
+    if (!raw)
+        return models;
+    try {
+        const spec = parseDagSpec(raw);
+        for (const task of spec.tasks) {
+            const model = resolveModelForTask(task, spec.executorModels);
+            if (model)
+                models.set(task.id, model);
+        }
+    }
+    catch {
+        // Historical specs may predate the current schema; state facts remain readable.
+    }
+    return models;
+}
+function parseDagNodes(parsed, rankByNode, modelByNode) {
     const nodes = [];
     const nodesValue = parsed.nodes;
     if (nodesValue && typeof nodesValue === "object" && !Array.isArray(nodesValue)) {
@@ -940,7 +1181,7 @@ function parseDagNodes(parsed, rankByNode) {
                 nodeId: resolvedId,
                 rank: rankByNode.get(nodeId) ?? rankByNode.get(resolvedId),
                 executor: readString(node, "executor"),
-                model: readString(node, "model"),
+                model: readString(node, "model") ?? modelByNode.get(resolvedId),
                 status: nodeStatus,
                 label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
                 durationMs: readNumber(node, "durationMs"),
@@ -962,7 +1203,7 @@ function parseDagNodes(parsed, rankByNode) {
             nodeId,
             rank: rankByNode.get(nodeId),
             executor: readString(node, "executor"),
-            model: readString(node, "model"),
+            model: readString(node, "model") ?? modelByNode.get(nodeId),
             status: nodeStatus,
             label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
             durationMs: readNumber(node, "durationMs"),

package/dist/worker/observe/paths.js

@@ -1,10 +1,7 @@
 import { existsSync, realpathSync } from "node:fs";
 import path from "node:path";
-export function resolveArtifactPath(repoRoot, relative) {
-    if (!relative || path.isAbsolute(relative)) {
-        return null;
-    }
-    if (!isAllowedArtifactRelativePath(relative)) {
+export function resolveArtifactPath(repoRoot, artifactPath) {
+    if (!artifactPath) {
         return null;
     }
     const resolvedRepoRoot = path.resolve(repoRoot);
@@ -15,6 +12,21 @@ export function resolveArtifactPath(repoRoot, relative) {
     catch {
         realRepoRoot = resolvedRepoRoot;
     }
+    let absoluteArtifact = path.resolve(artifactPath);
+    if (path.isAbsolute(artifactPath) && existsSync(absoluteArtifact)) {
+        try {
+            absoluteArtifact = realpathSync(absoluteArtifact);
+        }
+        catch {
+            return null;
+        }
+    }
+    const relative = path.isAbsolute(artifactPath)
+        ? path.relative(realRepoRoot, absoluteArtifact)
+        : artifactPath;
+    if (!relative || path.isAbsolute(relative) || !isAllowedArtifactRelativePath(relative)) {
+        return null;
+    }
     const candidate = path.resolve(realRepoRoot, relative);
     if (!isPathInside(realRepoRoot, candidate)) {
         return null;