@sabaiway/agent-workflow-kit 10.3.0 → 10.5.0

package/tools/procedures.mjs

@@ -3,10 +3,10 @@
 //
 // It composes the AD-018 orchestration recipes into NAMED activities: it reads the canonical procedure
 // steps LIVE from the installed agent-workflow-engine (references/procedures.md — AD-016 live read, no
-// bundled mirror), reads the per-project, hand-edited config (docs/ai/orchestration.json), runs the
-// read-only backend detector, and prints the activity's steps VERBATIM + the resolved effective recipe
-// per slot (default = Reviewed-when-a-backend-is-ready, Council on request, slot-aware incl. Delegated),
-// plus the project's DECLARED source-size practice when it declares one (D-17 U1).
+// bundled mirror), reads the per-project, hand-edited config (docs/ai/orchestration.json), composes the
+// readiness every caller composes (detected backends + the executor vehicle), and prints the activity's
+// steps VERBATIM + the resolved effective recipe per slot, plus the project's DECLARED source-size
+// practice when it declares one (D-17 U1).
 //
 // Invariants (mirror recipes.mjs): pure-where-possible, READ-ONLY (never writes, never commits, never
 // runs a subscription CLI). The deterministic resolution lives in the kit (resolveActivityRecipe), not
@@ -26,29 +26,28 @@ import { detectBackends, wrapperCmdFor, wrapperContractFor } from './detect-back
 // core only — never the writer — so this read-only advisor never imports the atomic-write core.
 import { loadRegistry, allowedLabel } from './bridge-settings-read.mjs';
 import { isDirectRun } from './direct-run.mjs';
-import { ACTIVITIES, resolveActivityRecipe, planRecipe } from './recipes.mjs';
+import { ACTIVITIES, SLOT_RECIPES, isSwitchSlot, resolveActivityRecipe, planRecipe, composeReadiness } from './recipes.mjs';
+// The dispatch-form wording, from the pure (fs-free) leaf that owns it: composed here, never re-worded.
+import { dispatchForm, parallelLine } from './carriers.mjs';
 import { resolveEngineDir, readEngineFragment, PROCEDURES_FRAGMENT_REL } from './engine-source.mjs';
 // The plan-in-flight detector (AD-038) — imported from the plan-files.mjs LEAF (read-only fs by
 // construction); the WRITER-capable grounding.mjs is only NAMED in rendered text, never imported.
 import { plansInFlight, PLANS_REL } from './plan-files.mjs';
 // The family's ONE shell quoter for a RENDERED command operand (bare when the value is already safe,
 // single-quoted otherwise) — the same leaf eight other command renderers here read through.
-import { shellQuoteArg } from './repo-lex.mjs';
-// The config schema/read core lives in orchestration-config.mjs (the single config contract). procedures
-// is READ-ONLY: it imports the reader + the SHARED slot/recipe validity, never the fs-writer
-// (orchestration-write.mjs) DIRECTLY — the import-split test pins the direct-import rule.
-// CONFIG_REL is RE-EXPORTED so existing importers (procedures.test.mjs, historically) keep their
-// import site working.
+import { shellQuoteArg, isSeedablePathToken, isRenderableLine, escapeForDisplay, isArtifactPathCarriable } from './repo-lex.mjs';
+// The config schema/read core (orchestration-config.mjs, the single config contract): the reader +
+// the SHARED slot/recipe validity, never the fs-writer (orchestration-write.mjs) DIRECTLY — the
+// import-split test pins the direct-import rule.
 import { CONFIG_REL, fail, loadConfig, assertSlotRecipe } from './orchestration-config.mjs';
 import { AUTONOMY_REL, loadAutonomy, resolveAutonomy, isSparseSeedConfig } from './autonomy-config.mjs';
-// The flow armed-halves probe (P8): read-only store presence/adoption facts for the session-start
-// surface, imported from the read module that OWNS no write API — this advisor never imports the
-// mixed flow-store module (append API) DIRECTLY, like it never imports orchestration-write (the
-// import-split test pins both direct rules). The TRANSITIVE claim is now structural, not
-// narrated: this advisor's import closure reaches NO write-API module and the tools graph is
-// acyclic — pinned by test/read-graph-purity.test.mjs (FLOW-READ-GRAPH-PURITY).
+// The flow armed-halves probe (P8): read-only store presence/adoption facts, from the read module
+// that OWNS no write API — never the mixed flow-store module (append API) DIRECTLY, like never
+// orchestration-write (the import-split test pins both direct rules; the TRANSITIVE claim is
+// structural — test/read-graph-purity.test.mjs pins it).
 import { resolveFlowStorePath, readFlowStore } from './flow-store-read.mjs';
 import { CHAIN_KIND } from './flow-record.mjs';
