@tea-agent/loop-agent 0.8.0 → 0.9.0

package/AGENTS.md

@@ -24,6 +24,8 @@
 - Shell 搜索优先 `rg`，按名找文件优先 `fd`；脚本确为 Bash 脚本时使用 Git Bash 或已配置的兼容 Bash，不要求 Windows 环境适配 POSIX 路径。
 - 用 loop-agent 迭代本仓库时，控制器必须来自已发布的 npm 安装包；首次安装或有意升级可用 `@tea-agent/loop-agent@latest`，但一次自举任务启动后不要中途升级控制器，并记录 `npm list -g @tea-agent/loop-agent --depth=0` 显示的实际版本。不要用当前工作区的 `npm link` 或 `npm run dev` 控制可能改动 CLI、DAG runtime、executor、package metadata 或 build output 的任务。
 - 反复出现的约束要固化为文档、脚本、检查项、测试或模板。
+- 除非用户明确要求，不要自行引入外部 SDD、spec-first、brainstorming 等方法论的强制设计文档、审批门或专用目录；本仓库的工作流程以本文件和 `docs/` 中的治理规则为准。
+- 对非微小的实现或修复，`exec-plan` 只负责记录 Contract、进度和验证证据，不能替代 Agent DAG。除非用户明确要求 one-shot，或在计划中记录了适用的 escape hatch 与理由，否则在改动实现文件前必须完成 `new-task`、结构化 `allowedPaths` / `forbiddenPaths`、`dag run-task` 和 `dag validate`；随后按已校验的 DAG 执行并审查 writer `writeSet`。
 - 禁止占位实现；除非 contract 明确约定为脚手架且标出后续闭环。
 
 ## 开始顺序

package/CHANGELOG.md

@@ -2,9 +2,28 @@
 
 这里记录每个版本对使用者有影响的变化。命令名和配置字段保持原样，其余内容尽量用日常语言说明。
 
-## [Unreleased]
-
-- 暂无未发布内容。
+## [Unreleased]
+
+## [0.9.0] - 2026-07-12
+
+### 修复
+
+- 修复 Observe 总览误把已结束、但仍保留未执行节点的 DAG 显示为“活跃 DAG”的问题。
+- DAG 详情页中的节点输出、错误输出、依赖图和执行过程会在轮询更新时保留当前查看位置，不再把页面拉回默认位置。
+- DAG 和 Worker 运行详情完成首次加载后，会在运行结束时停止自动刷新；页面切到后台时会降低刷新频率，减少不必要的本机资源占用。
+- 新建 Task 默认改为串行执行验证，避免治理检查、类型检查和测试同时抢占本机资源；需要并行时仍可显式配置。
+- `run-dag` 和 `dag run-task --execute` 会拒绝无效的 `--max-concurrent`，避免异常参数导致同一批节点同时启动。
+- Worker batch 的 SSE 事件流在没有新增内容时不再重复读取历史事件，并且会等上一轮完成后再继续轮询。
+- Observe 看板在一个刷新周期内会复用同一份运行快照；同时打开总览、批次、Task 或 DAG 详情时，不会为每个请求重复扫描运行记录。
+- DAG shell 命令和 Worker 调用遇到大量输出时，只在内存中保留最近一段内容并标明截断；完整 stdout/stderr 仍会写入运行产物，避免长日志拖慢本机。
+- 建立 reference index 时会跳过依赖、构建产物、虚拟环境和版本控制目录，并在遍历规模过大时提前停止，减少误扫大型仓库。
+
+### 修改
+
+- Observe 看板改为暖白运行控制台：总览、批次、Task、DAG 和异常页面使用统一的信息层级；DAG 详情中的依赖图和节点表各自完整展示，选择节点后可从右侧检查器查看输出和执行过程。
+- 统一整理运行看板的总览、批次详情、运行详情、DAG 详情和异常 Task 页面：先展示当前状态和风险，再呈现运行记录、输出与产物，桌面端查看信息更集中。
+- 最近 DAG 运行改为按时间排列的状态时间线，标题过长时不会再挤压状态；DAG 详情仍可从每条记录直接进入。
+- 优化节点表格和宽屏布局：节点 ID、模型、状态、耗时和备注更容易扫读；节点输出支持 Markdown 阅读，完成节点在依赖图中以绿色状态提示。
 
 ## [0.8.0] - 2026-07-11
 

