@mindrian_os/install 1.13.0-beta.11

package/lib/wiki/wiki-watcher.cjs

@@ -0,0 +1,105 @@
+'use strict';
+/**
+ * wiki-watcher.cjs — File watcher + SSE broadcast for wiki auto-refresh
+ *
+ * Watches room/ directory via chokidar. On file changes,
+ * calls the onChange callback and broadcasts SSE events
+ * to all connected browser clients.
+ */
+
+const chokidar = require('chokidar');
+const path = require('path');
+
+const sseClients = new Set();
+
+/**
+ * Start watching a room directory for changes.
+ * @param {string} roomDir - Path to room/ directory
+ * @param {function} onChangeCallback - Called with { event, path } on changes
+ * @returns {object} chokidar watcher instance
+ */
+function startWatcher(roomDir, onChangeCallback) {
+  const absRoom = path.resolve(roomDir);
+
+  const watcher = chokidar.watch(absRoom, {
+    ignoreInitial: true,
+    ignored: [
+      /\.mindrian/,
+      /\.reasoning/,
+      /node_modules/,
+      /\.git/
+    ],
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+
+  watcher.on('all', (event, filePath) => {
+    // Only care about .md file changes
+    if (!filePath.endsWith('.md')) return;
+
+    const relPath = path.relative(absRoom, filePath);
+
+    // Call the application callback (rebuild index, etc.)
+    if (typeof onChangeCallback === 'function') {
+      onChangeCallback({ event, path: relPath });
+    }
+
+    // Broadcast SSE event to all connected clients
+    broadcast({ event: 'change', path: relPath, type: event });
+  });
+
+  return watcher;
+}
+
+/**
+ * Add an SSE client (Express response object).
+ * Sets appropriate headers and sends initial keepalive.
+ * @param {object} res - Express response object
+ */
+function addSSEClient(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive'
+  });
+
+  // Initial keepalive comment
+  res.write(':keepalive\n\n');
+
+  sseClients.add(res);
+
+  // Clean up on disconnect
+  res.on('close', () => {
+    removeSSEClient(res);
+  });
+}
+
+/**
+ * Remove an SSE client from the set.
+ * @param {object} res - Express response object
+ */
+function removeSSEClient(res) {
+  sseClients.delete(res);
+}
+
+/**
+ * Broadcast an SSE event to all connected clients.
+ * @param {object} data - Event data to serialize as JSON
+ */
+function broadcast(data) {
+  const message = `data: ${JSON.stringify(data)}\n\n`;
+
+  for (const client of sseClients) {
+    try {
+      client.write(message);
+    } catch (e) {
+      // Client disconnected — remove
+      sseClients.delete(client);
+    }
+  }
+}
+
+module.exports = { startWatcher, addSSEClient, removeSSEClient };

package/lib/workflow/ROOM.md