+import { readRegistration } from './mcp-registration.mjs';
 // The declared source-size practice (D-17 U1), read through the practice's PURE READ core — never
 // source-size-check.mjs, which owns the writer half: this advisor is a read root of
 // test/read-graph-purity.test.mjs, and the core exists so a surface can ask without reaching a writer.
@@ -57,18 +56,17 @@ export { CONFIG_REL };
 
 // ── argument + override parsing (usage errors → exit 2) ─────────────────────────────
 
-// Parse the activity's --override <slot>=<recipe> tokens into a { slot: recipe } map, validating each
+// Parse the activity's --override <slot>=<value> tokens into a { slot: recipe } map, validating each
 // against the SHARED slot/recipe validity table (assertSlotRecipe — the SAME accept/reject the set-recipe
-// op parser uses, drift-guarded). Every malformed token is a USAGE error (exit 2): a bare `<recipe>` (no
-// slot), an unknown slot for the activity, an invalid recipe-for-slot, or a duplicate slot. (An override
-// naming a recipe whose backend merely is not `ready` is NOT a usage error — it degrades loudly at
-// resolution time, exit 0.) The `--override` grammar stays activity-SCOPED (the activity comes from the
-// CLI arg), unlike the fully-qualified `--set <activity>.<slot>=<recipe>` the writer takes.
+// op parser uses, drift-guarded). Every malformed token is a USAGE error (exit 2): a bare `<recipe>`, an
+// unknown slot for the activity, an invalid recipe-for-slot, or a duplicate slot. (An override naming a
+// recipe whose backend merely is not `ready` is NOT a usage error — it degrades loudly at resolution
+// time, exit 0.) The grammar stays activity-SCOPED, unlike the writer's `--set <activity>.<slot>=<x>`.
 const parseOverrides = (tokens, activity) => {
   const overrides = {};
   for (const tok of tokens) {
     const eq = tok.indexOf('=');
-    if (eq <= 0) throw fail(2, `--override must be <slot>=<recipe> (got "${tok}")`);
+    if (eq <= 0) throw fail(2, `--override must be <slot>=<value> (got "${tok}")`);
     const slot = tok.slice(0, eq);
     const recipe = tok.slice(eq + 1);
     assertSlotRecipe(activity, slot, recipe); // shared validity (unknown slot / invalid recipe → exit 2)
@@ -91,7 +89,7 @@ const parseArgs = (argv) => {
       json = true;
     } else if (a === '--override') {
       const tok = argv[i + 1];
-      if (tok === undefined || tok.startsWith('--')) throw fail(2, '--override requires <slot>=<recipe>');
+      if (tok === undefined || tok.startsWith('--')) throw fail(2, '--override requires <slot>=<value>');
       overrideTokens.push(tok);
       i += 1;
     } else if (a.startsWith('--override=')) {
@@ -162,30 +160,39 @@ const resolveAllSlots = ({ activity, config, detection, overrides }) => {
     }
   })();
   const knobsFor = (cmd) => [...registry.values()].filter((k) => (k.appliesTo ?? []).includes(cmd));
-  return Object.keys(ACTIVITIES[activity].slots).map((slot) => {
+  return Object.entries(ACTIVITIES[activity].slots).map(([slot, slotType]) => {
     const resolved = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity, slot, override: overrides[slot] });
+    if (isSwitchSlot(slotType)) return { slot, slotType, ...resolved, backends: [], contracts: [], vehicles: [] };
     // The concrete wrapper set this slot's EFFECTIVE recipe dispatches (empty for solo). Reuse
     // planRecipe's drift-guarded dispatch for WHICH backends, then resolve each (backend, role) to its
-    // manifest wrapper cmd via the bridge registry — no wrapper name is hand-composed here.
-    const { dispatch } = planRecipe(resolved.recipe, detection);
-    const backends = dispatch.map((d) => wrapperCmdFor(d.backend, d.role)).filter(Boolean);
+    // manifest wrapper cmd via the bridge registry — no wrapper name is hand-composed here. A vehicle
+    // step is NOT a bridge: it carries its own state and is never looked up in a manifest.
+    const { dispatch } = resolved.roster ? { dispatch: [] } : planRecipe(resolved.recipe, detection);
+    const vehicles = dispatch.filter((d) => d.vehicle != null).map((d) => ({ backend: d.backend, state: d.vehicle }));
+    const bridged = dispatch.filter((d) => d.vehicle == null);
+    const backends = bridged.map((d) => wrapperCmdFor(d.backend, d.role)).filter(Boolean);
     // The full DRIVING CONTRACT per dispatched (backend, role) — resolved HERE, on the raw dispatch
     // pairs, BEFORE they are flattened to wrapper names (the name array cannot reconstruct the role).
     // Every slot with a non-empty dispatch gets contracts — including execute=delegated; the contract
     // is NEVER gated by REVIEW_RECIPES (that set gates only the review-loop economics block).
-    const contracts = dispatch
+    const contracts = bridged
       .map((d) => ({ backend: d.backend, role: d.role, cmd: wrapperCmdFor(d.backend, d.role), contract: wrapperContractFor(d.backend, d.role) }))
       .filter((c) => c.cmd && c.contract)
       // `retired` rides along: without it this surface advertised a RETIRED key as an ordinary
       // settable knob, while the writer refuses to set it — a driving contract that contradicts the
       // tool it points at.
       .map((c) => ({ ...c, settings: knobsFor(c.cmd).map((k) => ({ key: k.key, allowed: allowedLabel(k), retired: k.retired ?? null })) }));
-    return { slot, ...resolved, backends, contracts };
+    return { slot, slotType, ...resolved, backends, contracts, vehicles };
   });
 };
 
