@tea-agent/loop-agent 0.25.0 → 0.25.2

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [0.25.2] - 2026-07-30
+
+### 重点更新
+
+- 加固后端测试中文 HTML 报告的用例关联与解析逻辑，提升报告的准确性与可读性
+
+### 改进
+
+- 改进基于 class 的 pytest node id 解析，准确提取真实脚本路径，避免显示为 unknown.py
+- 当用例名称缺失后端 ID 时，支持按函数名与 Markdown catalog 进行回退关联
+- 规范化 [REQ]/[RESP] HTTP 日志块，增强日志兼容性
+
+### 修复
+
+- 修复成功执行路径下原生 pytest-html 报告未正确保留的问题，现会将其另存为 backend-test-pytest-native.html
+
+## [0.25.1] - 2026-07-30
+
+### 重点更新
+
+- 后端测试 DAG 节点新增 JaCoCo 覆盖率收集能力，支持在 L-5 dashboard 展示 Java 后端的代码行与分支覆盖率
+- 规范任务 DAG 草稿的默认输出路径，统一指向 `.harness/tasks/<task-id>/dag.json`
+- 修复 loop-agent 技能条目因注入预算超限被截断的问题，确保默认 DAG 下技能完整解析
+
+### 新增
+
+- backend-test DAG 节点 7 支持可选的 JaCoCo 覆盖率收集：通过跨网络 TCP dump JaCoCo tcpserver 数据，经 jacococli.jar 转换并解析为 code-coverage-v1 合约，供 L-5 dashboard 使用
+- task shell 配置新增 `jacocoCoverage` 字段，支持配置 endpoint、cliJarPath、includes 和 connectTimeoutMs
+- 新增面向开发与运维的 JaCoCo 覆盖率部署指南，涵盖 tcpserver agent 挂载、端口放行、cli 预装及安全提醒
+
+### 改进
+
+- `dag run-task` 与 `dag init-hybrid` 的默认输出路径改为 `.harness/tasks/<task-id>/dag.json`，不再写入系统临时目录
+- agent-worker 在 strict validate 成功后，将校验通过的草稿原子同步到 task 根 `dag.json`
+- task read-model、delegate worktree 提示及各文档示例统一指向规范化的任务草稿路径
+- skills 补充 `source-and-plan-practice.md`，明确 `import-prd` 与 `plan create` 的决策表与推荐顺序，不强制微小任务
+
+### 修复
+
+- 压缩 SKILL.md 及 required-reference 体积，修复默认 DAG 技能注入预算超限导致 loop-agent 条目被截断的问题
+
 ## [0.25.0] - 2026-07-30
 
 ### 重点更新
@@ -14,6 +55,7 @@
 
 ### 新增
 
+- backend-test DAG 节点 7 支持可选的 JaCoCo 覆盖率收集（Java 服务）：task shell 配置新增 `jacocoCoverage`（endpoint + cliJarPath + includes + connectTimeoutMs）；节点 7 在 pytest 后跨网络 TCP dump JaCoCo tcpserver 执行数据，用 jacococli.jar 转为 jacoco.xml，确定性解析为 `contracts/code-coverage-v1.json` 并喂给 L-5 dashboard 的 line/branch 指标；全程失败安全（endpoint 不通 / cli 缺失 / 解析失败 → 覆盖率降级 unavailable，不阻断测试与 L-5）
 - 提供 agent-worker Feature Packet 脚手架，内置 backend-only、frontend-only 和 fe-with-api 模板，支持原子批量写入与 validate-feature 预检
 - 新增 agent-worker feature advance 命令，编排 verify-final、delivery 到 closeout 的完整交付路径
 - 新增 agent-worker feature doctor 命令，提供只读的交付就绪诊断（覆盖证据、Pool 状态与工作区改动）

package/README.md

@@ -64,19 +64,19 @@ loop-agent new-task example-task "实现一个有明确验收标准的小功能"
 loop-agent dag run-task example-task \
   --profile auto \
   --strict-models \
