@tea-agent/loop-agent 0.7.4 → 0.8.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/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/task/runtime.js

@@ -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/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) {

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) {
@@ -645,7 +647,7 @@ async function loadDagRuns(repoRoot) {
     const byId = new Map();
     const statePaths = await findStateJsonFiles(path.join(repoRoot, ".harness", "dag-runs"));
     for (const statePath of statePaths) {
-        const summary = parseDagStateFile(statePath);
+        const summary = await parseDagStateFile(statePath);
         if (summary)
             byId.set(summary.dagRunId, mergeDagRun(byId.get(summary.dagRunId), summary));
     }
@@ -674,6 +676,7 @@ function mergeDagRun(existing, incoming) {
         ...(durationMs !== undefined ? { durationMs } : {}),
         ...(ranks && ranks.length > 0 ? { ranks } : {}),
         nodes: mergeDagNodes(existing.nodes, incoming.nodes),
+        edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
         ...(incoming.dagPath ?? existing.dagPath ? { dagPath: incoming.dagPath ?? existing.dagPath } : {}),
     };
 }
@@ -735,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 });
@@ -819,6 +822,7 @@ async function loadDagEventFiles(repoRoot) {
             ...(finishedAt ? { finishedAt } : {}),
             ...(durationMs !== undefined ? { durationMs } : {}),
             nodes: [...nodeMap.values()].sort((a, b) => a.nodeId.localeCompare(b.nodeId)),
+            edges: [],
         });
     }
     return result;
@@ -845,7 +849,7 @@ async function walkForStateJson(dir, results) {
         // skip
     }
 }
-function parseDagStateFile(statePath) {
+async function parseDagStateFile(statePath) {
     try {
         if (!existsSync(statePath))
             return undefined;
@@ -863,6 +867,7 @@ function parseDagStateFile(statePath) {
         const ranks = readStringMatrix(parsed, "ranks");
         const rankByNode = buildRankIndex(ranks);
         const nodes = parseDagNodes(parsed, rankByNode);
+        const edges = await parseDagEdges(path.join(runDir, "run.json"), nodes);
         return {
             dagRunId,
             status,
@@ -872,6 +877,7 @@ function parseDagStateFile(statePath) {
             ...(durationMs !== undefined ? { durationMs } : {}),
             ...(ranks.length > 0 ? { ranks } : {}),
             nodes,
+            edges,
             dagPath: runDir,
         };
     }
@@ -879,6 +885,30 @@ function parseDagStateFile(statePath) {
         return undefined;
     }
 }
+async function parseDagEdges(runPath, nodes) {
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const tasks = readObjectArray(parsed, "tasks");
+    if (tasks.length === 0)
+        return [];
+    const knownNodeIds = new Set(nodes.map((node) => node.nodeId));
+    const edges = new Map();
+    for (const task of tasks) {
+        const taskId = readString(task, "id") ?? readString(task, "nodeId");
+        if (!taskId || !knownNodeIds.has(taskId))
+            continue;
+        const dependencies = readStringArray(task, "depends_on");
+        const compatibleDependencies = dependencies.length > 0 ? dependencies : readStringArray(task, "dependsOn");
+        for (const dependencyId of compatibleDependencies) {
+            if (dependencyId === taskId || !knownNodeIds.has(dependencyId))
+                continue;
+            const edge = { from: dependencyId, to: taskId };
+            edges.set(`${edge.from}\u0000${edge.to}`, edge);
+        }
+    }
+    return [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
 function buildRankIndex(ranks) {
     const index = new Map();
     for (let i = 0; i < ranks.length; i++) {
@@ -995,6 +1025,14 @@ function readString(value, key) {
     const child = value[key];
     return typeof child === "string" ? child : undefined;
 }
+function readStringArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => typeof item === "string");
+}
 function readNumber(value, key) {
     if (!value || typeof value !== "object")
         return undefined;

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

@@ -4,6 +4,7 @@ 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";
 const ROUTES = [
     { method: "GET", pattern: /^\/api\/health$/, handler: handleHealth },
@@ -148,7 +149,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 });
 }
@@ -170,7 +171,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;
@@ -254,7 +255,7 @@ 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;
     const sendMatchingEvents = async (initial) => {