@mstar-harness/engine 3.10.2 → 3.10.3

package/dist/audit.js

@@ -279,7 +279,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 = [
@@ -419,7 +419,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;
 }
@@ -455,7 +473,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"];
@@ -474,7 +492,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`));
   }
@@ -797,6 +815,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(violation2("high", "coordination.row.handoff-field", `standalone completed handoff requires row ${String(row.id)} to be Done`));
+  }
+  if (row.execution_lease !== undefined) {
+    violations.push(violation2("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(violation2("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(violation2("high", "coordination.row.handoff-field", "standalone completed handoff requires nonblank branch.source and branch.target"));
+  } else {
+    if (handoff.source_branch !== source) {
+      violations.push(violation2("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(",")}]`;
@@ -916,13 +973,17 @@ function validateWorkflowSnapshot(doc) {
   } else if (!Array.isArray(doc.plans)) {
     violations.push(violation2("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));
       }
     }
   }

package/dist/coordination-write.d.ts

@@ -1,6 +1,6 @@
 import type { ValidationResult } from "./core.js";
 /** Stable refusal codes of the scoped coordination surface (spec §C4). */
-export declare const COORDINATION_ERROR_CODES: readonly ["coordination.harness-not-found", "coordination.workflow-not-found", "coordination.plan-not-found", "coordination.scope-mismatch", "coordination.path-mismatch", "coordination.assignment-invalid", "coordination.assignment-stale", "coordination.not-prepared", "coordination.duplicate-holder", "coordination.session-mismatch", "coordination.session-not-found", "coordination.session-role", "coordination.version-conflict", "coordination.expected-version-required", "coordination.invalid-transition", "coordination.invalid-input", "coordination.forbidden-field", "coordination.not-in-git", "coordination.git-unavailable", "coordination.git-proof", "coordination.evidence-stale", "coordination.integration-unresolved", "coordination.integration-diverged", "coordination.local-store-required", "coordination.direct-write-refused", "coordination.scoped-writer-required", "coordination.unknown-operation", "coordination.store", "coordination.prepare-amendment.stale", "coordination.prepare-amendment.invalid-patch", "coordination.prepare-amendment.not-prepare", "coordination.prepare-amendment.execution-started", "coordination.prepare-amendment.duplicate-plan", "coordination.prepare-amendment.invalid-plan", "coordination.prepare-amendment.compass-mismatch", "coordination.prepare-amendment.invalid-worktree"];
+export declare const COORDINATION_ERROR_CODES: readonly ["coordination.harness-not-found", "coordination.workflow-not-found", "coordination.plan-not-found", "coordination.scope-mismatch", "coordination.path-mismatch", "coordination.assignment-invalid", "coordination.assignment-stale", "coordination.not-prepared", "coordination.duplicate-holder", "coordination.session-mismatch", "coordination.session-not-found", "coordination.session-role", "coordination.version-conflict", "coordination.expected-version-required", "coordination.invalid-transition", "coordination.invalid-input", "coordination.forbidden-field", "coordination.not-in-git", "coordination.git-unavailable", "coordination.git-proof", "coordination.evidence-stale", "coordination.integration-unresolved", "coordination.integration-diverged", "coordination.local-store-required", "coordination.direct-write-refused", "coordination.scoped-writer-required", "coordination.unknown-operation", "coordination.store", "coordination.prepare-amendment.stale", "coordination.prepare-amendment.invalid-patch", "coordination.prepare-amendment.not-prepare", "coordination.prepare-amendment.execution-started", "coordination.prepare-amendment.duplicate-plan", "coordination.prepare-amendment.invalid-plan", "coordination.prepare-amendment.compass-mismatch", "coordination.prepare-amendment.invalid-worktree", "coordination.delivery-source-repair.unsupported-workflow", "coordination.delivery-source-repair.terminal", "coordination.delivery-source-repair.no-accepted-handoff", "coordination.delivery-source-repair.already-aligned", "coordination.delivery-source-repair.not-legacy-shape", "coordination.delivery-source-repair.pr-conflict"];
 export type CoordinationErrorCode = (typeof COORDINATION_ERROR_CODES)[number];
 /**
  * Stable exception of the coordination surface: `code` is the consumer
@@ -156,12 +156,14 @@ export declare const HANDOFF_STATES: readonly HandoffState[];
 export declare const PLAN_PROGRESS_STATUSES: readonly PlanProgressStatus[];
 /** Validate a stored `PlanProgress` (`status`, `summary`, `evidence_paths`, `track_branches`). */
 export declare function validatePlanProgress(value: unknown, what?: string): ValidationResult[];
