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

package/dist/worker/feature/ready-plan-projection.js

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { planReadyTasks, } from "../task-graph/ready-planner.js";
+import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
+import { taskSpecSchema } from "../task-spec/schema.js";
+/** Single Feature-side entry to M1 planReadyTasks; never reimplements ordering. */
+export function projectReadyPlan(input) {
+    return planReadyTasks(input);
+}
+/**
+ * Apply a tighter selectionLimit to an existing planner projection.
+ * Eligible order is preserved from planReadyTasks; this does not re-sort.
+ */
+export function applySelectionLimit(plan, selectionLimit) {
+    if (!Number.isInteger(selectionLimit) || selectionLimit < 1) {
+        throw new Error("selectionLimit must be a positive integer");
+    }
+    const selected = plan.eligible.slice(0, selectionLimit);
+    const deferred = plan.eligible.slice(selectionLimit).map((candidate) => ({
+        ...candidate,
+        reasonCode: "selection-limit",
+        selectedAhead: selected.map((item) => item.taskId),
+    }));
+    return {
+        ...plan,
+        selectionLimit,
+        selected,
+        deferred,
+        summary: {
+            ...plan.summary,
+            selected: selected.length,
+            deferred: deferred.length,
+        },
+    };
+}
+export function selectedTaskIds(plan) {
+    return plan.selected.map((item) => item.taskId);
+}
+export function summarizePlanReasons(plan) {
+    return {
+        selected: plan.selected.map((item) => ({ taskId: item.taskId, priority: item.priority })),
+        deferred: plan.deferred.map((item) => ({
+            taskId: item.taskId,
+            reasonCode: item.reasonCode,
+            selectedAhead: item.selectedAhead,
+        })),
+        blocked: plan.blocked.map((item) => ({
+            taskId: item.taskId,
+            reasonCode: item.reasonCode,
+            reason: item.reason,
+            blockedBy: item.blockedBy,
+        })),
+    };
+}
+export async function loadReadyPlanInputs(featureDir) {
+    const resolved = path.resolve(featureDir);
+    const graphRaw = YAML.parse(await readFile(path.join(resolved, "tasks", "task-graph.yaml"), "utf-8"));
+    const graph = taskGraphSpecSchema.parse(graphRaw);
+    const taskSpecs = new Map();
+    for (const node of graph.nodes) {
+        const value = YAML.parse(await readFile(path.join(resolved, "tasks", node.task), "utf-8"));
+        taskSpecs.set(node.id, taskSpecSchema.parse(value));
+    }
+    return { featureId: graph.feature_id, graph, taskSpecs };
+}
+export async function projectReadyPlanForFeature(input) {
+    try {
+        const loaded = await loadReadyPlanInputs(input.featureDir);
+        return projectReadyPlan({
+            featureId: input.featureId || loaded.featureId,
+            graph: loaded.graph,
+            taskSpecs: loaded.taskSpecs,
+            states: input.states,
+            selectionLimit: input.selectionLimit,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/worker/feature/reducer.js

@@ -10,7 +10,7 @@ const STATUS_LABELS = {
 };
 export function reduceFeature(input) {
     const status = deriveStatus(input);
-    const readyTasks = input.tasks.filter((task) => isReady(task.taskId, input));
+    const readyTasks = input.planning?.eligible ?? input.tasks.filter((task) => isReady(task.taskId, input));
     const blockingItems = [];
     const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
     for (const error of input.validationErrors) {
@@ -88,6 +88,7 @@ export function reduceFeature(input) {
             closeout: input.closeout?.path ?? null,
         },
         projectionWarnings: [...input.projectionWarnings],
+        ...(input.planning ? { planning: input.planning } : {}),
     };
 }
 function deriveStatus(input) {

package/dist/worker/feature/review.js

@@ -3,12 +3,14 @@ import { access, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
-import { getRunsJsonlPath, getTaskPoolRoot, readAllTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
+import { getRunsJsonlPath, getTaskPoolRoot, readFeatureTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
 import { acceptanceSpecSchema } from "../task-graph/acceptance-schema.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
+import { taskSpecSchema } from "../task-spec/schema.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
 import { followUpActionCardSchema, followUpApprovalSchema, followUpDraftSchema, followUpEvidenceSchema } from "../follow-up/schema.js";
 import { readFollowUpIndex, resolveRepoFile, sha256File as sha256FollowUpFile } from "../follow-up/store.js";
+import { projectReadyPlan } from "./ready-plan-projection.js";
 import { reduceFeature } from "./reducer.js";
 export async function reviewFeature(input) {
     const projection = await loadFeatureProjection(input);
@@ -67,7 +69,7 @@ async function loadFeatureProjection(input) {
     let states = {};
     let runs = [];
     try {
-        states = await readAllTaskPoolStates(repoRoot);
+        states = await readFeatureTaskPoolStates(repoRoot, validation.featureId);
         runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     }
     catch (error) {
@@ -86,6 +88,20 @@ async function loadFeatureProjection(input) {
         return valid;
     });
     const graphNodes = graph.success ? graph.data.nodes : [];
+    let planning;
+    if (graph.success) {
+        try {
+            const taskSpecs = new Map();
+            for (const node of graph.data.nodes) {
+                const value = YAML.parse(await readFile(path.join(featureDir, "tasks", node.task), "utf-8"));
+                taskSpecs.set(node.id, taskSpecSchema.parse(value));
+            }
+            planning = projectReadyPlan({ featureId: validation.featureId, graph: graph.data, taskSpecs, states, selectionLimit: Math.max(graph.data.nodes.length, 1) });
+        }
+        catch (error) {
+            projectionWarnings.push(`Ready Planner projection is unavailable: ${message(error)}`);
+        }
+    }
     let pendingFollowUps = [];
     let actionCards = [];
     let resolvedFailureTaskIds = [];
@@ -292,6 +308,7 @@ async function loadFeatureProjection(input) {
         ...((await exists(morningReportPath)) ? { morningReport: morningReportPath } : {}),
         ...((await exists(observeSnapshotPath)) ? { observeSnapshot: observeSnapshotPath } : {}),
         projectionWarnings,
+        ...(planning ? { planning } : {}),
     };
 }
 async function exists(filePath) {

package/dist/worker/feature/run.js

@@ -5,11 +5,12 @@ import { buildGlobalSnapshot } from "../observability/read-model.js";
 import { createSnapshotStore } from "../observability/snapshot-store.js";
 import { preflightTargetRepo } from "../preflight.js";
 import { noopProgressReporter } from "../progress-reporter.js";
-import { getTaskPoolRoot } from "../pool/run-store.js";
+import { getTaskPoolRoot, listLegacyStateFiles } from "../pool/run-store.js";
 import { writeMorningReport } from "../report/morning-report.js";
 import { buildBatchRunId, runReadyTasks } from "../runner/run-ready.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
 import { reviewFeature } from "./review.js";
+import { applySelectionLimit, selectedTaskIds } from "./ready-plan-projection.js";
 import { finalizeGitTask, startGitTransaction } from "../delivery/git-transaction.js";
 export async function runFeature(options) {
     const featureDir = path.resolve(options.featureDir);
@@ -125,7 +126,13 @@ export async function runFeature(options) {
             controllerIdentity });
     }
     before = beforeStep.value;
-    const readyTasks = before.tasks.filter((task) => task.status === "Ready").map((task) => task.taskId);
+    const fullReadyPlan = before.planning;
+    const readyPlan = fullReadyPlan
+        ? applySelectionLimit(fullReadyPlan, limitApplied)
+        : undefined;
+    const readyTasks = readyPlan
+        ? selectedTaskIds(readyPlan)
+        : before.tasks.filter((task) => task.status === "Ready").map((task) => task.taskId);
     if (options.dryRun) {
         steps.push({ ...planned("run-ready", readyTasks.length > 0 ? `execute at most ${limitApplied} Ready task` : "no Ready task"), artifacts: [expectedArtifacts.batchRun] }, { ...planned("morning-report", "refresh morning report"), artifacts: [expectedArtifacts.morningReport] }, { ...planned("observe-snapshot", "refresh Observe snapshot"), artifacts: [expectedArtifacts.observeSnapshot] }, planned("review-after", "derive final Feature review"));
         return {
@@ -138,6 +145,7 @@ export async function runFeature(options) {
             statusAfter: before.status,
             steps,
             readyTasks,
+            ...(readyPlan ? { readyPlan } : {}),
             executedTasks: [],
             artifacts: { batchRun: null, morningReport: null, observeSnapshot: null, ...(checkpointMode ? { gitTransaction: expectedArtifacts.gitTransaction ?? null } : {}) },
             expectedArtifacts,
@@ -151,6 +159,22 @@ export async function runFeature(options) {
         };
     }
     if (readyTasks.length > 0 && limitApplied > 0) {
+        const legacyStates = await listLegacyStateFiles(repoRoot);
+        if (legacyStates.length > 0) {
+            return failedResult({
+                featureId,
+                mode: "executed",
+                steps,
+                limitApplied,
+                code: "task-pool-state-migration-required",
+                message: `cannot execute Ready tasks while legacy Task Pool states require migration: ${legacyStates.map((item) => item.taskId).join(", ")}`,
+                evidence: legacyStates.map((item) => item.path),
+                expectedArtifacts,
+                controllerIdentity,
+                before,
+                readyTasks,
+            });
+        }
         progress.batch(`feature ${featureId}: executing ${Math.min(readyTasks.length, limitApplied)} of ${readyTasks.length} Ready task(s)`);
         const runStep = await timedStep(steps, "run-ready", async () => dependencies.runReady({
             repoRoot,
@@ -226,6 +250,7 @@ export async function runFeature(options) {
         statusAfter: after.value.status,
         steps,
         readyTasks,
+        ...(readyPlan ? { readyPlan } : {}),
         executedTasks: batch?.tasks ?? [],
         artifacts: { batchRun: batch?.batchRunPath ?? null, morningReport: report.value, observeSnapshot: snapshot.value, ...(gitTransaction ? { gitTransaction: gitTransaction.recordPath } : {}) },
         expectedArtifacts,

package/dist/worker/follow-up/approve.js

@@ -99,6 +99,8 @@ async function executeApproval(input) {
         }
         await input.faultInjector?.("before-state-write");
         await writeTaskPoolState(input.repoRoot, {
+            schemaVersion: 2,
+            featureId: input.featureId,
             taskId: loaded.draft.proposed_task_id,
             status: "Ready",
             updatedAt: (input.now ?? new Date()).toISOString(),
@@ -201,7 +203,7 @@ async function loadApprovalInputs(input) {
         entry, draft, draftPath, evidencePath, approvalPath, existingApproval,
         taskSpecPath: path.join(input.featureDir, "tasks", `${draft.proposed_task_id}.yaml`),
         graphPath: path.join(input.featureDir, "tasks", "task-graph.yaml"),
-        statePath: getTaskStatePath(input.repoRoot, draft.proposed_task_id),
+        statePath: getTaskStatePath(input.repoRoot, { featureId: input.featureId, taskId: draft.proposed_task_id }),
         featureId: input.featureId,
         featureDir: input.featureDir,
         repoRoot: input.repoRoot,
@@ -237,8 +239,9 @@ async function assertApprovalPreconditions(loaded) {
     const graph = taskGraphSpecSchema.parse(YAML.parse(await readFile(loaded.graphPath, "utf-8")));
     if (graph.nodes.some((node) => node.id === loaded.draft.proposed_task_id))
         throw new Error(`proposed graph node already exists: ${loaded.draft.proposed_task_id}`);
-    if (await readTaskPoolState(loaded.repoRoot, loaded.draft.proposed_task_id))
+    if (await readTaskPoolState(loaded.repoRoot, { featureId: loaded.featureId, taskId: loaded.draft.proposed_task_id })) {
         throw new Error(`Task Pool state already exists: ${loaded.draft.proposed_task_id}`);
+    }
 }
 function resultFromApproval(approval, repoRoot, approvalPath, idempotent) {
     return {

package/dist/worker/follow-up/factory.js

@@ -99,7 +99,7 @@ export async function draftFollowUpDecision(input, productBugOnly = false) {
                     generated_from: { feature_id: run.featureId, task_id: input.taskId, worker_run_id: input.workerRunId, failure_category: category },
                     action: policy.action,
                     label: policy.label,
-                    ...(policy.recommendedCommand === "task-retry" ? { command: `agent-worker task retry ${JSON.stringify(input.taskId)} --repo ${JSON.stringify(repoRoot)}` } : {}),
+                    ...(policy.recommendedCommand === "task-retry" ? { command: `agent-worker task retry ${JSON.stringify(input.taskId)} --feature-id ${JSON.stringify(run.featureId)} --repo ${JSON.stringify(repoRoot)}` } : {}),
                     evidence_refs: evidenceRefs,
                     dedupe_key: dedupeKey,
                     created_at: (input.now ?? new Date()).toISOString(),

package/dist/worker/observability/event-history.js

@@ -0,0 +1,216 @@
+import { open as openFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { getTaskPoolRoot } from "../pool/run-store.js";
+import { isSafeObservabilityIdentifier } from "./event-store.js";
+import { parseWorkerEventLine } from "./events.js";
+/** History REST page size defaults (distinct from Task run history 20/100 and SSE line offsets). */
+export const EVENT_HISTORY_DEFAULT_LIMIT = 50;
+export const EVENT_HISTORY_MAX_LIMIT = 200;
+/** Hard cap on bytes scanned from the end of a JSONL history file (AC-R4-02). */
+export const EVENT_HISTORY_MAX_SCAN_BYTES = 4 * 1024 * 1024;
+const CURSOR_PREFIX = "v1.";
+export function clampEventHistoryLimit(limit) {
+    if (limit === undefined || limit === null || !Number.isFinite(limit)) {
+        return EVENT_HISTORY_DEFAULT_LIMIT;
+    }
+    const n = Math.trunc(Number(limit));
+    if (!Number.isFinite(n) || n < 1)
+        return EVENT_HISTORY_DEFAULT_LIMIT;
+    if (n > EVENT_HISTORY_MAX_LIMIT)
+        return EVENT_HISTORY_MAX_LIMIT;
+    return n;
+}
+export function encodeEventHistoryCursor(beforeByte) {
+    const payload = Buffer.from(JSON.stringify({ b: Math.max(0, Math.trunc(beforeByte)) }), "utf-8").toString("base64url");
+    return `${CURSOR_PREFIX}${payload}`;
+}
+export function decodeEventHistoryCursor(cursor) {
+    if (cursor === undefined || cursor === null || cursor === "")
+        return null;
+    if (!cursor.startsWith(CURSOR_PREFIX))
+        return null;
+    try {
+        const raw = Buffer.from(cursor.slice(CURSOR_PREFIX.length), "base64url").toString("utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed === null ||
+            typeof parsed !== "object" ||
+            Array.isArray(parsed) ||
+            !("b" in parsed)) {
+            return null;
+        }
+        const b = parsed.b;
+        if (typeof b !== "number" || !Number.isFinite(b) || b < 0)
+            return null;
+        return { beforeByte: Math.trunc(b) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pool global observability events (newest-first page).
+ * History cursor semantics: `cursor` / `nextCursor` are opaque; do not confuse with
+ * SSE/run `after` integer line offsets.
+ */
+export async function listPoolEventHistory(repoRoot, options = {}) {
+    const filePath = path.join(getTaskPoolRoot(path.resolve(repoRoot)), "observability", "events.jsonl");
+    return readEventHistoryFile(filePath, options);
+}
+/**
+ * Batch-scoped observability events under observability/batches/<id>/events.jsonl.
+ */
+export async function listBatchEventHistory(repoRoot, batchRunId, options = {}) {
+    const limit = clampEventHistoryLimit(options.limit);
+    if (!isSafeObservabilityIdentifier(batchRunId)) {
+        return {
+            events: [],
+            limit,
+            source: "missing",
+            ...(options.cursor ? { cursor: options.cursor } : {}),
+        };
+    }
+    const filePath = path.join(getTaskPoolRoot(path.resolve(repoRoot)), "observability", "batches", batchRunId, "events.jsonl");
+    return readEventHistoryFile(filePath, options);
+}
+/**
+ * Bounded tail scan of a JSONL events file. Does not load the entire file into memory
+ * or split unbounded content: reads at most EVENT_HISTORY_MAX_SCAN_BYTES from the end
+ * (or from before the cursor window).
+ */
+export async function readEventHistoryFile(filePath, options = {}) {
+    const limit = clampEventHistoryLimit(options.limit);
+    const inputCursor = typeof options.cursor === "string" && options.cursor.length > 0
+        ? options.cursor
+        : undefined;
+    const decoded = decodeEventHistoryCursor(inputCursor);
+    let fileSize;
+    try {
+        const s = await stat(filePath);
+        if (!s.isFile()) {
+            return emptyPage(limit, inputCursor, "missing");
+        }
+        fileSize = s.size;
+    }
+    catch {
+        return emptyPage(limit, inputCursor, "missing");
+    }
+    if (fileSize === 0) {
+        return emptyPage(limit, inputCursor, "ok");
+    }
+    const beforeByte = decoded !== null ? Math.min(decoded.beforeByte, fileSize) : fileSize;
+    if (beforeByte <= 0) {
+        return emptyPage(limit, inputCursor, "ok");
+    }
+    const scanEnd = beforeByte;
+    const scanStart = Math.max(0, scanEnd - EVENT_HISTORY_MAX_SCAN_BYTES);
+    const truncated = scanStart > 0;
+    const { lines } = await readBoundedJsonlTail(filePath, {
+        beforeByte,
+        maxBytes: EVENT_HISTORY_MAX_SCAN_BYTES,
+    });
+    const parsed = [];
+    let corruptLineCount = 0;
+    for (const line of lines) {
+        if (line.startByte >= beforeByte)
+            continue;
+        const event = parseWorkerEventLine(line.text);
+        if (!event) {
+            corruptLineCount += 1;
+            continue;
+        }
+        parsed.push({ event, startByte: line.startByte });
+    }
+    // Newest first within the scanned window (file order is chronological append).
+    parsed.reverse();
+    const pageItems = parsed.slice(0, limit);
+    const hasMoreInScan = parsed.length > limit;
+    const oldest = pageItems[pageItems.length - 1];
+    const continuationByte = oldest?.startByte ?? lines[0]?.startByte ?? (truncated ? scanStart : undefined);
+    const nextCursor = continuationByte !== undefined && (hasMoreInScan || truncated)
+        ? encodeEventHistoryCursor(continuationByte)
+        : undefined;
+    return {
+        events: pageItems.map((item) => item.event),
+        limit,
+        source: "ok",
+        ...(inputCursor ? { cursor: inputCursor } : {}),
+        ...(nextCursor ? { nextCursor } : {}),
+        ...(truncated ? { truncated: true } : {}),
+        ...(corruptLineCount > 0 ? { corruptLineCount } : {}),
+    };
+}
+function emptyPage(limit, cursor, source) {
+    return {
+        events: [],
+        limit,
+        source,
+        ...(cursor ? { cursor } : {}),
+    };
+}
+export async function readBoundedJsonlTail(filePath, options = {}) {
+    let fileSize;
+    try {
+        const s = await stat(filePath);
+        if (!s.isFile())
+            return { lines: [], truncated: false };
+        fileSize = s.size;
+    }
+    catch {
+        return { lines: [], truncated: false };
+    }
+    const scanEnd = Math.min(options.beforeByte ?? fileSize, fileSize);
+    if (scanEnd <= 0)
+        return { lines: [], truncated: false };
+    const maxBytes = Math.max(1, options.maxBytes ?? EVENT_HISTORY_MAX_SCAN_BYTES);
+    const scanStart = Math.max(0, scanEnd - maxBytes);
+    const buffer = Buffer.alloc(scanEnd - scanStart);
+    const handle = await openFile(filePath, "r");
+    let bytesRead = 0;
+    try {
+        ({ bytesRead } = await handle.read(buffer, 0, buffer.length, scanStart));
+    }
+    finally {
+        await handle.close();
+    }
+    let lines = splitCompleteLines(buffer.subarray(0, bytesRead), scanStart, scanStart > 0, scanEnd < fileSize);
+    const maxLines = options.maxLines;
+    const lineTruncated = maxLines !== undefined && lines.length > maxLines;
+    if (lineTruncated) {
+        lines = lines.slice(-maxLines);
+    }
+    return {
+        lines,
+        truncated: scanStart > 0 || lineTruncated,
+    };
+}
+/**
+ * Split a byte window into complete UTF-8 lines with absolute start offsets.
+ * When truncated from the left, drop the first partial line.
+ */
+function splitCompleteLines(chunk, chunkStartByte, leftTruncated, rightTruncated) {
+    const lines = [];
+    let start = 0;
+    if (leftTruncated) {
+        const firstNl = chunk.indexOf(0x0a);
+        if (firstNl < 0)
+            return [];
+        start = firstNl + 1;
+    }
+    while (start < chunk.length) {
+        const nl = chunk.indexOf(0x0a, start);
+        if (nl < 0 && rightTruncated)
+            break;
+        const end = nl < 0 ? chunk.length : nl;
+        let line = chunk.subarray(start, end);
+        if (line.at(-1) === 0x0d)
+            line = line.subarray(0, line.length - 1);
+        const text = line.toString("utf-8");
+        if (text.trim().length > 0) {
+            lines.push({ text, startByte: chunkStartByte + start });
+        }
+        if (nl < 0)
+            break;
+        start = nl + 1;
+    }
+    return lines;
+}