@tea-agent/loop-agent 0.7.5 → 0.9.0

package/dist/commands/loop-benchmark.js

@@ -37,17 +37,17 @@ export function parseLoopBenchmarkArgs(args) {
     return { json, markdown, outputPath };
 }
 export function printLoopBenchmarkUsage() {
-    console.log(`usage: loop-benchmark [options]
-
-Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
-
-Options:
-  --json              Emit JSON (default when no format flag is set)
-  --markdown          Emit Markdown report
-  --output <path>     Write Markdown report to a repo-relative or absolute path
-  -h, --help          Show this help
-
-Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
+    console.log(`usage: loop-benchmark [options]
+
+Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
+
+Options:
+  --json              Emit JSON (default when no format flag is set)
+  --markdown          Emit Markdown report
+  --output <path>     Write Markdown report to a repo-relative or absolute path
+  -h, --help          Show this help
+
+Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
 Recommendation never changes convergence.enabled default.`);
 }
 export async function runLoopBenchmark(repoRoot, rawArgs) {

package/dist/commands/pi-reuse-benchmark.js

@@ -106,22 +106,22 @@ export function parsePiReuseBenchmarkArgs(args) {
     };
 }
 export function printPiReuseBenchmarkUsage() {
-    console.log(`usage: pi-reuse-benchmark [options]
-
-Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
-
-Options:
-  --report <path>         Benchmark report markdown (approval status)
-  --approval <path>       Explicit approval JSON artifact
-  --off-executor <path>   Baseline executor.jsonl (reuse off)
-  --on-executor <path>    Treatment executor.jsonl (reuse on)
-  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
-  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
-  --json                  Emit JSON (default when no format flag is set)
-  --markdown              Emit Markdown summary
-  -h, --help              Show this help
-
-Recommendations: defer | maintain-opt-in | eligible-for-human-review
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
 Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
 }
 function resolveRepoRelative(repoRoot, filePath) {

package/dist/executors/cursor-executor.js

@@ -29,7 +29,7 @@ export function resolveArtifactWriteDir(options) {
 }
 export function buildArtifactPathPrompt(writeDir) {
     if (!writeDir)
-        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
 ${ARTIFACT_INSTRUCTIONS}`;
     return [
         `After changes, write the following files:`,

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/governance/manifest-types.js

@@ -46,7 +46,7 @@ export const workflowPolicySchema = z
     .object({
     /** Preferred implementation workflow for recoverable loop-agent work. Declarative policy; callers may still require explicit CLI flags. */
     defaultImplementationWorkflow: z
-        .enum(["agent-dag", "level-1"])
+        .enum(["agent-dag"])
         .optional()
         .default("agent-dag"),
     dag: z

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',
@@ -237,35 +237,35 @@ export function shouldInjectSubagentGuidance(step, mode) {
     return false;
 }
 /** Advisory guidance for `analyze-plan` mode. */
-export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-Use it only for read-only tasks:
-- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+Use it only for read-only tasks:
+- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Strong guidance for `full` mode — prescriptive when to delegate. */
-export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-
-You SHOULD delegate to subagent scouts when:
-- The task requires scanning 3+ directories or comparing implementations across modules
-- You would otherwise need 5+ sequential read/grep calls to gather context
-- A reviewer subagent can independently catch scope drift before you finalize your output
-
-Delegation saves context tokens and produces better results.
-
-Allowed patterns:
-- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+
+You SHOULD delegate to subagent scouts when:
+- The task requires scanning 3+ directories or comparing implementations across modules
+- You would otherwise need 5+ sequential read/grep calls to gather context
+- A reviewer subagent can independently catch scope drift before you finalize your output
+
+Delegation saves context tokens and produces better results.
+
+Allowed patterns:
+- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Preserved for backward compatibility (alias of STANDARD). */
 export const SUBAGENT_GUIDANCE = SUBAGENT_GUIDANCE_STANDARD;

package/dist/worker/cli.js

@@ -13,7 +13,7 @@ import { createCompositeProgressReporter } from "./observability/progress-compos
 import { createRoutedWorkerEventStore } from "./observability/event-store.js";
 import { buildGlobalSnapshot } from "./observability/read-model.js";
 import { createObserveServer } from "./observe/server.js";
-import { prepareTaskPoolRetry } from "./pool/run-store.js";
+import { getTaskPoolRoot, prepareTaskPoolRetry } from "./pool/run-store.js";
 import { taskSpecSchema } from "./task-spec/schema.js";
 import { validateTaskSpec } from "./task-spec/validate.js";
 import { validateFeatureTaskGraph } from "./task-graph/validate.js";
@@ -91,7 +91,7 @@ export function buildAgentWorkerProgram() {
         const batchRunId = options.batchRunId ?? buildBatchRunId(new Date());
         const client = new LoopAgentClient({
             loopAgentBin: options.loopAgentBin,
-            artifactRoot: path.join(repoRoot, ".task-pool", "artifacts", batchRunId),
+            artifactRoot: path.join(getTaskPoolRoot(repoRoot), "artifacts", batchRunId),
         });
         let progress;
         try {
@@ -161,7 +161,7 @@ export function buildAgentWorkerProgram() {
         .action(async (options) => {
         const repoRoot = path.resolve(options.repo);
         const outputPath = options.output ??
-            path.join(repoRoot, ".task-pool", "reports", "morning-report.md");
+            path.join(getTaskPoolRoot(repoRoot), "reports", "morning-report.md");
         await writeMorningReport({
             repoRoot,
             ...(options.batchRunId ? { batchRunId: options.batchRunId } : {}),

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/observability/event-store.js

@@ -1,6 +1,7 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import { appendFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
+import { getTaskPoolRoot } from "../pool/run-store.js";
 function writeDiagnostic(context, error) {
     const message = error instanceof Error ? error.message : String(error);
     process.stderr.write(`[worker-event-store] ${context}: ${message}\n`);
@@ -43,7 +44,7 @@ export function createWorkerEventStore(jsonlPath) {
     };
 }
 export function createRoutedWorkerEventStore(repoRoot) {
-    const observabilityRoot = path.join(path.resolve(repoRoot), ".task-pool", "observability");
+    const observabilityRoot = path.join(getTaskPoolRoot(path.resolve(repoRoot)), "observability");
     const globalStore = createWorkerEventStore(path.join(observabilityRoot, "events.jsonl"));
     let queue = Promise.resolve();
     function storesFor(event) {