@sabaiway/agent-workflow-kit 10.3.0 → 10.4.0

package/tools/family-registry.mjs

@@ -28,7 +28,7 @@ import { parseSemver, compareSemver } from './semver-lite.mjs';
 import { validateManifest, readAuthoritativeVersion, UNSUPPORTED, INVALID } from './manifest/validate.mjs';
 import { START_MARKER, excludePath, inferVisibility } from './hide-footprint.mjs';
 import { readEngineFragment, ORCHESTRATION_FRAGMENT_REL, PROCEDURES_FRAGMENT_REL, AUTONOMY_FRAGMENT_REL, LENS_FRAGMENT_REL, LENS_PRIORS_REL } from './engine-source.mjs';
-import { ACTIVITIES, resolveActivityRecipe } from './recipes.mjs';
+import { ACTIVITIES, resolveActivityRecipe, composeReadiness, safeLine } from './recipes.mjs';
 // The config reader lives in orchestration-config.mjs (the single config contract). The read-only status
 // settings-survey reuses THIS reader (one strict-JSON + loud-on-malformed contract), not a second copy.
 import { loadConfig } from './orchestration-config.mjs';
@@ -52,9 +52,10 @@ import { HOOK_FILE_REL as GATE_HOOK_FILE_REL, isHookWired } from './gate-hook.mj
 // writer, which pulls in the atomic-write core) so the status survey stays a pure reader.
 import { settingsSnapshot } from './bridge-settings-read.mjs';
 import { GATES_REL, loadDeclaration } from './run-gates.mjs';
-// The cheap-agents writer's own bundle reader + placement planner — reused by the settings survey
-// (one implementation, never a drifting copy; cheap-agents imports only node builtins, no cycle).
-import { readBundledAgents, planPlacement } from './cheap-agents.mjs';
+// The cheap-agents READ core's bundle reader, placement planner and executor-vehicle survey —
+// reused by the settings survey (one implementation, never a drifting copy; the read core imports
+// only node builtins, no cycle).
+import { readBundledAgents, planPlacement, surveyExecutorVehicle, EXECUTOR_VEHICLE, assertDirSafe, readFsDeps, CLAUDE_DIR, AGENTS_DIR } from './cheap-agents-read.mjs';
 // The status vocabulary (manifestState constants, internal→public maps, display names, the no-leak
 // forbidden set) lives in the frozen labels.mjs LEAF (Plan §4.2 B1) so the import graph is acyclic —
 // nothing imports family-registry for vocabulary. Imported here for internal use; the public subset is