-  --output <temp-dir>/example-task-dag.json
+  --output .harness/tasks/example-task/dag.json
 
 loop-agent dag validate \
-  --dag <temp-dir>/example-task-dag.json \
+  --dag .harness/tasks/example-task/dag.json \
   --strict-models \
   --strict-governance
 
 loop-agent run-dag \
-  --dag <temp-dir>/example-task-dag.json \
+  --dag .harness/tasks/example-task/dag.json \
   --cwd .
 ```
 
-`<temp-dir>` 应使用当前平台的原生临时目录。详细步骤见[第一次运行](website/docs/quick-start/first-run.md)和 [Agent DAG 工作流](website/docs/guides/agent-dag.md)。
+省略 `--output` 时默认写入 `.harness/tasks/<task-id>/dag.json`。详细步骤见[第一次运行](website/docs/quick-start/first-run.md)和 [Agent DAG 工作流](website/docs/guides/agent-dag.md)。
 
 ## 查看执行状态
 

package/dist/application/dag/generate-task-dag.js

@@ -7,10 +7,10 @@ import { parseDagSpec } from "../../workflows/dag/types.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { assertExecPlanIndexConsistent } from "../../governance/exec-plans.js";
-import { defaultHybridDagOutputPath, initHybridDagFromTask, } from "../../workflows/dag/init-hybrid.js";
+import { initHybridDagFromTask, } from "../../workflows/dag/init-hybrid.js";
 import { validateDagUseCase } from "./validate-dag.js";
 import { runDagUseCase } from "./run-dag.js";
-import { loadTaskConfig } from "../../task/runtime.js";
+import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { writeTaskConfig } from "../../infrastructure/harness/task-store.js";
 const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
 function buildValidateInput(repoRoot, dagPath, parsed) {
@@ -41,7 +41,15 @@ function isUnsafeWriteSetEntry(entry) {
     return normalized.includes(PLACEHOLDER_WRITESET_MARKER);
 }
 export async function assertSafeForExecution(dagPath) {
-    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    let raw;
+    try {
+        const content = await readFile(dagPath, "utf-8");
+        raw = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to read valid DAG JSON at ${dagPath}: ${message}`);
+    }
     const unsafe = [];
     for (const task of raw.tasks ?? []) {
         if (task.writePolicy !== "exclusive")
@@ -126,7 +134,16 @@ function resolveReviewPacketShellCommands(task) {
     return resolveShellCommands(task.shell);
 }
 async function buildReviewPacket(input) {
-    const spec = parseDagSpec(JSON.parse(await readFile(input.dagPath, "utf-8")));
+    let raw;
+    try {
+        const content = await readFile(input.dagPath, "utf-8");
+        raw = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to read valid DAG JSON at ${input.dagPath}: ${message}`);
+    }
+    const spec = parseDagSpec(raw);
     const writers = collectWriterTasksForPacket(spec).map((task) => {
         const writeSet = task.writeSet ?? [];
         return {
@@ -247,8 +264,7 @@ export async function generateTaskDagUseCase(input) {
             : "task-source";
         profileRouting.routingReasons = candidateResult.templateSelection.reasons;
         if (parsed.profile === "auto") {
-            profileRouting.selectedByProfile =
-                resolveAutoRoutingProfile(profileRouting.candidateProfile);
+            profileRouting.selectedByProfile = resolveAutoRoutingProfile(profileRouting.candidateProfile);
         }
         else if (parsed.profileExplicit) {
             profileRouting.selectedByProfile = parsed.profile;
@@ -256,7 +272,8 @@ export async function generateTaskDagUseCase(input) {
     }
     // Persist the automatic business workflow route while preserving the
     // governance profile as a separate routing dimension.
-    if (hasAutomaticTaskSourceRoute && candidateResult.template === "frontend-implementation") {
+    if (hasAutomaticTaskSourceRoute &&
+        candidateResult.template === "frontend-implementation") {
         const taskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
         if (!taskConfig.taskKind || taskConfig.taskKind === "standard") {
             await writeTaskConfig(repoRoot, parsed.taskId, {
@@ -297,7 +314,7 @@ export async function generateTaskDagUseCase(input) {
             ok: true,
             taskId: initResult.taskId,
             outputPath,
-            defaultOutputPath: defaultHybridDagOutputPath(parsed.taskId),
+            defaultOutputPath: getTaskPaths(repoRoot, parsed.taskId).dagDraftPath,
             taskCount: initResult.taskCount,
             nodeIds: initResult.nodeIds,
             title: validateSummary.title,

package/dist/commands/dag-init-hybrid.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { defaultHybridDagOutputPath, initHybridDagFromTask, } from "../workflows/dag/init-hybrid.js";
+import { initHybridDagFromTask } from "../workflows/dag/init-hybrid.js";
+import { getTaskPaths } from "../task/runtime.js";
 export function parseDagInitHybridArgs(args) {
     if (args.length === 0) {
         throw new Error("usage: dag init-hybrid <task-id> [--output <path>]");
@@ -44,7 +45,7 @@ export async function runDagInitHybrid(repoRoot, rawArgs) {
         ok: true,
         taskId: result.taskId,
         outputPath: result.outputPath,
-        defaultOutputPath: defaultHybridDagOutputPath(parsed.taskId),
+        defaultOutputPath: getTaskPaths(repoRoot, parsed.taskId).dagDraftPath,
         taskCount: result.taskCount,
         nodeIds: result.nodeIds,
         next: [

package/dist/commands/delegate.js

@@ -1,10 +1,9 @@
-import os from "node:os";
-import path from "node:path";
 import { delegateTask } from "../task/delegate.js";
 import { loadHarnessManifest } from "../governance/harness.js";
 import { generateTaskDagUseCase } from "../application/dag/generate-task-dag.js";
 import { validateDagUseCase } from "../application/dag/validate-dag.js";
 import { runDagUseCase } from "../application/dag/run-dag.js";
+import { getTaskPaths } from "../task/runtime.js";
 const DELEGATE_USAGE = "usage: delegate <taskId> [--base <branch>] [--branch <name>] [--no-symlink] [--auto-run]";
 export function parseDelegateArgs(args) {
     if (args.length === 0) {
@@ -59,12 +58,13 @@ export function parseDelegateArgs(args) {
     return { taskId, base, branch, symlinkNodeModules, autoRun };
 }
 export function printDelegateNextSteps(taskId, result) {
-    const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
+    const dagPath = getTaskPaths(result.worktreePath, taskId).dagDraftPath;
     const lines = [
         `[delegate] worktree ready (Pi-only).`,
         `  worktree: ${result.worktreePath}`,
         `  Next — generate, validate, and run DAG in the worktree:`,
-        `    loop-agent dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`,
+        `    cd ${JSON.stringify(result.worktreePath)}`,
+        `    loop-agent --repo-root ${JSON.stringify(result.worktreePath)} dag run-task ${taskId} --profile auto --strict-models`,
         `    loop-agent dag validate --dag ${JSON.stringify(dagPath)} --strict-models --strict-governance`,
         `    loop-agent run-dag --dag ${JSON.stringify(dagPath)} --cwd ${JSON.stringify(result.worktreePath)}`,
         `  Or: loop-agent delegate ${taskId} --auto-run`,
@@ -89,30 +89,30 @@ export async function runDelegate(repoRoot, rawArgs, dependencies = DEFAULT_RUN_
         symlinkNodeModules: parsed.symlinkNodeModules,
     });
     if (parsed.autoRun) {
-        const dagPath = path.join(os.tmpdir(), `${parsed.taskId}-delegate-dag.json`);
+        const worktreeRoot = result.worktreePath;
+        const dagPath = getTaskPaths(worktreeRoot, parsed.taskId).dagDraftPath;
         await dependencies.generateTaskDag({
-            repoRoot,
+            repoRoot: worktreeRoot,
             taskId: parsed.taskId,
-            outputPath: dagPath,
             strictModels: true,
             execute: false,
             initOnly: false,
             dryRun: false,
-            cwd: result.worktreePath,
+            cwd: worktreeRoot,
             profile: "auto",
             profileExplicit: false,
         });
         await dependencies.validateDag({
-            repoRoot,
+            repoRoot: worktreeRoot,
             dagPath,
             strictModelMatrix: true,
             strictGovernance: true,
             forbidExecutors: [],
         });
         const runSummary = await dependencies.runDag({
-            repoRoot,
+            repoRoot: worktreeRoot,
             dagPath,
-            cwd: result.worktreePath,
+            cwd: worktreeRoot,
             initOnly: false,
             dryRun: false,
         });

package/dist/commands/init.js

@@ -345,7 +345,7 @@ check_ts_import_boundary() {
   local label="$3"
   [[ -d "\${from_dir}" && -d "\${forbidden_dir}" ]] || return 0
   while IFS= read -r -d '' file; do
-    if grep -Eq "from ['\\\"][^'\\\"]*\${forbidden_dir}/|import\\(['\\\"][^'\\\"]*\${forbidden_dir}/|require\\(['\\\"][^'\\\"]*\${forbidden_dir}/" "\${file}"; then
+    if grep -Eq "from ['\\"][^'\\"]*\${forbidden_dir}/|import\\(['\\"][^'\\"]*\${forbidden_dir}/|require\\(['\\"][^'\\"]*\${forbidden_dir}/" "\${file}"; then
       violations+=("\${label}: \${file} imports \${forbidden_dir}")
     fi
   done < <(find "\${from_dir}" -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.mjs' -o -name '*.cjs' \\) -print0)
@@ -412,7 +412,8 @@ check_skill "loop-agent" \\
   "references/harness-policy.md" \\
   "references/hybrid-dag.md" \\
   "references/verification-and-failure-handling.md" \\
-  "references/command-reference.md"
+  "references/command-reference.md" \\
+  "references/source-and-plan-practice.md"
 check_skill "agent-worker" "references/agent-worker-operator.md"
 
 # loop-agent description is a YAML folded block (>-); grep ^description: only
@@ -856,9 +857,9 @@ function buildManagedAgentsBlock(input) {
         "loop-agent new-task <task-id> \"任务标题\"",
         "# write .harness/tasks/<task-id>/source/需求.md",
         "# write .harness/tasks/<task-id>/source/执行约束.md",
-        "loop-agent dag run-task <task-id> --profile auto --strict-models --output <temp-dir>/<task-id>-dag.json",
-        "loop-agent dag validate --dag <temp-dir>/<task-id>-dag.json --strict-models --strict-governance",
-        "loop-agent run-dag --dag <temp-dir>/<task-id>-dag.json --cwd .",
+        "loop-agent dag run-task <task-id> --profile auto --strict-models",
+        "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
+        "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",
         "```",
         "",
         "`source/需求.md` 与 `source/执行约束.md` 必需；写入前同步 `task.json.allowedPaths` / `task.json.forbiddenPaths` 并审查 writer `writeSet`。",
@@ -1818,9 +1819,9 @@ function buildManagedReadmeBlock(input) {
         "loop-agent new-task <task-id> \"任务标题\"",
         "# write .harness/tasks/<task-id>/source/需求.md",
         "# write .harness/tasks/<task-id>/source/执行约束.md",
-        "loop-agent dag run-task <task-id> --profile auto --strict-models --output <temp-dir>/<task-id>-dag.json",
-        "loop-agent dag validate --dag <temp-dir>/<task-id>-dag.json --strict-models --strict-governance",
-        "loop-agent run-dag --dag <temp-dir>/<task-id>-dag.json --cwd .",
+        "loop-agent dag run-task <task-id> --profile auto --strict-models",
+        "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
+        "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",
         "```",
         "",
         `详细工作流见 \`${input.governanceRoot}/feature-workflow.md\`；验证矩阵见 \`${input.governanceRoot}/verification-matrix.md\`。任务 source 是必需项：\`source/需求.md\` 写目标、范围、非目标、验收标准和相关链接，\`source/执行约束.md\` 写允许路径、禁止路径、受保护变更、不变量、预期验证和失败条件。`,
@@ -2050,9 +2051,9 @@ function buildTargetFeatureWorkflow(input) {
         "loop-agent new-task <task-id> \"Task title\"",
         "# write .harness/tasks/<task-id>/source/需求.md",
         "# write .harness/tasks/<task-id>/source/执行约束.md",
-        "loop-agent dag run-task <task-id> --profile auto --strict-models --output <temp-dir>/<task-id>-dag.json",
-        "loop-agent dag validate --dag <temp-dir>/<task-id>-dag.json --strict-models --strict-governance",
-        "loop-agent run-dag --dag <temp-dir>/<task-id>-dag.json --cwd .",
+        "loop-agent dag run-task <task-id> --profile auto --strict-models",
+        "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
+        "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",
         "```",
         "",
         DAG_HARD_GATE_TRIGGER,
@@ -2674,7 +2675,7 @@ async function applySafeAction(input) {
         if (!isRecord(harness) || !isRecord(harness.executors) || !isRecord(harness.executors.pi)) {
             return false;
         }
-        if (!Object.prototype.hasOwnProperty.call(harness.executors.pi, "requiresApiKey")) {
+        if (!Object.hasOwn(harness.executors.pi, "requiresApiKey")) {
             return false;
         }
         const nextPi = { ...harness.executors.pi };

package/dist/commands/instructions.js

@@ -1,7 +1,6 @@
 import { access, readdir } from "node:fs/promises";
 import path from "node:path";
 import { getArtifactPath, getArtifactRelativePath, } from "../shared/artifacts-core.js";
-import { defaultHybridDagOutputPath } from "../workflows/dag/init-hybrid.js";
 import { getTaskDir, getTaskPaths, loadTaskConfig } from "../task/runtime.js";
 const STAGES = new Set([
     "source",
@@ -96,7 +95,7 @@ export async function buildInstructions(repoRoot, stage, taskId) {
     if (stage === "dag-draft") {
         return refreshInstructionBlockers(withMissingDependencies({
             ...base,
-            outputPath: defaultHybridDagOutputPath(taskId),
+            outputPath: paths.dagDraftPath,
             dependencies: [
                 paths.taskConfigPath,
                 path.join(paths.sourceDir, "需求.md"),

package/dist/executors/shell-executor.js

@@ -19,7 +19,7 @@ import { materializeFrontendLintAssessment, materializeFrontendLintBaseline, } f
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
-import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -587,11 +587,13 @@ async function executeBackendTestPipeline(input, meta) {
                 throw new Error(`pytest did not complete with a reportable exit code: ${pytestExitCode}`);
             }
             const parsed = parsePytestHtmlReport(pytestHtmlContent);
+            // Keep native pytest-html (data-jsonblob) for audit before styled overwrite.
+            const nativeHtmlPath = await writeRunReport(meta.runDir, "backend-test-pytest-native.html", pytestHtmlContent);
             // Bind Result v1 from the native pytest-html report BEFORE overwriting with the
             // styled renderer (which drops the data-jsonblob island).
             const resultArtifact = await materializeBackendTestResultFromPytestHtml({
                 runDir: meta.runDir,
-                htmlRelativePath: "reports/backend-test.html",
+                htmlRelativePath: "reports/backend-test-pytest-native.html",
                 htmlContent: pytestHtmlContent,
                 pytestExitCode,
             });
@@ -629,10 +631,40 @@ async function executeBackendTestPipeline(input, meta) {
             catch {
                 // manifest missing: L5 AC/automation metrics degrade to unavailable.
             }
+            // Optional JaCoCo coverage collection (Java services). When jacocoCoverage
+            // is configured on the shell node, dump exec data over TCP from the
+            // JaCoCo tcpserver agent, convert via jacococli.jar, and parse into a
+            // code-coverage-v1 contract. Failure-safe: any error → coverage stays
+            // null and the L-5 dashboard degrades line/branch to unavailable.
+            let coverageContract = null;
+            const jacocoCfg = input.task.shell?.jacocoCoverage;
+            if (jacocoCfg) {
+                const sourceBinding = meta.spec.sourceBinding;
+                const requirementIds = sourceBinding?.requirementIds ?? [];
+                try {
+                    coverageContract = await collectJacocoCoverage({
+                        endpoint: jacocoCfg.endpoint,
+                        cliJarPath: jacocoCfg.cliJarPath,
+                        includes: jacocoCfg.includes ?? "*",
+                        connectTimeoutMs: jacocoCfg.connectTimeoutMs ?? 5000,
+                        workDir: reportsDir,
+                        sourceScope: { requirementIds, paths: [] },
+                        commitSha: null,
+                    });
+                }
+                catch {
+                    // coverage unavailable: JaCoCo endpoint unreachable or parse failed.
+                }
+                if (coverageContract) {
+                    const contractsDir = path.join(meta.runDir, "contracts");
+                    await mkdir(contractsDir, { recursive: true });
+                    await writeFile(path.join(contractsDir, "code-coverage-v1.json"), JSON.stringify(coverageContract, null, 2), "utf8");
+                }
+            }
             const l5Metrics = computeL5ReportMetrics({
                 result: { passed: parsed.passed, failed: parsed.failed, error: parsed.errors, skipped: parsed.skipped },
                 manifest: manifestForL5,
-                coverage: null,
+                coverage: coverageContract,
                 criticalRiskCount: parsed.failed + parsed.errors > 0 ? 1 : 0,
             });
             const failureSummaries = parsed.cases
@@ -652,7 +684,7 @@ async function executeBackendTestPipeline(input, meta) {
             });
             const l5Path = await writeRunReport(meta.runDir, "backend-test-l5-dashboard.html", l5Html);
             const sanitizedOutputs = results.map((result) => redactBackendTestOutput(result.stdout));
-            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, `l5-dashboard=${l5Path}`, `result=${resultArtifact.path}`, facts);
+            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `nativeHtml=${nativeHtmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, `l5-dashboard=${l5Path}`, `result=${resultArtifact.path}`, facts);
         }
         else if (pipeline === "contracts") {
             const wrapperPath = path.join(meta.runDir, "analyze-and-discover-backend-test-pi.json");

package/dist/task/read-model.js

@@ -1,8 +1,7 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { queryCursorRuns } from "../records/one-shot-runs.js";
-import { defaultHybridDagOutputPath } from "../workflows/dag/init-hybrid.js";
-import { listAllDagRunEntries, readDagRunSpec } from "../workflows/dag/lifecycle.js";
+import { listAllDagRunEntries, readDagRunSpec, } from "../workflows/dag/lifecycle.js";
 import { getTaskDir, getTaskPaths, getTaskStatus } from "./runtime.js";
 async function exists(filePath) {
     try {
@@ -28,9 +27,6 @@ async function listRelatedDagRuns(repoRoot, taskId) {
     }
     return related;
 }
-function defaultDagDraftPath(taskId) {
-    return defaultHybridDagOutputPath(taskId);
-}
 function closeoutPath(repoRoot, taskId) {
     return path.join(repoRoot, "docs", "progress", `${taskId}.md`);
 }
@@ -43,7 +39,7 @@ function deriveNextAction(input) {
     }
     if (!input.dagDraftExists && !input.latestDagRun) {
         return {
-            command: `npm run dev -- dag run-task ${input.taskId} --profile auto --strict-models --output ${input.dagDraftPath}`,
+            command: `npm run dev -- dag run-task ${input.taskId} --profile auto --strict-models`,
             reason: "source ready; DAG draft/run evidence not found",
         };
     }
@@ -86,7 +82,7 @@ export async function buildTaskReadModel(repoRoot, taskId) {
     if (!(await exists(requirementPath)))
         missing.push(requirementPath);
     const sourceReady = missing.length === 0;
-    const dagDraftPath = defaultDagDraftPath(taskId);
+    const dagDraftPath = paths.dagDraftPath;
     const dagDraftExists = await exists(dagDraftPath);
     const dagRuns = await listRelatedDagRuns(repoRoot, taskId);
     const latestDagRun = dagRuns.at(-1) ?? null;

package/dist/task/runtime.js

@@ -68,6 +68,8 @@ export function getTaskPaths(repoRoot, taskId) {
         contractPath: path.join(taskDir, 'contract.json'),
         /** Journaled contract transactions directory. */
         transactionsDir: path.join(taskDir, '.transactions'),
+        /** Canonical current DAG draft input for validate / run-dag. */
+        dagDraftPath: path.join(taskDir, 'dag.json'),
     };
 }
 export async function createTask(repoRoot, taskId, title) {
@@ -177,8 +179,15 @@ export async function getTaskStatus(repoRoot, taskId) {
     return loadWorkflowState(getTaskPaths(repoRoot, taskId).statePath);
 }
 export async function loadTaskConfig(repoRoot, taskId) {
-    const raw = await readFile(getTaskPaths(repoRoot, taskId).taskConfigPath, 'utf-8');
-    return parseTaskConfigForRuntime(JSON.parse(raw));
+    const configPath = getTaskPaths(repoRoot, taskId).taskConfigPath;
+    const raw = await readFile(configPath, 'utf-8');
+    try {
+        return parseTaskConfigForRuntime(JSON.parse(raw));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid task config at ${configPath}: ${message}`);
+    }
 }
 export function parseTaskConfigForRuntime(rawConfig) {
     const parsed = taskConfigSchema.parse(rawConfig);
@@ -292,7 +301,7 @@ export function getSupportedNextCommand(step, taskId, status, options) {
         return `npm run dev -- loop status ${taskId}`;
     }
     if (step === 'analyze' || step === 'plan' || step === 'spec' || step === 'implement' || step === 'verify' || step === 'retrospective') {
-        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output /tmp/${taskId}-dag.json`;
+        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models`;
     }
     return `${step} step not yet implemented in this prototype; human intervention required`;
 }

package/dist/worker/run-task/run-task.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { writeTextAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { getTaskPaths } from "../../task/runtime.js";
 import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
 import { redactForPreview, truncatePreview } from "../observability/events.js";
 import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "../loop-agent/loop-agent-client.js";
@@ -104,6 +106,13 @@ export async function runTaskSpec(options) {
         ], true, undefined, eventCtx);
     });
     progress.step(`dag validated in ${formatDuration(Date.now() - validateStartedAt)}`);
+    const canonicalDraftPath = getTaskPaths(options.repoRoot, materializeManifest.harnessTaskId).dagDraftPath;
+    await runObservedStep(eventCtx, "publish-canonical-dag-draft", async () => {
+        const dagBytes = await readFile(dagPath, "utf-8");
+        await writeTextAtomic(canonicalDraftPath, dagBytes, {
+            repoRoot: options.repoRoot,
+        });
+    });
     const runDagStep = "run-dag";
     const runDagStartedAt = Date.now();
     const dagEventsPath = path.join(getTaskPoolRoot(options.repoRoot), "observability", "runs", workerRunId, "dag-events.jsonl");
@@ -330,7 +339,7 @@ export function buildWorkerRunId(businessId, now) {
         .slice(0, 6);
     return `wr-${date}-${businessId}-${hash}`;
 }
-async function runRequiredCommand(repoRoot, client, artifactName, args, expectJson = true, timeoutMs, eventCtx) {
+async function runRequiredCommand(repoRoot, client, artifactName, args, expectJson = true, timeoutMs, _eventCtx) {
     const result = await client.run(args, {
         cwd: repoRoot,
         artifactName,
@@ -743,7 +752,14 @@ function strictModelsArgs(piModel) {
  */
 export async function applyPiModelOverride(dagPath, piModel) {
     const raw = await readFile(dagPath, "utf-8");
-    const spec = JSON.parse(raw);
+    let spec;
+    try {
+        spec = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid generated DAG JSON at ${dagPath}: ${message}`);
+    }
     spec.executorModels = {
         pi: {
             LOW: piModel,