coding-agent-harness 1.0.4 → 1.0.5

package/scripts/lib/capability-registry.mjs

@@ -10,6 +10,7 @@ import {
   exists,
   existsInDocs,
   readFileSafe,
+  readJsonSafe,
   readBundledTemplate,
   walkFiles,
   normalizeLocale,
@@ -96,8 +97,9 @@ export function readCapabilityRegistry(target) {
     };
   }
 
-  try {
-    const raw = JSON.parse(fs.readFileSync(registryPath, "utf8"));
+  let readError = null;
+  const raw = readJsonSafe(registryPath, null, { onError: (error) => { readError = error; } });
+  if (raw) {
     const locale = normalizeLocale(raw.locale);
     const capabilities = Array.isArray(raw.capabilities)
       ? raw.capabilities.map((entry) =>
@@ -107,9 +109,8 @@ export function readCapabilityRegistry(target) {
         )
       : [];
     return { mode: "declared-capability", path: registryPath, capabilities, raw, locale, errors: [] };
-  } catch (error) {
-    return { mode: "declared-capability", path: registryPath, capabilities: [], raw: null, errors: [error.message] };
   }
+  return { mode: "declared-capability", path: registryPath, capabilities: [], raw: null, errors: [readError?.message || "invalid .harness-capabilities.json"] };
 }
 
 export function normalizeCapabilityName(name) {
@@ -157,7 +158,7 @@ function validateDashboardAssetAssembly(root, manifestName, assetName, driftMess
   const assetPath = path.join(assetsDir, assetName);
   if (!fs.existsSync(manifestPath) || !fs.existsSync(assetPath)) return [];
   try {
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const manifest = readJsonSafe(manifestPath, null);
     if (!Array.isArray(manifest) || manifest.length === 0) {
       return [`dashboard asset manifest must list source files: ${manifestName}`];
     }
@@ -221,7 +222,7 @@ export function buildInstallReport({ target, locale, capabilities, changes, dryR
 
 function packageVersion() {
   try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"));
+    const pkg = readJsonSafe(path.join(repoRoot, "package.json"), {});
     return pkg.version || "";
   } catch {
     return "";
@@ -261,19 +262,14 @@ function skillPackageEntries() {
 }
 
 function listPackageFiles() {
-  const files = [];
-  function walk(relativePath) {
-    const full = path.join(repoRoot, relativePath);
-    if (!fs.existsSync(full)) return;
-    const stat = fs.statSync(full);
-    if (stat.isDirectory()) {
-      for (const entry of fs.readdirSync(full)) walk(path.join(relativePath, entry));
-      return;
-    }
-    if (stat.isFile()) files.push(toPosix(relativePath));
-  }
-  for (const entry of skillPackageEntries()) walk(entry);
-  return files.sort();
+  return skillPackageEntries()
+    .flatMap((entry) => {
+      const fullPath = path.join(repoRoot, entry);
+      if (!fs.existsSync(fullPath)) return [];
+      if (fs.statSync(fullPath).isFile()) return [toPosix(path.relative(repoRoot, fullPath))];
+      return walkFiles(fullPath).map((file) => toPosix(path.relative(repoRoot, file)));
+    })
+    .sort();
 }
 
 function copySkillPackage(targetRoot, { dryRun = false, force = false } = {}) {
@@ -324,7 +320,7 @@ export function installUserSkill({ agent = "codex", home = "", dryRun = false, f
 
 function readInstalledVersion(targetRoot) {
   try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(targetRoot, "package.json"), "utf8"));
+    const pkg = readJsonSafe(path.join(targetRoot, "package.json"), {});
     return pkg.version || "";
   } catch {
     return "";
@@ -536,7 +532,7 @@ function initNextCommands() {
 function writeNpmScripts(target, { dryRun = true } = {}) {
   const packagePath = path.join(target.projectRoot, "package.json");
   if (!fs.existsSync(packagePath)) throw new Error("init --add-npm-scripts requires an existing package.json");
-  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  const pkg = readJsonSafe(packagePath, {});
   const scripts = { ...(pkg.scripts || {}) };
   const additions = {
     "harness:dev": "coding-agent-harness dev .",

package/scripts/lib/check-module-parallel.mjs

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { walkFiles } from "./core-shared.mjs";
 
 function stripMarkdownCode(value) {
   return String(value || "").replace(/`/g, "").trim();
@@ -17,22 +18,14 @@ function modulePromptBlock(content, key) {
 function listModuleTaskPlans({ targetRoot, rel, filePath }) {
   const modulesRoot = filePath("docs/09-PLANNING/MODULES");
   if (!fs.existsSync(modulesRoot)) return [];
-  const results = [];
-  function walk(dir) {
-    for (const entry of fs.readdirSync(dir)) {
-      const full = path.join(dir, entry);
-      const relativePath = rel(path.relative(targetRoot, full));
-      const stat = fs.statSync(full);
-      if (stat.isDirectory()) {
-        if (relativePath.includes("/_archive/") || relativePath.endsWith("/_task-template")) continue;
-        walk(full);
-      } else if (/\/TASKS\/[^/]+\/task_plan\.md$/.test(relativePath)) {
-        results.push(relativePath);
-      }
-    }
-  }
-  walk(modulesRoot);
-  return results;
+  return walkFiles(modulesRoot, {
+    dirFilter: (_dirName, fullPath) => {
+      const relativePath = rel(path.relative(targetRoot, fullPath));
+      return !relativePath.includes("/_archive/") && !relativePath.endsWith("/_task-template");
+    },
+  })
+    .map((file) => rel(path.relative(targetRoot, file)))
+    .filter((relativePath) => /\/TASKS\/[^/]+\/task_plan\.md$/.test(relativePath));
 }
 
 function parseModuleTaskPath(taskPlanPath) {

package/scripts/lib/check-profiles.mjs

@@ -22,26 +22,19 @@ import {
   firstColumn,
   contentHasAny,
 } from "./markdown-utils.mjs";
-import { capabilityDefinitions, validateCapabilities } from "./capability-registry.mjs";
+import { validateCapabilities } from "./capability-registry.mjs";
 import { readPresetPackage } from "./preset-registry.mjs";
 import { validateTaskPresetAuditSnapshot } from "./preset-audit-contracts.mjs";
 import { validatePresetResourcesForTask } from "./preset-resource-contracts.mjs";
-import {
-  collectTasks,
-  listTaskPlanPaths,
-  readVisualMapContractFile,
-  parsePhases,
-  taskCutoverCounters,
-} from "./task-scanner.mjs";
-import {
-  normalizeReviewBoolean,
-  reviewFindingColumns,
-} from "./task-review-model.mjs";
+import { collectTasks, listTaskPlanPaths, parseTaskBudget, readVisualMapContractFile, parsePhases } from "./task-scanner.mjs";
+import { normalizeReviewBoolean, reviewFindingColumns } from "./task-review-model.mjs";
+import { allowedPhaseActors, allowedPhaseKinds } from "./phase-kind.mjs";
 import { validateTaskCompletionConsistency } from "./task-completion-consistency.mjs";
 import { validatePlanContracts } from "./check-task-contracts.mjs";
 import { validateGovernanceTableBoundaries } from "./governance-table-boundary.mjs";
 import { validateSubagentAuthorization } from "./subagent-authorization-audit.mjs";
 import { summarizeGitState } from "./git-status-summary.mjs";
+import { buildStatusData } from "./status-builder.mjs";
 export { renderDashboard } from "./status-dashboard-renderer.mjs";
 
 export function runLegacyCheck(target) {
@@ -144,10 +137,10 @@ export function validateReviewSchema(target, { strict = true } = {}) {
   return { failures, warnings };
 }
 
-export function validateVisualMaps(target) {
+export function validateVisualMaps(target, { taskPlanPaths } = {}) {
   const failures = [];
   const warnings = [];
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
+  for (const taskPlanPath of taskPlanPaths || listTaskPlanPaths(target)) {
     const taskDir = path.dirname(taskPlanPath);
     const visualMapPath = path.join(taskDir, visualMapFile);
     const legacyPath = path.join(taskDir, legacyVisualRoadmapFile);
@@ -161,7 +154,10 @@ export function validateVisualMaps(target) {
       }
     }
     const phases = parsePhases(visualMap.content);
+    const budget = parseTaskBudget(taskPlan);
     for (const phase of phases) {
+      if (!allowedPhaseKinds.has(phase.kind)) failures.push(`${relative} phase ${phase.id} invalid kind: ${phase.kind}`);
+      if (!allowedPhaseActors.has(phase.actor)) failures.push(`${relative} phase ${phase.id} invalid actor: ${phase.actor}`);
       if (!allowedPhaseStates.has(phase.state)) failures.push(`${relative} phase ${phase.id} invalid state: ${phase.state}`);
       if (!allowedEvidenceStatus.has(phase.evidenceStatus)) {
         failures.push(`${relative} phase ${phase.id} invalid evidence status: ${phase.evidenceStatus}`);
@@ -176,6 +172,9 @@ export function validateVisualMaps(target) {
       failures.push(`${relative} missing Visual Map Contract: v1.0`);
     }
     if (visualMap.source === "canonical" && phases.length === 0) warnings.push(`${relative} has no Visual Map phase table`);
+    if (visualMap.source === "canonical" && budget !== "simple" && phases.length > 0 && !phases.some((phase) => phase.kind === "execution" && phase.state !== "skipped")) {
+      failures.push(`${relative} requires at least one non-skipped execution phase`);
+    }
     if (visualMap.source === "legacy" && fs.existsSync(legacyPath)) {
       warnings.push(`${relative} missing; legacy visual_roadmap.md is rewrite input only`);
     } else if (visualMap.source === "legacy" && phases.length > 0) {
@@ -185,7 +184,7 @@ export function validateVisualMaps(target) {
   return { failures, warnings };
 }
 
-export function validateTaskPresetContracts(target) {
+export function validateTaskPresetContracts(target, { tasks } = {}) {
   const failures = [];
   const allowedMigrationLevels = new Set([
     "migration-baseline",
@@ -193,7 +192,7 @@ export function validateTaskPresetContracts(target) {
     "migration-full-cutover",
     "migration-deferred",
   ]);
-  for (const task of collectTasks(target)) {
+  for (const task of tasks || collectTasks(target)) {
     if (!task.taskPreset || task.taskPreset === "none") continue;
     let presetPackage = null;
     try {
@@ -326,10 +325,13 @@ export function buildStatus(targetInput, options = {}) {
   const shouldRunLegacy = !options.skipLegacyCheck && (capabilityState.registry.mode === "legacy-compat" || safeAdoptionMode);
   const legacy = shouldRunLegacy ? runLegacyCheck(target) : { status: "skipped", code: 0, stdout: "", stderr: "" };
   const contractStrict = Boolean(options.strict) || (capabilityState.registry.mode !== "legacy-compat" && !safeAdoptionMode);
+  const taskPlanPaths = listTaskPlanPaths(target);
+  const closeoutContent = readFileSafe(path.join(target.docsRoot, "10-WALKTHROUGH/Closeout-SSoT.md"));
+  const tasks = collectTasks(target, { requireGeneratedScaffoldProvenance: contractStrict, taskPlanPaths, closeoutContent });
   const reviews = validateReviewSchema(target, { strict: contractStrict });
-  const visualMaps = validateVisualMaps(target);
-  const planContracts = validatePlanContracts(target, { strict: contractStrict });
-  const presetContracts = validateTaskPresetContracts(target);
+  const visualMaps = validateVisualMaps(target, { taskPlanPaths });
+  const planContracts = validatePlanContracts(target, { strict: contractStrict, taskPlanPaths });
+  const presetContracts = validateTaskPresetContracts(target, { tasks });
   const contextDocs = validateContextDocs(target, { strict: contractStrict });
   const governanceBoundaries = validateGovernanceTableBoundaries(target);
   const subagentAuthorization = validateSubagentAuthorization(target, { strict: contractStrict });
@@ -340,79 +342,31 @@ export function buildStatus(targetInput, options = {}) {
     else warnings.push(`adoption-needed: legacy check failed: ${(legacy.stderr || legacy.stdout).trim()}`);
   }
 
-  const tasks = collectTasks(target);
   const taskCompletionConsistency = validateTaskCompletionConsistency(tasks);
   failures.push(...taskCompletionConsistency.failures);
   warnings.push(...taskCompletionConsistency.warnings);
   const briefReady = tasks.filter((task) => task.briefSource === "standalone").length;
   const briefMissing = tasks.length - briefReady;
   for (const task of tasks) {
+    for (const issue of task.materialIssues || []) {
+      if (!String(issue.code || "").startsWith("missing-task-audit") && !String(issue.code || "").startsWith("legacy-")) continue;
+      const message = `${String(issue.sourcePath || task.path).replace(/^TARGET:/, "")} ${issue.message}`;
+      if (contractStrict || options.strictLegacy) failures.push(message);
+      else warnings.push(`adoption-needed: ${message}`);
+    }
     if (task.stateSource === "invalid") {
       const message = `${task.path}/progress.md invalid task state: ${task.stateRaw}`;
       if (contractStrict || options.strictLegacy) failures.push(message);
       else warnings.push(`adoption-needed: ${message}`);
     }
   }
-  const capabilityNames = new Map(capabilityState.registry.capabilities.map((capability) => [capability.name, capability]));
-  for (const detected of capabilityState.detected) {
-    if (!capabilityNames.has(detected)) capabilityNames.set(detected, { name: detected, state: "configured" });
-  }
-  const cutoverCounters = taskCutoverCounters(tasks);
-  const fullCutoverEligible =
-    failures.length === 0 &&
-    warnings.length === 0 &&
-    cutoverCounters.legacyVisualOnlyCount === 0 &&
-    cutoverCounters.unknownClassificationCount === 0 &&
-    cutoverCounters.weakBriefCount === 0 &&
-    cutoverCounters.missingCanonicalVisualMapCount === 0;
-
-  return {
-    project: {
-      name: path.basename(target.projectRoot),
-      root: `TARGET:${target.docsOnly ? toPosix(path.relative(target.projectRoot, target.docsRoot)) : "."}`,
-      docsOnly: target.docsOnly,
-    },
-    schemaVersion: 2,
-    generatedAt: new Date().toISOString(),
-    mode: capabilityState.registry.mode,
-    checkState: {
-      status: failures.length > 0 ? "fail" : warnings.length > 0 ? "warn" : "pass",
-      failures: failures.length,
-      warnings: warnings.length,
-      details: { failures, warnings },
-      legacy,
-    },
-    git: gitState.summary,
-    summary: {
-      tasks: tasks.length,
-      briefCoverage: {
-        ready: briefReady,
-        missing: briefMissing,
-        total: tasks.length,
-      },
-      visualMapCoverage: {
-        canonical: tasks.filter((task) => task.visualMapSource === "canonical").length,
-        legacyOnly: cutoverCounters.legacyVisualOnlyCount,
-        missing: tasks.filter((task) => task.visualMapStatus === "missing").length,
-        total: tasks.length,
-      },
-      fullCutoverEligible,
-      legacyVisualOnlyCount: cutoverCounters.legacyVisualOnlyCount,
-      unknownClassificationCount: cutoverCounters.unknownClassificationCount,
-      weakBriefCount: cutoverCounters.weakBriefCount,
-      visualMapRequiredCount: cutoverCounters.visualMapRequiredCount,
-      missingCanonicalVisualMapCount: cutoverCounters.missingCanonicalVisualMapCount,
-    },
-    capabilities: [...capabilityNames.values()].map((capability) => ({
-      name: capability.name,
-      state: capability.state || "configured",
-      dependencyStatus: capabilityDefinitions[capability.name]?.dependencies.every((dependency) => capabilityNames.has(dependency))
-        ? "valid"
-        : "invalid",
-      warnings: capabilityState.warnings.filter((warning) => warning.includes(capability.name)),
-    })),
+  return buildStatusData(target, {
+    capabilityState,
+    gitState,
+    legacy,
+    failures,
+    warnings,
     tasks,
-    handoffs: tasks.flatMap((task) => task.handoffs || []),
-    recentActivity: tasks.slice(0, 8).map((task) => ({ at: new Date().toISOString(), type: "task", summary: task.title })),
-  };
+    validationMode: "validated",
+  });
 }

package/scripts/lib/check-task-contracts.mjs

@@ -11,24 +11,32 @@ import {
   parseTaskBudget,
   parseTaskContractInfo,
 } from "./task-scanner.mjs";
+import { parseTaskAuditMetadata } from "./task-audit-metadata.mjs";
 
-export function validatePlanContracts(target, { strict = true } = {}) {
+export function validatePlanContracts(target, { strict = true, taskPlanPaths } = {}) {
   const failures = [];
   const warnings = [];
   const report = (message) => {
     if (strict) failures.push(message);
     else warnings.push(`adoption-needed: ${message}`);
   };
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
+  for (const taskPlanPath of taskPlanPaths || listTaskPlanPaths(target)) {
     const taskDir = path.dirname(taskPlanPath);
     const relativeDir = toPosix(path.relative(target.projectRoot, taskDir));
     const taskPlanContent = readFileSafe(taskPlanPath);
+    const indexContent = readFileSafe(path.join(taskDir, "INDEX.md"));
     const budget = parseTaskBudget(taskPlanContent);
     const taskContract = parseTaskContractInfo(taskPlanContent);
+    const taskAudit = parseTaskAuditMetadata(indexContent, { required: strict && taskContract.generated });
     if (!taskContract.generated) {
       warnings.push(`adoption-needed: ${relativeDir} missing Task Contract: harness-task/v1 marker`);
     }
-    for (const fileName of requiredTaskFilesForBudget(budget)) {
+    for (const issue of taskAudit.issues) {
+      if (taskContract.generated || taskAudit.present) failures.push(`${relativeDir}/INDEX.md ${issue.message}`);
+      else report(`${relativeDir}/INDEX.md ${issue.message}`);
+    }
+    const indexRequired = /^Task Package Index\s*[:：]\s*(required|yes|true|必需|必须|required)\s*$/im.test(taskPlanContent);
+    for (const fileName of requiredTaskFilesForBudget(budget, { indexRequired })) {
       if (!fs.existsSync(path.join(taskDir, fileName))) {
         if (taskContract.generated) failures.push(`${relativeDir} missing ${fileName}`);
         else report(`${relativeDir} missing ${fileName}`);
@@ -38,8 +46,8 @@ export function validatePlanContracts(target, { strict = true } = {}) {
   return { failures, warnings };
 }
 
-function requiredTaskFilesForBudget(budget) {
-  const simpleFiles = ["brief.md", "task_plan.md", visualMapFile, "progress.md"];
+function requiredTaskFilesForBudget(budget, { indexRequired = false } = {}) {
+  const simpleFiles = [...(indexRequired ? ["INDEX.md"] : []), "brief.md", "task_plan.md", visualMapFile, "progress.md"];
   if (budget === "simple") return simpleFiles;
   const standardFiles = [...simpleFiles, "execution_strategy.md", "findings.md", lessonCandidatesFile, "review.md"];
   if (budget === "complex") return [...standardFiles, "references/INDEX.md", "artifacts/INDEX.md"];

package/scripts/lib/core-shared.mjs

@@ -70,6 +70,15 @@ export function readFileSafe(filePath) {
   }
 }
 
+export function readJsonSafe(filePath, fallback = null, { onError } = {}) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (typeof onError === "function") onError(error);
+    return fallback;
+  }
+}
+
 export function readBundledTemplate(source) {
   const sourcePath = path.join(repoRoot, source);
   if (!fs.existsSync(sourcePath)) throw new Error(`Bundled template missing: ${source}`);
@@ -78,15 +87,17 @@ export function readBundledTemplate(source) {
   return content;
 }
 
-export function walkFiles(root) {
+export function walkFiles(root, options = {}) {
   const results = [];
   if (!fs.existsSync(root)) return results;
+  const dirFilter = typeof options.dirFilter === "function" ? options.dirFilter : () => true;
   function walk(dir) {
     for (const entry of fs.readdirSync(dir)) {
       const full = path.join(dir, entry);
       const stat = fs.statSync(full);
       if (stat.isDirectory()) {
         if ([".git", "node_modules", "tmp"].includes(entry)) continue;
+        if (!dirFilter(entry, full)) continue;
         walk(full);
       } else {
         results.push(full);
@@ -180,14 +191,56 @@ export function normalizeTaskId(value) {
   return slug(value || "task");
 }
 
-export function renderTaskTemplate(content, { taskId, title, locale, budget = "standard" }) {
+export function renderTaskTemplate(content, { taskId, title, locale, budget = "standard", moduleKey = "", preset = "none", presetVersion = "", evidenceBundle = "", longRunning = false, scaffoldProvenance = {}, taskAudit = {} }) {
   const date = todayDate();
+  const provenance = {
+    createdBy: scaffoldProvenance.createdBy || "harness new-task",
+    command: scaffoldProvenance.command || "harness new-task [task-id] <target>",
+    createdAt: scaffoldProvenance.createdAt || date,
+    budget: scaffoldProvenance.budget || budget,
+    templateSource: scaffoldProvenance.templateSource || "templates/planning/brief.md",
+    exceptionReason: scaffoldProvenance.exceptionReason || "n/a",
+  };
   return String(content)
     .replaceAll("{{TASK_ID}}", taskId)
     .replaceAll("{{TASK_TITLE}}", title)
     .replaceAll("{{DATE}}", date)
     .replaceAll("{{LOCALE}}", normalizeLocale(locale))
     .replaceAll("{{TASK_BUDGET}}", budget)
+    .replaceAll("{{TASK_MODULE}}", moduleKey || "n/a")
+    .replaceAll("{{TASK_PRESET}}", preset || "none")
+    .replaceAll("{{TASK_PRESET_VERSION}}", presetVersion || "n/a")
+    .replaceAll("{{TASK_EVIDENCE_BUNDLE}}", evidenceBundle || "n/a")
+    .replaceAll("{{TASK_LONG_RUNNING}}", longRunning ? "yes" : "no")
+    .replaceAll("{{SCAFFOLD_CREATED_BY}}", provenance.createdBy)
+    .replaceAll("{{SCAFFOLD_COMMAND}}", provenance.command)
+    .replaceAll("{{SCAFFOLD_CREATED_AT}}", provenance.createdAt)
+    .replaceAll("{{SCAFFOLD_BUDGET}}", provenance.budget)
+    .replaceAll("{{SCAFFOLD_TEMPLATE_SOURCE}}", provenance.templateSource)
+    .replaceAll("{{SCAFFOLD_EXCEPTION_REASON}}", provenance.exceptionReason)
+    .replaceAll("{{TASK_AUDIT_CREATED_BY}}", taskAudit["Created By"] || provenance.createdBy)
+    .replaceAll("{{TASK_AUDIT_CREATED_AT}}", taskAudit["Created At"] || provenance.createdAt)
+    .replaceAll("{{TASK_AUDIT_COMMAND_SHAPE}}", taskAudit["Command Shape"] || provenance.command)
+    .replaceAll("{{TASK_AUDIT_BUDGET}}", taskAudit.Budget || provenance.budget)
+    .replaceAll("{{TASK_AUDIT_TEMPLATE_SOURCE}}", taskAudit["Template Source"] || provenance.templateSource)
+    .replaceAll("{{TASK_AUDIT_TASK_CREATOR}}", taskAudit["Task Creator"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_TASK_CREATOR_SOURCE}}", taskAudit["Task Creator Source"] || "git-unavailable")
+    .replaceAll("{{TASK_AUDIT_HUMAN_REVIEW_STATUS}}", taskAudit["Human Review Status"] || "not-confirmed")
+    .replaceAll("{{TASK_AUDIT_CONFIRMATION_ID}}", taskAudit["Confirmation ID"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_CONFIRMED_AT}}", taskAudit["Confirmed At"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEWER}}", taskAudit.Reviewer || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEWER_EMAIL}}", taskAudit["Reviewer Email"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_CONFIRM_TEXT}}", taskAudit["Confirm Text"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_EVIDENCE_CHECKED}}", taskAudit["Evidence Checked"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEW_COMMIT_SHA}}", taskAudit["Review Commit SHA"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_AUDIT_SOURCE}}", taskAudit["Audit Source"] || "native-index")
+    .replaceAll("{{TASK_AUDIT_AUDIT_STATUS}}", taskAudit["Audit Status"] || "created")
+    .replaceAll("{{TASK_AUDIT_EXCEPTION_REASON}}", taskAudit["Exception Reason"] || provenance.exceptionReason)
+    .replaceAll("{{TASK_AUDIT_MESSAGE}}", taskAudit.Message || "n/a")
+    .replaceAll("{{TASK_AUDIT_MIGRATION_STATUS}}", taskAudit["Migration Status"] || "native")
+    .replaceAll("{{TASK_AUDIT_MIGRATED_FROM}}", taskAudit["Migrated From"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_LEGACY_EXTRA_FIELDS}}", taskAudit["Legacy Extra Fields"] || "{}")
+    .replaceAll("{{TASK_AUDIT_MIGRATION_NOTES}}", taskAudit["Migration Notes"] || "n/a")
     .replaceAll("[simple / standard / complex]", budget)
     .replaceAll("[simple / standard / long-running / module-parallel]", budget)
     .replaceAll("[simple / complex]", budget)