-// An unsatisfiable EXPLICIT override is the only "warning" (loud, flagged for the agent to relay). A
-// graceful config/default degradation is reported as a per-slot reason, not a warning.
+// The routine switch reads against the EFFECTIVE carrier: the resolved recipe of the activity's
+// carrier-typed slot (registry-driven — no slot name is spelled here), solo when it has none.
+const effectiveCarrier = (slots) => slots.find((s) => s.slotType === 'carrier')?.recipe ?? 'solo';
+
+// An unsatisfiable EXPLICIT override is a warning (loud, flagged for the agent to relay); a graceful
+// config/default degradation remains a per-slot reason. Canon/registry slot-skew warnings are
+// collected separately, after the live section is read.
 const collectWarnings = (slots) =>
   slots
     .filter((s) => s.overrideUnsatisfied)
@@ -211,24 +218,34 @@ const backendSetLabel = (backends) =>
       : ` → ${backends[0]}`;
 
 // The review-loop economics block (M1 + M6's firing half) — printed when the activity engages a review
-// backend (a slot resolving reviewed | council) and OMITTED for solo. It paraphrases the procedures.md
+// member: a slot RESOLVING reviewed | council, a roster, or one whose config or override REQUESTED a
+// review recipe and degraded (readiness removes no configured obligation, and the table still judges
+// it); omitted only for a solo nobody asked to be otherwise. It paraphrases the procedures.md
 // Fold + loop step + orchestration §4 canon (no rival rule): the ≤2-round architecture cap, the bar met by RAISING a
 // surviving major to an acceptance invariant (not exhausting prose), backend divergence = the crossover
 // stop, the thin-plan/diff-review carve-out, a self-consistency read before every re-review, and the
 // REQUIRED per-round structured emission {round N · finding-origin tally · per-backend verdict}. Only a
-// review slot can resolve reviewed|council (execute floors at solo|delegated), so gate on the recipe.
+// review slot can resolve or request reviewed|council (execute floors at solo|delegated), so the gate
+// reads the recipe, the requested recipe and the roster.
 const REVIEW_RECIPES = new Set(['reviewed', 'council']);
+const CONSULT_LINE = '  • Before every fold of a finding raised by a review member (a bridge backend or a placed lens): ASK that member whether the proposed fold solves it and adds no new problem; WAIT for its answer, READ it, then edit only as accepted or corrected — agy: agy-review --continue --decided @f --focus "Finding: <finding>. Proposed fold: <exact fold>. Does this proposed fold solve the finding and add no new problem? Reply accept, or correct with exact replacement text."; codex: fresh codex-review plan <consult-brief> written before the working tree changes; a placed lens: re-dispatch the same lens vehicle with the finding and the proposed fold. A self-review finding, or any finding when no review member ran, is folded directly — the exemption is the finding\'s ORIGIN, never the recipe word on the slot line.';
+const ARMED_CONSULT_LINE = '  • ARMED pre-fold sequence for a bridge-raised finding: the round is open → dispatch that bridge\'s consult with a nonce → WAIT and READ → fold accepted or corrected → flow-writer consult-attestation <planId> --backend <id> --nonce <n> --proposed-fix-digest <the-sha256-of-the-fold-text> → then edit. A lens-raised finding re-dispatches the lens without a nonce, WAIT and READ, then edit as accepted or corrected — it mints no manifest and no attestation — only its per-round participation rides its internal-attestation.';
 // activity-aware (AD-046): the triage classification vocabulary rides EVERY review-backed activity;
 // the LEDGER pointer renders ONLY for plan-execution — the ledger is plan-execution-scoped (AD-045),
 // and pointing plan-authoring at it would send rounds of the wrong activity into the code loop's gate.
