@tea-agent/loop-agent 0.2.1 → 0.4.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/dag-pi-executor.js

@@ -148,7 +148,14 @@ export function buildDagPiUserMessage(task, persona, step) {
     ].join(" ");
 }
 function resolveDagPiModelConfig(model) {
-    return { provider: DAG_PI_MODEL_PROVIDERS[model] ?? DEFAULT_DAG_PI_PROVIDER, model };
+    const provider = DAG_PI_MODEL_PROVIDERS[model] ?? DEFAULT_DAG_PI_PROVIDER;
+    return {
+        provider,
+        model,
+        ...(provider === "wizard-local" && model === "gpt-5.5"
+            ? { thinking: "low" }
+            : {}),
+    };
 }
 const SUMMARY_STDOUT_MAX = 4_000;
 const SUMMARY_STDERR_MAX = 2_000;

package/dist/task/runtime.js

@@ -236,35 +236,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

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import YAML from "yaml";
+import { LoopAgentClient } from "./loop-agent/loop-agent-client.js";
+import { resolveLoopAgentProfile } from "./profile-mapping.js";
+import { writeMorningReport } from "./report/morning-report.js";
+import { buildBatchRunId, runReadyTasks } from "./runner/run-ready.js";
+import { createProgressReporter } from "./progress-reporter.js";
+import { taskSpecSchema } from "./task-spec/schema.js";
+import { validateTaskSpec } from "./task-spec/validate.js";
+export function buildAgentWorkerProgram() {
+    const program = new Command();
+    program
+        .name("agent-worker")
+        .description("Local product-line worker utilities for TaskSpec validation")
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+    const task = program.command("task").description("TaskSpec utilities");
+    const batch = program.command("batch").description("Task Pool batch utilities");
+    const report = program.command("report").description("Task Pool reporting utilities");
+    task
+        .command("validate")
+        .argument("<task-yaml>", "TaskSpec YAML file")
+        .description("Validate a TaskSpec and print JSON")
+        .action(async (taskYaml) => {
+        const taskSpecPath = path.resolve(taskYaml);
+        const raw = await readTaskYaml(taskSpecPath);
+        const result = await validateTaskSpec(raw, { taskSpecPath });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (!result.ok)
+            process.exitCode = 1;
+    });
+    task
+        .command("explain-profile")
+        .argument("<task-yaml>", "TaskSpec YAML file")
+        .description("Explain business profile to loop-agent profile mapping")
+        .action(async (taskYaml) => {
+        const raw = await readTaskYaml(path.resolve(taskYaml));
+        const parsed = taskSpecSchema.parse(raw);
+        const result = resolveLoopAgentProfile(parsed);
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    });
+    batch
+        .command("run-ready")
+        .requiredOption("--feature-dir <dir>", "Feature directory containing tasks/task-graph.yaml")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--limit <count>", "Maximum ready tasks to run")
+        .option("--loop-agent-bin <bin>", "loop-agent binary", "loop-agent")
+        .option("--batch-run-id <id>", "Batch run id")
+        .option("--check-repo", "Run bash scripts/check-repo.sh during target repo preflight")
+        .option("--check-repo-command <command...>", "Override the check-repo preflight command")
+        .option("--quiet", "Suppress human-readable progress on stderr (JSON still goes to stdout)")
+        .option("--pi-model <model>", "Smoke override: force every pi executor node to this model (drops --strict-models)")
+        .description("Run ready TaskSpec tasks serially")
+        .action(async (options) => {
+        const repoRoot = path.resolve(options.repo);
+        const batchRunId = options.batchRunId ?? buildBatchRunId(new Date());
+        const client = new LoopAgentClient({
+            loopAgentBin: options.loopAgentBin,
+            artifactRoot: path.join(repoRoot, ".task-pool", "artifacts", batchRunId),
+        });
+        const progress = createProgressReporter({ quiet: options.quiet ?? false });
+        const result = await runReadyTasks({
+            repoRoot,
+            featureDir: path.resolve(options.featureDir),
+            ...(options.limit ? { limit: Number.parseInt(options.limit, 10) } : {}),
+            batchRunId,
+            client,
+            runCheckRepo: options.checkRepo ?? false,
+            ...(options.checkRepoCommand
+                ? { checkRepoCommand: options.checkRepoCommand }
+                : {}),
+            progress,
+            ...(options.piModel ? { piModel: options.piModel } : {}),
+        });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (result.status !== "completed")
+            process.exitCode = 1;
+    });
+    report
+        .command("morning")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--batch-run-id <id>", "Filter to one batch run id")
+        .option("--output <path>", "Write markdown report to this path")
+        .description("Render a markdown morning report from Task Pool runs")
+        .action(async (options) => {
+        const repoRoot = path.resolve(options.repo);
+        const outputPath = options.output ??
+            path.join(repoRoot, ".task-pool", "reports", "morning-report.md");
+        await writeMorningReport({
+            repoRoot,
+            ...(options.batchRunId ? { batchRunId: options.batchRunId } : {}),
+            outputPath: path.resolve(outputPath),
+        });
+        process.stdout.write(`${JSON.stringify({ ok: true, outputPath }, null, 2)}\n`);
+    });
+    return program;
+}
+export async function main(argv = process.argv) {
+    await buildAgentWorkerProgram().parseAsync(argv);
+}
+async function readTaskYaml(taskSpecPath) {
+    return YAML.parse(await readFile(taskSpecPath, "utf-8"));
+}
+function isDirectRun() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    return path.resolve(entry) === fileURLToPath(import.meta.url);
+}
+if (isDirectRun()) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/worker/loop-agent/command-result.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import { mkdir, 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 class LoopAgentClient {
+    loopAgentBin;
+    baseArgs;
+    artifactRoot;
+    defaultTimeoutMs;
+    env;
+    constructor(options) {
+        this.loopAgentBin = options.loopAgentBin;
+        this.baseArgs = options.baseArgs ?? [];
+        this.artifactRoot = options.artifactRoot;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? DEFAULT_WORKER_COMMAND_TIMEOUT_MS;
+        this.env = options.env;
+    }
+    async run(args, options) {
+        return this.runCommand(this.loopAgentBin, [...this.baseArgs, ...args], args, options);
+    }
+    async runExternal(command, args, options) {
+        return this.runCommand(command, args, args, options);
+    }
+    async runCommand(command, commandArgs, resultArgs, options) {
+        const startedAt = Date.now();
+        const artifactDir = path.join(this.artifactRoot, sanitizeName(options.artifactName));
+        await mkdir(artifactDir, { recursive: true });
+        const { stdout, stderr, exitCode, timedOut } = await spawnCommand({
+            command,
+            args: commandArgs,
+            cwd: options.cwd,
+            timeoutMs: options.timeoutMs ?? this.defaultTimeoutMs,
+            env: { ...process.env, ...this.env, ...options.env },
+        });
+        const result = {
+            ok: exitCode === 0 && !timedOut,
+            args: resultArgs,
+            command,
+            cwd: options.cwd,
+            durationMs: Date.now() - startedAt,
+            exitCode,
+            stdout,
+            stderr,
+            timedOut,
+            artifacts: {
+                dir: artifactDir,
+                stdoutPath: path.join(artifactDir, "stdout.txt"),
+                stderrPath: path.join(artifactDir, "stderr.txt"),
+                resultPath: path.join(artifactDir, "result.json"),
+            },
+        };
+        if (options.expectJson) {
+            const parsed = parseCommandJson(stdout);
+            if (parsed.ok) {
+                result.json = parsed.value;
+            }
+            else {
+                result.ok = false;
+                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;
+    }
+}
+function spawnCommand(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, input.timeoutMs);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timeout);
+            resolve({ stdout, stderr, exitCode, timedOut });
+        });
+    });
+}
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}

