coding-agent-harness 1.0.8 → 1.1.0

package/presets/legacy-migration/preset.yaml

@@ -43,7 +43,7 @@ templateValues:
 entrypoints:
   newTask:
     type: template
-    writes: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.tasksRoot}}/**]
     reads: [session.json]
     audit: true
     templates:
@@ -55,19 +55,19 @@ entrypoints:
   plan:
     type: script
     command: scripts/plan-work-queue.mjs
-    writes: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.tasksRoot}}/**]
     reads: [docs/**, .git/**]
     audit: true
   scaffold:
     type: script
     command: scripts/scaffold-task-contracts.mjs
-    writes: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.tasksRoot}}/**]
     reads: [docs/**]
     audit: true
   check:
     type: check
     command: checks/preset-check.mjs
-    writes: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.tasksRoot}}/**]
     reads: [docs/**]
     audit: true
 workbench:
@@ -130,5 +130,5 @@ audit:
   evidenceFiles: [preset-manifest.json, preset-audit.json, write-scope.json]
 writeScopes:
   taskArtifacts:
-    path: coding-agent-harness/planning/tasks/**
+    path: {{paths.tasksRoot}}/**
     access: write

package/presets/legacy-migration/templates/execution_strategy.append.md

@@ -15,4 +15,4 @@ Declare lanes before dispatching workers.
 
 | Lane ID | Allowed globs | Forbidden globs | Shared file owner | Worktree / branch | Handoff path | Merge order | Verification command |
 | --- | --- | --- | --- | --- | --- | --- | --- |
-| coordinator | coding-agent-harness/planning/tasks/** | AGENTS.md, CLAUDE.md, coding-agent-harness/governance/generated/Harness-Ledger.md until closeout | coordinator | current | progress.md | 1 | harness check --profile target-project . |
+| coordinator | {{paths.harnessRoot}}/planning/tasks/** | AGENTS.md, CLAUDE.md, {{paths.harnessRoot}}/governance/generated/Harness-Ledger.md until closeout | coordinator | current | progress.md | 1 | harness check --profile target-project . |

package/presets/lesson-sedimentation/preset.yaml

@@ -9,14 +9,14 @@ task:
 entrypoints:
   newTask:
     type: template
-    writes: [coding-agent-harness/planning/tasks/**]
-    reads: [coding-agent-harness/planning/tasks/**/lesson_candidates.md]
+    writes: [{{paths.tasksRoot}}/**]
+    reads: [{{paths.tasksRoot}}/**/lesson_candidates.md]
     audit: true
     templates:
       prompt: templates/prompt.md
 writeScopes:
   taskDocs:
