@aiwg/cli 2026.10.1 → 2026.10.4

package/dist/src/mcp/tools/orchestration.mjs

@@ -160,15 +160,25 @@ export function registerFlowToolset(server) {
     description: 'Fetch a declarative Flow playbook by name, including parsed step summary and the wrapper skill path when present.',
     inputSchema: {
       name: z.string().describe('Flow name or playbook file name (e.g. flow-release)'),
+      bound_rule_bodies: z.boolean().optional().describe('Include full bound rule bodies'),
       framework: z.string().optional().describe('Optional framework disambiguator'),
     },
     annotations: { readOnlyHint: true, openWorldHint: false },
-  }, async ({ name, framework }) => {
+  }, async ({ name, framework, bound_rule_bodies }) => {
     try {
       const flow = await findFlow(name, framework);
       if (!flow) return mcpError(`flow-show: flow not found: ${name}`);
       flow.wrapper_skill.exists = await pathExists(flow.wrapper_skill.path);
-      return mcpJson(flow);
+      const { stdout, stderr, code } = await runAiwgCli([
+        'show', 'flow', flow.path, '--json',
+        ...(bound_rule_bodies ? ['--bound-rule-bodies'] : []),
+      ]);
+      if (code !== 0) return mcpError(`flow-show binding lookup failed: ${stderr}`);
+      const shown = JSON.parse(stdout);
+      return mcpJson({ ...flow, ...(shown.bound_rules ? { bound_rules: shown.bound_rules,
+        ...(shown.required_rule_checks ? { required_rule_checks: shown.required_rule_checks } : {}),
+        ...(shown.rule_stats ? { rule_stats: shown.rule_stats } : {}),
+        ...(shown.rule_check_obligation ? { rule_check_obligation: shown.rule_check_obligation } : {}) } : {}) });
     } catch (err) {
       return mcpError(`flow-show: ${err.message}`);
     }
@@ -215,6 +225,7 @@ export function registerFlowToolset(server) {
 }
 
 export function registerMissionToolset(server) {
+  registerWorkerResolveTool(server);
   server.registerTool('mission-guide', {
     title: 'Show AIWG Mission Primitive',
     description: 'Fetch the aiwg-mission kernel skill. This is the AIWG-owned Mission primitive; it is distinct from the lower-level mc-* Mission Control toolset.',
@@ -318,3 +329,40 @@ export function registerMissionToolset(server) {
     }
   });
 }
+
+/** Frozen B-OG-33/35 read-only surface; the CLI and MCP share the typed renderer. */
+export function registerWorkerResolveTool(server) {
+  server.registerTool('worker-resolve', {
+    title: 'Resolve Worker Invocation',
+    description: 'Resolve a nonlaunching qualified worker plan without Mission or MC state.',
+    inputSchema: z.object({
+      role: z.enum(['efficiency', 'coding', 'reasoning']),
+      task: z.string().min(1),
+      group: z.string().min(1).regex(/^[a-z][a-z0-9-]{0,62}$/),
+      brief: z.string().min(1),
+      workdir: z.string().min(1),
+      final_output: z.string().min(1),
+      transport: z.enum(['shell', 'mcp']).default('shell'),
+      format: z.enum(['shell', 'json']).optional(),
+      project_dir: z.string().min(1).optional(),
+    }).strict(),
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+  }, async input => {
+    try {
+      const args = ['models', 'resolve'];
+      for (const [key, value] of Object.entries(input)) {
+        if (key === 'project_dir' || key === 'format') continue;
+        args.push(`--${key === 'final_output' ? 'final-output' : key}=${value}`);
+      }
+      const format = input.format ?? 'json';
+      args.push(`--format=${format}`);
+      const { stdout, stderr, code } = await runAiwgCli(args, { cwd: input.project_dir, timeoutMs: 30000 });
+      if (format === 'shell') {
+        return { ...mcpJson(stdout || stderr), ...(code === 0 ? {} : { isError: true }) };
+      }
+      let plan;
+      try { plan = JSON.parse(stdout); } catch { return mcpError(`worker-resolve failed (exit ${code}): ${stderr}`); }
+      return { ...mcpJson(plan), ...(code === 0 ? {} : { isError: true }) };
+    } catch (error) { return mcpError(`worker-resolve: ${error.message}`); }
+  });
+}

package/dist/src/mcp/tools/subsystems.mjs

@@ -17,6 +17,7 @@
 import { z } from 'zod';
 import { runAiwgCli, mcpError, mcpJson } from '../helpers.mjs';
 import { registerFlowToolset, registerMissionToolset } from './orchestration.mjs';
+import { registerWorkerInvokeToolset, WORKERS_TOOLSET_NAME } from './worker-invoke.mjs';
 import { registerAgenticSandboxToolset } from './agentic-sandbox.mjs';
 import { registerDecisionToolset } from './decision.mjs';
 
@@ -572,6 +573,9 @@ function registerOpsToolset(server) {
 const TOOLSET_REGISTRY = {
   flows: registerFlowToolset,
   missions: registerMissionToolset,
+  // #2892: bounded direct worker run/status/cancel. Explicit opt-in name
+  // ONLY — see WILDCARD_EXCLUDED_TOOLSETS below for why `all` cannot reach it.
+  [WORKERS_TOOLSET_NAME]: registerWorkerInvokeToolset,
   memory: (server) => {
     registerStorageSubsystem(server, STORAGE_SUBSYSTEMS.find(s => s.name === 'memory'));
     registerStorageSubsystem(server, STORAGE_SUBSYSTEMS.find(s => s.name === 'reflections'));
@@ -592,6 +596,14 @@ const TOOLSET_REGISTRY = {
   decision: registerDecisionToolset,
 };
 
+/**
+ * Toolsets that a bare `all` must NOT silently enable. Enabling these
+ * requires naming them explicitly in the AIWG_MCP_TOOLSETS list (#2892
+ * defect 4: a worker-invoke bridge must not become reachable just because
+ * an operator wanted "every read-only discovery toolset" via `all`).
+ */
+const WILDCARD_EXCLUDED_TOOLSETS = new Set([WORKERS_TOOLSET_NAME]);
+
 /**
  * Parse AIWG_MCP_TOOLSETS env or `--toolsets` CLI value into a Set.
  *
@@ -601,18 +613,19 @@ const TOOLSET_REGISTRY = {
  * Examples:
  *   AIWG_MCP_TOOLSETS=flows,missions,ralph
  *   AIWG_MCP_TOOLSETS=core,memory          (core is implicit; harmless)
- *   AIWG_MCP_TOOLSETS=all                  (all known toolsets)
+ *   AIWG_MCP_TOOLSETS=all                  (all known toolsets EXCEPT `workers`,
+ *                                            which needs an explicit opt-in)
+ *   AIWG_MCP_TOOLSETS=all,workers          (explicit opt-in on top of `all`)
  */
 export function parseToolsets(value) {
   if (!value || typeof value !== 'string') return new Set();
   const items = value.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
-  if (items.includes('all')) {
-    return new Set(Object.keys(TOOLSET_REGISTRY));
-  }
-  const out = new Set();
   const known = new Set(Object.keys(TOOLSET_REGISTRY));
+  const out = items.includes('all')
+    ? new Set([...known].filter((name) => !WILDCARD_EXCLUDED_TOOLSETS.has(name)))
+    : new Set();
   for (const item of items) {
-    if (item === 'core') continue;  // always on
+    if (item === 'core' || item === 'all') continue;  // 'core' always on; 'all' handled above
     if (!known.has(item)) {
       console.error(`[AIWG MCP] Unknown toolset: "${item}" — known: core, ${[...known].join(', ')}, all`);
       continue;
@@ -624,16 +637,34 @@ export function parseToolsets(value) {
 
 /**
  * Register all opt-in toolsets requested via env/flag.
+ *
+ * `options` is passed through to every registration function; only `workers`
+ * (#2892 B1) consumes it (`projectRoot`, pinned at registration — the served
+ * root must be resolved by the caller, e.g. `server.mjs`'s `findProjectRoot()`,
+ * never defaulted to `process.cwd()` here). Every other registration
+ * function in `TOOLSET_REGISTRY` is synchronous and ignores the extra arg.
+ *
+ * This function is `async` (returns a `Promise`) because `workers`'
+ * registration does real async work (realpath the root, resolve the default
+ * concurrency cap) before it calls `server.registerTool`. Calling it WITHOUT
+ * `await` is still safe for every other toolset: each registration function
+ * is invoked synchronously inside the loop below, so a purely-synchronous
+ * toolset's `server.registerTool` calls complete before this function's
+ * first (and only) `await` is ever reached — only `workers`'s own Promise is
+ * deferred into `pending`, and only an `await`ing caller needs to wait on it.
  */
-export function registerOptInToolsets(server, toolsets) {
+export async function registerOptInToolsets(server, toolsets, options = {}) {
   const enabled = [];
+  const pending = [];
   for (const name of toolsets) {
     const fn = TOOLSET_REGISTRY[name];
     if (fn) {
-      fn(server);
+      const result = fn(server, options);
+      if (result && typeof result.then === 'function') pending.push(result);
       enabled.push(name);
     }
   }
+  if (pending.length > 0) await Promise.all(pending);
   if (enabled.length > 0) {
     console.error(`[AIWG MCP] Opt-in toolsets enabled: ${enabled.join(', ')}`);
   } else {