coding-agent-harness 1.0.7 → 1.1.0

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

@@ -0,0 +1,572 @@
+#!/usr/bin/env node
+
+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 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 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));
+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,
+    state: task.state,
+    preset: task.preset || "none",
+    deletionState: task.deletionState,
+    archiveEligible: eligibleArchive.some((candidate) => candidate.id === task.id),
+    archiveBlockedReason: archiveBlockReason(task),
+  })),
+};
+
+const index = `# Release Closeout Package: ${release}
+
+Generated by \`presets/release-closeout\` through the generic preset runner.
+
+| Document | Purpose |
+| --- | --- |
+| \`task-aggregate.json\` | Machine-readable task inventory for this release closeout. |
+| \`task-archive-plan.md\` | Preset-owned archive eligibility plan. |
+| \`public-summary.md\` | Redacted public-facing summary. |
+| \`public-redaction-report.json\` | Redaction evidence for public materialization. |
+
+## Summary
+
+- Total tasks: ${aggregate.summary.totalTasks}
+- Done tasks: ${aggregate.summary.doneTasks}
+- Blocked tasks: ${aggregate.summary.blockedTasks}
+- Archive eligible tasks: ${aggregate.summary.archiveEligibleTasks}
+`;
+
+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
+
+${eligibleArchive.length ? eligibleArchive.map((task) => `- ${task.id} - ${task.title}`).join("\n") : "- none"}
+
+## Not Eligible
+
+${aggregate.notEligible.length ? aggregate.notEligible.map((task) => `- ${task.id} - ${task.reason}`).join("\n") : "- none"}
+`;
+
+const publicSummaryRaw = `# Release ${release} Public Summary
+
+This release closeout aggregates ${aggregate.summary.totalTasks} tasks, including ${aggregate.summary.doneTasks} done tasks and ${aggregate.summary.blockedTasks} blocked tasks.
+
+Recent evidence snippets:
+
+${tasks.slice(0, 20).map((task) => `- ${task.id}: ${task.evidenceSnippet || "no evidence snippet"}`).join("\n")}
+`;
+const publicSummary = redactPublic(publicSummaryRaw);
+const redactionReport = {
+  schemaVersion: "public-redaction-report/v1",
+  status: leaksLocalPath(publicSummary) ? "fail" : "pass",
+  rules: ["local-absolute-paths", "file-urls"],
+  checkedFiles: ["public-summary.md"],
+  findings: leaksLocalPath(publicSummary) ? ["public-summary contains local absolute path"] : [],
+  generatedAt: new Date().toISOString(),
+};
+if (redactionReport.status !== "pass") {
+  console.error("public redaction failed");
+  process.exit(3);
+}
+
+write("INDEX.md", index);
+write("task-archive-plan.md", archivePlan);
+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`);
+
+fs.writeFileSync(context.materializationManifestPath, `${JSON.stringify({
+  schemaVersion: "preset-materialization/v1",
+  status: "ok",
+  publicRedactionReport: { source: "release/public-redaction-report.json" },
+  writes: [
+    { source: "release/INDEX.md", destination: `${destinationRoot}/INDEX.md`, type: "text" },
+    { source: "release/task-archive-plan.md", destination: `${destinationRoot}/task-archive-plan.md`, type: "text" },
+    { source: "release/task-aggregate.json", destination: `${destinationRoot}/task-aggregate.json`, type: "json" },
+    { source: "release/public-summary.md", destination: `${destinationRoot}/public-summary.md`, type: "text", visibility: "public" },
+    { source: "release/public-redaction-report.json", destination: `${destinationRoot}/public-redaction-report.json`, type: "json" },
+  ],
+}, null, 2)}\n`);
+
+function write(name, content) {
+  fs.writeFileSync(path.join(releaseRoot, name), content.endsWith("\n") ? content : `${content}\n`);
+}
+
+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 {
+      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 })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...walk(full));
+    else if (entry.isFile()) files.push(full);
+  }
+  return files;
+}
+
+function read(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function titleFrom(content, fallback) {
+  const match = String(content || "").match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : fallback;
+}
+
+function metadataLine(content, labels) {
+  const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const match = String(content || "").match(new RegExp(`^(?:${escaped})\\s*[:：]\\s*([^\\n]+)`, "im"));
+  return match ? match[1].replace(/`/g, "").trim() : "";
+}
+
+function parseState(progress) {
+  const match = String(progress || "").match(/^##\s*(?:Current Status|Status|状态)\s*[:：]?\s*(?:\n\s*)?([^\n]+)/im);
+  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: {} };
+  const 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().toLowerCase());
+    if (cells.length >= 2) fields[cells[0]] = cells.slice(1).join("|").trim();
+  }
+  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 : "";
+}
+
+function redactPublic(value) {
+  return String(value || "")
+    .replace(/file:\/\/\/[^\s)"'`<>\]]+/g, "LOCAL_FILE_URL_REDACTED")
+    .replaceAll("file://", "LOCAL_FILE_URL_REDACTED")
+    .replace(/\/Users\/[^/\s)"'`<>\]]+(?:\/[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED")
+    .replace(/\/Volumes\/[^\s)"'`<>\]]+(?:\/[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED")
+    .replace(/\/(?:private\/)?tmp\/[^\s)"'`<>\]]+(?:\/[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED")
+    .replace(/\/var\/folders\/[^\s)"'`<>\]]+(?:\/[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED")
+    .replace(/\/home\/[^/\s)"'`<>\]]+(?:\/[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED")
+    .replace(/[A-Za-z]:\\[^\s)"'`<>\]]+(?:\\[^\s)"'`<>\]]*)*/g, "LOCAL_PATH_REDACTED");
+}
+
+function leaksLocalPath(value) {
+  return /(?:^|[\s"'(])(?:\/Users\/|\/Volumes\/|\/tmp\/|\/private\/tmp\/|\/var\/folders\/|\/home\/|[A-Za-z]:\\|file:\/\/)/.test(String(value || ""));
+}

package/presets/release-closeout/templates/execution_strategy.append.md

@@ -0,0 +1,7 @@
+## Release Closeout Strategy
+
+| Phase ID | Depends On | State | Completion | Output | Required Evidence | Evidence Status | Blocking Risk | Owner / Handoff |
+| --- | --- | --- | ---: | --- | --- | --- | --- | --- |
+| RC-PLAN | none | planned | 0 | Release task inventory and archive eligibility plan | `harness preset run release-closeout plan --task {{taskId}} .` | missing | none | coordinator |
+| RC-SCAFFOLD | RC-PLAN | planned | 0 | Version package materialized under governance releases | `harness preset run release-closeout scaffold --task {{taskId}} .` | missing | none | coordinator |
+| RC-CHECK | RC-SCAFFOLD | planned | 0 | Release package validation report | `harness preset run release-closeout check --task {{taskId}} .` | missing | none | coordinator |

package/presets/release-closeout/templates/findings.seed.md

@@ -0,0 +1,5 @@
+## Release Closeout Findings
+
+| Severity | Finding | Open | Blocks Release | Disposition | Waiver By |
+| --- | --- | --- | --- | --- | --- |
+| P2 | Release package has not been generated yet. | yes | no | pending `release-closeout scaffold` | n/a |

package/presets/release-closeout/templates/review.seed.md

@@ -0,0 +1,3 @@
+## Release Closeout Review
+
+Review the generated release package, archive plan, and public redaction report before marking this task complete.

package/presets/release-closeout/templates/task_plan.append.md

@@ -0,0 +1,24 @@
+## Release Closeout
+
+Release Version: {{release}}
+Previous Release: {{previousRelease}}
+Next Release: {{nextRelease}}
+Task Query: {{taskQuery}}
+
+## Release Package Workflow
+
+Run these preset entrypoints from the target root. The task scaffold only records the release intent; version package files are generated by the generic preset runner.
+
+1. `harness preset run release-closeout plan --task {{taskId}} .`
+2. `harness preset run release-closeout scaffold --task {{taskId}} .`
+3. `harness preset run release-closeout check --task {{taskId}} .`
+
+## Release Package Outputs
+
+| Output | Owner |
+| --- | --- |
+| `{{paths.governanceRoot}}/releases/{{release}}/INDEX.md` | `presets/release-closeout` |
+| `{{paths.governanceRoot}}/releases/{{release}}/task-aggregate.json` | `presets/release-closeout` |
+| `{{paths.governanceRoot}}/releases/{{release}}/task-archive-plan.md` | `presets/release-closeout` |
+| `{{paths.governanceRoot}}/releases/{{release}}/public-summary.md` | `presets/release-closeout` |
+| `{{paths.governanceRoot}}/releases/{{release}}/public-redaction-report.json` | `presets/release-closeout` |

package/presets/standard-task/preset.yaml

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

package/references/agents-md-pattern.md

@@ -70,23 +70,29 @@ AGENTS.md 只包含两类内容：
 项目根目录/
 ├── AGENTS.md        ← concise canonical charter + routing index
 ├── CLAUDE.md        ← 轻量 shim，指向 AGENTS.md
-└── docs/
-    ├── Harness-Ledger.md
-    └── coding-agent-harness/governance/standards/
-        ├── testing-standard.md
-        ├── execution-workflow-standard.md
-        ├── repo-governance-standard.md
-        ├── ci-cd-standard.md
-        ├── long-running-task-standard.md
-        ├── adversarial-review-standard.md
-        ├── review-routing-standard.md
-        ├── engineering-standard.md
-        ├── frontend-standard.md
-        ├── docs-library-standard.md
-        ├── harness-ledger-standard.md
-        ├── regression-ssot-governance.md
-        ├── walkthrough-standard.md
-        └── ...（按需扩展）
+└── coding-agent-harness/
+    ├── governance/
+    │   ├── generated/
+    │   │   ├── Harness-Ledger.md
+    │   │   └── Closeout-Index.md
+    │   └── standards/
+    │       ├── testing-standard.md
+    │       ├── execution-workflow-standard.md
+    │       ├── repo-governance-standard.md
+    │       ├── ci-cd-standard.md
+    │       ├── long-running-task-standard.md
+    │       ├── adversarial-review-standard.md
+    │       ├── review-routing-standard.md
+    │       ├── engineering-standard.md
+    │       ├── frontend-standard.md
+    │       ├── docs-library-standard.md
+    │       ├── harness-ledger-standard.md
+    │       ├── regression-ssot-governance.md
+    │       ├── walkthrough-standard.md
+    │       └── ...（按需扩展）
+    └── planning/
+        ├── tasks/
+        └── modules/
 ```
 
 ### 行数控制