-const reviewLoopAdvice = (slots, activity) =>
-  slots.some((s) => REVIEW_RECIPES.has(s.recipe))
+// A lens-only roster resolves to `solo` and a fully degraded request resolves to `solo`: both still run
+// a review round, which is why the gate never reads the effective recipe alone.
+const reviewLoopAdvice = (slots, activity, flowArmed = false, plans = []) =>
+  slots.some((s) => s.roster != null || REVIEW_RECIPES.has(s.recipe) || REVIEW_RECIPES.has(s.degradedFrom))
     ? [
         'Review-loop economics (procedures.md Fold + loop · orchestration.md §4) — the review this recipe runs:',
+        CONSULT_LINE,
+        ...(activity === 'plan-execution' && flowArmed ? [ARMED_CONSULT_LINE] : []),
         '  • Cap architecture plan-review at ≤2 rounds; the bar is met by RAISING a surviving major to an acceptance invariant (or handing it to Execute/diff-review), never by exhausting the strictest backend.',
         '  • Backend divergence (one backend grounded-ships while another keeps revising mechanics) IS the crossover stop.',
         '  • Route an all-mechanics/CI or prose-only artifact to a thin plan + diff-review; run a self-consistency read before every re-review.',
         '  • Each round MUST emit {round N · finding-origin tally (first-draft / fold-induced / mechanics) · per-backend verdict} so the crossover is a computed signal.',
+        ...(activity === 'plan-authoring' ? roundRenderAdvice(slots, plans) : []),
         '  • At the cap, classify every surviving blocking finding: fixable-bug (fold ONCE as a red→green test, re-review) / inherent-layer-residual (document + raise to an acceptance criterion) / escalate (the maintainer decides); a minor never forces triage.',
         ...(activity === 'plan-execution'
           ? [
@@ -241,38 +258,119 @@ const reviewLoopAdvice = (slots, activity) =>
 // The grounding pre-step (AD-038, extending the AD-033 verbatim-contract rendering): whenever the
 // resolved dispatch includes agy-review, print the CONCRETE facts-assembly invocation + the
 // --facts form as a copy-paste pre-step — population, not placeholders. Plan-path population rule
-// (the review-state plan-in-flight detector): exactly ONE plan in flight → render it populated;
-// zero or several → the explicit `--plan <path>` placeholder + a one-line discovery caveat. The
+// (the review-state plan-in-flight detector): exactly ONE renderable plan in flight → render it
+// populated; zero, several, or a name a one-line render cannot carry → the explicit placeholder + a
+// one-line discovery caveat; a name the receipt encoder refuses falls back on the receipt-minting
+// or receipt-matching command only (`agy-review plan`, the round table). The
 // suggested --out lives OUTSIDE the repo (/tmp) — grounding.mjs refuses a non-scratch destination.
 // Exported for the bridge-tier byte-parity pin (AD-044 Plan 4): the velocity tier seeds the
 // grounding rule in EXACTLY this rendered spelling — `node "${GROUNDING_TOOL}"` — so seeded and
 // rendered forms can never drift apart.
 export const GROUNDING_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'grounding.mjs');
+export const REVIEW_ROUNDS_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'review-rounds-cli.mjs');
+export const REPO_SEARCH_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'repo-search.mjs');
 const GROUNDING_FACTS_OUT = '/tmp/review-facts.md';
