@mstar-harness/engine 3.10.2 → 3.11.0

package/dist/engine.js

@@ -623,7 +623,7 @@ function validatePlanProgress(value, what = "coordination.progress") {
   }
   return violations;
 }
-function validatePlanHandoff(value, what = "coordination.handoff") {
+function validatePlanHandoff(value, what = "coordination.handoff", route = "integration") {
   if (!isPlainObject2(value))
     return [invalid("coordination.row.handoff-shape", `${what} must be an object`)];
   const allowed = [
@@ -763,7 +763,25 @@ function validatePlanHandoff(value, what = "coordination.handoff") {
     }
   }
   if ((value.state === "integrating" || value.state === "merged" || value.state === "completed") && value.integration === undefined) {
-    violations.push(invalid("coordination.row.handoff-field", `${what}.state ${String(value.state)} requires integration`));
+    if (route === "standalone-development" && value.state === "completed") {
+      if (value.completed_at === undefined) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.state completed requires completed_at for a standalone handoff`));
+      }
+      if (!isNonEmptyString(value.accepted_at)) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.accepted_at is required for a standalone completed handoff`));
+      }
+      if (!isNonEmptyString(value.accepted_by)) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.accepted_by is required for a standalone completed handoff`));
+      }
+      if (value.qc === undefined) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qc is required for a standalone completed handoff`));
+      }
+      if (value.qa === undefined) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qa is required for a standalone completed handoff`));
+      }
+    } else {
+      violations.push(invalid("coordination.row.handoff-field", `${what}.state ${String(value.state)} requires integration`));
+    }
   }
   return violations;
 }
@@ -799,7 +817,7 @@ function validatePreparedCoordination(value, what = "coordination.prepared") {
   }
   return violations;
 }
-function validateRowCoordination(value, what = "coordination") {
+function validateRowCoordination(value, what = "coordination", route = "integration") {
   if (!isPlainObject2(value))
     return [invalid("coordination.row.shape", `${what} must be an object`)];
   const allowed = ["revision", "prepared", "session", "progress", "handoff"];
@@ -818,7 +836,7 @@ function validateRowCoordination(value, what = "coordination") {
   if (value.progress !== undefined)
     violations.push(...validatePlanProgress(value.progress, `${what}.progress`));
   if (value.handoff !== undefined)
-    violations.push(...validatePlanHandoff(value.handoff, `${what}.handoff`));
+    violations.push(...validatePlanHandoff(value.handoff, `${what}.handoff`, route));
   if (value.handoff !== undefined && value.session === undefined) {
     violations.push(invalid("coordination.row.handoff-field", `${what}.handoff requires a bound plan session`));
   }
@@ -1331,6 +1349,45 @@ var WORKFLOW_TERMINAL_STATUSES = ["completed", "failed", "stopped"];
 var WORKFLOW_LIFECYCLE_TYPES = ["plan", "iteration"];
 var WORKFLOW_DELIVERY_KINDS = ["development", "verification/report-only"];
 var WORKFLOW_COMPOUND_OUTCOMES = ["created", "updated", "skipped"];
+function isStandaloneDevelopmentWorkflow(snapshot) {
+  return snapshot.type === "plan" && snapshot.delivery_kind === "development" && Array.isArray(snapshot.plans) && snapshot.plans.length === 1;
+}
+function rowValidationRoute(snapshot, row) {
+  if (isStandaloneDevelopmentWorkflow(snapshot) && snapshot.plans[0]?.id === row.id) {
+    return "standalone-development";
+  }
+  return "integration";
+}
+function validateStandaloneCompletedCoherence(snapshot, row) {
+  const violations = [];
+  if (!isStandaloneDevelopmentWorkflow(snapshot) || row.id !== snapshot.plans[0]?.id)
+    return violations;
+  const coordination = row.coordination;
+  if (!isPlainObject2(coordination) || !isPlainObject2(coordination.handoff))
+    return violations;
+  const handoff = coordination.handoff;
+  if (handoff.state !== "completed" || handoff.integration !== undefined)
+    return violations;
+  if (row.status !== "Done") {
+    violations.push(violation3("high", "coordination.row.handoff-field", `standalone completed handoff requires row ${String(row.id)} to be Done`));
+  }
+  if (row.execution_lease !== undefined) {
+    violations.push(violation3("high", "coordination.row.handoff-field", `standalone completed handoff requires no execution lease on row ${String(row.id)}`));
+  }
+  if (snapshot.integration_merge_lease !== undefined) {
+    violations.push(violation3("high", "coordination.row.handoff-field", "standalone completed handoff requires no integration_merge_lease on the snapshot"));
+  }
+  const source = snapshot.branch?.source;
+  const target = snapshot.branch?.target;
+  if (!isNonEmptyString(source) || !isNonEmptyString(target)) {
+    violations.push(violation3("high", "coordination.row.handoff-field", "standalone completed handoff requires nonblank branch.source and branch.target"));
+  } else {
+    if (handoff.source_branch !== source) {
+      violations.push(violation3("high", "coordination.row.handoff-field", `standalone completed handoff source_branch ${String(handoff.source_branch)} must equal branch.source ${source}`));
+    }
+  }
+  return violations;
+}
 function stableJson(value) {
   if (Array.isArray(value))
     return `[${value.map(stableJson).join(",")}]`;
@@ -1450,13 +1507,17 @@ function validateWorkflowSnapshot(doc) {
   } else if (!Array.isArray(doc.plans)) {
     violations.push(violation3("high", "workflow.snapshot.invalid-plans", "plans must be an array of legacy plan rows"));
   } else {
+    const snapshotDoc = doc;
     for (const row of doc.plans) {
       violations.push(...validatePlanRow(row).violations);
       if (isPlainObject2(row) && row.execution_lease !== undefined) {
         violations.push(...validateExecutionLease(row.execution_lease).violations);
       }
       if (isPlainObject2(row) && row.coordination !== undefined) {
-        violations.push(...validateRowCoordination(row.coordination, `plans[${String(row.id)}].coordination`));
+        const planRow = row;
+        const route = rowValidationRoute(snapshotDoc, planRow);
+        violations.push(...validateRowCoordination(row.coordination, `plans[${String(row.id)}].coordination`, route));
+        violations.push(...validateStandaloneCompletedCoherence(snapshotDoc, planRow));
       }
     }
   }
@@ -2023,6 +2084,158 @@ async function registerPlanWorkflow(workflowId, options) {
     return { workflowId, snapshotPath, recovered: false };
   });
 }
+function iterationWorkflowRegistrationIdentity(snapshot) {
+  const coordinator = snapshot.coordination?.coordinator;
+  return stableJson({
+    id: snapshot.id,
+    type: snapshot.type,
+    status: snapshot.status,
+    compass_ref: snapshot.compass_ref ?? null,
+    branch: snapshot.branch ?? null,
+    project: snapshot.project ?? null,
+    plans: snapshot.plans,
+    coordinator: coordinator ? { session_id: coordinator.session_id, session_file: coordinator.session_file } : null
+  });
+}
+async function registerIterationWorkflow(workflowId, options) {
+  const refuse = (detail) => new Error(`registerIterationWorkflow: ${detail}`);
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw refuse("options must be an object (harnessDir, compassRef, branch, rows)");
+  }
+  if (typeof options.harnessDir !== "string" || options.harnessDir.trim() === "") {
+    throw refuse("options.harnessDir is required (must contain status.json + workflows/)");
+  }
+  assertSafePathComponent(workflowId, "workflow id");
+  if (typeof options.compassRef !== "string" || options.compassRef.trim() === "") {
+    throw refuse("options.compassRef must be a non-empty string");
+  }
+  if (typeof options.branch !== "object" || options.branch === null || Array.isArray(options.branch)) {
+    throw refuse("options.branch must be an object (base, integration, target)");
+  }
+  for (const anchor of ["base", "integration", "target"]) {
+    const value = options.branch[anchor];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw refuse(`options.branch.${anchor} must be a non-empty string`);
+    }
+  }
+  if (options.project !== undefined && (typeof options.project !== "string" || options.project.trim() === "")) {
+    throw refuse("options.project must be a non-empty string when given");
+  }
+  const rows = options.rows;
+  if (!Array.isArray(rows) || rows.length === 0) {
+    throw refuse("options.rows must be a non-empty array of { id, title, file }");
+  }
+  const seenRowIds = new Set;
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw refuse("each row must be an object ({ id, title, file })");
+    }
+    for (const field of ["id", "title", "file"]) {
+      if (typeof row[field] !== "string" || row[field].trim() === "") {
+        throw refuse(`each row.${field} must be a non-empty string`);
+      }
+    }
+    if ("status" in row) {
+      throw refuse(`row ${JSON.stringify(row.id)} supplies a status — rows are always written status "Todo"; ` + "a state transition is requested through the lifecycle seams, never at registration");
+    }
+    if (seenRowIds.has(row.id)) {
+      throw refuse(`duplicate row id ${JSON.stringify(row.id)} — plan row ids are unique per workflow`);
+    }
+    seenRowIds.add(row.id);
+  }
+  const startedAt = options.startedAt ?? new Date().toISOString();
+  if (!isCloseTimestamp(startedAt)) {
+    throw refuse("options.startedAt must be a valid YYYY-MM-DD date or RFC3339 timestamp");
+  }
+  const harnessDir = resolve6(options.harnessDir);
+  const statusPath = join6(harnessDir, "status.json");
+  const workflowDir = join6(harnessDir, "workflows", workflowId);
+  const snapshotPath = join6(workflowDir, WORKFLOW_SNAPSHOT_FILE);
+  const store = getArtifactStore();
+  const snapshot = {
+    schema_version: 1,
+    id: workflowId,
+    type: "iteration",
+    status: "running",
+    started_at: startedAt,
+    updated_at: startedAt.slice(0, 10),
+    compass_ref: options.compassRef,
+    branch: { base: options.branch.base, integration: options.branch.integration, target: options.branch.target },
+    plans: rows.map((r) => ({
+      id: r.id,
+      title: r.title,
+      file: r.file,
+      status: "Todo",
+      metadata: {
+        iteration_refs: [options.compassRef],
+        spec_integration_branch: options.branch.integration,
+        merge_target: options.branch.integration
+      }
+    }))
+  };
+  if (options.project !== undefined)
+    snapshot.project = options.project;
+  const entry = {
+    id: workflowId,
+    type: "iteration",
+    started_at: snapshot.started_at,
+    dir: `workflows/${workflowId}`
+  };
+  const entryGate = validateWorkflowEntry(entry);
+  if (!entryGate.ok) {
+    throw new Error(`refusing to register invalid workflow entry: ${entryGate.violations.map((v) => v.message).join("; ")}`);
+  }
+  return withStatusWriteLock(statusPath, async () => {
+    const rootDoc = readJson(statusPath);
+    const workflows = Array.isArray(rootDoc.workflows) ? rootDoc.workflows : [];
+    if (workflows.some((candidate) => isPlainObject2(candidate) && candidate.id === workflowId)) {
+      throw new Error(`refusing to register workflow ${JSON.stringify(workflowId)}: it is already registered ` + `(root entry in ${statusPath}) — registration is create-only; ` + "remove that workflow before registering again");
+    }
+    if (existsSync4(snapshotPath)) {
+      const existing = readWorkflowSnapshot(workflowDir);
+      if (existing.snapshot.id !== workflowId || iterationWorkflowRegistrationIdentity(existing.snapshot) !== iterationWorkflowRegistrationIdentity(snapshot)) {
+        throw new Error(`refusing to register workflow ${JSON.stringify(workflowId)}: snapshot ${snapshotPath} already exists ` + "with a different registration identity — remove that workflow or register under a different id");
+      }
+      const recoveryEntry = {
+        id: workflowId,
+        type: "iteration",
+        started_at: existing.snapshot.started_at,
+        dir: `workflows/${workflowId}`
+      };
+      const recoveryGate = validateWorkflowEntry(recoveryEntry);
+      if (!recoveryGate.ok) {
+        throw new Error(`refusing to register invalid workflow entry: ${recoveryGate.violations.map((v) => v.message).join("; ")}`);
+      }
+      await registerWorkflowEntryLocked(statusPath, recoveryEntry);
+      return { workflowId, snapshotPath, recovered: true };
+    }
+    let createdVersion;
+    try {
+      await writeWorkflowSnapshot(snapshot, workflowDir, { createOnly: true });
+      createdVersion = readArtifactBytes(snapshotPath)?.version;
+      await registerWorkflowEntryLocked(statusPath, entry);
+    } catch (error) {
+      if (createdVersion !== undefined) {
+        await withStatusWriteLock(snapshotPath, async () => {
+          const current = readArtifactBytes(snapshotPath);
+          if (current === undefined || current.version !== createdVersion)
+            return;
+          const remove = store.delete?.bind(store);
+          if (remove !== undefined) {
+            await withProtectedWrite(snapshotPath, "delete", () => remove({ kind: "snapshot", key: workflowId }));
+          }
+        });
+      }
+      try {
+        if (readdirSync2(workflowDir).length === 0) {
+          rmdirSync2(workflowDir);
+        }
+      } catch {}
+      throw error;
+    }
+    return { workflowId, snapshotPath, recovered: false };
+  });
+}
 
 // src/status.ts
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -7566,6 +7779,176 @@ function slugify(title) {
 }
 var escapeCell = (value) => value.replace(/\|/g, "\\|");
 var truncate = (value, max) => value.length > max ? `${value.slice(0, max)}…` : value;
+var collapseEvidenceWs = (value) => value.replace(/\s*[\r\n]\s*/g, " ");
+var evidenceText = (item) => typeof item === "string" ? item : `${item.file}${item.line !== undefined ? `:${item.line}` : ""} — ${item.description}`;
+var hasEnrichedMetadata = (finding) => finding.fingerprint !== undefined || finding.trace !== undefined || finding.severity !== undefined || finding.evidence.some((item) => typeof item !== "string");
+var AUDIT_FINGERPRINT_RE = /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*(?![\s\S])/;
+var AUDIT_SEVERITY_ORDER = { informational: 0, low: 1, medium: 2, high: 3, critical: 4 };
+var DEFAULT_IGNORABLE_RE = /[\u00AD\u034F\u061C\u115F\u1160\u17B4\u17B5\u180B-\u180F\u200B-\u200F\u202A-\u202E\u2060-\u206F\u3164\uFE00-\uFE0F\uFEFF\uFFA0\uFFF0-\uFFF8\u{1BCA0}-\u{1BCA3}\u{1D173}-\u{1D17A}\u{E0000}-\u{E0FFF}]/u;
+var LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+var isPlainObject9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isVisibleText(value) {
+  if (LONE_SURROGATE_RE.test(value))
+    return false;
+  for (const ch of value) {
+    if (!/\p{White_Space}/u.test(ch) && !DEFAULT_IGNORABLE_RE.test(ch))
+      return true;
+  }
+  return false;
+}
+function safeAuditPath(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value === "")
+    return false;
+  if (value.includes("\\"))
+    return false;
+  if (/[\u0000-\u001F\u007F-\u009F]/.test(value))
+    return false;
+  if (LONE_SURROGATE_RE.test(value))
+    return false;
+  if (value.startsWith("/"))
+    return false;
+  if (/^[A-Za-z]:/.test(value))
+    return false;
+  for (const segment of value.split("/")) {
+    if (segment === "" || segment === "." || segment === "..")
+      return false;
+    if (segment.endsWith(".") || segment.endsWith(" "))
+      return false;
+  }
+  return true;
+}
+function validateAuditFindingGates(findings) {
+  const violations = [];
+  const seen = new Map;
+  let previousFingerprint;
+  if (!Array.isArray(findings)) {
+    violations.push(violation10("high", "audit.finding.shape", "findings — audit.finding.shape"));
+    return { ok: false, violations };
+  }
+  findings.forEach((finding, index) => {
+    const at = (field) => `findings[${index}].${field}`;
+    const push = (code, field) => {
+      violations.push(violation10("high", code, `${at(field)} — ${code}`));
+    };
+    if (!isPlainObject9(finding)) {
+      violations.push(violation10("high", "audit.finding.shape", `findings[${index}] — audit.finding.shape`));
+      return;
+    }
+    if (finding.fingerprint !== undefined) {
+      const fingerprint = finding.fingerprint;
+      if (typeof fingerprint !== "string" || !AUDIT_FINGERPRINT_RE.test(fingerprint))
+        push("audit.finding.fingerprint.grammar", "fingerprint");
+      else if (redactSecrets(fingerprint).text !== fingerprint)
+        push("audit.finding.fingerprint.secret", "fingerprint");
+      else {
+        const firstAt = seen.get(fingerprint);
+        if (firstAt !== undefined)
+          push("audit.finding.fingerprint.duplicate", "fingerprint");
+        else
+          seen.set(fingerprint, index);
+        if (previousFingerprint !== undefined && fingerprint < previousFingerprint) {
+          push("audit.finding.fingerprint.order", "fingerprint");
+        }
+        previousFingerprint = fingerprint;
+      }
+    }
+    if (finding.severity !== undefined) {
+      if (!isPlainObject9(finding.severity)) {
+        push("audit.finding.severity.shape", "severity");
+      } else {
+        const { likelihood, impact, overall } = finding.severity;
+        const rankOf = (r) => AUDIT_SEVERITY_ORDER[r];
+        for (const [field, value] of [
+          ["likelihood", likelihood],
+          ["impact", impact],
+          ["overall", overall]
+        ]) {
+          if (rankOf(value) === undefined)
+            push("audit.finding.severity.rank", `severity.${field}`);
+        }
+        const impactRank = rankOf(impact);
+        const overallRank = rankOf(overall);
+        if (impactRank !== undefined && overallRank !== undefined && overallRank > impactRank) {
+          push("audit.finding.severity.overall-exceeds-impact", "severity.overall");
+        }
+      }
+    }
+    const textViolation = (field, value) => {
+      if (value === undefined)
+        return;
+      if (typeof value !== "string")
+        push("audit.finding.text.type", field);
+      else if (LONE_SURROGATE_RE.test(value))
+        push("audit.finding.text.surrogate", field);
+      else if (!isVisibleText(value))
+        push("audit.finding.text.invisible", field);
+    };
+    if (finding.trace !== undefined) {
+      if (!Array.isArray(finding.trace))
+        push("audit.finding.trace.shape", "trace");
+      else if (finding.trace.length === 0)
+        push("audit.finding.trace.empty", "trace");
+      else {
+        const kinds = finding.trace.map((s) => isPlainObject9(s) ? s.kind : undefined);
+        const topologyOk = finding.trace.length === 1 ? kinds[0] === "entrypoint" || kinds[0] === "sink" : kinds[0] === "entrypoint" && kinds[kinds.length - 1] === "sink" && kinds.slice(1, -1).every((k) => k === "propagation");
+        if (!topologyOk)
+          push("audit.finding.trace.topology", "trace");
+        finding.trace.forEach((step, stepIndex) => {
+          const stepAt = `trace[${stepIndex}]`;
+          if (!isPlainObject9(step)) {
+            push("audit.finding.trace.shape", stepAt);
+            return;
+          }
+          if (typeof step.line !== "number" || !Number.isSafeInteger(step.line) || step.line <= 0) {
+            push("audit.finding.trace.line", `${stepAt}.line`);
+          }
+          const stepFile = step.file;
+          if (typeof stepFile !== "string" || !safeAuditPath(stepFile))
+            push("audit.finding.path.unsafe", `${stepAt}.file`);
+          else if (redactSecrets(stepFile).text !== stepFile)
+            push("audit.finding.path.secret", `${stepAt}.file`);
+          if (step.scope === undefined)
+            push("audit.finding.trace.shape", `${stepAt}.scope`);
+          else
+            textViolation(`${stepAt}.scope`, step.scope);
+          if (step.description === undefined)
+            push("audit.finding.trace.shape", `${stepAt}.description`);
+          else
+            textViolation(`${stepAt}.description`, step.description);
+        });
+      }
+    }
+    if (!Array.isArray(finding.evidence))
+      push("audit.finding.evidence.shape", "evidence");
+    else
+      finding.evidence.forEach((item, itemIndex) => {
+        if (typeof item === "string") {
+          textViolation(`evidence[${itemIndex}]`, item);
+          return;
+        }
+        if (!isPlainObject9(item)) {
+          push("audit.finding.evidence.shape", `evidence[${itemIndex}]`);
+          return;
+        }
+        const itemFile = item.file;
+        if (typeof itemFile !== "string" || !safeAuditPath(itemFile))
+          push("audit.finding.path.unsafe", `evidence[${itemIndex}].file`);
+        else if (redactSecrets(itemFile).text !== itemFile)
+          push("audit.finding.path.secret", `evidence[${itemIndex}].file`);
+        if (item.line !== undefined && (typeof item.line !== "number" || !Number.isSafeInteger(item.line) || item.line <= 0)) {
+          push("audit.finding.evidence.line", `evidence[${itemIndex}].line`);
+        }
+        textViolation(`evidence[${itemIndex}].description`, item.description);
+      });
+    textViolation("title", finding.title);
+    textViolation("impact", finding.impact);
+    textViolation("fixSketch", finding.fixSketch);
+    textViolation("verification", finding.verification);
+  });
+  return { ok: violations.length === 0, violations };
+}
 function renderPlanFile(finding, plannedAt) {
   const sections = [
     `# ${finding.title}`,
