coding-agent-harness 1.0.4 → 1.0.5

package/scripts/lib/task-metadata.mjs

@@ -0,0 +1,118 @@
+import {
+  allowedTaskStates,
+  allowedTaskBudgets,
+  taskContractMarker,
+} from "./core-shared.mjs";
+import { tableAfterHeading, firstColumn } from "./markdown-utils.mjs";
+
+export function parseTaskState(progressContent) {
+  return parseTaskStateInfo(progressContent).state;
+}
+
+export function parseTaskBudget(taskPlanContent) {
+  const match =
+    String(taskPlanContent || "").match(/^Selected budget\s*[:：]\s*([^\n]+)/im) ||
+    String(taskPlanContent || "").match(/^选择预算\s*[:：]\s*([^\n]+)/im);
+  if (!match) return "standard";
+  const raw = match[1].replace(/`/g, "").trim().toLowerCase();
+  const normalized = raw.replaceAll("_", "-").replace(/\s+/g, "-");
+  if (allowedTaskBudgets.has(normalized)) return normalized;
+  if (["long-running", "longrunning", "module-parallel"].includes(normalized)) return "complex";
+  return "standard";
+}
+
+function parseMetadataLine(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 normalizeMetadataValue(value, fallback = "") {
+  const normalized = String(value || "")
+    .replace(/`/g, "")
+    .trim()
+    .toLowerCase()
+    .replaceAll("_", "-")
+    .replace(/\s+/g, "-");
+  return normalized || fallback;
+}
+
+export function parseTaskMetadata(taskPlanContent) {
+  const content = String(taskPlanContent || "");
+  const kind = normalizeMetadataValue(parseMetadataLine(content, ["Task Kind", "任务类型"]), "general");
+  const preset = normalizeMetadataValue(parseMetadataLine(content, ["Task Preset", "Preset", "任务预设"]), "none");
+  const presetVersion = parseMetadataLine(content, ["Preset Version", "预设版本"]);
+  const migrationTargetLevel = normalizeMetadataValue(
+    parseMetadataLine(content, ["Migration Target Level", "Target Level", "迁移目标等级", "目标等级"]),
+    "",
+  );
+  const migrationAchievedLevel = normalizeMetadataValue(
+    parseMetadataLine(content, ["Migration Achieved Level", "Achieved Level", "迁移实际完成等级", "实际完成等级"]),
+    "",
+  );
+  const evidenceBundle = parseMetadataLine(content, ["Evidence Bundle", "证据包"]);
+  return {
+    kind,
+    preset,
+    presetVersion,
+    migrationTargetLevel,
+    migrationAchievedLevel,
+    evidenceBundle,
+  };
+}
+
+export function parseTaskContractInfo(taskPlanContent) {
+  const content = String(taskPlanContent || "");
+  const explicit =
+    content.match(/^Task Contract\s*[:：]\s*`?([^`\n]+)`?\s*$/im) ||
+    content.match(/^任务合同\s*[:：]\s*`?([^`\n]+)`?\s*$/im);
+  const version = explicit ? explicit[1].trim() : "";
+  return {
+    version,
+    generated: version === "harness-task/v1" || content.includes(taskContractMarker),
+  };
+}
+
+export function parseTaskStateInfo(progressContent) {
+  const match = progressContent.match(/^##\s*(?:Current Status|Status|状态)\s*[:：]?\s*(?:\n\s*)?([^\n]+)/im);
+  if (!match) return inferLegacyTaskState(progressContent);
+  const raw = match[1].replace(/`/g, "").trim();
+  if (!raw || raw.includes("|") || /^[-*]\s+/.test(raw)) return inferLegacyTaskState(progressContent);
+  const aliases = new Map([
+    ["进行中", "in_progress"],
+    ["已完成", "done"],
+    ["未开始", "not_started"],
+    ["计划中", "planned"],
+    ["审查中", "review"],
+    ["已阻塞", "blocked"],
+    ["pending", "planned"],
+  ]);
+  const normalized = aliases.get(raw) || raw.toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
+  return allowedTaskStates.has(normalized)
+    ? { state: normalized, source: "explicit", raw }
+    : { state: "unknown", source: "invalid", raw };
+}
+
+function inferLegacyTaskState(progressContent) {
+  const { header, rows } = tableAfterHeading(progressContent, /^(Status|状态)$/i);
+  const statusIndex = firstColumn(header, ["Status", "状态"]);
+  if (statusIndex < 0 || rows.length === 0) return { state: "unknown", source: "missing", raw: "" };
+  const states = rows.map((row) => normalizeLegacyState(row[statusIndex])).filter(Boolean);
+  if (states.includes("blocked")) return { state: "blocked", source: "legacy-table", raw: "blocked" };
+  if (states.includes("in_progress")) return { state: "in_progress", source: "legacy-table", raw: "in_progress" };
+  if (states.includes("review")) return { state: "review", source: "legacy-table", raw: "review" };
+  if (states.length > 0 && states.every((state) => state === "done")) return { state: "done", source: "legacy-table", raw: "done" };
+  if (states.some((state) => ["planned", "not_started"].includes(state))) return { state: "planned", source: "legacy-table", raw: "planned" };
+  return { state: "unknown", source: "missing", raw: "" };
+}
+
+function normalizeLegacyState(value) {
+  const raw = String(value || "").replace(/`/g, "").trim().toLowerCase();
+  if (!raw || /^(none|n\/a|na|-|—|–|无)$/.test(raw)) return "";
+  if (/block|阻塞|blocked/.test(raw)) return "blocked";
+  if (/in[-_\s]?progress|doing|active|进行中|当前|working/.test(raw)) return "in_progress";
+  if (/review|审查|审核|验证中/.test(raw)) return "review";
+  if (/done|complete|completed|merged|closed|完成|已完成/.test(raw)) return "done";
+  if (/pending|planned|todo|not[-_\s]?started|未开始|计划/.test(raw)) return "planned";
+  return "";
+}

package/scripts/lib/task-review-model.mjs

@@ -12,10 +12,15 @@ import {
   splitMarkdownRow,
   tableAfterHeading,
 } from "./markdown-utils.mjs";
+import {
+  implementationPhases,
+  phaseHasRecordedProgress,
+} from "./phase-kind.mjs";
 import { validateReviewConfirmationGitAudit } from "./review-confirm-git-gate.mjs";
 import { isLessonCandidateDecisionComplete } from "./task-lesson-candidates.mjs";
+import { reviewConfirmationFromTaskAudit } from "./task-audit-metadata.mjs";
 
-export const taskScannerVersion = "task-scanner/2026-05-23-lifecycle-queues";
+export const taskScannerVersion = "task-scanner/2026-05-25-phase-kind";
 export const reviewFindingColumns = {
   severity: ["Severity", "严重级别", "优先级"],
   finding: ["Finding", "发现"],
@@ -158,15 +163,12 @@ export function assessMaterialsReadiness({ budget, taskDir, brief, visualMap, re
     if (!isLessonCandidateDecisionComplete(lessonCandidates)) {
       addIssue("missing-lesson-decision", `Lesson candidate decision is not complete: ${lessonCandidates.status}.`, `TARGET:${lessonCandidatesFile}`);
     }
-    const actionablePhases = (phases || []).filter((phase) => phase.state !== "skipped");
-    const hasPhaseEvidence = actionablePhases.some(
-      (phase) =>
-        phase.completion > 0 ||
-        ["in_progress", "review", "blocked", "done"].includes(String(phase.state || "").toLowerCase()) ||
-        ["partial", "present", "waived"].includes(String(phase.evidenceStatus || "").toLowerCase()),
-    );
-    if (actionablePhases.length > 0 && !hasPhaseEvidence) {
-      addIssue("phase-incomplete", "Visual Map has no phase progress or evidence yet.", `TARGET:${visualMapFile}`);
+    const actionablePhases = implementationPhases(phases || []);
+    const hasPhaseEvidence = actionablePhases.some(phaseHasRecordedProgress);
+    if ((phases || []).length > 0 && actionablePhases.length === 0) {
+      addIssue("missing-execution-phase", "Visual Map has no non-skipped execution phase.", `TARGET:${visualMapFile}`);
+    } else if (actionablePhases.length > 0 && !hasPhaseEvidence) {
+      addIssue("phase-incomplete", "Visual Map has no execution phase progress or evidence yet.", `TARGET:${visualMapFile}`);
     }
   }
   return { ready: issues.length === 0, issues };
@@ -181,7 +183,7 @@ export function requiresReviewMaterials({ state = "unknown", lifecycleState = "u
   );
 }
 
-export function deriveTaskQueues({ id, title, reviewStatus, reviewSubmission, reviewConfirmation, reviewQueueState, materialIssues, risks, stateConflicts, lessonCandidates, closeoutStatus, tombstone, taskDir, target }) {
+export function deriveTaskQueues({ id, title, state, budget, reviewStatus, reviewSubmission, reviewConfirmation, reviewQueueState, materialIssues, risks, stateConflicts, lessonCandidates, closeoutStatus, tombstone, taskDir, target }) {
   const queueReasons = [];
   const pushReason = (reason) => {
     queueReasons.push({
@@ -227,17 +229,26 @@ export function deriveTaskQueues({ id, title, reviewStatus, reviewSubmission, re
       message: "Agent Review Submission was generated by a stale scanner version.",
     });
   }
+  if (budget !== "simple" && reviewSubmission?.submitted && reviewQueueState === "needs-material" && !queueReasons.some((reason) => reason.queue === "missing-materials")) {
+    pushReason({
+      code: "review-closeout-materials-incomplete",
+      queue: "missing-materials",
+      sourcePath: "TARGET:docs/10-WALKTHROUGH/Closeout-SSoT.md",
+      message: "Agent review was submitted, but closeout materials are not ready for human confirmation.",
+    });
+  }
   const hasLessonWork = lessonCandidates?.status === "needs-promotion" || lessonCandidates?.promotionState === "queued" || lessonCandidates?.openCount > 0;
   const taskQueues = [];
   if (tombstone.deletionState !== "active") {
     taskQueues.push("soft-deleted-superseded");
   } else {
-    if ((materialIssues || []).length > 0) taskQueues.push("missing-materials");
+    if ((materialIssues || []).length > 0 || queueReasons.some((reason) => reason.queue === "missing-materials")) taskQueues.push("missing-materials");
     if (queueReasons.some((reason) => reason.queue === "blocked")) taskQueues.push("blocked");
     if (reviewSubmission?.submitted && reviewQueueState === "ready-to-confirm" && !reviewConfirmation?.confirmed && !hasLessonWork && !taskQueues.includes("blocked") && !taskQueues.includes("missing-materials")) {
       taskQueues.push("review");
     }
     if (hasLessonWork) taskQueues.push("lessons");
+    if (budget === "simple" && state === "done" && closeoutStatus === "closed") taskQueues.push("finalized");
     if (reviewStatus === "confirmed") taskQueues.push(closeoutStatus === "closed" ? "finalized" : "confirmed");
   }
   if (taskQueues.length === 0) taskQueues.push("active");
@@ -248,60 +259,34 @@ export function deriveTaskQueues({ id, title, reviewStatus, reviewSubmission, re
   };
 }
 
-export function parseReviewConfirmation(reviewContent, { taskKey = "", projectRoot = "", taskDir = "", reviewPath = "", progressPath = "" } = {}) {
-  const match = String(reviewContent || "").match(/^##\s*(?:Human Review Confirmation|人工审查确认)\s*$([\s\S]*?)(?=^##\s+|(?![\s\S]))/im);
-  if (!match) return null;
-  const fields = fieldsFromMarkdownBlock(match[1] || "");
-  const required = ["Confirmation ID", "Confirmed At", "Reviewer", "Reviewer Email", "Task Key", "Confirm Text", "Evidence Checked", "Commit SHA", "Audit Status"];
-  const missing = required.filter((field) => !isConcreteField(fields.get(field.toLowerCase())));
-  const confirmedTaskKey = fields.get("task key") || "";
-  const confirmText = fields.get("confirm text") || "";
-  const commitSha = fields.get("commit sha") || "";
-  const auditStatus = fields.get("audit status") || "";
-  const taskKeyMismatch = Boolean(taskKey && isConcreteField(confirmedTaskKey) && !taskKeysMatch(confirmedTaskKey, taskKey));
-  const confirmTextMismatch = Boolean(taskKey && isConcreteField(confirmText) && !taskKeysMatch(confirmText, taskKey));
-  const commitShaInvalid = Boolean(isConcreteField(commitSha) && !/^[0-9a-f]{7,40}$/i.test(commitSha));
-  const auditStatusInvalid = Boolean(isConcreteField(auditStatus) && auditStatus.trim().toLowerCase() !== "committed");
-  let gitAudit = null;
-  if (missing.length === 0 && !taskKeyMismatch && !confirmTextMismatch && !commitShaInvalid && !auditStatusInvalid) {
-    gitAudit = validateReviewConfirmationGitAudit({
-      projectRoot,
-      taskId: taskKey,
-      reviewPath: reviewPath || (taskDir ? path.join(taskDir, "review.md") : ""),
-      progressPath: progressPath || (taskDir ? path.join(taskDir, "progress.md") : ""),
-      commitSha,
-    });
-  }
-  const gitAuditInvalid = Boolean(gitAudit && !gitAudit.valid);
-  const invalidFields = [
-    ...(taskKeyMismatch ? ["Task Key match"] : []),
-    ...(confirmTextMismatch ? ["Confirm Text match"] : []),
-    ...(commitShaInvalid ? ["Commit SHA valid"] : []),
-    ...(auditStatusInvalid ? ["Audit Status committed"] : []),
-    ...(gitAuditInvalid ? ["Commit SHA git audit"] : []),
-  ];
-  if (fields.size > 0) {
-    return {
-      confirmed: missing.length === 0 && invalidFields.length === 0,
-      missingFields: [...missing, ...invalidFields],
-      confirmationId: fields.get("confirmation id") || "",
-      confirmedAt: fields.get("confirmed at") || "",
-      reviewer: fields.get("reviewer") || "",
-      reviewerEmail: fields.get("reviewer email") || "",
-      taskKey: confirmedTaskKey,
-      taskKeyMismatch,
-      confirmText,
-      confirmTextMismatch,
-      evidenceChecked: fields.get("evidence checked") || "",
-      commitSha,
-      commitShaInvalid,
-      auditStatus,
-      auditStatusInvalid,
-      gitAudit,
-      gitAuditInvalid,
-    };
+export function parseReviewConfirmation(reviewContent, { taskKey = "", taskAudit = null, projectRoot = "", taskDir = "", indexPath = "", reviewPath = "", progressPath = "" } = {}) {
+  if (taskAudit) {
+    const confirmation = reviewConfirmationFromTaskAudit(taskAudit, { taskKey });
+    if (
+      confirmation?.confirmed &&
+      confirmation.auditSource !== "migrated-legacy-review" &&
+      projectRoot &&
+      (indexPath || taskDir) &&
+      confirmation.commitSha
+    ) {
+      const gitAudit = validateReviewConfirmationGitAudit({
+        projectRoot,
+        taskId: taskKey,
+        reviewPath: indexPath || path.join(taskDir, "INDEX.md"),
+        progressPath: "",
+        commitSha: confirmation.commitSha,
+      });
+      return {
+        ...confirmation,
+        confirmed: confirmation.confirmed && gitAudit.valid,
+        missingFields: gitAudit.valid ? confirmation.missingFields : [...confirmation.missingFields, "Review Commit SHA git audit"],
+        gitAudit,
+        gitAuditInvalid: !gitAudit.valid,
+      };
+    }
+    return confirmation;
   }
-  return { confirmed: false, missingFields: required };
+  return null;
 }
 
 export function taskReviewStatus({ reviewContent = "", risks = [], confirmation = null, submission = null } = {}) {
@@ -327,8 +312,9 @@ export function isBlockingReviewRisk(risk) {
   return /^P[0-2]$/i.test(risk?.severity || "") && (risk.open || risk.blocksRelease);
 }
 
-export function deriveLifecycleState({ state = "unknown", reviewStatus = "missing", closeoutStatus = "missing" } = {}) {
+export function deriveLifecycleState({ state = "unknown", reviewStatus = "missing", closeoutStatus = "missing", budget = "standard" } = {}) {
   if (reviewStatus === "blocked-open-findings") return "review-blocked";
+  if (budget === "simple" && closeoutStatus === "closed") return "closed";
   if (closeoutStatus === "closed" && reviewStatus !== "confirmed") return "closed-review-pending";
   if (closeoutStatus === "closed") return "closed";
   if (state === "blocked") return "blocked";
@@ -354,12 +340,12 @@ export function deriveReviewQueueState({ state = "unknown", lifecycleState = "un
   return "ready-to-confirm";
 }
 
-export function collectStateConflicts({ state, reviewStatus, closeoutStatus, lifecycleState }) {
+export function collectStateConflicts({ state, reviewStatus, closeoutStatus, lifecycleState, budget = "standard" }) {
   const conflicts = [];
   if (state === "done" && closeoutStatus !== "closed") {
     conflicts.push({ code: "done-without-closeout", severity: "warn", message: "Task state is done, but closeout is still missing or pending." });
   }
-  if (closeoutStatus === "closed" && reviewStatus !== "confirmed") {
+  if (closeoutStatus === "closed" && reviewStatus !== "confirmed" && budget !== "simple") {
     conflicts.push({ code: "closed-without-human-review", severity: "warn", message: "Task is closed, but human review confirmation is still missing." });
   }
   if (reviewStatus === "blocked-open-findings") {