@aiwg/cli 2026.9.24 → 2026.10.0

package/dist/src/mcp/muse-native-config.mjs

@@ -0,0 +1,123 @@
+import { access, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import os from 'node:os';
+import { resolveMuseXdgSkillsDir } from '../providers/muse-paths.js';
+
+// Mirrors tools/agents/providers/muse-hooks.mjs. src/ cannot import tools/:
+// tools/ is not part of the compiled dist/ tree.
+const MUSE_HOOKS_REL = join('.muse', 'hooks.json');
+const MUSE_HOOKS_SIDECAR_REL = join('.muse', '.aiwg-hooks.json');
+
+const MUSE_VERSION_TIMEOUT_MS = 5_000;
+
+/**
+ * JSONC-tolerant parse. String-aware twin of `stripJsonComments` in
+ * tools/agents/providers/base.mjs: `//` in URLs and `/*` in glob
+ * matchers survive.
+ */
+function parseJson(raw) {
+  const text = String(raw);
+  let out = '';
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') j += text[j] === '\\' ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j + 1;
+    } else if (ch === '/' && text[i + 1] === '/') {
+      while (i < text.length && text[i] !== '\n') i++;
+    } else if (ch === '/' && text[i + 1] === '*') {
+      const end = text.indexOf('*/', i + 2);
+      i = end === -1 ? text.length : end + 2;
+    } else {
+      out += ch;
+      i++;
+    }
+  }
+  return JSON.parse(out);
+}
+
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function inspectMuseCli(env) {
+  const result = spawnSync('muse', ['--version'], {
+    env,
+    encoding: 'utf8',
+    timeout: MUSE_VERSION_TIMEOUT_MS,
+  });
+  if (result.error?.code === 'ENOENT') return 'absent';
+  if (result.error?.code === 'ETIMEDOUT') return 'present (version timeout)';
+  if (result.error) return 'absent';
+  const firstLine = String(result.stdout || result.stderr || '').split(/\r?\n/).find((line) => line.trim());
+  return firstLine ? `present (${firstLine.trim()})` : 'present (version unavailable)';
+}
+
+async function inspectMuseHooks(projectDir) {
+  const hooksPath = join(projectDir, MUSE_HOOKS_REL);
+  try {
+    await access(hooksPath, constants.F_OK);
+  } catch {
+    return 'absent';
+  }
+
+  try {
+    const doc = parseJson(await readFile(hooksPath, 'utf8'));
+    const sessionStartGroups = Array.isArray(doc?.hooks?.SessionStart) ? doc.hooks.SessionStart : [];
+    // AIWG records every group it manages in the sidecar on deploy; a group
+    // counts as managed only when that recorded payload is present.
+    const sidecar = parseJson(await readFile(join(projectDir, MUSE_HOOKS_SIDECAR_REL), 'utf8'));
+    const recorded = Array.isArray(sidecar?.hooks)
+      ? sidecar.hooks.filter((hook) => hook?.event === 'SessionStart' && hook.group)
+      : [];
+    return recorded.some((hook) => sessionStartGroups.some((group) => deepEqual(group, hook.group)))
+      ? 'managed'
+      : 'operator-only';
+  } catch {
+    // Unreadable hooks or a missing/malformed sidecar: nothing proves AIWG
+    // owns these groups.
+    return 'operator-only';
+  }
+}
+
+async function inspectMuseMcp(options) {
+  // <xdg>/muse/skills -> <xdg>/muse/settings.json; bad XDG metadata yields
+  // no path (never ~/.muse).
+  const skillsDir = resolveMuseXdgSkillsDir(options.env || process.env, options.userHome || os.homedir());
+  if (!skillsDir) return 'unreadable';
+  const settingsPath = join(dirname(skillsDir), 'settings.json');
+  try {
+    const settings = parseJson(await readFile(settingsPath, 'utf8'));
+    return settings?.mcp_servers && typeof settings.mcp_servers === 'object'
+      && Object.prototype.hasOwnProperty.call(settings.mcp_servers, 'aiwg')
+      ? 'configured'
+      : 'absent';
+  } catch (error) {
+    if (error?.code === 'ENOENT') return 'absent';
+    return 'unreadable';
+  }
+}
+
+export async function inspectMuseNative(options = {}) {
+  return {
+    cli: inspectMuseCli(options.env || process.env),
+    hooks: await inspectMuseHooks(options.projectDir || process.cwd()),
+    mcp: await inspectMuseMcp(options),
+  };
+}
+
+export async function isMuseDeployedProject(projectDir = process.cwd()) {
+  try {
+    const raw = await readFile(join(projectDir, '.aiwg', 'aiwg.config'), 'utf8');
+    const config = parseJson(raw);
+    if (Array.isArray(config?.providers) && config.providers.includes('muse')) return true;
+    return Object.values(config?.installed || {}).some((entry) => entry?.deployedTo?.muse);
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+import { mcpError, mcpJson } from '../helpers.mjs';
+
+const STATUS = z.enum(['success', 'abstained', 'denied', 'unavailable', 'error', 'cancelled']);
+const ENVELOPE = z.object({ schema: z.string() }).passthrough();
+const LIVE_PLAN = z.object({ mode: z.literal('live'), status: z.enum(['ready', 'skipped', 'denied']), reason: z.string(), executes: z.literal(false) }).passthrough();
+const PATTERN_SUMMARY = z.object({
+  id: z.string(),
+  version: z.string(),
+  status: z.string(),
+  primitive: z.string().optional(),
+}).passthrough();
+const PATTERN_LIST = z.object({
+  schema: z.literal('aiwg-decision-pattern-list/v1'),
+  patterns: z.array(PATTERN_SUMMARY),
+}).passthrough();
+const PATTERN_SHOW = z.object({
+  schema: z.literal('aiwg-decision-pattern-show/v1'),
+  pack: PATTERN_SUMMARY,
+  inputSchema: z.unknown(),
+  outputSchema: z.unknown(),
+  livePlan: LIVE_PLAN,
+}).passthrough();
+const COMPACT_EVALUATION = z.object({
+  status: STATUS,
+  reason: z.string(),
+  attempts: z.number(),
+  value: z.unknown().nullable(),
+}).passthrough();
+const COMPACT_RESULT = z.object({
+  status: STATUS,
+  rulesetStatus: z.string(),
+  reason: z.string(),
+  matchedRules: z.array(z.string()),
+  evaluations: z.record(z.string(), COMPACT_EVALUATION),
+  outcome: z.unknown().nullable(),
+}).passthrough();
+const EVALUATE = z.object({
+  schema: z.literal('aiwg-decision-evaluate/v1'),
+  status: STATUS,
+  reason: z.string(),
+  exitCode: z.number(),
+  compact: COMPACT_RESULT.nullable().optional(),
+  result: z.unknown().nullable(),
+}).passthrough();
+const VALIDATION = z.object({
+  schema: z.literal('aiwg-decision-validation/v1'),
+  target: z.enum(['request', 'definition', 'ruleset', 'binding']),
+  valid: z.boolean(),
+  summary: z.object({
+    kind: z.string().nullable().optional(),
+    apiVersion: z.string().nullable().optional(),
+    id: z.string().nullable().optional(),
+    version: z.string().nullable().optional(),
+  }).passthrough(),
+  errors: z.array(z.string()),
+}).passthrough();
+const CAPABILITIES = z.object({
+  schema: z.literal('aiwg-decision-driver-capabilities/v1'),
+  enabled: z.boolean(),
+  offlineReady: z.boolean(),
+  primitives: z.array(z.string()),
+  backend: z.object({ configured: z.boolean(), probed: z.boolean(), status: z.literal('not-probed') }).passthrough(),
+}).passthrough();
+const OFFLINE_RUN = z.object({
+  schema: z.literal('aiwg-decision-offline-run/v1'),
+  status: STATUS,
+  route: z.enum(['accept', 'review', 'deny']),
+  reason: z.string(),
+  evaluations: z.array(z.object({
+    alias: z.string(),
+    primitive: z.string(),
+    status: z.string(),
+    reason: z.string(),
+    attempts: z.number(),
+    value: z.unknown(),
+  }).passthrough()),
+  checks: z.array(z.unknown()),
+}).passthrough();
+const SYNTHETIC_SETUP = z.object({
+  schema: z.literal('aiwg-decision-synthetic-setup/v1'),
+  pattern: z.object({ id: z.string(), version: z.string() }).passthrough(),
+  files: z.record(z.string(), z.unknown()),
+}).passthrough();
+
+let driverPromise;
+
+async function driver() {
+  driverPromise ??= import('../../decision/driver.js');
+  return driverPromise;
+}
+
+function options() {
+  return { cwd: process.cwd(), env: process.env };
+}
+
+function registerJsonTool(server, name, config, handler, output = ENVELOPE) {
+  server.registerTool(name, {
+    outputSchema: { result: output },
+    ...config,
+  }, async (args) => {
+    try {
+      const result = await handler(args);
+      return {
+        ...mcpJson(result),
+        structuredContent: { result },
+      };
+    } catch (error) {
+      return mcpError(`${name}: ${error.message}`);
+    }
+  });
+}
+
+export function registerDecisionToolset(server) {
+  registerJsonTool(server, 'decision-capabilities', {
+    title: 'Decision runtime capabilities',
+    description: 'Show offline readiness, primitives, experimental features and configured named request profiles.',
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+  }, async () => (await driver()).decisionCapabilities(options()), CAPABILITIES);
+
+  registerJsonTool(server, 'decision-patterns-list', {
+    title: 'List decision patterns',
+    description: 'List governed decision pattern packs.',
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+  }, async () => (await driver()).listPatterns(), PATTERN_LIST);
+
+  registerJsonTool(server, 'decision-pattern-show', {
+    title: 'Show decision pattern',
+    description: 'Show one pattern pack, schemas and disabled-by-default live plan.',
+    inputSchema: { id: z.string().describe('Decision pattern id') },
+    annotations: { readOnlyHint: true },
+  }, async ({ id }) => (await driver()).showPattern(id), PATTERN_SHOW);
+
+  registerJsonTool(server, 'decision-pattern-offline-run', {
+    title: 'Run offline decision pattern fixture',
+    description: 'Run a recorded offline fixture through the production decision runtime.',
+    inputSchema: { id: z.string(), fixture_id: z.string().optional() },
+    annotations: { readOnlyHint: true },
+  }, async ({ id, fixture_id }) => (await driver()).runOfflinePattern(id, fixture_id), OFFLINE_RUN);
+
+  registerJsonTool(server, 'decision-pattern-live-plan', {
+    title: 'Plan live decision pattern',
+    description: 'Report whether an explicitly opted-in synthetic live pattern would be ready; does not execute.',
+    inputSchema: {
+      id: z.string(),
+      explicit_opt_in: z.boolean().default(false),
+      credential_resolved: z.boolean().default(false),
+      egress_approved: z.boolean().default(false),
+    },
+    annotations: { readOnlyHint: true },
+  }, async ({ id, explicit_opt_in, credential_resolved, egress_approved }) => (await driver()).livePlan(id, {
+    explicitOptIn: explicit_opt_in,
+    credentialResolved: credential_resolved,
+    egressApproved: egress_approved,
+  }), LIVE_PLAN);
+
+  registerJsonTool(server, 'decision-validate', {
+    title: 'Validate decision artifact',
+    description: 'Validate a request, definition, ruleset or binding without importing modules or resolving secrets.',
+    inputSchema: {
+      target: z.enum(['request', 'definition', 'ruleset', 'binding']),
+      document: z.unknown().describe('Inline decision document or dispatcher request object'),
+    },
+    annotations: { readOnlyHint: true },
+  }, async ({ target, document }) => (await driver()).validateDecisionValue(target, document, 'mcp-inline'), VALIDATION);
+
+  registerJsonTool(server, 'decision-evaluate-profile', {
+    title: 'Evaluate named decision request profile',
+    description: 'Evaluate a server-configured named request profile only when env and per-call opt-in are present.',
+    inputSchema: {
+      profile: z.string().describe('Profile name from AIWG_DECISION_MCP_REQUESTS'),
+      opt_in: z.boolean().default(false).describe('Required per-call opt-in'),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+  }, async ({ profile, opt_in }) => (await driver()).evaluateMcpProfile(profile, opt_in, options()), EVALUATE);
+
+  registerJsonTool(server, 'decision-setup-synthetic-classification', {
+    title: 'Prepare synthetic classification artifacts',
+    description: 'Return reviewable pinned synthetic classification artifacts and a dispatcher request.',
+    inputSchema: {
+      allowed_options: z.array(z.string()).min(1).optional(),
+      text: z.string().optional(),
+    },
+    annotations: { readOnlyHint: true },
+  }, async ({ allowed_options, text }) => (await driver()).syntheticClassificationSetup({ allowedOptions: allowed_options, text }, options()), SYNTHETIC_SETUP);
+}

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

@@ -18,6 +18,7 @@ import { z } from 'zod';
 import { runAiwgCli, mcpError, mcpJson } from '../helpers.mjs';
 import { registerFlowToolset, registerMissionToolset } from './orchestration.mjs';
 import { registerAgenticSandboxToolset } from './agentic-sandbox.mjs';
+import { registerDecisionToolset } from './decision.mjs';
 
 /**
  * Wrap an `aiwg <subsystem> <verb>` CLI call as an MCP tool.
@@ -588,6 +589,7 @@ const TOOLSET_REGISTRY = {
   mc: registerMcToolset,
   ops: registerOpsToolset,
   sandbox: registerAgenticSandboxToolset,
+  decision: registerDecisionToolset,
 };
 
 /**

package/dist/src/providers/capability-matrix.yaml

@@ -488,12 +488,13 @@ providers:
 
   muse:
     display_name: Muse Code
-    status: experimental
+    status: stable
     # Meta's terminal/CI coding agent (Muse Spark-powered). Explicitly not a
     # model-API surface: Glimmer/Image/Voice are out of scope.
     # Skill writer (.agents/skills + XDG user root), discover-first AGENTS.md
     # bridge, managed .muse/hooks.json, and opt-in MCP settings profile.
     # ADR: docs/architecture/adr-muse-provider-target.md · epic #223.
+    # #231: promoted stable — Linux PUW + security review; maintainer Linux-only waiver 2026-10-02.
     daemon_tier: unsupported
     daemon_pty_adapter: false
     artifact_paths:

package/dist/src/providers/provider-definitions.js

@@ -783,7 +783,8 @@ const BUILT_IN_SEEDS = [
         displayName: 'Muse Code',
         // #225: ADR fixes the canonical id as `muse` with no aliases.
         aliases: [],
-        status: 'experimental',
+        // #231: promoted stable — Linux PUW + security review; maintainer Linux-only waiver 2026-10-02.
+        status: 'stable',
         builtIn: true,
         surfaces: {
             primary: 'muse',