@sabaiway/agent-workflow-kit 14.27.0 → 14.28.0

package/tools/bridge-wiring.mjs

@@ -0,0 +1,196 @@
+// bridge-wiring.mjs — the leaf that judges the project sandbox's coverage of ready bridges.
+// Contract: bridges/velocity-profile, part bridge-wiring. Dependency-free, Node >= 22.
+// No side effects on import.
+
+import { closeSync, constants, fstatSync, openSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { bundledSandboxRecipe, usedBridges } from './bridge-sandbox-recipe.mjs';
+import { missingStateDirs, stateDirsOf } from './bridge-state-dirs.mjs';
+import { loadConfig } from './orchestration-config.mjs';
+import { BACKEND_PRIORITY } from './carriers.mjs';
+import { READY } from './detect-backends.mjs';
+
+export const HOST_HONORS_QUALIFIER = 'where the host honors the settings sandbox keys';
+export const WIRED = 'wired';
+export const UNWIRED = 'not wired';
+export const UNCHECKED = 'unchecked';
+export const WIRING_ROUTE = 'wire it on the chat yes of /agent-workflow-kit upgrade';
+export const WIRING_ROUTE_UNUSED = 'no slot uses it for review — once one does, the chat yes of /agent-workflow-kit upgrade wires it';
+export const SANDBOX_ENABLED_CONDITION = `enabled in the project settings — ready means wired ${HOST_HONORS_QUALIFIER}`;
+export const SANDBOX_NOT_ENABLED_CONDITION = 'not enabled in the project settings — ready means installed';
+
+const PROJECT_FILE = 'settings.json';
+const LOCAL_FILE = 'settings.local.json';
+const SETTINGS_DIR = '.claude';
+const UTF8 = 'utf8';
+const ABSENT = 'ENOENT';
+const NOT_REGULAR = 'not a regular file';
+const REVIEW = 'review';
+const COVERED = 'covered';
+const NOT_COVERED = 'not covered';
+const ENABLED = 'enabled';
+const SANDBOX = 'sandbox';
+const SURFACE_KEYS = Object.freeze(['excludedCommands', 'hosts', 'dirs']);
+
+const isPlainObject = (value) => value !== null && typeof value === 'object'
+  && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+
+const assertObject = (value, key) => {
+  if (!isPlainObject(value)) throw new Error(`${key} must be a plain JSON object`);
+  return value;
+};
+
+const sandboxOf = (data, file) => {
+  if (data === undefined) return undefined;
+  assertObject(data, file);
+  if (!Object.hasOwn(data, SANDBOX)) return undefined;
+  return assertObject(data.sandbox, `${file}: sandbox`);
+};
+
+export const sandboxEnabled = (projectData, localData) => {
+  const project = sandboxOf(projectData, PROJECT_FILE);
+  const local = sandboxOf(localData, LOCAL_FILE);
+  const useLocal = local !== undefined && Object.hasOwn(local, ENABLED);
+  const judged = useLocal ? local : project;
+  const file = useLocal ? LOCAL_FILE : PROJECT_FILE;
+  if (judged === undefined || !Object.hasOwn(judged, ENABLED)) return false;
+  if (typeof judged.enabled !== 'boolean') throw new Error(`${file}: enabled must be a boolean`);
+  return judged.enabled === true;
+};
+
+const readObjectKey = (object, key) => {
+  if (!Object.hasOwn(object, key)) return {};
+  return assertObject(object[key], key);
+};
+
+const readArrayKey = (object, key) => {
+  if (!Object.hasOwn(object, key)) return [];
+  if (!Array.isArray(object[key])) throw new Error(`${key} must be an array`);
+  return object[key];
+};
+
+export const sandboxSurfaceDelta = (recipe, sandbox, { home, root }) => {
+  const base = sandbox === undefined ? {} : assertObject(sandbox, SANDBOX);
+  const exclusions = readArrayKey(base, 'excludedCommands');
+  const network = readObjectKey(base, 'network');
+  const filesystem = readObjectKey(base, 'filesystem');
+  const hosts = readArrayKey(network, 'allowedDomains');
+  const allowWrite = readArrayKey(filesystem, 'allowWrite');
+  if (allowWrite.some((entry) => typeof entry !== 'string' || entry.trim().length === 0)) {
+    throw new Error('allowWrite entries must be non-blank strings');
+  }
+  return {
+    excludedCommands: recipe.excludedCommands.filter((entry) => !exclusions.includes(entry)),
+    hosts: recipe.hosts.filter((entry) => !hosts.includes(entry)),
+    dirs: missingStateDirs(recipe.dirs, allowWrite, { home, root }),
+  };
+};
+
+const emptyDelta = () => ({ excludedCommands: [], hosts: [], dirs: [] });
+const countDelta = (delta) => SURFACE_KEYS.reduce((total, key) => total + delta[key].length, 0);
+const unionDeltas = (deltas) => Object.fromEntries(SURFACE_KEYS.map((key) => [
+  key, [...new Set(deltas.flatMap((delta) => delta[key]))],
+]));
+
+// One non-blocking descriptor for the type check and the read: a FIFO swapped in at the path never blocks.
+const readRegular = (path) => {
+  const descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+  try {
+    if (!fstatSync(descriptor).isFile()) throw new Error(NOT_REGULAR);
+    return readFileSync(descriptor, UTF8);
+  } finally {
+    closeSync(descriptor);
+  }
+};
+
+const readSettings = (root, file) => {
+  const path = join(root, SETTINGS_DIR, file);
+  const raw = (() => {
+    try {
+      return readRegular(path);
+    } catch (error) {
+      if (error?.code === ABSENT) return undefined;
+      throw new Error(`${file}: ${error?.message ?? error}`);
+    }
+  })();
+  if (raw === undefined) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${file}: ${error?.message ?? error}`);
+  }
+};
+
+const baseEntry = (bridge) => ({
+  bridge,
+  roles: [],
+  used: false,
+  state: WIRED,
+  review: COVERED,
+  missing: emptyDelta(),
+  count: 0,
+  reason: null,
+  route: null,
+  reviewRoute: null,
+});
+
+const judgeBridge = (bridge, used, sandbox, context, deps) => {
+  const roles = used.find((entry) => entry.bridge === bridge)?.roles ?? [];
+  const judgedRoles = roles.length === 0 ? [REVIEW] : roles;
+  const deltas = new Map([...new Set([...judgedRoles, REVIEW])].map((role) => {
+    const recipe = bundledSandboxRecipe([{ bridge, roles: [role] }], deps);
+    if (recipe.excludedCommands.length === 0) {
+      throw new Error(`bundled manifest ${join(bridge, 'capability.json')} missing or lacking roles.${role}.cmd`);
+    }
+    const dirs = stateDirsOf(recipe.dirEntries, context);
+    return [role, sandboxSurfaceDelta({ ...recipe, dirs }, sandbox, context)];
+  }));
+  const missing = unionDeltas(judgedRoles.map((role) => deltas.get(role)));
+  const count = countDelta(missing);
+  const isUsed = roles.length !== 0;
+  const reviewMissing = countDelta(deltas.get(REVIEW)) !== 0;
+  return {
+    ...baseEntry(bridge),
+    roles,
+    used: isUsed,
+    state: count === 0 ? WIRED : UNWIRED,
+    review: reviewMissing ? NOT_COVERED : COVERED,
+    missing,
+    count,
+    route: count === 0 ? null : (isUsed ? WIRING_ROUTE : WIRING_ROUTE_UNUSED),
+    reviewRoute: reviewMissing ? (roles.includes(REVIEW) ? WIRING_ROUTE : WIRING_ROUTE_UNUSED) : null,
+  };
+};
+
+export const composeBridgeWiring = ({ root, readiness }, deps = {}) => {
+  const ready = BACKEND_PRIORITY.filter((bridge) => readiness.some((row) => row.name === bridge && row.readiness === READY));
+  try {
+    const project = readSettings(root, PROJECT_FILE);
+    const local = readSettings(root, LOCAL_FILE);
+    if (!sandboxEnabled(project, local)) {
+      return {
+        enabled: false,
+        reason: null,
+        condition: SANDBOX_NOT_ENABLED_CONDITION,
+        bridges: ready.map(baseEntry),
+      };
+    }
+    if (deps.preflight) deps.preflight();
+    const config = (deps.loadConfig ?? loadConfig)(root).config;
+    const used = usedBridges(config, readiness);
+    const context = { root, env: deps.env ?? process.env, home: deps.home ?? homedir() };
+    const bridges = ready.map((bridge) => judgeBridge(bridge, used, project?.sandbox, context, deps));
+    return { enabled: true, reason: null, condition: SANDBOX_ENABLED_CONDITION, bridges };
+  } catch (error) {
+    const reason = String(error?.message ?? error).replace(/[\r\n]+/g, ' ');
+    return {
+      enabled: null,
+      reason,
+      condition: `${UNCHECKED} — ${reason}`,
+      bridges: ready.map((bridge) => ({
+        ...baseEntry(bridge), state: UNCHECKED, review: UNCHECKED, reason,
+      })),
+    };
+  }
+};

package/tools/manifest/schema.md

@@ -100,20 +100,21 @@ drift-guarded set-equal to this block by the bridge `bin/*.test.mjs` suites (hel
 `networkHosts` declares the hosts the backend CLI is **observed** to contact (synthetic examples:
 `*.api.backend.example`, `accounts.backend.example`; the real observed lists live in each bridge's
 `capability.json`) — the **single source** of the hosts `velocity-profile --bridge-tier` seeds
-into the project's `sandbox.network.allowedDomains` for every used bridge, and of a hand-applied
-session sandbox allowlist. Rules:
+into the project's `sandbox.network.allowedDomains` for every used bridge. Rules:
 
 - Each entry is a bare dotted hostname or a `*.family` wildcard — never a scheme/path/port.
-  Entries must be unique. A malformed list **fails** `--strict` (the entries are pasted verbatim
-  into allowlist lines by the Recommendations advisor).
+  Entries must be unique. A malformed list **fails** `--strict` (the tier writes the entries into
+  `sandbox.network.allowedDomains` and the Recommendations advisor renders them on its
+  `bridge-tier` item's `recipe:` line).
 - **The `--bridge-tier` seed is the primary lane** (AD-172): for every used bridge it merges
   hosts into the project's `sandbox.network.allowedDomains` beside the wrapper's `<wrapper> *`
   exclusion (`codex-exec *` for the execution wrapper). A settings-native harness that drops the
   exclusion still admits them; that pre-allow widens egress
-  for **every** sandboxed command, which the tier's consent states. The **hand-apply** fallback
-  stays for a harness-managed sandbox that ignores the settings keys.
+  for **every** sandboxed command, which the tier's consent states. A harness-managed sandbox
+  that ignores the settings keys keeps the harness's own controls — its scoped rules, a session
+  allowance, its consent at the point of action — and the kit writes no shape for it.
 - Observed-minimal, honestly incomplete: a blocked host names itself at run time — extend the
-  hand-applied list by hand; the manifest list records what was actually observed.
+  manifest list where it was observed; the list records what was actually observed.
 
 ## Writable dirs (REC-UX-REWORK, D6)
 
@@ -124,8 +125,8 @@ declared path is only the **default under no override**. Rules:
 
 - Each entry: `env` is `null` or an **UPPER_SNAKE_CASE env-var name**; `default` is a
   **`~/`-anchored or absolute POSIX path** — no globs, no trailing slash, no `..` traversal.
-  Defaults must be unique. A malformed list **fails** `--strict` (the resolved dir is rendered
-  into a hand-applied recipe line by the Recommendations advisor).
+  Defaults must be unique. A malformed list **fails** `--strict` (the resolved dir is written into
+  `sandbox.filesystem.allowWrite` and rendered on the Recommendations advisor's one-line `recipe:` line).
 - **Resolution is the advisor's, at run time, mirroring the wrapper's byte-semantics:** a
   NON-EMPTY env value wins (an EMPTY env value ≡ unset — the `${VAR:-default}` form); the
   wrapper's exact case-arms apply — `~`, `~/…` and absolute forms ride as-given, EVERY other
@@ -135,8 +136,8 @@ declared path is only the **default under no override**. Rules:
   (the wrapper itself anchors to its invocation `$PWD`); else the `default` applies.
 - **The `--bridge-tier` seeds every used bridge's state dirs**, home-relative under the home
   (absolute outside it), into `sandbox.filesystem.allowWrite` beside the wrapper's `<wrapper> *`
-  exclusion (`codex-exec *` for the execution wrapper) — the entries feed the
-  sandbox-lane discoverability item (session/host sandbox config is hand-applied territory).
+  exclusion (`codex-exec *` for the execution wrapper) — the advisor's `bridge-tier` item counts
+  and names each missing dir.
 
 ## Mode catalog (BRIDGE-MODES-CATALOG)
 

package/tools/manifest/validate.mjs

@@ -638,10 +638,10 @@ export const validateManifest = (skillDir) => {
   }
 
   // `networkHosts` (AD-044 Plan 4, consult-locked): the backend CLI's OBSERVED egress host
-  // families. `velocity-profile --bridge-tier` seeds them into sandbox.network.allowedDomains for
-  // placed bridges (AD-172; the pre-allow widens egress for EVERY sandboxed command, stated at that
-  // consent), and a malformed list FAILS --strict like `settings`: the tier writes it and the
-  // Recommendations advisor renders it verbatim, so a bad entry would corrupt a seeded line.
+  // families. `velocity-profile --bridge-tier` seeds them into sandbox.network.allowedDomains
+  // for USED bridges (a recipe slot uses them, revision 4; AD-172); the pre-allow widens egress for EVERY
+  // sandboxed command, stated at that consent. A malformed list FAILS --strict like `settings`:
+  // the tier writes it and the Recommendations advisor renders it verbatim, so a bad entry would corrupt a seeded line.
   const networkHosts = manifest.networkHosts;
   if (networkHosts != null) {
     if (!Array.isArray(networkHosts) || networkHosts.length === 0) {
@@ -659,11 +659,11 @@ export const validateManifest = (skillDir) => {
     }
   }
 
-  // `writableDirs` (REC-UX-REWORK, D6): the backend CLI's writable state-dir declarations —
-  // {env, default} entries the Recommendations advisor RESOLVES at run time (a NON-EMPTY env
-  // value wins, else the default) and renders into the sandbox-lane recipe. Unlike `networkHosts`
-  // this is a DOCUMENTATION source (the kit never seeds filesystem allowances), and a malformed
-  // list FAILS --strict for the same reason: the resolved dir is rendered into a hand-applied line.
+  // `writableDirs` (REC-UX-REWORK, D6): {env, default} entries the tier RESOLVES (a NON-EMPTY
+  // env value wins, else the default) and seeds home-relative into sandbox.filesystem.allowWrite
+  // for USED bridges via `bridge-state-dirs.mjs`; the advisor's `bridge-tier` item counts and names them.
+  // A malformed list FAILS --strict: the resolved dir is written into the settings and rendered
+  // on the Recommendations advisor's ONE-LINE `recipe:` line.
   const writableDirs = manifest.writableDirs;
   if (writableDirs != null) {
     if (!Array.isArray(writableDirs) || writableDirs.length === 0) {
@@ -685,8 +685,8 @@ export const validateManifest = (skillDir) => {
           return;
         }
         if (/[*?[\]]/.test(dir)) errors.push(`${at}.default must not carry glob characters ("${dir}")`);
-        // The resolved dir is rendered into a ONE-LINE hand-applied recipe — a control character
-        // (newline, CR, NUL, …) would break the line or the shell paste.
+        // The resolved dir is written into `allowWrite` and rendered on a ONE-LINE advisor line —
+        // a control character (newline, CR, NUL, …) would break that line or the settings entry.
         // eslint-disable-next-line no-control-regex
         if (/[\x00-\x1f\x7f]/.test(dir)) errors.push(`${at}.default must not carry control characters (${JSON.stringify(dir)})`);
         if (dir.endsWith('/')) errors.push(`${at}.default must not end with a trailing slash ("${dir}")`);

package/tools/recipes.mjs

@@ -40,6 +40,12 @@ export { ACTIVITIES, POLICY_ACTIVITIES, SLOT_RECIPES, isSwitchSlot, EXECUTOR_APP
 
 const [CODEX, AGY] = BACKEND_PRIORITY;
 
+// Mirror bridge-wiring.mjs states: a static import would cycle through bridge-sandbox-recipe.mjs.
+const WIRED = 'wired';
+const UNWIRED = 'not wired';
+const UNCHECKED = 'unchecked';
+const NOT_COVERED = 'not covered';
+
 // Keyed by readiness-array provider name; executor is the only `carry` provider.
 export const BACKEND_ROLES = {
   [CODEX]: ['execute', 'review'],
@@ -237,6 +243,20 @@ export const recommendRecipe = (detection) => {
   return { recipe: 'solo', clause: `Solo — ${DISPLAY_ALIASES[best.name] ?? best.name}: ${remedy} to unlock Reviewed` };
 };
 
+const orderedWiringEntries = (wiring) => [...(wiring?.bridges ?? [])]
+  .sort((a, b) => priorityIndex(a.bridge) - priorityIndex(b.bridge));
+
+export const recommendWiredRecipe = (detection, wiring) => {
+  const base = recommendRecipe(detection);
+  const entries = orderedWiringEntries(wiring);
+  const uncovered = entries.filter((entry) => entry.review === NOT_COVERED)
+    .map((entry) => `${DISPLAY_ALIASES[entry.bridge] ?? entry.bridge} (review) — ${entry.reviewRoute}`).join('; ');
+  const unchecked = entries.filter((entry) => entry.review === UNCHECKED)
+    .map((entry) => DISPLAY_ALIASES[entry.bridge] ?? entry.bridge).join(', ');
+  const tail = (uncovered ? ` · ${UNWIRED}: ${uncovered}` : '') + (unchecked ? ` · ${UNCHECKED}: ${unchecked}` : '');
+  return tail ? { recipe: base.recipe, clause: base.clause + tail } : base;
+};
+
 // ── activity procedures: per-slot recipe resolution ────────────────────────────────
 // The computed default for a silent slot. NEVER Council (opt-in: it spends two backends' quota) and
 // deliberately not recommendRecipe, which drives the status line rather than a per-slot default.
@@ -317,14 +337,26 @@ export const composeConfiguredPosture = (ctx = {}) => {
 // mode, and only the recipe lattice sees it.
 export const bridgeEntries = (readiness) => readiness.filter((b) => b.name !== EXECUTOR_PROVIDER);
 
-export const composeStatusLine = (detection, recommendation, settings = null, autonomy = null, posture = null) => {
+export const composeStatusLine = (detection, recommendation, settings = null, autonomy = null, posture = null, wiring = null) => {
+  // A raw env value may carry newlines/control chars — collapse them so the one-line contract holds.
+  const oneLine = (s) => String(s).replace(/[\s]+/g, ' ').trim();
   const backends = bridgeEntries(detection)
     .sort((a, b) => priorityIndex(a.name) - priorityIndex(b.name))
-    .map((b) => `${DISPLAY_ALIASES[b.name] ?? b.name} ${b.readiness === READY ? '✓' : '✗'} ${b.readiness}`)
+    .map((b) => {
+      const alias = DISPLAY_ALIASES[b.name] ?? b.name;
+      const entry = b.readiness === READY ? wiring?.bridges.find((row) => row.bridge === b.name) : null;
+      if (entry && entry.state !== WIRED) {
+        if (entry.state === UNWIRED) {
+          return `${alias} ✗ ${UNWIRED}${entry.used ? '' : ' (unused)'} — ${entry.count} sandbox entr(ies) missing`;
+        }
+        if (entry.state === UNCHECKED) return `${alias} ✗ ${UNCHECKED} — ${oneLine(entry.reason)}`;
+      }
+      return `${alias} ${b.readiness === READY ? '✓' : '✗'} ${b.readiness}`;
+    })
     .join(' · ');
-  const base = `backends: ${backends} — run /agent-workflow-kit backends · recipes: ${recommendation.clause} — see /agent-workflow-kit recipes`;
-  // A raw env value may carry newlines/control chars — collapse them so the one-line contract holds.
-  const oneLine = (s) => String(s).replace(/[\s]+/g, ' ').trim();
+  const clause = wiring == null ? recommendation.clause : recommendWiredRecipe(detection, wiring).clause;
+  const base = `backends: ${backends} — run /agent-workflow-kit backends · recipes: ${clause} — see /agent-workflow-kit recipes`;
+  const sandboxSegment = wiring == null ? '' : ` · sandbox: ${oneLine(wiring.condition)}`;
   const active = settings?.active ?? [];
   // A RETIRED knob renders as retired: hiding the user's line would be a silent deletion, reading it
   // as active would claim a capability the wrapper no longer has.
@@ -332,7 +364,7 @@ export const composeStatusLine = (detection, recommendation, settings = null, au
   // Each optional segment renders ONLY when its facts are supplied; an omitted param changes nothing.
   const autonomySegment = autonomy == null ? '' : ` · autonomy: ${oneLine(formatAutonomySegment(autonomy))}`;
   const postureSegment = posture == null ? '' : ` · posture: ${oneLine(posture)}`;
-  return base + suffix + autonomySegment + postureSegment;
+  return base + sandboxSegment + suffix + autonomySegment + postureSegment;
 };
 
 const formatAutonomySegment = (a) => {
@@ -432,7 +464,7 @@ export const composeActiveRecipeLine = ({ config, source } = {}, detection, auto
 // ── report + CLI ─────────────────────────────────────────────────────────────────
 
 // The structured report behind `--json`, incl. the same one-line status the --status-line mode emits.
-export const buildReport = (detection, settings = null, autonomy = null, posture = null) => {
+export const buildReport = (detection, settings = null, autonomy = null, posture = null, wiring = null) => {
   const recommendation = recommendRecipe(detection);
   return {
     recipes: RECIPES.map(({ id, title, role, minBackends, degradesTo, summary }) => ({
@@ -446,19 +478,31 @@ export const buildReport = (detection, settings = null, autonomy = null, posture
     recommendation,
     plans: RECIPES.map((r) => planRecipe(r.id, detection)),
     // The --json envelope must never expose a status line staler than the --status-line surface.
-    statusLine: composeStatusLine(detection, recommendation, settings, autonomy, posture),
+    statusLine: composeStatusLine(detection, recommendation, settings, autonomy, posture, wiring),
+    ...(wiring == null ? {} : { wiring }),
   };
 };
 
 // Deterministic human advisor text: the recipes, the recommendation, and the per-recipe plan here.
-export const formatRecipes = (detection) => {
+export const formatRecipes = (detection, wiring = null) => {
   const lines = [
     'agent-workflow orchestration recipes (read-only — the orchestrator executes via the bridge skills or the executor vehicle and always commits)',
     '',
   ];
   for (const r of RECIPES) lines.push(`  ${r.title} (${r.id}) — ${r.summary}`);
-  const rec = recommendRecipe(detection);
-  lines.push('', `recommended here: ${rec.recipe} — ${rec.clause}`, '', 'plan for the current environment:');
+  const rec = wiring == null ? recommendRecipe(detection) : recommendWiredRecipe(detection, wiring);
+  lines.push('', `recommended here: ${rec.recipe} — ${rec.clause}`);
+  for (const entry of orderedWiringEntries(wiring)) {
+    const alias = DISPLAY_ALIASES[entry.bridge] ?? entry.bridge;
+    if (entry.state === UNWIRED) {
+      const missing = [['excludedCommands', entry.missing.excludedCommands], ['allowedDomains', entry.missing.hosts], ['allowWrite', entry.missing.dirs]]
+        .filter(([, entries]) => entries.length)
+        .map(([key, entries]) => `${key} [${entries.join(', ')}]`).join('; ');
+      lines.push(`  ${UNWIRED}: ${alias} — missing ${missing}; ${wiring.condition}; ${entry.route}`);
+    }
+    if (entry.state === UNCHECKED) lines.push(`  ${UNCHECKED}: ${alias} — ${entry.reason}`);
+  }
+  lines.push('', 'plan for the current environment:');
   for (const r of RECIPES) {
     const p = planRecipe(r.id, detection);
     const arrow = p.degraded ? ` → ${p.effective}` : '';
@@ -493,6 +537,15 @@ export const composeReadiness = (cwd, deps = {}) => {
   return withVehicle(detection, survey);
 };
 
+// The wiring the status line, --json and the default output render. Lazy imports: the leaf reaches
+// this module through bridge-sandbox-recipe.mjs. A failed import fails the run loudly.
+const composeWiring = async (cwd, readiness) => {
+  const { composeBridgeWiring } = await import('./bridge-wiring.mjs');
+  const { preflightVelocityProfile } = await import('./velocity-profile.mjs');
+  const root = projectTopOf(cwd);
+  return composeBridgeWiring({ root, readiness }, { preflight: () => preflightVelocityProfile({ cwd: root }) });
+};
+
 const main = async (argv, deps = {}) => {
   if (argv.includes('--help') || argv.includes('-h')) {
     console.log(`recipes — read-only orchestration-recipe advisor for the agent-workflow family.
@@ -510,7 +563,13 @@ CONFIGURED recipe per activity/slot, resolved from the per-project docs/ai/orche
 from the current directory) + live readiness, with degradation stated and each activity's autonomy
 level beside its cells; paste it verbatim at session start / into the handover "Active recipes:" slot.
 --json emits the structured report (incl. the same line as \`statusLine\`); the three are mutually
-exclusive. Detection only — never writes, never commits, never runs a subscription CLI.`);
+exclusive. Detection only — never writes, never commits, never runs a subscription CLI.
+
+Where the project settings enable the sandbox, a ready bridge whose sandbox entries they lack
+reads "<alias> ✗ not wired — <n> sandbox entr(ies) missing" ("not wired (unused)" when no slot
+uses it), one that cannot be judged "<alias> ✗ unchecked — <reason>"; the status line carries
+" · sandbox: <condition>" after the recipes pointer, and the default output lists the missing
+entries and the route per bridge.`);
     return;
   }
   const unknown = argv.find((a) => !KNOWN_ARGS.has(a));
@@ -525,6 +584,7 @@ exclusive. Detection only — never writes, never commits, never runs a subscrip
   }
   const cwd = process.cwd();
   const readiness = composeReadiness(cwd, deps);
+  const wiring = argv.includes('--active-line') ? null : await composeWiring(cwd, readiness);
   if (argv.includes('--active-line')) {
     // Lazy: orchestration-config.mjs statically imports this module — no static cycle.
     const { loadConfig } = await import('./orchestration-config.mjs');
@@ -541,12 +601,12 @@ exclusive. Detection only — never writes, never commits, never runs a subscrip
     }
   } else if (argv.includes('--status-line')) {
     const snapshot = settingsSnapshot();
-    console.log(composeStatusLine(readiness, recommendRecipe(readiness), snapshot, await composeAutonomyFacts(cwd), composeConfiguredPosture({ settings: snapshot })));
+    console.log(composeStatusLine(readiness, recommendRecipe(readiness), snapshot, await composeAutonomyFacts(cwd), composeConfiguredPosture({ settings: snapshot }), wiring));
   } else if (argv.includes('--json')) {
     const snapshot = settingsSnapshot();
-    console.log(JSON.stringify(buildReport(readiness, snapshot, await composeAutonomyFacts(cwd), composeConfiguredPosture({ settings: snapshot })), null, 2));
+    console.log(JSON.stringify(buildReport(readiness, snapshot, await composeAutonomyFacts(cwd), composeConfiguredPosture({ settings: snapshot }), wiring), null, 2));
   }
-  else console.log(formatRecipes(readiness));
+  else console.log(formatRecipes(readiness, wiring));
   return 0;
 };