@mstar-harness/dsh 2.2.0 → 2.3.0

package/dist/index.js

@@ -1106,8 +1106,8 @@ var require_lib2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync7 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "node:fs";
+import { join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
   apply as applySkillLocal,
@@ -1473,7 +1473,7 @@ function parseAssignmentBranchForms(assignmentText) {
   if (fields.branchPolicy !== undefined && fields.branchPolicy !== "") {
     const direct = fields.branchPolicy.match(/^direct\s+on\s+(\S+)/i);
     if (direct) {
-      const strict = fields.branchPolicy.match(/^direct\s+on\s+(\S+)(?:\s*(?:[—–]|--|-)\s*(.+))?$/);
+      const strict = fields.branchPolicy.match(/^direct\s+on\s+(\S+)(?:\s*(?:[\u2014\u2013]|--|-)\s*(.+))?$/);
       forms.directOn = { branch: direct[1].trim(), reason: strict ? (strict[2] ?? "").trim() : "" };
     }
   }
@@ -3337,6 +3337,26 @@ function scopeGuard(path, allowedRoots) {
 function violation9(severity, code, message, fix) {
   return { ok: false, severity, code, message, fix };
 }
+var TASK_ARTIFACT_RE = /\btask-\d+(?:-(?:brief|report|fix-report|diff)|\.diff)\b/g;
+var SDD_DEEPLINK_RE = /\.(?:mstar|agents)\/sdd\/([^\s/<>{}\[\]"'\*\?]+)/g;
+function findEphemeralCitations(skillText) {
+  const citations = [];
+  const lines = skillText.split(/\r?\n/);
+  for (let i = 0;i < lines.length; i++) {
+    const found = [];
+    for (const m of lines[i].matchAll(TASK_ARTIFACT_RE)) {
+      found.push({ index: m.index, match: m[0], kind: "task-artifact" });
+    }
+    for (const m of lines[i].matchAll(SDD_DEEPLINK_RE)) {
+      found.push({ index: m.index, match: m[0], kind: "sdd-deeplink" });
+    }
+    found.sort((a, b) => a.index - b.index);
+    for (const f of found) {
+      citations.push({ line: i + 1, match: f.match, kind: f.kind });
+    }
+  }
+  return citations;
+}
 var WORKFLOW_VERB_START_RE = /^(?:explains?|describes?|covers?|provides?|walks?|guides?|shows?|lists?|details?|demonstrates?|outlines?|teaches?|summarizes?)\b/i;
 var PRONOUN_RE = /\bI\b(?!\/)|\b(?:we|you|my|our|your|us)\b/gi;
 var DESCRIPTION_MAX_WORDS = 120;
@@ -3640,6 +3660,19 @@ import { existsSync as existsSync7 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var STATUS_FILE = "status.json";
+var PERSONA_INTERPOLATION_HAZARD = /\{\{[\s\S]*\}\}/;
+function stripInterpolationHazard(text) {
+  let out = text;
+  for (;; ) {
+    const open = out.indexOf("{{");
+    if (open < 0)
+      return out;
+    const close = out.indexOf("}}", open + 2);
+    if (close < 0)
+      return out;
+    out = `${out.slice(0, open)}{ {${out.slice(open + 2, close)}} }${out.slice(close + 2)}`;
+  }
+}
 var Config = import_schemastery.default.object({
   harnessDir: import_schemastery.default.string(),
   enforcement: import_schemastery.default.union(["hard", "soft"]),
@@ -3647,7 +3680,19 @@ var Config = import_schemastery.default.object({
   dispatchBinding: import_schemastery.default.string().default(undefined),
   skillRoots: import_schemastery.default.array(import_schemastery.default.string()).default(undefined),
   bundledSkillDir: import_schemastery.default.string().default(undefined),
-  catalogTtlMs: import_schemastery.default.number().default(undefined)
+  catalogTtlMs: import_schemastery.default.number().default(undefined),
+  roleMap: import_schemastery.default.dict(import_schemastery.default.string()).default(undefined),
+  rolePersonas: import_schemastery.default.transform(import_schemastery.default.dict(import_schemastery.default.string()), (value) => {
+    for (const [role, persona] of Object.entries(value)) {
+      if (PERSONA_INTERPOLATION_HAZARD.test(persona)) {
+        throw new import_schemastery.default.ValidationError(`rolePersonas["${role}"] must not contain a "{{" paired with a later "}}" (dsh system-prompt strict interpolation renders persona text and throws on unknown or malformed references — use single braces or reword)`, {});
+      }
+    }
+    return value;
+  }).default(undefined),
+  workflowGate: import_schemastery.default.union(["off", "warn", "ask", "hard"]).default("warn"),
+  workflowNames: import_schemastery.default.array(import_schemastery.default.string()).default(undefined),
+  maxGoalRounds: import_schemastery.default.number().default(undefined)
 });
 function formatViolation(violation12) {
   return `[${violation12.severity}] ${violation12.code}: ${violation12.message}${violation12.fix !== undefined ? ` (fix: ${violation12.fix})` : ""}`;
@@ -3681,6 +3726,25 @@ function packagedSkillsDir() {
     packagedSkillsDirMemo = dir;
   return dir;
 }
+function resolvePackagedAgentsDir(fileUrl) {
+  for (const rel of ["../harness-agents", "../../harness-agents"]) {
+    try {
+      const dir = fileURLToPath2(new URL(rel, fileUrl));
+      if (existsSync7(dir))
+        return dir;
+    } catch {}
+  }
+  return;
+}
+var packagedAgentsDirMemo;
+function packagedAgentsDir() {
+  if (packagedAgentsDirMemo !== undefined)
+    return packagedAgentsDirMemo;
+  const dir = resolvePackagedAgentsDir(import.meta.url);
+  if (dir !== undefined)
+    packagedAgentsDirMemo = dir;
+  return dir;
+}
 
 class HarnessResolver {
   explicit;
@@ -3745,8 +3809,99 @@ import { join as join10 } from "node:path";
 // src/gates/dispatch.ts
 import { existsSync as existsSync9 } from "node:fs";
 import { basename as basename5, join as join6, resolve as resolve9 } from "node:path";
+
+// src/gates/workflow-policy.ts
+var WORKFLOW_NAME_UNKNOWN_CODE = "workflow.name.unknown";
+var WORKFLOW_LEASE_UNCOVERED_CODE = "workflow.lease.uncovered";
+var WORKFLOW_NAME_CONTROL_CHARS = /[\u0000-\u001F\u007F]/g;
+function normalizeWorkflowName(value) {
+  return value.replace(WORKFLOW_NAME_CONTROL_CHARS, "");
+}
+function workflowNameUnknown(config, metaName) {
+  const names = config.workflowNames;
+  if (names === undefined || names.length === 0)
+    return true;
+  return !names.some((entry) => normalizeWorkflowName(entry) === metaName);
+}
+
+class WorkflowAskCache {
+  decisions = new Map;
+  asked = new Set;
+  get(name) {
+    return this.decisions.get(name);
+  }
+  record(name, decision) {
+    this.decisions.set(normalizeWorkflowName(name), decision);
+  }
+  markAsked(name) {
+    this.asked.add(normalizeWorkflowName(name));
+  }
+  wasAsked(name) {
+    return this.asked.has(normalizeWorkflowName(name));
+  }
+}
+function workflowPolicy(config, cache, input) {
+  const mode = config.workflowGate ?? "warn";
+  if (mode === "off")
+    return { decision: "allow" };
+  if (input.uncoveredPlanId !== undefined) {
+    if (mode === "hard") {
+      return {
+        decision: "deny",
+        code: WORKFLOW_LEASE_UNCOVERED_CODE,
+        reason: `workflow gate (${input.tool}) vetoed: plan "${input.uncoveredPlanId}" is InProgress without execution_lease coverage (workflowGate: hard — no writable fan-out until the plan is recovered)`
+      };
+    }
+    return {
+      decision: "warn",
+      code: WORKFLOW_LEASE_UNCOVERED_CODE,
+      reason: `plan "${input.uncoveredPlanId}" is InProgress without execution_lease coverage (workflowGate: warn — advisory only)`
+    };
+  }
+  if (input.metaName === undefined) {
+    return { decision: "allow" };
+  }
+  const name = input.metaName;
+  if (!workflowNameUnknown(config, name))
+    return { decision: "allow" };
+  switch (mode) {
+    case "warn":
+      return {
+        decision: "warn",
+        code: WORKFLOW_NAME_UNKNOWN_CODE,
+        reason: `workflow name "${name}" is not in the workflowNames allowlist (workflowGate: warn — advisory only)`
+      };
+    case "hard":
+      return {
+        decision: "deny",
+        code: WORKFLOW_NAME_UNKNOWN_CODE,
+        reason: `workflow gate (${input.tool}) vetoed: workflow name "${name}" is not in the workflowNames allowlist (workflowGate: hard)`
+      };
+    case "ask": {
+      const cached = cache.get(name);
+      if (cached === "allow")
+        return { decision: "allow" };
+      if (cached === "deny") {
+        return {
+          decision: "deny",
+          code: WORKFLOW_NAME_UNKNOWN_CODE,
+          reason: `workflow gate (${input.tool}) vetoed: workflow name "${name}" was denied earlier in this session (workflowGate: ask — cached decision)`
+        };
+      }
+      cache.markAsked(name);
+      return {
+        decision: "ask",
+        code: WORKFLOW_NAME_UNKNOWN_CODE,
+        reason: `workflow name "${name}" is not in the workflowNames allowlist (workflowGate: ask — first-seen; approve to allow this session, or deny to veto; the decision is cached)`
+      };
+    }
+  }
+}
+
+// src/gates/dispatch.ts
 var DISPATCH_LOGGER = "mstar/dispatch-gate";
-var DEFAULT_DISPATCH_TOOLS = ["subagent"];
+var DEFAULT_DISPATCH_TOOLS = ["subagent", "subagent_fork"];
+var DEFAULT_WORKFLOW_TOOLS = ["workflow", "ralph"];
 var ASSIGNMENT_HEADING_RE2 = /^#{1,6}\s+Assignment\s*$/m;
 var ASSIGNMENT_FIELD_RE2 = /^[ \t]*(?:[-*][ \t]+)?\*{0,2}(Execute as|Delegation|Task category)\*{0,2}[ \t]*:[ \t]*(\S.*)$/gm;
 function isAssignmentShaped2(assignmentText) {
@@ -3931,6 +4086,30 @@ function worktreeL1Violations(harnessDir, header) {
   }
   return l1PreDispatchCheck({ controlWorktreePath, leaseWorktreePath, leaseWorkingBranch, planId }).violations;
 }
+function writableFanOutUncovered(harnessDir) {
+  if (harnessDir === null)
+    return { unreadable: false };
+  const statusPath = join6(harnessDir, STATUS_FILE);
+  if (!existsSync9(statusPath))
+    return { unreadable: false };
+  let doc;
+  try {
+    doc = readJson(statusPath);
+  } catch {
+    return { unreadable: true };
+  }
+  if (!Array.isArray(doc.plans))
+    return { unreadable: true };
+  for (const raw of doc.plans) {
+    const row = asRecord(raw);
+    if (row === undefined || row.status !== "InProgress")
+      continue;
+    const planId = typeof row.id === "string" && row.id !== "" ? row.id : typeof row.plan_id === "string" && row.plan_id !== "" ? row.plan_id : "in-progress-plan";
+    if (!verifyPlanExecutionLease(row, planId).ok)
+      return { uncoveredPlanId: planId, unreadable: false };
+  }
+  return { unreadable: false };
+}
 function dispatchGateCore(config, harnessDir, prompt) {
   const header = assignmentHeaderRegion(prompt);
   const violations = [...worktreeL2Violations(header), ...worktreeL1Violations(harnessDir, header)];
@@ -3938,8 +4117,96 @@ function dispatchGateCore(config, harnessDir, prompt) {
   violations.push(...composeDispatchGate(header, { agent: config.dispatchBinding ?? "", writable }).violations);
   return { violations, writable };
 }
+function workflowGateInputOf(exec) {
+  const args = asRecord(exec.arguments);
+  if (args === undefined)
+    return;
+  if (exec.name === "ralph") {
+    const objective = typeof args.objective === "string" ? args.objective : undefined;
+    if (objective === undefined)
+      return;
+    return { tool: exec.name, objective, exec };
+  }
+  if (exec.name === "workflow") {
+    const meta = asRecord(args.meta);
+    const metaName = typeof meta?.name === "string" ? normalizeWorkflowName(meta.name) : undefined;
+    if (meta === undefined || metaName === undefined || metaName === "")
+      return;
+    return { tool: exec.name, metaName, exec };
+  }
+  return;
+}
+function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
+  const toolName = exec.name;
+  if (!DEFAULT_WORKFLOW_TOOLS.includes(toolName))
+    return;
+  const mode = config.workflowGate ?? "warn";
+  if (mode === "off")
+    return;
+  const input = workflowGateInputOf(exec);
+  if (input === undefined) {
+    ctx.logger(DISPATCH_LOGGER).warn(`workflow gate (${toolName}) (fail-open): malformed arguments — no ${toolName === "ralph" ? "objective" : "meta"} to gate on; call allowed`);
+    return;
+  }
+  const pb = writableFanOutUncovered(harnessDir);
+  if (pb.unreadable) {
+    const statusLabel = harnessDir === null ? STATUS_FILE : join6(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, {
+    ...input,
+    ...pb.uncoveredPlanId !== undefined ? { uncoveredPlanId: pb.uncoveredPlanId } : {}
+  });
+  const recordVerdict = (v, code) => {
+    if (harnessDir === null)
+      return;
+    adapter.recordWorkflowVerdict({
+      harnessDir,
+      exec,
+      tool: input.tool,
+      ...input.metaName !== undefined ? { workflow: input.metaName } : {},
+      ...input.objective !== undefined ? { objective: input.objective } : {},
+      mode,
+      verdict: v,
+      ...code !== undefined ? { code } : {}
+    });
+  };
+  switch (verdict.decision) {
+    case "allow":
+      recordVerdict("ok");
+      return;
+    case "warn":
+      ctx.logger(DISPATCH_LOGGER).warn(`workflow gate (${toolName}) (advisory): ${verdict.reason}`);
+      ctx.emit("mstar/dispatch-gate", {
+        tool: toolName,
+        role: "",
+        result: {
+          ok: false,
+          violations: [{
+            ok: false,
+            severity: "medium",
+            code: verdict.code,
+            message: verdict.reason
+          }]
+        },
+        hard: false
+      });
+      recordVerdict("advisory", verdict.code);
+      return;
+    case "ask":
+      recordVerdict("ask", verdict.code);
+      return { kind: "ask", reason: verdict.reason };
+    case "deny":
+      recordVerdict("denied", verdict.code);
+      ctx.logger(DISPATCH_LOGGER).error(`workflow gate (${toolName}) vetoed: ${verdict.reason}`);
+      return { kind: "deny", reason: verdict.reason };
+  }
+}
 function gateDispatch(ctx, harnessDir, config, adapter, exec) {
   const toolName = exec.name;
+  const workflowDecision = gateWorkflow(ctx, harnessDir, config, adapter, exec);
+  if (workflowDecision !== undefined)
+    return workflowDecision;
   if (!(config.dispatchTools ?? [...DEFAULT_DISPATCH_TOOLS]).includes(toolName))
     return;
   const args = asRecord(exec.arguments);
@@ -4002,6 +4269,19 @@ var AGENT_FLOW_FILE = "agent-flow.jsonl";
 var AGENT_FLOW_MAX_EVENTS = 500;
 var AGENT_FLOW_DEFAULT_LIMIT = 50;
 var AGENT_FLOW_SIZE_GATE_BYTES = 64 * 1024;
+var WORKFLOW_LEDGER_MAX_ID_LENGTH = 512;
+var WORKFLOW_LEDGER_MAX_LABEL_LENGTH = 512;
+var WORKFLOW_LEDGER_MAX_NAME_LENGTH = 1024;
+var WORKFLOW_LEDGER_TRUNCATION_MARKER = "…";
+var WORKFLOW_LEDGER_MAX_SEQ = 2 ** 31;
+function truncateLedgerField(value, cap) {
+  const cps = Array.from(value);
+  if (cps.length <= cap)
+    return value;
+  const keep = cap - WORKFLOW_LEDGER_TRUNCATION_MARKER.length;
+  const prefix = keep > 0 ? cps.slice(0, keep).join("") : "";
+  return prefix + WORKFLOW_LEDGER_TRUNCATION_MARKER;
+}
 var AGENT_FLOW_LOGGER = "mstar/agent-flow";
 var SETTLE_SEAM = "tools/post-execute";
 var SETTLE_SEAM_PAIRING_NOTE = `settle seam "${SETTLE_SEAM}" IS part of the verified dsh-tools registry surface (runPostExecute dispatches it for every tool call) — foreground dispatch calls settle here, background subagents settle via ctx.jobs.onJobDone pairing; only UNPAIRED payloads (non-dispatch tools, calls outside the apply-scoped pairing window) stay dispatch-only — never a fabricated settle`;
@@ -4140,13 +4420,53 @@ function recordSettle(input) {
     log("error", `settle record failed (contained): ${errorMessage(error)}`);
   }
 }
+function recordWorkflowEvent(input) {
+  try {
+    appendEvent(input.harnessDir, input.event);
+    try {
+      invalidator?.(input.harnessDir);
+    } catch (error) {
+      log("error", `catalog invalidation failed (contained): ${errorMessage(error)}`);
+    }
+    return true;
+  } catch (error) {
+    log("error", `workflow record failed (contained — the workflow run proceeds): ${errorMessage(error)}`);
+    return false;
+  }
+}
+function recordWorkflowVerdict(input) {
+  try {
+    const agent = input.exec !== undefined ? agentOfExec(input.exec) : undefined;
+    const event = {
+      v: 1,
+      ts: Date.now(),
+      kind: "workflow-verdict",
+      ...agent !== undefined ? { agent } : {},
+      tool: input.tool,
+      ...input.workflow !== undefined && input.workflow !== "" ? { workflow: truncateLedgerField(input.workflow, WORKFLOW_LEDGER_MAX_NAME_LENGTH) } : {},
+      ...input.objective !== undefined && input.objective !== "" ? { objective: truncateLedgerField(normalizeWorkflowName(input.objective), WORKFLOW_LEDGER_MAX_NAME_LENGTH) } : {},
+      mode: input.mode,
+      verdict: input.verdict,
+      ...input.code !== undefined && input.code !== "" ? { code: input.code } : {}
+    };
+    appendEvent(input.harnessDir, event);
+    try {
+      invalidator?.(input.harnessDir);
+    } catch (error) {
+      log("error", `catalog invalidation failed (contained): ${errorMessage(error)}`);
+    }
+  } catch (error) {
+    log("error", `workflow verdict record failed (contained — the gate proceeds): ${errorMessage(error)}`);
+  }
+}
 function eventFromUnknown(value) {
   const rec = asRecord(value);
   if (rec === undefined || rec.v !== 1 || typeof rec.ts !== "number" || !Number.isFinite(rec.ts))
     return;
   const kind = rec.kind;
-  if (kind !== "dispatch" && kind !== "settle")
+  if (kind !== "dispatch" && kind !== "settle" && kind !== "workflow-verdict" && kind !== "workflow-run" && kind !== "workflow-agent" && kind !== "workflow-run-end") {
     return;
+  }
   const agent = typeof rec.agent === "string" && rec.agent !== "" ? rec.agent : undefined;
   if (kind === "dispatch") {
     if (typeof rec.role !== "string" || typeof rec.hard !== "boolean")
@@ -4167,19 +4487,92 @@ function eventFromUnknown(value) {
       hard: rec.hard
     };
   }
-  const outcome = rec.outcome;
-  if (outcome !== "ok" && outcome !== "error" && outcome !== "denied")
+  if (kind === "settle") {
+    const outcome = rec.outcome;
+    if (outcome !== "ok" && outcome !== "error" && outcome !== "denied")
+      return;
+    return {
+      v: 1,
+      ts: rec.ts,
+      kind: "settle",
+      ...agent !== undefined ? { agent } : {},
+      outcome,
+      ...typeof rec.durationMs === "number" && Number.isFinite(rec.durationMs) ? { durationMs: rec.durationMs } : {},
+      ...typeof rec.role === "string" ? { role: rec.role } : {},
+      ...typeof rec.planId === "string" && rec.planId !== "" ? { planId: rec.planId } : {},
+      ...typeof rec.taskId === "string" && rec.taskId !== "" ? { taskId: rec.taskId } : {}
+    };
+  }
+  if (kind === "workflow-verdict") {
+    if (rec.tool !== "workflow" && rec.tool !== "ralph")
+      return;
+    const mode = rec.mode;
+    if (mode !== "off" && mode !== "warn" && mode !== "ask" && mode !== "hard")
+      return;
+    const verdict = rec.verdict;
+    if (verdict !== "ok" && verdict !== "advisory" && verdict !== "denied" && verdict !== "ask")
+      return;
+    if (rec.tool === "workflow") {
+      if (typeof rec.workflow !== "string" || rec.workflow === "")
+        return;
+    } else if (typeof rec.objective !== "string" || rec.objective === "") {
+      return;
+    }
+    return {
+      v: 1,
+      ts: rec.ts,
+      kind: "workflow-verdict",
+      ...agent !== undefined ? { agent } : {},
+      tool: rec.tool,
+      ...typeof rec.workflow === "string" && rec.workflow !== "" ? { workflow: truncateLedgerField(rec.workflow, WORKFLOW_LEDGER_MAX_NAME_LENGTH) } : {},
+      ...typeof rec.objective === "string" && rec.objective !== "" ? { objective: truncateLedgerField(rec.objective, WORKFLOW_LEDGER_MAX_NAME_LENGTH) } : {},
+      mode,
+      verdict,
+      ...typeof rec.code === "string" && rec.code !== "" ? { code: rec.code } : {}
+    };
+  }
+  if (typeof rec.runId !== "string" || rec.runId === "" || rec.runId.length > WORKFLOW_LEDGER_MAX_ID_LENGTH)
+    return;
+  if (kind === "workflow-run") {
+    if (typeof rec.name !== "string" || rec.name === "")
+      return;
+    return {
+      v: 1,
+      ts: rec.ts,
+      kind: "workflow-run",
+      ...agent !== undefined ? { agent } : {},
+      runId: rec.runId,
+      name: truncateLedgerField(rec.name, WORKFLOW_LEDGER_MAX_NAME_LENGTH)
+    };
+  }
+  if (kind === "workflow-agent") {
+    if (typeof rec.seq !== "number" || !Number.isInteger(rec.seq) || rec.seq < 1 || rec.seq >= WORKFLOW_LEDGER_MAX_SEQ) {
+      return;
+    }
+    if (typeof rec.label !== "string" || rec.label === "")
+      return;
+    if (typeof rec.childId !== "string" || rec.childId === "" || rec.childId.length > WORKFLOW_LEDGER_MAX_ID_LENGTH)
+      return;
+    return {
+      v: 1,
+      ts: rec.ts,
+      kind: "workflow-agent",
+      runId: rec.runId,
+      seq: rec.seq,
+      label: truncateLedgerField(rec.label, WORKFLOW_LEDGER_MAX_LABEL_LENGTH),
+      ...typeof rec.phase === "string" ? { phase: truncateLedgerField(rec.phase, WORKFLOW_LEDGER_MAX_LABEL_LENGTH) } : {},
+      childId: rec.childId
+    };
+  }
+  const stopReason = rec.stopReason;
+  if (stopReason !== "completed" && stopReason !== "cancelled" && stopReason !== "error")
     return;
   return {
     v: 1,
     ts: rec.ts,
-    kind: "settle",
-    ...agent !== undefined ? { agent } : {},
-    outcome,
-    ...typeof rec.durationMs === "number" && Number.isFinite(rec.durationMs) ? { durationMs: rec.durationMs } : {},
-    ...typeof rec.role === "string" ? { role: rec.role } : {},
-    ...typeof rec.planId === "string" && rec.planId !== "" ? { planId: rec.planId } : {},
-    ...typeof rec.taskId === "string" && rec.taskId !== "" ? { taskId: rec.taskId } : {}
+    kind: "workflow-run-end",
+    runId: rec.runId,
+    stopReason
   };
 }
 function eventView(event) {
@@ -4196,6 +4589,65 @@ function eventView(event) {
       ...event.hard !== undefined ? { hard: event.hard } : {}
     };
   }
+  if (event.kind === "workflow-run") {
+    return {
+      ts: event.ts,
+      kind: "workflow-run",
+      agent: event.agent ?? null,
+      role: "",
+      planId: null,
+      taskId: null,
+      taskCategory: null,
+      runId: event.runId,
+      name: event.name
+    };
+  }
+  if (event.kind === "workflow-agent") {
+    return {
+      ts: event.ts,
+      kind: "workflow-agent",
+      agent: null,
+      role: "",
+      planId: null,
+      taskId: null,
+      taskCategory: null,
+      runId: event.runId,
+      seq: event.seq,
+      label: event.label,
+      ...event.phase !== undefined ? { phase: event.phase } : {},
+      childId: event.childId
+    };
+  }
+  if (event.kind === "workflow-run-end") {
+    return {
+      ts: event.ts,
+      kind: "workflow-run-end",
+      agent: null,
+      role: "",
+      planId: null,
+      taskId: null,
+      taskCategory: null,
+      runId: event.runId,
+      stopReason: event.stopReason
+    };
+  }
+  if (event.kind === "workflow-verdict") {
+    return {
+      ts: event.ts,
+      kind: "workflow-verdict",
+      agent: event.agent ?? null,
+      role: "",
+      planId: null,
+      taskId: null,
+      taskCategory: null,
+      tool: event.tool,
+      ...event.workflow !== undefined ? { workflow: event.workflow } : {},
+      ...event.objective !== undefined ? { objective: event.objective } : {},
+      mode: event.mode,
+      verdict: event.verdict,
+      ...event.code !== undefined ? { code: event.code } : {}
+    };
+  }
   return {
     ts: event.ts,
     kind: "settle",
@@ -4212,8 +4664,8 @@ function eventView(event) {
 function summaryOf(events) {
   const counts = new Map;
   for (const event of events) {
-    const role = event.kind === "dispatch" ? event.role : "";
-    const outcome = event.kind === "dispatch" ? event.verdict : event.outcome;
+    const role = event.kind === "dispatch" ? event.role : event.kind === "workflow-run" || event.kind === "workflow-agent" || event.kind === "workflow-run-end" || event.kind === "workflow-verdict" ? "workflow" : "";
+    const outcome = event.kind === "dispatch" ? event.verdict : event.kind === "workflow-verdict" ? event.verdict : event.kind === "settle" ? event.outcome : event.kind;
     const key = `${role}\x00${outcome}`;
     counts.set(key, (counts.get(key) ?? 0) + 1);
   }
@@ -4832,6 +5284,18 @@ function stripFrontmatter(text) {
   }
   return text;
 }
+var EPHEMERAL_CODES = {
+  "task-artifact": "skill.ephemeral.task-artifact",
+  "sdd-deeplink": "skill.ephemeral.sdd-deeplink"
+};
+function ephemeralViolation(citation) {
+  return {
+    ok: false,
+    severity: "medium",
+    code: EPHEMERAL_CODES[citation.kind],
+    message: `ephemeral citation \`${citation.match}\` on line ${citation.line} — durable skill text must reference in-repo artifacts only (knowledge conventions/skill-content-porting-discipline.md §3)`
+  };
+}
 function lintSkillDoc(doc) {
   const violations = [];
   const frontmatter = lintSkillFrontmatter(doc);
@@ -4840,6 +5304,7 @@ function lintSkillDoc(doc) {
   const body = lintFiveQuestion(stripFrontmatter(doc));
   if (!body.ok)
     violations.push(...body.violations);
+  violations.push(...findEphemeralCitations(doc).map(ephemeralViolation));
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
 function lintSkillWrite(doc, options) {
@@ -5512,12 +5977,14 @@ class DshHostAdapter extends Service2 {
   resolver;
   config;
   pairing;
+  workflowAskCache;
   logSink;
   constructor(ctx, options) {
     super(ctx, "dshHostAdapter");
     this.resolver = options.resolver;
     this.config = options.config;
     this.pairing = options.pairing;
+    this.workflowAskCache = options.workflowAskCache ?? new WorkflowAskCache;
     this.logSink = options.log ?? ((level, msg) => {
       const logger = ctx.logger(HOST_LOGGER);
       if (level === "warn")
@@ -5558,6 +6025,9 @@ class DshHostAdapter extends Service2 {
     }
     return { ok: violations.length === 0, violations };
   }
+  recordWorkflowVerdict(input) {
+    recordWorkflowVerdict(input);
+  }
   async beforeStatusWrite(path, doc) {
     const gate2 = doc !== undefined ? validateStatusValue(doc) : this.statusGate(path);
     if (!gate2.ok) {
@@ -5578,28 +6048,91 @@ class DshHostAdapter extends Service2 {
   }
 }
 
-// src/index.ts
-var name = "dsh";
-var inject = [];
-function packagedCommandsDir() {
+// src/gates/agent-personas.ts
+import { readFileSync as readFileSync12, readdirSync as readdirSync7, statSync as statSync4 } from "node:fs";
+import { join as join16, resolve as resolve14, sep as sep4 } from "node:path";
+var ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
+var defaultCache = new Map;
+function personaFor(roleId, lookup, warn) {
+  const configured = lookup.rolePersonas?.[roleId];
+  if (configured !== undefined && configured !== "")
+    return { text: configured, source: "config" };
+  if (lookup.agentsDir === undefined)
+    return;
+  const text = defaultFromMirror(lookup.agentsDir, roleId, warn);
+  if (text === undefined || text.trim() === "")
+    return;
+  return { text, source: "default" };
+}
+function subagentRoleIds(agentsDir) {
+  let names;
   try {
-    const dir = fileURLToPath3(new URL("../harness-commands", import.meta.url));
-    return existsSync16(dir) ? dir : undefined;
+    names = readdirSync7(agentsDir);
   } catch {
-    return;
+    return [];
+  }
+  const ids = [];
+  for (const name of names) {
+    if (!name.endsWith(".md"))
+      continue;
+    const roleId = name.slice(0, -3);
+    let content;
+    try {
+      content = readFileSync12(join16(agentsDir, name), "utf8");
+    } catch {
+      continue;
+    }
+    const mode = parseShellFrontmatter(content).mode;
+    if (mode === undefined || mode === "subagent")
+      ids.push(roleId);
   }
+  return ids.sort();
 }
-function commandFrontmatterField(frontmatter, label) {
-  const match = new RegExp(`^${label}[ \\t]*:[ \\t]*(.+)$`, "m").exec(frontmatter);
-  return match?.[1]?.trim();
+function defaultFromMirror(agentsDir, roleId, warn) {
+  if (!ROLE_ID_PATTERN.test(roleId))
+    return;
+  const root = resolve14(agentsDir);
+  const file = resolve14(agentsDir, `${roleId}.md`);
+  if (!file.startsWith(root + sep4))
+    return;
+  let stat;
+  try {
+    stat = statSync4(file);
+  } catch {
+    return;
+  }
+  if (!stat.isFile())
+    return;
+  const hit = defaultCache.get(file);
+  if (hit !== undefined && hit.mtimeMs === stat.mtimeMs)
+    return hit.text;
+  let content;
+  try {
+    content = readFileSync12(file, "utf8");
+  } catch {
+    return;
+  }
+  const text = extractShellPersona(content, roleId, warn);
+  defaultCache.set(file, { mtimeMs: stat.mtimeMs, text });
+  return text;
 }
-function unquote(value) {
-  return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+function extractShellPersona(content, roleId, warn) {
+  const parsed = parseShellFrontmatter(content);
+  const description = parsed.description;
+  if (description === undefined || description.trim() === "")
+    return;
+  if (parsed.mode !== undefined && parsed.mode !== "subagent")
+    return;
+  if (PERSONA_INTERPOLATION_HAZARD.test(description)) {
+    warn?.(`harness-agents default skipped for role '${roleId}' — description contains a "{{" paired with a later "}}" (dsh system-prompt strict interpolation renders persona text and throws on unknown or malformed references — use single braces or reword)`);
+    return;
+  }
+  return description;
 }
-function parseCommandMarkdown(content) {
+function parseShellFrontmatter(content) {
   const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
   if (lines.length === 0 || lines[0].trim() !== "---")
-    return;
+    return {};
   let end = -1;
   for (let i = 1;i < lines.length; i++) {
     if (lines[i].trim() === "---") {
@@ -5608,34 +6141,1169 @@ function parseCommandMarkdown(content) {
     }
   }
   if (end === -1)
-    return;
-  const frontmatter = lines.slice(1, end).join(`
-`);
-  const name2 = commandFrontmatterField(frontmatter, "name");
-  const description = commandFrontmatterField(frontmatter, "description");
-  if (name2 === undefined || description === undefined)
-    return;
-  const input = commandFrontmatterField(frontmatter, "input");
-  return {
-    name: name2,
-    description: unquote(description),
-    ...input !== undefined && input !== "" ? { input: unquote(input) } : {},
-    body: lines.slice(end + 1).join(`
-`).trim()
-  };
+    return {};
+  const frontmatter = lines.slice(1, end);
+  const result = {};
+  for (let i = 0;i < frontmatter.length; i++) {
+    const line = frontmatter[i];
+    const key = /^([A-Za-z][A-Za-z0-9_-]*)[ \t]*:[ \t]*(.*)$/.exec(line);
+    if (key === null)
+      continue;
+    const label = key[1];
+    const rest = key[2];
+    if (label === "description") {
+      const block = /^\|[+-]?(?<indent>\d*)[ \t]*$/.exec(rest);
+      result.description = block !== null ? extractBlockScalar(frontmatter, i + 1, block.groups?.indent) : unquote(rest.trim());
+    } else if (label === "mode") {
+      result.mode = unquote(rest.trim());
+    }
+  }
+  return result;
 }
-function registerMstarCommands(ctx) {
-  const dir = packagedCommandsDir();
-  if (dir === undefined)
-    return;
-  ctx.inject(["commands"], (commandsCtx) => {
-    for (const file of readdirSync7(dir).sort()) {
-      if (!file.endsWith(".md"))
-        continue;
-      const parsed = parseCommandMarkdown(readFileSync12(join16(dir, file), "utf8"));
-      if (parsed === undefined)
-        continue;
-      commandsCtx.commands.register({
+function extractBlockScalar(frontmatter, start, explicitIndent) {
+  const blockLines = [];
+  for (let i = start;i < frontmatter.length; i++) {
+    const line = frontmatter[i];
+    if (line.trim() === "") {
+      blockLines.push("");
+      continue;
+    }
+    if (/^[ \t]/.test(line)) {
+      blockLines.push(line);
+      continue;
+    }
+    break;
+  }
+  let indent = explicitIndent !== undefined && explicitIndent !== "" ? Number(explicitIndent) : undefined;
+  if (indent === undefined) {
+    const first = blockLines.find((line) => line.trim() !== "");
+    indent = first !== undefined ? /^[ \t]*/.exec(first)[0].length : 0;
+  }
+  return blockLines.map((line) => line.trim() === "" ? "" : line.slice(Math.min(indent, line.length))).join(`
+`).replace(/\n+$/, "");
+}
+function unquote(value) {
+  return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+
+// src/gates/fallbacks-probe.ts
+var FALLBACKS_ENTRY_NAME = "dsh-llm-fallbacks";
+function fallbacksService(ctx) {
+  return ctx.get("llm-fallbacks");
+}
+function fallbacksEntry(ctx) {
+  const loader = ctx.get("loader");
+  if (loader === undefined)
+    return;
+  for (const entry of loader.entries()) {
+    if (entry.options.name !== FALLBACKS_ENTRY_NAME)
+      continue;
+    if (entry.options.group)
+      continue;
+    if (entry.disabled)
+      continue;
+    return entry;
+  }
+  return;
+}
+function fallbacksMounted(ctx) {
+  if (fallbacksService(ctx) !== undefined)
+    return true;
+  const entry = fallbacksEntry(ctx);
+  if (entry === undefined)
+    return false;
+  return entry.fiber !== undefined;
+}
+
+// src/gates/fallbacks-decoration.ts
+var DECORATION_LOGGER = "mstar/subagent-decoration";
+var PERSONA_SECTION_NAME = "mstar:role-persona";
+var PERSONA_SECTION_ORDER = 1;
+var decorationLogSink = () => {};
+function setDecorationLogger(sink) {
+  const prior = decorationLogSink;
+  decorationLogSink = sink;
+  return prior;
+}
+var decorationAgentsDir;
+var mirrorAbsentDebugged = false;
+function setDecorationAgentsDir(dir) {
+  const prior = decorationAgentsDir;
+  decorationAgentsDir = dir;
+  mirrorAbsentDebugged = false;
+  return prior;
+}
+function seededTaskPrompt(child) {
+  for (const event of child.session.events) {
+    if (event.type !== "user/message")
+      continue;
+    const text = event.data.content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+    if (text.trim().length > 0)
+      return text;
+  }
+  return;
+}
+function decorateSubagentStart(ctx, config, info) {
+  try {
+    const personas = config.rolePersonas;
+    const agentsDir = decorationAgentsDir;
+    if ((personas == null || Object.keys(personas).length === 0) && agentsDir === undefined)
+      return;
+    const agents = ctx.get("agents");
+    if (agents === undefined) {
+      log2("debug", "agents service absent — mstar:role-persona decoration skipped (composition without dsh-agent)");
+      return;
+    }
+    const child = agents.get(info.id);
+    if (child === undefined)
+      return;
+    const taskPrompt = seededTaskPrompt(child);
+    if (taskPrompt === undefined)
+      return;
+    const executeAs = parseAssignmentFields(assignmentHeaderRegion(taskPrompt)).executeAs;
+    if (executeAs === undefined)
+      return;
+    const persona = personaFor(executeAs, { rolePersonas: config.rolePersonas, agentsDir }, (message) => log2("warn", message));
+    if (persona === undefined) {
+      if (agentsDir === undefined && !mirrorAbsentDebugged) {
+        mirrorAbsentDebugged = true;
+        log2("debug", "harness-agents mirror absent — mstar:role-persona skipped (config-only lookups; mirror defaults unavailable)");
+      }
+      return;
+    }
+    child.ctx.systemPrompt.section({
+      name: PERSONA_SECTION_NAME,
+      order: PERSONA_SECTION_ORDER,
+      text: persona.text
+    });
+    if (fallbacksMounted(ctx)) {
+      log2("info", `dsh-llm-fallbacks mounted (v${fallbacksService(ctx)?.version ?? "unknown"}) — mstar:role-persona injected for role '${executeAs}'`);
+    } else {
+      log2("debug", `dsh-llm-fallbacks unmounted — mstar:role-persona injected from ${persona.source === "config" ? "mstar Config" : "harness-agents default"} for role '${executeAs}' (decoration channel unchanged)`);
+    }
+  } catch (error) {
+    log2("warn", `mstar:role-persona decoration aborted (degraded — subagent dispatch unaffected): ${errorMessage2(error)}`);
+  }
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function log2(level, message) {
+  try {
+    decorationLogSink(level, message);
+  } catch {}
+}
+
+// src/gates/workflow-ledger.ts
+import { readFileSync as readFileSync13, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join17 } 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";
+var TOOL_WORKFLOW_AGENT_END = "tool-workflow/agent-end";
+var TOOL_WORKFLOW_RUN_END = "tool-workflow/run-end";
+var DEPTH_ADVISORY_THRESHOLD = 2;
+var WORKFLOW_LEDGER_WATERMARK_FILE = "workflow-ledger-cursors.json";
+var WORKFLOW_LEDGER_WATERMARK_MAX_SESSIONS = 256;
+var workflowLedgerLogSink = () => {};
+function setWorkflowLedgerLogger(sink) {
+  const prior = workflowLedgerLogSink;
+  workflowLedgerLogSink = sink;
+  return prior;
+}
+function log3(level, message) {
+  try {
+    workflowLedgerLogSink(level, message);
+  } catch {}
+}
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function sessionIdOf2(session) {
+  const id = session?.id;
+  return typeof id === "string" && id !== "" ? id : undefined;
+}
+var watermarkCache = new Map;
+function loadWatermark(harnessDir) {
+  const cached = watermarkCache.get(harnessDir);
+  if (cached !== undefined)
+    return cached;
+  const watermark = new Map;
+  try {
+    const raw = readFileSync13(join17(harnessDir, WORKFLOW_LEDGER_WATERMARK_FILE), "utf8");
+    const record = asRecord(JSON.parse(raw));
+    const cursors = asRecord(record?.cursors);
+    if (cursors !== undefined) {
+      for (const [sid, next] of Object.entries(cursors)) {
+        if (typeof next === "number" && Number.isInteger(next) && next >= 1 && next < WORKFLOW_LEDGER_MAX_SEQ && sid !== "") {
+          watermark.set(sid, next);
+        }
+      }
+    }
+  } catch (error) {
+    const err = error;
+    if (err?.code !== "ENOENT") {
+      log3("warn", `workflow-ledger watermark unreadable for ${harnessDir} — degrading to in-memory-only (restart re-records): ${errorMessage3(error)}`);
+    }
+  }
+  watermarkCache.set(harnessDir, watermark);
+  return watermark;
+}
+function saveWatermark(harnessDir, watermark) {
+  try {
+    const file = join17(harnessDir, WORKFLOW_LEDGER_WATERMARK_FILE);
+    const tmp = `${file}.tmp`;
+    writeFileSync4(tmp, JSON.stringify({ v: 1, cursors: Object.fromEntries(watermark) }));
+    renameSync3(tmp, file);
+  } catch (error) {
+    log3("warn", `workflow-ledger watermark write failed for ${harnessDir} — in-memory only (restart re-records): ${errorMessage3(error)}`);
+  }
+}
+function advanceWatermark(harnessDir, sid, nextSeq, isEvictable) {
+  const watermark = loadWatermark(harnessDir);
+  if (!watermark.has(sid) && watermark.size >= WORKFLOW_LEDGER_WATERMARK_MAX_SESSIONS) {
+    let victim;
+    for (const key of watermark.keys()) {
+      if (isEvictable(key)) {
+        victim = key;
+        break;
+      }
+    }
+    victim ??= watermark.keys().next().value;
+    if (victim !== undefined) {
+      watermark.delete(victim);
+      log3("warn", `workflow-ledger watermark capped at ${WORKFLOW_LEDGER_WATERMARK_MAX_SESSIONS} sessions — evicted ${victim} (a restored evicted session re-records; bounded by the cap)`);
+    }
+  }
+  watermark.set(sid, nextSeq);
+  saveWatermark(harnessDir, watermark);
+}
+function rowOf(session, envelope) {
+  const record = asRecord(envelope);
+  if (record === undefined)
+    return;
+  const type = record.type;
+  if (typeof type !== "string")
+    return;
+  const seq = record.seq;
+  if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 0 || seq >= WORKFLOW_LEDGER_MAX_SEQ)
+    return;
+  const time = record.time;
+  if (typeof time !== "number" || !Number.isFinite(time))
+    return;
+  const data = asRecord(record.data);
+  if (data === undefined)
+    return;
+  const runId = data.runId;
+  if (typeof runId !== "string" || runId === "" || runId.length > WORKFLOW_LEDGER_MAX_ID_LENGTH)
+    return;
+  if (type === TOOL_WORKFLOW_RUN_START) {
+    const name = typeof data.name === "string" ? normalizeWorkflowName(data.name) : data.name;
+    if (typeof name !== "string" || name === "")
+      return;
+    const agent = sessionIdOf2(session);
+    return {
+      seq,
+      runName: name,
+      event: {
+        v: 1,
+        ts: time,
+        kind: "workflow-run",
+        runId,
+        name: truncateLedgerField(name, WORKFLOW_LEDGER_MAX_NAME_LENGTH),
+        ...agent !== undefined ? { agent } : {}
+      }
+    };
+  }
+  if (type === TOOL_WORKFLOW_AGENT_START) {
+    if (typeof data.seq !== "number" || !Number.isInteger(data.seq) || data.seq < 1 || data.seq >= WORKFLOW_LEDGER_MAX_SEQ) {
+      return;
+    }
+    const label = typeof data.label === "string" ? normalizeWorkflowName(data.label) : data.label;
+    if (typeof label !== "string" || label === "")
+      return;
+    if (typeof data.childId !== "string" || data.childId === "" || data.childId.length > WORKFLOW_LEDGER_MAX_ID_LENGTH)
+      return;
+    return {
+      seq,
+      childId: data.childId,
+      event: {
+        v: 1,
+        ts: time,
+        kind: "workflow-agent",
+        runId,
+        seq: data.seq,
+        label: truncateLedgerField(label, WORKFLOW_LEDGER_MAX_LABEL_LENGTH),
+        ...typeof data.phase === "string" ? { phase: truncateLedgerField(normalizeWorkflowName(data.phase), WORKFLOW_LEDGER_MAX_LABEL_LENGTH) } : {},
+        childId: data.childId
+      }
+    };
+  }
+  if (type === TOOL_WORKFLOW_AGENT_END) {
+    return;
+  }
+  if (type === TOOL_WORKFLOW_RUN_END) {
+    const stopReason = data.stopReason;
+    if (stopReason !== "completed" && stopReason !== "cancelled" && stopReason !== "error")
+      return;
+    return {
+      seq,
+      event: { v: 1, ts: time, kind: "workflow-run-end", runId, stopReason }
+    };
+  }
+  return;
+}
+function depthAdvisory(sessions, row, warned) {
+  if (row.event.kind !== "workflow-agent" || row.childId === undefined)
+    return;
+  if (warned.has(row.event.runId))
+    return;
+  const child = sessions.get(row.childId);
+  const delegationDepth = child?.header?.delegationDepth;
+  if (typeof delegationDepth !== "number" || !Number.isFinite(delegationDepth) || delegationDepth < DEPTH_ADVISORY_THRESHOLD) {
+    return;
+  }
+  warned.add(row.event.runId);
+  log3("warn", `workflow run ${row.event.runId} member '${row.event.label}' (child ${row.childId}) is at delegation depth ${delegationDepth} (>= ${DEPTH_ADVISORY_THRESHOLD}) — advisory only, the run proceeds`);
+}
+function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
+  const sessions = ctx.get("sessions");
+  if (sessions === undefined) {
+    log3("debug", "sessions service absent — workflow-ledger consumer disabled (composition without dsh-session)");
+    return;
+  }
+  const depthWarned = new Set;
+  const consume = (session, envelope) => {
+    const sid = sessionIdOf2(session);
+    if (sid === undefined)
+      return;
+    const row = rowOf(session, envelope);
+    if (row === undefined)
+      return;
+    const cwd = session?.header?.cwd;
+    const harnessDir = resolver.forWorkspace(typeof cwd === "string" && cwd.trim() !== "" ? cwd : undefined);
+    if (harnessDir === null)
+      return;
+    const watermark = loadWatermark(harnessDir);
+    let next = watermark.get(sid) ?? 0;
+    const events = session.events;
+    if (Array.isArray(events) && events.length < next)
+      next = 0;
+    if (row.seq < next)
+      return;
+    if (recordWorkflowEvent({ harnessDir, event: row.event })) {
+      advanceWatermark(harnessDir, sid, row.seq + 1, (candidate) => sessions.get(candidate) === undefined);
+      if (workflowAskCache !== undefined && row.event.kind === "workflow-run") {
+        try {
+          const runName = row.runName ?? row.event.name;
+          if (workflowAskCache.wasAsked(runName)) {
+            workflowAskCache.record(runName, "allow");
+          }
+        } catch (error) {
+          log3("warn", `workflow P-c allow observation degraded (contained — the ledger row stays): ${errorMessage3(error)}`);
+        }
+      }
+    }
+    if (row.event.kind === "workflow-agent") {
+      try {
+        depthAdvisory(sessions, row, depthWarned);
+      } catch (error) {
+        log3("warn", `workflow depth advisory degraded (contained — the run proceeds): ${errorMessage3(error)}`);
+      }
+    }
+  };
+  const scanSession = (session) => {
+    const sid = sessionIdOf2(session);
+    if (sid === undefined)
+      return;
+    const events = session.events;
+    if (!Array.isArray(events))
+      return;
+    for (const envelope of events)
+      consume(session, envelope);
+  };
+  ctx.events.on("session/created", (session) => {
+    try {
+      scanSession(session);
+    } catch (error) {
+      log3("warn", `workflow-ledger session-created backfill failed (contained — the session publication proceeds): ${errorMessage3(error)}`);
+    }
+  });
+  let sessionsSnapshot;
+  try {
+    sessionsSnapshot = sessions.list();
+  } catch (error) {
+    log3("warn", `workflow-ledger cold scan could not list sessions (contained — the live firehose and session-created backfill stay active): ${errorMessage3(error)}`);
+    sessionsSnapshot = [];
+  }
+  for (const session of sessionsSnapshot) {
+    const sid = sessionIdOf2(session);
+    if (sid === undefined)
+      continue;
+    try {
+      scanSession(session);
+    } catch (error) {
+      log3("warn", `workflow-ledger cold scan failed for session ${sid} (contained — other sessions unaffected): ${errorMessage3(error)}`);
+    }
+  }
+  ctx.events.on("session/event", (session, envelope) => {
+    try {
+      consume(session, envelope);
+    } catch (error) {
+      log3("warn", `workflow-ledger live consume failed (contained — the workflow run proceeds): ${errorMessage3(error)}`);
+    }
+  });
+}
+
+// src/gates/goal-bridge.ts
+import { existsSync as existsSync16, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
+import { join as join18 } from "node:path";
+var GOAL_BRIDGE_LOGGER = "mstar/goal-bridge";
+var DEFAULT_MAX_GOAL_ROUNDS = 256;
+var FLOW_SEQUENCE = "iteration-start → per-plan cycles → iteration-close → PR delivery → merge-ready";
+var GOAL_CHANGE_EVENT_TYPE = "goal/change";
+var GOAL_CHANGE_VERSION = 1;
+var GOAL_ADVISORY_OBJECTIVE_CAP = 512;
+var GOAL_ADVISORY_MESSAGE_CAP = 512;
+var GOAL_ADVISORY_CODE_CAP = 128;
+var goalBridgeLogSink = () => {};
+function setGoalBridgeLogger(sink) {
+  const prior = goalBridgeLogSink;
+  goalBridgeLogSink = sink;
+  return prior;
+}
+function log4(level, message) {
+  goalBridgeLogSink(level, message);
+}
+function errorMessage4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRootLikeAgent(agent) {
+  const header = agent?.session?.header;
+  return header?.parentSession === undefined;
+}
+function iterationGoalObjective(iterationId) {
+  return `Run iteration ${iterationId} through the complete flow to its exit: ${FLOW_SEQUENCE}. ` + "Exit: the iteration's delivery PR is merged to the target branch and the merge-ready loop closes; the harness status.json stays the source of truth.";
+}
+function steeringCompass(harnessDir) {
+  const iterationsDir = resolveIterationDir(harnessDir);
+  if (!existsSync16(iterationsDir))
+    return;
+  let entries;
+  try {
+    entries = readdirSync8(iterationsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const compassPath = join18(iterationsDir, entry.name, "delivery-compass.md");
+    if (!existsSync16(compassPath))
+      continue;
+    let content;
+    try {
+      content = readFileSync14(compassPath, "utf8");
+    } catch {
+      continue;
+    }
+    const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (frontmatter === null || !/^status[ \t]*:[ \t]*(?:active|locked)[ \t]*$/m.test(frontmatter[1]))
+      continue;
+    return { iterationId: entry.name };
+  }
+  return;
+}
+var GOAL_STALE_REVISION = "GOAL_STALE_REVISION";
+function goalErrorCode(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  if (!("code" in error))
+    return;
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+function resolveGoalRounds(configValue) {
+  if (configValue === undefined)
+    return DEFAULT_MAX_GOAL_ROUNDS;
+  if (!Number.isSafeInteger(configValue) || configValue < 1) {
+    log4("warn", `invalid maxGoalRounds config ${String(configValue)} (must be a positive safe integer) — falling back to the default ${DEFAULT_MAX_GOAL_ROUNDS}`);
+    return DEFAULT_MAX_GOAL_ROUNDS;
+  }
+  return configValue;
+}
+function replaceDriftedGoal(goals, agent, current, objective, maxGoalRounds) {
+  if (current.phase === "complete") {
+    goals.create(agent, { objective, maxGoalRounds });
+    return;
+  }
+  goals.complete(agent, { id: current.id, revision: current.revision });
+  goals.create(agent, { objective, maxGoalRounds });
+}
+function mirrorIterationGoal(agent, input) {
+  const { resolver, goals, maxGoalRounds } = input;
+  if (goals === undefined)
+    return false;
+  if (!isRootLikeAgent(agent))
+    return false;
+  const harnessDir = resolver.forAgent(agent);
+  if (harnessDir === null)
+    return false;
+  const compass = steeringCompass(harnessDir);
+  if (compass === undefined)
+    return false;
+  const objective = iterationGoalObjective(compass.iterationId);
+  try {
+    const current = goals.get(agent);
+    if (current === undefined) {
+      goals.create(agent, { objective, maxGoalRounds });
+      return true;
+    }
+    if (current.objective === objective)
+      return true;
+    try {
+      replaceDriftedGoal(goals, agent, current, objective, maxGoalRounds);
+      return true;
+    } catch (error) {
+      if (goalErrorCode(error) !== GOAL_STALE_REVISION)
+        throw error;
+      const fresh = goals.get(agent);
+      if (fresh === undefined) {
+        goals.create(agent, { objective, maxGoalRounds });
+        return true;
+      }
+      if (fresh.objective === objective)
+        return true;
+      replaceDriftedGoal(goals, agent, fresh, objective, maxGoalRounds);
+      return true;
+    }
+  } catch (error) {
+    const code = goalErrorCode(error);
+    log4("warn", `goal mirror failed (contained — the session/decision point proceeds)${code !== undefined ? ` [${code}]` : ""}: ${errorMessage4(error)}`);
+    return false;
+  }
+}
+function blockedAdvisoryOf(envelope) {
+  const record = asRecord(envelope);
+  if (record === undefined || record.type !== GOAL_CHANGE_EVENT_TYPE)
+    return;
+  const data = asRecord(record.data);
+  if (data === undefined)
+    return;
+  if (data.version !== GOAL_CHANGE_VERSION)
+    return;
+  const goal = asRecord(data.goal);
+  if (goal === undefined)
+    return;
+  if (data.operation !== "block" && goal.phase !== "blocked")
+    return;
+  const blockedReason = asRecord(goal.blockedReason);
+  if (blockedReason === undefined)
+    return;
+  const code = blockedReason.code;
+  const message = blockedReason.message;
+  const objective = goal.objective;
+  if (typeof code !== "string" || code === "" || typeof message !== "string" || message === "" || typeof objective !== "string" || objective === "") {
+    return;
+  }
+  return { code, message, objective };
+}
+function warnBlockedGoal(harnessDir, advisory) {
+  const code = truncateLedgerField(advisory.code, GOAL_ADVISORY_CODE_CAP);
+  const reason = truncateLedgerField(normalizeWorkflowName(advisory.message), GOAL_ADVISORY_MESSAGE_CAP);
+  const objective = truncateLedgerField(normalizeWorkflowName(advisory.objective), GOAL_ADVISORY_OBJECTIVE_CAP);
+  log4("warn", `goal blocked [${code}] — ${reason}; objective: ${objective}; residuals: see ${harnessDir}/${STATUS_FILE} (residual_findings) — advisory only, zero harness writes`);
+}
+function rootAgentOf(agent, agents) {
+  let current = agent;
+  const seen = new Set;
+  for (;; ) {
+    const header = current?.session?.header;
+    if (header === undefined)
+      return;
+    if (header.parentSession === undefined)
+      return current;
+    if (typeof header.parentSession !== "string")
+      return;
+    if (seen.has(header.parentSession))
+      return;
+    seen.add(header.parentSession);
+    const parent = agents.get(header.parentSession);
+    if (parent === undefined)
+      return;
+    current = parent;
+  }
+}
+function registerGoalBridge(ctx, resolver, config) {
+  const goals = ctx.get("goals");
+  if (goals === undefined) {
+    log4("debug", "goals service absent — goal bridge disabled (composition without @deepseek-ai/dsh-goal)");
+  }
+  const maxGoalRounds = resolveGoalRounds(config.maxGoalRounds);
+  const mirror = (agent) => {
+    try {
+      mirrorIterationGoal(agent, { resolver, goals, maxGoalRounds });
+    } catch (error) {
+      log4("warn", `goal bridge mirror failed (contained — the session/decision point proceeds): ${errorMessage4(error)}`);
+    }
+  };
+  ctx.events.on("agent/session-start", (payload) => {
+    if (payload.agent !== undefined)
+      mirror(payload.agent);
+  });
+  ctx.events.on("subagent/start", (info) => {
+    const agents = ctx.get("agents");
+    if (agents === undefined || typeof info.id !== "string")
+      return;
+    const child = agents.get(info.id);
+    if (child === undefined)
+      return;
+    const root = rootAgentOf(child, agents);
+    if (root !== undefined)
+      mirror(root);
+  });
+  ctx.events.on("session/event", (session, envelope) => {
+    try {
+      const advisory = blockedAdvisoryOf(envelope);
+      if (advisory === undefined)
+        return;
+      const cwd = session?.header?.cwd;
+      const harnessDir = resolver.forWorkspace(typeof cwd === "string" && cwd.trim() !== "" ? cwd : undefined);
+      if (harnessDir === null)
+        return;
+      warnBlockedGoal(harnessDir, advisory);
+    } catch (error) {
+      log4("warn", `goal blocked advisory degraded (contained — the session proceeds): ${errorMessage4(error)}`);
+    }
+  });
+}
+
+// src/gates/plan-mode-bridge.ts
+import { existsSync as existsSync17 } from "node:fs";
+import { join as join19 } from "node:path";
+var PLAN_MODE_BRIDGE_LOGGER = "mstar/plan-mode-bridge";
+var PLAN_STATUS_TODO = "Todo";
+var planModeBridgeLogSink = () => {};
+function setPlanModeBridgeLogger(sink) {
+  const prior = planModeBridgeLogSink;
+  planModeBridgeLogSink = sink;
+  return prior;
+}
+function log5(level, message) {
+  planModeBridgeLogSink(level, message);
+}
+function errorMessage5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function hasPrepareWindow(harnessDir) {
+  const statusPath = join19(harnessDir, STATUS_FILE);
+  if (!existsSync17(statusPath))
+    return false;
+  let doc;
+  try {
+    doc = readJson(statusPath);
+  } catch {
+    return false;
+  }
+  const plans = doc.plans;
+  if (!Array.isArray(plans))
+    return false;
+  return plans.some((row) => asRecord(row)?.status === PLAN_STATUS_TODO);
+}
+function planModeTarget(harnessDir) {
+  if (steeringCompass(harnessDir) === undefined)
+    return false;
+  return hasPrepareWindow(harnessDir);
+}
+function syncPlanMode(agent, input) {
+  const { resolver, planMode } = input;
+  if (planMode === undefined)
+    return false;
+  if (!isRootLikeAgent(agent))
+    return false;
+  const harnessDir = resolver.forAgent(agent);
+  if (harnessDir === null)
+    return false;
+  try {
+    planMode.set(agent, planModeTarget(harnessDir));
+    return true;
+  } catch (error) {
+    log5("warn", `planMode sync failed (contained — the session/decision point proceeds): ${errorMessage5(error)}`);
+    return false;
+  }
+}
+function registerPlanModeBridge(ctx, resolver) {
+  const planMode = ctx.get("planMode");
+  if (planMode === undefined) {
+    log5("debug", "planMode service absent — plan-mode bridge disabled (composition without @deepseek-ai/dsh-plan-mode)");
+  }
+  const sync = (agent) => {
+    try {
+      syncPlanMode(agent, { resolver, planMode });
+    } catch (error) {
+      log5("warn", `planMode bridge sync failed (contained — the session/decision point proceeds): ${errorMessage5(error)}`);
+    }
+  };
+  ctx.events.on("agent/session-start", (payload) => {
+    if (payload.agent !== undefined)
+      sync(payload.agent);
+  });
+  ctx.events.on("subagent/start", (info) => {
+    const agents = ctx.get("agents");
+    if (agents === undefined || typeof info.id !== "string")
+      return;
+    const child = agents.get(info.id);
+    if (child === undefined)
+      return;
+    const root = rootAgentOf(child, agents);
+    if (root !== undefined)
+      sync(root);
+  });
+}
+
+// src/gates/fallbacks-seeds.ts
+var SEEDS_LOGGER = "mstar/fallbacks-seeds";
+var EMPTY_OUTCOME = { applied: [], skipped: [], conflicts: [] };
+function errorMessage6(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function mstarLoadLine(roleId) {
+  return `Load mstar-roles (references/${roleId}.md) and the role's Required Skill Dependencies before acting.`;
+}
+async function declareMstarSeeds(service, options) {
+  const { agentsDir, log: log6 } = options;
+  let readback;
+  try {
+    readback = service.getEffectiveRoles();
+  } catch (error) {
+    log6("warn", `fallbacks seed readback failed — mstar seeds not declared: ${errorMessage6(error)}`);
+    return { declared: [], skipped: [], preserved: [], outcome: EMPTY_OUTCOME };
+  }
+  const mstarIds = agentsDir === undefined ? [] : subagentRoleIds(agentsDir);
+  const mstarSet = new Set(mstarIds);
+  const preservedCandidates = [];
+  for (const row of readback.roles) {
+    if (!row.seeded)
+      continue;
+    const id = row.id.trim();
+    if (id === "" || mstarSet.has(id))
+      continue;
+    if (row.seedPersona === undefined || row.seedPersona.trim() === "") {
+      log6("debug", `seeded row '${id}' carries no seedPersona (upstream contract: present iff seeded) — not preserved`);
+      continue;
+    }
+    preservedCandidates.push({ id, persona: row.seedPersona });
+  }
+  const declared = [];
+  const skipped = [];
+  const forwardWarn = (message) => log6("warn", message);
+  for (const roleId of mstarIds) {
+    const persona = personaFor(roleId, { agentsDir }, forwardWarn);
+    if (persona === undefined) {
+      skipped.push({ id: roleId, reason: "no-persona" });
+      continue;
+    }
+    if (PERSONA_INTERPOLATION_HAZARD.test(persona.text)) {
+      log6("warn", `seed persona for mstar role '${roleId}' contains a "{{" paired with a later "}}" (dsh system-prompt strict interpolation renders persona text and throws on unknown or malformed references) — skipped`);
+      skipped.push({ id: roleId, reason: "interpolation" });
+      continue;
+    }
+    declared.push({ id: roleId, persona: `${persona.text}
+
+${mstarLoadLine(roleId)}` });
+  }
+  const preserved = [];
+  for (const entry of preservedCandidates) {
+    if (PERSONA_INTERPOLATION_HAZARD.test(entry.persona)) {
+      log6("warn", `preserved seed persona for '${entry.id}' contains a "{{" paired with a later "}}" (dsh system-prompt strict interpolation renders persona text and throws on unknown or malformed references) — skipped`);
+      skipped.push({ id: entry.id, reason: "interpolation" });
+      continue;
+    }
+    declared.push({ id: entry.id, persona: entry.persona });
+    preserved.push(entry);
+  }
+  if (declared.length === 0) {
+    log6("debug", "no mstar or preserved seeds to declare — empty batch skipped (registry untouched)");
+    return { declared, skipped, preserved, outcome: EMPTY_OUTCOME };
+  }
+  const outcome = await service.declareSeeds(declared);
+  log6("debug", `mstar seeds declared: ${declared.length} ids (${mstarIds.length} mstar + ${preserved.length} preserved); ${skipped.length} skipped locally`);
+  return { declared, skipped, preserved, outcome };
+}
+
+// src/gates/fallbacks-advisory.ts
+var ADVISORY_LOGGER = "mstar/fallbacks-advisory";
+var advisoryLogSink = () => {};
+function setAdvisoryLogger(sink) {
+  const prior = advisoryLogSink;
+  advisoryLogSink = sink;
+  return prior;
+}
+var ADVISORY_ID_LIST_CAP = 20;
+function capIdList(items) {
+  if (items.length <= ADVISORY_ID_LIST_CAP)
+    return items.join(", ");
+  return `${items.slice(0, ADVISORY_ID_LIST_CAP).join(", ")}… and ${items.length - ADVISORY_ID_LIST_CAP} more`;
+}
+async function runFallbacksAdvisory(ctx, agentsDir) {
+  try {
+    if (!fallbacksMounted(ctx))
+      return false;
+    const config = readRowConfig(ctx);
+    if (config === undefined) {
+      log6("debug", "fallbacks row config unreadable (absent or non-object) — adoption advisory skipped");
+      return true;
+    }
+    const service = fallbacksService(ctx);
+    if (service !== undefined) {
+      return await runSeedsAdvisory(service, config, agentsDir);
+    }
+    return runStructuralAdvisory(config, agentsDir);
+  } catch (error) {
+    log6("warn", `fallbacks adoption advisory aborted (degraded — warn-only, deployment config untouched): ${errorMessage7(error)}`);
+    return true;
+  }
+}
+async function runSeedsAdvisory(service, config, agentsDir) {
+  const legacy = service.detectLegacyKeys(config);
+  if (legacy.length > 0) {
+    log6("warn", `fallbacks config carries legacy keys (detectLegacyKeys): ${capIdList(legacy)} — migrate to the current shape (role entities use 'persona'; 'chains', 'roles.default', 'label' and 'description' are removed)`);
+  }
+  if (agentsDir === undefined) {
+    log6("debug", "harness-agents mirror absent — fallbacks adoption taxonomy check skipped (config-only advisory)");
+    return true;
+  }
+  const mstarIds = subagentRoleIds(agentsDir);
+  if (mstarIds.length === 0) {
+    log6("debug", "harness-agents mirror has no subagent-mode shells — fallbacks adoption taxonomy check skipped");
+    return true;
+  }
+  const seedsLog = (_level, message) => log6("debug", message);
+  const view = await declareMstarSeeds(service, { agentsDir, log: seedsLog });
+  let readback;
+  try {
+    readback = service.getEffectiveRoles();
+  } catch (error) {
+    log6("warn", `fallbacks effective-state readback failed — adoption state unavailable: ${errorMessage7(error)}`);
+    return true;
+  }
+  reportEffectiveState(mstarIds, readback);
+  reportDeclareOutcome(view);
+  return true;
+}
+function runStructuralAdvisory(config, agentsDir) {
+  if (agentsDir === undefined) {
+    log6("debug", "harness-agents mirror absent — fallbacks adoption taxonomy check skipped (config-only advisory)");
+    return true;
+  }
+  const mstarIds = subagentRoleIds(agentsDir);
+  if (mstarIds.length === 0) {
+    log6("debug", "harness-agents mirror has no subagent-mode shells — fallbacks adoption taxonomy check skipped");
+    return true;
+  }
+  const list = readRolesList(config);
+  if (list === undefined) {
+    log6("debug", "fallbacks roles block not structurally readable (roles.list absent or non-array) — adoption advisory skipped");
+    return true;
+  }
+  const declared = new Map;
+  for (let index = 0;index < list.length; index++) {
+    const entity = list[index];
+    if (entity === null || typeof entity !== "object") {
+      log6("debug", `fallbacks roles.list entry ${index} is not an object (${entity === null ? "null" : typeof entity}) — skipped`);
+      continue;
+    }
+    const view = entity;
+    if (typeof view.id !== "string" || view.id === "")
+      continue;
+    declared.set(view.id, view);
+  }
+  const missing = mstarIds.filter((id) => !declared.has(id));
+  if (missing.length > 0) {
+    log6("warn", `fallbacks roles.list is missing mstar roles: ${capIdList(missing)} — declare them under the mstar role id (or map via a taxonomy that uses those ids) so role-matched fallback chains resolve`);
+  }
+  const emptyPersona = [...declared.values()].filter((entity) => {
+    const persona = entity.persona;
+    return typeof persona !== "string" || persona.trim() === "";
+  }).map((entity) => entity.id);
+  if (emptyPersona.length > 0) {
+    log6("warn", `fallbacks roles.list declares roles with an empty persona: ${capIdList(emptyPersona)} — declare a persona (or remove the role)`);
+  }
+  return true;
+}
+function reportEffectiveState(mstarIds, readback) {
+  const byId = new Map;
+  for (const row of readback.roles) {
+    const key = row.id.trim();
+    if (byId.has(key)) {
+      log6("debug", `effective readback carries a duplicate id '${key}' after trimming — first row wins for the three-state report`);
+      continue;
+    }
+    byId.set(key, row);
+  }
+  const missing = [];
+  const overridden = [];
+  const seeded = [];
+  for (const id of mstarIds) {
+    const row = byId.get(id);
+    if (row === undefined) {
+      missing.push(id);
+      continue;
+    }
+    if (row.personaOverridden) {
+      overridden.push(id);
+      continue;
+    }
+    if (row.seeded)
+      seeded.push(id);
+  }
+  if (missing.length > 0) {
+    log6("warn", `fallbacks taxonomy is missing mstar roles: ${capIdList(missing)} — declare them under the mstar role id (or map via a taxonomy that uses those ids) so role-matched fallback chains resolve`);
+  }
+  if (seeded.length > 0) {
+    log6("debug", `fallbacks taxonomy: mstar roles seeded at their defaults — ${capIdList(seeded)}`);
+  }
+  if (overridden.length > 0) {
+    log6("warn", `fallbacks taxonomy overrides the seed persona for mstar roles: ${capIdList(overridden)} — the operator override is retained; revert to the seed default via the fallbacks settings card rollback button (fallbacks/revert-seed gateway)`);
+  }
+  const emptyPersona = readback.roles.filter((row) => {
+    const persona = row.persona;
+    if (typeof persona === "string" && persona.trim() !== "")
+      return false;
+    return !row.seeded || row.personaOverridden;
+  }).map((row) => row.id);
+  if (emptyPersona.length > 0) {
+    log6("warn", `fallbacks taxonomy declares roles with an empty persona: ${capIdList(emptyPersona)} — declare a persona (or remove the role)`);
+  }
+}
+function reportDeclareOutcome(view) {
+  const { skipped, outcome } = view;
+  const conflicts = outcome.conflicts;
+  if (skipped.length === 0 && outcome.skipped.length === 0 && conflicts.length === 0)
+    return;
+  const parts = [];
+  if (skipped.length > 0) {
+    parts.push(`skipped locally: ${capIdList(skipped.map((s) => `${s.id} (${s.reason})`))}`);
+  }
+  if (outcome.skipped.length > 0) {
+    parts.push(`skipped upstream: ${capIdList(outcome.skipped.map((s) => `${s.id} (${s.reason})`))}`);
+  }
+  if (conflicts.length > 0) {
+    parts.push(`conflicts: ${capIdList(conflicts.map((c) => `${c.id} (${c.kind} — operator override retained)`))}`);
+  }
+  const revertNote = conflicts.length > 0 ? " — revert an override via the fallbacks settings card rollback button (fallbacks/revert-seed gateway)" : "";
+  log6("warn", `fallbacks seed declaration: ${parts.join("; ")}${revertNote}`);
+}
+function errorMessage7(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function readRowConfig(ctx) {
+  const entry = fallbacksEntry(ctx);
+  if (entry === undefined)
+    return;
+  const config = entry.options.config;
+  if (config === undefined || config === null || typeof config !== "object" || Array.isArray(config))
+    return;
+  return config;
+}
+function readRolesList(config) {
+  const roles = config.roles;
+  if (roles === undefined || roles === null || typeof roles !== "object" || Array.isArray(roles))
+    return;
+  const list = roles.list;
+  if (!Array.isArray(list))
+    return;
+  return list;
+}
+function log6(level, message) {
+  try {
+    advisoryLogSink(level, message);
+  } catch {}
+}
+
+// src/gates/system-prompt.ts
+var HARNESS_PROMPT_LOGGER = "mstar/harness-prompt";
+var HARNESS_RULES_SECTION_NAME = "mstar:harness-rules";
+var HARNESS_RULES_SECTION_ORDER = 2;
+var ENGINE_STATUS_CONTEXT_NAME = "mstar:engine-status";
+var ENGINE_STATUS_CONTEXT_ORDER = 100;
+var harnessPromptLogSink = () => {};
+function setHarnessPromptLogger(sink) {
+  const prior = harnessPromptLogSink;
+  harnessPromptLogSink = sink;
+  return prior;
+}
+function resolveAssemblyHarnessDir(context, resolver, fallback) {
+  const agent = context?.agent;
+  if (agent === undefined || agent === null)
+    return fallback;
+  try {
+    return resolver.forAgent(agent);
+  } catch (error) {
+    log7("debug", `mstar:harness-rules per-assembly harness-dir resolution failed (falling back to the boot value): ${errorMessage8(error)}`);
+    return fallback;
+  }
+}
+function registerHarnessPrompt(ctx, options) {
+  const systemPrompt = ctx.get("systemPrompt");
+  if (systemPrompt === undefined || typeof systemPrompt.section !== "function" || typeof systemPrompt.context !== "function") {
+    log7("debug", "systemPrompt service absent — mstar:harness-rules injection skipped (composition without dsh-system-prompt)");
+    return false;
+  }
+  let bootHarnessDir;
+  try {
+    bootHarnessDir = options.resolver.forWorkspace(undefined);
+  } catch (error) {
+    log7("warn", `mstar:harness-rules injection aborted (degraded — session boot unaffected): ${errorMessage8(error)}`);
+    return false;
+  }
+  ctx.inject(["systemPrompt"], (systemPromptCtx) => {
+    try {
+      const view = systemPromptCtx.systemPrompt;
+      const disposeSection = view.section({
+        name: HARNESS_RULES_SECTION_NAME,
+        order: HARNESS_RULES_SECTION_ORDER,
+        text: (context) => {
+          const harnessDir = resolveAssemblyHarnessDir(context, options.resolver, bootHarnessDir);
+          return harnessRulesText(harnessDir, sectionEnforcement(harnessDir));
+        }
+      });
+      const disposeContext = view.context({
+        name: ENGINE_STATUS_CONTEXT_NAME,
+        order: ENGINE_STATUS_CONTEXT_ORDER,
+        text: engineStatusProvider(ctx, options.resolver, bootHarnessDir)
+      });
+      systemPromptCtx.effect(function* () {
+        yield () => {
+          try {
+            disposeSection();
+          } catch {}
+          try {
+            disposeContext();
+          } catch {}
+        };
+      }, "mstar:harness-rules disposer collection");
+    } catch (error) {
+      log7("warn", `mstar:harness-rules registration failed (contained — session boot unaffected): ${errorMessage8(error)}`);
+    }
+  });
+  return true;
+}
+function sectionEnforcement(harnessDir) {
+  return harnessDir === null ? { hard: false, source: "none" } : resolveCompassEnforcement(harnessDir);
+}
+function harnessRulesText(harnessDir, enforcement) {
+  return [
+    "This session runs under the Morning Star (mstar) harness: prompts and tool calls are governed by the harness gates and rules.",
+    `enforcement: ${enforcement.hard ? "hard" : "soft"}`,
+    `harness dir: ${stripInterpolationHazard(harnessDir ?? "none")}`,
+    "Before non-trivial work, read the skill `skill://mstar-harness-core` — the authoritative harness entry point (mstar-harness-core first, then topic skills)."
+  ].join(`
+`);
+}
+function engineStatusProvider(ctx, resolver, bootHarnessDir) {
+  const memo = new Map;
+  return (context) => {
+    const harnessDir = resolveAssemblyHarnessDir(context, resolver, bootHarnessDir);
+    const now = Date.now();
+    let entry = memo.get(harnessDir);
+    if (entry === undefined || now - entry.builtAt >= DEFAULT_CATALOG_TTL_MS) {
+      entry = { source: buildCatalogSources(ctx, harnessDir), builtAt: now };
+      memo.set(harnessDir, entry);
+    }
+    return engineStatusSummary(entry.source);
+  };
+}
+function engineStatusSummary(source) {
+  const lines = [
+    `mstar engine status: v${source.version} | harness ${stripInterpolationHazard(source.harnessDir ?? "none")} | enforcement ${source.enforcement.hard ? "hard" : "soft"}`
+  ];
+  const iteration = source.iteration;
+  if (iteration !== undefined) {
+    const gate2 = iteration.gate;
+    const codes = gate2.violations.map((v) => v.code).join(", ");
+    lines.push(`iteration ${stripInterpolationHazard(iteration.iterationId)}: gate ${gate2.ok ? "PASS" : `FAIL (${codes})`} | transition ${gate2.transition} | all plans done ${gate2.all_plans_done}`);
+  }
+  const state = source.state;
+  if (state !== null) {
+    const plans = state.plans.length === 0 ? "none" : state.plans.map((p) => `${stripInterpolationHazard(p.id)}(${stripInterpolationHazard(p.status)})`).join(" ");
+    const residuals = state.residuals.length === 0 ? "none" : state.residuals.map((r) => `${r.severity} ${r.count}`).join(", ");
+    const leases = state.leases.length === 0 ? "none active" : state.leases.map((l) => `${stripInterpolationHazard(l.planId)} → ${stripInterpolationHazard(l.holder)}`).join("; ");
+    lines.push(`plans: ${plans} | residuals: ${residuals} | leases: ${leases}`);
+    if (state.direction !== null)
+      lines.push(`direction: ${stripInterpolationHazard(state.direction)}`);
+  }
+  return lines.join(`
+`);
+}
+function errorMessage8(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function log7(level, message) {
+  try {
+    harnessPromptLogSink(level, message);
+  } catch {}
+}
+
+// src/index.ts
+var name = "dsh";
+var inject = ["loader"];
+function packagedCommandsDir() {
+  try {
+    const dir = fileURLToPath3(new URL("../harness-commands", import.meta.url));
+    return existsSync18(dir) ? dir : undefined;
+  } catch {
+    return;
+  }
+}
+function commandFrontmatterField(frontmatter, label) {
+  const match = new RegExp(`^${label}[ \\t]*:[ \\t]*(.+)$`, "m").exec(frontmatter);
+  return match?.[1]?.trim();
+}
+function unquote2(value) {
+  return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+function parseCommandMarkdown(content) {
+  const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
+  if (lines.length === 0 || lines[0].trim() !== "---")
+    return;
+  let end = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      end = i;
+      break;
+    }
+  }
+  if (end === -1)
+    return;
+  const frontmatter = lines.slice(1, end).join(`
+`);
+  const name2 = commandFrontmatterField(frontmatter, "name");
+  const description = commandFrontmatterField(frontmatter, "description");
+  if (name2 === undefined || description === undefined)
+    return;
+  const input = commandFrontmatterField(frontmatter, "input");
+  return {
+    name: name2,
+    description: unquote2(description),
+    ...input !== undefined && input !== "" ? { input: unquote2(input) } : {},
+    body: lines.slice(end + 1).join(`
+`).trim()
+  };
+}
+function registerMstarCommands(ctx) {
+  const dir = packagedCommandsDir();
+  if (dir === undefined)
+    return;
+  ctx.inject(["commands"], (commandsCtx) => {
+    for (const file of readdirSync9(dir).sort()) {
+      if (!file.endsWith(".md"))
+        continue;
+      const parsed = parseCommandMarkdown(readFileSync15(join20(dir, file), "utf8"));
+      if (parsed === undefined)
+        continue;
+      commandsCtx.commands.register({
         name: parsed.name,
         description: parsed.description,
         ...parsed.input !== undefined ? { input: { hint: parsed.input } } : {},
@@ -5675,7 +7343,98 @@ function apply(ctx, config) {
     else
       logger.info(message);
   });
+  setDecorationLogger((level, message) => {
+    const logger = ctx.logger(DECORATION_LOGGER);
+    if (level === "debug")
+      logger.debug(message);
+    else if (level === "info")
+      logger.info(message);
+    else
+      logger.warn(message);
+  });
+  setDecorationAgentsDir(packagedAgentsDir());
+  setHarnessPromptLogger((level, message) => {
+    const logger = ctx.logger(HARNESS_PROMPT_LOGGER);
+    if (level === "debug")
+      logger.debug(message);
+    else
+      logger.warn(message);
+  });
+  registerHarnessPrompt(ctx, { resolver });
+  setAdvisoryLogger((level, message) => {
+    const logger = ctx.logger(ADVISORY_LOGGER);
+    if (level === "debug")
+      logger.debug(message);
+    else
+      logger.warn(message);
+  });
+  let advisoryPassed = false;
+  let advisoryPassInFlight = false;
+  let advisoryGeneration = 0;
+  const runAdvisoryPass = () => {
+    if (advisoryPassed || advisoryPassInFlight)
+      return;
+    advisoryPassInFlight = true;
+    const generation = advisoryGeneration;
+    runFallbacksAdvisory(ctx, packagedAgentsDir()).then((ran) => {
+      if (ran && generation === advisoryGeneration)
+        advisoryPassed = true;
+    }).finally(() => {
+      advisoryPassInFlight = false;
+    });
+  };
+  runAdvisoryPass();
+  if (!fallbacksMounted(ctx)) {
+    ctx.logger(SEEDS_LOGGER).debug("fallbacks not mounted at apply — mstar seeds inject child armed; declare fires when the llm-fallbacks service appears (apply/HMR)");
+  }
+  ctx.inject(["llm-fallbacks"], (serviceCtx) => {
+    const service = fallbacksService(serviceCtx);
+    if (service === undefined)
+      return;
+    declareMstarSeeds(service, {
+      agentsDir: packagedAgentsDir(),
+      log: (level, message) => {
+        const logger = ctx.logger(SEEDS_LOGGER);
+        if (level === "warn")
+          logger.warn(message);
+        else if (level === "error")
+          logger.error(message);
+        else
+          logger.debug(message);
+      }
+    }).catch((error) => {
+      ctx.logger(SEEDS_LOGGER).error(`mstar seeds declaration failed (contained — fallbacks taxonomy unchanged): ${error instanceof Error ? error.message : String(error)}`);
+    });
+    return () => {
+      advisoryPassed = false;
+      advisoryGeneration += 1;
+    };
+  });
   registerSettleListener(ctx, config, pairing);
+  setWorkflowLedgerLogger((level, message) => {
+    const logger = ctx.logger(WORKFLOW_LEDGER_LOGGER);
+    if (level === "warn")
+      logger.warn(message);
+    else
+      logger.debug(message);
+  });
+  registerWorkflowLedger(ctx, resolver, adapter.workflowAskCache);
+  setGoalBridgeLogger((level, message) => {
+    const logger = ctx.logger(GOAL_BRIDGE_LOGGER);
+    if (level === "debug")
+      logger.debug(message);
+    else
+      logger.warn(message);
+  });
+  registerGoalBridge(ctx, resolver, config);
+  setPlanModeBridgeLogger((level, message) => {
+    const logger = ctx.logger(PLAN_MODE_BRIDGE_LOGGER);
+    if (level === "debug")
+      logger.debug(message);
+    else
+      logger.warn(message);
+  });
+  registerPlanModeBridge(ctx, resolver);
   ctx.inject(["jobs"], (jobsCtx) => {
     const jobs = jobsCtx.jobs;
     try {
@@ -5696,7 +7455,7 @@ function apply(ctx, config) {
     ctx.logger(DISPATCH_LOGGER).warn("Enforcement: hard is active but dispatchBinding is unset — the anti-recursion precheck is skipped (an Assignment whose Execute as equals the dispatching agent cannot be detected)");
   }
   if (effectiveHard && config.dispatchTools === undefined) {
-    ctx.logger(DISPATCH_LOGGER).warn('Enforcement: hard is active but dispatchTools is unset — the dispatch gate matches the default tool name "subagent"; a deployment renaming the dsh subagent tool (toolName) without declaring dispatchTools silently disables the gate');
+    ctx.logger(DISPATCH_LOGGER).warn('Enforcement: hard is active but dispatchTools is unset — the dispatch gate matches the default tool names "subagent" and "subagent_fork"; a deployment renaming either dsh subagent tool (toolName) without declaring dispatchTools silently disables the gate');
   }
   ctx.on("fs/write-intent", (target, actor, next) => writeIntentListener(ctx, resolver, config, adapter, target, actor, next), { prepend: true });
   ctx.on("fs/edit-intent", (target, actor, next) => editIntentListener(ctx, resolver, config, adapter, target, actor, next), { prepend: true });
@@ -5706,6 +7465,10 @@ function apply(ctx, config) {
     ctx.on("fs/write-intent", (target, actor, next) => seamWriteIntentListener(ctx, resolver, config, seam, target, actor, next), { prepend: true });
   }
   ctx.on("tools/pre-execute", (exec, next) => preExecuteListener(ctx, resolver, config, adapter, exec, next), { prepend: true });
+  ctx.events.on("subagent/start", (info) => {
+    runAdvisoryPass();
+    decorateSubagentStart(ctx, config, info);
+  });
   const ttlMs = config.catalogTtlMs ?? DEFAULT_CATALOG_TTL_MS;
   const explicitKey = bootHarnessDir !== null ? EXPLICIT_CACHE_KEY : undefined;
   const catalogCache = new Map;
@@ -5723,6 +7486,11 @@ function apply(ctx, config) {
 }
 export {
   skillLocalConfig,
+  setDecorationLogger,
+  setDecorationAgentsDir,
+  setAdvisoryLogger,
+  runFallbacksAdvisory,
+  recordWorkflowVerdict,
   recordSettle,
   recordDispatch,
   readAgentFlow,
@@ -5735,14 +7503,19 @@ export {
   lintCompoundWrite,
   lintAuditWrite,
   inject,
+  decorateSubagentStart,
   apply,
   SkillLintVetoError,
   SeamVetoError,
   SETTLE_SEAM,
+  PERSONA_SECTION_ORDER,
+  PERSONA_SECTION_NAME,
   HarnessResolver,
   DshMstar,
   DshHostAdapter,
+  DECORATION_LOGGER,
   Config,
   AGENT_FLOW_MAX_EVENTS,
-  AGENT_FLOW_FILE
+  AGENT_FLOW_FILE,
+  ADVISORY_LOGGER
 };