@mstar-harness/dsh 3.9.3 → 3.10.0

package/dist/index.js

@@ -75,7 +75,7 @@ var require_lib = __commonJS(function(exports, module) {
     is: () => is,
     isNonNullable: () => isNonNullable,
     isNullable: () => isNullable,
-    isPlainObject: () => isPlainObject6,
+    isPlainObject: () => isPlainObject4,
     makeArray: () => makeArray,
     mapValues: () => mapValues,
     noop: () => noop,
@@ -98,7 +98,7 @@ var require_lib = __commonJS(function(exports, module) {
   function isNonNullable(value) {
     return !isNullable(value);
   }
-  function isPlainObject6(data) {
+  function isPlainObject4(data) {
     return data && typeof data === "object" && !Array.isArray(data);
   }
   function filterKeys(object, filter) {
@@ -679,7 +679,7 @@ var require_lib2 = __commonJS(function(exports, module) {
   Schema.extend = /* @__PURE__ */ __name(function extend(type, resolve22) {
     resolvers[type] = resolve22;
   }, "extend");
-  Schema.resolve = /* @__PURE__ */ __name(function resolve4(data, schema, options = {}, strict = false) {
+  Schema.resolve = /* @__PURE__ */ __name(function resolve5(data, schema, options = {}, strict = false) {
     if (!schema)
       return [data];
     if (options.ignore?.(data, schema))
@@ -1122,8 +1122,8 @@ var require_lib2 = __commonJS(function(exports, module) {
 });
 
 // src/index.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19, readdirSync as readdirSync14 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync19, readdirSync as readdirSync15 } from "node:fs";
+import { join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
   apply as applySkillLocal,
@@ -1138,28 +1138,30 @@ import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readFileSync as readFileSync2, statSync } from "node:fs";
 import { dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2 } from "node:path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync5, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync6, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute5, join as join9, relative as relative2, resolve as resolve7 } from "node:path";
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, realpathSync } from "node:fs";
-import { dirname as dirname4, join as join6, resolve as resolve5, sep } from "node:path";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute6, join as join10, relative as relative2, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname5, join as join7, resolve as resolve7, sep as sep2 } from "node:path";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve as resolve3 } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join5 } from "node:path";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, join as join4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, rmdirSync as rmdirSync2 } from "node:fs";
+import { isAbsolute as isAbsolute5, join as join6, resolve as resolve6 } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync8, realpathSync as realpathSync3 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join10, resolve as resolve8 } from "node:path";
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join11, dirname as dirname7 } from "node:path";
+import { existsSync as existsSync9, realpathSync as realpathSync4 } from "node:fs";
+import { isAbsolute as isAbsolute7, join as join11, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join12, dirname as dirname8 } from "node:path";
 import { execFileSync as execFileSync3, spawn } from "node:child_process";
-import { mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync8, realpathSync as realpathSync4, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute7, join as join12, relative as relative3, resolve as resolve9 } from "node:path";
-import { existsSync as existsSync12, readdirSync as readdirSync9, readFileSync as readFileSync11 } from "node:fs";
-import { basename as basename8, isAbsolute as isAbsolute9, join as join16, relative as relative6, resolve as resolve13, sep as sep4 } from "node:path";
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join17 } from "node:path";
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync7, readFileSync as readFileSync9, realpathSync as realpathSync5, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename as basename7, dirname as dirname9, isAbsolute as isAbsolute8, join as join13, relative as relative3, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync10, readFileSync as readFileSync12 } from "node:fs";
+import { basename as basename11, isAbsolute as isAbsolute10, join as join17, relative as relative6, resolve as resolve15, sep as sep5 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join18 } from "node:path";
 var SEVERITY_ORDER = ["critical", "high", "medium", "low", "nit"];
 function applyEnforcement(gate, opts) {
   return { ...gate, hardBlocked: opts.hard && gate.violations.length > 0 };
@@ -1395,6 +1397,302 @@ function verifyPlanExecutionLease(row, planId) {
   return { ok: violations.length === 0, violations, lease };
 }
 var heldLockDirs = new AsyncLocalStorage;
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+var writeAuthorizations = new AsyncLocalStorage2;
+var HANDOFF_STATES = [
+  "submitted",
+  "accepted",
+  "returned",
+  "integrating",
+  "merged",
+  "completed"
+];
+var PLAN_PROGRESS_STATUSES = ["InProgress", "InReview", "Blocked"];
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var GIT_SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function invalid(code, message) {
+  return { ok: false, severity: "high", code, message };
+}
+function validateBinding(value, what) {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.binding-shape", `${what} must be an object`)];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !["session_id", "session_file", "bound_at"].includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.binding-field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  if (!isNonEmptyString(value.session_id)) {
+    violations.push(invalid("coordination.row.binding-field", `${what}.session_id must be a non-empty string`));
+  }
+  if (!isNonEmptyString(value.session_file) || !isAbsolute3(String(value.session_file))) {
+    violations.push(invalid("coordination.row.binding-field", `${what}.session_file must be an absolute path`));
+  }
+  if (!isNonEmptyString(value.bound_at)) {
+    violations.push(invalid("coordination.row.binding-field", `${what}.bound_at must be a timestamp`));
+  }
+  return violations;
+}
+function validateEvidenceRef(value, what) {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.evidence-shape", `${what} must be a hash-pinned reference`)];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !["path", "sha256"].includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.evidence-field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  if (!isNonEmptyString(value.path) || !isAbsolute3(String(value.path))) {
+    violations.push(invalid("coordination.row.evidence-field", `${what}.path must be an absolute path`));
+  }
+  if (!isNonEmptyString(value.sha256) || !SHA256_HEX.test(String(value.sha256))) {
+    violations.push(invalid("coordination.row.evidence-field", `${what}.sha256 must be 64 lowercase hex`));
+  }
+  return violations;
+}
+function validatePlanProgress(value, what = "coordination.progress") {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.progress-shape", `${what} must be an object`)];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !["status", "summary", "evidence_paths", "track_branches"].includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.progress-field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  if (!PLAN_PROGRESS_STATUSES.includes(value.status)) {
+    violations.push(invalid("coordination.row.progress-field", `${what}.status must be one of ${PLAN_PROGRESS_STATUSES.join(", ")}`));
+  }
+  if (!isNonEmptyString(value.summary)) {
+    violations.push(invalid("coordination.row.progress-field", `${what}.summary must be a non-empty string`));
+  }
+  if (!Array.isArray(value.evidence_paths) || !value.evidence_paths.every(isNonEmptyString)) {
+    violations.push(invalid("coordination.row.progress-field", `${what}.evidence_paths must be an array of paths`));
+  }
+  if (value.track_branches !== undefined) {
+    if (!Array.isArray(value.track_branches) || !value.track_branches.every(isNonEmptyString)) {
+      violations.push(invalid("coordination.row.progress-field", `${what}.track_branches must be an array of branch names`));
+    }
+  }
+  return violations;
+}
+function validatePlanHandoff(value, what = "coordination.handoff") {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.handoff-shape", `${what} must be an object`)];
+  const allowed = [
+    "id",
+    "attempt",
+    "state",
+    "submitted_by",
+    "submitted_at",
+    "source_branch",
+    "source_sha",
+    "worktree_path",
+    "review_base",
+    "review_head",
+    "qc",
+    "qa",
+    "accepted_by",
+    "accepted_at",
+    "returned_at",
+    "return_reason",
+    "integration",
+    "completed_at"
+  ];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.handoff-field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  const required = [
+    "id",
+    "attempt",
+    "state",
+    "submitted_by",
+    "submitted_at",
+    "source_branch",
+    "source_sha",
+    "worktree_path",
+    "review_base",
+    "review_head"
+  ];
+  for (const key of required) {
+    if (value[key] === undefined) {
+      violations.push(invalid("coordination.row.handoff-field", `${what}.${key} is required`));
+    }
+  }
+  if (!Number.isInteger(value.attempt) || value.attempt < 1) {
+    violations.push(invalid("coordination.row.handoff-field", `${what}.attempt must be a positive integer`));
+  }
+  if (!HANDOFF_STATES.includes(value.state)) {
+    violations.push(invalid("coordination.row.handoff-field", `${what}.state must be one of ${HANDOFF_STATES.join(", ")}`));
+  }
+  if (value.id !== undefined && !isNonEmptyString(value.id)) {
+    violations.push(invalid("coordination.row.handoff-field", `${what}.id must be a non-empty string`));
+  }
+  for (const key of ["source_sha", "review_base", "review_head"]) {
+    if (value[key] !== undefined && !GIT_SHA.test(String(value[key]))) {
+      violations.push(invalid("coordination.row.handoff-field", `${what}.${key} must be a 40-hex git object id`));
+    }
+  }
+  for (const key of ["submitted_at", "accepted_at", "returned_at", "completed_at"]) {
+    if (value[key] !== undefined && !isNonEmptyString(value[key])) {
+      violations.push(invalid("coordination.row.handoff-field", `${what}.${key} must be a timestamp`));
+    }
+  }
+  if (value.worktree_path !== undefined && (!isNonEmptyString(value.worktree_path) || !isAbsolute3(String(value.worktree_path)))) {
+    violations.push(invalid("coordination.row.handoff-field", `${what}.worktree_path must be an absolute path`));
+  }
+  if (value.qc !== undefined) {
+    if (!isPlainObject2(value.qc)) {
+      violations.push(invalid("coordination.row.handoff-shape", `${what}.qc must be an object`));
+    } else {
+      const qc = value.qc;
+      const qcExtra = Object.keys(qc).filter((key) => !["decision", "reports", "consolidated"].includes(key));
+      if (qcExtra.length > 0) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qc has unexpected key(s): ${qcExtra.join(", ")}`));
+      }
+      if (!isNonEmptyString(qc.decision)) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qc.decision must be a non-empty string`));
+      }
+      if (!Array.isArray(qc.reports) || qc.reports.length === 0) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qc.reports must be a non-empty array`));
+      } else {
+        qc.reports.forEach((ref, index) => {
+          violations.push(...validateEvidenceRef(ref, `${what}.qc.reports[${index}]`));
+        });
+      }
+      violations.push(...validateEvidenceRef(qc.consolidated, `${what}.qc.consolidated`));
+    }
+  }
+  if (value.qa !== undefined) {
+    if (!isPlainObject2(value.qa)) {
+      violations.push(invalid("coordination.row.handoff-shape", `${what}.qa must be an object`));
+    } else {
+      const qa = value.qa;
+      const qaExtra = Object.keys(qa).filter((key) => !["gate", "decision", "report"].includes(key));
+      if (qaExtra.length > 0) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qa has unexpected key(s): ${qaExtra.join(", ")}`));
+      }
+      if (!isNonEmptyString(qa.gate)) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qa.gate must be a non-empty string`));
+      }
+      if (!isNonEmptyString(qa.decision)) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.qa.decision must be a non-empty string`));
+      }
+      violations.push(...validateEvidenceRef(qa.report, `${what}.qa.report`));
+    }
+  }
+  if (value.integration !== undefined) {
+    if (!isPlainObject2(value.integration)) {
+      violations.push(invalid("coordination.row.handoff-shape", `${what}.integration must be an object`));
+    } else {
+      const integration = value.integration;
+      const integrationAllowed = [
+        "target_branch",
+        "worktree_path",
+        "base_sha",
+        "started_at",
+        "result_sha",
+        "verified_at"
+      ];
+      const integrationExtra = Object.keys(integration).filter((key) => !integrationAllowed.includes(key));
+      if (integrationExtra.length > 0) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.integration has unexpected key(s): ${integrationExtra.join(", ")}`));
+      }
+      for (const key of ["target_branch", "worktree_path", "base_sha", "started_at"]) {
+        if (!isNonEmptyString(integration[key])) {
+          violations.push(invalid("coordination.row.handoff-field", `${what}.integration.${key} is required`));
+        }
+      }
+      for (const key of ["base_sha", "result_sha"]) {
+        if (integration[key] !== undefined && !GIT_SHA.test(String(integration[key]))) {
+          violations.push(invalid("coordination.row.handoff-field", `${what}.integration.${key} must be a 40-hex git object id`));
+        }
+      }
+      if (integration.result_sha !== undefined && integration.verified_at === undefined) {
+        violations.push(invalid("coordination.row.handoff-field", `${what}.integration.result_sha requires verified_at`));
+      }
+    }
+  }
+  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`));
+  }
+  return violations;
+}
+function validatePreparedCoordination(value, what = "coordination.prepared") {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.prepared-shape", `${what} must be an object`)];
+  const allowed = [
+    "assignment_path",
+    "assignment_sha256",
+    "plan_sha256",
+    "qa_gate",
+    "findings_cleanup",
+    "prepared_by",
+    "prepared_at"
+  ];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.prepared-field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  for (const key of allowed) {
+    if (!isNonEmptyString(value[key])) {
+      violations.push(invalid("coordination.row.prepared-field", `${what}.${key} is required`));
+    }
+  }
+  if (value.assignment_path !== undefined && !isAbsolute3(String(value.assignment_path))) {
+    violations.push(invalid("coordination.row.prepared-field", `${what}.assignment_path must be absolute`));
+  }
+  for (const key of ["assignment_sha256", "plan_sha256"]) {
+    if (value[key] !== undefined && !SHA256_HEX.test(String(value[key]))) {
+      violations.push(invalid("coordination.row.prepared-field", `${what}.${key} must be 64 lowercase hex`));
+    }
+  }
+  return violations;
+}
+function validateRowCoordination(value, what = "coordination") {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.row.shape", `${what} must be an object`)];
+  const allowed = ["revision", "prepared", "session", "progress", "handoff"];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.row.field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  if (!Number.isInteger(value.revision) || value.revision < 0) {
+    violations.push(invalid("coordination.row.revision", `${what}.revision must be a non-negative integer`));
+  }
+  if (value.prepared !== undefined)
+    violations.push(...validatePreparedCoordination(value.prepared, `${what}.prepared`));
+  if (value.session !== undefined)
+    violations.push(...validateBinding(value.session, `${what}.session`));
+  if (value.progress !== undefined)
+    violations.push(...validatePlanProgress(value.progress, `${what}.progress`));
+  if (value.handoff !== undefined)
+    violations.push(...validatePlanHandoff(value.handoff, `${what}.handoff`));
+  if (value.handoff !== undefined && value.session === undefined) {
+    violations.push(invalid("coordination.row.handoff-field", `${what}.handoff requires a bound plan session`));
+  }
+  return violations;
+}
+function validateSnapshotCoordination(value, what = "coordination") {
+  if (!isPlainObject2(value))
+    return [invalid("coordination.snapshot.shape", `${what} must be an object`)];
+  const violations = [];
+  const extra = Object.keys(value).filter((key) => key !== "coordinator");
+  if (extra.length > 0) {
+    violations.push(invalid("coordination.snapshot.field", `${what} has unexpected key(s): ${extra.join(", ")}`));
+  }
+  if (value.coordinator === undefined) {
+    violations.push(invalid("coordination.snapshot.field", `${what}.coordinator is required`));
+  } else {
+    violations.push(...validateBinding(value.coordinator, `${what}.coordinator`));
+  }
+  return violations;
+}
 var BRANCH_FORMS_HINT = '"Working branch: <existing>" | "Working branch: create <new> from <base>" | "Branch policy: direct on <branch> — <reason>"';
 var REQUIRED_FIELDS = [
   { key: "executeAs", label: "Execute as", code: "execute-as" },
@@ -1404,6 +1702,7 @@ var REQUIRED_FIELDS = [
 var REVIEW_SEAT_ROLES = ["qc-specialist", "qc-specialist-2", "qc-specialist-3", "code-reviewer", "qa-engineer"];
 var BUDGET_LABELS = ["Budget (review / QC seats)", "Budget"];
 var RETURN_SHAPE_LABELS = ["Return shape (review / QC seats)", "Return shape"];
+var TASK_BUDGET_LABELS = ["Task budget (implement / ops rounds)", "Task budget"];
 function violation2(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -1431,6 +1730,8 @@ function parseAssignmentFields(assignmentText) {
       fields.budget = value;
     else if (RETURN_SHAPE_LABELS.includes(label))
       fields.returnShape = value;
+    else if (TASK_BUDGET_LABELS.includes(label))
+      fields.taskBudget = value;
   }
   return fields;
 }
@@ -1545,6 +1846,12 @@ function validateAssignmentFields(assignmentText, opts = {}) {
       violations.push(violation2("high", field.code, `${subject} must declare a round ${field.label} — ${missing}`, field.fix));
     }
   }
+  if (!reviewSeat && !auditRound) {
+    const missing = describeAbsence(fields.taskBudget);
+    if (missing !== undefined) {
+      violations.push(violation2("high", "assignment.field.task-budget-missing", `implement/ops round "${role}" must declare a Task budget — ${missing}`, `add "**Task budget (implement / ops rounds)**: <one implementer round closing the task's declared Files list and verification gates> — capacity contract spec § A1/A2"`));
+    }
+  }
   if (writable) {
     const workingPresent = fields.workingBranch !== undefined && fields.workingBranch !== "";
     const policyPresent = fields.branchPolicy !== undefined && fields.branchPolicy !== "";
@@ -1665,9 +1972,8 @@ var WORKFLOW_SNAPSHOT_FILE = "snapshot.json";
 var WORKFLOW_LIFECYCLE_STATUSES = ["running", "paused", "completed", "failed", "stopped"];
 var WORKFLOW_TERMINAL_STATUSES = ["completed", "failed", "stopped"];
 var WORKFLOW_LIFECYCLE_TYPES = ["plan", "iteration"];
-function isPlainObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+var WORKFLOW_DELIVERY_KINDS = ["development", "verification/report-only"];
+var WORKFLOW_COMPOUND_OUTCOMES = ["created", "updated", "skipped"];
 function violation3(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -1679,10 +1985,65 @@ function validateNonEmptyString2(violations, value, field, missingCode, invalidC
   }
 }
 function validateWorktreePathValue(violations, value, field) {
-  if (typeof value !== "string" || value.trim() === "" || !isAbsolute4(value)) {
+  if (typeof value !== "string" || value.trim() === "" || !isAbsolute5(value)) {
     violations.push(violation3("high", "workflow.snapshot.invalid-integration-worktree-path", `${field} must be a non-empty absolute path — got ${JSON.stringify(value)}`, "record the absolute integration checkout path (integration_worktree_path)"));
   }
 }
+function deliveryEvidenceViolations(value, what) {
+  const violations = [];
+  const invalid2 = (message) => {
+    violations.push(violation3("medium", "workflow.snapshot.invalid-delivery-evidence", `${what}: ${message}`));
+  };
+  if (!isPlainObject2(value)) {
+    invalid2("must be an object");
+    return violations;
+  }
+  const members = ["compound", "pr", "merge", "completion"];
+  const unknownMembers = Object.keys(value).filter((key) => !members.includes(key));
+  if (unknownMembers.length > 0)
+    invalid2(`unknown member(s) ${unknownMembers.join(", ")} — expected ${members.join(" | ")}`);
+  const compound = value.compound;
+  if (compound !== undefined) {
+    if (!isPlainObject2(compound))
+      invalid2("compound must be an object");
+    else {
+      const unknown = Object.keys(compound).filter((key) => key !== "outcome" && key !== "reason");
+      if (unknown.length > 0)
+        invalid2(`compound has unknown key(s) ${unknown.join(", ")}`);
+      if (typeof compound.outcome !== "string" || !WORKFLOW_COMPOUND_OUTCOMES.includes(compound.outcome)) {
+        invalid2(`compound.outcome must be one of ${WORKFLOW_COMPOUND_OUTCOMES.join(" | ")} — got ${JSON.stringify(compound.outcome)}`);
+      } else if (compound.outcome === "skipped" && (typeof compound.reason !== "string" || compound.reason.trim() === "")) {
+        invalid2("compound reason is required when the disposition outcome is 'skipped' (contract §4c)");
+      } else if (compound.reason !== undefined && (typeof compound.reason !== "string" || compound.reason.trim() === "")) {
+        invalid2("compound.reason must be a non-empty string when given");
+      }
+    }
+  }
+  const stringMembers = {
+    pr: ["repo", "head", "target"],
+    merge: ["provider", "evidence"],
+    completion: ["policy", "evidence"]
+  };
+  for (const member of ["pr", "merge", "completion"]) {
+    const block = value[member];
+    if (block === undefined)
+      continue;
+    if (!isPlainObject2(block)) {
+      invalid2(`${member} must be an object`);
+      continue;
+    }
+    const fields = stringMembers[member];
+    const unknown = Object.keys(block).filter((key) => !fields.includes(key));
+    if (unknown.length > 0)
+      invalid2(`${member} has unknown key(s) ${unknown.join(", ")}`);
+    for (const field of fields) {
+      if (typeof block[field] !== "string" || block[field].trim() === "") {
+        invalid2(`${member}.${field} must be a non-empty string`);
+      }
+    }
+  }
+  return violations;
+}
 function validateWorkflowSnapshot(doc) {
   const violations = [];
   if (!isPlainObject2(doc)) {
@@ -1728,8 +2089,14 @@ function validateWorkflowSnapshot(doc) {
       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`));
+      }
     }
   }
+  if (doc.coordination !== undefined) {
+    violations.push(...validateSnapshotCoordination(doc.coordination));
+  }
   if (doc.execution_policy !== undefined) {
     if (!isPlainObject2(doc.execution_policy)) {
       violations.push(violation3("medium", "workflow.snapshot.invalid-execution-policy", "execution_policy must be an object"));
@@ -1742,7 +2109,7 @@ function validateWorkflowSnapshot(doc) {
     if (!isPlainObject2(doc.branch)) {
       violations.push(violation3("medium", "workflow.snapshot.invalid-branch", "branch must be an object"));
     } else {
-      for (const key of ["base", "integration", "target"]) {
+      for (const key of ["base", "source", "integration", "target"]) {
         if (doc.branch[key] !== undefined && (typeof doc.branch[key] !== "string" || doc.branch[key].trim() === "")) {
           violations.push(violation3("medium", "workflow.snapshot.invalid-branch", `branch.${key} must be a non-empty string`));
         }
@@ -1768,6 +2135,20 @@ function validateWorkflowSnapshot(doc) {
   if (doc.compass_ref !== undefined) {
     validateNonEmptyString2(violations, doc.compass_ref, "compass_ref", "workflow.snapshot.missing-compass-ref", "workflow.snapshot.invalid-compass-ref");
   }
+  if (doc.delivery_kind !== undefined) {
+    if (typeof doc.delivery_kind !== "string" || !WORKFLOW_DELIVERY_KINDS.includes(doc.delivery_kind)) {
+      violations.push(violation3("medium", "workflow.snapshot.invalid-delivery-kind", `delivery_kind must be one of ${WORKFLOW_DELIVERY_KINDS.join(" | ")} — got ${JSON.stringify(doc.delivery_kind)}`));
+    }
+  }
+  if (doc.project !== undefined) {
+    validateNonEmptyString2(violations, doc.project, "project", "workflow.snapshot.missing-project", "workflow.snapshot.invalid-project");
+  }
+  if (doc.completion_policy !== undefined) {
+    validateNonEmptyString2(violations, doc.completion_policy, "completion_policy", "workflow.snapshot.missing-completion-policy", "workflow.snapshot.invalid-completion-policy");
+  }
+  if (doc.delivery !== undefined) {
+    violations.push(...deliveryEvidenceViolations(doc.delivery, "delivery"));
+  }
   const terminal = typeof doc.status === "string" && WORKFLOW_TERMINAL_STATUSES.includes(doc.status);
   if (terminal) {
     if (doc.ended_at === undefined) {
@@ -1796,13 +2177,13 @@ class WorkflowSnapshotValidationError extends Error {
   }
 }
 function readWorkflowSnapshot(dir) {
-  const snapshotPath = join5(dir, WORKFLOW_SNAPSHOT_FILE);
-  if (!existsSync3(snapshotPath)) {
+  const snapshotPath = join6(dir, WORKFLOW_SNAPSHOT_FILE);
+  if (!existsSync4(snapshotPath)) {
     throw new Error(`workflow snapshot not found: ${snapshotPath}`);
   }
   let doc;
   try {
-    doc = JSON.parse(readFileSync3(snapshotPath, "utf8"));
+    doc = JSON.parse(readFileSync4(snapshotPath, "utf8"));
   } catch (error) {
     throw new Error(`Invalid JSON in ${snapshotPath}: ${error.message}`);
   }
@@ -1833,9 +2214,6 @@ var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var PLAN_STATUSES = ["Todo", "InProgress", "InReview", "Blocked", "Done"];
 var RESIDUAL_DECISIONS = ["defer", "accept", "risk-accepted"];
 var RESIDUAL_LIFECYCLES = ["open", "resolved", "waived", "superseded", "duplicate"];
-function isPlainObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function violation4(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -1860,7 +2238,7 @@ function validateNonEmptyString3(violations, value, field, missingCode, invalidC
 }
 function validatePlanRow(row) {
   const violations = [];
-  if (!isPlainObject3(row)) {
+  if (!isPlainObject2(row)) {
     return { ok: false, violations: [violation4("high", "status.plan-row.invalid", "plan row must be an object")] };
   }
   const { id, plan_id: planId, title, file, status, metadata, execution_lease } = row;
@@ -1884,10 +2262,10 @@ function validatePlanRow(row) {
   } else if (typeof status !== "string" || !PLAN_STATUSES.includes(status)) {
     violations.push(violation4("medium", "status.plan-row.invalid-status", `status must be one of ${PLAN_STATUSES.join(" | ")} — got ${JSON.stringify(status)}`));
   }
-  if (metadata !== undefined && !isPlainObject3(metadata)) {
+  if (metadata !== undefined && !isPlainObject2(metadata)) {
     violations.push(violation4("medium", "status.plan-row.invalid-metadata", "metadata must be an object"));
   }
-  if (execution_lease !== undefined && !isPlainObject3(execution_lease)) {
+  if (execution_lease !== undefined && !isPlainObject2(execution_lease)) {
     violations.push(violation4("medium", "status.plan-row.invalid-execution-lease", "execution_lease must be an object"));
   }
   if (status === "Done" && execution_lease !== undefined) {
@@ -1897,7 +2275,7 @@ function validatePlanRow(row) {
 }
 function validateResidual(entry) {
   const violations = [];
-  if (!isPlainObject3(entry)) {
+  if (!isPlainObject2(entry)) {
     return { ok: false, violations: [violation4("high", "status.residual.invalid", "residual entry must be an object")] };
   }
   const { id, title, severity, source, scope, decision, owner, target, tracking, detail_doc, lifecycle, closed_at } = entry;
@@ -1957,7 +2335,7 @@ function isHarnessRelativePath(dir) {
 }
 function validateWorkflowEntry(entry) {
   const violations = [];
-  if (!isPlainObject3(entry)) {
+  if (!isPlainObject2(entry)) {
     return {
       ok: false,
       violations: [violation4("high", "status.workflow.invalid", "workflow entry must be an object")]
@@ -1985,7 +2363,7 @@ function validateStatusV2(docOrPath, opts = {}) {
   if (typeof docOrPath === "string") {
     try {
       doc = readJson(docOrPath);
-      harnessDir = dirname4(resolve5(docOrPath));
+      harnessDir = dirname5(resolve7(docOrPath));
     } catch (error) {
       return {
         ok: false,
@@ -1995,7 +2373,7 @@ function validateStatusV2(docOrPath, opts = {}) {
   } else {
     doc = docOrPath;
   }
-  if (!isPlainObject3(doc)) {
+  if (!isPlainObject2(doc)) {
     return { ok: false, violations: [violation4("high", "status.invalid-doc", "status document must be an object")] };
   }
   if (doc.version !== 2) {
@@ -2036,7 +2414,7 @@ function validateStatusV2(docOrPath, opts = {}) {
     const seen = new Set;
     for (const entry of doc.workflows) {
       violations.push(...validateWorkflowEntry(entry).violations);
-      if (isPlainObject3(entry) && typeof entry.id === "string") {
+      if (isPlainObject2(entry) && typeof entry.id === "string") {
         if (seen.has(entry.id)) {
           violations.push(violation4("medium", "status.workflow.duplicate-id", `duplicate workflow id in workflows[]: ${JSON.stringify(entry.id)}`));
         }
@@ -2047,22 +2425,22 @@ function validateStatusV2(docOrPath, opts = {}) {
   if (harnessDir !== undefined && Array.isArray(doc.workflows)) {
     let realHarnessDir = null;
     try {
-      realHarnessDir = realpathSync(harnessDir);
+      realHarnessDir = realpathSync2(harnessDir);
     } catch {}
     for (const entry of doc.workflows) {
-      if (!isPlainObject3(entry) || typeof entry.dir !== "string")
+      if (!isPlainObject2(entry) || typeof entry.dir !== "string")
         continue;
-      const relSnapshot = join6(entry.dir, WORKFLOW_SNAPSHOT_FILE);
-      const snapshotPath = join6(harnessDir, relSnapshot);
+      const relSnapshot = join7(entry.dir, WORKFLOW_SNAPSHOT_FILE);
+      const snapshotPath = join7(harnessDir, relSnapshot);
       const label = typeof entry.id === "string" ? entry.id : relSnapshot;
       let physical;
       try {
-        physical = realpathSync(snapshotPath);
+        physical = realpathSync2(snapshotPath);
       } catch {
         violations.push(violation4("high", "status.workflow.snapshot-missing", `workflows[] lists ${JSON.stringify(label)} but its snapshot does not exist at ${JSON.stringify(relSnapshot)} — the root holds active lifecycles only; unregister the id when its snapshot is removed`));
         continue;
       }
-      if (realHarnessDir !== null && physical !== realHarnessDir && !physical.startsWith(`${realHarnessDir}${sep}`)) {
+      if (realHarnessDir !== null && physical !== realHarnessDir && !physical.startsWith(`${realHarnessDir}${sep2}`)) {
         violations.push(violation4("high", "status.workflow.snapshot-outside-harness", `workflows[] lists ${JSON.stringify(label)} but its snapshot resolves outside the harness dir (${JSON.stringify(physical)}) — symlinked snapshot paths are rejected; the snapshot must physically live under ${JSON.stringify(harnessDir)}`));
         continue;
       }
@@ -2089,23 +2467,23 @@ function validateStatusV2(docOrPath, opts = {}) {
 var validateStatus = validateStatusV2;
 function resolveCompassEnforcement(harnessDir) {
   const iterationsDir = resolveIterationDir(harnessDir);
-  if (!existsSync4(iterationsDir))
+  if (!existsSync5(iterationsDir))
     return { hard: false, source: "none" };
   let entries;
   try {
-    entries = readdirSync2(iterationsDir, { withFileTypes: true });
+    entries = readdirSync3(iterationsDir, { withFileTypes: true });
   } catch {
     return { hard: false, source: "none" };
   }
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const compassPath = join6(iterationsDir, entry.name, "delivery-compass.md");
-    if (!existsSync4(compassPath))
+    const compassPath = join7(iterationsDir, entry.name, "delivery-compass.md");
+    if (!existsSync5(compassPath))
       continue;
     let content;
     try {
-      content = readFileSync4(compassPath, "utf8");
+      content = readFileSync5(compassPath, "utf8");
     } catch {
       continue;
     }
@@ -2120,8 +2498,8 @@ function resolveCompassEnforcement(harnessDir) {
   return { hard: false, source: "none" };
 }
 function resolveMstarcEnforcement(harnessDir) {
-  const dir = resolve5(harnessDir);
-  const rc = loadMstarc(dir, dirname4(dir));
+  const dir = resolve7(harnessDir);
+  const rc = loadMstarc(dir, dirname5(dir));
   const value = rc?.config.enforcement;
   if (value === "hard")
     return { hard: true, source: "mstarc" };
@@ -2212,11 +2590,11 @@ function validateCompassShape(doc) {
 function violation5(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
-function isPlainObject4(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateCompassFrontmatter(doc) {
-  if (!isPlainObject4(doc)) {
+  if (!isPlainObject3(doc)) {
     return {
       ok: false,
       violations: [
@@ -2253,7 +2631,7 @@ function findPlanRow(snapshotDoc, planId) {
   if (!Array.isArray(snapshotDoc.plans))
     return null;
   for (const row of snapshotDoc.plans) {
-    if (!isPlainObject4(row))
+    if (!isPlainObject3(row))
       continue;
     const rowId = typeof row.id === "string" ? row.id : typeof row.plan_id === "string" ? row.plan_id : null;
     if (rowId === planId)
@@ -2349,7 +2727,7 @@ function evaluatePhaseGate(snapshotDoc, compassDoc, opts = {}) {
   };
 }
 function parseCompassFrontmatter(filePath) {
-  return parseCompassFrontmatterText(readFileSync5(filePath, "utf8"), filePath);
+  return parseCompassFrontmatterText(readFileSync6(filePath, "utf8"), filePath);
 }
 function parseCompassFrontmatterText(content, filePath) {
   const lines = content.split(/\r?\n/);
@@ -2416,9 +2794,6 @@ var PROJECT_ROADMAP_FILE = "roadmap.md";
 var PROJECT_REGISTER_FILE = "residuals.json";
 var _DEFAULT_PROJECT = "_default";
 var DATE_RE3 = /^\d{4}-\d{2}-\d{2}$/;
-function isPlainObject5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function violation6(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
@@ -2431,7 +2806,7 @@ function validateNonEmptyString4(violations, value, field, missingCode, invalidC
 }
 function validateProjectRegister(doc) {
   const violations = [];
-  if (!isPlainObject5(doc)) {
+  if (!isPlainObject2(doc)) {
     return {
       ok: false,
       violations: [violation6("high", "project.register.invalid", "project register must be an object")]
@@ -2439,7 +2814,7 @@ function validateProjectRegister(doc) {
   }
   if (doc.entries === undefined) {
     violations.push(violation6("high", "project.register.missing-entries", "missing required field: entries"));
-  } else if (!isPlainObject5(doc.entries)) {
+  } else if (!isPlainObject2(doc.entries)) {
     violations.push(violation6("high", "project.register.invalid-entries", "entries must be an object keyed by plan id"));
   } else {
     for (const [key, entries] of Object.entries(doc.entries)) {
@@ -2452,7 +2827,7 @@ function validateProjectRegister(doc) {
       }
       for (const entry of entries) {
         violations.push(...validateResidual(entry).violations);
-        if (!isPlainObject5(entry))
+        if (!isPlainObject2(entry))
           continue;
         validateNonEmptyString4(violations, entry.source_plan, "source_plan", "project.register.missing-source-plan", "project.register.invalid-source-plan");
         if (entry.registered_at === undefined) {
@@ -2474,7 +2849,7 @@ function validateProjectRegister(doc) {
 function findingsCleanupGate(register, planId, opts) {
   const mode = opts?.mode ?? "allow-residual";
   const violations = [];
-  const entries = isPlainObject5(register.entries) ? register.entries[planId] : undefined;
+  const entries = isPlainObject2(register.entries) ? register.entries[planId] : undefined;
   if (entries === undefined) {
     return { ok: true, violations };
   }
@@ -2511,25 +2886,25 @@ function findingsCleanupGate(register, planId, opts) {
   return { ok: violations.length === 0, violations };
 }
 function resolveHarnessDir(startDir = process.cwd(), opts = {}) {
-  const start = resolve7(startDir);
+  const start = resolve9(startDir);
   const explicit = opts.harnessDir ?? process.env.MSTAR_HARNESS_DIR;
   if (explicit)
-    return resolve7(start, explicit);
-  const boundary = resolve7(start, opts.workspaceRoot ?? defaultWorkspaceRoot(start));
+    return resolve9(start, explicit);
+  const boundary = resolve9(start, opts.workspaceRoot ?? defaultWorkspaceRoot(start));
   const rc = loadMstarc(start, boundary);
   if (rc !== null && rc.config.harnessDir)
-    return resolve7(rc.dir, rc.config.harnessDir);
+    return resolve9(rc.dir, rc.config.harnessDir);
   let dir = start;
   for (;; ) {
     if (!isAtOrBelow2(dir, boundary))
       return null;
-    for (const candidate of [join9(dir, ".mstar"), join9(dir, ".agents"), join9(dir, ".plans"), join9(dir, "plans")]) {
+    for (const candidate of [join10(dir, ".mstar"), join10(dir, ".agents"), join10(dir, ".plans"), join10(dir, "plans")]) {
       if (isDirectory(candidate))
         return candidate;
     }
     if (dir === boundary)
       return null;
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -2547,21 +2922,21 @@ function defaultWorkspaceRoot(startDir) {
     let boundary = startDir;
     for (const segment of cdup.split(/[\\/]/)) {
       if (segment && segment !== ".")
-        boundary = dirname5(boundary);
+        boundary = dirname6(boundary);
     }
-    return resolve7(boundary);
+    return resolve9(boundary);
   } catch {}
   return startDir;
 }
 function isAtOrBelow2(dir, root) {
   const rel = relative2(root, dir);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
 }
 function mstarcDirOverride(harnessDir, key) {
-  const dir = resolve7(harnessDir);
-  const rc = loadMstarc(dir, dirname5(dir));
+  const dir = resolve9(harnessDir);
+  const rc = loadMstarc(dir, dirname6(dir));
   const declared = rc?.config[key];
-  return declared ? resolve7(rc.dir, declared) : null;
+  return declared ? resolve9(rc.dir, declared) : null;
 }
 function assertSafePathComponent(value, what) {
   if (value === "" || value === "." || value === ".." || !/^[A-Za-z0-9._-]+$/.test(value)) {
@@ -2569,44 +2944,44 @@ function assertSafePathComponent(value, what) {
   }
 }
 function canonicalizeNearestExisting(path) {
-  const abs = resolve7(path);
+  const abs = resolve9(path);
   let dir = abs;
   const tail = [];
   for (;; ) {
-    if (existsSync7(dir)) {
+    if (existsSync8(dir)) {
       try {
-        return join9(realpathSync2(dir), ...tail);
+        return join10(realpathSync3(dir), ...tail);
       } catch {
         return abs;
       }
     }
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir)
       return abs;
-    tail.unshift(basename3(dir));
+    tail.unshift(basename5(dir));
     dir = parent;
   }
 }
 function resolveSddDir(harnessDir, planId) {
   assertSafePathComponent(planId, "planId");
-  const base = resolve7(harnessDir);
+  const base = resolve9(harnessDir);
   const declared = mstarcDirOverride(base, "sddDir");
-  const sddBase = declared !== null ? declared : join9(base, "sdd");
-  return join9(sddBase, planId);
+  const sddBase = declared !== null ? declared : join10(base, "sdd");
+  return join10(sddBase, planId);
 }
 function resolveIterationDir(harnessDir) {
   const declared = mstarcDirOverride(harnessDir, "iterationDir");
   if (declared !== null)
     return declared;
-  return join9(resolve7(harnessDir), "iterations");
+  return join10(resolve9(harnessDir), "iterations");
 }
 function resolveHarnessSubdir(startDir, opts, key, fallback) {
   const harness = resolveHarnessDir(startDir, opts);
   if (harness === null) {
-    throw new Error(`harness dir not found from ${resolve7(startDir)} — cannot resolve the ${fallback} dir (run \`mstar harness scaffold\`, pass opts.harnessDir, or set MSTAR_HARNESS_DIR)`);
+    throw new Error(`harness dir not found from ${resolve9(startDir)} — cannot resolve the ${fallback} dir (run \`mstar harness scaffold\`, pass opts.harnessDir, or set MSTAR_HARNESS_DIR)`);
   }
   const declared = mstarcDirOverride(harness, key);
-  return declared !== null ? declared : join9(resolve7(harness), fallback);
+  return declared !== null ? declared : join10(resolve9(harness), fallback);
 }
 function resolveWorkflowDir(startDir = process.cwd(), opts = {}) {
   return resolveHarnessSubdir(startDir, opts, "workflowDir", "workflows");
@@ -2686,7 +3061,7 @@ function parseMainWorktree(out) {
   if (branch === null)
     return null;
   try {
-    return { root: realpathSync3(rawPath), branch };
+    return { root: realpathSync4(rawPath), branch };
   } catch {
     return null;
   }
@@ -2754,8 +3129,8 @@ function probeCheckout(worktreePath, opts) {
     const raw = stdout.trim();
     if (raw === "")
       return { error: `no git dir reported at "${worktreePath}"` };
-    const abs = isAbsolute6(raw) ? raw : join10(worktreePath, raw);
-    return { gitDir: realpathSync3(abs) };
+    const abs = isAbsolute7(raw) ? raw : join11(worktreePath, raw);
+    return { gitDir: realpathSync4(abs) };
   } catch (err) {
     const e = err;
     if (e.killed === true || e.signal !== undefined) {
@@ -2776,7 +3151,7 @@ function probeCheckoutRoot(path, opts = {}) {
     const raw = stdout.trim();
     if (raw === "")
       return null;
-    return realpathSync3(raw);
+    return realpathSync4(raw);
   } catch {
     return null;
   }
@@ -2785,7 +3160,7 @@ function l1PreDispatchCheck(input, opts = {}) {
   const violations = [];
   const checkoutCache = new Map;
   const checkout = (path) => {
-    const key = resolve8(path);
+    const key = resolve10(path);
     if (!checkoutCache.has(key))
       checkoutCache.set(key, probeCheckout(path, opts));
     return checkoutCache.get(key);
@@ -2824,7 +3199,7 @@ function l1PreDispatchCheck(input, opts = {}) {
     violations.push(violation8("high", "worktree.l1.lease-branch-missing", `execution_lease.working_branch is empty for plan "${planId}"`, "record the lease working_branch before dispatch"));
   }
   if (integrationRequired && integrationWorktreePath.trim() !== "" && integrationBranch.trim() !== "") {
-    if (!existsSync8(integrationWorktreePath)) {
+    if (!existsSync9(integrationWorktreePath)) {
       violations.push(violation8("high", "worktree.l1.integration-missing", `integration worktree "${integrationWorktreePath}" does not exist for plan "${planId}" — the integration checkout must exist before dispatch`, `create it before dispatch: git worktree add ${shellQuote(integrationWorktreePath)} ${shellQuote(integrationBranch)}`));
     } else {
       const probe = probeBranch(integrationWorktreePath, opts);
@@ -2836,10 +3211,10 @@ function l1PreDispatchCheck(input, opts = {}) {
     }
   }
   const identityViolation = (aPath, bPath, code, describe, fix) => {
-    if (resolve8(aPath) === resolve8(bPath)) {
+    if (resolve10(aPath) === resolve10(bPath)) {
       return violation8("critical", code, `${describe} — the same checkout (normalized path equality) is not isolation`, fix);
     }
-    if (!existsSync8(aPath) || !existsSync8(bPath))
+    if (!existsSync9(aPath) || !existsSync9(bPath))
       return null;
     const a = checkout(aPath);
     const b = checkout(bPath);
@@ -2869,7 +3244,7 @@ function l1PreDispatchCheck(input, opts = {}) {
     if (v !== null)
       violations.push(v);
   }
-  if (leaseWorktreePath.trim() !== "" && !existsSync8(leaseWorktreePath)) {
+  if (leaseWorktreePath.trim() !== "" && !existsSync9(leaseWorktreePath)) {
     violations.push(violation8("high", "worktree.l1.feature-missing", `feature worktree directory "${leaseWorktreePath}" does not exist for plan "${planId}"`, `create it before dispatch: git worktree add ${shellQuote(leaseWorktreePath)} <working-branch>`));
   } else if (leaseWorktreePath.trim() !== "" && leaseWorkingBranch.trim() !== "") {
     const probe = probeBranch(leaseWorktreePath, opts);
@@ -2893,17 +3268,17 @@ function l2PreDispatchCheck(input, opts = {}) {
       violations.push(violation8("high", "worktree.l2.track-invalid", `track ${index + 1} is missing worktreePath and/or workingBranch`, "fill both fields for every track"));
       return;
     }
-    if (!isAbsolute6(track.worktreePath)) {
+    if (!isAbsolute7(track.worktreePath)) {
       violations.push(violation8("high", "worktree.l2.track-path-relative", `track ${index + 1} worktreePath "${track.worktreePath}" is not an absolute path — L2 tracks MUST use absolute worktree checkout paths (consistent with the lease validator's absolute worktree_path enforcement)`, `use an absolute path for track ${index + 1} (e.g. /Users/<you>/worktrees/<branch>)`));
       return;
     }
-    const normalized = resolve8(track.worktreePath);
+    const normalized = resolve10(track.worktreePath);
     if (seenPaths.has(normalized)) {
       violations.push(violation8("high", "worktree.l2.track-path-collision", `duplicate worktreePath "${track.worktreePath}" across parallel tracks — L2 parallel-writable isolation requires a distinct absolute Worktree path per track (N parallel invokes ≠ isolation)`, "give every parallel track its own git worktree checkout"));
       return;
     }
     seenPaths.add(normalized);
-    if (!existsSync8(track.worktreePath)) {
+    if (!existsSync9(track.worktreePath)) {
       violations.push(violation8("high", "worktree.l2.track-missing", `track worktree directory "${track.worktreePath}" does not exist`, `create it before dispatch: git worktree add ${track.worktreePath} ${track.workingBranch}`));
       return;
     }
@@ -2929,33 +3304,33 @@ function assertBranchAlignment(worktreePath, expectedBranch, opts = {}) {
 function shellQuote(value) {
   return "'" + value.replaceAll("'", `'"'"'`) + "'";
 }
-function isPlainObject8(value) {
+function isPlainObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function collectActiveLifecycleBranches(snapshots) {
   const owned = new Set;
   for (const doc of snapshots) {
     const branch = doc.branch;
-    if (isPlainObject8(branch) && typeof branch.integration === "string" && branch.integration.trim() !== "") {
+    if (isPlainObject6(branch) && typeof branch.integration === "string" && branch.integration.trim() !== "") {
       owned.add(branch.integration);
     }
     if (!Array.isArray(doc.plans))
       continue;
     for (const row of doc.plans) {
-      if (!isPlainObject8(row))
+      if (!isPlainObject6(row))
         continue;
       const lease = row.execution_lease;
-      if (isPlainObject8(lease) && typeof lease.working_branch === "string" && lease.working_branch.trim() !== "") {
+      if (isPlainObject6(lease) && typeof lease.working_branch === "string" && lease.working_branch.trim() !== "") {
         owned.add(lease.working_branch);
       }
       const meta = row.metadata;
-      if (isPlainObject8(meta) && Array.isArray(meta.track_branches)) {
+      if (isPlainObject6(meta) && Array.isArray(meta.track_branches)) {
         for (const branch2 of meta.track_branches) {
           if (typeof branch2 === "string" && branch2.trim() !== "")
             owned.add(branch2);
         }
       }
-      if (isPlainObject8(meta) && typeof meta.working_branch === "string" && meta.working_branch.trim() !== "") {
+      if (isPlainObject6(meta) && typeof meta.working_branch === "string" && meta.working_branch.trim() !== "") {
         owned.add(meta.working_branch);
       }
     }
@@ -2963,8 +3338,8 @@ function collectActiveLifecycleBranches(snapshots) {
   return [...owned];
 }
 function scanActiveLifecycleBranches(harnessDir, governingWorkflowId) {
-  const registerPath = join11(harnessDir, "status.json");
-  if (!existsSync9(registerPath))
+  const registerPath = join12(harnessDir, "status.json");
+  if (!existsSync10(registerPath))
     return { kind: "ok", branches: [], notes: [] };
   let register;
   try {
@@ -2972,7 +3347,7 @@ function scanActiveLifecycleBranches(harnessDir, governingWorkflowId) {
   } catch (error) {
     return { kind: "refusal", code: "worktree.l1.lifecycle-register-unreadable", detail: `${registerPath}: ${error.message}` };
   }
-  if (!isPlainObject8(register) || register.version !== 2 || !Array.isArray(register.workflows)) {
+  if (!isPlainObject6(register) || register.version !== 2 || !Array.isArray(register.workflows)) {
     return {
       kind: "refusal",
       code: "worktree.l1.lifecycle-register-unreadable",
@@ -3003,10 +3378,10 @@ function scanActiveLifecycleBranches(harnessDir, governingWorkflowId) {
     }
     if (id === governingWorkflowId)
       continue;
-    const snapshotPath = join11(workflowsDir, id, WORKFLOW_SNAPSHOT_FILE);
+    const snapshotPath = join12(workflowsDir, id, WORKFLOW_SNAPSHOT_FILE);
     let snapshot;
     try {
-      const read = readWorkflowSnapshot(dirname7(snapshotPath));
+      const read = readWorkflowSnapshot(dirname8(snapshotPath));
       snapshot = read.snapshot;
       notes.push(...read.diagnostics);
     } catch (error) {
@@ -3059,14 +3434,14 @@ function gitOut(cwd, args) {
   }
 }
 function probeHarnessWithStatus(root) {
-  if (isFile2(join12(root, ".mstar", "status.json")))
-    return join12(root, ".mstar");
-  if (isFile2(join12(root, ".agents", "status.json")))
-    return join12(root, ".agents");
-  if (hasWorkflowSnapshot(join12(root, ".mstar")))
-    return join12(root, ".mstar");
-  if (hasWorkflowSnapshot(join12(root, ".agents")))
-    return join12(root, ".agents");
+  if (isFile2(join13(root, ".mstar", "status.json")))
+    return join13(root, ".mstar");
+  if (isFile2(join13(root, ".agents", "status.json")))
+    return join13(root, ".agents");
+  if (hasWorkflowSnapshot(join13(root, ".mstar")))
+    return join13(root, ".mstar");
+  if (hasWorkflowSnapshot(join13(root, ".agents")))
+    return join13(root, ".agents");
   return null;
 }
 function hasWorkflowSnapshot(harnessDir) {
@@ -3074,13 +3449,13 @@ function hasWorkflowSnapshot(harnessDir) {
   try {
     workflowsDir = resolveWorkflowDir(harnessDir, { harnessDir });
   } catch {
-    workflowsDir = join12(harnessDir, "workflows");
+    workflowsDir = join13(harnessDir, "workflows");
   }
   if (!isDirectory2(workflowsDir))
     return false;
   try {
-    for (const entry of readdirSync6(workflowsDir, { withFileTypes: true })) {
-      if (entry.isDirectory() && isFile2(join12(workflowsDir, entry.name, "snapshot.json")))
+    for (const entry of readdirSync7(workflowsDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && isFile2(join13(workflowsDir, entry.name, "snapshot.json")))
         return true;
     }
   } catch {
@@ -3089,16 +3464,16 @@ function hasWorkflowSnapshot(harnessDir) {
   return false;
 }
 function checkoutRootNearestExisting(dir, boundary) {
-  const stop = resolve9(boundary);
-  const startInside = isInside(resolve9(dir), stop);
-  let current = resolve9(dir);
+  const stop = resolve11(boundary);
+  const startInside = isInside(resolve11(dir), stop);
+  let current = resolve11(dir);
   for (;; ) {
     const probed = probeCheckoutRoot(current);
     if (probed !== null)
       return probed;
     if (startInside && current === stop)
       return null;
-    const parent = dirname8(current);
+    const parent = dirname9(current);
     if (parent === current)
       return null;
     if (startInside && !isInside(parent, stop))
@@ -3118,7 +3493,7 @@ function sddWorkspace(planId, opts = {}) {
     if (!isDirectory2(controlRoot)) {
       throw new SddScriptError(`mstar sdd workspace: CONTROL_ROOT / MSTAR_CONTROL_ROOT is not a directory: ${controlRoot}`, 1);
     }
-    const supplied = realpathSync4(controlRoot);
+    const supplied = realpathSync5(controlRoot);
     const main = readMainWorktree(supplied);
     if (main !== null) {
       if (main.root !== supplied) {
@@ -3127,7 +3502,7 @@ function sddWorkspace(planId, opts = {}) {
 ` + `  Re-run with MSTAR_CONTROL_ROOT=${main.root}`, 1);
       }
       root = main.root;
-    } else if (isFile2(join12(supplied, ".git")) || gitOut(supplied, ["rev-parse", "--is-inside-work-tree"]) === "true") {
+    } else if (isFile2(join13(supplied, ".git")) || gitOut(supplied, ["rev-parse", "--is-inside-work-tree"]) === "true") {
       throw new SddScriptError(`mstar sdd workspace: cannot verify the main worktree for CONTROL_ROOT "${supplied}" (git worktree discovery failed).
   Refusing to resolve or create any SDD tree without a verified main worktree.`, 1);
     } else {
@@ -3145,22 +3520,22 @@ function sddWorkspace(planId, opts = {}) {
   const harnessOverride = opts.harnessDir ?? (process.env.MSTAR_HARNESS_DIR || undefined);
   let harnessDir;
   if (harnessOverride) {
-    harnessDir = resolve9(root, harnessOverride);
+    harnessDir = resolve11(root, harnessOverride);
   } else {
     const rc = findMstarc(root, root);
-    const rcHarnessDir = rc !== null ? parseMstarc(readFileSync8(rc, "utf8")).harnessDir : undefined;
+    const rcHarnessDir = rc !== null ? parseMstarc(readFileSync9(rc, "utf8")).harnessDir : undefined;
     if (rcHarnessDir) {
-      harnessDir = resolve9(rc !== null ? dirname8(rc) : root, rcHarnessDir);
+      harnessDir = resolve11(rc !== null ? dirname9(rc) : root, rcHarnessDir);
     } else {
       const probed = probeHarnessWithStatus(root);
       if (probed) {
         harnessDir = probed;
-      } else if (isDirectory2(join12(root, ".mstar"))) {
-        harnessDir = join12(root, ".mstar");
-      } else if (isDirectory2(join12(root, ".agents"))) {
-        harnessDir = join12(root, ".agents");
+      } else if (isDirectory2(join13(root, ".mstar"))) {
+        harnessDir = join13(root, ".mstar");
+      } else if (isDirectory2(join13(root, ".agents"))) {
+        harnessDir = join13(root, ".agents");
       } else {
-        harnessDir = join12(root, ".mstar");
+        harnessDir = join13(root, ".mstar");
       }
     }
   }
@@ -3171,9 +3546,9 @@ function sddWorkspace(planId, opts = {}) {
   }
   const sddDir = resolveSddDir(harnessDir, planId);
   mkdirSync6(sddDir, { recursive: true });
-  writeFileSync4(join12(sddDir, ".gitignore"), `*
+  writeFileSync4(join13(sddDir, ".gitignore"), `*
 `);
-  return realpathSync4(sddDir);
+  return realpathSync5(sddDir);
 }
 function taskBrief(planFile, taskN, outFile, opts = {}) {
   if (!planFile || !Number.isInteger(taskN) || taskN < 1) {
@@ -3182,7 +3557,7 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   const bound = opts.context;
   const observedCwd = opts.cwd ?? process.cwd();
   if (bound) {
-    const inputPlan = canonicalizeNearestExisting(resolve9(observedCwd, planFile));
+    const inputPlan = canonicalizeNearestExisting(resolve11(observedCwd, planFile));
     if (inputPlan !== canonicalizeNearestExisting(bound.planFile)) {
       throwGateFail([
         contextViolation("high", "sdd.context.plan-file-mismatch", `plan file "${planFile}" does not match the bound context plan file "${bound.planFile}" — ` + "bound mode extracts only the resolved context's plan; refused before any read or write")
@@ -3191,16 +3566,16 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   }
   let content;
   try {
-    content = readFileSync8(planFile, "utf8");
+    content = readFileSync9(planFile, "utf8");
   } catch {
     throw new SddScriptError(`no such plan file: ${planFile}`, 2);
   }
   let out;
   let mkdirAfterGate = null;
   if (outFile) {
-    out = bound ? resolve9(observedCwd, outFile) : outFile;
+    out = bound ? resolve11(observedCwd, outFile) : outFile;
   } else if (bound) {
-    out = join12(bound.sddDir, `task-${taskN}-brief.md`);
+    out = join13(bound.sddDir, `task-${taskN}-brief.md`);
     mkdirAfterGate = bound.sddDir;
   } else {
     const sddDir = opts.sddDir ?? process.env.SDD_DIR;
@@ -3208,7 +3583,7 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
       throw new SddScriptError("mstar sdd task-brief: set SDD_DIR or pass OUTFILE (run mstar sdd workspace PLAN_ID first)", 2);
     }
     mkdirSync6(sddDir, { recursive: true });
-    out = join12(sddDir, `task-${taskN}-brief.md`);
+    out = join13(sddDir, `task-${taskN}-brief.md`);
   }
   if (bound) {
     const gate2 = checkSddAction(bound, { kind: "artifact", cwd: observedCwd, target: out });
@@ -3241,15 +3616,15 @@ function taskBrief(planFile, taskN, outFile, opts = {}) {
   if (printed.length === 0) {
     throw new SddScriptError(`task ${taskN} not found in ${planFile} (no heading matching Task ${taskN})`, 3);
   }
-  return bound ? resolve9(observedCwd, out) : out;
+  return bound ? resolve11(observedCwd, out) : out;
 }
 function isInside(child, ancestor) {
   const rel = relative3(ancestor, child);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute7(rel);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute8(rel);
 }
 function canonicalDir(path) {
   try {
-    return statSync4(path).isDirectory() ? realpathSync4(path) : null;
+    return statSync4(path).isDirectory() ? realpathSync5(path) : null;
   } catch {
     return null;
   }
@@ -3279,11 +3654,11 @@ function checkSddAction(context, action) {
   const featureReal = canonicalDir(context.featureCwd);
   const canonicalSddDir = canonicalizeNearestExisting(context.sddDir);
   const canonicalPlanFile = canonicalizeNearestExisting(context.planFile);
-  const cwdResolved = resolve9(action.cwd);
+  const cwdResolved = resolve11(action.cwd);
   const checkTarget = (baseDir, target, kind) => {
     if (featureReal === null)
       return;
-    const targetAbs = resolve9(baseDir, target);
+    const targetAbs = resolve11(baseDir, target);
     const canonical = canonicalizeNearestExisting(targetAbs);
     if (!isInside(canonical, featureReal)) {
       const declaredPrefix = targetAbs === featureReal || targetAbs.startsWith(`${featureReal}/`);
@@ -3311,10 +3686,10 @@ function checkSddAction(context, action) {
       add("sdd.context.target-missing", "artifact checks require the destination target");
       return { ok: false, violations };
     }
-    const targetAbs = resolve9(cwdResolved, action.target);
+    const targetAbs = resolve11(cwdResolved, action.target);
     const canonical = canonicalizeNearestExisting(targetAbs);
     if (!isInside(canonical, canonicalSddDir) && canonical !== canonicalPlanFile) {
-      const rawSddDir = resolve9(context.sddDir);
+      const rawSddDir = resolve11(context.sddDir);
       const declaredPrefix = targetAbs === rawSddDir || targetAbs.startsWith(`${rawSddDir}/`) || targetAbs === canonicalSddDir || targetAbs.startsWith(`${canonicalSddDir}/`) || targetAbs === canonicalPlanFile;
       if (declaredPrefix) {
         add("sdd.context.artifact-symlink-escape", `artifact target "${targetAbs}" canonicalizes to "${canonical}", outside the plan's control sddDir — symlink escape refused before write`);
@@ -4047,7 +4422,7 @@ function referenceExists(repoRoot, docText) {
     if (ref === "" || seen.has(ref))
       continue;
     seen.add(ref);
-    if (SCHEME_RE.test(ref) || ref.startsWith("{") || ref.startsWith("#") || ref.includes("*") || ref.includes("?") || ref.startsWith("~") || isAbsolute9(ref)) {
+    if (SCHEME_RE.test(ref) || ref.startsWith("{") || ref.startsWith("#") || ref.includes("*") || ref.includes("?") || ref.startsWith("~") || isAbsolute10(ref)) {
       continue;
     }
     if (ref.includes("/") || REF_EXT_RE.test(ref)) {
@@ -4066,7 +4441,7 @@ function referenceExists(repoRoot, docText) {
       const dir = stack.pop();
       let entries;
       try {
-        entries = readdirSync9(dir, { withFileTypes: true });
+        entries = readdirSync10(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -4075,7 +4450,7 @@ function referenceExists(repoRoot, docText) {
           break;
         if (entry.isDirectory()) {
           if (!WALK_SKIP_DIRS.has(entry.name))
-            stack.push(join16(dir, entry.name));
+            stack.push(join17(dir, entry.name));
         } else if (!entry.isSymbolicLink()) {
           const base = entry.name.replace(/\.(?:ts|tsx|js|jsx|mjs|cjs)$/, "");
           if (moduleNames.has(base))
@@ -4087,7 +4462,7 @@ function referenceExists(repoRoot, docText) {
   for (const { ref, isSymbol, module } of refs) {
     if (!isSymbol || module === undefined) {
       const candidate = ref.replace(LINE_SUFFIX_RE, "").replace(ANCHOR_RE, "");
-      if (existsSync12(resolve13(repoRoot, candidate))) {
+      if (existsSync13(resolve15(repoRoot, candidate))) {
         checked++;
       } else {
         violations.push(violation11("medium", "compound.reference.missing-file", `referenced path \`${ref}\` does not exist under ${repoRoot} (compound-refresh Phase 2: referenced code still exists?)`, "update the doc to reference an existing path, or delete the stale reference"));
@@ -4107,18 +4482,18 @@ function collectKnowledgeDocs(dir) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync9(current, { withFileTypes: true });
+      entries = readdirSync10(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink())
         continue;
-      const full = join16(current, entry.name);
+      const full = join17(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
       } else if (entry.name.endsWith(".md") && entry.name !== "README.md" && entry.name !== "index.md") {
-        docs.push(relative6(dir, full).split(sep4).join("/"));
+        docs.push(relative6(dir, full).split(sep5).join("/"));
       }
     }
   }
@@ -4134,14 +4509,14 @@ function normalizeIndexRef(cell) {
 }
 function assertIndexRows(knowledgeDir) {
   const violations = [];
-  const readmePath = join16(knowledgeDir, "README.md");
-  if (!existsSync12(readmePath)) {
+  const readmePath = join17(knowledgeDir, "README.md");
+  if (!existsSync13(readmePath)) {
     violations.push(violation11("medium", "compound.index.missing-readme", `missing ${readmePath} — the knowledge index is required (mstar-compound Phase 6: every doc gets a README.md row)`, "create knowledge/README.md with a Document / Source Plan / Description / Status table"));
     return { ok: false, violations };
   }
   const docs = collectKnowledgeDocs(knowledgeDir);
   const rows = new Set;
-  for (const line of readFileSync11(readmePath, "utf8").split(/\r?\n/)) {
+  for (const line of readFileSync12(readmePath, "utf8").split(/\r?\n/)) {
     if (!line.trim().startsWith("|"))
       continue;
     const cells = line.split("|").map((c) => c.trim());
@@ -4159,16 +4534,16 @@ function assertIndexRows(knowledgeDir) {
   return { ok: violations.length === 0, violations };
 }
 function isFileLikeRoot(root) {
-  return /^[^.]*\.[A-Za-z0-9]{1,10}$/.test(basename8(root));
+  return /^[^.]*\.[A-Za-z0-9]{1,10}$/.test(basename11(root));
 }
 function scopeGuard(path, allowedRoots) {
-  const resolved = resolve13(path);
+  const resolved = resolve15(path);
   for (const root of allowedRoots) {
-    const r = resolve13(root);
+    const r = resolve15(root);
     if (isFileLikeRoot(r)) {
       if (resolved === r)
         return { ok: true, violations: [] };
-    } else if (resolved === r || resolved.startsWith(r + sep4)) {
+    } else if (resolved === r || resolved.startsWith(r + sep5)) {
       return { ok: true, violations: [] };
     }
   }
@@ -4324,8 +4699,8 @@ function validateRoleMapping(rolesDir, options = {}) {
   const violations = [];
   const referenceById = new Map(mapping.map((m) => [m.agentId, m.reference]));
   for (const { agentId, reference } of mapping) {
-    if (!existsSync13(join17(rolesDir, reference))) {
-      violations.push(violation13("medium", "roles.mapping.reference.missing", `role "${agentId}" maps to ${reference} which does not exist under ${rolesDir} (mstar-roles § Role Reference Mapping)`, `create ${join17(rolesDir, reference)} or fix the mapping row`));
+    if (!existsSync14(join18(rolesDir, reference))) {
+      violations.push(violation13("medium", "roles.mapping.reference.missing", `role "${agentId}" maps to ${reference} which does not exist under ${rolesDir} (mstar-roles § Role Reference Mapping)`, `create ${join18(rolesDir, reference)} or fix the mapping row`));
     }
   }
   for (const { family, memberIds } of families) {
@@ -4584,7 +4959,7 @@ class DshMstar extends Service {
 // src/gates/_shared.ts
 var import_schemastery = __toESM(require_lib2(), 1);
 import { existsSync as existsSync2 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var STATUS_FILE = "status.json";
 var PERSONA_INTERPOLATION_HAZARD = /\{\{[\s\S]*\}\}/;
@@ -4683,14 +5058,14 @@ class HarnessResolver {
   explicit;
   cache = new Map;
   constructor(explicit) {
-    this.explicit = explicit !== undefined && explicit.trim() !== "" ? resolve4(process.cwd(), explicit) : null;
+    this.explicit = explicit !== undefined && explicit.trim() !== "" ? resolve5(process.cwd(), explicit) : null;
   }
   forWorkspace(cwd) {
     if (this.explicit !== null)
       return this.explicit;
     if (cwd === undefined || cwd.trim() === "")
       return null;
-    const abs = resolve4(cwd);
+    const abs = resolve5(cwd);
     const hit = this.cache.get(abs);
     if (hit !== undefined)
       return hit;
@@ -4761,21 +5136,21 @@ function skillLocalConfig(config) {
 }
 
 // src/gates/catalog.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync4, realpathSync as realpathSync7 } from "node:fs";
-import { basename as basename4, isAbsolute as isAbsolute8, join as join18, relative as relative7, sep as sep3 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, readdirSync as readdirSync5, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename6, isAbsolute as isAbsolute9, join as join19, relative as relative7, sep as sep3 } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // src/gates/agent-flow.ts
-import { appendFileSync, closeSync, existsSync as existsSync14, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync6, readSync, renameSync as renameSync2, rmdirSync, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join13 } from "node:path";
+import { appendFileSync, closeSync, existsSync as existsSync11, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, readSync, renameSync as renameSync2, rmdirSync, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/gates/dispatch.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { basename as basename2, join as join7, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { basename as basename3, join as join8, resolve as resolve8 } from "node:path";
 
 // src/gates/workflow-selection.ts
-import { existsSync as existsSync6, readdirSync, realpathSync as realpathSync5, statSync as statSync2 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute3, join as join4, normalize, relative as relative4, sep as sep2 } from "node:path";
+import { existsSync as existsSync3, readdirSync, realpathSync, statSync as statSync2 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join5, normalize, relative as relative4, sep } from "node:path";
 var TERMINAL_STATUS_CACHE_MAX = 64;
 var terminalStatusCache = new Map;
 function terminalStatusOf(snapshotPath) {
@@ -4811,7 +5186,7 @@ function terminalStatusOf(snapshotPath) {
 }
 function stripTrailingSeparators(path) {
   let out = path;
-  while (out.length > 1 && out.endsWith(sep2))
+  while (out.length > 1 && out.endsWith(sep))
     out = out.slice(0, -1);
   return out;
 }
@@ -4821,13 +5196,13 @@ function lexical(path) {
 function canonicalPath(path) {
   const fallback = lexical(path);
   try {
-    return { kind: "ok", path: lexical(realpathSync5(path)) };
+    return { kind: "ok", path: lexical(realpathSync(path)) };
   } catch (error) {
     return error.code === "ENOENT" ? { kind: "missing", path: fallback } : { kind: "error" };
   }
 }
 function within(root, cwd) {
-  if (root === "" || cwd === "" || !isAbsolute3(root) || !isAbsolute3(cwd))
+  if (root === "" || cwd === "" || !isAbsolute4(root) || !isAbsolute4(cwd))
     return false;
   const rootCanonical = canonicalPath(root);
   if (rootCanonical.kind === "error")
@@ -4841,7 +5216,7 @@ function within(root, cwd) {
   if (rootPath === cwdPath)
     return true;
   const rel = relative4(rootPath, cwdPath);
-  return rel !== "" && !isAbsolute3(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
+  return rel !== "" && !isAbsolute4(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
 }
 function validLeases(snapshot) {
   if (!Array.isArray(snapshot.plans))
@@ -4856,8 +5231,8 @@ function validLeases(snapshot) {
   return leases;
 }
 function readSnapshot(harnessDir, entry) {
-  const snapshotPath = join4(harnessDir, entry.dir, WORKFLOW_SNAPSHOT_FILE);
-  if (!existsSync6(snapshotPath))
+  const snapshotPath = join5(harnessDir, entry.dir, WORKFLOW_SNAPSHOT_FILE);
+  if (!existsSync3(snapshotPath))
     return;
   try {
     const snapshot = asRecord(readJson(snapshotPath));
@@ -4913,8 +5288,8 @@ function automaticBinding(harnessDir, entries, hint) {
   return byCwd === undefined ? undefined : { kind: "active", workflowId: byCwd.id, dir: byCwd.dir };
 }
 function resolveActiveWorkflow(harnessDir, hint) {
-  const statusPath = join4(harnessDir, STATUS_FILE);
-  if (!existsSync6(statusPath)) {
+  const statusPath = join5(harnessDir, STATUS_FILE);
+  if (!existsSync3(statusPath)) {
     return {
       kind: "error",
       code: "status.missing",
@@ -5004,7 +5379,7 @@ function resolveReadWorkflow(harnessDir, hint) {
   if (active.kind === "error" && active.code !== "workflow.selection.no-active")
     return active;
   const workflowsDir = resolveWorkflowDir(harnessDir, { harnessDir });
-  if (!existsSync6(workflowsDir)) {
+  if (!existsSync3(workflowsDir)) {
     return {
       kind: "error",
       code: "workflow.selection.no-snapshot",
@@ -5025,8 +5400,8 @@ function resolveReadWorkflow(harnessDir, hint) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const snapshotPath = join4(workflowsDir, entry.name, WORKFLOW_SNAPSHOT_FILE);
-    if (!existsSync6(snapshotPath)) {
+    const snapshotPath = join5(workflowsDir, entry.name, WORKFLOW_SNAPSHOT_FILE);
+    if (!existsSync3(snapshotPath)) {
       terminalStatusCache.delete(snapshotPath);
       continue;
     }
@@ -5034,11 +5409,11 @@ function resolveReadWorkflow(harnessDir, hint) {
     if (verdict === undefined || !verdict.terminal)
       continue;
     if (best === undefined || verdict.mtimeMs > best.mtimeMs) {
-      best = { workflowId: entry.name, dir: join4(relative4(harnessDir, workflowsDir), entry.name), mtimeMs: verdict.mtimeMs };
+      best = { workflowId: entry.name, dir: join5(relative4(harnessDir, workflowsDir), entry.name), mtimeMs: verdict.mtimeMs };
     }
   }
   for (const cachedPath of terminalStatusCache.keys()) {
-    if (!existsSync6(join4(dirname6(cachedPath), WORKFLOW_SNAPSHOT_FILE))) {
+    if (!existsSync3(join5(dirname7(cachedPath), WORKFLOW_SNAPSHOT_FILE))) {
       terminalStatusCache.delete(cachedPath);
     }
   }
@@ -5207,12 +5582,12 @@ function isNaValue(value) {
 function planIdOf(headerRegion) {
   const planPath = assignmentHeaderValue(headerRegion, "Plan Path");
   if (!isNaValue(planPath)) {
-    const id = basename2(firstToken(planPath) ?? "");
+    const id = basename3(firstToken(planPath) ?? "");
     return id.endsWith(".md") ? id.slice(0, -3) : id;
   }
   const sddDir = assignmentHeaderValue(headerRegion, "SDD dir");
   if (!isNaValue(sddDir)) {
-    const id = basename2(firstToken(sddDir) ?? "");
+    const id = basename3(firstToken(sddDir) ?? "");
     return id === "" ? undefined : id;
   }
   const planId = assignmentHeaderValue(headerRegion, "plan_id");
@@ -5237,12 +5612,12 @@ function leaseGateViolations(harnessDir, exec, writable, prompt, hint) {
     if (!sdd)
       return [];
     if (selection.kind === "error" && selection.code === "status.unreadable") {
-      return [leaseViolation("lease.dispatch.unreadable", `cannot read ${join7(harnessDir, STATUS_FILE)}: the plan's execution_lease state is unverifiable; STOP before writable dispatch`, "restore a valid status.json (the status gate refuses invalid writes)")];
+      return [leaseViolation("lease.dispatch.unreadable", `cannot read ${join8(harnessDir, STATUS_FILE)}: the plan's execution_lease state is unverifiable; STOP before writable dispatch`, "restore a valid status.json (the status gate refuses invalid writes)")];
     }
-    return [leaseViolation("lease.dispatch.unverifiable", `${join7(harnessDir, STATUS_FILE)}: ${selection.kind === "error" ? selection.message : "no active workflow"} — the plan's execution_lease state is unverifiable; STOP before writable dispatch`, "create a valid v2 status.json registering an active workflow (first implement dispatch requires a plan row + lease)")];
+    return [leaseViolation("lease.dispatch.unverifiable", `${join8(harnessDir, STATUS_FILE)}: ${selection.kind === "error" ? selection.message : "no active workflow"} — the plan's execution_lease state is unverifiable; STOP before writable dispatch`, "create a valid v2 status.json registering an active workflow (first implement dispatch requires a plan row + lease)")];
   }
-  const snapshotPath = join7(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
-  if (!existsSync10(snapshotPath)) {
+  const snapshotPath = join8(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+  if (!existsSync7(snapshotPath)) {
     if (!sdd)
       return [];
     return [leaseViolation("lease.dispatch.unverifiable", `${snapshotPath} is missing — the plan's execution_lease state is unverifiable; STOP before writable dispatch`, "create a valid workflow snapshot registering the plan row (first implement dispatch requires a plan row)")];
@@ -5275,7 +5650,7 @@ function leaseGateViolations(harnessDir, exec, writable, prompt, hint) {
     const wt = worktree === undefined ? undefined : firstToken(worktree);
     if (isNaValue(wt)) {
       violations.push(leaseViolation("lease.dispatch.worktree-mismatch", "Assignment declares no Worktree path — cannot confirm this dispatch matches execution_lease.worktree_path", "add the absolute Worktree path to the Assignment (must equal the lease worktree_path)"));
-    } else if (resolve6(wt) !== resolve6(String(lease.worktree_path ?? ""))) {
+    } else if (resolve8(wt) !== resolve8(String(lease.worktree_path ?? ""))) {
       violations.push(leaseViolation("lease.dispatch.worktree-mismatch", `Assignment Worktree path "${wt}" differs from execution_lease.worktree_path "${String(lease.worktree_path)}"`, "align the Assignment with the lease worktree path (or update the lease)"));
     }
     const forms = parseAssignmentBranchForms(header);
@@ -5316,7 +5691,7 @@ function worktreeL2Violations(header) {
   return violations;
 }
 function activeSnapshotRows(harnessDir, hint) {
-  if (!existsSync10(join7(harnessDir, STATUS_FILE)))
+  if (!existsSync7(join8(harnessDir, STATUS_FILE)))
     return { rows: null, snapshot: null, workflowId: null, unreadable: false };
   const selection = resolveActiveWorkflow(harnessDir, hint);
   if (selection.kind !== "active") {
@@ -5327,8 +5702,8 @@ function activeSnapshotRows(harnessDir, hint) {
       unreadable: selection.kind === "error" && selection.code !== "workflow.selection.no-active"
     };
   }
-  const snapshotDir = join7(harnessDir, selection.dir);
-  if (!existsSync10(join7(snapshotDir, WORKFLOW_SNAPSHOT_FILE))) {
+  const snapshotDir = join8(harnessDir, selection.dir);
+  if (!existsSync7(join8(snapshotDir, WORKFLOW_SNAPSHOT_FILE))) {
     return { rows: null, snapshot: null, workflowId: selection.workflowId, unreadable: true };
   }
   let snapshot;
@@ -5432,7 +5807,7 @@ function gateWorkflow(ctx, harnessDir, config, adapter, exec, hintReadOf) {
   }
   const pb = writableFanOutUncovered(harnessDir, hintReadOf().hint);
   if (pb.unreadable) {
-    const statusLabel = harnessDir === null ? STATUS_FILE : join7(harnessDir, STATUS_FILE);
+    const statusLabel = harnessDir === null ? STATUS_FILE : join8(harnessDir, STATUS_FILE);
     ctx.logger(DISPATCH_LOGGER).warn(`workflow gate (${toolName}) (fail-open): cannot read ${statusLabel} — P-b lease attribution degraded; call allowed`);
   }
   const verdict = workflowPolicy(config, adapter.workflowAskCache, {
@@ -5544,10 +5919,16 @@ function assignmentTextFromFields(fields) {
     lines.push(`**Delegation**: ${fields.delegation}`);
   if (fields.taskCategory !== undefined)
     lines.push(`**Task category**: ${fields.taskCategory}`);
+  if (fields.taskBudget !== undefined)
+    lines.push(`**Task budget (implement / ops rounds)**: ${fields.taskBudget}`);
   if (fields.workingBranch !== undefined)
     lines.push(`**Working branch**: ${fields.workingBranch}`);
   if (fields.branchPolicy !== undefined)
     lines.push(`**Branch policy**: ${fields.branchPolicy}`);
+  if (fields.budget !== undefined)
+    lines.push(`**Budget (review / QC seats)**: ${fields.budget}`);
+  if (fields.returnShape !== undefined)
+    lines.push(`**Return shape (review / QC seats)**: ${fields.returnShape}`);
   return lines.join(`
 `);
 }
@@ -5637,7 +6018,7 @@ function callPairingKey(exec) {
 function resolveAgentFlowWriteTarget(harnessDir, hint) {
   const selection = resolveActiveWorkflow(harnessDir, hint);
   if (selection.kind === "active")
-    return { dir: join13(harnessDir, selection.dir), selection };
+    return { dir: join14(harnessDir, selection.dir), selection };
   const message = selection.kind === "error" ? selection.message : "no active lifecycle (unexpected terminal selection — the active-set resolver has no history view)";
   if (!noActiveWarned) {
     noActiveWarned = true;
@@ -5657,7 +6038,7 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function withWorkflowDirLock(workflowDir, fn, opts = {}) {
-  const lockDir = join13(workflowDir, WORKFLOW_LEDGER_LOCKDIR);
+  const lockDir = join14(workflowDir, WORKFLOW_LEDGER_LOCKDIR);
   if (heldWorkflowLocks.has(lockDir)) {
     throw new Error(`${lockDir} is already held by this process — withWorkflowDirLock is not reentrant; a nested acquisition on the same workflow dir is a bug`);
   }
@@ -5683,7 +6064,7 @@ function withWorkflowDirLock(workflowDir, fn, opts = {}) {
   heldWorkflowLocks.add(lockDir);
   try {
     try {
-      writeFileSync2(join13(lockDir, WORKFLOW_LOCKER_HOLDER_PID), String(process.pid), "utf8");
+      writeFileSync2(join14(lockDir, WORKFLOW_LOCKER_HOLDER_PID), String(process.pid), "utf8");
     } catch {}
     return fn();
   } finally {
@@ -5692,7 +6073,7 @@ function withWorkflowDirLock(workflowDir, fn, opts = {}) {
       const current = statSync5(lockDir);
       if (acquired !== null && current.dev === acquired.dev && current.ino === acquired.ino) {
         try {
-          unlinkSync2(join13(lockDir, WORKFLOW_LOCKER_HOLDER_PID));
+          unlinkSync2(join14(lockDir, WORKFLOW_LOCKER_HOLDER_PID));
         } catch {}
         rmdirSync(lockDir);
       }
@@ -5700,13 +6081,13 @@ function withWorkflowDirLock(workflowDir, fn, opts = {}) {
   }
 }
 function appendEvent(workflowDir, event) {
-  const file = join13(workflowDir, AGENT_FLOW_FILE);
+  const file = join14(workflowDir, AGENT_FLOW_FILE);
   withWorkflowDirLock(workflowDir, () => {
     appendFileSync(file, `${JSON.stringify(event)}
 `);
     if (statSync5(file).size <= AGENT_FLOW_SIZE_GATE_BYTES)
       return;
-    const content = readFileSync6(file, "utf8");
+    const content = readFileSync3(file, "utf8");
     const lines = content.replace(/\n$/, "").split(`
 `);
     if (lines.length > AGENT_FLOW_MAX_EVENTS) {
@@ -6110,7 +6491,7 @@ function summaryOf(events) {
 function ledgerContent(file, n) {
   const size = statSync5(file).size;
   if (size <= AGENT_FLOW_TAIL_READ_THRESHOLD_BYTES) {
-    return readFileSync6(file, "utf8");
+    return readFileSync3(file, "utf8");
   }
   let windowBytes = AGENT_FLOW_TAIL_READ_THRESHOLD_BYTES;
   const fd = openSync(file, "r");
@@ -6142,8 +6523,8 @@ function ledgerContent(file, n) {
   }
 }
 function readAgentFlow(workflowDir, limit) {
-  const file = join13(workflowDir, AGENT_FLOW_FILE);
-  if (!existsSync14(file)) {
+  const file = join14(workflowDir, AGENT_FLOW_FILE);
+  if (!existsSync11(file)) {
     return { events: [], summary: [] };
   }
   const n = limit === undefined ? AGENT_FLOW_DEFAULT_LIMIT : Math.max(0, Math.floor(limit));
@@ -6308,8 +6689,8 @@ function reserveCatalogCandidate(pairing, ref, exec) {
   map.set(label, { ref, fromSeq: seq });
   ref.catalog = { session, label };
 }
-function matchCatalogEvent(session, label, join8, envelope) {
-  const result = join8.result;
+function matchCatalogEvent(session, label, join9, envelope) {
+  const result = join9.result;
   if (result === undefined)
     return;
   const rec = asRecord(envelope);
@@ -6323,7 +6704,7 @@ function matchCatalogEvent(session, label, join8, envelope) {
   const seq = rec.seq;
   if (typeof seq !== "number" || !Number.isInteger(seq))
     return;
-  if (seq < join8.fromSeq || seq >= session.seq || seq >= WORKFLOW_LEDGER_MAX_SEQ)
+  if (seq < join9.fromSeq || seq >= session.seq || seq >= WORKFLOW_LEDGER_MAX_SEQ)
     return;
   const childCreatedAt = data.childCreatedAt;
   if (typeof childCreatedAt !== "number" || !Number.isInteger(childCreatedAt) || childCreatedAt < 0)
@@ -6339,9 +6720,9 @@ function matchCatalogEvent(session, label, join8, envelope) {
     return;
   return childId;
 }
-function consumeCatalogCandidate(map, label, join8, childId) {
+function consumeCatalogCandidate(map, label, join9, childId) {
   map.set(label, null);
-  const ref = join8.ref;
+  const ref = join9.ref;
   ref.childId = childId;
   delete ref.catalog;
   recordSubagentLink({ ref, childId, label });
@@ -6352,16 +6733,16 @@ function advanceCatalogCandidate(pairing, ref, result) {
     if (catalog === undefined)
       return;
     const map = pairing.catalogBySession.get(catalog.session);
-    const join8 = map?.get(catalog.label);
-    if (map === undefined || join8 === undefined || join8 === null || join8.ref !== ref)
+    const join9 = map?.get(catalog.label);
+    if (map === undefined || join9 === undefined || join9 === null || join9.ref !== ref)
       return;
-    join8.result = result;
+    join9.result = result;
     const end = catalog.session.seq;
     let skippedReads = 0;
     let firstSkippedSeq;
     let firstSkippedError;
     try {
-      for (let seq = join8.fromSeq;seq < end; seq += 1) {
+      for (let seq = join9.fromSeq;seq < end; seq += 1) {
         let envelope;
         try {
           envelope = catalog.session.eventAt(seq);
@@ -6373,10 +6754,10 @@ function advanceCatalogCandidate(pairing, ref, result) {
           }
           continue;
         }
-        const childId = matchCatalogEvent(catalog.session, catalog.label, join8, envelope);
+        const childId = matchCatalogEvent(catalog.session, catalog.label, join9, envelope);
         if (childId === undefined)
           continue;
-        consumeCatalogCandidate(map, catalog.label, join8, childId);
+        consumeCatalogCandidate(map, catalog.label, join9, childId);
         return;
       }
     } finally {
@@ -6451,13 +6832,13 @@ function registerSubagentCatalogListener(ctx, pairing) {
       const map = pairing.catalogBySession.get(session);
       if (map === undefined)
         return;
-      for (const [label, join8] of map) {
-        if (join8 === null || join8.result === undefined)
+      for (const [label, join9] of map) {
+        if (join9 === null || join9.result === undefined)
           continue;
-        const childId = matchCatalogEvent(session, label, join8, envelope);
+        const childId = matchCatalogEvent(session, label, join9, envelope);
         if (childId === undefined)
           continue;
-        consumeCatalogCandidate(map, label, join8, childId);
+        consumeCatalogCandidate(map, label, join9, childId);
       }
     } catch (error) {
       log("warn", `subagent catalog observation failed (contained — the session append proceeds): ${errorMessage(error)}`);
@@ -6466,8 +6847,8 @@ function registerSubagentCatalogListener(ctx, pairing) {
 }
 
 // src/engine-status-store.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync as renameSync3, rmSync, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync3, rmSync, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 var ENGINE_STATUS_SNAPSHOT_VERSION = 1;
 var ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION = 1;
 var ENGINE_STATUS_SNAPSHOT_MAX_PER_SESSION = 50;
@@ -6476,19 +6857,19 @@ var ENGINE_STATUS_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
 var ENGINE_STATUS_SNAPSHOT_LOCK_TIMEOUT_MS = 250;
 var ENGINE_STATUS_SNAPSHOT_RELATIVE_PATH = "snapshots/engine-status.json";
 function engineStatusSnapshotPath(harnessDir) {
-  return join15(harnessDir, ENGINE_STATUS_SNAPSHOT_RELATIVE_PATH);
+  return join16(harnessDir, ENGINE_STATUS_SNAPSHOT_RELATIVE_PATH);
 }
 function engineStatusUnavailable(reason) {
   return { kind: "unavailable", reason };
 }
-function isPlainObject6(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value !== "" ? value : undefined;
 }
 function asEntry(value) {
-  if (!isPlainObject6(value))
+  if (!isPlainObject4(value))
     return;
   if (value.rv !== ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION)
     return;
@@ -6498,12 +6879,12 @@ function asEntry(value) {
     return;
   if (typeof value.turn !== "number" || !Number.isFinite(value.turn))
     return;
-  if (!isPlainObject6(value.payload))
+  if (!isPlainObject4(value.payload))
     return;
   return { rv: value.rv, cwd, at, turn: value.turn, payload: value.payload };
 }
 function asBinding(value) {
-  if (!isPlainObject6(value))
+  if (!isPlainObject4(value))
     return;
   const cwd = nonEmptyString(value.cwd);
   if (cwd === undefined)
@@ -6534,7 +6915,7 @@ function readEngineStatusSnapshot(harnessDir, sessionId) {
     return engineStatusUnavailable("no-session-entry");
   let raw;
   try {
-    raw = readFileSync9(engineStatusSnapshotPath(harnessDir), "utf8");
+    raw = readFileSync7(engineStatusSnapshotPath(harnessDir), "utf8");
   } catch (error) {
     const code = error.code;
     return engineStatusUnavailable(code === "ENOENT" ? "absent" : "unreadable");
@@ -6545,11 +6926,11 @@ function readEngineStatusSnapshot(harnessDir, sessionId) {
   } catch {
     return engineStatusUnavailable("invalid-json");
   }
-  if (!isPlainObject6(doc) || doc.sv !== ENGINE_STATUS_SNAPSHOT_VERSION) {
+  if (!isPlainObject4(doc) || doc.sv !== ENGINE_STATUS_SNAPSHOT_VERSION) {
     return engineStatusUnavailable("envelope-schema");
   }
   const entries = doc.entries;
-  if (!isPlainObject6(entries))
+  if (!isPlainObject4(entries))
     return engineStatusUnavailable("envelope-schema");
   if (!Object.hasOwn(entries, sessionId))
     return engineStatusUnavailable("no-session-entry");
@@ -6574,7 +6955,7 @@ function serializeEnvelope(entries, bindings) {
 function loadForWrite(harnessDir) {
   let raw;
   try {
-    raw = readFileSync9(engineStatusSnapshotPath(harnessDir), "utf8");
+    raw = readFileSync7(engineStatusSnapshotPath(harnessDir), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return {
@@ -6590,7 +6971,7 @@ function loadForWrite(harnessDir) {
   } catch {
     return { kind: "refused", reason: "store-invalid-json" };
   }
-  if (!isPlainObject6(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject6(parsed.entries)) {
+  if (!isPlainObject4(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject4(parsed.entries)) {
     return { kind: "refused", reason: "store-envelope-schema" };
   }
   const entries = sessionMap();
@@ -6609,7 +6990,7 @@ function loadForWrite(harnessDir) {
   }
   const bindings = bindingMap();
   if (parsed.bindings !== undefined) {
-    if (!isPlainObject6(parsed.bindings))
+    if (!isPlainObject4(parsed.bindings))
       return { kind: "refused", reason: "store-bindings-schema" };
     for (const [key, value] of Object.entries(parsed.bindings)) {
       const binding = asBinding(value);
@@ -6664,12 +7045,12 @@ function writeEngineStatusSnapshot(harnessDir, input) {
     return { kind: "degraded", reason: "no-session-cwd" };
   if (!Number.isFinite(input.turn))
     return { kind: "degraded", reason: "invalid-turn" };
-  if (!isPlainObject6(input.payload))
+  if (!isPlainObject4(input.payload))
     return { kind: "degraded", reason: "payload-not-object" };
   const at = (input.now ?? new Date).toISOString();
   if (!Number.isFinite(Date.parse(at)))
     return { kind: "degraded", reason: "invalid-timestamp" };
-  const dir = dirname9(engineStatusSnapshotPath(harnessDir));
+  const dir = dirname10(engineStatusSnapshotPath(harnessDir));
   const file = engineStatusSnapshotPath(harnessDir);
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
   try {
@@ -6732,7 +7113,7 @@ var bindingStoreMemos = new Map;
 function parseBindingStore(file) {
   let raw;
   try {
-    raw = readFileSync9(file, "utf8");
+    raw = readFileSync7(file, "utf8");
   } catch {
     return { kind: "unavailable", reason: "store-unreadable" };
   }
@@ -6742,13 +7123,13 @@ function parseBindingStore(file) {
   } catch {
     return { kind: "unavailable", reason: "store-invalid-json" };
   }
-  if (!isPlainObject6(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject6(parsed.entries)) {
+  if (!isPlainObject4(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject4(parsed.entries)) {
     return { kind: "unavailable", reason: "store-envelope-schema" };
   }
   const bindings = parsed.bindings;
   if (bindings === undefined)
     return { kind: "ok", bindings: undefined };
-  if (!isPlainObject6(bindings))
+  if (!isPlainObject4(bindings))
     return { kind: "unavailable", reason: "store-bindings-schema" };
   return { kind: "ok", bindings };
 }
@@ -6806,7 +7187,7 @@ function updateWorkflowSessionBinding(harnessDir, sessionId, cwd, update) {
     return { kind: "degraded", reason: "invalid-selected-workflow-id" };
   }
   const file = engineStatusSnapshotPath(harnessDir);
-  const dir = dirname9(file);
+  const dir = dirname10(file);
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
   try {
     mkdirSync4(dir, { recursive: true });
@@ -6858,7 +7239,7 @@ function residualSeverityIndex(severity) {
 function pluginVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync12(new URL(rel, import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync10(new URL(rel, import.meta.url), "utf8"));
       if (typeof pkg.version === "string" && pkg.version !== "")
         return pkg.version;
     } catch {}
@@ -7024,8 +7405,8 @@ function hhmm(ts) {
   return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
 }
 function harnessStateSource(harnessDir, selection) {
-  const statusPath = join18(harnessDir, STATUS_FILE);
-  if (!existsSync16(statusPath))
+  const statusPath = join19(harnessDir, STATUS_FILE);
+  if (!existsSync15(statusPath))
     return null;
   try {
     const rollup = residualRollup(harnessDir);
@@ -7034,9 +7415,9 @@ function harnessStateSource(harnessDir, selection) {
     if (selection.kind === "error") {
       return selectionErrorState(selection, rollup, harnessDir);
     }
-    const snapshotPath = join18(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+    const snapshotPath = join19(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
     let snapshot;
-    if (!existsSync16(snapshotPath)) {
+    if (!existsSync15(snapshotPath)) {
       return selectionErrorState({
         kind: "error",
         code: "workflow.selection.snapshot-unreadable",
@@ -7044,7 +7425,7 @@ function harnessStateSource(harnessDir, selection) {
       }, rollup, harnessDir);
     }
     try {
-      snapshot = readWorkflowSnapshot(join18(harnessDir, selection.dir)).snapshot;
+      snapshot = readWorkflowSnapshot(join19(harnessDir, selection.dir)).snapshot;
     } catch {
       return selectionErrorState({
         kind: "error",
@@ -7100,7 +7481,7 @@ function harnessStateSource(harnessDir, selection) {
       leases,
       knowledge: knowledgeDigest(harnessDir),
       direction: compass !== undefined ? compassDirection(compass.compassPath) : null,
-      agentFlow: readAgentFlow(join18(harnessDir, selection.dir), 50)
+      agentFlow: readAgentFlow(join19(harnessDir, selection.dir), 50)
     };
   } catch {
     return null;
@@ -7130,21 +7511,21 @@ function selectionErrorState(selection, rollup, harnessDir) {
 function projectRollupSource(harnessDir, residuals) {
   const milestones = [];
   const projectsDir = resolveProjectDir(harnessDir, { harnessDir });
-  if (existsSync16(projectsDir)) {
+  if (existsSync15(projectsDir)) {
     let entries;
     try {
-      entries = readdirSync4(projectsDir, { withFileTypes: true });
+      entries = readdirSync5(projectsDir, { withFileTypes: true });
     } catch {
       entries = [];
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const roadmapPath = join18(projectsDir, entry.name, PROJECT_ROADMAP_FILE);
-      if (!existsSync16(roadmapPath))
+      const roadmapPath = join19(projectsDir, entry.name, PROJECT_ROADMAP_FILE);
+      if (!existsSync15(roadmapPath))
         continue;
       try {
-        const doc = parseCompassFrontmatterText(readFileSync12(roadmapPath, "utf8"), roadmapPath);
+        const doc = parseCompassFrontmatterText(readFileSync10(roadmapPath, "utf8"), roadmapPath);
         if (Array.isArray(doc.milestones)) {
           for (const milestone of doc.milestones) {
             if (typeof milestone === "string" && milestone.trim() !== "")
@@ -7206,11 +7587,11 @@ function residualRollup(harnessDir) {
 }
 function projectRegisters(harnessDir) {
   const projectsDir = resolveProjectDir(harnessDir, { harnessDir });
-  if (!existsSync16(projectsDir))
+  if (!existsSync15(projectsDir))
     return [];
   let entries;
   try {
-    entries = readdirSync4(projectsDir, { withFileTypes: true });
+    entries = readdirSync5(projectsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7218,8 +7599,8 @@ function projectRegisters(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const registerPath = join18(projectsDir, entry.name, PROJECT_REGISTER_FILE);
-    if (!existsSync16(registerPath))
+    const registerPath = join19(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+    if (!existsSync15(registerPath))
       continue;
     try {
       registers.push({ projectId: entry.name, doc: readJson(registerPath) });
@@ -7230,13 +7611,13 @@ function projectRegisters(harnessDir) {
   return registers;
 }
 function knowledgeDigest(harnessDir) {
-  const indexPath = join18(harnessDir, "knowledge", "README.md");
-  if (!existsSync16(indexPath))
+  const indexPath = join19(harnessDir, "knowledge", "README.md");
+  if (!existsSync15(indexPath))
     return null;
   try {
     const categories = new Set;
     let docCount = 0;
-    for (const line of readFileSync12(indexPath, "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync10(indexPath, "utf8").split(/\r?\n/)) {
       const row = line.trim().match(/^\|(.+)\|$/);
       if (row === null)
         continue;
@@ -7259,7 +7640,7 @@ function knowledgeDigest(harnessDir) {
 }
 function compassDirection(compassPath) {
   try {
-    const content = readFileSync12(compassPath, "utf8");
+    const content = readFileSync10(compassPath, "utf8");
     const section = content.match(/^## Direction lock[^\n]*\n+([\s\S]*?)(?=\n## |$)/m);
     if (section === null)
       return null;
@@ -7276,20 +7657,20 @@ function compassDirection(compassPath) {
 }
 function selectedCompass(harnessDir, workflowId, snapshot) {
   const ref = snapshot.compass_ref;
-  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute8(ref))
+  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute9(ref))
     return;
-  const compassPath = join18(harnessDir, ref);
+  const compassPath = join19(harnessDir, ref);
   if (!pathInside(harnessDir, compassPath))
     return;
-  if (basename4(compassPath) !== "delivery-compass.md")
+  if (basename6(compassPath) !== "delivery-compass.md")
     return;
-  if (!existsSync16(compassPath))
+  if (!existsSync15(compassPath))
     return;
   let resolvedHarness;
   let resolvedCompass;
   try {
-    resolvedHarness = realpathSync7(harnessDir);
-    resolvedCompass = realpathSync7(compassPath);
+    resolvedHarness = realpathSync6(harnessDir);
+    resolvedCompass = realpathSync6(compassPath);
   } catch {
     return;
   }
@@ -7309,15 +7690,15 @@ function selectedCompass(harnessDir, workflowId, snapshot) {
 }
 function pathInside(root, candidate) {
   const rel = relative7(root, candidate);
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute8(rel);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute9(rel);
 }
 function iterationGateSource(harnessDir, selection) {
   if (harnessDir === null || selection === undefined || selection.kind === "error")
     return;
-  const statusPath = join18(harnessDir, STATUS_FILE);
-  if (!existsSync16(statusPath))
+  const statusPath = join19(harnessDir, STATUS_FILE);
+  if (!existsSync15(statusPath))
     return;
-  const snapshotPath = join18(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+  const snapshotPath = join19(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
   try {
     const snapshotDoc = readJson(snapshotPath);
     const compass = selectedCompass(harnessDir, selection.workflowId, snapshotDoc);
@@ -7407,7 +7788,7 @@ function persistEngineStatusSnapshot(ctx, harnessDir, cwd, turn, catalogPayload,
 }
 
 // src/engine-status-endpoint.ts
-import { isAbsolute as isAbsolute10 } from "node:path";
+import { isAbsolute as isAbsolute11 } from "node:path";
 
 // ../../node_modules/.bun/@deepseek-ai+dsh-typert-protocol@0.1.5-rc.2+1e4e7adc57ac8890/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
 import { Service as Service2 } from "@deepseek-ai/cordis";
@@ -7463,7 +7844,7 @@ function liveSeqOf(value) {
 function isRefusedPath(cwd) {
   if (cwd.includes("\x00"))
     return true;
-  if (!isAbsolute10(cwd))
+  if (!isAbsolute11(cwd))
     return true;
   return cwd.split(/[\\/]+/).includes("..");
 }
@@ -7699,12 +8080,12 @@ function installEngineStatusEndpoint(ctx, options) {
 }
 
 // src/gates/status.ts
-import { existsSync as existsSync17, readdirSync as readdirSync7 } from "node:fs";
-import { basename as basename6, join as join20, relative as relative9, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync8 } from "node:fs";
+import { basename as basename8, join as join21, relative as relative9, resolve as resolve12 } from "node:path";
 var LOGGER_NAME = "mstar/status-gate";
 function harnessDocKindOfTarget(harnessDir, targetPath) {
-  const resolved = resolve10(targetPath);
-  const name = basename6(resolved);
+  const resolved = resolve12(targetPath);
+  const name = basename8(resolved);
   if (name !== STATUS_FILE && name !== WORKFLOW_SNAPSHOT_FILE && name !== PROJECT_REGISTER_FILE)
     return null;
   const rel = relative9(harnessDir, resolved);
@@ -7716,8 +8097,8 @@ function harnessDocKindOfTarget(harnessDir, targetPath) {
     workflowDir = resolveWorkflowDir(harnessDir, { harnessDir });
     projectDir = resolveProjectDir(harnessDir, { harnessDir });
   } catch {
-    workflowDir = join20(harnessDir, "workflows");
-    projectDir = join20(harnessDir, "projects");
+    workflowDir = join21(harnessDir, "workflows");
+    projectDir = join21(harnessDir, "projects");
   }
   if (name === WORKFLOW_SNAPSHOT_FILE && /^[^/]+\/snapshot\.json$/.test(relative9(workflowDir, resolved)))
     return "snapshot";
@@ -7773,7 +8154,7 @@ function projectRegisterDocs(harnessDir) {
   const projectsDir = resolveProjectDir(harnessDir, { harnessDir });
   let entries;
   try {
-    entries = readdirSync7(projectsDir, { withFileTypes: true });
+    entries = readdirSync8(projectsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7781,7 +8162,7 @@ function projectRegisterDocs(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const registerPath = join20(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+    const registerPath = join21(projectsDir, entry.name, PROJECT_REGISTER_FILE);
     if (!existsSync17(registerPath))
       continue;
     try {
@@ -7855,8 +8236,8 @@ async function editIntentListener(ctx, resolver, config, adapter, target, actor,
 }
 
 // src/gates/skill-lint.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14 } from "node:fs";
-import { basename as basename7, dirname as dirname11, resolve as resolve12, sep as sep5 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename9, dirname as dirname12, resolve as resolve14, sep as sep6 } from "node:path";
 var SKILL_LINT_LOGGER = "mstar/skill-lint";
 
 class SkillLintVetoError extends Error {
@@ -7897,7 +8278,7 @@ function lintSkillDoc(doc, options = {}) {
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
 function lintSkillWrite(doc, options) {
-  const skillId = basename7(dirname11(resolve12(options.target)));
+  const skillId = basename9(dirname12(resolve14(options.target)));
   const result = lintSkillDoc(doc, { skillId });
   if (options.hard && !result.ok) {
     throw new SkillLintVetoError(options.target, result.violations);
@@ -7910,13 +8291,13 @@ function skillRootsOf(config) {
   return roots.map((root) => root.trim()).filter((root) => root !== "");
 }
 function isSkillTarget(roots, target) {
-  if (basename7(target.displayPath) !== "SKILL.md")
+  if (basename9(target.displayPath) !== "SKILL.md")
     return false;
-  const resolvedPath = resolve12(target.displayPath);
-  return roots.some((root) => resolvedPath.startsWith(resolve12(root) + sep5));
+  const resolvedPath = resolve14(target.displayPath);
+  return roots.some((root) => resolvedPath.startsWith(resolve14(root) + sep6));
 }
 function skillNameOf(target) {
-  return basename7(dirname11(target.displayPath));
+  return basename9(dirname12(target.displayPath));
 }
 function skillCanonicalForm(target) {
   return resolveSkillRoot("dsh", { skill: skillNameOf(target), rel: "SKILL.md" });
@@ -7928,12 +8309,12 @@ function gateSkillIntent(ctx, harnessDir, config, target) {
       return;
     if (!isSkillTarget(roots, target))
       return;
-    const skillPath = resolve12(target.displayPath);
+    const skillPath = resolve14(target.displayPath);
     if (!existsSync18(skillPath))
       return;
     let doc;
     try {
-      doc = readFileSync14(skillPath, "utf8");
+      doc = readFileSync13(skillPath, "utf8");
     } catch (error) {
       ctx.logger(SKILL_LINT_LOGGER).error(`skill lint degraded to allow (cannot read ${skillPath}): ${error.message}`);
       ctx.emit("mstar/skill-lint", {
@@ -7946,7 +8327,7 @@ function gateSkillIntent(ctx, harnessDir, config, target) {
       });
       return;
     }
-    const result = lintSkillDoc(doc, { skillId: basename7(dirname11(skillPath)) });
+    const result = lintSkillDoc(doc, { skillId: basename9(dirname12(skillPath)) });
     if (result.ok)
       return;
     const hard = resolveSeamHard(harnessDir, config);
@@ -7980,15 +8361,17 @@ async function skillWriteIntentListener(ctx, resolver, config, target, actor, ne
 }
 
 // src/gates/seams.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15, readdirSync as readdirSync10 } from "node:fs";
-import { basename as basename9, dirname as dirname12, join as join21, resolve as resolve14, sep as sep7 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync15, readdirSync as readdirSync11 } from "node:fs";
+import { basename as basename10, dirname as dirname13, join as join22, resolve as resolve16, sep as sep8 } from "node:path";
 
 // ../engine/dist/audit.js
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage22 } from "node:async_hooks";
 var DATE_PART2 = String.raw`\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])`;
 var RFC3339_Z_RE2 = new RegExp(String.raw`^${DATE_PART2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$`);
 var DATE_ONLY_RE2 = new RegExp(String.raw`^${DATE_PART2}$`);
-var heldLockDirs2 = new AsyncLocalStorage2;
+var heldLockDirs2 = new AsyncLocalStorage3;
+var writeAuthorizations2 = new AsyncLocalStorage22;
 var MSTARC_HARNESS_DIR_KEY2 = "harness_dir";
 var MSTARC_PLAN_DIR_KEY2 = "plan_dir";
 var MSTARC_SDD_DIR_KEY2 = "sdd_dir";
@@ -8180,7 +8563,7 @@ var SEAM_LOGGERS = {
   roles: "mstar/roles-lint"
 };
 function isIndexFile(path) {
-  const base = basename9(path);
+  const base = basename10(path);
   return base === "README.md" || base === "index.md";
 }
 function isMarkdownDoc(path) {
@@ -8189,7 +8572,7 @@ function isMarkdownDoc(path) {
 function isAuditPlanTarget(path) {
   if (!isMarkdownDoc(path))
     return false;
-  const segments = resolve14(path).split(sep7);
+  const segments = resolve16(path).split(sep8);
   for (let i = 0;i < segments.length; i++) {
     if (segments[i] !== "plans")
       continue;
@@ -8200,7 +8583,7 @@ function isAuditPlanTarget(path) {
   return false;
 }
 function isRolesTarget(path) {
-  const segments = resolve14(path).split(sep7);
+  const segments = resolve16(path).split(sep8);
   const idx = segments.indexOf("mstar-roles");
   if (idx === -1)
     return false;
@@ -8210,17 +8593,17 @@ function isRolesTarget(path) {
   return rest[0] === "SKILL.md" || rest[0] === "references" && rest[rest.length - 1].endsWith(".md");
 }
 function rolesDirOf(path) {
-  const segments = resolve14(path).split(sep7);
+  const segments = resolve16(path).split(sep8);
   const idx = segments.indexOf("mstar-roles");
   if (idx === -1)
-    return dirname12(path);
-  return idx === 0 ? sep7 : join21(sep7, ...segments.slice(1, idx + 1));
+    return dirname13(path);
+  return idx === 0 ? sep8 : join22(sep8, ...segments.slice(1, idx + 1));
 }
 function isSeamTarget(seam, harnessDir, target) {
-  const path = resolve14(target.displayPath);
+  const path = resolve16(target.displayPath);
   switch (seam) {
     case "design-md": {
-      const base = basename9(path);
+      const base = basename10(path);
       return base === "DESIGN.md" || base === "DESIGN.dark.md";
     }
     case "audit":
@@ -8228,7 +8611,7 @@ function isSeamTarget(seam, harnessDir, target) {
     case "compound": {
       if (harnessDir === null)
         return false;
-      return path.startsWith(resolve14(join21(harnessDir, "knowledge")) + sep7) && isMarkdownDoc(path);
+      return path.startsWith(resolve16(join22(harnessDir, "knowledge")) + sep8) && isMarkdownDoc(path);
     }
     case "roles":
       return isRolesTarget(path);
@@ -8245,8 +8628,8 @@ function auditSecretsViolations(findings, file) {
 }
 function validateDesignDoc(doc, path) {
   const violations = [...validateDesignTokenFrontmatter(doc).violations];
-  const isDark = basename9(path) === "DESIGN.dark.md";
-  const sibling = join21(dirname12(path), isDark ? "DESIGN.md" : "DESIGN.dark.md");
+  const isDark = basename10(path) === "DESIGN.dark.md";
+  const sibling = join22(dirname13(path), isDark ? "DESIGN.md" : "DESIGN.dark.md");
   if (existsSync19(sibling)) {
     const light = isDark ? readFileSync15(sibling, "utf8") : doc;
     const dark = isDark ? doc : readFileSync15(sibling, "utf8");
@@ -8263,17 +8646,17 @@ function validateAuditDoc(doc, path) {
 function validateCompoundDoc(doc, _path, harnessDir) {
   const violations = [...validateSchemaYaml(doc).violations];
   if (harnessDir !== null) {
-    violations.push(...referenceExists(dirname12(harnessDir), doc).violations);
+    violations.push(...referenceExists(dirname13(harnessDir), doc).violations);
   }
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
-function validateRolesState(rolesDir, skillsRoot = dirname12(rolesDir)) {
+function validateRolesState(rolesDir, skillsRoot = dirname13(rolesDir)) {
   const violations = [...validateRoleMapping(rolesDir).violations];
   const skillTexts = {};
-  for (const entry of readdirSync10(skillsRoot, { withFileTypes: true })) {
+  for (const entry of readdirSync11(skillsRoot, { withFileTypes: true })) {
     if (!entry.isDirectory() || !entry.name.startsWith("mstar-"))
       continue;
-    const skillFile = join21(skillsRoot, entry.name, "SKILL.md");
+    const skillFile = join22(skillsRoot, entry.name, "SKILL.md");
     if (!existsSync19(skillFile))
       continue;
     try {
@@ -8307,7 +8690,7 @@ function gateSeamIntent(ctx, harnessDir, config, seam, target) {
   try {
     if (!isSeamTarget(seam, harnessDir, target))
       return;
-    const path = resolve14(target.displayPath);
+    const path = resolve16(target.displayPath);
     if (!existsSync19(path))
       return;
     let doc;
@@ -8324,12 +8707,12 @@ function gateSeamIntent(ctx, harnessDir, config, seam, target) {
     const hard = resolveSeamHard(harnessDir, config);
     const verdict = applyEnforcement(result, { hard });
     if (verdict.hardBlocked) {
-      logger.error(`${basename9(path)} write to ${target.displayPath} ALLOWED as repair (Enforcement: hard; the current on-disk document is already invalid — the intent carries no incoming content, so the vetoable signal is only the pre-write state):
+      logger.error(`${basename10(path)} write to ${target.displayPath} ALLOWED as repair (Enforcement: hard; the current on-disk document is already invalid — the intent carries no incoming content, so the vetoable signal is only the pre-write state):
 ${verdict.violations.map(formatViolation).join(`
 `)}`);
       emitSeamAdvisory(ctx, seam, target.displayPath, verdict, hard, { repair: true });
     } else {
-      logger.warn(`${basename9(path)} write to ${target.displayPath} (advisory):
+      logger.warn(`${basename10(path)} write to ${target.displayPath} (advisory):
 ${verdict.violations.map(formatViolation).join(`
 `)}`);
       emitSeamAdvisory(ctx, seam, target.displayPath, verdict, hard);
@@ -8379,7 +8762,7 @@ function lintRolesWrite(doc, options) {
 
 // src/gates/tools.ts
 import { existsSync as existsSync20, readFileSync as readFileSync16 } from "node:fs";
-import { join as join22, resolve as resolve16 } from "node:path";
+import { join as join23, resolve as resolve18 } from "node:path";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 var ITERATION_VIOLATION_SCHEMA = {
   type: "object",
@@ -8599,8 +8982,8 @@ function registerSeamTools(ctx, resolver) {
       presentCall: (args) => ({ card: "generic", title: "Validate DESIGN.md", kind: "other", rawInput: args.dir }),
       isConcurrencySafe: () => false,
       async execute(args) {
-        const abs = resolve16(args.dir);
-        const lightPath = join22(abs, "DESIGN.md");
+        const abs = resolve18(args.dir);
+        const lightPath = join23(abs, "DESIGN.md");
         if (!existsSync20(lightPath))
           throw new Error(`design file not found: ${lightPath}`);
         const light = readFileSync16(lightPath, "utf8");
@@ -8653,7 +9036,7 @@ function registerSeamTools(ctx, resolver) {
       presentCall: (args) => ({ card: "generic", title: "Validate audit plan", kind: "other", rawInput: args.plan_path }),
       isConcurrencySafe: () => false,
       async execute(args) {
-        const abs = resolve16(args.plan_path);
+        const abs = resolve18(args.plan_path);
         if (!existsSync20(abs))
           throw new Error(`plan file not found: ${abs}`);
         const text = readFileSync16(abs, "utf8");
@@ -8693,17 +9076,17 @@ function registerSeamTools(ctx, resolver) {
       presentCall: (args) => ({ card: "generic", title: "Validate knowledge doc", kind: "other", rawInput: args.doc_path }),
       isConcurrencySafe: () => false,
       async execute(args, exec) {
-        const abs = resolve16(args.doc_path);
+        const abs = resolve18(args.doc_path);
         if (!existsSync20(abs))
           throw new Error(`knowledge doc not found: ${abs}`);
         const text = readFileSync16(abs, "utf8");
         const base = validateCompoundDoc(text, abs, args.repo_root !== undefined ? null : resolver.forAgent(exec.agent));
         const violations = [...base.violations];
         if (args.repo_root !== undefined) {
-          violations.push(...referenceExists(resolve16(args.repo_root), text).violations);
+          violations.push(...referenceExists(resolve18(args.repo_root), text).violations);
         }
         if (args.knowledge_dir !== undefined) {
-          const knowledgeDir = resolve16(args.knowledge_dir);
+          const knowledgeDir = resolve18(args.knowledge_dir);
           violations.push(...assertIndexRows(knowledgeDir).violations);
           violations.push(...scopeGuard(abs, [knowledgeDir]).violations);
         }
@@ -8738,10 +9121,10 @@ function registerSeamTools(ctx, resolver) {
       presentCall: (args) => ({ card: "generic", title: "Validate roles mapping", kind: "other", rawInput: args.roles_dir }),
       isConcurrencySafe: () => false,
       async execute(args) {
-        const rolesDir = resolve16(args.roles_dir);
-        if (!existsSync20(join22(rolesDir, "SKILL.md")))
+        const rolesDir = resolve18(args.roles_dir);
+        if (!existsSync20(join23(rolesDir, "SKILL.md")))
           throw new Error(`roles dir not found: ${rolesDir}`);
-        const result = validateRolesState(rolesDir, args.skills_root !== undefined ? resolve16(args.skills_root) : undefined);
+        const result = validateRolesState(rolesDir, args.skills_root !== undefined ? resolve18(args.skills_root) : undefined);
         return { ok: result.ok, violations: result.violations.map(iterationViolationView) };
       }
     }));
@@ -8750,7 +9133,7 @@ function registerSeamTools(ctx, resolver) {
 
 // src/gates/adapter.ts
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import { Service as Service3 } from "@deepseek-ai/cordis";
 var HOST_LOGGER = "mstar/host-adapter";
 function mergeLeasesMatch(left, right) {
@@ -8865,7 +9248,7 @@ class DshHostAdapter extends Service3 {
     if (harnessDir !== null) {
       const selection = resolveActiveWorkflow(harnessDir);
       if (selection.kind === "active") {
-        const snapshotPath = join23(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+        const snapshotPath = join24(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
         try {
           const snapshot = readJson(snapshotPath);
           const stored = snapshot?.integration_merge_lease;
@@ -8891,8 +9274,8 @@ class DshHostAdapter extends Service3 {
 }
 
 // src/gates/agent-personas.ts
-import { readFileSync as readFileSync17, readdirSync as readdirSync12, statSync as statSync8 } from "node:fs";
-import { join as join24, resolve as resolve17, sep as sep8 } from "node:path";
+import { readFileSync as readFileSync17, readdirSync as readdirSync13, statSync as statSync8 } from "node:fs";
+import { join as join25, resolve as resolve19, sep as sep9 } from "node:path";
 var ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
 var defaultCache = new Map;
 function personaFor(roleId, lookup, warn) {
@@ -8909,7 +9292,7 @@ function personaFor(roleId, lookup, warn) {
 function subagentRoleIds(agentsDir) {
   let names;
   try {
-    names = readdirSync12(agentsDir);
+    names = readdirSync13(agentsDir);
   } catch {
     return [];
   }
@@ -8920,7 +9303,7 @@ function subagentRoleIds(agentsDir) {
     const roleId = name.slice(0, -3);
     let content;
     try {
-      content = readFileSync17(join24(agentsDir, name), "utf8");
+      content = readFileSync17(join25(agentsDir, name), "utf8");
     } catch {
       continue;
     }
@@ -8933,9 +9316,9 @@ function subagentRoleIds(agentsDir) {
 function defaultFromMirror(agentsDir, roleId, warn) {
   if (!ROLE_ID_PATTERN.test(roleId))
     return;
-  const root = resolve17(agentsDir);
-  const file = resolve17(agentsDir, `${roleId}.md`);
-  if (!file.startsWith(root + sep8))
+  const root = resolve19(agentsDir);
+  const file = resolve19(agentsDir, `${roleId}.md`);
+  if (!file.startsWith(root + sep9))
     return;
   let stat;
   try {
@@ -9182,7 +9565,7 @@ function log2(level, message) {
 
 // src/gates/workflow-ledger.ts
 import { readFileSync as readFileSync18, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 var WORKFLOW_LEDGER_LOGGER = "mstar/workflow-ledger";
 var TOOL_WORKFLOW_RUN_START = "tool-workflow/run-start";
 var TOOL_WORKFLOW_AGENT_START = "tool-workflow/agent-start";
@@ -9242,7 +9625,7 @@ function loadWatermark(workflowDir, fresh = false) {
     return cached;
   const watermark = new Map;
   try {
-    const raw = readFileSync18(join25(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE), "utf8");
+    const raw = readFileSync18(join26(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE), "utf8");
     const record = asRecord(JSON.parse(raw));
     const cursors = asRecord(record?.cursors);
     if (cursors !== undefined) {
@@ -9265,7 +9648,7 @@ function loadWatermark(workflowDir, fresh = false) {
 }
 function saveWatermark(workflowDir, watermark) {
   try {
-    const file = join25(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE);
+    const file = join26(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE);
     const tmp = `${file}.tmp`;
     writeFileSync7(tmp, JSON.stringify({ v: 1, cursors: Object.fromEntries(watermark) }));
     renameSync4(tmp, file);
@@ -9584,8 +9967,8 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
 }
 
 // src/gates/goal-bridge.ts
-import { existsSync as existsSync22, readdirSync as readdirSync13 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync14 } from "node:fs";
+import { join as join27 } from "node:path";
 var GOAL_BRIDGE_LOGGER = "mstar/goal-bridge";
 var GOAL_CHANGE_EVENT_TYPE = "goal/change";
 var GOAL_CHANGE_VERSION = 1;
@@ -9607,15 +9990,15 @@ function errorMessage4(error) {
 function projectRegisterPointer(harnessDir) {
   const projectsDir = resolveProjectDir(harnessDir, { harnessDir });
   try {
-    for (const entry of readdirSync13(projectsDir, { withFileTypes: true })) {
+    for (const entry of readdirSync14(projectsDir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const registerPath = join26(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+      const registerPath = join27(projectsDir, entry.name, PROJECT_REGISTER_FILE);
       if (existsSync22(registerPath))
         return registerPath;
     }
   } catch {}
-  return join26(projectsDir, _DEFAULT_PROJECT, PROJECT_REGISTER_FILE);
+  return join27(projectsDir, _DEFAULT_PROJECT, PROJECT_REGISTER_FILE);
 }
 function blockedAdvisoryOf(envelope) {
   const record = asRecord(envelope);
@@ -9667,7 +10050,7 @@ function registerGoalBridge(ctx, resolver) {
 
 // src/gates/plan-mode-bridge.ts
 import { existsSync as existsSync23 } from "node:fs";
-import { isAbsolute as isAbsolute11, join as join27, relative as relative10, sep as sep9 } from "node:path";
+import { isAbsolute as isAbsolute12, join as join28, relative as relative10, sep as sep10 } from "node:path";
 
 // src/gates/steering.ts
 function isRootLikeAgent(agent) {
@@ -9711,7 +10094,7 @@ function errorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function selectedLifecycle(harnessDir, hint) {
-  if (!existsSync23(join27(harnessDir, STATUS_FILE)))
+  if (!existsSync23(join28(harnessDir, STATUS_FILE)))
     return { kind: "none" };
   const selection = resolveReadWorkflow(harnessDir, hint);
   if (selection.kind === "error") {
@@ -9719,7 +10102,7 @@ function selectedLifecycle(harnessDir, hint) {
   }
   let doc;
   try {
-    doc = readJson(join27(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE));
+    doc = readJson(join28(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE));
   } catch {
     return { kind: "none" };
   }
@@ -9729,11 +10112,11 @@ function selectedLifecycle(harnessDir, hint) {
 }
 function selectedCompassSteers(harnessDir, lifecycle) {
   const ref = lifecycle.doc.compass_ref;
-  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute11(ref))
+  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute12(ref))
     return false;
-  const compassPath = join27(harnessDir, ref);
+  const compassPath = join28(harnessDir, ref);
   const inside = relative10(harnessDir, compassPath);
-  if (inside === "" || inside === ".." || inside.startsWith(`..${sep9}`) || isAbsolute11(inside))
+  if (inside === "" || inside === ".." || inside.startsWith(`..${sep10}`) || isAbsolute12(inside))
     return false;
   if (!existsSync23(compassPath))
     return false;
@@ -10301,10 +10684,10 @@ function registerMstarCommands(ctx) {
   if (dir === undefined)
     return;
   ctx.inject(["commands"], (commandsCtx) => {
-    for (const file of readdirSync14(dir).sort()) {
+    for (const file of readdirSync15(dir).sort()) {
       if (!file.endsWith(".md"))
         continue;
-      const parsed = parseCommandMarkdown(readFileSync19(join28(dir, file), "utf8"));
+      const parsed = parseCommandMarkdown(readFileSync19(join29(dir, file), "utf8"));
       if (parsed === undefined)
         continue;
       commandsCtx.commands.register({