package/dist/application/dag/args.js

@@ -7,6 +7,13 @@ const LIFECYCLE_FILTERS = new Set([
     "completed",
     "all",
 ]);
+function parseMaxConcurrent(value) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error("max-concurrent must be a positive integer");
+    }
+    return parsed;
+}
 export function parseDagRunTaskArgs(args, defaultCwd) {
     if (args.length === 0) {
         throw new Error("usage: dag run-task <task-id> [--output <path>] [--profile auto|minimal|standard|reviewed|supervised] [--strict-models] [--no-cursor] [--execute] [--init-only] [--dry-run] [--cwd <dir>] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]]");
@@ -68,7 +75,7 @@ export function parseDagRunTaskArgs(args, defaultCwd) {
             continue;
         }
         if (arg === "--max-concurrent") {
-            maxConcurrent = Number(args[++i]);
+            maxConcurrent = parseMaxConcurrent(args[++i]);
             continue;
         }
         if (arg === "--run-id") {
@@ -276,7 +283,7 @@ export function parseRunDagArgs(args, defaultCwd) {
             dryRun = true;
         }
         else if (arg === "--max-concurrent") {
-            maxConcurrent = Number(args[++i]);
+            maxConcurrent = parseMaxConcurrent(args[++i]);
         }
         else if (arg === "--run-id") {
             runId = args[++i];

package/dist/executors/shell-executor.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-store.js";
 import { truncateOutput } from "./cursor-executor.js";
@@ -11,6 +11,7 @@ const SUMMARY_STDOUT_MAX = 4_000;
 const SUMMARY_STDERR_MAX = 2_000;
 const NODE_STDOUT_MAX = 12_000;
 const NODE_STDERR_MAX = 8_000;
+const MAX_BUFFERED_OUTPUT_BYTES = 64 * 1024;
 function resolveBashExecutable() {
     const envCandidate = process.env.LOOP_AGENT_BASH ?? process.env.GIT_BASH;
     if (envCandidate && existsSync(envCandidate))
@@ -85,8 +86,8 @@ export async function executeShellCommand(input) {
             env: buildShellProcessEnv(input.envAllowlist, injectedEnv),
             stdio: ["ignore", "pipe", "pipe"],
         });
-        let stdout = "";
-        let stderr = "";
+        let stdout = createBoundedOutput();
+        let stderr = createBoundedOutput();
         let timedOut = false;
         let settled = false;
         let timeoutHandle;
@@ -103,22 +104,36 @@ export async function executeShellCommand(input) {
                 command: input.command,
                 cwd: input.cwd,
                 durationMs: Date.now() - startedAt,
-                stdout,
-                stderr,
+                stdout: formatBoundedOutput(stdout),
+                stdoutBytes: stdout.bytes,
+                stdoutTruncated: stdout.truncated,
+                stderr: formatBoundedOutput(stderr),
+                stderrBytes: stderr.bytes,
+                stderrTruncated: stderr.truncated,
+                ...(input.outputArtifacts
+                    ? {
+                        stdoutArtifactPath: input.outputArtifacts.stdoutPath,
+                        stderrArtifactPath: input.outputArtifacts.stderrPath,
+                    }
+                    : {}),
                 timedOut,
                 ...result,
             });
         }
         child.stdout.setEncoding("utf-8");
         child.stderr.setEncoding("utf-8");
+        initializeOutputArtifacts(input.outputArtifacts);
         child.stdout.on("data", (chunk) => {
-            stdout += chunk;
+            stdout = appendBoundedOutput(stdout, chunk);
+            appendOutputArtifact(input.outputArtifacts?.stdoutPath, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk;
+            stderr = appendBoundedOutput(stderr, chunk);
+            appendOutputArtifact(input.outputArtifacts?.stderrPath, chunk);
         });
         child.on("error", (error) => {
-            stderr += stderr ? `\n${error.message}` : error.message;
+            stderr = appendBoundedOutput(stderr, `${stderr.text ? "\n" : ""}${error.message}`);
+            appendOutputArtifact(input.outputArtifacts?.stderrPath, error.message);
             finish({
                 exitCode: null,
                 failureCategory: "spawn-error",
@@ -149,6 +164,46 @@ export async function executeShellCommand(input) {
         }
     });
 }
+function createBoundedOutput() {
+    return { bytes: 0, text: "", truncated: false };
+}
+function appendBoundedOutput(current, chunk) {
+    const bytes = current.bytes + Buffer.byteLength(chunk);
+    const combined = current.text + chunk;
+    if (Buffer.byteLength(combined) <= MAX_BUFFERED_OUTPUT_BYTES) {
+        return { bytes, text: combined, truncated: current.truncated };
+    }
+    const tail = Buffer.from(combined)
+        .subarray(-MAX_BUFFERED_OUTPUT_BYTES)
+        .toString("utf-8")
+        .replace(/^\uFFFD/, "");
+    return { bytes, text: tail, truncated: true };
+}
+function formatBoundedOutput(output) {
+    return output.truncated ? `${output.text}\n...[truncated]` : output.text;
+}
+function initializeOutputArtifacts(paths) {
+    if (!paths)
+        return;
+    try {
+        mkdirSync(path.dirname(paths.stdoutPath), { recursive: true });
+        writeFileSync(paths.stdoutPath, "", "utf-8");
+        writeFileSync(paths.stderrPath, "", "utf-8");
+    }
+    catch {
+        // Artifact persistence is best-effort; the bounded result remains available.
+    }
+}
+function appendOutputArtifact(filePath, chunk) {
+    if (!filePath)
+        return;
+    try {
+        appendFileSync(filePath, chunk, "utf-8");
+    }
+    catch {
+        // Keep command execution independent from a transient artifact write failure.
+    }
+}
 function summarizeCommandResults(results) {
     const stdout = results
         .map((result) => [`$ ${result.command}`, result.stdout.trim()].filter(Boolean).join("\n"))
@@ -195,11 +250,17 @@ export function buildShellResultSummaryMarkdown(input) {
         lines.push("", `## Command ${index + 1}: ${result.command}`, "", "### stdout", "", "```text", stdout.text, "```");
         if (stdout.truncated)
             lines.push("", "_(stdout truncated)_");
+        if (result.stdoutArtifactPath) {
+            lines.push("", `Full stdout artifact: ${result.stdoutArtifactPath}`);
+        }
         if (stderr.text.trim()) {
             lines.push("", "### stderr", "", "```text", stderr.text, "```");
             if (stderr.truncated)
                 lines.push("", "_(stderr truncated)_");
         }
+        if (result.stderrArtifactPath) {
+            lines.push("", `Full stderr artifact: ${result.stderrArtifactPath}`);
+        }
     }
     return `${lines.join("\n")}\n`;
 }
@@ -235,12 +296,17 @@ export async function executeDagShellNode(input, meta) {
         beforeStatus = undefined;
     }
     for (const command of commands) {
+        const commandNumber = results.length + 1;
         const result = await executeShellCommand({
             command,
             cwd,
             timeoutMs,
             envAllowlist: shell.envAllowlist,
             dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+            outputArtifacts: {
+                stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+            },
         });
         results.push(result);
         if (!result.ok)

package/dist/shared/reference-context.js

@@ -7,6 +7,17 @@ import path from 'node:path';
 const DEFAULT_MAX_FILES_PER_REPO = 24;
 const DEFAULT_MAX_TOTAL_FILES = 48;
 const DEFAULT_MAX_FILE_BYTES = 512_000;
+const MAX_REFERENCE_ENTRIES_PER_REPO = 1_024;
+const SKIPPED_REFERENCE_DIRECTORIES = new Set([
+    '.git',
+    '.hg',
+    '.svn',
+    '.venv',
+    'build',
+    'dist',
+    'node_modules',
+    'target',
+]);
 export function isFeatureStudyTask(taskConfig) {
     return taskConfig.taskKind === 'feature-study';
 }
@@ -102,8 +113,8 @@ function uniqueKeepOrder(items) {
     return result;
 }
 async function collectRepoFiles(root, focusGlobs, maxFiles) {
-    const candidates = await listFilesRecursive(root);
-    const matched = candidates
+    const candidates = await listFilesRecursive(root, MAX_REFERENCE_ENTRIES_PER_REPO);
+    const matched = candidates.files
         .map((absolutePath) => ({
         absolutePath,
         relativePath: path.relative(root, absolutePath).replace(/\\/g, '/'),
@@ -111,7 +122,7 @@ async function collectRepoFiles(root, focusGlobs, maxFiles) {
         .filter((entry) => focusGlobs.some((pattern) => matchGlob(pattern, entry.relativePath)))
         .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
     const files = [];
-    let truncated = false;
+    let truncated = candidates.truncated;
     for (const entry of matched) {
         if (files.length >= maxFiles) {
             truncated = true;
@@ -122,10 +133,6 @@ async function collectRepoFiles(root, focusGlobs, maxFiles) {
             continue;
         if (fileStat.size > DEFAULT_MAX_FILE_BYTES)
             continue;
-        const lower = entry.relativePath.toLowerCase();
-        if (lower.includes('/target/') || lower.includes('/node_modules/') || lower.includes('/.git/')) {
-            continue;
-        }
         files.push({
             relativePath: entry.relativePath,
             absolutePath: entry.absolutePath,
@@ -134,21 +141,40 @@ async function collectRepoFiles(root, focusGlobs, maxFiles) {
     }
     return { files, truncated };
 }
-async function listFilesRecursive(dir) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const nested = await Promise.all(entries.map(async (entry) => {
-        const target = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            return listFilesRecursive(target);
-        return [target];
-    }));
-    return nested.flat();
+async function listFilesRecursive(dir, maxEntries) {
+    const files = [];
+    let visited = 0;
+    let truncated = false;
+    const walk = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (visited >= maxEntries) {
+                truncated = true;
+                return;
+            }
+            visited += 1;
+            if (entry.isDirectory() && SKIPPED_REFERENCE_DIRECTORIES.has(entry.name.toLowerCase())) {
+                continue;
+            }
+            const target = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(target);
+                if (truncated)
+                    return;
+            }
+            else {
+                files.push(target);
+            }
+        }
+    };
+    await walk(dir);
+    return { files, truncated };
 }
 export function matchGlob(pattern, relativePath) {
     const normalizedPattern = pattern.replace(/\\/g, '/');

package/dist/task/config-types.js

@@ -76,7 +76,7 @@ export const taskConfigSchema = z.object({
     complexity: taskComplexitySchema.optional().default("medium"),
     /** Explicit delivery capabilities that affect writer contracts/model tier without changing risk. */
     capabilities: z.array(taskCapabilitySchema).optional(),
-    verifyMode: verifyModeSchema.optional().default("parallel"),
+    verifyMode: verifyModeSchema.optional().default("serial"),
     verifyPreset: verifyPresetSchema.optional().default("auto"),
     /** Task-contract commands that must be included in final DAG shell verification. */
     verifyCommands: z.array(taskVerifyCommandSchema).optional().default([]),

package/dist/task/runtime.js

@@ -102,7 +102,7 @@ export async function createTask(repoRoot, taskId, title) {
         complexity: 'medium',
         dagFallbackReason: '',
         contextProfile: 'full',
-        verifyMode: 'parallel',
+        verifyMode: 'serial',
         verifyPreset: 'auto',
         verifyCommands: [],
         verifyQuota: 'full',

package/dist/worker/loop-agent/loop-agent-client.js

@@ -1,10 +1,11 @@
 import { spawn } from "node:child_process";
 import { appendFileSync, writeFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { parseCommandJson } from "./parse-json.js";
 export const DEFAULT_WORKER_COMMAND_TIMEOUT_MS = 120_000;
 export const DEFAULT_HEARTBEAT_INTERVAL_MS = 15_000;
+const MAX_BUFFERED_OUTPUT_BYTES = 64 * 1024;
 export class LoopAgentClient {
     loopAgentBin;
     baseArgs;
@@ -35,7 +36,7 @@ export class LoopAgentClient {
         const stdoutPath = path.join(artifactDir, "stdout.txt");
         const stderrPath = path.join(artifactDir, "stderr.txt");
         const resultPath = path.join(artifactDir, "result.json");
-        const { stdout, stderr, exitCode, timedOut } = await spawnCommand({
+        const { stdout, stdoutBytes, stdoutTruncated, stderr, stderrBytes, stderrTruncated, exitCode, timedOut, } = await spawnCommand({
             command,
             args: commandArgs,
             cwd: options.cwd,
@@ -58,7 +59,11 @@ export class LoopAgentClient {
             durationMs: Date.now() - startedAt,
             exitCode,
             stdout,
+            stdoutBytes,
+            stdoutTruncated,
             stderr,
+            stderrBytes,
+            stderrTruncated,
             timedOut,
             artifacts: {
                 dir: artifactDir,
@@ -68,7 +73,10 @@ export class LoopAgentClient {
             },
         };
         if (options.expectJson) {
-            const parsed = parseCommandJson(stdout);
+            const jsonSource = stdoutTruncated
+                ? await readFullOutputArtifact(stdoutPath, stdout)
+                : stdout;
+            const parsed = parseCommandJson(jsonSource);
             if (parsed.ok) {
                 result.json = parsed.value;
             }
@@ -77,8 +85,6 @@ export class LoopAgentClient {
                 result.parseFailure = parsed.failure;
             }
         }
-        await writeFile(result.artifacts.stdoutPath, stdout, "utf-8");
-        await writeFile(result.artifacts.stderrPath, stderr, "utf-8");
         await writeFile(result.artifacts.resultPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
         return result;
     }
@@ -109,8 +115,8 @@ function spawnCommand(input) {
                 resultPath: input.resultPath,
             },
         });
-        let stdout = "";
-        let stderr = "";
+        let stdout = createBoundedOutput();
+        let stderr = createBoundedOutput();
         let timedOut = false;
         const timeout = setTimeout(() => {
             timedOut = true;
@@ -132,12 +138,12 @@ function spawnCommand(input) {
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
-            stdout += chunk;
+            stdout = appendBoundedOutput(stdout, chunk);
             appendChunkBestEffort(input.stdoutPath, chunk);
             invokeChunkCallback(input.onStdout, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk;
+            stderr = appendBoundedOutput(stderr, chunk);
             appendChunkBestEffort(input.stderrPath, chunk);
             invokeChunkCallback(input.onStderr, chunk);
         });
@@ -147,10 +153,45 @@ function spawnCommand(input) {
         });
         child.on("close", (exitCode) => {
             clearTimers();
-            resolve({ stdout, stderr, exitCode, timedOut });
+            resolve({
+                stdout: formatBoundedOutput(stdout),
+                stdoutBytes: stdout.bytes,
+                stdoutTruncated: stdout.truncated,
+                stderr: formatBoundedOutput(stderr),
+                stderrBytes: stderr.bytes,
+                stderrTruncated: stderr.truncated,
+                exitCode,
+                timedOut,
+            });
         });
     });
 }
+function createBoundedOutput() {
+    return { bytes: 0, text: "", truncated: false };
+}
+function appendBoundedOutput(current, chunk) {
+    const bytes = current.bytes + Buffer.byteLength(chunk);
+    const combined = current.text + chunk;
+    if (Buffer.byteLength(combined) <= MAX_BUFFERED_OUTPUT_BYTES) {
+        return { bytes, text: combined, truncated: current.truncated };
+    }
+    const tail = Buffer.from(combined)
+        .subarray(-MAX_BUFFERED_OUTPUT_BYTES)
+        .toString("utf-8")
+        .replace(/^\uFFFD/, "");
+    return { bytes, text: tail, truncated: true };
+}
+function formatBoundedOutput(output) {
+    return output.truncated ? `${output.text}\n...[truncated]` : output.text;
+}
+async function readFullOutputArtifact(filePath, fallback) {
+    try {
+        return await readFile(filePath, "utf-8");
+    }
+    catch {
+        return fallback;
+    }
+}
 function appendChunkBestEffort(filePath, chunk) {
     try {
         appendFileSync(filePath, chunk, "utf-8");

package/dist/worker/observe/routes.js

@@ -1,11 +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 },
@@ -99,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" });
@@ -117,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" });
@@ -134,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" });
@@ -159,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();
@@ -190,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" });
@@ -206,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) {
@@ -258,9 +283,29 @@ async function handleEventStream(req, res, match, ctx) {
     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`);
@@ -268,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();
     });
@@ -368,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;