@aiwg/cli 2026.10.5 → 2026.10.6

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

@@ -6,12 +6,12 @@
  *
  *   - discover          (cross-type ranked search)
  *   - skill-list        (enumerate canonical skill corpus)
- *   - skill-show        (fetch SKILL.md body)
+ *   - skill-show        (metadata card + drill-ins)
  *   - command-list      (enumerate CLI commands)
- *   - command-show      (fetch command definition)
+ *   - command-show      (metadata card + drill-ins)
  *   - rule-list         (enumerate rules)
- *   - rule-show         (fetch rule body)
- *   - agent-show        (fetch agent definition; agent-list pre-exists)
+ *   - rule-show         (metadata card + drill-ins)
+ *   - agent-show        (metadata card + drill-ins; agent-list pre-exists)
  *   - template-list     (enumerate templates)
  *   - template-show     (fetch raw template body)
  *
@@ -22,10 +22,33 @@
  */
 
 import { z } from 'zod';
+import { integer } from '../../schema/zod-validation.mjs';
 import { runAiwgCli, mcpError, mcpJson, AIWG_ROOT } from '../helpers.mjs';
 import path from 'node:path';
 import { pinContainedRoot, readContainedFile, listContainedFiles, validateContainedPath } from '../../utils/contained-filesystem.mjs';
 
+/** Shared CLI/MCP drill-in vocabulary for all discovery cards. */
+export const showDrillInSchema = {
+  body: z.boolean().optional().describe('Fetch the full authored body'),
+  section: z.array(z.string()).optional().describe('Exact headings (case-insensitive fallback); repeatable'),
+  rules: z.boolean().optional().describe('Show governing rule summaries and required checks'),
+  with_rule_bodies: z.boolean().optional().describe('Include full governing rule bodies'),
+  bound_rule_bodies: z.boolean().optional().describe('Legacy alias for with_rule_bodies'),
+  resources: z.boolean().optional().describe('List companion resources'),
+  resource: z.string().optional().describe('Fetch one resource path from the card'),
+};
+export function showDrillInArgs(input) {
+  return [
+    ...(input.body ? ['--body'] : []),
+    ...(input.section ?? []).flatMap(heading => ['--section', heading]),
+    ...(input.rules ? ['--rules'] : []),
+    ...(input.with_rule_bodies ? ['--with-rule-bodies'] : []),
+    ...(input.bound_rule_bodies ? ['--bound-rule-bodies'] : []),
+    ...(input.resources ? ['--resources'] : []),
+    ...(input.resource ? ['--resource', input.resource] : []),
+  ];
+}
+
 /**
  * Register discovery tools on the MCP server.
  *
@@ -42,7 +65,7 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
     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'),
-      limit: z.number().int().min(1).max(50).default(5).describe('Maximum results (default 5)'),
+      limit: integer().min(1).max(50).default(5).describe('Maximum results (default 5)'),
     },
     annotations: { readOnlyHint: true, openWorldHint: false },
   }, async ({ phrase, type, limit }) => {
@@ -67,7 +90,7 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
     description: 'Enumerate available AIWG skills from the canonical corpus. Optional filter by name pattern.',
     inputSchema: {
       filter: z.string().optional().describe('Substring or glob filter on skill name'),
-      limit: z.number().int().min(1).max(500).default(50).describe('Maximum results'),
+      limit: integer().min(1).max(500).default(50).describe('Maximum results'),
     },
     annotations: { readOnlyHint: true },
   }, async ({ filter, limit }) => {
@@ -83,15 +106,15 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
 
   server.registerTool('skill-show', {
     title: 'Show AIWG Skill',
-    description: 'Fetch the full body of an AIWG SKILL.md by name. Returns path + content envelope.',
+    description: 'Return the AIWG metadata card with governing rules, outline, resources, and drill-in guidance. Use body/section for authored content.',
     inputSchema: {
-      bound_rule_bodies: z.boolean().optional().describe('Include full bound rule bodies'),
+      ...showDrillInSchema,
       name: z.string().describe('Skill name (slug; e.g. "intake-wizard")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name, bound_rule_bodies }) => {
+  }, async ({ name, ...drillIn }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'skill', name, '--json', ...(bound_rule_bodies ? ['--bound-rule-bodies'] : [])]);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'skill', name, '--json', ...showDrillInArgs(drillIn)]);
       if (code !== 0) return mcpError(`skill-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {
@@ -122,14 +145,15 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
 
   server.registerTool('command-show', {
     title: 'Show AIWG CLI Command Definition',
-    description: 'Fetch the full spec/help text for a specific `aiwg` CLI command.',
+    description: 'Return the AIWG metadata card with governing rules, outline, resources, and drill-in guidance. Use body/section for authored content.',
     inputSchema: {
+      ...showDrillInSchema,
       name: z.string().describe('Command name (e.g. "use", "discover", "ralph")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name }) => {
+  }, async ({ name, ...drillIn }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'command', name, '--json']);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'command', name, '--json', ...showDrillInArgs(drillIn)]);
       if (code !== 0) return mcpError(`command-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {
@@ -166,7 +190,7 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
     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.',
     inputSchema: {
       filter: z.string().optional().describe('Substring filter on rule name'),
-      limit: z.number().int().min(1).max(200).default(50),
+      limit: integer().min(1).max(200).default(50),
     },
     annotations: { readOnlyHint: true },
   }, async ({ filter, limit }) => {
@@ -182,14 +206,15 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
 
   server.registerTool('rule-show', {
     title: 'Show AIWG Rule',
-    description: 'Fetch the full body of a specific AIWG rule by name.',
+    description: 'Return the AIWG metadata card with governing rules, outline, resources, and drill-in guidance. Use body/section for authored content.',
     inputSchema: {
+      ...showDrillInSchema,
       name: z.string().describe('Rule name (e.g. "no-attribution", "anti-laziness")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name }) => {
+  }, async ({ name, ...drillIn }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'rule', name, '--json']);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'rule', name, '--json', ...showDrillInArgs(drillIn)]);
       if (code !== 0) return mcpError(`rule-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {
@@ -202,15 +227,15 @@ export function registerDiscoveryTools(server, { corpusStore } = {}) {
   // ============================================================
   server.registerTool('agent-show', {
     title: 'Show AIWG Agent Definition',
-    description: 'Fetch the full agent definition (system prompt + frontmatter) by name.',
+    description: 'Return the AIWG metadata card with governing rules, outline, resources, and drill-in guidance. Use body/section for authored content.',
     inputSchema: {
-      bound_rule_bodies: z.boolean().optional().describe('Include full bound rule bodies'),
+      ...showDrillInSchema,
       name: z.string().describe('Agent name (e.g. "test-engineer", "security-auditor")'),
     },
     annotations: { readOnlyHint: true },
-  }, async ({ name, bound_rule_bodies }) => {
+  }, async ({ name, ...drillIn }) => {
     try {
-      const { stdout, code, stderr } = await runAiwgCli(['show', 'agent', name, '--json', ...(bound_rule_bodies ? ['--bound-rule-bodies'] : [])]);
+      const { stdout, code, stderr } = await runAiwgCli(['show', 'agent', name, '--json', ...showDrillInArgs(drillIn)]);
       if (code !== 0) return mcpError(`agent-show failed: ${stderr}`);
       return mcpJson(stdout);
     } catch (err) {

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

@@ -9,6 +9,8 @@
  */
 
 import { z } from 'zod';