-    path: coding-agent-harness/planning/tasks/**
+    path: {{paths.tasksRoot}}/**
     access: write
 audit:
   manifestRequired: true

package/presets/module/preset.yaml

@@ -8,7 +8,7 @@ task:
 entrypoints:
   newTask:
     type: template
-    writes: [coding-agent-harness/planning/**]
+    writes: [{{paths.planningRoot}}/**]
     audit: true
     templates:
       taskPlanAppend: templates/task_plan.append.md
@@ -21,5 +21,5 @@ audit:
   evidenceFiles: [preset-audit.json]
 writeScopes:
   planningDocs:
-    path: coding-agent-harness/planning/**
+    path: {{paths.planningRoot}}/**
     access: write

package/presets/module/templates/execution_strategy.append.md

@@ -3,6 +3,6 @@
 | Field | Value |
 | --- | --- |
 | Module Key | {{moduleKey}} |
-| Module Plan | coding-agent-harness/planning/modules/{{moduleKey}}/module_plan.md |
+| Module Plan | {{paths.harnessRoot}}/planning/modules/{{moduleKey}}/module_plan.md |
 
 Keep shared module decisions in the module plan or module context files. Keep task-specific evidence in this task directory.

package/presets/module/templates/task_plan.append.md

@@ -12,6 +12,6 @@ Read these module-level entry points before changing shared module behavior. Con
 
 | Reference | Path | Why / When |
 | --- | --- | --- |
-| Module brief | coding-agent-harness/planning/modules/{{moduleKey}}/brief.md | Start here for the module purpose and current scope. |
-| Module plan | coding-agent-harness/planning/modules/{{moduleKey}}/module_plan.md | Use this for module steps, active task links, and handoff state. |
-| Module visual map | coding-agent-harness/planning/modules/{{moduleKey}}/visual_map.md | Inspect when the change affects module sequencing or dependencies. |
+| Module brief | {{paths.harnessRoot}}/planning/modules/{{moduleKey}}/brief.md | Start here for the module purpose and current scope. |
+| Module plan | {{paths.harnessRoot}}/planning/modules/{{moduleKey}}/module_plan.md | Use this for module steps, active task links, and handoff state. |
+| Module visual map | {{paths.harnessRoot}}/planning/modules/{{moduleKey}}/visual_map.md | Inspect when the change affects module sequencing or dependencies. |

package/presets/release-closeout/checks/check-release-package.mjs

@@ -5,7 +5,12 @@ import path from "node:path";
 
 const context = JSON.parse(fs.readFileSync(process.env.HARNESS_PRESET_CONTEXT, "utf8"));
 const release = String(context.inputs.release || "").trim();
-const releaseRoot = path.join(context.targetRoot, "coding-agent-harness/governance/releases", release);
+const governanceRoot = context.paths?.governanceRoot;
+if (!governanceRoot) {
+  console.error("release-closeout check requires structure-aware context.paths from the preset runner");
+  process.exit(2);
+}
+const releaseRoot = path.join(context.targetRoot, governanceRoot, "releases", release);
 const required = ["INDEX.md", "task-aggregate.json", "task-archive-plan.md", "public-summary.md", "public-redaction-report.json"];
 const missing = required.filter((file) => !fs.existsSync(path.join(releaseRoot, file)));
 if (missing.length) {

package/presets/release-closeout/preset.yaml

@@ -47,7 +47,7 @@ templateValues:
 entrypoints:
   newTask:
     type: template
-    writes: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.tasksRoot}}/**]
     audit: true
     templates:
       taskPlanAppend: templates/task_plan.append.md
@@ -57,20 +57,20 @@ entrypoints:
   plan:
     type: script
     command: scripts/generate-release-package.mjs
-    writes: [coding-agent-harness/governance/releases/**]
-    reads: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.governanceRoot}}/releases/**]
+    reads: [{{paths.tasksRoot}}/**, {{paths.modulesRoot}}/**]
     audit: true
   scaffold:
     type: script
     command: scripts/generate-release-package.mjs
-    writes: [coding-agent-harness/governance/releases/**]
-    reads: [coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.governanceRoot}}/releases/**]
+    reads: [{{paths.tasksRoot}}/**, {{paths.modulesRoot}}/**]
     audit: true
   check:
     type: check
     command: checks/check-release-package.mjs
-    writes: [coding-agent-harness/governance/releases/**]
-    reads: [coding-agent-harness/governance/releases/**, coding-agent-harness/planning/tasks/**]
+    writes: [{{paths.governanceRoot}}/releases/**]
+    reads: [{{paths.governanceRoot}}/releases/**, {{paths.tasksRoot}}/**, {{paths.modulesRoot}}/**]
     audit: true
 evidence:
   bundleDir: artifacts/preset
@@ -93,8 +93,8 @@ audit:
   evidenceFiles: [preset-audit.json, preset-manifest.json, write-scope.json]
 writeScopes:
   taskDocs:
-    path: coding-agent-harness/planning/tasks/**
+    path: {{paths.tasksRoot}}/**
     access: write
   releasePackage:
-    path: coding-agent-harness/governance/releases/**
+    path: {{paths.governanceRoot}}/releases/**
     access: write

package/presets/release-closeout/scripts/generate-release-package.mjs

@@ -4,32 +4,70 @@ import fs from "node:fs";
 import path from "node:path";
 
 const context = JSON.parse(fs.readFileSync(process.env.HARNESS_PRESET_CONTEXT, "utf8"));
+const harnessCore = await import(context.runtime?.coreModule || new URL("../../../dist/harness-core.mjs", import.meta.url).href);
+const {
+  normalizeTarget,
+  collectTasks: collectCoreTasks,
+  archiveBlockReason: sharedArchiveBlockReason,
+} = harnessCore;
+
 const release = safeRelease(context.inputs.release);
 if (!release) {
   console.error("release-closeout requires inputs.release");
   process.exit(2);
 }
 
-const tasksRoot = path.join(context.targetRoot, "coding-agent-harness/planning/tasks");
+const paths = context.paths || {};
+if (!paths.tasksRoot || !paths.governanceRoot) {
+  console.error("release-closeout requires structure-aware context.paths from the preset runner");
+  process.exit(2);
+}
 const releaseRoot = path.join(context.outputRoot, "release");
 fs.mkdirSync(releaseRoot, { recursive: true });
 
-const tasks = collectTasks(tasksRoot)
-  .filter((task) => task.id !== context.task.id && task.preset !== "release-closeout")
+const target = normalizeTarget(context.targetRoot);
+const allTasks = collectCoreTasks(target)
+  .map(releaseTaskFromCore)
+  .filter((task) => task.id !== context.task.id && task.shortId !== context.task.id && task.preset !== "release-closeout")
   .sort((a, b) => a.id.localeCompare(b.id));
-const eligibleArchive = tasks.filter((task) => task.state === "done" && task.deletionState !== "superseded");
-const blockedArchive = tasks.filter((task) => task.state === "blocked" || task.queue === "blocked");
+let selection;
+try {
+  selection = selectTasks(allTasks, context.inputs, release);
+} catch (error) {
+  console.error(error.message);
+  process.exit(2);
+}
+
+const tasks = selection.tasks.sort((a, b) => a.id.localeCompare(b.id));
+if (tasks.length === 0) {
+  console.error("release-closeout selector matched no tasks");
+  process.exit(2);
+}
+
+const eligibility = tasks.map((task) => ({ task, reason: archiveBlockReason(task) }));
+const eligibleArchive = eligibility.filter((item) => !item.reason).map((item) => item.task);
+const notEligibleArchive = eligibility.filter((item) => item.reason);
+const governanceRoot = paths.governanceRoot;
+const destinationRoot = `${governanceRoot}/releases/${release}`;
+const releasePackageRef = `${destinationRoot}/INDEX.md`;
 
 const aggregate = {
   schemaVersion: "release-closeout-aggregate/v1",
   release,
   generatedAt: new Date().toISOString(),
+  selector: selection.selector,
   summary: {
     totalTasks: tasks.length,
     doneTasks: tasks.filter((task) => task.state === "done").length,
     blockedTasks: tasks.filter((task) => task.state === "blocked").length,
     archiveEligibleTasks: eligibleArchive.length,
   },
+  matched: tasks.map(taskSummary),
+  excluded: selection.excluded.map((task) => ({ ...taskSummary(task), reason: "not-selected" })),
+  notEligible: [
+    ...selection.missing.map((id) => ({ id, reason: "task-not-found" })),
+    ...notEligibleArchive.map(({ task, reason }) => ({ ...taskSummary(task), reason })),
+  ],
   tasks: tasks.map((task) => ({
     id: task.id,
     title: task.title,
@@ -37,7 +75,7 @@ const aggregate = {
     preset: task.preset || "none",
     deletionState: task.deletionState,
     archiveEligible: eligibleArchive.some((candidate) => candidate.id === task.id),
-    archiveBlockedReason: task.state === "blocked" ? "blocked tasks cannot be archived" : "",
+    archiveBlockedReason: archiveBlockReason(task),
   })),
 };
 
@@ -63,6 +101,11 @@ Generated by \`presets/release-closeout\` through the generic preset runner.
 const archivePlan = `# Release ${release} Task Archive Plan
 
 This plan is generated by the release-closeout preset. It does not archive tasks by itself.
+Run the commands from the target project root after reviewing this package.
+
+## Eligible Archive Commands
+
+${eligibleArchive.length ? eligibleArchive.map((task) => `- ${archiveCommand(task, release, releasePackageRef)}`).join("\n") : "- none"}
 
 ## Eligible Tasks
 
@@ -70,7 +113,7 @@ ${eligibleArchive.length ? eligibleArchive.map((task) => `- ${task.id} - ${task.
 
 ## Not Eligible
 
-${blockedArchive.length ? blockedArchive.map((task) => `- ${task.id} - blocked tasks cannot be archived`).join("\n") : "- none"}
+${aggregate.notEligible.length ? aggregate.notEligible.map((task) => `- ${task.id} - ${task.reason}`).join("\n") : "- none"}
 `;
 
 const publicSummaryRaw = `# Release ${release} Public Summary
@@ -101,7 +144,6 @@ write("task-aggregate.json", `${JSON.stringify(aggregate, null, 2)}\n`);
 write("public-summary.md", publicSummary);
 write("public-redaction-report.json", `${JSON.stringify(redactionReport, null, 2)}\n`);
 
-const destinationRoot = `coding-agent-harness/governance/releases/${release}`;
 fs.writeFileSync(context.materializationManifestPath, `${JSON.stringify({
   schemaVersion: "preset-materialization/v1",
   status: "ok",
@@ -119,27 +161,264 @@ function write(name, content) {
   fs.writeFileSync(path.join(releaseRoot, name), content.endsWith("\n") ? content : `${content}\n`);
 }
 
-function collectTasks(root) {
-  if (!fs.existsSync(root)) return [];
-  const taskPlans = walk(root).filter((file) => path.basename(file) === "task_plan.md");
-  return taskPlans.map((taskPlanPath) => {
-    const taskDir = path.dirname(taskPlanPath);
-    const taskPlan = read(taskPlanPath);
-    const progress = read(path.join(taskDir, "progress.md"));
-    const tombstone = parseTombstone(taskPlan);
+function selectTasks(tasks, inputs, release) {
+  const hasTaskList = Boolean(inputs.taskList);
+  const hasTaskQuery = Boolean(String(inputs.taskQuery || "").trim());
+  if (!hasTaskList && !hasTaskQuery) throw new Error("release-closeout requires --task-list or --task-query");
+  if (hasTaskList && hasTaskQuery) throw new Error("release-closeout accepts only one selector: --task-list or --task-query");
+
+  if (hasTaskList) {
+    const taskList = inputs.taskList;
+    if (!taskList || typeof taskList !== "object" || Array.isArray(taskList)) {
+      throw new Error("--task-list must be a JSON object");
+    }
+    if (taskList.schemaVersion !== "release-closeout-task-list/v1") {
+      throw new Error("--task-list schemaVersion must be release-closeout-task-list/v1");
+    }
+    if (taskList.release && taskList.release !== release) {
+      throw new Error(`--task-list release ${taskList.release} does not match --release ${release}`);
+    }
+    const requestedTaskIds = Array.isArray(taskList.taskIds) ? taskList.taskIds.map(normalizeTaskListId).filter(Boolean) : [];
+    if (requestedTaskIds.length === 0) throw new Error("--task-list requires non-empty taskIds");
+    const selected = resolveTaskReferences(requestedTaskIds, tasks);
+    const selectedIds = new Set(selected.map((task) => task.id));
     return {
-      id: path.basename(taskDir),
-      title: titleFrom(taskPlan, path.basename(taskDir)),
-      preset: metadataLine(taskPlan, ["Task Preset", "Preset"]).toLowerCase(),
-      state: parseState(progress),
-      deletionState: tombstone.state || "active",
-      queue: parseState(progress) === "blocked" ? "blocked" : "active",
-      evidenceSnippet: progress.split(/\r?\n/).find((line) => /\/Users\/|\/Volumes\/|file:\/\//.test(line)) || "",
-      tombstone,
+      selector: {
+        type: "task-list",
+        schemaVersion: taskList.schemaVersion,
+        release,
+        sourcePath: taskList.sourcePath || "",
+        taskIds: requestedTaskIds,
+        resolvedTaskIds: selected.map((task) => task.id),
+      },
+      tasks: selected,
+      excluded: tasks.filter((task) => !selectedIds.has(task.id)),
+      missing: [],
     };
+  }
+
+  const query = String(inputs.taskQuery || "").trim();
+  const terms = parseTaskQuery(query);
+  const selected = tasks.filter((task) => terms.every((term) => matchesQueryTerm(task, term)));
+  const selectedIds = new Set(selected.map((task) => task.id));
+  return {
+    selector: {
+      type: "task-query",
+      query,
+      terms,
+    },
+    tasks: selected,
+    excluded: tasks.filter((task) => !selectedIds.has(task.id)),
+    missing: [],
+  };
+}
+
+function normalizeTaskListId(value) {
+  return String(value || "").trim();
+}
+
+function resolveTaskReferences(references, tasks) {
+  return references.map((reference) => {
+    const canonical = tasks.filter((task) => task.id === reference);
+    const candidates = canonical.length > 0 ? canonical : tasks.filter((task) => taskReferenceMatches(task, reference));
+    if (candidates.length === 0) {
+      throw new Error(`Missing task reference: ${reference}`);
+    }
+    if (candidates.length > 1) {
+      throw new Error(`Ambiguous task reference: ${reference} matched ${candidates.map((task) => task.id).join(", ")}`);
+    }
+    return candidates[0];
   });
 }
 
+function taskReferenceMatches(task, reference) {
+  if (/^(TASKS|MODULES|EXTERNAL)\//.test(reference)) return task.id === reference;
+  return task.shortId === reference || task.legacyId === reference || task.id.endsWith(`/${reference}`);
+}
+
+function parseTaskQuery(query) {
+  const rawTerms = query.split(/\s+/).map((item) => item.trim()).filter(Boolean);
+  if (rawTerms.length === 0) throw new Error("--task-query requires at least one selector term");
+  return rawTerms.map((term) => {
+    let match = term.match(/^date:(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/);
+    if (match) return { type: "date", from: match[1], to: match[2] };
+    match = term.match(/^state:([A-Za-z0-9_-]+)$/);
+    if (match) return { type: "state", value: normalizeState(match[1]) };
+    match = term.match(/^preset:([A-Za-z0-9._-]+)$/);
+    if (match) return { type: "preset", value: match[1].toLowerCase() };
+    match = term.match(/^module:([A-Za-z0-9._-]+)$/);
+    if (match) return { type: "module", value: match[1].toLowerCase() };
+    throw new Error(`Unsupported --task-query term: ${term}`);
+  });
+}
+
+function matchesQueryTerm(task, term) {
+  if (term.type === "date") {
+    const date = task.date || "";
+    return date >= term.from && date <= term.to;
+  }
+  if (term.type === "state") return task.state === term.value;
+  if (term.type === "preset") return (task.preset || "none") === term.value;
+  if (term.type === "module") return (task.module || "").toLowerCase() === term.value;
+  return false;
+}
+
+function taskSummary(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    state: task.state,
+    preset: task.preset || "none",
+    deletionState: task.deletionState,
+    module: task.module || "",
+    shortId: task.shortId || "",
+  };
+}
+
+function archiveBlockReason(task) {
+  return sharedArchiveBlockReason(task, { archivedBy: task.reviewConfirmation?.reviewer || "" });
+}
+
+function releaseTaskFromCore(task) {
+  const shortId = task.shortId || task.id.split("/").at(-1) || "";
+  return {
+    ...task,
+    preset: task.taskPreset || "none",
+    date: shortId.match(/^(\d{4}-\d{2}-\d{2})/)?.[1] || "",
+    queue: (task.taskQueues || []).includes("blocked") ? "blocked" : "active",
+    hasOpenBlockingFindings: (task.risks || []).some((risk) => String(risk.open) !== "no" && (String(risk.blocksRelease) === "yes" || ["P0", "P1", "P2"].includes(String(risk.severity)))),
+    materialsIncomplete: task.materialsReady === false,
+    evidenceSnippet: "",
+  };
+}
+
+function archiveCommand(task, release, releasePackageRef) {
+  return [
+    "harness",
+    "task-archive",
+    quoteCli(task.id),
+    "--reason",
+    quoteCli(`release closeout ${release}`),
+    "--archived-by",
+    quoteCli(task.reviewConfirmation?.reviewer || ""),
+    "--archive-field",
+    quoteCli(`retention bucket=release:${release}`),
+    "--archive-field",
+    quoteCli(`release package=${releasePackageRef}`),
+    ".",
+  ].join(" ");
+}
+
+function quoteCli(value) {
+  return `"${String(value || "").replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function taskRootsFromContext(targetRoot, paths) {
+  const roots = [];
+  const seen = new Set();
+  const addRoot = (kind, relativeRoot) => {
+    if (!relativeRoot) return;
+    const root = path.join(targetRoot, relativeRoot);
+    const key = path.resolve(root);
+    if (seen.has(key)) return;
+    seen.add(key);
+    roots.push({ kind, root, relativeRoot: toPosix(relativeRoot) });
+  };
+  addRoot("TASKS", paths.tasksRoot);
+  addRoot("MODULES", paths.modulesRoot);
+  addRoot("EXTERNAL", paths.externalRoot);
+  if (Array.isArray(paths.taskRoots)) {
+    for (const relativeRoot of paths.taskRoots) addRoot(inferTaskRootKind(relativeRoot, paths), relativeRoot);
+  }
+  return roots;
+}
+
+function inferTaskRootKind(relativeRoot, paths) {
+  const normalized = toPosix(relativeRoot);
+  if (normalized === toPosix(paths.tasksRoot || "")) return "TASKS";
+  if (normalized === toPosix(paths.modulesRoot || "")) return "MODULES";
+  if (normalized === toPosix(paths.externalRoot || "")) return "EXTERNAL";
+  return "EXTERNAL";
+}
+
+function collectTasks(roots) {
+  const tasks = [];
+  for (const rootInfo of roots) {
+    if (!fs.existsSync(rootInfo.root)) continue;
+    const taskPlans = walk(rootInfo.root).filter((file) => path.basename(file) === "task_plan.md");
+    for (const taskPlanPath of taskPlans) {
+      const taskDir = path.dirname(taskPlanPath);
+      const identity = taskIdentity(rootInfo, taskDir);
+      if (!identity) continue;
+      const taskPlan = read(taskPlanPath);
+      const progress = read(path.join(taskDir, "progress.md"));
+      const review = read(path.join(taskDir, "review.md"));
+      const index = read(path.join(taskDir, "INDEX.md"));
+      const budget = parseBudget(taskPlan);
+      const state = parseState(progress);
+      const tombstone = parseTombstone(taskPlan);
+      tasks.push({
+        ...identity,
+        title: titleFrom(taskPlan, identity.shortId),
+        preset: metadataLine(taskPlan, ["Task Preset", "Preset"]).toLowerCase(),
+        state,
+        deletionState: tombstone.state || "active",
+        queue: state === "blocked" ? "blocked" : "active",
+        budget,
+        hasOpenBlockingFindings: hasOpenBlockingReviewFinding(review),
+        materialsIncomplete: budget !== "simple" && hasIncompleteMaterials(taskDir),
+        reviewConfirmation: parseReviewConfirmation(index, identity.id),
+        evidenceSnippet: progress.split(/\r?\n/).find((line) => /\/Users\/|\/Volumes\/|file:\/\//.test(line)) || "",
+        tombstone,
+      });
+    }
+  }
+  return tasks;
+}
+
+function taskIdentity(rootInfo, taskDir) {
+  const relative = toPosix(path.relative(rootInfo.root, taskDir));
+  if (!relative || relative.startsWith("..")) return null;
+  const segments = relative.split("/").filter(Boolean);
+  const shortId = segments.at(-1) || path.basename(taskDir);
+  const date = shortId.match(/^(\d{4}-\d{2}-\d{2})/)?.[1] || "";
+  if (rootInfo.kind === "TASKS") {
+    return {
+      id: `TASKS/${relative}`,
+      legacyId: shortId,
+      shortId,
+      date,
+      module: "",
+      rootKind: "TASKS",
+    };
+  }
+  if (rootInfo.kind === "MODULES") {
+    if (segments.length < 3 || segments[1] !== "tasks") return null;
+    const moduleKey = segments[0];
+    const taskRelative = segments.slice(2).join("/");
+    return {
+      id: `MODULES/${moduleKey}/${taskRelative}`,
+      legacyId: shortId,
+      shortId,
+      date,
+      module: moduleKey,
+      rootKind: "MODULES",
+    };
+  }
+  return {
+    id: `EXTERNAL/${toPosix(path.basename(rootInfo.root))}/${relative}`,
+    legacyId: shortId,
+    shortId,
+    date,
+    module: "",
+    rootKind: "EXTERNAL",
+  };
+}
+
+function toPosix(value) {
+  return String(value || "").split(path.sep).join("/");
+}
+
 function walk(root) {
   const files = [];
   for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
@@ -171,10 +450,40 @@ function metadataLine(content, labels) {
 
 function parseState(progress) {
   const match = String(progress || "").match(/^##\s*(?:Current Status|Status|状态)\s*[:：]?\s*(?:\n\s*)?([^\n]+)/im);
-  const raw = (match ? match[1] : "").trim().toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
+  return normalizeState(match ? match[1] : "");
+}
+
+function normalizeState(value) {
+  const raw = String(value || "").trim().toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
   return ["not_started", "planned", "in_progress", "review", "blocked", "done"].includes(raw) ? raw : "unknown";
 }
 
+function parseBudget(taskPlan) {
+  const match = String(taskPlan || "").match(/Selected budget\s*[:：]\s*([A-Za-z0-9_-]+)/i);
+  return match ? match[1].trim().toLowerCase() : "standard";
+}
+
+function hasOpenBlockingReviewFinding(review) {
+  const lines = String(review || "").split(/\r?\n/);
+  for (const line of lines) {
+    const row = line.trim();
+    if (!row.startsWith("|") || /---/.test(row) || /severity|finding/i.test(row)) continue;
+    const cells = row.slice(1, -1).split("|").map((cell) => cell.trim().toLowerCase());
+    const hasBlockingSeverity = cells.some((cell) => /^p[0-2]\b/.test(cell));
+    const openOrBlocking = cells.some((cell) => /^(yes|true|open|是|开放)$/.test(cell));
+    if (hasBlockingSeverity && openOrBlocking) return true;
+  }
+  return /^Open Blocking Findings\s*[:：]\s*(yes|true|open|是)/im.test(review);
+}
+
+function hasIncompleteMaterials(taskDir) {
+  for (const fileName of ["task_plan.md", "progress.md", "review.md", "INDEX.md"]) {
+    const content = read(path.join(taskDir, fileName));
+    if (/Materials\s*(?:Status|Ready)\s*[:：]\s*(incomplete|missing|no|false)/im.test(content)) return true;
+  }
+  return false;
+}
+
 function parseTombstone(content) {
   const match = String(content || "").match(/^##\s*(?:Task Tombstone|任务墓碑)\s*$([\s\S]*?)(?=^##\s+|(?![\s\S]))/im);
   if (!match) return { state: "active", fields: {} };
@@ -188,6 +497,59 @@ function parseTombstone(content) {
   return { state: fields.state || "soft-deleted", fields };
 }
 
+function parseReviewConfirmation(content, taskId) {
+  const fields = markdownFieldsFromBlock(content, /^##\s*(?:Task Audit Metadata|任务审计元数据)\s*$/im);
+  if (fields.size === 0) return { confirmed: false, missingFields: ["Task Audit Metadata"] };
+  if (normalizeToken(fields.get("human review status")) !== "confirmed") return { confirmed: false, missingFields: [] };
+  const required = ["confirmation id", "confirmed at", "reviewer", "reviewer email", "confirm text", "evidence checked", "review commit sha", "audit status"];
+  const missing = required.filter((field) => !isConcreteAuditField(fields.get(field)));
+  const confirmText = fields.get("confirm text") || "";
+  if (isConcreteAuditField(confirmText) && !taskKeysMatch(confirmText, taskId)) missing.push("confirm text match");
+  const auditStatus = fields.get("audit status") || "";
+  if (isConcreteAuditField(auditStatus) && normalizeToken(auditStatus) !== "committed") missing.push("audit status committed");
+  const commitSha = fields.get("review commit sha") || "";
+  if (isConcreteAuditField(commitSha) && !/^[0-9a-f]{7,40}$/i.test(commitSha)) missing.push("review commit sha valid");
+  return {
+    confirmed: missing.length === 0,
+    missingFields: missing,
+    confirmationId: fields.get("confirmation id") || "",
+    confirmedAt: fields.get("confirmed at") || "",
+    reviewer: fields.get("reviewer") || "",
+    reviewerEmail: fields.get("reviewer email") || "",
+    confirmText,
+    evidenceChecked: fields.get("evidence checked") || "",
+    commitSha,
+  };
+}
+
+function markdownFieldsFromBlock(content, headingPattern) {
+  const match = String(content || "").match(new RegExp(`${headingPattern.source}([\\s\\S]*?)(?=^##\\s+|(?![\\s\\S]))`, headingPattern.flags));
+  const fields = new Map();
+  if (!match) return fields;
+  for (const line of match[1].split(/\r?\n/)) {
+    const row = line.trim();
+    if (!row.startsWith("|") || /---/.test(row) || /Field\s*\|\s*Value/i.test(row)) continue;
+    const cells = row.slice(1, -1).split("|").map((cell) => cell.trim());
+    if (cells.length >= 2) fields.set(cells[0].toLowerCase(), cells.slice(1).join("|").trim());
+  }
+  return fields;
+}
+
+function isConcreteAuditField(value) {
+  const raw = String(value || "").replace(/`/g, "").trim();
+  return Boolean(raw) && !/^(n\/a|na|none|pending(?:[-_ ].*)?|todo|tbd|\[.*\]|-|—|–|不适用|无|待定|\{\})$/i.test(raw) && !/\{\{[^}]+\}\}/.test(raw);
+}
+
+function normalizeToken(value) {
+  return String(value || "").trim().toLowerCase().replaceAll("_", "-").replace(/\s+/g, "-");
+}
+
+function taskKeysMatch(candidate, expected) {
+  const left = String(candidate || "").replace(/`/g, "").trim();
+  const right = String(expected || "").replace(/`/g, "").trim();
+  return left === right || right.endsWith(`/${left}`);
+}
+
 function safeRelease(value) {
   const release = String(value || "").trim();
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(release) ? release : "";