+/** Route-aware stored handoff validation (spec A5). Default remains strict integration. */
+export type RowValidationRoute = "integration" | "standalone-development";
 /** Validate a stored `PlanHandoff`, including its state/field coherence. */
-export declare function validatePlanHandoff(value: unknown, what?: string): ValidationResult[];
+export declare function validatePlanHandoff(value: unknown, what?: string, route?: RowValidationRoute): ValidationResult[];
 /** Validate a stored `PreparedCoordination`. */
 export declare function validatePreparedCoordination(value: unknown, what?: string): ValidationResult[];
 /** Validate one plan row's `coordination` object (spec §C2). */
-export declare function validateRowCoordination(value: unknown, what?: string): ValidationResult[];
+export declare function validateRowCoordination(value: unknown, what?: string, route?: RowValidationRoute): ValidationResult[];
 /** Validate a snapshot's top `coordination` block (spec §C2). */
 export declare function validateSnapshotCoordination(value: unknown, what?: string): ValidationResult[];
 /** Hash-pinned evidence reference for an absolute path, read from disk. */

package/dist/coordination.d.ts

@@ -197,6 +197,9 @@ export type PlanCoordinationOperation = {
 } | {
     kind: "complete";
     handoffId: string;
+} | {
+    kind: "repair-delivery-source";
+    handoffId: string;
 } | {
     kind: "reconcile";
     handoffId: string;
@@ -272,6 +275,8 @@ export declare function bindPlanSession(input: BindPlanSessionInput): Promise<Co
  * an unknown key anywhere is rejected before any state is touched.
  */
 export declare function mutatePlanCoordination(request: CoordinationRequest): Promise<CoordinationResult>;
+/** Test-only hook to observe the precheck→mutate gap in standalone complete. */
+export declare function setCompleteStandaloneMutateGapForTest(callback: (() => void) | undefined): void;
 /**
  * Replace a coordinated artifact with an exact-version precondition (spec §B,
  * §C4 line 156). Snapshot replacement goes through the canonical snapshot

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));
       }
     }
   }
@@ -9906,6 +9967,7 @@ var IMPLEMENTED_OPERATIONS = {
   "integration-start": true,
   "integration-accept": true,
   complete: true,
+  "repair-delivery-source": true,
   reconcile: true
 };
 function nowIso() {
@@ -10465,7 +10527,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 +11306,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 +11343,7 @@ var COORDINATOR_OPERATIONS = [
   "integration-start",
   "integration-accept",
   "complete",
+  "repair-delivery-source",
   "reconcile"
 ];
 function assertSessionRole(session, kind) {
@@ -11910,6 +11984,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 +12309,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 +12353,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) {

package/dist/workflow.d.ts

@@ -1,5 +1,5 @@
 import { type GateResult, type ValidationResult } from "./core.js";
-import { type SnapshotCoordination } from "./coordination-write.js";
+import { type RowValidationRoute, type SnapshotCoordination } from "./coordination-write.js";
 import { type IntegrationMergeLease } from "./lease.js";
 import { type PlanRow } from "./status.js";
 /** Snapshot file name inside `workflows/<id>/` ( — writer contract). */
@@ -159,6 +159,10 @@ export type WorkflowSnapshot = {
      */
     delivery?: WorkflowDeliveryEvidence;
 };
+/** True exactly for a single-row standalone development plan workflow (spec A1). */
+export declare function isStandaloneDevelopmentWorkflow(snapshot: WorkflowSnapshot): boolean;
+/** Classify row coordination validation: standalone development vs integration delivery. */
+export declare function rowValidationRoute(snapshot: WorkflowSnapshot, row: PlanRow): RowValidationRoute;
 /** Stable JSON for change detection (sorted keys, recursive). */
 export declare function stableJson(value: unknown): string;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstar-harness/engine",
-  "version": "3.10.2",
+  "version": "3.10.3",
   "description": "Morning Star Harness Workflow Engine — deterministic workflow enforcement library (path, status, lease, dispatch, sdd, iteration, lint gates).",
   "license": "MIT",
   "repository": {