@@ -0,0 +1,47 @@
+---
+type: directory-identity
+name: lib/workflow
+section: lib/workflow
+purpose: Workflow layer -- the framework <-> command registry resolver. The sole door from "framework" to "/mos: command".
+founding_phase: 122
+phase: 122
+milestone: v1.13.0-beta.11
+canon_parts: [7, 8]
+created: 2026-05-12
+---
+
+# lib/workflow/
+
+`lib/workflow/` is the home for the Workflow Layer -- the deterministic join between the Brain's methodology graph (`Framework -[:FEEDS_INTO]-> Framework`) and the plugin's `/mos:` command surface. Phase 122 is the founding phase; the resolver is the contained surface.
+
+The reliability rules this directory enforces (per `.planning/WORKFLOW-LAYER-SPEC.md`):
+
+1. **Single source of truth.** `frameworks:` in each `commands/*.md` frontmatter is the only place the framework-to-command mapping is declared. Nothing here re-asserts it.
+2. **Generated, drift-impossible.** `data/command-registry.json` is built from frontmatter; a CI tripwire fails on stale registry or an unresolvable Brain framework name.
+3. **The resolver is the only door.** `command-resolver.cjs` is the sole path from framework to command. Larry never names a `/mos:` command from memory.
+4. **The trigger is the hook, not the model.** The navigation engine computes the command sequence; Larry is the voice, not the decision-maker.
+5. **Degrade, do not fabricate.** A framework with no command yields "run [framework] manually" -- never a made-up command.
+
+## Files in this section
+
+| File | Plan | Purpose |
+|------|------|---------|
+| `command-resolver.test.cjs` | 122-01 (stub), 122-03 (fill) | Wave-0 stub for the resolver test suite. Covers `commandsForFramework`, `frameworksForCommand`, `composeWorkflow` (incl. null/optional markers), `validateChainAutonomy`, the empty-registry degrade path, and the no-Brain assertion once 122-03 fills it. |
+| `command-resolver.cjs` | 122-03 | The resolver. `commandsForFramework`, `frameworksForCommand`, `composeWorkflow(frameworkChain) -> [{step, framework, command\|null, optional}]`, `validateChainAutonomy(workflow) -> {runnable, blockers}`. Reads only `data/command-registry.json` at runtime. Never queries the Brain. |
+
+## Canon Part 8 boundary (LOCAL + plugin-local, never Brain)
+
+The resolver reads `data/command-registry.json` (plugin-local, generated, committed) and nothing else. It makes zero network calls. Commands NEVER enter the Brain (Canon Part 8) -- the registry is validated AGAINST the Brain's framework names at build time (`scripts/build-command-registry.cjs --refresh-names`), never written back. The chain recommender that seeds workflows from `FEEDS_INTO` lives in `lib/brain/` and carries only generic framework handles + problem-type enums in its Cypher -- never user content.
+
+## Decision #15 compliance
+
+Per `CLAUDE.md` Decision #15, every directory in the data room (and the lib tree by extension under this milestone's policy) carries a ROOM.md identity file. `lib/workflow/` is bound to Phase 122; subsequent additions update this file's "Files in this section" table. No MINTO.md required at this level -- the `.room-root` cascade scope is `room/`, not `lib/`.
+
+## Cross-references
+
+- Spec: `.planning/WORKFLOW-LAYER-SPEC.md`
+- Phase 122 PLAN: `.planning/phases/122-workflow-layer/122-01-PLAN.md`
+- Phase 122 RESEARCH: `.planning/phases/122-workflow-layer/122-RESEARCH.md`
+- Frontmatter contract: `docs/COMMAND-FRONTMATTER.md`
+- Canon: `docs/MINDRIAN-CANON.md` Parts 7, 8
+- Sibling identity reference: `lib/hmi/ROOM.md` (Phase 100), `lib/conversation/ROOM.md` (Phase 99)