@@ -486,9 +487,6 @@ export const surveyProject = (projectDir, deps = {}) => {
 // consumes THIS, never the human table verbatim. An envelope-shape test pins its shape so later phases
 // (the settings/visibility block) can't silently break the Phase-2 version consumer.
 
-// STATE_PUBLIC (internal→public token map) + DISPLAY_NAMES + displayOf now live in labels.mjs (B1) —
-// imported at the top of this file. They are used below exactly as before.
-
 // ── the settings survey (Phase 3) — read-only, honest, localized-on-error ──────────
 // Each sub-survey returns a small user-safe object OR a single `{ error }` field (a localized message,
 // never a crash): a malformed/unreadable file in ONE area must not break the rest of `status`. The
@@ -527,19 +525,21 @@ export const surveyVisibility = (dir, deps = {}) => {
 };
 
 // orchestration recipes: the EFFECTIVE recipe per slot (config · default · effective), engine-free —
-// shared loadConfig + resolveActivityRecipe + the read-only backend detector. A malformed config → a
-// localized error field; a detection failure floors at solo (a corrupt bridge must not break the view).
+// shared loadConfig + resolveActivityRecipe + the ONE readiness composition (detected backends +
+// the executor vehicle). A malformed config → a localized error field; a detection failure floors
+// at solo (a corrupt bridge must not break the view) but is surfaced as `detectError`, so the
+// render says "couldn't check backends" instead of letting a real solo-default look identical.
 export const surveyRecipes = (dir, deps = {}) => {
-  // A detector failure floors recipes at solo (mirrors procedures) but is surfaced as `detectError`, so
-  // the render says "couldn't check backends" instead of letting a real solo-default look identical.
   const { detection, error: detectError } = detectSafe(deps);
+  const projectDir = resolve(dir);
+  const readiness = composeReadiness(projectDir, { ...deps, detect: () => detection });
   try {
-    const { config, source } = loadConfig(resolve(dir), deps.readFile ?? readFileSync, deps.lstat ?? lstatSync);
+    const { config, source } = loadConfig(projectDir, deps.readFile ?? readFileSync, deps.lstat ?? lstatSync);
     const activities = {};
     for (const [activity, def] of Object.entries(ACTIVITIES)) {
       activities[activity] = {};
       for (const slot of Object.keys(def.slots)) {
-        const r = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity, slot });
+        const r = resolveActivityRecipe({ config: config ?? {}, readiness, activity, slot });
         activities[activity][slot] = { recipe: r.recipe, source: r.source, degradedFrom: r.degradedFrom ?? null };
       }
     }
@@ -616,14 +616,34 @@ export const surveyGateHook = (dir, deps = {}) => {
 };
 
 // cheap agents: the kit-placed .claude/agents/ vehicles (Mode: agents) — how many of the bundled
-// cheap-lane definitions are present in the project. A customized copy counts as PLACED (it exists;
-// the writer preserves it) — the welcome-mat agents rung keys on zero placed. Read-only; REUSES the
-// writer's own bundle reader + placement planner (cheap-agents.mjs — one implementation).
+// definitions are present in the project, plus the ONE full-tool vehicle's own state. A customized
+// copy counts as PLACED (it exists; the writer preserves it) — the welcome-mat agents rung keys on
+// zero placed, so the counts span every vehicle, the executor included. The executor state comes
+// from the read core's survey (the subagent carrier's one instrument — one implementation), which
+// answers a state instead of throwing; its reason rides along when it carries one.
 export const surveyCheapAgents = (dir, deps = {}) => {
   try {
+    const projectDir = resolve(dir);
     const templates = readBundledAgents(deps);
-    const plan = planPlacement(templates, resolve(dir), deps);
-    return { bundled: templates.length, placed: plan.filter((p) => p.action !== 'place').length };
+    const vehicle = (deps.surveyVehicle ?? surveyExecutorVehicle)(projectDir, deps);
+    // The executor is judged by its own survey (which answers a state where the placement plan
+    // would throw); the plan covers the read-only vehicles, so a broken executor never hides them,
+    // and it never follows a symlinked ancestor — the writer's own guard refuses first.
+    const executor = { executor: vehicle.state, ...(vehicle.reason ? { executorReason: safeLine(vehicle.reason) } : {}) };
+    try {
+      const fs = readFsDeps(deps);
+      assertDirSafe(join(projectDir, CLAUDE_DIR), CLAUDE_DIR, fs);
+      assertDirSafe(join(projectDir, AGENTS_DIR), AGENTS_DIR, fs);
+      const plan = planPlacement(templates.filter((t) => t.name !== EXECUTOR_VEHICLE), projectDir, deps);
+      return {
+        bundled: templates.length,
+        readOnly: templates.filter((t) => t.name !== EXECUTOR_VEHICLE).length,
+        placed: plan.filter((p) => p.action !== 'place').length + (['placed', 'customized'].includes(vehicle.state) ? 1 : 0),
+        ...executor,
+      };
+    } catch (err) {
+      return { error: localizeError(err), ...executor };
+    }
   } catch (err) {
     return { error: localizeError(err) };
   }

package/tools/flow-check.mjs

@@ -29,8 +29,7 @@ import {
   resolveReceiptsPath, readReceipts, computeTreeFingerprint,
 } from './core-evidence.mjs';
 import { loadConfig } from './orchestration-config.mjs';
-import { requiredBackendsForConfiguredRecipe, DISPLAY_ALIASES } from './recipes.mjs';
-import { detectBackends } from './detect-backends.mjs';
+import { requiredBackendsForConfiguredRecipe, DISPLAY_ALIASES, composeReadiness } from './recipes.mjs';
 import { decideFlowCheck } from './flow-check-cores.mjs';
 import { short } from './flow-check-rungs.mjs';
 import {
@@ -116,11 +115,7 @@ export const computeFlowDecision = ({ cwd = process.cwd(), consumer = 'gate', pr
     let readiness = [];
     let detectionFailed = false;
     if (configFailure == null && config?.['plan-execution']?.review == null) {
-      try {
-        readiness = detectBackends();
-      } catch {
-        detectionFailed = true;
-      }
+      readiness = composeReadiness(top, { ...probes, onDetectError: () => { detectionFailed = true; } });
     }
     const obligations = configFailure == null
       ? requiredBackendsForConfiguredRecipe({ config, readiness, detectionFailed })

package/tools/inject-methodology.mjs

@@ -86,10 +86,14 @@ export const KNOWN_PRIOR_METHODOLOGY_SLOT = [
   '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. Full vocabulary, lifecycle, and the plan-then-execute split live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe.',
   // engine 2.1.0 — the pre-canon-rewrite pointer (vocabulary + plan-then-execute wording, with the communication contract).
   '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. Full vocabulary, lifecycle, and the plan-then-execute split live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe. **Communication:** user-facing messages deliver the artifact inline (paste the prompt / diff / command — never "see §X" as a substitute), lead with the result, show exactly what was asked, and never read as mockery (a large artifact: a real summary inline + a link).',
+  // engine 4.2.0 — the two-activity pointer, before `routine` joined the named activities.
+  '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. The plan shape, its caps and lifecycle live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe. **Communication:** user-facing messages deliver the artifact inline (paste the prompt / diff / command — never "see §X" as a substitute), lead with the result, show exactly what was asked, and never read as mockery (a large artifact: a real summary inline + a link).',
 ];
 export const KNOWN_PRIOR_ORCH_SLOT = [
   // v1.3.0 — pre-read-at-start orchestration pointer (recipes vocabulary, no orchestration.json clause).
   '> **Orchestration recipes** — compose plan → execute → review with a named recipe: **Solo** (no backend), **Reviewed** (one backend reviews), **Council** (both review, you synthesize), **Delegated** (a backend executes a bounded sub-task); the orchestrator always commits, a backend is never autonomous. Pick + plan one for this environment with `/agent-workflow-kit recipes` (read-only); the deployed how/why lives in your `docs/ai/` workflow docs.',
+  // engine 4.2.0 — the four-recipe pointer with the read-at-start clause, before the Subagent carrier joined the list.
+  '> **Orchestration recipes** — compose plan → execute → review with a named recipe: **Solo** (no backend), **Reviewed** (one backend reviews), **Council** (both review, you synthesize), **Delegated** (a backend executes a bounded sub-task); the orchestrator always commits, a backend is never autonomous. Pick + plan one for this environment with `/agent-workflow-kit recipes` (read-only); the deployed how/why lives in your `docs/ai/` workflow docs. At the start of a planning/execution session, read your standing recipe preference in `docs/ai/orchestration.json` — set it in plain language with `/agent-workflow-kit set-recipe` (previews first; hand-edit stays supported).',
 ];
 
 // A slot descriptor bundles everything the generic engine needs to operate on ONE marker pair.

package/tools/orchestration-config.mjs

@@ -68,7 +68,7 @@ export const assertSlotRecipe = (activity, slot, recipe, exitCode = 2) => {
   if (!(SLOT_RECIPES[slotType] ?? []).includes(recipe)) {
     throw fail(
       exitCode,
-      `invalid recipe "${recipe}" for ${slotType} slot of "${activity}" (${slotType} accepts: ${SLOT_RECIPES[slotType].join(', ')})`,
+      `invalid value "${recipe}" for ${slotType} slot of "${activity}" (${slotType} accepts: ${SLOT_RECIPES[slotType].join(', ')})`,
     );
   }
   return slotType;
@@ -98,14 +98,14 @@ const parseQualified = (lhs, flag) => {
 export const parseOp = (kind, token) => {
   if (kind === 'set') {
     const eq = token.indexOf('=');
-    if (eq <= 0) throw fail(2, `--set must be <activity>.<slot>=<recipe> (got "${token}")`);
+    if (eq <= 0) throw fail(2, `--set must be <activity>.<slot>=<value> (got "${token}")`);
     const recipe = token.slice(eq + 1);
-    if (!recipe) throw fail(2, `--set must be <activity>.<slot>=<recipe> (got "${token}")`);
+    if (!recipe) throw fail(2, `--set must be <activity>.<slot>=<value> (got "${token}")`);
     const { activity, slot } = parseQualified(token.slice(0, eq), '--set');
     assertSlotRecipe(activity, slot, recipe);
     return { kind: 'set', activity, slot, recipe };
   }
-  if (token.includes('=')) throw fail(2, `--unset takes <activity>.<slot> without a recipe (got "${token}")`);
+  if (token.includes('=')) throw fail(2, `--unset takes <activity>.<slot> without a value (got "${token}")`);
   const { activity, slot } = parseQualified(token, '--unset');
   assertSlot(activity, slot);
   return { kind: 'unset', activity, slot };
@@ -245,7 +245,7 @@ export const validateConfig = (config) => {
       if (typeof recipe !== 'string' || !(SLOT_RECIPES[slotType] ?? []).includes(recipe)) {
         throw fail(
           1,
-          `${CONFIG_REL}: invalid recipe "${recipe}" for ${slotType} slot of "${key}" (${slotType} accepts: ${SLOT_RECIPES[slotType].join(', ')})`,
+          `${CONFIG_REL}: invalid value "${recipe}" for ${slotType} slot of "${key}" (${slotType} accepts: ${SLOT_RECIPES[slotType].join(', ')})`,
         );
       }
     }
@@ -361,19 +361,40 @@ export const CANON_README =
   "Per-project orchestration config: the recipe used at each step (slot) of each named activity. " +
   "Easiest: tell the agent in plain language and run the `set-recipe` writer — it interprets your intent, " +
   "previews the change, and writes valid JSON for you. You can still hand-edit this file directly whenever you " +
-  "prefer; that option never goes away. Each activity is configured independently (e.g. plan-authoring, " +
-  "plan-execution), and so is each slot within it. A slot's value is a recipe: a 'review' slot accepts " +
+  "prefer; that option never goes away. Three activities are configured independently, and so is each slot " +
+  "within them: 'plan-authoring' (slots author, review), 'plan-execution' (slots execute, review) and " +
+  "'routine' (slots carrier, parallel). A slot's value is a recipe: a 'review' slot accepts " +
   "solo | reviewed | council (you self-review / one backend reviews / both review and you synthesize); an " +
-  "'execute' slot accepts solo | delegated (you implement / a backend runs a bounded sub-task). The default " +
-  "below is 'solo' everywhere — no execution backend required. Raise a slot to reviewed or council for a second " +
-  "opinion, or to delegated to hand off execution; those need an execution backend set up first. Remove a slot's " +
-  "line (or run `set-recipe --unset <activity>.<slot>`) to fall back to the computed default (reviewed when a " +
-  "review backend is ready, otherwise solo). Run the read-only procedures advisor to see an activity's steps " +
-  "plus the recipe resolved for your environment. Strict JSON — no comments.";
+  "'execute' slot accepts solo | delegated | subagent (you implement / a backend runs a bounded sub-task / a " +
+  "full-tool frontier subagent carries a bounded slice you verify); the carrier slots 'plan-authoring.author' " +
+  "and 'routine.carrier' accept solo | subagent. 'routine.parallel' is a flag rather than a recipe: it accepts " +
+  "on | off and decides whether file-disjoint subagent slices dispatch concurrently. The default below is " +
+  "'solo' for every recipe and carrier slot, and 'on' for the parallel switch — no execution backend required. " +
+  "Raise a slot to reviewed or council for a second " +
+  "opinion, or to delegated to hand off execution; those need an execution backend set up first. 'subagent' " +
+  "needs the executor vehicle placed in this project — the composition root's `agents` writer places it; without " +
+  "it the slot resolves to solo with the reason stated. Remove a slot's line, or a whole activity block (or " +
+  "run `set-recipe --unset <activity>.<slot>`), to fall back to the computed default: reviewed when a review " +
+  "backend is ready and otherwise solo for a review slot, solo for author, execute and carrier, on for " +
+  "parallel. Run the read-only procedures advisor to see an activity's steps plus the recipe resolved for " +
+  "your environment. Strict JSON — no comments.";
 
 export const KNOWN_PRIOR_README = [
   // v1 (pre-set-recipe) — the "Hand-edit this file — it is never written for you" note. APPEND-ONLY.
   "Per-project orchestration config: the recipe used at each step (slot) of each named activity. Hand-edit this file — it is never written for you. Each activity is configured independently (e.g. plan-authoring, plan-execution), and so is each slot within it. A slot's value is a recipe: a 'review' slot accepts solo | reviewed | council (you self-review / one backend reviews / both review and you synthesize); an 'execute' slot accepts solo | delegated (you implement / a backend runs a bounded sub-task). The default below is 'solo' everywhere — no execution backend required. Raise a slot to reviewed or council for a second opinion, or to delegated to hand off execution; those need an execution backend set up first. Remove a slot's line to fall back to the computed default (reviewed when a review backend is ready, otherwise solo). Run the read-only procedures advisor to see an activity's steps plus the recipe resolved for your environment, and pass a per-run override to change one slot just once. Strict JSON — no comments.",
+  // v2 (two activities, an `execute` slot without a carrier) — the note that shipped before AD-124.
+  "Per-project orchestration config: the recipe used at each step (slot) of each named activity. Easiest: tell " +
+  "the agent in plain language and run the `set-recipe` writer — it interprets your intent, previews the change, " +
+  "and writes valid JSON for you. You can still hand-edit this file directly whenever you prefer; that option " +
+  "never goes away. Each activity is configured independently (e.g. plan-authoring, plan-execution), and so is " +
+  "each slot within it. A slot's value is a recipe: a 'review' slot accepts solo | reviewed | council (you " +
+  "self-review / one backend reviews / both review and you synthesize); an 'execute' slot accepts solo | " +
+  "delegated (you implement / a backend runs a bounded sub-task). The default below is 'solo' everywhere — no " +
+  "execution backend required. Raise a slot to reviewed or council for a second opinion, or to delegated to hand " +
+  "off execution; those need an execution backend set up first. Remove a slot's line (or run `set-recipe --unset " +
+  "<activity>.<slot>`) to fall back to the computed default (reviewed when a review backend is ready, otherwise " +
+  "solo). Run the read-only procedures advisor to see an activity's steps plus the recipe resolved for your " +
+  "environment. Strict JSON — no comments.",
 ];
 
 // refreshReadme(config) → { config, changed }: refresh ONLY the `_README` value when it normalize-

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,7 +26,9 @@ 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.
@@ -34,19 +36,15 @@ 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.
+// 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';
 // The declared source-size practice (D-17 U1), read through the practice's PURE READ core — never
@@ -57,18 +55,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 +88,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,28 +159,36 @@ 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.
+    // 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 } = planRecipe(resolved.recipe, detection);
-    const backends = dispatch.map((d) => wrapperCmdFor(d.backend, d.role)).filter(Boolean);
+    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 };
   });
 };
 
+// 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 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.
 const collectWarnings = (slots) =>
@@ -410,12 +415,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:`;
 
@@ -486,12 +490,21 @@ const formatHuman = ({ activity, section, slots, warnings, plans, autonomy, flow
   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);
@@ -544,16 +557,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,18 +596,17 @@ 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 plans = plansInFlight(cwd);