package/dist/worker/loop-agent/parse-json.js

@@ -0,0 +1,14 @@
+export function parseCommandJson(stdout) {
+    try {
+        return { ok: true, value: JSON.parse(stdout) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failure: {
+                code: "json-parse-failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}

package/dist/worker/materialize/harness-task-materializer.js

@@ -0,0 +1,157 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { writeTaskConfig, writeTaskArtifactFile } from "../../infrastructure/harness/task-store.js";
+import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
+import { resolveLoopAgentProfile } from "../profile-mapping.js";
+import { mapRiskLevelToComplexity } from "../task-spec/complexity-mapping.js";
+import { validateTaskSpec } from "../task-spec/validate.js";
+export async function materializeTaskSpec(options) {
+    const now = options.now ?? new Date();
+    const validation = await validateTaskSpec(options.taskSpec, {
+        taskSpecPath: options.taskSpecPath,
+    });
+    if (!validation.ok) {
+        const codes = validation.errors.map((error) => error.code).join(", ");
+        throw new Error(`TaskSpec validation failed: ${codes}`);
+    }
+    const harnessTaskId = buildHarnessTaskId(options.taskSpec, now);
+    const existingConfig = await loadExistingTaskConfig(options.repoRoot, harnessTaskId);
+    if (!existingConfig) {
+        const newTaskResult = await options.client.run(["new-task", harnessTaskId, options.taskSpec.title], {
+            cwd: options.repoRoot,
+            artifactName: `new-task-${harnessTaskId}`,
+        });
+        if (!newTaskResult.ok) {
+            const racedConfig = await loadExistingTaskConfig(options.repoRoot, harnessTaskId);
+            if (!racedConfig) {
+                throw new Error(`loop-agent new-task failed with exit ${newTaskResult.exitCode}: ${newTaskResult.stderr}`);
+            }
+        }
+    }
+    const paths = getTaskPaths(options.repoRoot, harnessTaskId);
+    const baseConfig = await loadTaskConfig(options.repoRoot, harnessTaskId);
+    const taskConfig = {
+        ...baseConfig,
+        taskId: harnessTaskId,
+        title: options.taskSpec.title,
+        allowedPaths: options.taskSpec.constraints.allowed_paths,
+        forbiddenPaths: options.taskSpec.constraints.forbidden_paths,
+        hardConstraints: options.taskSpec.constraints.hard_constraints,
+        complexity: mapRiskLevelToComplexity(options.taskSpec.risk_level),
+        verifyMode: options.taskSpec.verify.mode,
+        verifyPreset: options.taskSpec.verify.preset,
+        verifyQuota: options.taskSpec.verify.quota,
+        autoCommitAfterVerify: false,
+    };
+    await writeTaskConfig(options.repoRoot, harnessTaskId, taskConfig);
+    const sourcePaths = {
+        requirementPath: path.join(paths.sourceDir, "需求.md"),
+        constraintsPath: path.join(paths.sourceDir, "执行约束.md"),
+        taskYamlPath: path.join(paths.sourceDir, "task.yaml"),
+    };
+    await mkdir(paths.sourceDir, { recursive: true });
+    await writeFile(sourcePaths.requirementPath, renderRequirementMarkdown(options.taskSpec), "utf-8");
+    await writeFile(sourcePaths.constraintsPath, renderConstraintsMarkdown(options.taskSpec), "utf-8");
+    await writeFile(sourcePaths.taskYamlPath, YAML.stringify(options.taskSpec), "utf-8");
+    const profileMapping = resolveLoopAgentProfile(options.taskSpec);
+    const manifest = {
+        schemaVersion: 1,
+        businessId: options.taskSpec.id,
+        harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        loopAgentProfile: profileMapping.loopAgentProfile,
+        taskConfigPath: paths.taskConfigPath,
+        source: sourcePaths,
+    };
+    await writeTaskArtifactFile(options.repoRoot, harnessTaskId, "materialize-manifest.json", `${JSON.stringify(manifest, null, 2)}\n`);
+    return manifest;
+}
+export function buildHarnessTaskId(taskSpec, now) {
+    const date = now.toISOString().slice(0, 10);
+    const slug = slugify(`${taskSpec.id}-${taskSpec.title}`);
+    return `${date}-${slug}`;
+}
+function slugify(value) {
+    return value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function renderRequirementMarkdown(taskSpec) {
+    const lines = [
+        `# ${taskSpec.title}`,
+        "",
+        `TaskSpec business id: ${taskSpec.id}`,
+        `Feature id: ${taskSpec.feature_id}`,
+        `Task type: ${taskSpec.type}`,
+        `Risk level: ${taskSpec.risk_level}`,
+        "",
+    ];
+    if (taskSpec.description) {
+        lines.push("## Description", "", taskSpec.description, "");
+    }
+    lines.push("## Goals", "", ...bulletLines(taskSpec.scope.goals), "");
+    if (taskSpec.scope.non_goals.length > 0) {
+        lines.push("## Non Goals", "", ...bulletLines(taskSpec.scope.non_goals), "");
+    }
+    if (taskSpec.scope.assumptions.length > 0) {
+        lines.push("## Assumptions", "", ...bulletLines(taskSpec.scope.assumptions), "");
+    }
+    if (taskSpec.scope.open_questions.length > 0) {
+        lines.push("## Open Questions", "", ...bulletLines(taskSpec.scope.open_questions), "");
+    }
+    lines.push("## Acceptance References", "", ...bulletLines(taskSpec.acceptance_refs), "");
+    lines.push("## Required Outputs", "", ...bulletLines(taskSpec.outputs.required), "");
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function renderConstraintsMarkdown(taskSpec) {
+    const lines = [
+        `# Execution Constraints for ${taskSpec.id}`,
+        "",
+        "## Allowed Paths",
+        "",
+        ...bulletLines(taskSpec.constraints.allowed_paths),
+        "",
+        "## Forbidden Paths",
+        "",
+        ...bulletLines(taskSpec.constraints.forbidden_paths),
+        "",
+        "## Hard Constraints",
+        "",
+        ...bulletLines(taskSpec.constraints.hard_constraints),
+        "",
+        "## Verification Commands",
+        "",
+        ...bulletLines(taskSpec.verify.commands.map((command) => command.command)),
+        "",
+        "## Source Docs",
+        "",
+        ...bulletLines(Object.entries(taskSpec.source_docs).map(([key, value]) => `${key}: ${value}`)),
+    ];
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function bulletLines(values) {
+    if (values.length === 0)
+        return ["- None"];
+    return values.map((value) => `- ${value}`);
+}
+async function loadExistingTaskConfig(repoRoot, taskId) {
+    try {
+        return await loadTaskConfig(repoRoot, taskId);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/worker/pool/failure-routing.js

@@ -0,0 +1,98 @@
+const PRODUCT_CATEGORIES = new Set([
+    "SpecUnclear",
+    "ContractMismatch",
+    "ProductBug",
+    "TestBug",
+    "EnvFailure",
+    "FlakyTest",
+    "RiskyChange",
+    "DependencyFailure",
+    "NeedsHuman",
+    "Unknown",
+]);
+const FOLLOW_UP_BY_CATEGORY = {
+    SpecUnclear: "spec-clarification",
+    ContractMismatch: "architecture-contract-fix",
+    ProductBug: "dev-fix",
+    TestBug: "qa-fix-test",
+    EnvFailure: "env-fix",
+    FlakyTest: "flaky-test-analysis",
+    RiskyChange: "human-review",
+    DependencyFailure: "unblock-dependency",
+    NeedsHuman: "human-review",
+    Unknown: "human-triage",
+};
+const FOLLOW_UP_PREFIX_BY_CATEGORY = {
+    SpecUnclear: "SPEC",
+    ContractMismatch: "CONTRACT",
+    ProductBug: "FIX",
+    TestBug: "QA-FIX",
+    EnvFailure: "ENV",
+    FlakyTest: "FLAKY",
+    RiskyChange: "REVIEW",
+    DependencyFailure: "UNBLOCK",
+    NeedsHuman: "REVIEW",
+    Unknown: "TRIAGE",
+};
+const DAG_TO_PRODUCT_CATEGORY = {
+    validation: "SpecUnclear",
+    executor: "EnvFailure",
+    "write-guard": "RiskyChange",
+    timeout: "EnvFailure",
+    auth: "EnvFailure",
+    "human-required": "NeedsHuman",
+    "human-rejected": "NeedsHuman",
+    "shell-command": "ProductBug",
+    "static-error": "SpecUnclear",
+    "decision-envelope": "NeedsHuman",
+    skipped: "DependencyFailure",
+    unknown: "Unknown",
+};
+export function deriveFailureRoute(result) {
+    if (result.status === "succeeded")
+        return undefined;
+    const primaryFailure = readObject(result.reportDecision.primaryFailure);
+    const category = readProductCategory(primaryFailure, "productLineFailureCategory") ??
+        readProductCategory(primaryFailure, "productLineCategory") ??
+        readProductCategory(primaryFailure, "product_line_failure_category") ??
+        mapDagCategory(readString(primaryFailure, "failureCategory")) ??
+        mapDagCategory(readString(primaryFailure, "normalizedFailureCategory")) ??
+        categoryFromDecisionReason(result.reportDecision.reason);
+    const recommendedFollowUpKind = readString(primaryFailure, "recommendedFollowUpKind") ??
+        readString(primaryFailure, "recommendedFollowUp") ??
+        FOLLOW_UP_BY_CATEGORY[category];
+    return {
+        category,
+        recommendedFollowUpKind,
+        derivedFollowUpTaskId: `${FOLLOW_UP_PREFIX_BY_CATEGORY[category]}-${result.businessId}`,
+        source: primaryFailure ? "report-primary-failure" : "fallback",
+    };
+}
+function readProductCategory(value, key) {
+    const candidate = readString(value, key);
+    return candidate && PRODUCT_CATEGORIES.has(candidate)
+        ? candidate
+        : undefined;
+}
+function mapDagCategory(value) {
+    if (!value || value === "success")
+        return undefined;
+    return DAG_TO_PRODUCT_CATEGORY[value] ?? "Unknown";
+}
+function categoryFromDecisionReason(reason) {
+    if (reason === "report-json-unavailable" || reason === "report-run-missing") {
+        return "Unknown";
+    }
+    return "Unknown";
+}
+function readObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function readString(value, key) {
+    if (!value)
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}