package/lib/workflow/command-resolver.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 122-03 -- command-resolver.cjs (the only door)
+ * ====================================================
+ * The SOLE deterministic read-only path from "framework" to "command".
+ * Reads only data/command-registry.json at runtime. NEVER touches the Brain.
+ *
+ * Reliability rules (per .planning/WORKFLOW-LAYER-SPEC.md):
+ *   3. The resolver is the only door. The suggest-next / pipeline / act
+ *      orchestrators, the navigation hook, the pws-methodology skill, and
+ *      the brain-connector skill all go through this module. Larry never
+ *      names a command from memory; every command he emits came back from
+ *      the resolver.
+ *   5. Degrade, do not fabricate. A framework with no command yields
+ *      { command: null, optional: true } -- never a made-up command. A
+ *      missing / empty registry degrades every function to empty results.
+ *
+ * Canon Part 8 (Graph Boundary): this file does NOT require the Brain HTTP
+ * client and makes ZERO network calls. The registry is a plugin-local,
+ * generated, committed artifact (built by scripts/build-command-registry.cjs,
+ * validated AGAINST the Brain's framework names at build time, never written
+ * back). The pre-commit / test grep guard from 122-02 enforces the no-Brain
+ * rule.
+ *
+ * The four functions:
+ *   commandsForFramework(name)  -> string[]   (registry framework_index[name] or [])
+ *   frameworksForCommand(cmd)   -> string[]   (the command entry's frameworks, or [])
+ *   composeWorkflow(chain)      -> [{ step, framework, command|null, optional }]
+ *   validateChainAutonomy(wf)   -> { runnable, blockers }
+ *
+ * Test-only surface (small, clearly test-only):
+ *   __reset()                       clears the per-process cache
+ *   MINDRIAN_COMMAND_REGISTRY env   overrides REGISTRY_PATH (for fixtures)
+ *
+ * License: BSL 1.1.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_REGISTRY_PATH = path.join(__dirname, '..', '..', 'data', 'command-registry.json');
+
+// Test-only override: lets the test point at a fixture or a nonexistent file
+// to exercise the degrade path. Resolved fresh on every _load() cache miss so
+// a test can flip it between __reset() calls.
+function _registryPath() {
+  const override = process.env.MINDRIAN_COMMAND_REGISTRY;
+  return (typeof override === 'string' && override.length > 0) ? override : DEFAULT_REGISTRY_PATH;
+}
+
+// Per-process cache. The registry is a generated artifact that does not change
+// during a run; reading it once is the integration-registry.cjs precedent.
+let _cache = null;
+
+// Degrade shape: an empty registry. Every function returns empty results
+// against it -- no throw, no fabricated command.
+const EMPTY_REGISTRY = Object.freeze({ commands: [], framework_index: {}, curated_chains: [] });
+
+function _load() {
+  if (_cache) return _cache;
+  try {
+    const raw = fs.readFileSync(_registryPath(), 'utf8');
+    const parsed = JSON.parse(raw);
+    // Be tolerant of a partially-shaped file: fill missing keys.
+    _cache = {
+      commands: Array.isArray(parsed && parsed.commands) ? parsed.commands : [],
+      framework_index: (parsed && parsed.framework_index && typeof parsed.framework_index === 'object')
+        ? parsed.framework_index : {},
+      curated_chains: Array.isArray(parsed && parsed.curated_chains) ? parsed.curated_chains : [],
+    };
+  } catch (_e) {
+    _cache = EMPTY_REGISTRY; // degrade: missing / unreadable / malformed registry
+  }
+  return _cache;
+}
+
+/**
+ * commandsForFramework(name) -> string[]
+ * The /mos: command(s) declared (via frontmatter) to run framework `name`.
+ * Unknown framework / empty registry -> []. Never throws.
+ */
+function commandsForFramework(name) {
+  if (typeof name !== 'string' || name.length === 0) return [];
+  const idx = _load().framework_index || {};
+  const cmds = idx[name];
+  return Array.isArray(cmds) ? cmds.slice() : [];
+}
+
+/**
+ * frameworksForCommand(cmd) -> string[]
+ * The framework(s) the given /mos: command declares it runs.
+ * Unknown command / empty registry -> []. Never throws.
+ */
+function frameworksForCommand(cmd) {
+  if (typeof cmd !== 'string' || cmd.length === 0) return [];
+  const c = _load().commands.find(function (x) { return x && x.command === cmd; });
+  return (c && Array.isArray(c.frameworks)) ? c.frameworks.slice() : [];
+}
+
+/**
+ * composeWorkflow(frameworkChain) -> [{ step, framework, command|null, optional }]
+ * Maps an ordered framework-name list to a step list. The first command for
+ * each framework is taken; a framework with no command degrades to
+ * { command: null, optional: true } (the consumer prints "run X manually").
+ * Non-array / [] -> []. Never throws.
+ */
+function composeWorkflow(frameworkChain) {
+  if (!Array.isArray(frameworkChain)) return [];
+  return frameworkChain.map(function (fw, i) {
+    const cmds = commandsForFramework(fw);
+    return {
+      step: i + 1,
+      framework: fw,
+      command: cmds.length > 0 ? cmds[0] : null,
+      optional: cmds.length === 0,
+    };
+  });
+}
+
+/**
+ * validateChainAutonomy(workflow) -> { runnable, blockers }
+ * `blockers` names every step whose command exists in the registry but is not
+ * `autonomous_safe: true` (or is unknown to the registry). Steps with
+ * command === null are skipped (not blockers -- they are manual-only by
+ * design, the consumer surfaces a "run manually" line, /mos:act --chain stops
+ * there with a "needs you here" gate per the spec). Never throws.
+ */
+function validateChainAutonomy(workflow) {
+  const reg = _load();
+  const byCmd = new Map(reg.commands.map(function (c) { return [c && c.command, c]; }));
+  const blockers = [];
+  for (const s of (Array.isArray(workflow) ? workflow : [])) {
+    if (!s || !s.command) continue; // null command -> not a blocker (manual step)
+    const c = byCmd.get(s.command);
+    if (!c || c.autonomous_safe !== true) {
+      blockers.push({ step: s.step, command: s.command, reason: 'not autonomous_safe' });
+    }
+  }
+  return { runnable: blockers.length === 0, blockers: blockers };
+}
+
+// Test-only: clear the per-process cache so a test can re-point the registry.
+function __reset() { _cache = null; }
+
+module.exports = {
+  commandsForFramework: commandsForFramework,
+  frameworksForCommand: frameworksForCommand,
+  composeWorkflow: composeWorkflow,
+  validateChainAutonomy: validateChainAutonomy,
+  // Test-only surface (see header).
+  __reset: __reset,
+};

package/lib/workflow/command-resolver.test.cjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Phase 122-03 -- command-resolver tests (real suite; fills the 122-01 Wave-0 stub).
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs TEST_FILES[] (since 122-01,
+ * unchanged path). Run: node lib/workflow/command-resolver.test.cjs
+ * Exit 0 on pass; throws (node:assert) on any fail.
+ *
+ * Seven assertion groups (per 122-03-PLAN.md Task 1 <behavior>):
+ *   1. commandsForFramework -- known framework returns its array; unknown -> [].
+ *   2. frameworksForCommand -- known command returns its frameworks; unknown -> [].
+ *   3. composeWorkflow -- step/framework/command/optional shape, 1-indexed, in
+ *      order; []/non-array -> [].
+ *   4. composeWorkflow on a deliberately command-less framework ("Red Teaming")
+ *      -> { step:1, framework:"Red Teaming", command:null, optional:true }.
+ *   5. validateChainAutonomy -- /mos:hat-briefing (autonomous_safe: false) is a
+ *      blocker; an all-autonomous_safe chain -> { runnable:true, blockers:[] };
+ *      command:null steps are skipped.
+ *   6. Degrade -- MINDRIAN_COMMAND_REGISTRY pointed at a nonexistent file +
+ *      __reset() -> empty registry, every function empty, no throw.
+ *   7. No-Brain -- the resolver source contains no require() of brain-client,
+ *      no fetch(, no require('node:http'/'node:https').
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const RESOLVER_PATH = path.join(__dirname, 'command-resolver.cjs');
+const REGISTRY_PATH = path.join(REPO_ROOT, 'data', 'command-registry.json');
+
+// The real registry (read directly so the test asserts the COMPOSITION SHAPE
+// against the committed artifact rather than hardcoding command strings that
+// the 122-01 retrofit could legitimately tweak).
+const registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+const frameworkIndex = registry.framework_index || {};
+const commandsByName = new Map(registry.commands.map(function (c) { return [c.command, c]; }));
+
+const resolver = require('./command-resolver.cjs');
+
+let passed = 0;
+function test(name, fn) {
+  fn();
+  process.stdout.write('  ok  ' + name + '\n');
+  passed += 1;
+}
+
+// Pick a real framework that has at least one command, deterministically (first
+// key in the index whose value is a non-empty array). Keeps the test
+// retrofit-proof.
+const mappedFramework = Object.keys(frameworkIndex).find(function (k) {
+  return Array.isArray(frameworkIndex[k]) && frameworkIndex[k].length > 0;
+});
+assert.ok(mappedFramework, 'registry framework_index must contain at least one mapped framework');
+
+// ---------------------------------------------------------------------------
+// 1. commandsForFramework
+// ---------------------------------------------------------------------------
+test('commandsForFramework returns the registry framework_index array for a known framework', function () {
+  const got = resolver.commandsForFramework(mappedFramework);
+  assert.deepStrictEqual(got, frameworkIndex[mappedFramework]);
+  assert.ok(Array.isArray(got) && got.length > 0);
+});
+
+test('commandsForFramework returns [] for an unknown framework / empty / non-string', function () {
+  assert.deepStrictEqual(resolver.commandsForFramework('No Such Framework XYZ'), []);
+  assert.deepStrictEqual(resolver.commandsForFramework(''), []);
+  assert.deepStrictEqual(resolver.commandsForFramework(undefined), []);
+  assert.deepStrictEqual(resolver.commandsForFramework(null), []);
+});
+
+// ---------------------------------------------------------------------------
+// 2. frameworksForCommand
+// ---------------------------------------------------------------------------
+test('frameworksForCommand returns the frameworks array from that command entry', function () {
+  const methCmd = registry.commands.find(function (c) {
+    return Array.isArray(c.frameworks) && c.frameworks.length > 0;
+  });
+  assert.ok(methCmd, 'registry must contain a command with a non-empty frameworks list');
+  assert.deepStrictEqual(resolver.frameworksForCommand(methCmd.command), methCmd.frameworks);
+});
+
+test('frameworksForCommand returns [] for an unknown command / empty / non-string', function () {
+  assert.deepStrictEqual(resolver.frameworksForCommand('/mos:no-such-command-xyz'), []);
+  assert.deepStrictEqual(resolver.frameworksForCommand(''), []);
+  assert.deepStrictEqual(resolver.frameworksForCommand(undefined), []);
+});
+
+// ---------------------------------------------------------------------------
+// 3. composeWorkflow -- shape, 1-indexed, in order
+// ---------------------------------------------------------------------------
+test('composeWorkflow returns 1-indexed in-order { step, framework, command|null, optional } steps', function () {
+  // The spec acceptance example -- all three frameworks ARE mapped post-retrofit.
+  const chain = ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)'];
+  const wf = resolver.composeWorkflow(chain);
+  assert.strictEqual(wf.length, 3);
+  wf.forEach(function (s, i) {
+    assert.strictEqual(s.step, i + 1);
+    assert.strictEqual(s.framework, chain[i]);
+    assert.ok('command' in s);
+    assert.ok('optional' in s);
+    const cmds = frameworkIndex[chain[i]] || [];
+    if (cmds.length > 0) {
+      assert.strictEqual(s.command, cmds[0]);
+      assert.strictEqual(s.optional, false);
+    } else {
+      assert.strictEqual(s.command, null);
+      assert.strictEqual(s.optional, true);
+    }
+  });
+  // The spec example expects all three filled.
+  assert.ok(wf.every(function (s) { return s.command !== null && s.optional === false; }),
+    'the spec acceptance example expects all three frameworks to resolve to a command');
+});
+
+test('composeWorkflow inverse-of-framework_index consistency for every mapped framework', function () {
+  const allMapped = Object.keys(frameworkIndex).filter(function (k) {
+    return Array.isArray(frameworkIndex[k]) && frameworkIndex[k].length > 0;
+  });
+  const wf = resolver.composeWorkflow(allMapped);
+  assert.strictEqual(wf.length, allMapped.length);
+  wf.forEach(function (s, i) {
+    assert.strictEqual(s.command, frameworkIndex[allMapped[i]][0]);
+    assert.strictEqual(s.optional, false);
+  });
+});
+
+test('composeWorkflow on [] returns []; on a non-array returns []', function () {
+  assert.deepStrictEqual(resolver.composeWorkflow([]), []);
+  assert.deepStrictEqual(resolver.composeWorkflow(null), []);
+  assert.deepStrictEqual(resolver.composeWorkflow(undefined), []);
+  assert.deepStrictEqual(resolver.composeWorkflow('not an array'), []);
+  assert.deepStrictEqual(resolver.composeWorkflow(42), []);
+});
+
+// ---------------------------------------------------------------------------
+// 4. command-less framework degrades, does not fabricate
+// ---------------------------------------------------------------------------
+test('composeWorkflow(["Red Teaming"]) degrades to { command:null, optional:true } (no fabricated command)', function () {
+  // "Red Teaming" is intentionally command-less per the spec.
+  assert.ok(!(frameworkIndex['Red Teaming'] && frameworkIndex['Red Teaming'].length > 0),
+    'Red Teaming must remain command-less for this assertion to be meaningful');
+  const wf = resolver.composeWorkflow(['Red Teaming']);
+  assert.deepStrictEqual(wf, [{ step: 1, framework: 'Red Teaming', command: null, optional: true }]);
+});
+
+// ---------------------------------------------------------------------------
+// 5. validateChainAutonomy
+// ---------------------------------------------------------------------------
+test('validateChainAutonomy flags a non-autonomous_safe command (/mos:hat-briefing) as a blocker', function () {
+  const hb = commandsByName.get('/mos:hat-briefing');
+  assert.ok(hb, 'registry must contain /mos:hat-briefing');
+  assert.strictEqual(hb.autonomous_safe, false, '/mos:hat-briefing must be autonomous_safe: false');
+  const v = resolver.validateChainAutonomy([
+    { step: 1, command: '/mos:hat-briefing' },
+    { step: 2, command: '/mos:analyze-needs' },
+  ]);
+  assert.strictEqual(v.runnable, false);
+  assert.ok(v.blockers.some(function (b) {
+    return b.step === 1 && b.command === '/mos:hat-briefing' && b.reason === 'not autonomous_safe';
+  }));
+});
+
+test('validateChainAutonomy on an all-autonomous_safe chain returns { runnable:true, blockers:[] }', function () {
+  const safeCmds = registry.commands.filter(function (c) { return c.autonomous_safe === true; }).slice(0, 3);
+  assert.ok(safeCmds.length >= 2, 'registry must contain at least 2 autonomous_safe commands');
+  const wf = safeCmds.map(function (c, i) { return { step: i + 1, command: c.command }; });
+  const v = resolver.validateChainAutonomy(wf);
+  assert.deepStrictEqual(v, { runnable: true, blockers: [] });
+});
+
+test('validateChainAutonomy skips command:null steps (they are not blockers)', function () {
+  const v = resolver.validateChainAutonomy([
+    { step: 1, command: null },
+    { step: 2, command: '/mos:analyze-needs' }, // autonomous_safe: true
+  ]);
+  assert.strictEqual(v.runnable, true);
+  assert.deepStrictEqual(v.blockers, []);
+  const v2 = resolver.validateChainAutonomy([
+    { step: 1, command: null },
+    { step: 2, command: '/mos:hat-briefing' },
+  ]);
+  assert.strictEqual(v2.runnable, false);
+  assert.strictEqual(v2.blockers.length, 1);
+  assert.strictEqual(v2.blockers[0].step, 2);
+});
+
+test('validateChainAutonomy on []/non-array/undefined returns { runnable:true, blockers:[] }', function () {
+  assert.deepStrictEqual(resolver.validateChainAutonomy([]), { runnable: true, blockers: [] });
+  assert.deepStrictEqual(resolver.validateChainAutonomy(undefined), { runnable: true, blockers: [] });
+  assert.deepStrictEqual(resolver.validateChainAutonomy(null), { runnable: true, blockers: [] });
+});
+
+// ---------------------------------------------------------------------------
+// 6. Degrade -- missing registry -> empty results, no throw
+// ---------------------------------------------------------------------------
+test('a missing / unreadable registry degrades every function to empty results (no throw)', function () {
+  const prev = process.env.MINDRIAN_COMMAND_REGISTRY;
+  try {
+    process.env.MINDRIAN_COMMAND_REGISTRY = path.join(REPO_ROOT, 'data', '__nonexistent_registry__.json');
+    resolver.__reset();
+    assert.deepStrictEqual(resolver.commandsForFramework('Beautiful Question Framework'), []);
+    assert.deepStrictEqual(resolver.frameworksForCommand('/mos:analyze-needs'), []);
+    assert.deepStrictEqual(resolver.composeWorkflow(['Beautiful Question Framework', 'Red Teaming']),
+      [
+        { step: 1, framework: 'Beautiful Question Framework', command: null, optional: true },
+        { step: 2, framework: 'Red Teaming', command: null, optional: true },
+      ]);
+    assert.deepStrictEqual(resolver.validateChainAutonomy([{ step: 1, command: '/mos:analyze-needs' }]),
+      { runnable: false, blockers: [{ step: 1, command: '/mos:analyze-needs', reason: 'not autonomous_safe' }] });
+  } finally {
+    if (prev === undefined) { delete process.env.MINDRIAN_COMMAND_REGISTRY; }
+    else { process.env.MINDRIAN_COMMAND_REGISTRY = prev; }
+    resolver.__reset();
+  }
+  // Sanity: back to the real registry after reset.
+  assert.ok(resolver.commandsForFramework(mappedFramework).length > 0);
+});
+
+// ---------------------------------------------------------------------------
+// 7. No-Brain -- the resolver source is a pure local reader
+// ---------------------------------------------------------------------------
+test('command-resolver.cjs source contains no brain-client require, no fetch(, no node:http(s) require', function () {
+  const src = fs.readFileSync(RESOLVER_PATH, 'utf8');
+  assert.ok(!/brain-client/.test(src), 'resolver must not reference brain-client');
+  assert.ok(!/\bfetch\s*\(/.test(src), 'resolver must not call fetch()');
+  assert.ok(!/require\(\s*['"]node:https?['"]\s*\)/.test(src), 'resolver must not require node:http / node:https');
+  assert.ok(!/require\(\s*['"]https?['"]\s*\)/.test(src), 'resolver must not require http / https');
+});
+
+process.stdout.write('\ncommand-resolver.test.cjs: ' + passed + ' assertion groups PASSED\n');
+process.exit(0);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@mindrian_os/install",
+  "version": "1.13.0-beta.11",
+  "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/install`. Ships the MindrianOS plugin (Larry + PWS methodology + Data Room) plus a setup/diagnostics CLI (install/doctor/update).",
+  "scripts": {
+    "mcp": "node bin/mindrian-mcp-server.cjs",
+    "parity": "node lib/parity/check-parity.cjs",
+    "migrate-minto-v88": "node scripts/migrate-minto-schema-v88.cjs"
+  },
+  "bin": {
+    "mindrian-os": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "pipelines/",
+    "references/",
+    "skills/",
+    "commands/",
+    "agents/",
+    "hooks/",
+    ".claude-plugin/",
+    ".mcp.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@ig3/markdown-it-wikilinks": "^1.0.2",
+    "@modelcontextprotocol/ext-apps": "^1.5.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "asciichart": "^1.5.25",
+    "chokidar": "^4.0.3",
+    "express": "^5.1.0",
+    "flexsearch": "^0.7.43",
+    "gray-matter": "^4.0.3",
+    "markdown-it": "^14.1.0",
+    "zod": "^3.25.76"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "license": "BSL-1.1"
+}

package/pipelines/analogy/01-decompose.md

@@ -0,0 +1,80 @@
+---
+stage: 1
+methodology: reason
+chain: analogy
+input_from: null
+output_to: abstract
+room_section: problem-definition
+---
+
+# Stage 1: Decompose (SAPPhIRE Extraction)
+
+## Input Extraction
+
+First stage -- uses room artifacts across all sections. No prior pipeline artifact needed.
+
+Scan `room/STATE.md` for venture context: problem type, venture stage, filled sections. Then read key artifacts from the most populated sections (problem-definition, solution-design, market-analysis) to understand the venture's core challenge.
+
+If the user provided a specific problem or contradiction when starting the pipeline, use that as the focal point. Otherwise, identify the venture's primary challenge from room state.
+
+## Stage Instructions
+
+Run `/mos:reason` with the venture's core problem, framing the decomposition around SAPPhIRE layers.
+
+Read `references/methodology/sapphire-encoding.md` for the SAPPhIRE ontology reference.
+
+For each major room artifact, extract:
+
+### SAPPhIRE Triples
+
+| Layer | Question | Extract From |
+|-------|----------|-------------|
+| **State** | What is the current situation/condition? | problem-definition/ |
+| **Action** | What action does the system perform? | solution-design/ |
+| **Part** | What structural components exist? | team-execution/ |
+| **Phenomenon** | What observable behaviors/trends drive this? | market-analysis/ |
+| **Input** | What resources/inputs does the system consume? | business-model/ |
+| **Real effect** | What underlying principle/mechanism operates? | competitive-analysis/ |
+| **Effect** | What measurable outcome results? | financial-model/ |
+
+### Core Contradiction Identification
+
+Identify the venture's CORE CONTRADICTION -- the tension where improving one dimension worsens another:
+- "Increasing [X] degrades [Y]"
+- "We need [A] but [A] prevents [B]"
+- "Our strength in [domain] becomes a weakness when [condition]"
+
+Check existing KuzuDB `CONTRADICTS` edges if available:
+```
+Scan room/.lazygraph/ for existing contradiction edges
+```
+
+### Function-Behavior-Structure Encoding
+
+For the core problem, produce:
+- **Function:** What the system DOES (verb + object, domain-independent)
+- **Behavior:** HOW it achieves the function (mechanism)
+- **Structure:** WHAT components enable the behavior (parts and relationships)
+
+Larry should push the user past domain-specific language: "You say 'customer acquisition' -- but functionally, what are you doing? You're FILTERING a population by fit criteria and CONVERTING interest to commitment. Those are functions that exist everywhere."
+
+When the methodology produces its artifact, ensure pipeline provenance is added to frontmatter:
+
+```yaml
+pipeline: analogy
+pipeline_stage: 1
+sapphire_function: "[extracted function]"
+sapphire_behavior: "[extracted behavior]"
+sapphire_structure: "[extracted structure]"
+core_contradiction: "[improving X] vs [worsening Y]"
+```
+
+## Output Contract
+
+The following sections from the artifact feed into Stage 2 (abstract):
+
+- **SAPPhIRE triples** -- become the input for domain-independent encoding
+- **Core contradiction** -- becomes the target for TRIZ parameter mapping
+- **Function-behavior-structure** -- becomes the basis for cross-domain search queries
+
+Stage 2 will extract these by scanning `room/problem-definition/` for the most recent artifact with `pipeline: analogy` and `pipeline_stage: 1` in frontmatter.