+const MINTS_RECEIPT = Object.freeze({ mintsReceipt: true });
+
+// The round table judges what review-rounds-cli resolves from the config (S27), never this render's
+// override or degradation, so the advisor states that fact beneath the command instead of predicting
+// when the two agree; a bridge-less roster gets the fact that no receipt can exist in the command's place.
+// A requested review recipe renders the command even when every bridge is unavailable here: readiness
+// degradation removes no configured obligation, so the table still has something to say.
+const ROUND_RENDER_FACT_LINE = "  ↳ the table judges the obligation review-rounds-cli resolves from docs/ai/orchestration.json (S27) — the configured recipe, or the computed default for a silent slot — never this run's --override or a degraded recipe; it reads receipts only: a backend that did not run shows as missing (no receipts when none ran), and its degrade record is judged by review-state and core-evidence summary, not here.";
+const ROUND_RENDER_NO_BRIDGE_LINE = "  • Round render: a roster with no bridge mints no receipt, so review-rounds-cli cannot supply this round's verdicts — emit the finding-origin tally plus each lens member's verdict (or silent) directly.";
+const roundRenderAdvice = (slots, plans) => {
+  const review = slots.find((s) => s.slot === 'review');
+  if (review === undefined) return [];
+  const roster = review.roster ?? null;
+  const shouldRenderCommand = roster === null
+    ? (review.backends ?? []).length > 0 || REVIEW_RECIPES.has(review.degradedFrom)
+    : roster.some((row) => row.kind === 'bridge');
+  if (!shouldRenderCommand) return [ROUND_RENDER_NO_BRIDGE_LINE];
+  const lensMembers = (roster ?? []).filter((row) => row.kind === 'lens').map((row) => row.member);
+  const operand = populatedPlan(plans, MINTS_RECEIPT);
+  return [
+    `  • Round render (verdict half of the per-round emission; the finding-origin tally stays the orchestrator's): node ${renderToolPath(REVIEW_ROUNDS_TOOL)} --artifact ${operand ?? '<plan-file>'}`,
+    ...planDiscoveryCaveat(plans, '--artifact', 'populate --artifact with the plan file under review.', operand === null ? ['--artifact'] : []),
+    ROUND_RENDER_FACT_LINE,
+    ...(lensMembers.length > 0 ? [`  ↳ the table carries the bridge verdicts only — add each lens member's verdict (or silent) by hand: ${lensMembers.join(', ')}`] : []),
+  ];
+};
+
+// The ONE plan in flight as a pasteable operand: shell-significant bytes ride shellQuoteArg; a name a
+// one-line render cannot carry is never populated, nor one the receipt encoder refuses (S21) for a
+// command that MINTS or MATCHES a plan receipt: agy-review plan would be refused pre-spend by name, the
+// round table would match no receipt.
+const populatedPlan = (plans, { mintsReceipt = false } = {}) => {
+  if (plans.length !== 1 || !isRenderableLine(plans[0])) return null;
+  if (mintsReceipt && !isArtifactPathCarriable(plans[0])) return null;
+  return shellQuoteArg(`${PLANS_REL}/${plans[0]}`);
+};
+const planDiscoveryCaveat = (plans, flag, noPlanAction, fellBack = []) => {
+  if (plans.length === 0) return [`  ↳ plan discovery: no plan in flight under ${PLANS_REL} — ${noPlanAction}`];
+  if (plans.length > 1) return [`  ↳ plan discovery: ${plans.length} plans in flight under ${PLANS_REL} (${plans.map(escapeForDisplay).join(', ')}) — populate ${flag} with the one under review.`];
+  return fellBack.length === 0
+    ? []
+    : [`  ↳ plan discovery: the plan in flight ${escapeForDisplay(plans[0])} carries a character that either a review receipt or a rendered command cannot carry — ${fellBack.join(' and ')} ${fellBack.length === 1 ? 'stays a placeholder' : 'stay placeholders'}; rename the plan.`];
+};
+
+// The kit-tools tier seeds `Bash(node <abs>/tools/repo-search.mjs:*)` BARE (velocity-profile.mjs
+// deriveKitToolsAllowlist, the same predicate), so a seedable path renders bare — a quoted path is
+// a different prefix and the allow rule is dead. A path the tier could never seed has no rule to
+// match and is single-quoted for a safe paste (double quotes would still expand `$` and backticks).
+const renderToolPath = (abs) => (isSeedablePathToken(abs) ? abs : shellQuoteArg(abs));
+// `registered` is the registration on disk, never the tool's availability in this session — the
+// command line stays as the fallback under the typed form. `toolPath` is a test seam (an unseedable
+// kit path is not constructible from a test against the real checkout).
+const readersSweepAdvice = (activity, registered, toolPath = REPO_SEARCH_TOOL) => {
+  if (activity !== 'plan-authoring') return [];
+  return [
+    'Readers sweep (before the first review) — for every changed config key, registry entry, exported constant, receipt field or canon sentence:',
+    ...(registered ? ['  use: repo_search {"pattern": "<the literal>"} — the kit\'s read-only MCP tool (registration complete; if it is not loaded in this session, the command below)'] : []),
+    `  run: node ${renderToolPath(toolPath)} --pattern <the literal> (a pattern carrying a shell-significant byte goes through --pattern-file <f> instead)`,
+    '  classify every reader as a ledger row, a stated non-goal, or unchanged with its proof',
+  ];
+};
+
+// The canon's own claim — the kit "parses only each section's `Slots:` line" — made true: an installed
+// engine older (or newer) than this kit's registry prints its section verbatim, so the skew is SAID.
+// A section without a Slots line is a customized canon, not a skew: silent. Never the exit code.
+const SLOTS_LINE = /^Slots:[ \t]*(.+?)[ \t]*$/mu;
+const slotSkewWarning = (section, activity) => {
+  const listed = section.match(SLOTS_LINE)?.[1].split(',').map((s) => s.trim()).filter(Boolean);
+  const registry = Object.keys(ACTIVITIES[activity].slots);
+  if (listed == null || listed.join(',') === registry.join(',')) return [];
+  return [`the installed engine's canon lists slots (${listed.join(', ')}) for ${activity} while this kit's registry names (${registry.join(', ')}) — the resolved lines follow the registry; the engine and this kit are out of step — /agent-workflow-kit status names which member is behind: upgrade that one. Tell the user.`];
+};
 const groundingPreStepAdvice = (activity, slots, plans) => {
   if (!slots.some((s) => (s.backends ?? []).includes('agy-review'))) return [];
-  const planArg = plans.length === 1 ? `--plan "${PLANS_REL}/${plans[0]}"` : '--plan <path>';
-  // plan-authoring reviews the plan FILE — when exactly one plan is in flight, the review command
-  // is populated with the same discovered path (a known path never renders a placeholder).
+  const operand = populatedPlan(plans);
+  const planArg = operand === null ? '--plan <path>' : `--plan ${operand}`;
+  const reviewOperand = populatedPlan(plans, MINTS_RECEIPT);
+  // plan-authoring reviews the plan FILE — a plain name in flight renders the review command populated;
+  // the renderability and receipt-carriability fallbacks are the only placeholders a known path produces.
   const reviewForm =
     activity === 'plan-authoring'
-      ? plans.length === 1
-        ? `agy-review plan "${PLANS_REL}/${plans[0]}"`
-        : 'agy-review plan <plan-file>'
+      ? reviewOperand === null
+        ? 'agy-review plan <plan-file>'
+        : `agy-review plan ${reviewOperand}`
       : 'agy-review code';
   // `run:`/`then:` prefixes keep these POPULATED command lines machine-distinguishable from the
   // verbatim contract DESCRIPTORS above (the descriptor drift guard set-equals bare wrapper lines).
-  // Path arguments are double-quoted — a skill dir or plan name with a space must stay copy-pasteable.
+  // The TOOL path stays double-quoted (the bridge tier seeds that exact byte-form); the plan operand
+  // rides shellQuoteArg — bare when safe, single-quoted otherwise.
   const lines = [
     'Grounding pre-step (agy is dispatched — assemble the verified facts BEFORE the review; grounding.mjs slices verbatim, judgment additions stay yours):',
     `  run:  node "${GROUNDING_TOOL}" --constraints --autonomy ${planArg} --out ${GROUNDING_FACTS_OUT}`,
     `  then: ${reviewForm} --facts @${GROUNDING_FACTS_OUT}`,
   ];
-  if (plans.length === 0) {
-    lines.push(`  ↳ plan discovery: no plan in flight under ${PLANS_REL} — substitute the plan file you are reviewing against, or drop --plan for constraints+autonomy facts.`);
-  } else if (plans.length > 1) {
-    lines.push(`  ↳ plan discovery: ${plans.length} plans in flight under ${PLANS_REL} (${plans.join(', ')}) — populate --plan with the one under review.`);
-  }
+  const fellBack = [operand === null ? '--plan' : null, activity === 'plan-authoring' && reviewOperand === null ? 'agy-review plan' : null].filter(Boolean);
+  lines.push(...planDiscoveryCaveat(
+    plans,
+    '--plan',
+    'substitute the plan file you are reviewing against, or drop --plan for constraints+autonomy facts.',
+    fellBack,
+  ));
   return lines;
 };
 