+import { integer } from '../../schema/zod-validation.mjs';
+import { showDrillInSchema, showDrillInArgs } from './discovery.mjs';
 import { parse as parseYaml } from 'yaml';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -157,28 +159,23 @@ export function registerFlowToolset(server) {
 
   server.registerTool('flow-show', {
     title: 'Show AIWG Flow',
-    description: 'Fetch a declarative Flow playbook by name, including parsed step summary and the wrapper skill path when present.',
+    description: 'Return the same metadata card as aiwg show flow, with optional body, section, rules, and resource drill-ins.',
     inputSchema: {
+      ...showDrillInSchema,
       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, bound_rule_bodies }) => {
+  }, async ({ name, framework, ...drillIn }) => {
     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);
+      const flow = framework ? await findFlow(name, framework) : null;
+      if (framework && !flow) return mcpError(`flow-show: flow not found: ${name}`);
       const { stdout, stderr, code } = await runAiwgCli([
-        'show', 'flow', flow.path, '--json',
-        ...(bound_rule_bodies ? ['--bound-rule-bodies'] : []),
+        'show', 'flow', flow?.path ?? name, '--json',
+        ...showDrillInArgs(drillIn),
       ]);
-      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 } : {}) } : {}) });
+      if (code !== 0) return mcpError(`flow-show lookup failed: ${stderr}`);
+      return mcpJson(stdout);
     } catch (err) {
       return mcpError(`flow-show: ${err.message}`);
     }
