@tea-agent/loop-agent 0.7.5 → 0.9.0

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

@@ -3,6 +3,7 @@ import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "./events.js";
+import { getTaskPoolRoot } from "../pool/run-store.js";
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
 const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
 export async function buildGlobalSnapshot(options) {
@@ -474,7 +475,7 @@ function mapBatchStatus(status) {
 }
 async function loadObservabilityEvents(repoRoot) {
     const events = [];
-    const obsRoot = path.join(repoRoot, ".task-pool", "observability");
+    const obsRoot = path.join(getTaskPoolRoot(repoRoot), "observability");
     await appendJsonlEvents(path.join(obsRoot, "events.jsonl"), events);
     const batchesDir = path.join(obsRoot, "batches");
     await forEachSubdirJsonl(batchesDir, "events.jsonl", events);
@@ -510,7 +511,7 @@ async function appendJsonlEvents(filePath, events) {
 }
 async function loadLedgerRuns(repoRoot) {
     const runs = [];
-    const raw = await safeReadText(path.join(repoRoot, ".task-pool", "runs", "runs.jsonl"));
+    const raw = await safeReadText(path.join(getTaskPoolRoot(repoRoot), "runs.jsonl"));
     if (!raw)
         return runs;
     for (const line of raw.split("\n")) {
@@ -553,14 +554,15 @@ async function loadLedgerRuns(repoRoot) {
 }
 async function loadLedgerBatches(repoRoot) {
     const batches = [];
-    const runsDir = path.join(repoRoot, ".task-pool", "runs");
+    const artifactsDir = path.join(getTaskPoolRoot(repoRoot), "artifacts");
     try {
-        const entries = await readdir(runsDir, { withFileTypes: true });
+        const entries = await readdir(artifactsDir, { withFileTypes: true });
         for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name === "runs.jsonl")
+            if (!entry.isDirectory())
                 continue;
-            const batchRunId = entry.name.replace(/\.json$/, "");
-            const parsed = await safeReadJson(path.join(runsDir, entry.name));
+            const batchRunId = entry.name;
+            const batchRunPath = path.join(artifactsDir, batchRunId, "batch-run.json");
+            const parsed = await safeReadJson(batchRunPath);
             if (!parsed)
                 continue;
             const summaryObj = readObject(parsed, "summary");
@@ -579,7 +581,7 @@ async function loadLedgerBatches(repoRoot) {
                     }
                     : undefined,
                 tasks: [],
-                batchRunPath: path.join(runsDir, entry.name),
+                batchRunPath,
             });
         }
     }
@@ -590,7 +592,7 @@ async function loadLedgerBatches(repoRoot) {
 }
 async function loadStateRecords(repoRoot) {
     const states = [];
-    const stateDir = path.join(repoRoot, ".task-pool", "state");
+    const stateDir = path.join(getTaskPoolRoot(repoRoot), "states");
     try {
         const entries = await readdir(stateDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -621,7 +623,7 @@ async function loadStateRecords(repoRoot) {
 }
 async function loadFailureHandoffs(repoRoot) {
     const handoffs = [];
-    const handoffDir = path.join(repoRoot, ".task-pool", "failure-handoffs");
+    const handoffDir = path.join(getTaskPoolRoot(repoRoot), "failure-handoffs");
     try {
         const entries = await readdir(handoffDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -736,7 +738,7 @@ function nodeErrorPreview(node, status) {
     return truncateUtf8Preview(stderr);
 }
 async function loadDagEventFiles(repoRoot) {
-    const runsDir = path.join(repoRoot, ".task-pool", "observability", "runs");
+    const runsDir = path.join(getTaskPoolRoot(repoRoot), "observability", "runs");
     let entries;
     try {
         entries = await readdir(runsDir, { withFileTypes: true });

package/dist/worker/observe/paths.js

@@ -33,8 +33,8 @@ export function resolveArtifactPath(repoRoot, relative) {
 function isAllowedArtifactRelativePath(relative) {
     const normalized = path.normalize(relative);
     const segments = normalized.split(path.sep).filter(Boolean);
-    if (segments[0] === ".task-pool") {
-        return ["artifacts", "failure-handoffs", "reports"].includes(segments[1] ?? "");
+    if (segments[0] === ".harness" && segments[1] === "task-pool") {
+        return ["artifacts", "failure-handoffs", "reports"].includes(segments[2] ?? "");
     }
     if (segments[0] === ".harness" && segments[1] === "tasks") {
         return segments.includes("artifacts");

package/dist/worker/observe/routes.js

@@ -1,10 +1,14 @@
 import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { parseWorkerEventLine } from "../observability/events.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
 import { buildGlobalSnapshot } from "../observability/read-model.js";
+import { getTaskPoolRoot } from "../pool/run-store.js";
 import { resolveArtifactPath, toRepoRelativeArtifactPath, } from "./paths.js";
+export function createObserveSnapshotCache() {
+    return { expiresAt: 0 };
+}
 const ROUTES = [
     { method: "GET", pattern: /^\/api\/health$/, handler: handleHealth },
     { method: "GET", pattern: /^\/api\/snapshot$/, handler: handleSnapshot },
@@ -98,16 +102,38 @@ async function handleHealth(_req, res, _match, ctx) {
         generatedAt: new Date().toISOString(),
     });
 }
+async function getSnapshot(ctx) {
+    const now = Date.now();
+    if (ctx.snapshotCache.snapshot && now < ctx.snapshotCache.expiresAt) {
+        return ctx.snapshotCache.snapshot;
+    }
+    if (ctx.snapshotCache.inFlight) {
+        return ctx.snapshotCache.inFlight;
+    }
+    const inFlight = buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    ctx.snapshotCache.inFlight = inFlight;
+    try {
+        const snapshot = await inFlight;
+        ctx.snapshotCache.snapshot = snapshot;
+        ctx.snapshotCache.expiresAt = Date.now() + ctx.pollIntervalMs;
+        return snapshot;
+    }
+    finally {
+        if (ctx.snapshotCache.inFlight === inFlight) {
+            ctx.snapshotCache.inFlight = undefined;
+        }
+    }
+}
 async function handleSnapshot(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot);
 }
 async function handleBatches(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot.batches);
 }
 async function handleBatchById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const batch = snapshot.batches.find((b) => b.batchRunId === match.params.id);
     if (!batch) {
         sendJson(res, 404, { error: "Batch not found" });
@@ -116,11 +142,11 @@ async function handleBatchById(_req, res, match, ctx) {
     sendJson(res, 200, batch);
 }
 async function handleTasks(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot.tasks);
 }
 async function handleTaskById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = snapshot.tasks.find((t) => t.taskId === match.params.id);
     if (!task) {
         sendJson(res, 404, { error: "Task not found" });
@@ -133,7 +159,7 @@ async function handleRunById(_req, res, match, ctx) {
         sendJson(res, 400, { error: "Invalid run identifier" });
         return;
     }
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, match.params.id);
     if (!task) {
         sendJson(res, 404, { error: "Run not found" });
@@ -148,7 +174,7 @@ async function handleRunEvents(_req, res, match, ctx) {
         return;
     }
     const after = parseNonNegativeInt(match.query.get("after"), 0);
-    const eventsPath = path.join(ctx.repoRoot, ".task-pool", "observability", "runs", workerRunId, "events.jsonl");
+    const eventsPath = path.join(getTaskPoolRoot(ctx.repoRoot), "observability", "runs", workerRunId, "events.jsonl");
     const events = (await readJsonlLines(eventsPath, after)).map((event) => normalizeEventArtifactRefs(ctx.repoRoot, event));
     sendJson(res, 200, { events });
 }
@@ -158,7 +184,7 @@ async function handleRunArtifacts(_req, res, match, ctx) {
         sendJson(res, 400, { error: "Invalid run identifier" });
         return;
     }
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, workerRunId);
     const artifacts = [];
     const seen = new Set();
@@ -170,7 +196,7 @@ async function handleRunArtifacts(_req, res, match, ctx) {
             artifacts.push({ path: artifactPath, label });
         }
     }
-    const eventsPath = path.join(ctx.repoRoot, ".task-pool", "observability", "runs", workerRunId, "events.jsonl");
+    const eventsPath = path.join(getTaskPoolRoot(ctx.repoRoot), "observability", "runs", workerRunId, "events.jsonl");
     const runEvents = await readJsonlLines(eventsPath, 0);
     for (const event of runEvents) {
         const parsed = event;
@@ -189,7 +215,7 @@ async function handleRunArtifacts(_req, res, match, ctx) {
     sendJson(res, 200, { artifacts });
 }
 async function handleDagRunById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);
     if (!dagRun) {
         sendJson(res, 404, { error: "DAG run not found" });
@@ -205,7 +231,7 @@ async function handleDagNodeSessionEvents(_req, res, match, ctx) {
         return;
     }
     const after = parseNonNegativeInt(match.query.get("after"), 0);
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === dagRunId);
     const eventsPath = resolveSessionEventsPath(ctx.repoRoot, dagRunId, nodeId, dagRun?.dagPath);
     if (!eventsPath) {
@@ -254,12 +280,32 @@ async function handleEventStream(req, res, match, ctx) {
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
     });
-    const observabilityRoot = path.join(ctx.repoRoot, ".task-pool", "observability");
+    const observabilityRoot = path.join(getTaskPoolRoot(ctx.repoRoot), "observability");
     const eventsPath = path.join(observabilityRoot, "events.jsonl");
     let offset = 0;
+    let knownFileSize;
+    let timer;
+    let closed = false;
     const sendMatchingEvents = async (initial) => {
+        let currentFileSize;
+        try {
+            currentFileSize = (await stat(eventsPath)).size;
+        }
+        catch {
+            knownFileSize = undefined;
+            offset = 0;
+            return;
+        }
+        if (!shouldReadSseEventFile(knownFileSize, currentFileSize))
+            return;
+        if (knownFileSize !== undefined && currentFileSize < knownFileSize) {
+            offset = 0;
+        }
         const page = await readFilteredEvents(eventsPath, offset, batchRunId, ctx.repoRoot);
+        if (!page.ok)
+            return;
         offset = page.nextOffset;
+        knownFileSize = currentFileSize;
         for (const event of page.events) {
             if (initial || !res.writableEnded) {
                 res.write(`data: ${JSON.stringify(event)}\n\n`);
@@ -267,15 +313,25 @@ async function handleEventStream(req, res, match, ctx) {
         }
     };
     await sendMatchingEvents(true);
-    const timer = setInterval(() => {
-        void sendMatchingEvents(false).catch(() => {
-            clearInterval(timer);
-            if (!res.writableEnded)
-                res.end();
-        });
-    }, ctx.pollIntervalMs);
+    const scheduleNextPoll = () => {
+        if (closed)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            void sendMatchingEvents(false)
+                .then(scheduleNextPoll)
+                .catch(() => {
+                closed = true;
+                if (!res.writableEnded)
+                    res.end();
+            });
+        }, ctx.pollIntervalMs);
+    };
+    scheduleNextPoll();
     req.on("close", () => {
-        clearInterval(timer);
+        closed = true;
+        if (timer)
+            clearTimeout(timer);
         if (!res.writableEnded)
             res.end();
     });
@@ -367,12 +423,15 @@ async function readFilteredEvents(filePath, offset, batchRunId, repoRoot) {
                 events.push(normalizeEventArtifactRefs(repoRoot, event));
             }
         }
-        return { events, nextOffset: lines.length };
+        return { events, nextOffset: lines.length, ok: true };
     }
     catch {
-        return { events: [], nextOffset: offset };
+        return { events: [], nextOffset: offset, ok: false };
     }
 }
+export function shouldReadSseEventFile(previousSize, currentSize) {
+    return previousSize !== currentSize;
+}
 function normalizeEventArtifactRefs(repoRoot, value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;

package/dist/worker/observe/server.js

@@ -1,7 +1,7 @@
 import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { handleRequest, serveStatic } from "./routes.js";
+import { createObserveSnapshotCache, handleRequest, serveStatic, } from "./routes.js";
 const STATIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "static");
 export function createObserveServer(options) {
     const repoRoot = path.resolve(options.repoRoot);
@@ -11,6 +11,12 @@ export function createObserveServer(options) {
     }
     const port = options.port ?? 0;
     const pollIntervalMs = options.pollIntervalMs ?? 1000;
+    const routeContext = {
+        repoRoot,
+        pollIntervalMs,
+        staticDir: STATIC_DIR,
+        snapshotCache: createObserveSnapshotCache(),
+    };
     return new Promise((resolve, reject) => {
         const server = createServer((req, res) => {
             void dispatch(req, res).catch((error) => {
@@ -27,11 +33,7 @@ export function createObserveServer(options) {
             });
         });
         async function dispatch(req, res) {
-            const handled = await handleRequest(req, res, {
-                repoRoot,
-                pollIntervalMs,
-                staticDir: STATIC_DIR,
-            });
+            const handled = await handleRequest(req, res, routeContext);
             if (!handled) {
                 await serveStatic(req, res, STATIC_DIR);
             }