@@ -410,12 +508,11 @@ const flowHalvesAdvice = (flow, probe) => {
 // plan is being written. Composed from the project's live declaration, never from constants here.
 // Each config state speaks as itself: ABSENT renders NOTHING (a project that declares no practice must
 // not be handed invented limits); AUTHORED and INCOMPLETE render the declared caps plus the honest
-// "nothing is recorded yet" line — both are pre-mint states, and treating INCOMPLETE as MINTED would
-// report a half record as the whole tree's debt; MINTED renders the recorded counts too.
+// "nothing is recorded yet" line (treating INCOMPLETE as MINTED would report a half record as the
+// whole tree's debt); MINTED renders the recorded counts too.
 // A config that cannot be read renders ONE loud line carrying the reader's own message and the render
-// still completes: the exit code for a broken source-size config belongs to the practice's own
-// checker (exit 2 there, and its declared gate reds the matrix on it), while THIS tool's exit
-// contract is about its own config and the engine.
+// still completes: the exit code for a broken source-size config belongs to the practice's own checker,
+// while THIS tool's exit contract is about its own config and the engine.
 
 export const DECLARED_PRACTICE_HEADER = `Declared source-size practice (${SOURCE_SIZE_CONFIG_REL}) — known BEFORE the code is written:`;
 
@@ -482,24 +579,34 @@ const contractLines = ({ cmd, contract, settings }) => {
   return lines;
 };
 
-const formatHuman = ({ activity, section, slots, warnings, plans, autonomy, flowHalves, declaredPractice, foldScope, specCheck }) => {
+const formatHuman = ({ activity, section, slots, warnings, plans, autonomy, flowHalves, flowArmed, readersSweep, declaredPractice, foldScope, specCheck }) => {
   const lines = [
     section,
     '',
-    `resolved recipes for "${activity}" (read-only — the orchestrator runs the recipe via the bridge skills and owns any commit; a backend never commits):`,
+    `resolved recipes for "${activity}" (read-only — the orchestrator runs the recipe via the bridge skills or the executor vehicle and owns any commit; every other carrier never commits):`,
   ];
+  const carrier = effectiveCarrier(slots);
   for (const s of slots) {
     const arrow = s.degradedFrom ? ` (requested ${s.degradedFrom} → degraded)` : '';
-    lines.push(`  ${s.slot}: ${s.recipe} — ${SOURCE_LABEL[s.source]}${arrow}${backendSetLabel(s.backends)}`);
+    // A switch slot states what the flag DOES under the effective carrier; both keep the source suffix.
+    lines.push(isSwitchSlot(s.slotType)
+      ? `  ${parallelLine({ value: s.recipe, carrier })} — ${SOURCE_LABEL[s.source]}`
+      : `  ${s.slot}: ${s.recipe} — ${SOURCE_LABEL[s.source]}${arrow}${backendSetLabel(s.backends)}`);
     if (s.reason) lines.push(`      ↳ ${s.reason}`);
+    // The form replaces the one-line vehicle mention: a carrier never told how to carry is a name,
+    // not an instruction. Indented like the driving contracts beside it.
+    for (const v of s.vehicles ?? []) {
+      for (const line of dispatchForm({ activity, slot: s.slot, state: v.state })) lines.push(`      ${line}`);
+    }
     for (const c of s.contracts ?? []) lines.push(...contractLines(c));
   }
   if ((flowHalves ?? []).length) lines.push('', ...flowHalves);
   const autonomyBlock = autonomyAdvice(activity, autonomy);
   if (autonomyBlock.length) lines.push('', ...autonomyBlock);
+  if (readersSweep.length) lines.push('', ...readersSweep);
   const grounding = groundingPreStepAdvice(activity, slots, plans);
   if (grounding.length) lines.push('', ...grounding);
-  const advice = reviewLoopAdvice(slots, activity);
+  const advice = reviewLoopAdvice(slots, activity, flowArmed, plans);
   if (advice.length) lines.push('', ...advice);
   if (foldScope.length) lines.push('', ...foldScope);
   if (specCheck.length) lines.push('', ...specCheck);
@@ -512,15 +619,19 @@ const formatHuman = ({ activity, section, slots, warnings, plans, autonomy, flow
   return lines.join('\n');
 };
 
-const buildJson = ({ activity, section, slots, configSource, warnings, plans, autonomy, flowHalves, declaredPractice, foldScope, specCheck }) => ({
+const buildJson = ({ activity, section, slots, configSource, warnings, plans, autonomy, flowHalves, flowArmed, readersSweep, declaredPractice, foldScope, specCheck }) => ({
   activity,
   section,
   slots: Object.fromEntries(
     // `backends: string[]` is the STABLE pre-existing shape (wrapper names) — never repurposed.
     // `contracts` is the ADDITIVE per-dispatch driving-contract field (empty for solo).
-    slots.map((s) => [s.slot, { recipe: s.recipe, source: s.source, degradedFrom: s.degradedFrom, reason: s.reason, backends: s.backends, contracts: s.contracts }]),
+    slots.map((s) => [s.slot, {
+      recipe: s.recipe, source: s.source, degradedFrom: s.degradedFrom, reason: s.reason, backends: s.backends, contracts: s.contracts,
+      ...(s.roster ? { roster: s.roster } : {}),
+    }]),
   ),
-  reviewLoop: reviewLoopAdvice(slots, activity),
+  reviewLoop: reviewLoopAdvice(slots, activity, flowArmed, plans),
+  readersSweep,
   // ADDITIVE (AD-038): the populated grounding pre-step, structured (empty when agy is not dispatched).
   groundingPreStep: groundingPreStepAdvice(activity, slots, plans),
   // ADDITIVE (cost-tiered execution): the unconditional cost-lane advisory, structured.
@@ -544,16 +655,17 @@ const buildJson = ({ activity, section, slots, configSource, warnings, plans, au
 const HELP = `procedures — read-only activity-procedures advisor for the agent-workflow family.
 
 Usage:
-  node procedures.mjs <activity> [--override <slot>=<recipe>]... [--json]
+  node procedures.mjs <activity> [--override <slot>=<value>]... [--json]
 
 Activities: ${Object.keys(ACTIVITIES).join(', ')}
-Slots:      plan-authoring → review;  plan-execution → execute, review
-Recipes:    review accepts solo|reviewed|council;  execute accepts solo|delegated
+Slots:      ${Object.entries(ACTIVITIES).map(([a, d]) => `${a} → ${Object.keys(d.slots).join(', ')}`).join(';  ')}
+Accepted values: ${Object.entries(SLOT_RECIPES).map(([type, values]) => `${type} accepts ${values.join('|')}`).join(';  ')}
 
 Reads the activity's procedure steps LIVE from the installed agent-workflow-engine
 (references/procedures.md), resolves the effective recipe per slot from
-${CONFIG_REL} + the read-only backend detector, and prints both. A per-run
---override <slot>=<recipe> (repeatable) overrides the configured/default recipe for that slot.
+${CONFIG_REL} + the read-only backend detector plus the executor-vehicle survey, and prints
+both. A per-run
+--override <slot>=<value> (repeatable) overrides the configured/default recipe for that slot.
 Read-only: never writes, never commits, never runs a subscription CLI.
 
 Also prints the project's DECLARED source-size practice (${SOURCE_SIZE_CONFIG_REL}) when it declares
@@ -582,20 +694,19 @@ export const main = (argv, ctx = {}) => {
     const { activity, overrides, json } = parseArgs(argv);
     const { config, source: configSource } = loadConfig(cwd, readFile, lstat);
     const section = extractSection(readProceduresCanon(env, home), activity);
-    // Backend detection is a SECONDARY input — it only refines the recipe. A corrupt / unreadable backend
-    // must NOT fail activity resolution as a config/engine error (exit 1, outside the contract): treat all
-    // backends as not-ready (resolution floors at Solo) and surface the failure as a loud warning, exit 0.
+    // Readiness is a SECONDARY input — it only refines the recipe. A corrupt bridge must NOT fail
+    // activity resolution as a config/engine error: the detector-failure hook floors the bridge half
+    // at not-ready and warns (exit 0), while the surveyed executor vehicle survives untouched.
     const detectWarnings = [];
-    let detection = [];
-    try {
-      detection = detect();
-    } catch (err) {
-      detectWarnings.push(
-        `backend detection failed (${(err && err.message) || err}) — treating all backends as not ready; recipes needing a backend degrade to solo.`,
-      );
-    }
+    const detection = composeReadiness(cwd, {
+      detect,
+      surveyVehicle: ctx.surveyVehicle,
+      onDetectError: (err) => detectWarnings.push(
+        `backend detection failed (${(err && err.message) || err}) — treating every bridge as not ready; recipes needing a bridge degrade to solo (the executor vehicle is unaffected).`,
+      ),
+    });
     const slots = resolveAllSlots({ activity, config, detection, overrides });
-    const warnings = [...detectWarnings, ...collectWarnings(slots)];
+    const warnings = [...detectWarnings, ...collectWarnings(slots), ...slotSkewWarning(section, activity)];
     const plans = plansInFlight(cwd);
     // The autonomy facts (AD-044 Plan 4): resolved levels + red-lines from the policy file. A
     // malformed policy renders LOUDLY in the block AND flips the exit to 1 (config error) — the
@@ -615,13 +726,16 @@ export const main = (argv, ctx = {}) => {
     // The flow armed-halves block (P8): probed ONLY when the config carries a flow block — an
     // unarmed project keeps byte-identical output (human AND JSON) and never pays the store probe.
     const flowProbe = ctx.flowProbe ?? defaultFlowProbe;
-    const flowHalves = config?.flow == null ? null : flowHalvesAdvice(config.flow, flowProbe(cwd));
+    const flowState = config?.flow == null ? null : flowProbe(cwd);
+    const flowHalves = flowState == null ? null : flowHalvesAdvice(config.flow, flowState);
+    const registrationReader = ctx.readRegistration ?? readRegistration;
+    const readersSweep = readersSweepAdvice(activity, activity === 'plan-authoring' && registrationReader(cwd).registered, ctx.repoSearchTool);
     const declaredPractice = declaredPracticeAdvice(cwd, readFile, lstat);
     const foldScope = foldScopeAdvice(activity, config, plans);
     const specCheck = specCheckAdvice(activity);
     const stdout = json
-      ? JSON.stringify(buildJson({ activity, section, slots, configSource, warnings, plans, autonomy, flowHalves, declaredPractice, foldScope, specCheck }), null, 2)
-      : formatHuman({ activity, section, slots, warnings, plans, autonomy, flowHalves, declaredPractice, foldScope, specCheck });
+      ? JSON.stringify(buildJson({ activity, section, slots, configSource, warnings, plans, autonomy, flowHalves, flowArmed: flowState?.armed === true, readersSweep, declaredPractice, foldScope, specCheck }), null, 2)
+      : formatHuman({ activity, section, slots, warnings, plans, autonomy, flowHalves, flowArmed: flowState?.armed === true, readersSweep, declaredPractice, foldScope, specCheck });
     if (autonomy?.error) {
       return { code: 1, stdout, stderr: `procedures: malformed ${AUTONOMY_REL} — ${autonomy.error}` };
     }