@tea-agent/loop-agent 0.12.0 → 0.13.0-alpha.0

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

@@ -4,10 +4,41 @@ import path from "node:path";
 import { truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "./events.js";
 import { readBoundedJsonlTail } from "./event-history.js";
-import { getTaskPoolRoot } from "../pool/run-store.js";
+import { getTaskPoolRoot, listLegacyStateFiles, listTaskPoolStates, } 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";
+/** Internal map key: featureId + NUL + taskId (stable, non-printable delimiter). */
+export function taskIdentityKey(featureId, taskId) {
+    return `${featureId}\0${taskId}`;
+}
+export function compareTaskIdentity(a, b) {
+    const fa = a.featureId ?? "";
+    const fb = b.featureId ?? "";
+    const byFeature = fa.localeCompare(fb);
+    if (byFeature !== 0)
+        return byFeature;
+    return a.taskId.localeCompare(b.taskId);
+}
+export function findTasksByTaskId(tasks, taskId) {
+    return tasks.filter((task) => task.taskId === taskId);
+}
+export function resolveLegacyTask(tasks, taskId) {
+    const matches = findTasksByTaskId(tasks, taskId);
+    const candidates = matches.map((task) => ({
+        featureId: task.featureId,
+        taskId: task.taskId,
+        status: task.status,
+        workerRunId: task.workerRunId,
+    }));
+    if (matches.length === 0) {
+        return { kind: "missing", candidates: [] };
+    }
+    if (matches.length === 1) {
+        return { kind: "unique", task: matches[0], candidates };
+    }
+    return { kind: "ambiguous", candidates };
+}
 export const TASK_RUN_HISTORY_DEFAULT_LIMIT = 20;
 export const TASK_RUN_HISTORY_MAX_LIMIT = 100;
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
@@ -19,7 +50,7 @@ export async function buildGlobalSnapshot(options) {
         const staleThresholdMs = options.staleThresholdMs ?? 90_000;
         const quietThresholdMs = options.quietThresholdMs ?? 60_000;
         const taskPoolPresent = existsSync(getTaskPoolRoot(repoRoot));
-        const [eventsLoad, ledgerLoad, ledgerBatches, states, handoffs, dagRuns] = await Promise.all([
+        const [eventsLoad, ledgerLoad, ledgerBatches, statesLoad, handoffs, dagRuns,] = await Promise.all([
             loadObservabilityEvents(repoRoot),
             loadLedgerRuns(repoRoot),
             loadLedgerBatches(repoRoot),
@@ -29,23 +60,30 @@ export async function buildGlobalSnapshot(options) {
         ]);
         const events = eventsLoad.events;
         const ledgerRuns = ledgerLoad.runs;
+        const identityWarnings = [];
         const taskMap = new Map();
-        for (const state of states) {
-            mergeStateRecord(taskMap, state);
-        }
+        // Ledger first so featureId-bearing rows seed composite identity before states/events.
         for (const run of ledgerRuns) {
-            mergeLedgerRun(taskMap, run);
+            mergeLedgerRun(taskMap, run, identityWarnings);
+        }
+        for (const state of statesLoad.states) {
+            mergeStateRecord(taskMap, state, identityWarnings);
+        }
+        // Attach uniquely-resolvable legacy flat states after owned rows exist.
+        for (const state of statesLoad.legacyCandidates) {
+            mergeLegacyStateRecord(taskMap, state, identityWarnings);
         }
-        mergeEvents(taskMap, events);
+        const workerRunFeatureIndex = buildWorkerRunFeatureIndex(ledgerRuns, taskMap);
+        mergeEvents(taskMap, events, workerRunFeatureIndex, identityWarnings);
         mergeHandoffs(taskMap, handoffs);
         applyStaleDetection(taskMap, now(), staleThresholdMs, quietThresholdMs);
-        const historicalRunMap = buildHistoricalRunMap(ledgerRuns, events);
+        const historicalRunMap = buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex, identityWarnings);
         mergeHandoffs(historicalRunMap, handoffs);
         applyStaleDetection(historicalRunMap, now(), staleThresholdMs, quietThresholdMs);
         const tasks = [...taskMap.values()]
             .map(toPublicTaskSummary)
             .map((task) => normalizeTaskArtifactRefs(task, repoRoot))
-            .sort((a, b) => a.taskId.localeCompare(b.taskId));
+            .sort(compareTaskIdentity);
         const batches = buildBatches(ledgerBatches, events, historicalRunMap).map((batch) => ({
             ...batch,
             tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
@@ -55,6 +93,8 @@ export async function buildGlobalSnapshot(options) {
         const projectionWarnings = [
             ...(eventsLoad.warnings ?? []),
             ...(ledgerLoad.warnings ?? []),
+            ...(statesLoad.warnings ?? []),
+            ...identityWarnings,
             ...(featureLoad.projectionWarnings ?? []),
         ];
         return {
@@ -94,9 +134,10 @@ export async function buildGlobalSnapshot(options) {
 }
 /**
  * Bounded Task run history from Task Pool ledger facts (newest first).
+ * Filtered by composite `{featureId, taskId}`.
  * `before` is an exclusive upper bound on the sort key (`recordedAt` or empty).
  */
-export async function listTaskRunHistory(repoRoot, taskId, options = {}) {
+export async function listTaskRunHistory(repoRoot, featureId, taskId, options = {}) {
     const limit = clampTaskRunHistoryLimit(options.limit);
     const before = decodeTaskRunHistoryCursor(options.before);
     const [ledgerLoad, eventsLoad] = await Promise.all([
@@ -105,15 +146,19 @@ export async function listTaskRunHistory(repoRoot, taskId, options = {}) {
     ]);
     const ledgerRuns = ledgerLoad.runs;
     const events = eventsLoad.events;
-    const historical = buildHistoricalRunMap(ledgerRuns, events);
+    const workerRunFeatureIndex = buildWorkerRunFeatureIndex(ledgerRuns);
+    const historical = buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex);
     const items = [];
     for (const run of ledgerRuns) {
         if (run.taskId !== taskId)
             continue;
+        if ((run.featureId ?? "") !== featureId)
+            continue;
         const enriched = historical.get(run.workerRunId);
         items.push({
             workerRunId: run.workerRunId,
             taskId: run.taskId,
+            featureId: run.featureId ?? featureId,
             status: enriched?.status ?? mapRunRecordStatus(run.status),
             startedAt: enriched?.startedAt,
             finishedAt: enriched?.finishedAt ?? run.recordedAt,
@@ -142,6 +187,7 @@ export async function listTaskRunHistory(repoRoot, taskId, options = {}) {
         ? encodeTaskRunHistoryCursor(page[page.length - 1])
         : null;
     return {
+        featureId,
         taskId,
         runs: page,
         limit,
@@ -226,13 +272,21 @@ function toPublicTaskSummary(task) {
     const { timeoutMs: _to, commandStartedAt: _cs, ...rest } = task;
     return rest;
 }
-function mergeStateRecord(taskMap, state) {
-    const existing = taskMap.get(state.taskId) ?? {
+function mergeStateRecord(taskMap, state, warnings) {
+    const featureId = state.featureId?.trim();
+    if (!featureId) {
+        warnings?.push(`state for task ${state.taskId} missing featureId; excluded from composite projection`);
+        return;
+    }
+    const key = taskIdentityKey(featureId, state.taskId);
+    const existing = taskMap.get(key) ?? {
         taskId: state.taskId,
+        featureId,
         status: "unknown",
     };
-    taskMap.set(state.taskId, {
+    taskMap.set(key, {
         ...existing,
+        featureId,
         status: existing.status !== "unknown"
             ? existing.status
             : mapStateStatus(state.status),
@@ -245,9 +299,35 @@ function mergeStateRecord(taskMap, state) {
         recommendedFollowUp: existing.recommendedFollowUp ?? state.recommendedFollowUp,
     });
 }
-function mergeLedgerRun(taskMap, run) {
-    const existing = taskMap.get(run.taskId) ?? {
+/**
+ * Legacy flat states/<taskId>.json: only merge when the taskId already maps to
+ * exactly one composite row in the snapshot (unique ownership). Otherwise warn+exclude.
+ */
+function mergeLegacyStateRecord(taskMap, state, warnings) {
+    const owners = [...taskMap.values()].filter((task) => task.taskId === state.taskId && Boolean(task.featureId));
+    if (owners.length === 1) {
+        const owner = owners[0];
+        mergeStateRecord(taskMap, { ...state, featureId: owner.featureId }, warnings);
+        warnings.push(`legacy flat state for task ${state.taskId} attached to unique feature ${owner.featureId}`);
+        return;
+    }
+    if (owners.length === 0) {
+        // No owned composite row yet: still surface as a warning and do not invent featureId.
+        warnings.push(`legacy flat state for task ${state.taskId} has no unique feature ownership; excluded from composite projection`);
+        return;
+    }
+    warnings.push(`legacy flat state for task ${state.taskId} is ambiguous across features; excluded from composite projection`);
+}
+function mergeLedgerRun(taskMap, run, warnings) {
+    const featureId = run.featureId?.trim();
+    if (!featureId) {
+        warnings?.push(`ledger run ${run.workerRunId} for task ${run.taskId} missing featureId; excluded from composite projection`);
+        return;
+    }
+    const key = taskIdentityKey(featureId, run.taskId);
+    const existing = taskMap.get(key) ?? {
         taskId: run.taskId,
+        featureId,
         status: "unknown",
     };
     const sameRun = existing.workerRunId === run.workerRunId;
@@ -256,17 +336,17 @@ function mergeLedgerRun(taskMap, run) {
         dagPath: run.dagPath,
         ...run.failureArtifacts,
     };
-    taskMap.set(run.taskId, {
+    taskMap.set(key, {
         ...(sameRun
             ? existing
             : {
                 taskId: run.taskId,
+                featureId,
                 status: "unknown",
-                featureId: existing.featureId,
                 harnessTaskId: existing.harnessTaskId,
             }),
         batchRunId: run.batchRunId,
-        featureId: run.featureId ?? existing.featureId,
+        featureId,
         status: mapRunRecordStatus(run.status),
         workerRunId: run.workerRunId,
         harnessTaskId: run.harnessTaskId ?? existing.harnessTaskId,
@@ -277,21 +357,82 @@ function mergeLedgerRun(taskMap, run) {
         artifactRefs: mergeArtifactRefs(sameRun ? existing.artifactRefs : undefined, runArtifactRefs),
     });
 }
-function mergeEvents(taskMap, events) {
+/**
+ * Build workerRunId → featureId unique index from ledger + already-owned task rows.
+ * Ambiguous (0 or N) mappings are omitted so callers treat them as unowned.
+ */
+function buildWorkerRunFeatureIndex(ledgerRuns, taskMap) {
+    const candidates = new Map();
+    const add = (workerRunId, featureId) => {
+        const wr = workerRunId?.trim();
+        const fid = featureId?.trim();
+        if (!wr || !fid)
+            return;
+        let set = candidates.get(wr);
+        if (!set) {
+            set = new Set();
+            candidates.set(wr, set);
+        }
+        set.add(fid);
+    };
+    for (const run of ledgerRuns) {
+        add(run.workerRunId, run.featureId);
+    }
+    if (taskMap) {
+        for (const task of taskMap.values()) {
+            add(task.workerRunId, task.featureId);
+        }
+    }
+    const unique = new Map();
+    for (const [workerRunId, features] of candidates) {
+        if (features.size === 1) {
+            unique.set(workerRunId, [...features][0]);
+        }
+    }
+    return unique;
+}
+function mergeEvents(taskMap, events, workerRunFeatureIndex, warnings) {
     const sorted = [...events].sort((a, b) => a.at.localeCompare(b.at));
     for (const event of sorted) {
         if (event.taskId) {
-            applyTaskEvent(taskMap, event);
+            applyTaskEvent(taskMap, event, workerRunFeatureIndex, warnings);
         }
     }
 }
-function applyTaskEvent(taskMap, event) {
+function applyTaskEvent(taskMap, event, workerRunFeatureIndex, warnings) {
     const taskId = event.taskId;
-    const existing = taskMap.get(taskId) ?? {
+    const featureId = resolveEventFeatureId(event, taskMap, workerRunFeatureIndex, warnings);
+    if (!featureId)
+        return;
+    const key = taskIdentityKey(featureId, taskId);
+    const existing = taskMap.get(key) ?? {
         taskId,
+        featureId,
         status: "unknown",
     };
-    taskMap.set(taskId, applyEventToSummary(existing, event));
+    taskMap.set(key, applyEventToSummary(existing, event));
+}
+function resolveEventFeatureId(event, taskMap, workerRunFeatureIndex, warnings) {
+    const taskId = event.taskId;
+    if (!taskId)
+        return undefined;
+    if (event.workerRunId) {
+        const fromIndex = workerRunFeatureIndex.get(event.workerRunId);
+        if (fromIndex)
+            return fromIndex;
+        // Fall through: maybe a single existing composite row already owns this workerRunId.
+        const byWorkerRun = [...taskMap.values()].filter((task) => task.workerRunId === event.workerRunId && Boolean(task.featureId));
+        if (byWorkerRun.length === 1)
+            return byWorkerRun[0].featureId;
+    }
+    // Unique taskId ownership in current map (single Feature).
+    const byTaskId = [...taskMap.values()].filter((task) => task.taskId === taskId && Boolean(task.featureId));
+    if (byTaskId.length === 1)
+        return byTaskId[0].featureId;
+    warnings?.push(`unowned event ${event.type} for task ${taskId}` +
+        (event.workerRunId ? ` workerRunId ${event.workerRunId}` : "") +
+        ` cannot uniquely resolve featureId; excluded from task projection`);
+    return undefined;
 }
 function applyEventToSummary(existing, event) {
     const updated = {
@@ -342,9 +483,10 @@ function applyEventToSummary(existing, event) {
     }
     return updated;
 }
-function buildHistoricalRunMap(ledgerRuns, events) {
+function buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex = new Map(), warnings) {
     const runMap = new Map();
     for (const run of ledgerRuns) {
+        // History map is keyed by workerRunId (run-scoped); featureId still required when present.
         runMap.set(run.workerRunId, {
             taskId: run.taskId,
             batchRunId: run.batchRunId,
@@ -365,12 +507,23 @@ function buildHistoricalRunMap(ledgerRuns, events) {
     for (const event of [...events].sort((a, b) => a.at.localeCompare(b.at))) {
         if (!event.workerRunId || !event.taskId)
             continue;
-        const existing = runMap.get(event.workerRunId) ?? {
+        const existing = runMap.get(event.workerRunId);
+        if (existing) {
+            runMap.set(event.workerRunId, applyEventToSummary(existing, event));
+            continue;
+        }
+        // Only invent a historical row when workerRunId uniquely maps to a feature.
+        const featureId = workerRunFeatureIndex.get(event.workerRunId);
+        if (!featureId) {
+            warnings?.push(`unowned historical event ${event.type} for task ${event.taskId} workerRunId ${event.workerRunId} cannot uniquely resolve featureId; excluded from historical run map`);
+            continue;
+        }
+        runMap.set(event.workerRunId, applyEventToSummary({
             taskId: event.taskId,
+            featureId,
             workerRunId: event.workerRunId,
             status: "unknown",
-        };
-        runMap.set(event.workerRunId, applyEventToSummary(existing, event));
+        }, event));
     }
     return runMap;
 }
@@ -512,7 +665,7 @@ function buildBatches(ledgerBatches, events, taskMap) {
         batch.tasks.push(toPublicTaskSummary(task));
     }
     for (const batch of batchMap.values()) {
-        batch.tasks.sort((a, b) => a.taskId.localeCompare(b.taskId));
+        batch.tasks.sort(compareTaskIdentity);
         if (batch.summary === undefined && batch.tasks.length > 0) {
             batch.summary = summarizeTasks(batch.tasks);
         }
@@ -784,6 +937,7 @@ function mapStateStatus(status) {
         case "Running":
             return "running";
         case "Queued":
+        case "Ready":
             return "pending";
         case "Done":
             return "succeeded";
@@ -973,21 +1127,71 @@ async function loadLedgerBatches(repoRoot) {
 }
 async function loadStateRecords(repoRoot) {
     const states = [];
-    const stateDir = path.join(getTaskPoolRoot(repoRoot), "states");
+    const legacyCandidates = [];
+    const warnings = [];
+    // Primary path: v2 nested states via pool list API (read-only import).
     try {
-        const entries = await readdir(stateDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith(".json"))
+        const v2 = await listTaskPoolStates(repoRoot);
+        for (const record of v2) {
+            if (!record.taskId || !record.status)
                 continue;
-            const parsed = await safeReadJson(path.join(stateDir, entry.name));
-            if (!parsed)
+            if (!record.featureId) {
+                warnings.push(`v2 state for task ${record.taskId} missing featureId; excluded from composite projection`);
                 continue;
-            const taskId = readString(parsed, "taskId") ?? entry.name.replace(/\.json$/, "");
+            }
+            states.push({
+                taskId: record.taskId,
+                featureId: record.featureId,
+                status: record.status,
+                workerRunId: record.workerRunId,
+                lastRunRecordPath: record.lastRunRecordPath,
+                updatedAt: record.updatedAt,
+                failureCategory: record.failure?.category,
+                recommendedFollowUp: record.failure?.recommendedFollowUpKind,
+            });
+        }
+    }
+    catch (error) {
+        warnings.push(`failed to load feature-scoped task pool states: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Compatibility: legacy flat states/<taskId>.json (warning + unique-only merge later).
+    try {
+        const legacyFiles = await listLegacyStateFiles(repoRoot);
+        for (const file of legacyFiles) {
+            const parsed = await safeReadJson(file.path);
+            if (!parsed) {
+                warnings.push(`legacy flat state file unreadable or corrupt: ${file.path}`);
+                continue;
+            }
+            const taskId = readString(parsed, "taskId") ?? file.taskId;
             const status = readString(parsed, "status");
-            if (!status)
+            if (!taskId || !status) {
+                warnings.push(`legacy flat state missing taskId/status: ${file.path}`);
                 continue;
+            }
             const failure = readObject(parsed, "failure");
-            states.push({
+            const embeddedFeatureId = readString(parsed, "featureId");
+            if (embeddedFeatureId) {
+                // Rare: flat file already carries featureId — treat as owned state.
+                states.push({
+                    taskId,
+                    featureId: embeddedFeatureId,
+                    status,
+                    workerRunId: readString(parsed, "workerRunId"),
+                    lastRunRecordPath: readString(parsed, "lastRunRecordPath"),
+                    updatedAt: readString(parsed, "updatedAt"),
+                    failureCategory: failure
+                        ? readString(failure, "category")
+                        : undefined,
+                    recommendedFollowUp: failure
+                        ? readString(failure, "recommendedFollowUpKind")
+                        : undefined,
+                    legacyFlat: true,
+                });
+                warnings.push(`legacy flat state for task ${taskId} carries featureId ${embeddedFeatureId}`);
+                continue;
+            }
+            legacyCandidates.push({
                 taskId,
                 status,
                 workerRunId: readString(parsed, "workerRunId"),
@@ -997,13 +1201,14 @@ async function loadStateRecords(repoRoot) {
                 recommendedFollowUp: failure
                     ? readString(failure, "recommendedFollowUpKind")
                     : undefined,
+                legacyFlat: true,
             });
         }
     }
-    catch {
-        // skip
+    catch (error) {
+        warnings.push(`failed to scan legacy flat states: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return states;
+    return { states, legacyCandidates, warnings };
 }
 async function loadFailureHandoffs(repoRoot) {
     const handoffs = [];