@@ -191,7 +188,7 @@ export function registerFlowToolset(server) {
       name: z.string().describe('Flow name (e.g. flow-release)'),
       framework: z.string().optional().describe('Optional framework disambiguator'),
       project_dir: z.string().optional().describe('Project directory where the Flow should operate'),
-      args: z.array(z.string()).default([]).describe('Operator arguments to pass conceptually to the wrapper skill'),
+      args: z.array(z.string()).prefault([]).describe('Operator arguments to pass conceptually to the wrapper skill'),
       confirmed: z.boolean().default(false).describe('Required because Flows can run shell commands and write artifacts'),
     },
     annotations: { destructiveHint: true, openWorldHint: true },
@@ -246,15 +243,16 @@ export function registerMissionToolset(server) {
       session_id: z.string().describe('Existing Mission Control session id from mc-start / mc-list'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().describe('Measurable completion criterion'),
-      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_iterations: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
       max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
       max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      exploration_quota: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
       project_dir: z.string().optional().describe('Project directory for CLI dispatch'),
+      worker_dispatch: z.string().optional().describe('Absolute prepared managed worker dispatch JSON path inside the project'),
       confirmed: z.boolean().default(false).describe('Required for durable/long-running mission dispatch'),
     },
     annotations: { destructiveHint: true, openWorldHint: true },
@@ -270,6 +268,7 @@ export function registerMissionToolset(server) {
     max_wall_clock_minutes,
     exploration_quota,
     budget_stop_policy,
+    worker_dispatch,
     project_dir,
     confirmed,
   }) => {
@@ -289,6 +288,7 @@ export function registerMissionToolset(server) {
       if (max_wall_clock_minutes) cliArgs.push('--max-wall-clock-minutes', String(max_wall_clock_minutes));
       if (exploration_quota) cliArgs.push('--exploration-quota', String(exploration_quota));
       if (budget_stop_policy) cliArgs.push('--budget-stop-policy', budget_stop_policy);
+      if (worker_dispatch) cliArgs.push('--worker-dispatch', worker_dispatch);
       const { stdout, stderr, code } = await runAiwgCli(
         cliArgs,
         { cwd: project_dir, timeoutMs: 30_000 },
@@ -335,7 +335,7 @@ 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({
+    inputSchema: z.strictObject({
       role: z.enum(['efficiency', 'coding', 'reasoning']),
       task: z.string().min(1),
       group: z.string().min(1).regex(/^[a-z][a-z0-9-]{0,62}$/),
@@ -345,7 +345,7 @@ export function registerWorkerResolveTool(server) {
       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 {

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

@@ -15,6 +15,7 @@
  */
 
 import { z } from 'zod';
+import { integer } from '../../schema/zod-validation.mjs';
 import { runAiwgCli, mcpError, mcpJson } from '../helpers.mjs';
 import { registerFlowToolset, registerMissionToolset } from './orchestration.mjs';
 import { registerWorkerInvokeToolset, WORKERS_TOOLSET_NAME } from './worker-invoke.mjs';
@@ -187,7 +188,7 @@ function registerActivityLogToolset(server) {
     inputSchema: {
       since: z.string().optional().describe('Filter by date YYYY-MM-DD'),
       operation: z.string().optional().describe('Filter by operation token (e.g. "create", "deploy")'),
-      limit: z.number().int().min(1).max(1000).default(100),
+      limit: integer().min(1).max(1000).default(100),
     },
     readOnly: true,
     buildArgs: ({ since, operation, limit }) => {
@@ -256,7 +257,7 @@ function registerIndexToolset(server) {
     inputSchema: {
       keyword: z.string().optional().describe('Keyword query'),
       type: z.string().optional().describe('Artifact type filter'),
-      limit: z.number().int().min(1).max(500).default(50),
+      limit: integer().min(1).max(500).default(50),
     },
     readOnly: true,
     buildArgs: ({ keyword, type, limit }) => {
@@ -310,7 +311,7 @@ function registerRalphToolset(server) {
     inputSchema: {
       task: z.string().describe('Task description'),
       completion: z.string().describe('Measurable completion criteria (verification command)'),
-      max_cycles: z.number().int().min(1).max(500).default(20),
+      max_cycles: integer().min(1).max(500).default(20),
       confirmed: z.boolean().default(false).describe('Required (Ralph is long-running)'),
     },
     annotations: { destructiveHint: true },
@@ -415,13 +416,13 @@ function registerMcToolset(server) {
       session_id: z.string().describe('Session id'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().optional().describe('Completion criteria'),
-      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_iterations: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
       max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
       max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      exploration_quota: integer().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
     },
     buildArgs: ({

package/dist/src/mcp/tools/worker-invoke.mjs

@@ -159,6 +159,13 @@
 
 import { signalChild } from '../../process/signal-child.mjs';
 import { z } from 'zod';
+
+// Keep accepting existing UUID-shaped identifiers regardless of version bits.
+const invocationUuid = () => z.string().check(ctx => {
+  if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(ctx.value)) {
+    ctx.issues.push({ code: 'invalid_format', format: 'uuid', input: ctx.value, message: 'Invalid uuid' });
+  }
+}).meta({ format: 'uuid' });
 import { createHash, randomUUID } from 'node:crypto';
 import {
   realpath, readlink as fsReadlink, open as fsOpen, lstat, unlink,
@@ -1532,12 +1539,12 @@ function publicStatus(entry, healthHook) {
 // Tool registration.
 // ===========================================================================
 
-const inputSchema = z.object({
+const inputSchema = z.strictObject({
   // #2915 round 8 (D4): `reconcile_stopped` is an explicit operator-
   // authorized reconciliation operation on this SAME handler (never a
   // mailbox file, never a new breaker) — see `reconcileStopped` below.
   operation: z.enum(['run', 'status', 'cancel', 'reconcile_stopped', 'reset_recovery_scope']),
-  invocation_id: z.string().uuid().optional(),
+  invocation_id: invocationUuid().optional(),
   scope_id: z.string().min(1).max(512).optional(),
   request_id: z.string().min(1).max(128).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
   role: z.enum(['efficiency', 'coding', 'reasoning']).optional(),
@@ -1553,8 +1560,8 @@ const inputSchema = z.object({
   // configuration exists yet for the MCP shell-launch path — see
   // session-launcher.mjs `verifyRetryPredecessor`, which the CLI entry
   // point already uses). Omission is unrelated work, as always.
-  retry_of: z.string().uuid().optional(),
-}).strict();
+  retry_of: invocationUuid().optional(),
+});
 
 /**
  * #2892 B1: `options.projectRoot` is REQUIRED — the caller (`server.mjs`,
@@ -1726,6 +1733,12 @@ export async function registerWorkerInvokeToolset(server, options = {}) {
       if (plan.invocation?.readiness !== 'launchable') {
         return markTerminal({ status: 'blocked', termination: 'confirmed', diagnostics: plan.diagnostics ?? [] });
       }
+      if (plan.invocation.isolation === 'native-sandbox') {
+        return markTerminal({ status: 'blocked', termination: 'confirmed', diagnostics: [{
+          code: 'OG_POLICY_RELAXATION', pointer: '/worker/isolation',
+          message: 'MCP worker-invoke run does not support pinned native-sandbox isolation',
+        }] });
+      }
       prefix = { root, snapshot, drivers, invocation: plan.invocation };
     } catch (error) {
       return markTerminal({ status: 'blocked', termination: 'confirmed', diagnostics: [error.message] });

package/dist/src/mcp/tools/writer-profiles.mjs

@@ -32,7 +32,7 @@ export function registerWriterProfileResources(server, options = {}) {
   server.registerResource('writer-profile', new ResourceTemplate('aiwg://writer-profiles/{scope}/{id}', { list: undefined }), {
     title: 'Shared Writer Profile', description: 'Explicit scoped read using profile sharing approvals; private exports are unavailable through this resource.', mimeType: 'application/json',
   }, async (uri, variables) => {
-    const selection = z.object({ scope: z.enum(['project', 'user']), id: z.string().regex(/^[a-z0-9][a-z0-9.-]{0,79}$/) }).strict().parse(variables);
+    const selection = z.strictObject({ scope: z.enum(['project', 'user']), id: z.string().regex(/^[a-z0-9][a-z0-9.-]{0,79}$/) }).parse(variables);
     const cwd = await projectRoot(); const { WriterProfileStore, exportWriterProfile } = await api();
     const profile = await new WriterProfileStore({ cwd, scope: selection.scope }).read(selection.id);
     return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(exportWriterProfile(profile, 'shared')) }] };