@@ -7574,15 +7957,22 @@ function renderPlanFile(finding, plannedAt) {
     `- **Priority**: ${finding.priority}`,
     `- **Effort**: ${finding.effort}`,
     `- **Risk**: ${finding.risk}`,
+    ...finding.confidence !== "MED" || hasEnrichedMetadata(finding) ? [`- **Confidence**: ${finding.confidence}`] : [],
+    ...finding.fingerprint !== undefined ? [`- **Fingerprint**: ${finding.fingerprint}`] : [],
+    ...finding.severity !== undefined ? [`- **Likelihood**: ${finding.severity.likelihood}`, `- **Severity impact**: ${finding.severity.impact}`, `- **Severity**: ${finding.severity.overall}`] : [],
     `- **Depends on**: ${finding.dependsOn ?? "none"}`,
     `- **Category**: ${finding.category}`,
+    ...finding.evidence.length > 0 ? [`- **Evidence**: ${collapseEvidenceWs(evidenceText(finding.evidence[0]))}`] : [],
     `- **Planned at**: commit \`${plannedAt.commit}\`, ${plannedAt.date}`,
     "",
     "## Impact",
     finding.impact
   ];
   if (finding.evidence.length > 0) {
-    sections.push("", "## Evidence", ...finding.evidence.map((e) => `- ${e}`));
+    sections.push("", "## Evidence", ...finding.evidence.map((item) => `- ${evidenceText(item)}`));
+  }
+  if (finding.trace !== undefined) {
+    sections.push("", "## Trace", "", "| Kind | Location | Scope / Description |", "|------|----------|---------------------|", ...finding.trace.map((step) => `| ${escapeCell(step.kind)} | ${escapeCell(`${step.file}:${step.line}`)} | ${escapeCell(`${step.scope} — ${step.description}`).replace(/\r\n|\r|\n/g, "\\n")} |`));
   }
   if (finding.fixSketch !== undefined) {
     sections.push("", "## Fix sketch", finding.fixSketch);
@@ -7602,7 +7992,8 @@ function redactFinding(finding) {
     ...finding,
     title: redactText(finding.title),
     impact: redactText(finding.impact),
-    evidence: finding.evidence.map(redactText),
+    evidence: finding.evidence.map((item) => typeof item === "string" ? redactText(item) : { ...item, description: redactText(item.description) }),
+    ...finding.trace !== undefined ? { trace: finding.trace.map((step) => ({ ...step, scope: redactText(step.scope), description: redactText(step.description) })) } : {},
     ...finding.fixSketch !== undefined ? { fixSketch: redactText(finding.fixSketch) } : {},
     ...finding.verification !== undefined ? { verification: redactText(finding.verification) } : {}
   };
@@ -7624,7 +8015,10 @@ function extractSecurityDispositionSections(text) {
 }
 function renderIndex(params) {
   const { date, repoName, repoShortSha, rows, rejected, needsVerification, hardeningChecked } = params;
-  const findingsRows = rows.map((r) => `| ${r.num} | ${escapeCell(r.title)} | ${r.category} | ${escapeCell(truncate(r.impact, 80))} | ${r.effort} | ${r.risk} | ${r.confidence} | ${escapeCell(truncate(r.evidence, 80))} |`).join(`
+  const showFingerprint = rows.some((r) => r.fingerprint !== undefined);
+  const showSeverity = rows.some((r) => r.likelihood !== undefined || r.severityImpact !== undefined || r.severity !== undefined);
+  const cell = (value) => escapeCell(value ?? "—");
+  const findingsRows = rows.map((r) => `| ${r.num} | ${escapeCell(r.title)} | ${r.category} | ${escapeCell(truncate(r.impact, 80))} | ${r.effort} | ${r.risk} | ${r.confidence} | ${escapeCell(truncate(r.evidence, 80))}` + (showFingerprint ? ` | ${cell(r.fingerprint)}` : "") + (showSeverity ? ` | ${cell(r.likelihood)} | ${cell(r.severityImpact)} | ${cell(r.severity)}` : "") + " |").join(`
 `);
   const directionRows = rows.filter((r) => r.category === "direction").map((r) => `- ${escapeCell(r.title)} — ${escapeCell(truncate(r.impact, 120))}`).join(`
 `);
@@ -7637,8 +8031,8 @@ function renderIndex(params) {
     "",
     "## Findings",
     "",
-    "| # | Finding | Category | Impact | Effort | Risk | Confidence | Evidence |",
-    "|---|---------|----------|--------|--------|------|------------|----------|",
+    "| # | Finding | Category | Impact | Effort | Risk | Confidence | Evidence" + (showFingerprint ? " | Fingerprint" : "") + (showSeverity ? " | Likelihood | Severity impact | Severity" : "") + " |",
+    "|---|---------|----------|--------|--------|------|------------|----------" + (showFingerprint ? "|------------" : "") + (showSeverity ? "|------------|-----------------|----------" : "") + "|",
     findingsRows
   ];
   if (directionRows !== "") {
@@ -7662,6 +8056,11 @@ function renderIndex(params) {
 function scaffoldAuditPlan(outDir, findings, options = {}) {
   const date = options.date ?? new Date().toISOString().slice(0, 10);
   const plannedAt = options.plannedAt ?? { commit: options.repoShortSha ?? "unknown", date };
+  const gate2 = validateAuditFindingGates(findings);
+  if (!gate2.ok) {
+    const first = gate2.violations[0];
+    throw new TypeError(`invalid audit findings — ${first.code}: ${first.message}`);
+  }
   mkdirSync8(outDir, { recursive: true });
   const existingReadme = join16(outDir, "README.md");
   const carried = existsSync12(existingReadme) ? extractSecurityDispositionSections(readFileSync11(existingReadme, "utf8")) : { needsVerification: [], hardeningChecked: [] };
@@ -7696,10 +8095,14 @@ function scaffoldAuditPlan(outDir, findings, options = {}) {
       impact: "see plan file",
       effort: fields.get("Effort") ?? "—",
       risk: fields.get("Risk") ?? "—",
-      confidence: "—",
+      confidence: fields.get("Confidence") ?? "—",
       evidence: fields.get("Evidence") ?? "—",
       priority: fields.get("Priority") ?? "—",
-      dependsOn: fields.get("Depends on") ?? "—"
+      dependsOn: fields.get("Depends on") ?? "—",
+      fingerprint: fields.get("Fingerprint"),
+      likelihood: fields.get("Likelihood"),
+      severityImpact: fields.get("Severity impact"),
+      severity: fields.get("Severity")
     };
   });
   const byNum = new Map(rows.map((r) => [r.num, r]));
@@ -7714,9 +8117,13 @@ function scaffoldAuditPlan(outDir, findings, options = {}) {
       row.effort = finding.effort;
       row.risk = finding.risk;
       row.confidence = finding.confidence;
-      row.evidence = finding.evidence[0] ?? "";
+      row.evidence = finding.evidence.length > 0 ? collapseEvidenceWs(evidenceText(finding.evidence[0])) : "";
       row.priority = finding.priority;
       row.dependsOn = finding.dependsOn ?? "none";
+      row.fingerprint = finding.fingerprint;
+      row.likelihood = finding.severity?.likelihood;
+      row.severityImpact = finding.severity?.impact;
+      row.severity = finding.severity?.overall;
     }
   });
   const needsVerificationLines = options.needsVerification !== undefined ? options.needsVerification.map((nv) => `- ${escapeCell(redactText(nv.lead))}: ${escapeCell(redactText(nv.how))}${nv.evidence ? ` (${escapeCell(redactText(nv.evidence))})` : ""}`) : carried.needsVerification;
@@ -8952,7 +9359,7 @@ function computePrTally(input) {
 var REVIEW_SCHEMA_ID = "mstar.review/v1";
 var INSPECTOR_VERDICTS = ["comment", "request_changes", "approve"];
 var INSPECTOR_SEVERITIES = ["critical", "warning", "suggestion", "info"];
-function isPlainObject9(value) {
+function isPlainObject10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var TALLY_COUNT_KEYS = ["mustFix", "shouldFix", "nit", "unverified"];
@@ -8963,7 +9370,7 @@ function checkProvidedTallyShape(tally, violations) {
   if (typeof tally.scorePct !== "number" || !Number.isInteger(tally.scorePct) || tally.scorePct < 0 || tally.scorePct > 100) {
     violations.push(violation15("high", "review.tally-malformed", `tally.scorePct must be an integer in [0, 100] - got ${String(tally.scorePct)}`));
   }
-  if (!isPlainObject9(tally.tally)) {
+  if (!isPlainObject10(tally.tally)) {
     violations.push(violation15("high", "review.tally-malformed", "tally.tally must be an object carrying the four class counts"));
   } else {
     for (const key of TALLY_COUNT_KEYS) {
@@ -8979,7 +9386,7 @@ function checkProvidedTallyShape(tally, violations) {
 }
 function validateMstarReviewV1(doc) {
   const violations = [];
-  if (!isPlainObject9(doc)) {
+  if (!isPlainObject10(doc)) {
     return {
       ok: false,
       violations: [violation15("high", "review.not-object", "review document must be a JSON object")]
@@ -9006,7 +9413,7 @@ function validateMstarReviewV1(doc) {
     violations.push(violation15("high", "review.findings-not-array", "findings must be an array"));
   } else {
     doc.findings.forEach((finding, index) => {
-      if (!isPlainObject9(finding)) {
+      if (!isPlainObject10(finding)) {
         violations.push(violation15("high", "review.invalid-finding", `findings[${index}] must be an object`));
         return;
       }
@@ -9046,7 +9453,7 @@ function validateMstarReviewV1(doc) {
     });
   }
   if (doc.tally !== undefined) {
-    if (!isPlainObject9(doc.tally)) {
+    if (!isPlainObject10(doc.tally)) {
       violations.push(violation15("high", "review.invalid-tally", "tally must be a PrTallyResult object"));
     } else {
       checkProvidedTallyShape(doc.tally, violations);
@@ -9056,7 +9463,7 @@ function validateMstarReviewV1(doc) {
     }
   }
   if (doc.target !== undefined) {
-    if (!isPlainObject9(doc.target)) {
+    if (!isPlainObject10(doc.target)) {
       violations.push(violation15("high", "review.invalid-target", "target must be an object"));
     } else {
       if (doc.target.owner !== undefined && typeof doc.target.owner !== "string") {
@@ -9906,6 +10313,7 @@ var IMPLEMENTED_OPERATIONS = {
   "integration-start": true,
   "integration-accept": true,
   complete: true,
+  "repair-delivery-source": true,
   reconcile: true
 };
 function nowIso() {
@@ -10465,7 +10873,11 @@ function allowedOperations(role, sessionId, snapshot, row) {
         out.push("accept", "return");
         break;
       case "accepted":
-        out.push("return", "integration-start");
+        if (isStandaloneDevelopmentWorkflow(snapshot)) {
+          out.push("return", "complete", "repair-delivery-source");
+        } else {
+          out.push("return", "integration-start");
+        }
         break;
       case "integrating":
         out.push("integration-accept", "complete", "reconcile");
@@ -11240,6 +11652,13 @@ async function mutatePlanCoordination(request) {
         expectedRevision
       });
     }
+    case "repair-delivery-source": {
+      assertExactKeys(operation, ["kind", "handoffId"], "repair-delivery-source operation");
+      return mutateRepairDeliverySource(await coordinatorScope(session, request.planId, kind), session, sessionAbs, {
+        handoffId: namedHandoffId(operation),
+        expectedRevision
+      });
+    }
     case "reconcile": {
       assertExactKeys(operation, ["kind", "handoffId"], "reconcile operation");
       return mutateReconcile(await coordinatorScope(session, request.planId, kind), session, sessionAbs, {
@@ -11270,6 +11689,7 @@ var COORDINATOR_OPERATIONS = [
   "integration-start",
   "integration-accept",
   "complete",
+  "repair-delivery-source",
   "reconcile"
 ];
 function assertSessionRole(session, kind) {
@@ -11910,6 +12330,313 @@ async function mutateIntegrationAccept(scope, session, sessionPath, request) {
     view: buildView(scope.harnessRoot, scope.workflowId, scope.projectId, scope, result.snapshot, result.row, session, sessionPath)
   };
 }
+function validateRowCoordinationInContext(context, coordination, what) {
+  assertViolationFree(validateRowCoordination(coordination, what, rowValidationRoute(context.snapshot, context.row)), what);
+}
+function standaloneDeliveryAnchors(snapshot, planId) {
+  const source = snapshot.branch?.source;
+  const target = snapshot.branch?.target;
+  if (!isNonEmptyString(source) || !isNonEmptyString(target)) {
+    throw new CoordinationError("coordination.invalid-transition", `plan ${planId} has no delivery anchors — the snapshot must name branch.source and branch.target`, { plan_id: planId });
+  }
+  return { source, target };
+}
+function assertStandaloneRoute(snapshot, planId, what) {
+  if (!isStandaloneDevelopmentWorkflow(snapshot)) {
+    throw new CoordinationError("coordination.invalid-transition", `${what} requires a standalone development workflow for plan ${planId}`, { plan_id: planId });
+  }
+}
+function assertNoIntegrationContamination(context, planId, handoff, what, code = "coordination.invalid-transition") {
+  if (handoff.integration !== undefined) {
+    throw new CoordinationError(code, `${what} refuses plan ${planId} because the handoff already carries an integration record`, { plan_id: planId });
+  }
+  if (context.snapshot.integration_worktree_path !== undefined) {
+    throw new CoordinationError(code, `${what} refuses plan ${planId} because the snapshot names integration_worktree_path`, { plan_id: planId });
+  }
+  if (isNonEmptyString(context.snapshot.branch?.integration)) {
+    throw new CoordinationError(code, `${what} refuses plan ${planId} because the snapshot names branch.integration`, { plan_id: planId, integration: context.snapshot.branch?.integration });
+  }
+  if (context.snapshot.integration_merge_lease !== undefined) {
+    throw new CoordinationError(code, `${what} refuses plan ${planId} because the snapshot carries an integration merge lease`, { plan_id: planId });
+  }
+}
+function assertAcceptedReviewDecision(handoff, planId, what) {
+  if (handoff.qc.decision !== "Approve" && handoff.qc.decision !== "Approve with residuals") {
+    throw new CoordinationError("coordination.invalid-transition", `${what} requires an accepted QC decision for plan ${planId} — got ${handoff.qc.decision}`, { plan_id: planId, decision: handoff.qc.decision });
+  }
+  if (handoff.qa.decision !== "pass") {
+    throw new CoordinationError("coordination.invalid-transition", `${what} requires QA decision pass for plan ${planId} — got ${handoff.qa.decision}`, { plan_id: planId, decision: handoff.qa.decision });
+  }
+}
+function assertStandaloneBranchIdentity(context, scope, handoff, anchors, what, requireLease = true) {
+  const worktree = canonicalTarget(scope.worktreePath);
+  if (handoff.source_branch !== anchors.source) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires handoff.source_branch ${handoff.source_branch} to equal the registered delivery source ${anchors.source}`, { plan_id: scope.planId, expected: anchors.source, actual: handoff.source_branch });
+  }
+  if (requireLease) {
+    const lease = requireExecutionLease(context.row, scope.planId, what);
+    if (scope.workingBranch !== anchors.source) {
+      throw new CoordinationError("coordination.scope-mismatch", `${what} requires the prepared working branch ${scope.workingBranch} to equal the registered delivery source ${anchors.source}`, { plan_id: scope.planId, expected: anchors.source, actual: scope.workingBranch });
+    }
+    if (lease.working_branch !== anchors.source) {
+      throw new CoordinationError("coordination.scope-mismatch", `${what} requires the execution lease working branch ${lease.working_branch} to equal the registered delivery source ${anchors.source}`, { plan_id: scope.planId, expected: anchors.source, actual: lease.working_branch });
+    }
+    if (canonicalTarget(lease.worktree_path) !== worktree) {
+      throw new CoordinationError("coordination.path-mismatch", `${what} requires the execution lease worktree ${lease.worktree_path} to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: lease.worktree_path });
+    }
+  }
+  if (canonicalTarget(handoff.worktree_path) !== worktree) {
+    throw new CoordinationError("coordination.path-mismatch", `${what} requires the handoff worktree ${handoff.worktree_path} to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: handoff.worktree_path });
+  }
+  const metadata = context.row.metadata;
+  if (isPlainObject2(metadata) && metadata.working_branch !== undefined && metadata.working_branch !== anchors.source) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires row metadata.working_branch to equal the registered delivery source ${anchors.source}`, { plan_id: scope.planId, expected: anchors.source, actual: metadata.working_branch });
+  }
+  if (isPlainObject2(metadata) && metadata.worktree_path !== undefined && canonicalTarget(String(metadata.worktree_path)) !== worktree) {
+    throw new CoordinationError("coordination.path-mismatch", `${what} requires row metadata.worktree_path to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: metadata.worktree_path });
+  }
+}
+function assertStandaloneSourceGitProof(scope, handoff, sourceBranch, what) {
+  assertFeatureCheckout(scope, handoff.source_sha, what);
+  const branch = gitRead(scope.worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (branch !== sourceBranch) {
+    throw gitProof(`${what} requires the plan worktree ${scope.worktreePath} to be on ${sourceBranch} — got ${branch || "a detached HEAD"}`, { plan_id: scope.planId, expected: sourceBranch, actual: branch });
+  }
+  const refTip = gitRead(scope.worktreePath, ["rev-parse", `refs/heads/${sourceBranch}`]);
+  if (refTip !== handoff.source_sha) {
+    throw gitProof(`${what} requires refs/heads/${sourceBranch} to resolve to the pinned source ${handoff.source_sha} — got ${refTip || "missing"}`, { plan_id: scope.planId, expected: handoff.source_sha, actual: refTip });
+  }
+  if (handoff.review_head !== handoff.source_sha) {
+    throw gitProof(`${what} requires review_head to be the pinned source ${handoff.source_sha} — got ${handoff.review_head}`, { plan_id: scope.planId, source_sha: handoff.source_sha, review_head: handoff.review_head });
+  }
+  if (!gitObjectExists(scope.worktreePath, handoff.review_base)) {
+    throw gitProof(`${what} review base ${handoff.review_base} is not a commit of ${scope.worktreePath}`, {
+      plan_id: scope.planId,
+      review_base: handoff.review_base
+    });
+  }
+  if (!gitIsAncestor(scope.worktreePath, handoff.review_base, handoff.review_head)) {
+    throw gitProof(`${what} review range ${handoff.review_base}..${handoff.review_head} is not an ancestry`, { plan_id: scope.planId, review_base: handoff.review_base, review_head: handoff.review_head });
+  }
+}
+async function assertStandaloneCompletionPrecheck(context, scope, session, handoff) {
+  assertStandaloneRoute(context.snapshot, scope.planId, "complete");
+  if (context.snapshot.status !== "running") {
+    throw new CoordinationError("coordination.invalid-transition", `complete requires workflow ${context.snapshot.id} to still be running — got ${context.snapshot.status}`, { workflow_id: context.snapshot.id, status: context.snapshot.status });
+  }
+  if (handoff.state !== "accepted") {
+    throw new CoordinationError("coordination.invalid-transition", `plan ${scope.planId} handoff is ${handoff.state} — standalone complete requires an accepted handoff`, { plan_id: scope.planId, state: handoff.state });
+  }
+  if (rowStatusOf(context.row) !== "InReview") {
+    throw new CoordinationError("coordination.invalid-transition", `complete requires ${scope.planId} to still be InReview`, { plan_id: scope.planId, status: context.row.status });
+  }
+  const prepared = context.coordination?.prepared;
+  if (prepared === undefined) {
+    throw new CoordinationError("coordination.not-prepared", `plan ${scope.planId} is not prepared in this workflow`, { plan_id: scope.planId });
+  }
+  assertNoIntegrationContamination(context, scope.planId, handoff, "complete");
+  assertEvidenceDigests(handoff);
+  assertAcceptedReviewDecision(handoff, scope.planId, "complete");
+  if (handoff.qa.gate !== prepared.qa_gate) {
+    throw new CoordinationError("coordination.assignment-stale", `complete qa.gate ${handoff.qa.gate} is not the Assignment's QA gate ${prepared.qa_gate}`, { plan_id: scope.planId, expected: prepared.qa_gate, actual: handoff.qa.gate });
+  }
+  await assertFindingsClosed(scope, prepared, "complete");
+  assertExecutionHolder(context.row, session.session_id, scope.planId, "complete");
+  const anchors = standaloneDeliveryAnchors(context.snapshot, scope.planId);
+  assertStandaloneBranchIdentity(context, scope, handoff, anchors, "complete");
+  assertStandaloneSourceGitProof(scope, handoff, anchors.source, "complete");
+}
+function requireAcceptedHandoffForRepair(context, planId, namedHandoffId2) {
+  const handoff = context.coordination?.handoff;
+  if (handoff === undefined || handoff.id !== namedHandoffId2 || handoff.state !== "accepted" || rowStatusOf(context.row) !== "InReview") {
+    throw new CoordinationError("coordination.delivery-source-repair.no-accepted-handoff", `repair-delivery-source requires plan ${planId} to carry the named accepted handoff while InReview`, { plan_id: planId, handoff_id: namedHandoffId2, state: handoff?.state, status: context.row.status });
+  }
+  return handoff;
+}
+function assertRepairNotTerminal(snapshot) {
+  if (WORKFLOW_TERMINAL_STATUSES.includes(snapshot.status)) {
+    throw new CoordinationError("coordination.delivery-source-repair.terminal", `repair-delivery-source refuses workflow ${snapshot.id} in terminal status ${snapshot.status}`, { workflow_id: snapshot.id, status: snapshot.status });
+  }
+}
+function assertLegacyRepairShape(snapshot, planId, handoff) {
+  const source = snapshot.branch?.source;
+  const target = snapshot.branch?.target;
+  if (!isNonEmptyString(source) || !isNonEmptyString(target)) {
+    throw new CoordinationError("coordination.delivery-source-repair.not-legacy-shape", `repair-delivery-source requires nonblank delivery anchors on plan ${planId}`, { plan_id: planId });
+  }
+  const candidateSource = handoff.source_branch;
+  if (!isNonEmptyString(candidateSource)) {
+    throw new CoordinationError("coordination.delivery-source-repair.not-legacy-shape", `repair-delivery-source requires the accepted handoff to name a nonblank source branch for plan ${planId}`, { plan_id: planId });
+  }
+  if (source === candidateSource) {
+    throw new CoordinationError("coordination.delivery-source-repair.already-aligned", `repair-delivery-source refuses plan ${planId} because branch.source already equals the accepted handoff source ${candidateSource}`, { plan_id: planId, source, candidate: candidateSource });
+  }
+  if (source !== target) {
+    throw new CoordinationError("coordination.delivery-source-repair.not-legacy-shape", `repair-delivery-source requires the legacy shape branch.source === branch.target for plan ${planId} — got source ${source} and target ${target}`, { plan_id: planId, source, target });
+  }
+  return { target, candidateSource };
+}
+function assertRepairBranchIdentity(context, scope, handoff, candidateSource, what) {
+  const worktree = canonicalTarget(scope.worktreePath);
+  if (handoff.source_branch !== candidateSource) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires handoff.source_branch ${handoff.source_branch} to equal the candidate delivery source ${candidateSource}`, { plan_id: scope.planId, expected: candidateSource, actual: handoff.source_branch });
+  }
+  const lease = requireExecutionLease(context.row, scope.planId, what);
+  if (scope.workingBranch !== candidateSource) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires the prepared working branch ${scope.workingBranch} to equal the candidate delivery source ${candidateSource}`, { plan_id: scope.planId, expected: candidateSource, actual: scope.workingBranch });
+  }
+  if (lease.working_branch !== candidateSource) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires the execution lease working branch ${lease.working_branch} to equal the candidate delivery source ${candidateSource}`, { plan_id: scope.planId, expected: candidateSource, actual: lease.working_branch });
+  }
+  if (canonicalTarget(lease.worktree_path) !== worktree) {
+    throw new CoordinationError("coordination.path-mismatch", `${what} requires the execution lease worktree ${lease.worktree_path} to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: lease.worktree_path });
+  }
+  if (canonicalTarget(handoff.worktree_path) !== worktree) {
+    throw new CoordinationError("coordination.path-mismatch", `${what} requires the handoff worktree ${handoff.worktree_path} to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: handoff.worktree_path });
+  }
+  const metadata = context.row.metadata;
+  if (isPlainObject2(metadata) && metadata.working_branch !== undefined && metadata.working_branch !== candidateSource) {
+    throw new CoordinationError("coordination.scope-mismatch", `${what} requires row metadata.working_branch to equal the candidate delivery source ${candidateSource}`, { plan_id: scope.planId, expected: candidateSource, actual: metadata.working_branch });
+  }
+  if (isPlainObject2(metadata) && metadata.worktree_path !== undefined && canonicalTarget(String(metadata.worktree_path)) !== worktree) {
+    throw new CoordinationError("coordination.path-mismatch", `${what} requires row metadata.worktree_path to equal the prepared scope ${worktree}`, { plan_id: scope.planId, expected: worktree, actual: metadata.worktree_path });
+  }
+}
+function assertDeliveryPrCompatible(snapshot, candidateSource, registeredTarget, planId) {
+  const pr = snapshot.delivery?.pr;
+  if (pr === undefined)
+    return;
+  if (pr.head !== candidateSource || pr.target !== registeredTarget) {
+    throw new CoordinationError("coordination.delivery-source-repair.pr-conflict", `repair-delivery-source refuses plan ${planId} because stored PR identity head ${JSON.stringify(pr.head)} target ${JSON.stringify(pr.target)} conflicts with candidate source ${candidateSource} and registered target ${registeredTarget}`, { plan_id: planId, pr_head: pr.head, pr_target: pr.target, candidate: candidateSource, target: registeredTarget });
+  }
+}
+function assertRepairDeliverySourceAdmission(context, scope) {
+  if (!isStandaloneDevelopmentWorkflow(context.snapshot)) {
+    throw new CoordinationError("coordination.delivery-source-repair.unsupported-workflow", `repair-delivery-source requires a single-row standalone development workflow for plan ${scope.planId}`, { plan_id: scope.planId, workflow_id: context.snapshot.id });
+  }
+  assertRepairNotTerminal(context.snapshot);
+  if (context.snapshot.status === "paused") {
+    throw new CoordinationError("coordination.invalid-transition", `repair-delivery-source refuses paused workflow ${context.snapshot.id}`, { workflow_id: context.snapshot.id, status: context.snapshot.status });
+  }
+  if (context.snapshot.status !== "running") {
+    throw new CoordinationError("coordination.invalid-transition", `repair-delivery-source requires workflow ${context.snapshot.id} to still be running — got ${context.snapshot.status}`, { workflow_id: context.snapshot.id, status: context.snapshot.status });
+  }
+}
+async function assertRepairDeliverySourcePrecheck(context, scope, session, handoff) {
+  assertNoIntegrationContamination(context, scope.planId, handoff, "repair-delivery-source", "coordination.delivery-source-repair.not-legacy-shape");
+  const prepared = context.coordination?.prepared;
+  if (prepared === undefined) {
+    throw new CoordinationError("coordination.not-prepared", `plan ${scope.planId} is not prepared in this workflow`, { plan_id: scope.planId });
+  }
+  assertEvidenceDigests(handoff);
+  assertAcceptedReviewDecision(handoff, scope.planId, "repair-delivery-source");
+  if (handoff.qa.gate !== prepared.qa_gate) {
+    throw new CoordinationError("coordination.assignment-stale", `repair-delivery-source qa.gate ${handoff.qa.gate} is not the Assignment's QA gate ${prepared.qa_gate}`, { plan_id: scope.planId, expected: prepared.qa_gate, actual: handoff.qa.gate });
+  }
+  await assertFindingsClosed(scope, prepared, "repair-delivery-source");
+  assertExecutionHolder(context.row, session.session_id, scope.planId, "repair-delivery-source");
+  const { target, candidateSource } = assertLegacyRepairShape(context.snapshot, scope.planId, handoff);
+  assertRepairBranchIdentity(context, scope, handoff, candidateSource, "repair-delivery-source");
+  assertDeliveryPrCompatible(context.snapshot, candidateSource, target, scope.planId);
+  assertStandaloneSourceGitProof(scope, handoff, candidateSource, "repair-delivery-source");
+}
+function repairDeliverySourceRow(context, scope, candidateSource) {
+  const nextCoordination = {
+    ...context.coordination ?? { revision: 0 },
+    revision: context.revision + 1
+  };
+  validateRowCoordinationInContext(context, nextCoordination, `plan ${scope.planId} coordination`);
+  const currentBranch = context.snapshot.branch ?? {};
+  return {
+    row: { ...context.row, coordination: nextCoordination },
+    coordination: nextCoordination,
+    topLevel: {
+      branch: { ...currentBranch, source: candidateSource }
+    }
+  };
+}
+async function mutateRepairDeliverySource(scope, session, sessionPath, request) {
+  const result = await withRowCommit(scope, {
+    expectedRevision: request.expectedRevision,
+    precheck: async (context) => {
+      assertCoordinatorBinding(session, sessionPath, context.snapshot);
+      assertRepairDeliverySourceAdmission(context, scope);
+      const handoff = requireAcceptedHandoffForRepair(context, scope.planId, request.handoffId);
+      await assertRepairDeliverySourcePrecheck(context, scope, session, handoff);
+    },
+    mutate: (context) => {
+      const handoff = requireAcceptedHandoffForRepair(context, scope.planId, request.handoffId);
+      const { candidateSource } = assertLegacyRepairShape(context.snapshot, scope.planId, handoff);
+      return repairDeliverySourceRow(context, scope, candidateSource);
+    }
+  });
+  return {
+    ok: true,
+    operation: "repair-delivery-source",
+    session,
+    session_file: sessionPath,
+    outcome: "delivery-source-repaired",
+    view: buildView(scope.harnessRoot, scope.workflowId, scope.projectId, scope, result.snapshot, result.row, session, sessionPath)
+  };
+}
+function completeStandaloneRow(context, scope, handoff) {
+  const metadata = isPlainObject2(context.row.metadata) ? { ...context.row.metadata } : {};
+  metadata.working_branch = handoff.source_branch;
+  metadata.worktree_path = handoff.worktree_path;
+  const nextCoordination = {
+    ...context.coordination ?? { revision: 0 },
+    revision: context.revision + 1,
+    handoff: { ...handoff, state: "completed", completed_at: nowIso() }
+  };
+  validateRowCoordinationInContext(context, nextCoordination, `plan ${scope.planId} coordination`);
+  const nextRow = { ...context.row, status: "Done", metadata, coordination: nextCoordination };
+  delete nextRow.execution_lease;
+  return { row: nextRow, coordination: nextCoordination };
+}
+function assertStandaloneCompletedReplay(context, scope, handoff) {
+  assertStandaloneRoute(context.snapshot, scope.planId, "reconcile");
+  if (rowStatusOf(context.row) !== "Done") {
+    throw new CoordinationError("coordination.invalid-transition", `reconcile requires ${scope.planId} to be Done for a standalone completed replay`, { plan_id: scope.planId, status: context.row.status });
+  }
+  if (context.row.execution_lease !== undefined) {
+    throw new CoordinationError("coordination.invalid-transition", `reconcile requires no execution lease on ${scope.planId} for a standalone completed replay`, { plan_id: scope.planId });
+  }
+  if (context.snapshot.integration_merge_lease !== undefined) {
+    throw new CoordinationError("coordination.invalid-transition", `reconcile requires no integration merge lease for a standalone completed replay of ${scope.planId}`, { plan_id: scope.planId });
+  }
+  assertNoIntegrationContamination(context, scope.planId, handoff, "reconcile");
+  const storedHandoffViolations = validatePlanHandoff(handoff, `plan ${scope.planId} coordination.handoff`, "standalone-development");
+  const storedHandoffFailure = storedHandoffViolations.find((entry) => !entry.ok);
+  if (storedHandoffFailure !== undefined) {
+    throw new CoordinationError(storedHandoffFailure.code, storedHandoffFailure.message, { plan_id: scope.planId });
+  }
+  const anchors = standaloneDeliveryAnchors(context.snapshot, scope.planId);
+  assertStandaloneBranchIdentity(context, scope, handoff, anchors, "reconcile", false);
+  const repository = proofRepository([handoff.worktree_path, scope.worktreePath, scope.harnessRoot]);
+  if (repository !== undefined && !gitObjectExists(repository, handoff.source_sha)) {
+    throw gitProof(`reconcile cannot re-verify the pinned standalone source ${handoff.source_sha} for plan ${scope.planId}`, { plan_id: scope.planId, source_sha: handoff.source_sha });
+  }
+}
+async function assertIterationCompletionPrecheck(context, scope, session, handoff) {
+  if (handoff.state !== "merged") {
+    throw new CoordinationError("coordination.invalid-transition", `plan ${scope.planId} handoff is ${handoff.state} — complete requires a merged attempt`, { plan_id: scope.planId, state: handoff.state });
+  }
+  if (rowStatusOf(context.row) !== "InReview") {
+    throw new CoordinationError("coordination.invalid-transition", `complete requires ${scope.planId} to still be InReview`, { plan_id: scope.planId, status: context.row.status });
+  }
+  const prepared = context.coordination?.prepared;
+  if (prepared === undefined) {
+    throw new CoordinationError("coordination.not-prepared", `plan ${scope.planId} is not prepared in this workflow`, { plan_id: scope.planId });
+  }
+  assertEvidenceDigests(handoff);
+  await assertFindingsClosed(scope, prepared, "complete");
+  assertExecutionHolder(context.row, session.session_id, scope.planId, "complete");
+  assertMergeLease(context.snapshot, session, scope.planId, handoff);
+  const integration = requireIntegration(handoff, scope.planId);
+  const anchors = integrationAnchors(context.snapshot, scope.planId);
+  const checkout = assertIntegrationCheckout(anchors, scope.planId);
+  assertRecordedResult(anchors.worktreePath, scope.planId, integration, handoff.source_sha, checkout.head);
+}
 function completeRow(context, scope, handoff, resultSha) {
   const integration = requireIntegration(handoff, scope.planId);
   const completed = { ...integration, result_sha: resultSha, verified_at: nowIso() };
@@ -11928,33 +12655,27 @@ function completeRow(context, scope, handoff, resultSha) {
     dropTopLevel: release === undefined ? [] : ["integration_merge_lease"]
   };
 }
