@aiwg/cli 2026.10.3 → 2026.10.5

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

@@ -202,10 +202,12 @@ export function registerDecisionToolset(server) {
       context: z.string().optional(),
       threshold: z.number().min(0).max(1).default(0.8),
       timeout_ms: z.number().int().positive().default(15000),
+      passes: z.number().int().positive().optional(),
+      escalation_passes: z.number().int().positive().optional(),
       caller: z.string().optional().describe('Optional decision-point attribution tag, recorded in the decision ledger (#2946)'),
     },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
-  }, async ({ question, yes_no, choices, scale, context, threshold, timeout_ms, caller }) => {
+  }, async ({ question, yes_no, choices, scale, context, threshold, timeout_ms, passes, escalation_passes, caller }) => {
     const modeCount = (yes_no ? 1 : 0) + (choices ? 1 : 0) + (scale ? 1 : 0);
     if (modeCount !== 1) throw new Error('Select exactly one of yes_no, choices, or scale');
     const driverModule = await driver();
@@ -216,22 +218,21 @@ export function registerDecisionToolset(server) {
       ...(context === undefined ? {} : { context }),
       threshold,
       timeoutMs: timeout_ms,
+      ...(passes === undefined ? {} : { passes }),
+      ...(escalation_passes === undefined ? {} : { escalationPasses: escalation_passes }),
     };
-    const result = await driverModule.askDecision(input, opts);
-    // Every decision-ask call records through the same ledger function the CLI
-    // `ask` handler uses, tagged with this tool's transport (#2946). Attribution
-    // resolution and the write both happen inside recordDecisionAsk's own
-    // bounded, never-throwing step (review r1 findings 3 and 4): a provider-
-    // detection failure, a slow/failed write, or an invalid caller tag can
-    // never replace `result` with an error or hold up this tool call.
     const sanitizedCaller = typeof caller === 'string' && driverModule.ATTRIBUTION_FIELD_PATTERN.test(caller) ? caller : null;
-    await driverModule.recordDecisionAsk(input, result, {
+    const invocation = await driverModule.runDecisionOffloadCheckpoint(input, {
       transport: 'mcp',
       projectRoot: opts.cwd,
       env: opts.env,
-      caller: sanitizedCaller,
+      caller: sanitizedCaller ?? 'decision-mcp:ask',
+      ledgerCaller: sanitizedCaller,
+      category: sanitizedCaller ? undefined : 'unattributed',
+      askRuntime: opts,
     });
-    return result;
+    if (!invocation.result) throw invocation.error ?? new Error('Decision ask was skipped');
+    return invocation.result;
   }, ASK);
 
   registerJsonTool(server, 'decision-setup-synthetic-classification', {

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

@@ -23,21 +23,22 @@
 
 import { z } from 'zod';
 import { runAiwgCli, mcpError, mcpJson, AIWG_ROOT } from '../helpers.mjs';
-import fs from 'node:fs/promises';
 import path from 'node:path';
+import { pinContainedRoot, readContainedFile, listContainedFiles, validateContainedPath } from '../../utils/contained-filesystem.mjs';
 
 /**
  * Register discovery tools on the MCP server.
  *
  * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
  */
-export function registerDiscoveryTools(server) {
+export function registerDiscoveryTools(server, { corpusStore } = {}) {
+  const store = corpusStore ? Promise.resolve(corpusStore) : pinContainedRoot(path.resolve(AIWG_ROOT));
   // ============================================================
   // discover — cross-type semantic search
   // ============================================================
   server.registerTool('discover', {
     title: 'Discover AIWG Capabilities',
-    description: 'Semantic search across AIWG operational assets: skills, agents, commands, rules, flows, runbooks, templates, and behaviors. Returns ranked candidates with capability summaries. Mirrors `aiwg discover --json`.',
+    description: 'Semantic search across AIWG operational assets: skills, agents, commands, rules, flows, runbooks, templates, and behaviors. Returns ranked candidates with capability summaries, governing rules, rule stats, and required fetch-and-follow checks before governed work. Mirrors `aiwg discover --json`.',
     inputSchema: {
       phrase: z.string().describe('Natural-language capability description (e.g. "create intake form")'),
       type: z.enum(['skill', 'agent', 'command', 'rule', 'flow', 'runbook', 'template', 'behavior']).optional().describe('Restrict to one artifact type'),
@@ -84,12 +85,13 @@ export function registerDiscoveryTools(server) {
     title: 'Show AIWG Skill',
     description: 'Fetch the full body of an AIWG SKILL.md by name. Returns path + content envelope.',
     inputSchema: {
+      bound_rule_bodies: z.boolean().optional().describe('Include full bound rule bodies'),
       name: z.string().describe('Skill name (slug; e.g. "intake-wizard")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name }) => {
+  }, async ({ name, bound_rule_bodies }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'skill', name, '--json']);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'skill', name, '--json', ...(bound_rule_bodies ? ['--bound-rule-bodies'] : [])]);
       if (code !== 0) return mcpError(`skill-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {
@@ -138,6 +140,27 @@ export function registerDiscoveryTools(server) {
   // ============================================================
   // rule-list / rule-show  (#1320)
   // ============================================================
+  server.registerTool('rule-inventory', {
+    title: 'Inventory configured AIWG rules',
+    description: 'Inspect scoped rule configuration and activation without asserting native session loading. Mirrors aiwg rules inventory --json.',
+    inputSchema: {
+      scope: z.enum(['workspace', 'user', 'installation', 'catalog']).default('workspace'),
+      capability: z.string().optional(), activation: z.string().optional(),
+      tier: z.string().optional(), provider: z.string().optional(), bodies: z.boolean().default(false),
+    },
+    annotations: { readOnlyHint: true },
+  }, async ({ scope, capability, activation, tier, provider, bodies }) => {
+    try {
+      const args = ['rules', 'inventory', '--scope', scope ?? 'workspace', '--json'];
+      for (const [flag, value] of [['--capability', capability], ['--activation', activation], ['--tier', tier], ['--provider', provider]]) {
+        if (value) args.push(flag, value);
+      }
+      if (bodies) args.push('--bodies');
+      const { stdout, code, stderr } = await runAiwgCli(args);
+      if (code !== 0) return mcpError(`rule-inventory failed: ${stderr || stdout}`);
+      return mcpJson(stdout);
+    } catch (err) { return mcpError(`rule-inventory: ${err.message}`); }
+  });
   server.registerTool('rule-list', {
     title: 'List AIWG Rules',
     description: 'Enumerate AIWG enforcement rules (e.g. skill-discovery, no-attribution, anti-laziness, citation-policy). Top-7 CRITICAL/HIGH rules are inlined into Hermes AGENTS.md priming (skill-discovery added #1347); this tool reaches the rest.',
@@ -181,12 +204,13 @@ export function registerDiscoveryTools(server) {
     title: 'Show AIWG Agent Definition',
     description: 'Fetch the full agent definition (system prompt + frontmatter) by name.',
     inputSchema: {
+      bound_rule_bodies: z.boolean().optional().describe('Include full bound rule bodies'),
       name: z.string().describe('Agent name (e.g. "test-engineer", "security-auditor")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name }) => {
+  }, async ({ name, bound_rule_bodies }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'agent', name, '--json']);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'agent', name, '--json', ...(bound_rule_bodies ? ['--bound-rule-bodies'] : [])]);
       if (code !== 0) return mcpError(`agent-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {
@@ -207,7 +231,7 @@ export function registerDiscoveryTools(server) {
     annotations: { readOnlyHint: true },
   }, async ({ framework, filter }) => {
     try {
-      const results = await scanTemplates(AIWG_ROOT, { framework, filter });
+      const results = await scanTemplates(await store, { framework, filter });
       return mcpJson({ count: results.length, templates: results });
     } catch (err) {
       return mcpError(`template-list: ${err.message}`);
@@ -223,21 +247,27 @@ export function registerDiscoveryTools(server) {
     annotations: { readOnlyHint: true },
   }, async ({ template }) => {
     try {
-      // Allow caller to pass either a corpus-relative path or just the template filename
-      const candidates = [
-        path.join(AIWG_ROOT, 'agentic/code/frameworks', template),
-        path.join(AIWG_ROOT, 'agentic/code/frameworks/sdlc-complete/templates', template),
-        path.resolve(template),
-      ];
-      for (const c of candidates) {
+      validateContainedPath(template);
+      // Preserve corpus-relative and template-relative selection, but never
+      // try cwd/absolute candidates. Each candidate is read through one pin.
+      const root = await store;
+      const frameworks = 'agentic/code/frameworks';
+      const [framework, ...parts] = template.split('/');
+      const candidates = template.startsWith(`${frameworks}/`)
+        ? [template]
+        : [
+          `${frameworks}/${template}`,
+          `${frameworks}/${framework}/templates/${parts.join('/')}`,
+          `${frameworks}/sdlc-complete/templates/${template}`,
+        ];
+      for (const candidate of candidates) {
+        // Only template subtrees, including basename selection, are eligible.
+        if (!/^agentic\/code\/frameworks\/[^/]+\/templates\/.+/.test(candidate)) continue;
         try {
-          // Anti-traversal: ensure resolved path stays inside AIWG_ROOT
-          const resolved = path.resolve(c);
-          if (!resolved.startsWith(path.resolve(AIWG_ROOT))) continue;
-          const content = await fs.readFile(resolved, 'utf-8');
-          return mcpJson({ path: resolved, content });
+          const content = await readContainedFile(root, candidate);
+          if (content !== null) return mcpJson({ path: path.join(root.root, candidate), content });
         } catch {
-          // try next
+          // Try the next contained candidate; no alternate root is adopted.
         }
       }
       return mcpError(`template not found: ${template}`);
@@ -251,41 +281,18 @@ export function registerDiscoveryTools(server) {
  * Enumerate templates by walking the canonical corpus.
  * Restricted to the AIWG_ROOT subtree (no .aiwg/ project artifacts).
  */
-async function scanTemplates(aiwgRoot, { framework, filter } = {}) {
+async function scanTemplates(store, { framework, filter } = {}) {
+  if (framework) validateContainedPath(framework);
+  const prefix = framework ? `agentic/code/frameworks/${framework}/templates/` : 'agentic/code/frameworks/';
+  const entries = await listContainedFiles(store, prefix);
   const results = [];
-  const root = path.join(aiwgRoot, 'agentic/code/frameworks');
-  let frameworks = [];
-  try {
-    frameworks = (await fs.readdir(root, { withFileTypes: true }))
-      .filter(d => d.isDirectory())
-      .map(d => d.name);
-  } catch {
-    return results;
-  }
-  for (const fw of frameworks) {
-    if (framework && fw !== framework) continue;
-    const tplRoot = path.join(root, fw, 'templates');
-    await walkTemplates(tplRoot, tplRoot, fw, results, filter);
-  }
-  return results;
-}
-
-async function walkTemplates(base, dir, framework, out, filter) {
-  let entries = [];
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
   for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walkTemplates(base, full, framework, out, filter);
-    } else if (entry.isFile() && entry.name.endsWith('.md')) {
-      const rel = path.relative(base, full);
-      const name = entry.name.replace(/\.md$/, '');
-      if (filter && !name.includes(filter) && !rel.includes(filter)) continue;
-      out.push({ framework, name, relativePath: rel, path: full });
-    }
+    const match = /^agentic\/code\/frameworks\/([^/]+)\/templates\/(.+\.md)$/.exec(entry.path);
+    if (!match) continue;
+    const [, fw, relativePath] = match;
+    const name = path.basename(relativePath, '.md');
+    if (filter && !name.includes(filter) && !relativePath.includes(filter)) continue;
+    results.push({ framework: fw, name, relativePath, path: path.join(store.root, entry.path) });
   }
+  return results;
 }

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}`);
     }