@mstar-harness/dsh 3.8.1 → 3.8.2

package/dist/index.js

@@ -1122,7 +1122,7 @@ var require_lib2 = __commonJS(function(exports, module) {
 });
 
 // src/index.ts
-import { existsSync as existsSync22, readFileSync as readFileSync19, readdirSync as readdirSync14 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18, readdirSync as readdirSync14 } from "node:fs";
 import { join as join25 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
@@ -4263,8 +4263,7 @@ var Config = import_schemastery.default.object({
     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)
+  workflowNames: import_schemastery.default.array(import_schemastery.default.string()).default(undefined)
 });
 function formatViolation(violation14) {
   return `[${violation14.severity}] ${violation14.code}: ${violation14.message}${violation14.fix !== undefined ? ` (fix: ${violation14.fix})` : ""}`;
@@ -4358,6 +4357,31 @@ function sessionHeaderIdOf(agent) {
   const id = session?.header?.id;
   return typeof id === "string" && id.trim() !== "" ? id : undefined;
 }
+function agentIdOf(agent) {
+  const id = agent?.id;
+  return typeof id === "string" && id.trim() !== "" ? id : undefined;
+}
+function verifiedLeaseHolderOf(agent, sessionId, cwd) {
+  if (agent === undefined)
+    return;
+  if (sessionHeaderIdOf(agent) !== sessionId)
+    return;
+  if (cwd !== undefined && sessionCwdOf(agent) !== cwd)
+    return;
+  return agentIdOf(agent);
+}
+function sessionHintOf(agent) {
+  const cwd = sessionCwdOf(agent);
+  const sessionId = sessionHeaderIdOf(agent);
+  const leaseHolder = agentIdOf(agent);
+  if (cwd === undefined && sessionId === undefined && leaseHolder === undefined)
+    return;
+  return {
+    ...cwd === undefined ? {} : { cwd },
+    ...sessionId === undefined ? {} : { sessionId },
+    ...leaseHolder === undefined ? {} : { leaseHolder }
+  };
+}
 function actorAgentOf(actor) {
   return actor?.agent;
 }
@@ -4382,8 +4406,8 @@ function skillLocalConfig(config) {
 }
 
 // src/gates/catalog.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync4, realpathSync as realpathSync7 } from "node:fs";
+import { basename as basename5, isAbsolute as isAbsolute7, join as join12, relative as relative7, sep as sep3 } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // src/gates/agent-flow.ts
@@ -4395,8 +4419,8 @@ import { existsSync as existsSync8 } from "node:fs";
 import { basename as basename2, join as join5, resolve as resolve6 } from "node:path";
 
 // src/gates/workflow-selection.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { dirname as dirname7, join as join3, relative as relative4 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, realpathSync as realpathSync5, statSync as statSync2 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join3, normalize, relative as relative4, sep as sep2 } from "node:path";
 var TERMINAL_STATUS_CACHE_MAX = 64;
 var terminalStatusCache = new Map;
 function terminalStatusOf(snapshotPath) {
@@ -4412,7 +4436,9 @@ function terminalStatusOf(snapshotPath) {
     return cached;
   let terminal = false;
   try {
-    const snapshot = readJson(snapshotPath);
+    const snapshot = asRecord(readJson(snapshotPath));
+    if (snapshot === undefined)
+      return;
     const status = snapshot.status;
     terminal = typeof status === "string" && WORKFLOW_TERMINAL_STATUSES.includes(status);
   } catch {
@@ -4428,7 +4454,101 @@ function terminalStatusOf(snapshotPath) {
   }
   return verdict;
 }
-function resolveActiveWorkflow(harnessDir) {
+function stripTrailingSeparators(path) {
+  let out = path;
+  while (out.length > 1 && out.endsWith(sep2))
+    out = out.slice(0, -1);
+  return out;
+}
+function lexical(path) {
+  return stripTrailingSeparators(normalize(path));
+}
+function canonicalPath(path) {
+  const fallback = lexical(path);
+  try {
+    return { kind: "ok", path: lexical(realpathSync5(path)) };
+  } catch (error) {
+    return error.code === "ENOENT" ? { kind: "missing", path: fallback } : { kind: "error" };
+  }
+}
+function within(root, cwd) {
+  if (root === "" || cwd === "" || !isAbsolute3(root) || !isAbsolute3(cwd))
+    return false;
+  const rootCanonical = canonicalPath(root);
+  if (rootCanonical.kind === "error")
+    return false;
+  const cwdCanonical = canonicalPath(cwd);
+  if (cwdCanonical.kind === "error")
+    return false;
+  const bothExist = rootCanonical.kind === "ok" && cwdCanonical.kind === "ok";
+  const rootPath = bothExist ? rootCanonical.path : lexical(root);
+  const cwdPath = bothExist ? cwdCanonical.path : lexical(cwd);
+  if (rootPath === cwdPath)
+    return true;
+  const rel = relative4(rootPath, cwdPath);
+  return rel !== "" && !isAbsolute3(rel) && rel !== ".." && !rel.startsWith(`..${sep2}`);
+}
+function validLeases(snapshot) {
+  if (!Array.isArray(snapshot.plans))
+    return [];
+  const leases = [];
+  for (const row of snapshot.plans) {
+    const lease = asRecord(asRecord(row)?.execution_lease);
+    if (lease === undefined || !validateExecutionLease(lease).ok)
+      continue;
+    leases.push(lease);
+  }
+  return leases;
+}
+function readSnapshot(harnessDir, entry) {
+  const snapshotPath = join3(harnessDir, entry.dir, WORKFLOW_SNAPSHOT_FILE);
+  if (!existsSync5(snapshotPath))
+    return;
+  try {
+    return asRecord(readJson(snapshotPath));
+  } catch {
+    return;
+  }
+}
+function soleEntry(matches) {
+  return matches.size === 1 ? matches.values().next().value : undefined;
+}
+function automaticBinding(harnessDir, entries, hint) {
+  const cwd = hint.cwd === "" ? undefined : hint.cwd;
+  const holder = hint.leaseHolder === "" ? undefined : hint.leaseHolder;
+  if (cwd === undefined && holder === undefined)
+    return;
+  const snapshots = new Map;
+  const snapshotOf = (entry) => {
+    const cached = snapshots.get(entry.dir);
+    if (cached !== undefined || snapshots.has(entry.dir))
+      return cached;
+    const snapshot = readSnapshot(harnessDir, entry);
+    snapshots.set(entry.dir, snapshot);
+    return snapshot;
+  };
+  const leaseMatches = new Map;
+  const cwdMatches = new Map;
+  for (const entry of entries) {
+    const snapshot = snapshotOf(entry);
+    if (snapshot === undefined)
+      continue;
+    const leases = validLeases(snapshot);
+    if (holder !== undefined && leases.some((lease) => lease.holder === holder) || cwd !== undefined && leases.some((lease) => within(String(lease.worktree_path), cwd))) {
+      leaseMatches.set(entry.id, entry);
+    }
+    const controlWorktree = snapshot.control_worktree_path;
+    if (cwd !== undefined && typeof controlWorktree === "string" && within(controlWorktree, cwd)) {
+      cwdMatches.set(entry.id, entry);
+    }
+  }
+  const byLease = soleEntry(leaseMatches);
+  if (byLease !== undefined)
+    return { kind: "active", workflowId: byLease.id, dir: byLease.dir };
+  const byCwd = soleEntry(cwdMatches);
+  return byCwd === undefined ? undefined : { kind: "active", workflowId: byCwd.id, dir: byCwd.dir };
+}
+function resolveActiveWorkflow(harnessDir, hint) {
   const statusPath = join3(harnessDir, STATUS_FILE);
   if (!existsSync5(statusPath)) {
     return {
@@ -4439,7 +4559,11 @@ function resolveActiveWorkflow(harnessDir) {
   }
   let doc;
   try {
-    doc = readJson(statusPath);
+    const parsed = asRecord(readJson(statusPath));
+    if (parsed === undefined) {
+      return { kind: "error", code: "status.unreadable", message: `cannot read ${statusPath}` };
+    }
+    doc = parsed;
   } catch {
     return { kind: "error", code: "status.unreadable", message: `cannot read ${statusPath}` };
   }
@@ -4450,39 +4574,67 @@ function resolveActiveWorkflow(harnessDir) {
       message: `status.json schema version 2 required — got ${JSON.stringify(doc.version)} (v1 or unknown version); run \`mstar migrate\` to convert the tree`
     };
   }
-  if (!Array.isArray(doc.workflows) || doc.workflows.length === 0) {
+  const registry = doc.workflows;
+  if (!Array.isArray(registry)) {
     return {
       kind: "error",
-      code: "workflow.selection.no-active",
-      message: "no active lifecycle in status.json workflows[] — the agent-flow writer appends only to an active lifecycle"
+      code: "workflow.selection.invalid-registry",
+      message: `status.json workflows[] is not an array: ${JSON.stringify(registry)} — the registry cannot be validated`
     };
   }
-  const first = doc.workflows[0];
-  const entry = asRecord(first);
-  const workflowId = typeof entry?.id === "string" ? entry.id : undefined;
-  const dir = typeof entry?.dir === "string" ? entry.dir : undefined;
-  if (workflowId === undefined || dir === undefined) {
+  if (registry.length === 0) {
     return {
       kind: "error",
-      code: "workflow.selection.invalid-entry",
-      message: `workflows[] first entry is missing id/dir: ${JSON.stringify(first)}`
+      code: "workflow.selection.no-active",
+      message: "no active lifecycle in status.json workflows[] — the agent-flow writer appends only to an active lifecycle"
     };
   }
-  if (doc.workflows.length > 1) {
-    return {
-      kind: "active",
-      workflowId,
-      dir,
-      warning: {
-        code: "workflow.selection.multi-active",
-        message: `${doc.workflows.length} active lifecycles in status.json workflows[] — selected the first (${workflowId}); no silent pick`
-      }
-    };
+  const entries = [];
+  const seen = new Set;
+  for (const raw of registry) {
+    const gate2 = validateWorkflowEntry(raw);
+    if (!gate2.ok) {
+      return {
+        kind: "error",
+        code: "workflow.selection.invalid-entry",
+        message: `workflows[] entry fails the v2 workflow-entry contract: ${gate2.violations.map((violation14) => violation14.message).join("; ")}`
+      };
+    }
+    const entry = raw;
+    if (seen.has(entry.id)) {
+      return {
+        kind: "error",
+        code: "workflow.selection.invalid-registry",
+        message: `duplicate workflow id in status.json workflows[]: ${entry.id} — the registry must be keyed by unique active lifecycles`
+      };
+    }
+    seen.add(entry.id);
+    entries.push({ id: entry.id, dir: entry.dir });
+  }
+  if (hint !== undefined) {
+    const automatic = automaticBinding(harnessDir, entries, hint);
+    if (automatic !== undefined)
+      return automatic;
+    const selected = hint.selectedWorkflowId;
+    if (selected !== undefined && selected !== "") {
+      const picked = entries.find((entry) => entry.id === selected);
+      if (picked !== undefined)
+        return { kind: "active", workflowId: picked.id, dir: picked.dir };
+    }
+  }
+  if (entries.length === 1) {
+    const only = entries[0];
+    return { kind: "active", workflowId: only.id, dir: only.dir };
   }
-  return { kind: "active", workflowId, dir };
+  return {
+    kind: "error",
+    code: "workflow.selection.unbound-multi-active",
+    message: `${entries.length} active lifecycles in status.json workflows[] — this session has no lease, is not inside a workflow worktree and has no stored selection; pick one for this session (writes pause until then)`,
+    activeWorkflowIds: entries.map((entry) => entry.id)
+  };
 }
-function resolveReadWorkflow(harnessDir) {
-  const active = resolveActiveWorkflow(harnessDir);
+function resolveReadWorkflow(harnessDir, hint) {
+  const active = resolveActiveWorkflow(harnessDir, hint);
   if (active.kind === "active")
     return active;
   if (active.kind === "error" && active.code !== "workflow.selection.no-active")
@@ -4707,7 +4859,7 @@ function sessionIdOf(exec) {
   const id = agent?.id;
   return typeof id === "string" && id.trim() !== "" ? id : undefined;
 }
-function leaseGateViolations(harnessDir, exec, writable, prompt) {
+function leaseGateViolations(harnessDir, exec, writable, prompt, hint) {
   if (harnessDir === null || writable === false)
     return [];
   const header = assignmentHeaderRegion(prompt);
@@ -4716,7 +4868,7 @@ function leaseGateViolations(harnessDir, exec, writable, prompt) {
   const planId = planIdOf(header);
   if (planId === undefined || planId === "")
     return [];
-  const selection = resolveActiveWorkflow(harnessDir);
+  const selection = resolveActiveWorkflow(harnessDir, hint);
   if (selection.kind !== "active") {
     if (!sdd)
       return [];
@@ -4799,10 +4951,10 @@ function worktreeL2Violations(header) {
   violations.push(...l2PreDispatchCheck({ tracks }).violations);
   return violations;
 }
-function activeSnapshotRows(harnessDir) {
+function activeSnapshotRows(harnessDir, hint) {
   if (!existsSync8(join5(harnessDir, STATUS_FILE)))
     return { rows: null, controlWorktreePath: undefined, unreadable: false };
-  const selection = resolveActiveWorkflow(harnessDir);
+  const selection = resolveActiveWorkflow(harnessDir, hint);
   if (selection.kind !== "active") {
     return {
       rows: null,
@@ -4825,13 +4977,13 @@ function activeSnapshotRows(harnessDir) {
   const rows = doc.plans.map((row) => asRecord(row)).filter((row) => row !== undefined);
   return { rows, controlWorktreePath, unreadable: false };
 }
-function worktreeL1Violations(harnessDir, header) {
+function worktreeL1Violations(harnessDir, header, hint) {
   if (harnessDir === null)
     return [];
   const planId = planIdOf(header);
   if (planId === undefined || planId === "")
     return [];
-  const read = activeSnapshotRows(harnessDir);
+  const read = activeSnapshotRows(harnessDir, hint);
   if (read.rows === null)
     return [];
   const controlWorktreePath = read.controlWorktreePath;
@@ -4846,10 +4998,10 @@ function worktreeL1Violations(harnessDir, header) {
   }
   return l1PreDispatchCheck({ controlWorktreePath, leaseWorktreePath, leaseWorkingBranch, planId }).violations;
 }
-function writableFanOutUncovered(harnessDir) {
+function writableFanOutUncovered(harnessDir, hint) {
   if (harnessDir === null)
     return { unreadable: false };
-  const read = activeSnapshotRows(harnessDir);
+  const read = activeSnapshotRows(harnessDir, hint);
   if (read.rows === null)
     return { unreadable: read.unreadable };
   for (const row of read.rows) {
@@ -4861,9 +5013,9 @@ function writableFanOutUncovered(harnessDir) {
   }
   return { unreadable: false };
 }
-function dispatchGateCore(config, harnessDir, prompt) {
+function dispatchGateCore(config, harnessDir, prompt, hint) {
   const header = assignmentHeaderRegion(prompt);
-  const violations = [...worktreeL2Violations(header), ...worktreeL1Violations(harnessDir, header)];
+  const violations = [...worktreeL2Violations(header), ...worktreeL1Violations(harnessDir, header, hint)];
   const writable = isReadOnlyAssignmentRole(parseAssignmentFields(header).executeAs ?? "") ? false : undefined;
   violations.push(...composeDispatchGate(header, { caller: config.dispatchBinding ?? "", callerRequired: true, writable }).violations);
   return { violations, writable };
@@ -4887,7 +5039,7 @@ function workflowGateInputOf(exec) {
   }
   return;
 }
-function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
+function gateWorkflow(ctx, harnessDir, config, adapter, exec, hintReadOf) {
   const toolName = exec.name;
   if (!DEFAULT_WORKFLOW_TOOLS.includes(toolName))
     return;
@@ -4899,7 +5051,7 @@ function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
     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);
+  const pb = writableFanOutUncovered(harnessDir, hintReadOf().hint);
   if (pb.unreadable) {
     const statusLabel = harnessDir === null ? STATUS_FILE : join5(harnessDir, STATUS_FILE);
     ctx.logger(DISPATCH_LOGGER).warn(`workflow gate (${toolName}) (fail-open): cannot read ${statusLabel} — P-b lease attribution degraded; call allowed`);
@@ -4911,6 +5063,9 @@ function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
   const recordVerdict = (v, code) => {
     if (harnessDir === null)
       return;
+    const hintRead = hintReadOf();
+    if (hintRead.kind === "unavailable")
+      return;
     adapter.recordWorkflowVerdict({
       harnessDir,
       exec,
@@ -4919,7 +5074,8 @@ function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
       ...input.objective !== undefined ? { objective: input.objective } : {},
       mode,
       verdict: v,
-      ...code !== undefined ? { code } : {}
+      ...code !== undefined ? { code } : {},
+      ...hintRead.hint !== undefined ? { hint: hintRead.hint } : {}
     });
   };
   switch (verdict.decision) {
@@ -4955,7 +5111,9 @@ function gateWorkflow(ctx, harnessDir, config, adapter, exec) {
 }
 function gateDispatch(ctx, harnessDir, config, adapter, exec) {
   const toolName = exec.name;
-  const workflowDecision = gateWorkflow(ctx, harnessDir, config, adapter, exec);
+  let derived;
+  const hintReadOf = () => derived ??= adapter.sessionHintFor(exec.agent);
+  const workflowDecision = gateWorkflow(ctx, harnessDir, config, adapter, exec, hintReadOf);
   if (workflowDecision !== undefined)
     return workflowDecision;
   if (!(config.dispatchTools ?? [...DEFAULT_DISPATCH_TOOLS]).includes(toolName))
@@ -4968,7 +5126,7 @@ function gateDispatch(ctx, harnessDir, config, adapter, exec) {
   if (!isAssignmentShaped2(header))
     return;
   const hard = resolveDispatchHard(harnessDir, config, prompt);
-  const result = adapter.dispatchGate(prompt, exec, hard);
+  const result = adapter.dispatchGate(prompt, exec, hard, hintReadOf());
   const verdict = applyEnforcement(result, { hard });
   if (verdict.hardBlocked) {
     ctx.logger(DISPATCH_LOGGER).error(`subagent dispatch (${toolName}) vetoed (Enforcement: hard):
@@ -5034,12 +5192,20 @@ function truncateLedgerField(value, cap) {
   const prefix = keep > 0 ? cps.slice(0, keep).join("") : "";
   return prefix + WORKFLOW_LEDGER_TRUNCATION_MARKER;
 }
+function normalizeRoleId(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function optionalLedgerId(value) {
+  return typeof value === "string" && value !== "" && value.length <= WORKFLOW_LEDGER_MAX_ID_LENGTH ? value : undefined;
+}
 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`;
+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.inject(['jobs']) → jobs.onJobDone pairing; only UNPAIRED payloads (non-dispatch tools, calls outside the apply-scoped pairing window) stay dispatch-only — never a fabricated settle`;
 var logSink;
 var settleNoteLogged = false;
 var noActiveWarned = false;
+var catalogCapacityWarned = false;
 var invalidator;
 function setAgentFlowInvalidator(invalidate) {
   const prior = invalidator;
@@ -5051,6 +5217,7 @@ function setAgentFlowLogger(sink) {
   logSink = sink;
   settleNoteLogged = false;
   noActiveWarned = false;
+  catalogCapacityWarned = false;
   return prior;
 }
 function log(level, message) {
@@ -5088,16 +5255,19 @@ function callPairingKey(exec) {
     return;
   return `${sessionIdOf(exec) ?? ""}\x00${callId}`;
 }
-function resolveAgentFlowWriteDir(harnessDir) {
-  const selection = resolveActiveWorkflow(harnessDir);
+function resolveAgentFlowWriteTarget(harnessDir, hint) {
+  const selection = resolveActiveWorkflow(harnessDir, hint);
   if (selection.kind === "active")
-    return join6(harnessDir, selection.dir);
+    return { dir: join6(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;
     log("warn", `agent-flow record skipped — ${message}`);
   }
-  return null;
+  return { dir: null, selection };
+}
+function resolveAgentFlowWriteDir(harnessDir, hint) {
+  return resolveAgentFlowWriteTarget(harnessDir, hint).dir;
 }
 var WORKFLOW_LEDGER_LOCKDIR = ".ledger-write.lockdir";
 var WORKFLOW_LOCKER_TIMEOUT_MS = 30000;
@@ -5171,7 +5341,7 @@ function appendEvent(workflowDir, event) {
 }
 function recordDispatch(input) {
   try {
-    const workflowDir = resolveAgentFlowWriteDir(input.harnessDir);
+    const workflowDir = resolveAgentFlowWriteDir(input.harnessDir, input.hint);
     if (workflowDir === null)
       return;
     const header = assignmentHeaderRegion(input.prompt);
@@ -5179,13 +5349,14 @@ function recordDispatch(input) {
     const planId = planIdOf(header);
     const taskId = taskIdOf(input.prompt);
     const taskCategory = fields.taskCategory;
+    const role = normalizeRoleId(fields.executeAs ?? "");
     const agent = input.exec !== undefined ? agentOfExec(input.exec) : undefined;
     const event = {
       v: 1,
       ts: Date.now(),
       kind: "dispatch",
       ...agent !== undefined ? { agent } : {},
-      role: fields.executeAs ?? "",
+      role,
       ...planId !== undefined && !isNaValue(planId) ? { planId } : {},
       ...taskId !== undefined ? { taskId } : {},
       ...taskCategory !== undefined && taskCategory.trim() !== "" ? { taskCategory } : {},
@@ -5202,14 +5373,20 @@ function recordDispatch(input) {
       if (input.pairing !== undefined && input.exec !== undefined) {
         const key = callPairingKey(input.exec);
         if (key !== undefined) {
-          input.pairing.dispatchByCallId.set(key, {
+          const ref = {
             harnessDir: input.harnessDir,
             workflowDir,
             ...agent !== undefined ? { agent } : {},
-            role: fields.executeAs ?? "",
+            role,
             ...planId !== undefined && !isNaValue(planId) ? { planId } : {},
             ...taskId !== undefined ? { taskId } : {}
-          });
+          };
+          input.pairing.dispatchByCallId.set(key, ref);
+          try {
+            reserveCatalogCandidate(input.pairing, ref, input.exec);
+          } catch (error) {
+            log("error", `catalog candidate reservation failed (contained — the dispatch record and pairing stand): ${errorMessage(error)}`);
+          }
         }
       }
     } catch (error) {
@@ -5221,9 +5398,11 @@ function recordDispatch(input) {
 }
 function recordSettle(input) {
   try {
-    const workflowDir = input.workflowDir ?? resolveAgentFlowWriteDir(input.harnessDir);
+    const workflowDir = input.workflowDir ?? resolveAgentFlowWriteDir(input.harnessDir, input.hint);
     if (workflowDir === null)
       return;
+    const childId = optionalLedgerId(input.childId);
+    const taskRef = optionalLedgerId(input.taskRef);
     const event = {
       v: 1,
       ts: Date.now(),
@@ -5231,9 +5410,11 @@ function recordSettle(input) {
       ...input.agent !== undefined && input.agent.trim() !== "" ? { agent: input.agent } : {},
       outcome: input.outcome,
       ...input.durationMs !== undefined && Number.isFinite(input.durationMs) ? { durationMs: input.durationMs } : {},
-      ...input.role !== undefined ? { role: input.role } : {},
+      ...input.role !== undefined ? { role: normalizeRoleId(input.role) } : {},
       ...input.planId !== undefined && input.planId !== "" ? { planId: input.planId } : {},
-      ...input.taskId !== undefined && input.taskId !== "" ? { taskId: input.taskId } : {}
+      ...input.taskId !== undefined && input.taskId !== "" ? { taskId: input.taskId } : {},
+      ...childId !== undefined ? { childId } : {},
+      ...taskRef !== undefined ? { taskRef } : {}
     };
     appendEvent(workflowDir, event);
     try {
@@ -5247,7 +5428,7 @@ function recordSettle(input) {
 }
 function recordWorkflowEvent(input) {
   try {
-    const workflowDir = input.workflowDir ?? resolveAgentFlowWriteDir(input.harnessDir);
+    const workflowDir = input.workflowDir ?? resolveAgentFlowWriteDir(input.harnessDir, input.hint);
     if (workflowDir === null)
       return false;
     appendEvent(workflowDir, input.event);
@@ -5264,7 +5445,7 @@ function recordWorkflowEvent(input) {
 }
 function recordWorkflowVerdict(input) {
   try {
-    const workflowDir = resolveAgentFlowWriteDir(input.harnessDir);
+    const workflowDir = resolveAgentFlowWriteDir(input.harnessDir, input.hint);
     if (workflowDir === null)
       return;
     const agent = input.exec !== undefined ? agentOfExec(input.exec) : undefined;
@@ -5295,7 +5476,7 @@ function eventFromUnknown(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" && kind !== "workflow-verdict" && kind !== "workflow-run" && kind !== "workflow-agent" && kind !== "workflow-run-end") {
+  if (kind !== "dispatch" && kind !== "settle" && kind !== "subagent-link" && 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;
@@ -5322,6 +5503,8 @@ function eventFromUnknown(value) {
     const outcome = rec.outcome;
     if (outcome !== "ok" && outcome !== "error" && outcome !== "denied")
       return;
+    const childId = optionalLedgerId(rec.childId);
+    const taskRef = optionalLedgerId(rec.taskRef);
     return {
       v: 1,
       ts: rec.ts,
@@ -5331,7 +5514,31 @@ function eventFromUnknown(value) {
       ...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 } : {}
+      ...typeof rec.taskId === "string" && rec.taskId !== "" ? { taskId: rec.taskId } : {},
+      ...childId !== undefined ? { childId } : {},
+      ...taskRef !== undefined ? { taskRef } : {}
+    };
+  }
+  if (kind === "subagent-link") {
+    const childId = optionalLedgerId(rec.childId);
+    if (childId === undefined)
+      return;
+    if (typeof rec.role !== "string")
+      return;
+    if (typeof rec.label !== "string" || rec.label === "")
+      return;
+    const taskRef = optionalLedgerId(rec.taskRef);
+    return {
+      v: 1,
+      ts: rec.ts,
+      kind: "subagent-link",
+      ...agent !== undefined ? { agent } : {},
+      childId,
+      label: truncateLedgerField(normalizeWorkflowName(rec.label), WORKFLOW_LEDGER_MAX_LABEL_LENGTH),
+      role: rec.role,
+      ...typeof rec.planId === "string" && rec.planId !== "" ? { planId: rec.planId } : {},
+      ...typeof rec.taskId === "string" && rec.taskId !== "" ? { taskId: rec.taskId } : {},
+      ...taskRef !== undefined ? { taskRef } : {}
     };
   }
   if (kind === "workflow-verdict") {
@@ -5479,6 +5686,20 @@ function eventView(event) {
       ...event.code !== undefined ? { code: event.code } : {}
     };
   }
+  if (event.kind === "subagent-link") {
+    return {
+      ts: event.ts,
+      kind: "subagent-link",
+      agent: event.agent ?? null,
+      role: event.role,
+      planId: event.planId ?? null,
+      taskId: event.taskId ?? null,
+      taskCategory: null,
+      label: event.label,
+      childId: event.childId,
+      ...event.taskRef !== undefined ? { taskRef: event.taskRef } : {}
+    };
+  }
   return {
     ts: event.ts,
     kind: "settle",
@@ -5489,13 +5710,15 @@ function eventView(event) {
     taskCategory: null,
     ...event.role !== undefined ? { paired: true } : {},
     ...event.outcome !== undefined ? { outcome: event.outcome } : {},
-    ...event.durationMs !== undefined ? { durationMs: event.durationMs } : {}
+    ...event.durationMs !== undefined ? { durationMs: event.durationMs } : {},
+    ...event.childId !== undefined ? { childId: event.childId } : {},
+    ...event.taskRef !== undefined ? { taskRef: event.taskRef } : {}
   };
 }
 function summaryOf(events) {
   const counts = new Map;
   for (const event of events) {
-    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 role = event.kind === "dispatch" || event.kind === "subagent-link" ? 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);
@@ -5570,7 +5793,8 @@ function readAgentFlow(workflowDir, limit) {
     summary: summaryOf(latestFirst)
   };
 }
-function recordSettleWithRef(ref, outcome, durationMs) {
+function recordSettleWithRef(ref, outcome, durationMs, childId) {
+  const settleChildId = childId ?? ref.childId;
   recordSettle({
     harnessDir: ref.harnessDir,
     workflowDir: ref.workflowDir,
@@ -5579,7 +5803,9 @@ function recordSettleWithRef(ref, outcome, durationMs) {
     ...durationMs !== undefined && Number.isFinite(durationMs) ? { durationMs } : {},
     role: ref.role,
     ...ref.planId !== undefined ? { planId: ref.planId } : {},
-    ...ref.taskId !== undefined ? { taskId: ref.taskId } : {}
+    ...ref.taskId !== undefined ? { taskId: ref.taskId } : {},
+    ...settleChildId !== undefined ? { childId: settleChildId } : {},
+    ...ref.taskRef !== undefined ? { taskRef: ref.taskRef } : {}
   });
 }
 function registerSettleListener(ctx, config, pairing) {
@@ -5600,18 +5826,34 @@ function registerSettleListener(ctx, config, pairing) {
         } else {
           const resultRec = asRecord(result);
           if (resultRec !== undefined) {
+            const value = asRecord(resultRec.value);
+            const childId = value !== undefined && value.kind === "foreground" && typeof value.runId === "string" ? value.runId : undefined;
             if (resultRec.isError === true || resultRec.error !== undefined) {
-              recordSettleWithRef(dispatchRef, "error", undefined);
-            } else {
-              const value = asRecord(resultRec.value);
-              if (value !== undefined && value.kind === "background") {
-                if (typeof value.taskId === "string" && value.taskId !== "") {
-                  pairing.dispatchByTaskId.set(value.taskId, dispatchRef);
-                }
-              } else if (value !== undefined && value.kind === "continuable") {} else {
-                recordSettleWithRef(dispatchRef, "ok", undefined);
+              retireCatalogCandidate(pairing, dispatchRef);
+              recordSettleWithRef(dispatchRef, "error", undefined, childId);
+            } else if (value !== undefined && value.kind === "background") {
+              if (typeof value.jobId === "string" && value.jobId !== "") {
+                pairing.dispatchByJobId.set(value.jobId, dispatchRef);
+                const taskRef = optionalLedgerId(value.jobId);
+                if (taskRef !== undefined)
+                  dispatchRef.taskRef = taskRef;
+                advanceCatalogCandidate(pairing, dispatchRef, { kind: "background", jobId: value.jobId });
+              } else {
+                retireCatalogCandidate(pairing, dispatchRef);
+              }
+            } else if (value !== undefined && value.kind === "continuable") {
+              const subagentId = optionalLedgerId(value.subagentId);
+              if (subagentId !== undefined) {
+                advanceCatalogCandidate(pairing, dispatchRef, { kind: "continuable", subagentId });
+              } else {
+                retireCatalogCandidate(pairing, dispatchRef);
               }
+            } else {
+              retireCatalogCandidate(pairing, dispatchRef);
+              recordSettleWithRef(dispatchRef, "ok", undefined, childId);
             }
+          } else {
+            retireCatalogCandidate(pairing, dispatchRef);
           }
         }
         if (key !== undefined)
@@ -5628,9 +5870,9 @@ function registerSettleListener(ctx, config, pairing) {
     log("info", SETTLE_SEAM_PAIRING_NOTE);
   }
 }
-function recordTaskSettle(snapshot, pairing) {
+function recordJobSettle(snapshot, pairing) {
   try {
-    const dispatchRef = pairing.dispatchByTaskId.get(snapshot.id);
+    const dispatchRef = pairing.dispatchByJobId.get(snapshot.id);
     if (dispatchRef === undefined)
       return;
     let outcome;
@@ -5644,14 +5886,208 @@ function recordTaskSettle(snapshot, pairing) {
       return;
     const durationMs = typeof snapshot.startedAt === "number" && typeof snapshot.finishedAt === "number" ? snapshot.finishedAt - snapshot.startedAt : undefined;
     recordSettleWithRef(dispatchRef, outcome, durationMs);
-    pairing.dispatchByTaskId.delete(snapshot.id);
+    pairing.dispatchByJobId.delete(snapshot.id);
   } catch (error) {
     log("error", `settle record failed (contained): ${errorMessage(error)}`);
   }
 }
+function reserveCatalogCandidate(pairing, ref, exec) {
+  const session = asRecord(asRecord(exec)?.agent)?.session;
+  if (typeof session !== "object" || session === null)
+    return;
+  const view = asRecord(session);
+  if (view === undefined)
+    return;
+  if (typeof view.id !== "string" || view.id === "")
+    return;
+  const seq = view.seq;
+  if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0 || seq >= WORKFLOW_LEDGER_MAX_SEQ)
+    return;
+  if (typeof view.eventAt !== "function")
+    return;
+  const label = asRecord(asRecord(exec)?.arguments)?.description;
+  if (typeof label !== "string" || label === "")
+    return;
+  if (normalizeWorkflowName(label) === "")
+    return;
+  if (label.length > WORKFLOW_LEDGER_MAX_NAME_LENGTH)
+    return;
+  let map = pairing.catalogBySession.get(session);
+  if (map === undefined) {
+    map = new Map;
+    pairing.catalogBySession.set(session, map);
+  }
+  if (map.has(label))
+    return;
+  if (map.size >= AGENT_FLOW_MAX_EVENTS) {
+    if (!catalogCapacityWarned) {
+      catalogCapacityWarned = true;
+      log("warn", `catalog slot capacity reached on parent session ${view.id} (${String(AGENT_FLOW_MAX_EVENTS)} slots) — new delegation labels admit no call-window candidate, so no child identity is linked for the rest of this session (existing entries retained; honest degrade)`);
+    }
+    return;
+  }
+  map.set(label, { ref, fromSeq: seq });
+  ref.catalog = { session, label };
+}
+function matchCatalogEvent(session, label, join8, envelope) {
+  const result = join8.result;
+  if (result === undefined)
+    return;
+  const rec = asRecord(envelope);
+  if (rec === undefined || rec.type !== "subagent/catalog")
+    return;
+  const data = asRecord(rec.data);
+  if (data === undefined || data.version !== 0)
+    return;
+  if (typeof rec.time !== "number" || !Number.isFinite(rec.time))
+    return;
+  const seq = rec.seq;
+  if (typeof seq !== "number" || !Number.isInteger(seq))
+    return;
+  if (seq < join8.fromSeq || seq >= session.seq || seq >= WORKFLOW_LEDGER_MAX_SEQ)
+    return;
+  const childCreatedAt = data.childCreatedAt;
+  if (typeof childCreatedAt !== "number" || !Number.isInteger(childCreatedAt) || childCreatedAt < 0)
+    return;
+  const childId = data.childId;
+  if (typeof childId !== "string" || childId === "" || childId.length > WORKFLOW_LEDGER_MAX_ID_LENGTH)
+    return;
+  if (data.label !== label)
+    return;
+  if (data.mode !== (result.kind === "background" ? "one-shot" : "continuable"))
+    return;
+  if (result.kind === "continuable" && result.subagentId !== childId)
+    return;
+  return childId;
+}
+function consumeCatalogCandidate(map, label, join8, childId) {
+  map.set(label, null);
+  const ref = join8.ref;
+  ref.childId = childId;
+  delete ref.catalog;
+  recordSubagentLink({ ref, childId, label });
+}
+function advanceCatalogCandidate(pairing, ref, result) {
+  try {
+    const catalog = ref.catalog;
+    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)
+      return;
+    join8.result = result;
+    const end = catalog.session.seq;
+    let skippedReads = 0;
+    let firstSkippedSeq;
+    let firstSkippedError;
+    try {
+      for (let seq = join8.fromSeq;seq < end; seq += 1) {
+        let envelope;
+        try {
+          envelope = catalog.session.eventAt(seq);
+        } catch (error) {
+          skippedReads += 1;
+          if (firstSkippedSeq === undefined) {
+            firstSkippedSeq = seq;
+            firstSkippedError = errorMessage(error);
+          }
+          continue;
+        }
+        const childId = matchCatalogEvent(catalog.session, catalog.label, join8, envelope);
+        if (childId === undefined)
+          continue;
+        consumeCatalogCandidate(map, catalog.label, join8, childId);
+        return;
+      }
+    } finally {
+      if (skippedReads > 0) {
+        log("warn", `catalog catch-up skipped ${String(skippedReads)} unreadable position(s) in parent session ${catalog.session.id} starting at seq ${String(firstSkippedSeq)} (contained — the window walk continues): ${firstSkippedError ?? "unknown"}`);
+      }
+    }
+  } catch (error) {
+    log("warn", `catalog candidate advance failed (contained — the result branch proceeds): ${errorMessage(error)}`);
+  }
+}
+function retireCatalogCandidate(pairing, ref) {
+  try {
+    const catalog = ref.catalog;
+    if (catalog === undefined)
+      return;
+    delete ref.catalog;
+    const map = pairing.catalogBySession.get(catalog.session);
+    const slot = map?.get(catalog.label);
+    if (map !== undefined && slot !== undefined && slot !== null && slot.ref === ref)
+      map.set(catalog.label, null);
+  } catch (error) {
+    log("warn", `catalog candidate retire failed (contained — the result branch proceeds): ${errorMessage(error)}`);
+  }
+}
+function recordSubagentLink(input) {
+  try {
+    const childId = optionalLedgerId(input.childId);
+    if (childId === undefined) {
+      log("warn", "subagent-link row skipped — the observed catalog child id is missing, empty, or oversized (never truncated, never fabricated)");
+      return;
+    }
+    const label = truncateLedgerField(normalizeWorkflowName(input.label), WORKFLOW_LEDGER_MAX_LABEL_LENGTH);
+    if (label === "") {
+      log("warn", "subagent-link row skipped — the matched delegation label carries no displayable text");
+      return;
+    }
+    const ref = input.ref;
+    if (typeof ref.role !== "string") {
+      log("warn", "subagent-link row skipped — the dispatch ref carries no role identity");
+      return;
+    }
+    const role = normalizeRoleId(ref.role);
+    const taskRef = optionalLedgerId(ref.taskRef);
+    const event = {
+      v: 1,
+      ts: Date.now(),
+      kind: "subagent-link",
+      ...ref.agent !== undefined && ref.agent.trim() !== "" ? { agent: ref.agent } : {},
+      childId,
+      label,
+      role,
+      ...ref.planId !== undefined && ref.planId !== "" ? { planId: ref.planId } : {},
+      ...ref.taskId !== undefined && ref.taskId !== "" ? { taskId: ref.taskId } : {},
+      ...taskRef !== undefined ? { taskRef } : {}
+    };
+    appendEvent(ref.workflowDir, event);
+    try {
+      invalidator?.(ref.harnessDir);
+    } catch (error) {
+      log("error", `catalog invalidation failed (contained): ${errorMessage(error)}`);
+    }
+  } catch (error) {
+    log("error", `subagent-link record failed (contained): ${errorMessage(error)}`);
+  }
+}
+function registerSubagentCatalogListener(ctx, pairing) {
+  ctx.events.on("session/event", (session, envelope) => {
+    try {
+      if (typeof session !== "object" || session === null)
+        return;
+      const map = pairing.catalogBySession.get(session);
+      if (map === undefined)
+        return;
+      for (const [label, join8] of map) {
+        if (join8 === null || join8.result === undefined)
+          continue;
+        const childId = matchCatalogEvent(session, label, join8, envelope);
+        if (childId === undefined)
+          continue;
+        consumeCatalogCandidate(map, label, join8, childId);
+      }
+    } catch (error) {
+      log("warn", `subagent catalog observation failed (contained — the session append proceeds): ${errorMessage(error)}`);
+    }
+  });
+}
 
 // src/engine-status-store.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, renameSync as renameSync3, rmSync, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname9, join as join8 } from "node:path";
 var ENGINE_STATUS_SNAPSHOT_VERSION = 1;
 var ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION = 1;
@@ -5687,6 +6123,25 @@ function asEntry(value) {
     return;
   return { rv: value.rv, cwd, at, turn: value.turn, payload: value.payload };
 }
+function asBinding(value) {
+  if (!isPlainObject6(value))
+    return;
+  const cwd = nonEmptyString(value.cwd);
+  if (cwd === undefined)
+    return;
+  const seq = value.excludedBeforeSeq;
+  if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 0)
+    return;
+  const selectedRaw = value.selectedWorkflowId;
+  const selected = nonEmptyString(selectedRaw);
+  if (selectedRaw !== undefined && selected === undefined)
+    return;
+  return {
+    cwd,
+    ...selected === undefined ? {} : { selectedWorkflowId: selected },
+    excludedBeforeSeq: seq
+  };
+}
 function entryAge(at, nowMs) {
   const parsed = Date.parse(at);
   if (!Number.isFinite(parsed))
@@ -5730,13 +6185,23 @@ function readEngineStatusSnapshot(harnessDir, sessionId) {
 function sessionMap() {
   return Object.create(null);
 }
+function bindingMap() {
+  return Object.create(null);
+}
+function serializeEnvelope(entries, bindings) {
+  const base = { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries };
+  return Object.keys(bindings).length === 0 ? JSON.stringify(base) : JSON.stringify({ ...base, bindings });
+}
 function loadForWrite(harnessDir) {
   let raw;
   try {
     raw = readFileSync8(engineStatusSnapshotPath(harnessDir), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
-      return { kind: "ok", doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries: sessionMap() } };
+      return {
+        kind: "ok",
+        doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries: sessionMap(), bindings: bindingMap() }
+      };
     }
     return { kind: "refused", reason: "store-unreadable" };
   }
@@ -5763,7 +6228,18 @@ function loadForWrite(harnessDir) {
     if (kept.length > 0)
       entries[key] = kept;
   }
-  return { kind: "ok", doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries } };
+  const bindings = bindingMap();
+  if (parsed.bindings !== undefined) {
+    if (!isPlainObject6(parsed.bindings))
+      return { kind: "refused", reason: "store-bindings-schema" };
+    for (const [key, value] of Object.entries(parsed.bindings)) {
+      const binding = asBinding(value);
+      if (binding === undefined)
+        return { kind: "refused", reason: "store-bindings-schema" };
+      bindings[key] = binding;
+    }
+  }
+  return { kind: "ok", doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries, bindings } };
 }
 function pruneBucket(bucket, nowMs) {
   const fresh = [];
@@ -5842,7 +6318,7 @@ function writeEngineStatusSnapshot(harnessDir, input) {
         pruned[key] = kept;
       }
       const maxBytes = input.maxBytes ?? ENGINE_STATUS_SNAPSHOT_MAX_BYTES;
-      const serialized = (entries) => JSON.stringify({ sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries });
+      const serialized = (entries) => serializeEnvelope(entries, doc.bindings);
       const evicted = enforceGlobalBound(pruned, input.sessionId, maxBytes, (entries) => Buffer.byteLength(serialized(entries), "utf8"));
       const payload = serialized(pruned);
       const oversized = Buffer.byteLength(payload, "utf8") > maxBytes;
@@ -5851,6 +6327,7 @@ function writeEngineStatusSnapshot(harnessDir, input) {
         total += kept.length;
       writeFileSync5(tmp, payload);
       renameSync3(tmp, file);
+      bindingStoreMemos.delete(file);
       let warn;
       if (oversized && !oversizeWarned.has(file)) {
         oversizeWarned.add(file);
@@ -5871,11 +6348,125 @@ function writeEngineStatusSnapshot(harnessDir, input) {
     return { kind: "degraded", reason: error?.message ?? "write-failed" };
   }
 }
+var BINDING_STORE_MEMO_CAP = 16;
+var bindingStoreMemos = new Map;
+function parseBindingStore(file) {
+  let raw;
+  try {
+    raw = readFileSync8(file, "utf8");
+  } catch {
+    return { kind: "unavailable", reason: "store-unreadable" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { kind: "unavailable", reason: "store-invalid-json" };
+  }
+  if (!isPlainObject6(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject6(parsed.entries)) {
+    return { kind: "unavailable", reason: "store-envelope-schema" };
+  }
+  const bindings = parsed.bindings;
+  if (bindings === undefined)
+    return { kind: "ok", bindings: undefined };
+  if (!isPlainObject6(bindings))
+    return { kind: "unavailable", reason: "store-bindings-schema" };
+  return { kind: "ok", bindings };
+}
+function readBindingStoreSnapshot(file) {
+  let stat;
+  try {
+    stat = statSync7(file);
+  } catch (error) {
+    return error.code === "ENOENT" ? { kind: "ok", bindings: undefined } : { kind: "unavailable", reason: "store-unreadable" };
+  }
+  const memo = bindingStoreMemos.get(file);
+  if (memo !== undefined && memo.ino === stat.ino && memo.size === stat.size && memo.mtimeMs === stat.mtimeMs) {
+    return memo.snapshot;
+  }
+  const snapshot = parseBindingStore(file);
+  if (bindingStoreMemos.size >= BINDING_STORE_MEMO_CAP) {
+    const oldest = bindingStoreMemos.keys().next();
+    if (!oldest.done)
+      bindingStoreMemos.delete(oldest.value);
+  }
+  bindingStoreMemos.set(file, { ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs, snapshot });
+  return snapshot;
+}
+function readWorkflowSessionBinding(harnessDir, sessionId, cwd) {
+  if (harnessDir === "")
+    return { kind: "unavailable", reason: "no-harness-dir" };
+  if (sessionId === "")
+    return { kind: "unavailable", reason: "no-session-id" };
+  if (cwd === "")
+    return { kind: "unavailable", reason: "no-session-cwd" };
+  const snapshot = readBindingStoreSnapshot(engineStatusSnapshotPath(harnessDir));
+  if (snapshot.kind === "unavailable")
+    return { kind: "unavailable", reason: snapshot.reason };
+  const bindings = snapshot.bindings;
+  if (bindings === undefined || !Object.hasOwn(bindings, sessionId))
+    return { kind: "ok" };
+  const binding = asBinding(bindings[sessionId]);
+  if (binding === undefined)
+    return { kind: "unavailable", reason: "store-bindings-schema" };
+  if (binding.cwd !== cwd)
+    return { kind: "unavailable", reason: "cwd-mismatch" };
+  return { kind: "ok", binding };
+}
+function updateWorkflowSessionBinding(harnessDir, sessionId, cwd, update) {
+  if (harnessDir === "")
+    return { kind: "degraded", reason: "no-harness-dir" };
+  if (sessionId === "")
+    return { kind: "degraded", reason: "no-session-id" };
+  if (cwd === "")
+    return { kind: "degraded", reason: "no-session-cwd" };
+  if (!Number.isInteger(update.excludedBeforeSeq) || update.excludedBeforeSeq < 0) {
+    return { kind: "degraded", reason: "invalid-excluded-before-seq" };
+  }
+  if (update.selectedWorkflowId !== undefined && update.selectedWorkflowId === "") {
+    return { kind: "degraded", reason: "invalid-selected-workflow-id" };
+  }
+  const file = engineStatusSnapshotPath(harnessDir);
+  const dir = dirname9(file);
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
+  try {
+    mkdirSync3(dir, { recursive: true });
+    return withWorkflowDirLock(dir, () => {
+      const loaded = loadForWrite(harnessDir);
+      if (loaded.kind === "refused")
+        return { kind: "degraded", reason: loaded.reason };
+      const doc = loaded.doc;
+      const existing = Object.hasOwn(doc.bindings, sessionId) ? doc.bindings[sessionId] : undefined;
+      if (existing !== undefined && existing.cwd !== cwd) {
+        return { kind: "degraded", reason: "cwd-mismatch" };
+      }
+      const selected = update.selectedWorkflowId ?? existing?.selectedWorkflowId;
+      doc.bindings[sessionId] = {
+        cwd,
+        ...selected === undefined ? {} : { selectedWorkflowId: selected },
+        excludedBeforeSeq: Math.max(existing?.excludedBeforeSeq ?? 0, update.excludedBeforeSeq)
+      };
+      const payload = serializeEnvelope(doc.entries, doc.bindings);
+      const maxBytes = update.maxBytes ?? ENGINE_STATUS_SNAPSHOT_MAX_BYTES;
+      if (Buffer.byteLength(payload, "utf8") > maxBytes) {
+        return { kind: "degraded", reason: "store-over-byte-ceiling" };
+      }
+      writeFileSync5(tmp, payload);
+      renameSync3(tmp, file);
+      bindingStoreMemos.delete(file);
+      return { kind: "written" };
+    }, { timeoutMs: ENGINE_STATUS_SNAPSHOT_LOCK_TIMEOUT_MS });
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {}
+    return { kind: "degraded", reason: error?.message ?? "write-failed" };
+  }
+}
 
 // src/gates/catalog.ts
 var CATALOG_LOGGER = "mstar/engine-status-catalog";
 var DEFAULT_CATALOG_TTL_MS = 60000;
-var EXPLICIT_CACHE_KEY = "\x00explicit";
 var RESIDUAL_SEVERITIES = ["critical", "high", "medium", "low", "nit"];
 function isOpenResidualParity(entry) {
   const lifecycle = entry.lifecycle;
@@ -5898,48 +6489,86 @@ function pluginVersion() {
 function engineStatusSource() {
   return { kind: "plugin", plugin: "mstar-engine", form: "catalog" };
 }
-function engineStatusPayload(harnessDir) {
-  const iteration = harnessDir !== null ? iterationGateSource(harnessDir) : undefined;
+function engineStatusPayload(harnessDir, hint) {
+  const selection = harnessDir !== null ? resolveReadWorkflow(harnessDir, hint) : undefined;
+  const iteration = harnessDir !== null ? iterationGateSource(harnessDir, selection) : undefined;
   return {
     version: pluginVersion(),
     harnessDir,
     enforcement: harnessDir !== null ? resolveRepoEnforcement(harnessDir) : { hard: false, source: "none" },
     ...iteration !== undefined ? { iteration } : {},
-    state: harnessDir !== null ? harnessStateSource(harnessDir) : null
+    state: harnessDir !== null && selection !== undefined ? harnessStateSource(harnessDir, selection) : null
   };
 }
-function createCatalogInvalidation(cache) {
-  const keyByHarnessDir = new Map;
+function createCatalogInvalidation(cache, digests) {
+  const keysByHarnessDir = new Map;
+  const sessionsOf = (harnessDir) => {
+    let sessions = keysByHarnessDir.get(harnessDir);
+    if (sessions === undefined) {
+      sessions = new Map;
+      keysByHarnessDir.set(harnessDir, sessions);
+    }
+    return sessions;
+  };
   return {
-    register(harnessDir, key) {
-      if (harnessDir === null)
+    register(harnessDir, sessionId, key) {
+      if (harnessDir === null || sessionId === undefined)
         return;
-      keyByHarnessDir.set(harnessDir, key);
+      const sessions = sessionsOf(harnessDir);
+      const previous = sessions.get(sessionId);
+      if (previous !== undefined && previous !== key)
+        cache.delete(previous);
+      sessions.set(sessionId, key);
     },
     invalidate(harnessDir) {
-      const key = keyByHarnessDir.get(harnessDir);
-      if (key === undefined)
+      const sessions = keysByHarnessDir.get(harnessDir);
+      if (sessions === undefined)
+        return;
+      for (const key of sessions.values())
+        cache.delete(key);
+    },
+    invalidateSession(harnessDir, sessionId) {
+      if (harnessDir === null || sessionId === undefined)
         return;
-      cache.delete(key);
+      const key = keysByHarnessDir.get(harnessDir)?.get(sessionId);
+      if (key !== undefined)
+        cache.delete(key);
+      const prefix = `[${JSON.stringify(sessionId)},`;
+      for (const digestKey of [...digests.keys()]) {
+        if (digestKey.startsWith(prefix))
+          digests.delete(digestKey);
+      }
     }
   };
 }
-function buildCatalogPayload(ctx, harnessDir) {
-  const payload = engineStatusPayload(harnessDir);
+function catalogCacheKey(harnessDir, sessionId, cwd, hint) {
+  return JSON.stringify([
+    harnessDir ?? "",
+    sessionId,
+    cwd,
+    hint?.leaseHolder ?? "",
+    hint?.selectedWorkflowId ?? ""
+  ]);
+}
+function buildCatalogPayload(ctx, harnessDir, hint) {
+  const payload = engineStatusPayload(harnessDir, hint);
   if (payload.version === "0.0.0") {
     ctx.logger(CATALOG_LOGGER).warn("plugin manifest version unavailable — falling back to 0.0.0 for the engine-status catalog watermark");
   }
   return payload;
 }
-function catalogPayloadFor(ctx, cache, register, key, harnessDir, ttlMs) {
+function catalogPayloadFor(ctx, cache, invalidation, harnessDir, sessionId, cwd, hint, ttlMs) {
+  if (sessionId === undefined)
+    return buildCatalogPayload(ctx, harnessDir, hint);
+  const key = catalogCacheKey(harnessDir, sessionId, cwd, hint);
   const entry = cache.get(key);
   if (entry !== undefined && Date.now() - entry.builtAt < ttlMs) {
-    register(harnessDir, key);
+    invalidation.register(harnessDir, sessionId, key);
     return entry.payload;
   }
-  const payload = buildCatalogPayload(ctx, harnessDir);
+  const payload = buildCatalogPayload(ctx, harnessDir, hint);
   cache.set(key, { payload, builtAt: Date.now() });
-  register(harnessDir, key);
+  invalidation.register(harnessDir, sessionId, key);
   return payload;
 }
 function renderEngineStatusCatalog(source) {
@@ -6000,7 +6629,7 @@ function renderEngineStatusCatalog(source) {
 function renderAgentFlowLine(flow) {
   const byRole = new Map;
   for (const row of flow.summary) {
-    if (row.role === "")
+    if (row.role === "" || row.outcome === "subagent-link")
       continue;
     byRole.set(row.role, (byRole.get(row.role) ?? 0) + row.count);
   }
@@ -6015,28 +6644,16 @@ function hhmm(ts) {
   const date = new Date(ts);
   return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
 }
-function harnessStateSource(harnessDir) {
-  if (harnessDir === null)
-    return null;
+function harnessStateSource(harnessDir, selection) {
   const statusPath = join12(harnessDir, STATUS_FILE);
   if (!existsSync14(statusPath))
     return null;
   try {
-    const selection = resolveReadWorkflow(harnessDir);
     const rollup = residualRollup(harnessDir);
     const str = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : null;
     const iterationRefsOf = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.trim() !== "") : [];
-    const compass = steeringCompassPath(harnessDir);
-    let compassFields;
-    if (compass !== undefined) {
-      try {
-        compassFields = parseCompassFrontmatter(compass.compassPath);
-      } catch {
-        compassFields = undefined;
-      }
-    }
     if (selection.kind === "error") {
-      return selectionErrorState(selection, rollup, harnessDir, compass);
+      return selectionErrorState(selection, rollup, harnessDir);
     }
     const snapshotPath = join12(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
     let snapshot;
@@ -6045,7 +6662,7 @@ function harnessStateSource(harnessDir) {
         kind: "error",
         code: "workflow.selection.snapshot-unreadable",
         message: `cannot read the selected workflow snapshot ${snapshotPath}`
-      }, rollup, harnessDir, compass);
+      }, rollup, harnessDir);
     }
     try {
       snapshot = readJson(snapshotPath);
@@ -6054,8 +6671,10 @@ function harnessStateSource(harnessDir) {
         kind: "error",
         code: "workflow.selection.snapshot-unreadable",
         message: `cannot read the selected workflow snapshot ${snapshotPath}`
-      }, rollup, harnessDir, compass);
+      }, rollup, harnessDir);
     }
+    const compass = selectedCompass(harnessDir, selection.workflowId, snapshot);
+    const compassFields = compass?.doc;
     const plans = [];
     const leases = [];
     if (Array.isArray(snapshot.plans)) {
@@ -6108,7 +6727,7 @@ function harnessStateSource(harnessDir) {
     return null;
   }
 }
-function selectionErrorState(selection, rollup, harnessDir, compass) {
+function selectionErrorState(selection, rollup, harnessDir) {
   return {
     selection,
     workflowType: null,
@@ -6125,7 +6744,7 @@ function selectionErrorState(selection, rollup, harnessDir, compass) {
     controlWorktreePath: null,
     leases: [],
     knowledge: knowledgeDigest(harnessDir),
-    direction: compass !== undefined ? compassDirection(compass.compassPath) : null,
+    direction: null,
     agentFlow: null
   };
 }
@@ -6273,55 +6892,59 @@ function compassDirection(compassPath) {
       return null;
     return cleaned.length > 160 ? `${cleaned.slice(0, 157)}…` : cleaned;
   } catch {
-    return null;
+    return null;
+  }
+}
+function selectedCompass(harnessDir, workflowId, snapshot) {
+  const ref = snapshot.compass_ref;
+  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute7(ref))
+    return;
+  const compassPath = join12(harnessDir, ref);
+  if (!pathInside(harnessDir, compassPath))
+    return;
+  if (basename5(compassPath) !== "delivery-compass.md")
+    return;
+  if (!existsSync14(compassPath))
+    return;
+  let resolvedHarness;
+  let resolvedCompass;
+  try {
+    resolvedHarness = realpathSync7(harnessDir);
+    resolvedCompass = realpathSync7(compassPath);
+  } catch {
+    return;
   }
-}
-function steeringCompassPath(harnessDir) {
-  const iterationsDir = resolveIterationDir(harnessDir);
-  if (!existsSync14(iterationsDir))
+  if (!pathInside(resolvedHarness, resolvedCompass))
     return;
-  let entries;
+  let doc;
   try {
-    entries = readdirSync4(iterationsDir, { withFileTypes: true });
+    doc = parseCompassFrontmatter(compassPath);
   } catch {
     return;
   }
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const compassPath = join12(iterationsDir, entry.name, "delivery-compass.md");
-    if (!existsSync14(compassPath))
-      continue;
-    let content;
-    try {
-      content = readFileSync11(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, compassPath };
-  }
-  return;
+  if (doc.status !== "active" && doc.status !== "locked")
+    return;
+  if (doc.iteration_id !== workflowId)
+    return;
+  return { iterationId: workflowId, compassPath, doc };
 }
-function iterationGateSource(harnessDir) {
-  if (harnessDir === null)
+function pathInside(root, candidate) {
+  const rel = relative7(root, candidate);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute7(rel);
+}
+function iterationGateSource(harnessDir, selection) {
+  if (harnessDir === null || selection === undefined || selection.kind === "error")
     return;
   const statusPath = join12(harnessDir, STATUS_FILE);
   if (!existsSync14(statusPath))
     return;
-  const compass = steeringCompassPath(harnessDir);
-  if (compass === undefined)
-    return;
-  const selection = resolveReadWorkflow(harnessDir);
-  if (selection.kind === "error")
-    return;
   const snapshotPath = join12(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
   try {
     const snapshotDoc = readJson(snapshotPath);
-    const compassDoc = parseCompassFrontmatter(compass.compassPath);
-    const result = evaluatePhaseGate(snapshotDoc, compassDoc);
+    const compass = selectedCompass(harnessDir, selection.workflowId, snapshotDoc);
+    if (compass === undefined)
+      return;
+    const result = evaluatePhaseGate(snapshotDoc, compass.doc);
     const gate2 = {
       transition: result.transition,
       all_plans_done: result.allPlansDone,
@@ -6330,7 +6953,7 @@ function iterationGateSource(harnessDir) {
       exit: iterationGateView(result.exit),
       violations: result.violations.map(iterationViolationView)
     };
-    const compassStatus = compassDoc.status === "active" || compassDoc.status === "locked" ? compassDoc.status : undefined;
+    const compassStatus = compass.doc.status === "active" || compass.doc.status === "locked" ? compass.doc.status : undefined;
     return {
       iterationId: compass.iterationId,
       statusPath: snapshotPath,
@@ -6342,15 +6965,16 @@ function iterationGateSource(harnessDir) {
     return;
   }
 }
-async function preStepCatalogListener(ctx, resolver, explicitKey, cache, ttlMs, register, digests, payload, next) {
+async function preStepCatalogListener(ctx, resolver, cache, ttlMs, invalidation, digests, payload, next) {
   const decision = await next();
   if (decision.kind === "reject" || payload.signal.aborted)
     return decision;
   try {
     const cwd = sessionCwdOf(payload.agent);
+    const sessionId = sessionHeaderIdOf(payload.agent);
     const harnessDir = resolver.forWorkspace(cwd);
-    const key = explicitKey ?? cwd ?? "";
-    const catalogPayload = catalogPayloadFor(ctx, cache, register, key, harnessDir, ttlMs);
+    const hint = sessionHintForCatalog(harnessDir, payload.agent);
+    const catalogPayload = catalogPayloadFor(ctx, cache, invalidation, harnessDir, sessionId, cwd ?? "", hint, ttlMs);
     const messages = [...decision.messages];
     const text = renderEngineStatusCatalog(catalogPayload);
     const digestKey = agentDigestKey(payload.agent, cwd);
@@ -6366,9 +6990,22 @@ async function preStepCatalogListener(ctx, resolver, explicitKey, cache, ttlMs,
     return decision;
   }
 }
+function sessionHintForCatalog(harnessDir, agent) {
+  const identity = sessionHintOf(agent);
+  if (identity === undefined)
+    return;
+  const { cwd, sessionId } = identity;
+  if (cwd === undefined || sessionId === undefined || harnessDir === null)
+    return identity;
+  const binding = readWorkflowSessionBinding(harnessDir, sessionId, cwd);
+  const selected = binding.kind === "ok" ? binding.binding?.selectedWorkflowId : undefined;
+  return selected === undefined ? identity : { ...identity, selectedWorkflowId: selected };
+}
 function agentDigestKey(agent, cwd) {
-  const id = agent?.id;
-  return `${typeof id === "string" ? id : "<unknown>"}\x00${cwd ?? ""}`;
+  return JSON.stringify([
+    sessionHeaderIdOf(agent) ?? agentIdOf(agent) ?? "<unknown>",
+    cwd ?? ""
+  ]);
 }
 function persistEngineStatusSnapshot(ctx, harnessDir, cwd, turn, catalogPayload, agent) {
   const sessionId = sessionHeaderIdOf(agent);
@@ -6391,7 +7028,7 @@ function persistEngineStatusSnapshot(ctx, harnessDir, cwd, turn, catalogPayload,
 }
 
 // src/engine-status-endpoint.ts
-import { isAbsolute as isAbsolute3 } from "node:path";
+import { isAbsolute as isAbsolute9 } 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";
@@ -6424,6 +7061,8 @@ function validateName(subject, value) {
 // src/engine-status-wire.ts
 var MSTAR_ENGINE_STATUS_NAMESPACE = "mstar";
 var MSTAR_ENGINE_STATUS_METHOD = "engineStatus";
+var MSTAR_SELECT_WORKFLOW_METHOD = "selectWorkflow";
+var SELECT_WORKFLOW_ENDPOINT = `${MSTAR_ENGINE_STATUS_NAMESPACE}/${MSTAR_SELECT_WORKFLOW_METHOD}`;
 
 // src/engine-status-endpoint.ts
 var CONTRIBUTING_PACKAGE = "@mstar-harness/dsh";
@@ -6438,10 +7077,14 @@ function headerCwdOf(value) {
   const header = value?.header;
   return nonEmptyString2(header?.cwd);
 }
+function liveSeqOf(value) {
+  const seq = value?.seq;
+  return typeof seq === "number" && Number.isInteger(seq) && seq >= 0 ? seq : undefined;
+}
 function isRefusedPath(cwd) {
   if (cwd.includes("\x00"))
     return true;
-  if (!isAbsolute3(cwd))
+  if (!isAbsolute9(cwd))
     return true;
   return cwd.split(/[\\/]+/).includes("..");
 }
@@ -6449,10 +7092,12 @@ function isRefusedPath(cwd) {
 class MstarEngineStatusGateway extends TypertRemoteService {
   resolver;
   bootHarnessDir;
+  invalidateSelection;
   constructor(ctx, options) {
     super(ctx, MSTAR_ENGINE_STATUS_NAMESPACE);
     this.resolver = options.resolver;
     this.bootHarnessDir = options.bootHarnessDir;
+    this.invalidateSelection = options.invalidateSelection;
   }
   async engineStatus(sessionId, cwd) {
     try {
@@ -6462,6 +7107,14 @@ class MstarEngineStatusGateway extends TypertRemoteService {
       return unavailable("internal-error");
     }
   }
+  async selectWorkflow(sessionId, cwd, workflowId) {
+    try {
+      return await this.pick(sessionId, cwd, workflowId);
+    } catch (error) {
+      this.ctx.logger(ENDPOINT_LOGGER).warn(`selectWorkflow failed for ${String(sessionId)} (answering unavailable): ${error?.message ?? error}`);
+      return unavailable("internal-error");
+    }
+  }
   async serve(sessionId, cwd) {
     const sid = nonEmptyString2(sessionId);
     if (sid === undefined)
@@ -6491,8 +7144,92 @@ class MstarEngineStatusGateway extends TypertRemoteService {
       cwd: entry.cwd,
       at: entry.at,
       turn: entry.turn,
-      payload: entry.payload
+      payload: entry.payload,
+      binding: { selection: this.currentSelection(harnessDir, sid, entry.cwd, session.source === "live") }
+    };
+  }
+  async pick(sessionId, cwd, workflowId) {
+    const sid = nonEmptyString2(sessionId);
+    if (sid === undefined)
+      return unavailable("invalid-session-id");
+    const claimed = nonEmptyString2(cwd);
+    if (claimed === undefined)
+      return unavailable("invalid-cwd");
+    if (isRefusedPath(claimed))
+      return unavailable("cwd-refused");
+    const wid = nonEmptyString2(workflowId);
+    if (wid === undefined)
+      return unavailable("invalid-workflow-id");
+    const sessions = this.ctx.get("sessions");
+    const live = typeof sessions?.get === "function" ? sessions.get(sid) : undefined;
+    const liveCwd = headerCwdOf(live);
+    if (liveCwd === undefined)
+      return unavailable("session-not-live");
+    if (liveCwd !== claimed)
+      return unavailable("cwd-mismatch");
+    const seq = liveSeqOf(live);
+    if (seq === undefined)
+      return unavailable("session-seq-unavailable");
+    const harnessDir = this.bootHarnessDir ?? this.resolver.forWorkspace(liveCwd);
+    if (harnessDir === null || harnessDir === "")
+      return unavailable("no-harness-dir");
+    const registry = resolveActiveWorkflow(harnessDir);
+    if (registry.kind === "active") {
+      if (registry.workflowId !== wid)
+        return unavailable("workflow-not-active");
+    } else if (registry.kind === "error") {
+      if (registry.code !== "workflow.selection.unbound-multi-active") {
+        return unavailable(`selection-unavailable:${registry.code}`);
+      }
+      if (!(registry.activeWorkflowIds ?? []).includes(wid))
+        return unavailable("workflow-not-active");
+    } else {
+      return unavailable("selection-unavailable:terminal");
+    }
+    const holder = this.leaseHolderOf(sid, liveCwd);
+    const structural = {
+      cwd: liveCwd,
+      sessionId: sid,
+      ...holder === undefined ? {} : { leaseHolder: holder }
     };
+    const automatic = resolveActiveWorkflow(harnessDir, structural);
+    if (automatic.kind === "active" && automatic.workflowId !== wid)
+      return unavailable("binding-conflict");
+    const stored = readWorkflowSessionBinding(harnessDir, sid, liveCwd);
+    if (stored.kind === "unavailable")
+      return unavailable(`store-${stored.reason}`);
+    if (stored.binding?.selectedWorkflowId === wid) {
+      return { status: "selected", sessionId: sid, workflowId: wid };
+    }
+    const written = updateWorkflowSessionBinding(harnessDir, sid, liveCwd, {
+      selectedWorkflowId: wid,
+      excludedBeforeSeq: seq
+    });
+    if (written.kind === "degraded")
+      return unavailable(`store-${written.reason}`);
+    try {
+      this.invalidateSelection?.(harnessDir, sid);
+    } catch (error) {
+      this.ctx.logger(ENDPOINT_LOGGER).warn(`selectWorkflow cache invalidation degraded for ${sid} (the durable pick stands): ${error?.message ?? error}`);
+    }
+    return { status: "selected", sessionId: sid, workflowId: wid };
+  }
+  currentSelection(harnessDir, sessionId, cwd, live) {
+    const holder = live ? this.leaseHolderOf(sessionId, cwd) : undefined;
+    const stored = readWorkflowSessionBinding(harnessDir, sessionId, cwd);
+    const selected = stored.kind === "ok" ? stored.binding?.selectedWorkflowId : undefined;
+    const hint = {
+      cwd,
+      sessionId,
+      ...holder === undefined ? {} : { leaseHolder: holder },
+      ...selected === undefined ? {} : { selectedWorkflowId: selected }
+    };
+    return resolveReadWorkflow(harnessDir, hint);
+  }
+  leaseHolderOf(sessionId, cwd) {
+    const agents = this.ctx.get("agents");
+    const agent = typeof agents?.get === "function" ? agents.get(sessionId) : undefined;
+    return verifiedLeaseHolderOf(agent, sessionId, cwd);
   }
   async resolveSessionCwd(sessionId) {
     const sessions = this.ctx.get("sessions");
@@ -6534,6 +7271,19 @@ function mstarEngineStatusContribution() {
           { name: "cwd", wire: "cwd", source: "json", codec: { mode: "src-json" } }
         ],
         result: { mode: "src-json" }
+      },
+      {
+        id: `${CONTRIBUTING_PACKAGE}#${MSTAR_ENGINE_STATUS_NAMESPACE}/${MSTAR_SELECT_WORKFLOW_METHOD}`,
+        service: MSTAR_ENGINE_STATUS_NAMESPACE,
+        namespace: MSTAR_ENGINE_STATUS_NAMESPACE,
+        method: MSTAR_SELECT_WORKFLOW_METHOD,
+        invocation: { kind: "direct" },
+        parameters: [
+          { name: "sessionId", wire: "sessionId", source: "json", codec: { mode: "src-json" } },
+          { name: "cwd", wire: "cwd", source: "json", codec: { mode: "src-json" } },
+          { name: "workflowId", wire: "workflowId", source: "json", codec: { mode: "src-json" } }
+        ],
+        result: { mode: "src-json" }
       }
     ]
   };
@@ -6571,14 +7321,14 @@ function installEngineStatusEndpoint(ctx, options) {
 
 // src/gates/status.ts
 import { existsSync as existsSync15, readdirSync as readdirSync7 } from "node:fs";
-import { basename as basename5, join as join14, relative as relative7, resolve as resolve10 } from "node:path";
+import { basename as basename8, join as join14, relative as relative9, resolve as resolve10 } from "node:path";
 var LOGGER_NAME = "mstar/status-gate";
 function harnessDocKindOfTarget(harnessDir, targetPath) {
   const resolved = resolve10(targetPath);
-  const name = basename5(resolved);
+  const name = basename8(resolved);
   if (name !== STATUS_FILE && name !== WORKFLOW_SNAPSHOT_FILE && name !== PROJECT_REGISTER_FILE)
     return null;
-  const rel = relative7(harnessDir, resolved);
+  const rel = relative9(harnessDir, resolved);
   if (name === STATUS_FILE && rel === STATUS_FILE)
     return "status";
   let workflowDir;
@@ -6590,9 +7340,9 @@ function harnessDocKindOfTarget(harnessDir, targetPath) {
     workflowDir = join14(harnessDir, "workflows");
     projectDir = join14(harnessDir, "projects");
   }
-  if (name === WORKFLOW_SNAPSHOT_FILE && /^[^/]+\/snapshot\.json$/.test(relative7(workflowDir, resolved)))
+  if (name === WORKFLOW_SNAPSHOT_FILE && /^[^/]+\/snapshot\.json$/.test(relative9(workflowDir, resolved)))
     return "snapshot";
-  if (name === PROJECT_REGISTER_FILE && /^[^/]+\/residuals\.json$/.test(relative7(projectDir, resolved)))
+  if (name === PROJECT_REGISTER_FILE && /^[^/]+\/residuals\.json$/.test(relative9(projectDir, resolved)))
     return "register";
   return null;
 }
@@ -6727,7 +7477,7 @@ async function editIntentListener(ctx, resolver, config, adapter, target, actor,
 
 // src/gates/skill-lint.ts
 import { existsSync as existsSync16, readFileSync as readFileSync13 } from "node:fs";
-import { basename as basename8, dirname as dirname10, resolve as resolve12, sep as sep2 } from "node:path";
+import { basename as basename10, dirname as dirname10, resolve as resolve12, sep as sep5 } from "node:path";
 var SKILL_LINT_LOGGER = "mstar/skill-lint";
 
 class SkillLintVetoError extends Error {
@@ -6768,7 +7518,7 @@ function lintSkillDoc(doc, options = {}) {
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
 function lintSkillWrite(doc, options) {
-  const skillId = basename8(dirname10(resolve12(options.target)));
+  const skillId = basename10(dirname10(resolve12(options.target)));
   const result = lintSkillDoc(doc, { skillId });
   if (options.hard && !result.ok) {
     throw new SkillLintVetoError(options.target, result.violations);
@@ -6781,13 +7531,13 @@ function skillRootsOf(config) {
   return roots.map((root) => root.trim()).filter((root) => root !== "");
 }
 function isSkillTarget(roots, target) {
-  if (basename8(target.displayPath) !== "SKILL.md")
+  if (basename10(target.displayPath) !== "SKILL.md")
     return false;
   const resolvedPath = resolve12(target.displayPath);
-  return roots.some((root) => resolvedPath.startsWith(resolve12(root) + sep2));
+  return roots.some((root) => resolvedPath.startsWith(resolve12(root) + sep5));
 }
 function skillNameOf(target) {
-  return basename8(dirname10(target.displayPath));
+  return basename10(dirname10(target.displayPath));
 }
 function skillCanonicalForm(target) {
   return resolveSkillRoot("dsh", { skill: skillNameOf(target), rel: "SKILL.md" });
@@ -6817,7 +7567,7 @@ function gateSkillIntent(ctx, harnessDir, config, target) {
       });
       return;
     }
-    const result = lintSkillDoc(doc, { skillId: basename8(dirname10(skillPath)) });
+    const result = lintSkillDoc(doc, { skillId: basename10(dirname10(skillPath)) });
     if (result.ok)
       return;
     const hard = resolveSeamHard(harnessDir, config);
@@ -6852,7 +7602,7 @@ async function skillWriteIntentListener(ctx, resolver, config, target, actor, ne
 
 // src/gates/seams.ts
 import { existsSync as existsSync17, readFileSync as readFileSync14, readdirSync as readdirSync10 } from "node:fs";
-import { basename as basename10, dirname as dirname11, join as join17, resolve as resolve14, sep as sep3 } from "node:path";
+import { basename as basename11, dirname as dirname11, join as join17, resolve as resolve14, sep as sep7 } from "node:path";
 
 // ../engine/dist/audit.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -7051,7 +7801,7 @@ var SEAM_LOGGERS = {
   roles: "mstar/roles-lint"
 };
 function isIndexFile(path) {
-  const base = basename10(path);
+  const base = basename11(path);
   return base === "README.md" || base === "index.md";
 }
 function isMarkdownDoc(path) {
@@ -7060,7 +7810,7 @@ function isMarkdownDoc(path) {
 function isAuditPlanTarget(path) {
   if (!isMarkdownDoc(path))
     return false;
-  const segments = resolve14(path).split(sep3);
+  const segments = resolve14(path).split(sep7);
   for (let i = 0;i < segments.length; i++) {
     if (segments[i] !== "plans")
       continue;
@@ -7071,7 +7821,7 @@ function isAuditPlanTarget(path) {
   return false;
 }
 function isRolesTarget(path) {
-  const segments = resolve14(path).split(sep3);
+  const segments = resolve14(path).split(sep7);
   const idx = segments.indexOf("mstar-roles");
   if (idx === -1)
     return false;
@@ -7081,17 +7831,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(sep3);
+  const segments = resolve14(path).split(sep7);
   const idx = segments.indexOf("mstar-roles");
   if (idx === -1)
     return dirname11(path);
-  return idx === 0 ? sep3 : join17(sep3, ...segments.slice(1, idx + 1));
+  return idx === 0 ? sep7 : join17(sep7, ...segments.slice(1, idx + 1));
 }
 function isSeamTarget(seam, harnessDir, target) {
   const path = resolve14(target.displayPath);
   switch (seam) {
     case "design-md": {
-      const base = basename10(path);
+      const base = basename11(path);
       return base === "DESIGN.md" || base === "DESIGN.dark.md";
     }
     case "audit":
@@ -7099,7 +7849,7 @@ function isSeamTarget(seam, harnessDir, target) {
     case "compound": {
       if (harnessDir === null)
         return false;
-      return path.startsWith(resolve14(join17(harnessDir, "knowledge")) + sep3) && isMarkdownDoc(path);
+      return path.startsWith(resolve14(join17(harnessDir, "knowledge")) + sep7) && isMarkdownDoc(path);
     }
     case "roles":
       return isRolesTarget(path);
@@ -7116,7 +7866,7 @@ function auditSecretsViolations(findings, file) {
 }
 function validateDesignDoc(doc, path) {
   const violations = [...validateDesignTokenFrontmatter(doc).violations];
-  const isDark = basename10(path) === "DESIGN.dark.md";
+  const isDark = basename11(path) === "DESIGN.dark.md";
   const sibling = join17(dirname11(path), isDark ? "DESIGN.md" : "DESIGN.dark.md");
   if (existsSync17(sibling)) {
     const light = isDark ? readFileSync14(sibling, "utf8") : doc;
@@ -7195,12 +7945,12 @@ function gateSeamIntent(ctx, harnessDir, config, seam, target) {
     const hard = resolveSeamHard(harnessDir, config);
     const verdict = applyEnforcement(result, { hard });
     if (verdict.hardBlocked) {
-      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):
+      logger.error(`${basename11(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(`${basename10(path)} write to ${target.displayPath} (advisory):
+      logger.warn(`${basename11(path)} write to ${target.displayPath} (advisory):
 ${verdict.violations.map(formatViolation).join(`
 `)}`);
       emitSeamAdvisory(ctx, seam, target.displayPath, verdict, hard);
@@ -7661,13 +8411,36 @@ class DshHostAdapter extends Service3 {
       return { ok: true, violations: [] };
     return validateStatusDoc(path, kind, harnessDir);
   }
-  dispatchGate(prompt, exec, hard) {
+  sessionHintFor(agent) {
+    const identity = sessionHintOf(agent);
+    if (identity === undefined)
+      return { kind: "ok" };
+    const { sessionId, cwd } = identity;
+    if (sessionId === undefined || cwd === undefined)
+      return { kind: "ok", hint: identity };
+    const harnessDir = this.resolver.forAgent(agent);
+    if (harnessDir === null)
+      return { kind: "ok", hint: identity };
+    const read = readWorkflowSessionBinding(harnessDir, sessionId, cwd);
+    if (read.kind === "unavailable") {
+      this.log("warn", `session ${sessionId}: workflow selection binding ${read.reason} — attribution paused (no ledger write for this call)`);
+      return { kind: "unavailable", reason: read.reason, hint: identity };
+    }
+    const selectedWorkflowId = read.binding?.selectedWorkflowId;
+    return {
+      kind: "ok",
+      hint: selectedWorkflowId === undefined ? identity : { ...identity, selectedWorkflowId }
+    };
+  }
+  dispatchGate(prompt, exec, hard, hintRead) {
     const harnessDir = this.resolver.forAgent(exec?.agent);
-    const { violations, writable } = dispatchGateCore(this.config, harnessDir, prompt);
+    const session = hintRead ?? this.sessionHintFor(exec?.agent);
+    const hint = session.hint;
+    const { violations, writable } = dispatchGateCore(this.config, harnessDir, prompt, hint);
     if (exec !== undefined) {
-      violations.push(...leaseGateViolations(harnessDir, exec, writable, prompt));
+      violations.push(...leaseGateViolations(harnessDir, exec, writable, prompt, hint));
     }
-    if (harnessDir !== null && isAssignmentShaped2(assignmentHeaderRegion(prompt))) {
+    if (harnessDir !== null && session.kind === "ok" && isAssignmentShaped2(assignmentHeaderRegion(prompt))) {
       try {
         recordDispatch({
           harnessDir,
@@ -7675,7 +8448,8 @@ class DshHostAdapter extends Service3 {
           prompt,
           violations,
           hard: hard ?? resolveDispatchHard(harnessDir, this.config, prompt),
-          pairing: this.pairing
+          pairing: this.pairing,
+          ...hint !== undefined ? { hint } : {}
         });
       } catch (error) {
         this.ctx.logger(AGENT_FLOW_LOGGER).error(`agent-flow dispatch record failed (contained — dispatch proceeds): ${error.message}`);
@@ -7738,8 +8512,8 @@ class DshHostAdapter extends Service3 {
 }
 
 // src/gates/agent-personas.ts
-import { readFileSync as readFileSync16, readdirSync as readdirSync12, statSync as statSync7 } from "node:fs";
-import { join as join21, resolve as resolve17, sep as sep5 } from "node:path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync12, statSync as statSync8 } from "node:fs";
+import { join as join21, resolve as resolve17, sep as sep8 } from "node:path";
 var ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
 var defaultCache = new Map;
 function personaFor(roleId, lookup, warn) {
@@ -7782,11 +8556,11 @@ function defaultFromMirror(agentsDir, roleId, warn) {
     return;
   const root = resolve17(agentsDir);
   const file = resolve17(agentsDir, `${roleId}.md`);
-  if (!file.startsWith(root + sep5))
+  if (!file.startsWith(root + sep8))
     return;
   let stat;
   try {
-    stat = statSync7(file);
+    stat = statSync8(file);
   } catch {
     return;
   }
@@ -7907,7 +8681,7 @@ function registerRolePersonaChannel(ctx, config) {
       log2("warn", `role persona channel degraded to pass-through (subagent starts unaffected): ${errorMessage2(error)}`);
       return value;
     }
-  });
+  }, { prepend: true });
 }
 var SEAM_WARN = `role persona channel not installed — cordis '${PERSONA_SEAM_EVENT}' seam missing or unrecognized (rolePersonas will not be merged into subagent starts)`;
 function evaluateSeamProbe({ dispatched, readError, value }) {
@@ -8054,9 +8828,25 @@ function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function sessionIdOf2(session) {
-  const id = session?.id;
+  const id = session?.header?.id;
   return typeof id === "string" && id !== "" ? id : undefined;
 }
+function sessionCwdOf2(session) {
+  const cwd = session?.header?.cwd;
+  return typeof cwd === "string" && cwd.trim() !== "" ? cwd : undefined;
+}
+function sessionForkCutOf(session) {
+  const inherited = session?.inheritedEventCount;
+  return typeof inherited === "number" && Number.isSafeInteger(inherited) && inherited >= 0 && inherited < WORKFLOW_LEDGER_MAX_SEQ ? inherited : 0;
+}
+function sessionEndSeqOf(session) {
+  const seq = session?.seq;
+  return typeof seq === "number" && Number.isSafeInteger(seq) && seq >= 0 && seq < WORKFLOW_LEDGER_MAX_SEQ ? seq : undefined;
+}
+function sessionEventAtOf(session) {
+  const eventAt = session?.eventAt;
+  return typeof eventAt === "function" ? eventAt.bind(session) : undefined;
+}
 var watermarkCache = new Map;
 function cacheWatermark(workflowDir, watermark) {
   watermarkCache.set(workflowDir, watermark);
@@ -8226,6 +9016,37 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
     return;
   }
   const depthWarned = new Set;
+  const pendingFloors = new Map;
+  let scanDepth = 0;
+  const persistExclusionFloor = (harnessDir, sessionId, cwd, floor) => {
+    const written = updateWorkflowSessionBinding(harnessDir, sessionId, cwd, { excludedBeforeSeq: floor });
+    if (written.kind === "degraded") {
+      log3("warn", `workflow-ledger exclusion floor not persisted for session ${sessionId} (${written.reason}) — attribution stays paused, the row is re-evaluated at the next scan`);
+    }
+  };
+  const flushExclusionFloors = () => {
+    for (const pending of pendingFloors.values()) {
+      persistExclusionFloor(pending.harnessDir, pending.sessionId, pending.cwd, pending.floor);
+    }
+    pendingFloors.clear();
+  };
+  const observeExclusionFloor = (harnessDir, sessionId, cwd, floor) => {
+    if (scanDepth === 0) {
+      persistExclusionFloor(harnessDir, sessionId, cwd, floor);
+      return;
+    }
+    const key = `${harnessDir}\x00${sessionId}`;
+    const pending = pendingFloors.get(key);
+    if (pending === undefined)
+      pendingFloors.set(key, { harnessDir, sessionId, cwd, floor });
+    else if (floor > pending.floor)
+      pending.floor = floor;
+  };
+  const leaseHolderOf = (sessionId, cwd) => {
+    const agents = ctx.get("agents");
+    const agent = typeof agents?.get === "function" ? agents.get(sessionId) : undefined;
+    return verifiedLeaseHolderOf(agent, sessionId, cwd);
+  };
   const consume = (session, envelope) => {
     const sid = sessionIdOf2(session);
     if (sid === undefined)
@@ -8233,17 +9054,44 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
     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);
+    const workspace = sessionCwdOf2(session);
+    const harnessDir = resolver.forWorkspace(workspace);
     if (harnessDir === null)
       return;
-    const workflowDir = resolveAgentFlowWriteDir(harnessDir);
-    if (workflowDir === null)
+    const holder = leaseHolderOf(sid, workspace);
+    const identity = {
+      sessionId: sid,
+      ...workspace === undefined ? {} : { cwd: workspace },
+      ...holder === undefined ? {} : { leaseHolder: holder }
+    };
+    let hint = identity;
+    let floor = 0;
+    if (workspace !== undefined) {
+      const binding = readWorkflowSessionBinding(harnessDir, sid, workspace);
+      if (binding.kind === "unavailable") {
+        log3("warn", `workflow-ledger attribution paused for session ${sid} — binding store ${binding.reason} (no ledger write, row stays eligible)`);
+        return;
+      }
+      floor = binding.binding?.excludedBeforeSeq ?? 0;
+      const selected = binding.binding?.selectedWorkflowId;
+      if (selected !== undefined)
+        hint = { ...identity, selectedWorkflowId: selected };
+    }
+    if (row.seq < floor)
+      return;
+    const target = resolveAgentFlowWriteTarget(harnessDir, hint);
+    const workflowDir = target.dir;
+    if (workflowDir === null) {
+      const unbound = target.selection.kind === "error" && target.selection.code === "workflow.selection.unbound-multi-active";
+      if (unbound && workspace !== undefined && row.seq + 1 > floor) {
+        observeExclusionFloor(harnessDir, sid, workspace, row.seq + 1);
+      }
       return;
+    }
     const watermark = loadWatermark(workflowDir);
     let next = watermark.get(sid) ?? 0;
-    const events = session.events;
-    if (Array.isArray(events) && events.length < next)
+    const endSeq = sessionEndSeqOf(session);
+    if (endSeq !== undefined && endSeq < next)
       next = 0;
     if (row.seq < next)
       return;
@@ -8268,15 +9116,59 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
       }
     }
   };
+  const scanStartSeq = (session, sid, endSeq) => {
+    const cut = sessionForkCutOf(session);
+    const workspace = sessionCwdOf2(session);
+    if (workspace === undefined)
+      return cut;
+    const harnessDir = resolver.forWorkspace(workspace);
+    if (harnessDir === null)
+      return cut;
+    const binding = readWorkflowSessionBinding(harnessDir, sid, workspace);
+    if (binding.kind === "unavailable")
+      return cut;
+    const floor = binding.binding?.excludedBeforeSeq ?? 0;
+    if (floor > endSeq) {
+      log3("warn", `workflow-ledger session ${sid} exclusion floor ${floor} is past its log end ${endSeq} — identity/log-rebuild drift, scan skipped (the intentional exclusion record is preserved)`);
+      return endSeq;
+    }
+    const selected = binding.binding?.selectedWorkflowId;
+    const holder = leaseHolderOf(sid, workspace);
+    const hint = {
+      sessionId: sid,
+      cwd: workspace,
+      ...holder === undefined ? {} : { leaseHolder: holder },
+      ...selected === undefined ? {} : { selectedWorkflowId: selected }
+    };
+    const bounded = Math.max(floor, cut);
+    const workflowDir = resolveAgentFlowWriteTarget(harnessDir, hint).dir;
+    if (workflowDir === null)
+      return bounded;
+    const cursor = loadWatermark(workflowDir).get(sid) ?? 0;
+    return Math.max(bounded, cursor > endSeq ? 0 : cursor);
+  };
   const scanSession = (session) => {
     const sid = sessionIdOf2(session);
     if (sid === undefined)
       return;
-    const events = session.events;
-    if (!Array.isArray(events))
+    const endSeq = sessionEndSeqOf(session);
+    if (endSeq === undefined)
       return;
-    for (const envelope of events)
-      consume(session, envelope);
+    const startSeq = scanStartSeq(session, sid, endSeq);
+    if (startSeq >= endSeq)
+      return;
+    const eventAt = sessionEventAtOf(session);
+    if (eventAt === undefined)
+      return;
+    scanDepth += 1;
+    try {
+      for (let seq = startSeq;seq < endSeq; seq += 1)
+        consume(session, eventAt(seq));
+    } finally {
+      scanDepth -= 1;
+      if (scanDepth === 0)
+        flushExclusionFloors();
+    }
   };
   ctx.events.on("session/created", (session) => {
     try {
@@ -8293,13 +9185,14 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
     sessionsSnapshot = [];
   }
   for (const session of sessionsSnapshot) {
-    const sid = sessionIdOf2(session);
-    if (sid === undefined)
-      continue;
+    let sid;
     try {
+      sid = sessionIdOf2(session);
+      if (sid === undefined)
+        continue;
       scanSession(session);
     } catch (error) {
-      log3("warn", `workflow-ledger cold scan failed for session ${sid} (contained — other sessions unaffected): ${errorMessage3(error)}`);
+      log3("warn", `workflow-ledger cold scan failed for session ${sid ?? "unknown"} (contained — other sessions unaffected): ${errorMessage3(error)}`);
     }
   }
   ctx.events.on("session/event", (session, envelope) => {
@@ -8312,11 +9205,9 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
 }
 
 // src/gates/goal-bridge.ts
-import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync13 } from "node:fs";
+import { existsSync as existsSync20, readdirSync as readdirSync13 } from "node:fs";
 import { join as join23 } 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;
@@ -8347,111 +9238,6 @@ function projectRegisterPointer(harnessDir) {
   } catch {}
   return join23(projectsDir, _DEFAULT_PROJECT, PROJECT_REGISTER_FILE);
 }
-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 (!existsSync20(iterationsDir))
-    return;
-  let entries;
-  try {
-    entries = readdirSync13(iterationsDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const compassPath = join23(iterationsDir, entry.name, "delivery-compass.md");
-    if (!existsSync20(compassPath))
-      continue;
-    let content;
-    try {
-      content = readFileSync18(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)
@@ -8483,6 +9269,32 @@ function warnBlockedGoal(harnessDir, advisory) {
   const objective = truncateLedgerField(normalizeWorkflowName(advisory.objective), GOAL_ADVISORY_OBJECTIVE_CAP);
   log4("warn", `goal blocked [${code}] — ${reason}; objective: ${objective}; residuals: see ${projectRegisterPointer(harnessDir)} — advisory only, zero harness writes`);
 }
+function registerGoalBridge(ctx, resolver) {
+  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 existsSync21 } from "node:fs";
+import { isAbsolute as isAbsolute10, join as join24, relative as relative10, sep as sep9 } from "node:path";
+
+// src/gates/steering.ts
+function isRootLikeAgent(agent) {
+  const header = agent?.session?.header;
+  return header?.parentSession === undefined;
+}
 function rootAgentOf(agent, agents) {
   let current = agent;
   const seen = new Set;
@@ -8503,53 +9315,8 @@ function rootAgentOf(agent, agents) {
     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 existsSync21 } from "node:fs";
-import { join as join24 } from "node:path";
 var PLAN_MODE_BRIDGE_LOGGER = "mstar/plan-mode-bridge";
 var PLAN_STATUS_TODO = "Todo";
 var planModeBridgeLogSink = () => {};
@@ -8564,29 +9331,73 @@ function log5(level, message) {
 function errorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function hasPrepareWindow(harnessDir) {
-  const statusPath = join24(harnessDir, STATUS_FILE);
-  if (!existsSync21(statusPath))
+function selectedLifecycle(harnessDir, hint) {
+  if (!existsSync21(join24(harnessDir, STATUS_FILE)))
+    return { kind: "none" };
+  const selection = resolveReadWorkflow(harnessDir, hint);
+  if (selection.kind === "error") {
+    return selection.code === "workflow.selection.unbound-multi-active" ? { kind: "unbound" } : { kind: "none" };
+  }
+  let doc;
+  try {
+    doc = readJson(join24(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE));
+  } catch {
+    return { kind: "none" };
+  }
+  if (asRecord(doc) === undefined)
+    return { kind: "none" };
+  return { kind: "selected", workflowId: selection.workflowId, doc };
+}
+function selectedCompassSteers(harnessDir, lifecycle) {
+  const ref = lifecycle.doc.compass_ref;
+  if (typeof ref !== "string" || ref.trim() === "" || isAbsolute10(ref))
     return false;
-  const selection = resolveReadWorkflow(harnessDir);
-  if (selection.kind === "error")
+  const compassPath = join24(harnessDir, ref);
+  const inside = relative10(harnessDir, compassPath);
+  if (inside === "" || inside === ".." || inside.startsWith(`..${sep9}`) || isAbsolute10(inside))
     return false;
-  const snapshotPath = join24(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
-  let doc;
+  if (!existsSync21(compassPath))
+    return false;
+  let fields;
   try {
-    doc = readJson(snapshotPath);
+    fields = parseCompassFrontmatter(compassPath);
   } catch {
     return false;
   }
+  if (fields.status !== "active" && fields.status !== "locked")
+    return false;
+  return fields.iteration_id === lifecycle.workflowId;
+}
+function hasPrepareWindow(doc) {
   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)
+function planModeTarget(harnessDir, hint) {
+  const lifecycle = selectedLifecycle(harnessDir, hint);
+  if (lifecycle.kind === "unbound")
+    return;
+  if (lifecycle.kind === "none")
+    return false;
+  if (!selectedCompassSteers(harnessDir, lifecycle))
     return false;
-  return hasPrepareWindow(harnessDir);
+  return hasPrepareWindow(lifecycle.doc);
+}
+function rootSessionHint(agent, harnessDir) {
+  const identity = sessionHintOf(agent);
+  if (identity === undefined)
+    return;
+  const { cwd, sessionId } = identity;
+  if (cwd === undefined || sessionId === undefined)
+    return identity;
+  const binding = readWorkflowSessionBinding(harnessDir, sessionId, cwd);
+  if (binding.kind === "unavailable") {
+    log5("warn", `planMode sync: session ${sessionId} binding store ${binding.reason} — selection falls back to lease/worktree evidence`);
+    return identity;
+  }
+  const selected = binding.binding?.selectedWorkflowId;
+  return selected === undefined ? identity : { ...identity, selectedWorkflowId: selected };
 }
 function syncPlanMode(agent, input) {
   const { resolver, planMode } = input;
@@ -8598,7 +9409,10 @@ function syncPlanMode(agent, input) {
   if (harnessDir === null)
     return false;
   try {
-    planMode.set(agent, planModeTarget(harnessDir));
+    const target = planModeTarget(harnessDir, rootSessionHint(agent, harnessDir));
+    if (target === undefined)
+      return false;
+    planMode.set(agent, target);
     return true;
   } catch (error) {
     log5("warn", `planMode sync failed (contained — the session/decision point proceeds): ${errorMessage5(error)}`);
@@ -9111,7 +9925,7 @@ function registerMstarCommands(ctx) {
     for (const file of readdirSync14(dir).sort()) {
       if (!file.endsWith(".md"))
         continue;
-      const parsed = parseCommandMarkdown(readFileSync19(join25(dir, file), "utf8"));
+      const parsed = parseCommandMarkdown(readFileSync18(join25(dir, file), "utf8"));
       if (parsed === undefined)
         continue;
       commandsCtx.commands.register({
@@ -9142,7 +9956,8 @@ function apply(ctx, config) {
   new DshMstar(ctx, { harnessDir: bootHarnessDir });
   const pairing = {
     dispatchByCallId: new Map,
-    dispatchByTaskId: new Map
+    dispatchByJobId: new Map,
+    catalogBySession: new WeakMap
   };
   const adapter = new DshHostAdapter(ctx, { resolver, config, pairing });
   setAgentFlowLogger((level, message) => {
@@ -9241,6 +10056,7 @@ function apply(ctx, config) {
     };
   });
   registerSettleListener(ctx, config, pairing);
+  registerSubagentCatalogListener(ctx, pairing);
   setWorkflowLedgerLogger((level, message) => {
     const logger = ctx.logger(WORKFLOW_LEDGER_LOGGER);
     if (level === "warn")
@@ -9256,7 +10072,7 @@ function apply(ctx, config) {
     else
       logger.warn(message);
   });
-  registerGoalBridge(ctx, resolver, config);
+  registerGoalBridge(ctx, resolver);
   setPlanModeBridgeLogger((level, message) => {
     const logger = ctx.logger(PLAN_MODE_BRIDGE_LOGGER);
     if (level === "debug")
@@ -9269,7 +10085,7 @@ function apply(ctx, config) {
     const jobs = jobsCtx.jobs;
     try {
       jobs.onJobDone((snapshot, _owner) => {
-        recordTaskSettle(snapshot, pairing);
+        recordJobSettle(snapshot, pairing);
       });
     } catch (error) {
       ctx.logger(AGENT_FLOW_LOGGER).error(`jobs.onJobDone registration failed (contained — background settle pairing degraded): ${error.message}`);
@@ -9301,18 +10117,16 @@ function apply(ctx, config) {
     runAdvisoryPass();
   });
   const ttlMs = config.catalogTtlMs ?? DEFAULT_CATALOG_TTL_MS;
-  const explicitKey = bootHarnessDir !== null ? EXPLICIT_CACHE_KEY : undefined;
   const catalogCache = new Map;
-  if (explicitKey !== undefined) {
-    catalogCache.set(explicitKey, { payload: buildCatalogPayload(ctx, bootHarnessDir), builtAt: Date.now() });
-  }
-  const catalogInvalidation = createCatalogInvalidation(catalogCache);
-  if (explicitKey !== undefined)
-    catalogInvalidation.register(bootHarnessDir, explicitKey);
-  setAgentFlowInvalidator(catalogInvalidation.invalidate);
   const catalogDigests = new Map;
-  ctx.on("agent/pre-step", (payload, next) => preStepCatalogListener(ctx, resolver, explicitKey, catalogCache, ttlMs, catalogInvalidation.register, catalogDigests, payload, next));
-  installEngineStatusEndpoint(ctx, { resolver, bootHarnessDir });
+  const catalogInvalidation = createCatalogInvalidation(catalogCache, catalogDigests);
+  setAgentFlowInvalidator(catalogInvalidation.invalidate);
+  ctx.on("agent/pre-step", (payload, next) => preStepCatalogListener(ctx, resolver, catalogCache, ttlMs, catalogInvalidation, catalogDigests, payload, next));
+  installEngineStatusEndpoint(ctx, {
+    resolver,
+    bootHarnessDir,
+    invalidateSelection: (harnessDir, sessionId) => catalogInvalidation.invalidateSession(harnessDir, sessionId)
+  });
   registerSddIterationTools(ctx, resolver);
   registerSeamTools(ctx, resolver);
 }