+var completeStandaloneMutateGapForTest;
 async function mutateComplete(scope, session, sessionPath, request) {
   const result = await withRowCommit(scope, {
     expectedRevision: request.expectedRevision,
     precheck: async (context) => {
       assertCoordinatorBinding(session, sessionPath, context.snapshot);
       const handoff = requireHandoff(context, scope.planId, request.handoffId);
-      if (handoff.state !== "merged") {
-        throw new CoordinationError("coordination.invalid-transition", `plan ${scope.planId} handoff is ${handoff.state} — complete requires a merged attempt`, { plan_id: scope.planId, state: handoff.state });
-      }
-      if (rowStatusOf(context.row) !== "InReview") {
-        throw new CoordinationError("coordination.invalid-transition", `complete requires ${scope.planId} to still be InReview`, { plan_id: scope.planId, status: context.row.status });
-      }
-      const prepared = context.coordination?.prepared;
-      if (prepared === undefined) {
-        throw new CoordinationError("coordination.not-prepared", `plan ${scope.planId} is not prepared in this workflow`, { plan_id: scope.planId });
+      if (isStandaloneDevelopmentWorkflow(context.snapshot)) {
+        await assertStandaloneCompletionPrecheck(context, scope, session, handoff);
+        return;
       }
-      assertEvidenceDigests(handoff);
-      await assertFindingsClosed(scope, prepared, "complete");
-      assertExecutionHolder(context.row, session.session_id, scope.planId, "complete");
-      assertMergeLease(context.snapshot, session, scope.planId, handoff);
-      const integration = requireIntegration(handoff, scope.planId);
-      const anchors = integrationAnchors(context.snapshot, scope.planId);
-      const checkout = assertIntegrationCheckout(anchors, scope.planId);
-      assertRecordedResult(anchors.worktreePath, scope.planId, integration, handoff.source_sha, checkout.head);
+      await assertIterationCompletionPrecheck(context, scope, session, handoff);
     },
     mutate: (context) => {
       const handoff = requireHandoff(context, scope.planId, request.handoffId);
+      if (isStandaloneDevelopmentWorkflow(context.snapshot)) {
+        completeStandaloneMutateGapForTest?.();
+        const anchors = standaloneDeliveryAnchors(context.snapshot, scope.planId);
+        assertStandaloneSourceGitProof(scope, handoff, anchors.source, "complete");
+        return completeStandaloneRow(context, scope, handoff);
+      }
       const integration = requireIntegration(handoff, scope.planId);
       const resultSha = assertRecordedResult(integration.worktree_path, scope.planId, integration, handoff.source_sha, undefined);
       return completeRow(context, scope, handoff, resultSha);
@@ -11978,6 +12699,10 @@ async function classifyReconcile(context, scope, session, handoff, expectedHando
     });
   }
   if (handoff.state === "completed") {
+    if (isStandaloneDevelopmentWorkflow(context.snapshot)) {
+      assertStandaloneCompletedReplay(context, scope, handoff);
+      return { outcome: "already-completed", apply: () => null };
+    }
     const integration = requireIntegration(handoff, planId);
     const repository = proofRepository([integration.worktree_path, handoff.worktree_path, session.harness_root]);
     if (repository === undefined) {
@@ -13051,6 +13776,7 @@ export {
   readWorkflowSnapshot,
   recordWorkflowDelivery,
   referenceExists,
+  registerIterationWorkflow,
   registerPlanWorkflow,
   registerWorkflow,
   releaseLease,
@@ -13095,6 +13821,7 @@ export {
   techDebtRollup,
   unregisterWorkflow,
   validateAssignmentFields,
+  validateAuditFindingGates,
   validateAuditStatusBlocks,
   validateCompassFrontmatter,
   validateDesignTokenFrontmatter,