@mindrian_os/install 1.13.0-beta.11

package/lib/core/room-ops-sync.cjs

@@ -0,0 +1,70 @@
+/**
+ * MindrianOS Plugin -- Room Ops (SYNC entry point)
+ * =================================================
+ * execSync-based variants of the public room-ops surface. Import this from
+ * CLI scripts / hook scripts that expect synchronous return values.
+ *
+ * NEVER import from lib/mcp/* -- MCP handlers must use room-ops-async.cjs
+ * so blocking subprocess I/O doesn't stall the MCP request loop.
+ *
+ * Phase 87-04 sync/async split (CASCADE-06).
+ *
+ * License: BSL 1.1 (Business Source License 1.1) -- see LICENSE.
+ */
+
+'use strict';
+
+const path = require('path');
+const { execSync } = require('child_process');
+const { discoverSections } = require('./section-registry.cjs');
+const { resolveRoom } = require('./room-ops-shared.cjs');
+
+const SCRIPTS_DIR = path.resolve(__dirname, '../../scripts');
+
+/**
+ * List discovered sections with metadata (synchronous).
+ * @param {string} roomDir - Path to room directory
+ * @returns {{ sections: Array, core_count: number, extended_count: number }}
+ */
+function listSections(roomDir) {
+  const resolved = path.resolve(roomDir);
+  const discovery = discoverSections(resolved);
+
+  const sections = discovery.all.map(name => {
+    const meta = discovery.getMeta(name);
+    return {
+      name,
+      type: meta.type,
+      label: meta.label,
+      color: meta.color,
+    };
+  });
+
+  return {
+    sections,
+    core_count: discovery.core.length,
+    extended_count: discovery.extended.length,
+  };
+}
+
+/**
+ * Run analyze-room script against a room directory (synchronous).
+ * Returns raw stdout as string.
+ * @param {string} roomDir - Path to room directory
+ * @returns {string} Raw script output
+ */
+function analyzeRoom(roomDir) {
+  const resolved = path.resolve(roomDir);
+  const scriptPath = path.join(SCRIPTS_DIR, 'analyze-room');
+  try {
+    return execSync(`bash "${scriptPath}" "${resolved}"`, {
+      timeout: 10000,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    throw new Error(`analyze-room failed: ${e.message}`);
+  }
+}
+
+module.exports = { listSections, analyzeRoom, resolveRoom };

package/lib/core/room-ops.cjs

@@ -0,0 +1,32 @@
+/**
+ * MindrianOS Plugin -- Room Ops (legacy entry point, SYNC-compat shim)
+ * =====================================================================
+ * DEPRECATED: import from './room-ops-sync.cjs' (CLI / hook scripts) or
+ * './room-ops-async.cjs' (MCP handlers) directly. This file exists only
+ * as a thin re-export for backward compatibility with any out-of-tree
+ * caller that copy-pasted older docs.
+ *
+ * Phase 87-04 sync/async split (CASCADE-06). Rationale: a single module
+ * with env branching (process.env.MOS_ASYNC) is the R4 footgun -- one
+ * forgotten guard ships blocking execSync into the MCP handler path.
+ * Two distinct entry points chosen by the caller at require time make
+ * the contract unambiguous.
+ *
+ * A one-time process.emitWarning() fires on require so accidental callers
+ * are surfaced. The warning uses a stable `code` (MOS_DEP_ROOM_OPS_LEGACY)
+ * so test environments can filter it via NODE_NO_WARNINGS / the process
+ * warning event handler if needed. process.emitWarning dedups by
+ * (name, code) per Node process automatically, so require'ing this file
+ * from multiple places still emits the warning only once.
+ *
+ * License: BSL 1.1 (Business Source License 1.1) -- see LICENSE.
+ */
+
+'use strict';
+
+process.emitWarning(
+  "require('lib/core/room-ops.cjs') is deprecated; import './room-ops-sync.cjs' (CLI) or './room-ops-async.cjs' (MCP) directly (Phase 87-04).",
+  { type: 'DeprecationWarning', code: 'MOS_DEP_ROOM_OPS_LEGACY' }
+);
+
+module.exports = require('./room-ops-sync.cjs');

package/lib/core/room-type-detector.cjs

@@ -0,0 +1,386 @@
+/**
+ * MindrianOS Plugin -- Room Type Detector
+ * Pure function: detects Room type from State content + Section names + Entry content.
+ * Maps each Room type to adaptive config (statsBar, hubTitle, sectionLabels, insightTypes, graphLabel).
+ *
+ * Satisfies: ROOM-01, ROOM-02, ROOM-03, ROOM-04
+ * Taxonomy: Room, Section, Entry, State, Thesis, Signal, Thread, Fabric
+ * Zero npm dependencies -- uses only Node.js built-ins.
+ */
+
+'use strict';
+
+/**
+ * ROOM_TYPE_CONFIG: Adaptive presentation config per Room type.
+ * Each preset maps to stats bar metrics, hub title, section label overrides,
+ * insight types, and Constellation graph label.
+ *
+ * statsBar: array of { key, label } objects for the stats bar
+ * hubTitle: display title for the hub page
+ * sectionLabels: map of section-id -> display label override
+ * insightTypes: prioritized Signal types for this Room type
+ * graphLabel: label for the Constellation view
+ */
+const ROOM_TYPE_CONFIG = {
+  venture: {
+    statsBar: [
+      { key: 'sectionCount', label: 'Sections' },
+      { key: 'entryCount',   label: 'Entries' },
+      { key: 'threadCount',  label: 'Threads' },
+      { key: 'gapCount',     label: 'Blind Spots' },
+      { key: 'grantCount',   label: 'Grants' },
+    ],
+    hubTitle: 'Venture Data Room',
+    sectionLabels: {
+      'problem-definition':   'Problem Definition',
+      'market-analysis':      'Market Analysis',
+      'solution-design':      'Solution Design',
+      'business-model':       'Business Model',
+      'competitive-analysis': 'Competitive Analysis',
+      'team-execution':       'Team & Execution',
+      'legal-ip':             'Legal & IP',
+      'financial-model':      'Financial Model',
+      'opportunity-bank':     'Opportunity Bank',
+      'funding-strategy':     'Funding Strategy',
+    },
+    insightTypes: ['investor-readiness', 'competitive-gaps', 'financial-viability'],
+    graphLabel: 'Venture Knowledge Graph',
+  },
+
+  website: {
+    statsBar: [
+      { key: 'sectionCount',    label: 'Sections' },
+      { key: 'entryCount',      label: 'Pages' },
+      { key: 'componentCount',  label: 'Components' },
+      { key: 'breakpointCount', label: 'Breakpoints' },
+      { key: 'gapCount',        label: 'Issues' },
+    ],
+    hubTitle: 'Design System Room',
+    sectionLabels: {
+      'problem-definition':   'User Needs',
+      'market-analysis':      'Competitor Analysis',
+      'solution-design':      'Component Architecture',
+      'business-model':       'Content Strategy',
+      'competitive-analysis': 'UX Benchmarks',
+      'team-execution':       'Design Team',
+      'legal-ip':             'Accessibility & Compliance',
+      'financial-model':      'Performance Budget',
+    },
+    insightTypes: ['design-consistency', 'accessibility', 'performance'],
+    graphLabel: 'Component Dependency Graph',
+  },
+
+  research: {
+    statsBar: [
+      { key: 'sectionCount', label: 'Sections' },
+      { key: 'entryCount',   label: 'Papers' },
+      { key: 'threadCount',  label: 'Citations' },
+      { key: 'findingCount', label: 'Findings' },
+      { key: 'gapCount',     label: 'Gaps' },
+    ],
+    hubTitle: 'Research Room',
+    sectionLabels: {
+      'problem-definition':   'Research Question',
+      'market-analysis':      'Literature Review',
+      'solution-design':      'Methodology',
+      'business-model':       'Data Collection',
+      'competitive-analysis': 'Related Work',
+      'team-execution':       'Research Team',
+      'legal-ip':             'Ethics & IRB',
+      'financial-model':      'Funding & Budget',
+      'literature':           'Literature',
+      'clinical-pathway':     'Clinical Pathway',
+      'findings':             'Findings',
+    },
+    insightTypes: ['methodology-coverage', 'citation-network', 'finding-strength'],
+    graphLabel: 'Research Knowledge Graph',
+  },
+
+  general: {
+    statsBar: [
+      { key: 'sectionCount', label: 'Sections' },
+      { key: 'entryCount',   label: 'Entries' },
+      { key: 'threadCount',  label: 'Threads' },
+      { key: 'gapCount',     label: 'Blind Spots' },
+      { key: 'signalCount',  label: 'Signals' },
+    ],
+    hubTitle: 'Data Room',
+    sectionLabels: {},
+    insightTypes: ['gaps', 'contradictions', 'convergences'],
+    graphLabel: 'Knowledge Graph',
+  },
+};
+
+/** All recognized Room types */
+const VALID_ROOM_TYPES = Object.keys(ROOM_TYPE_CONFIG);
+
+/**
+ * Keyword sets for heuristic Room type detection from Section names and Entry content.
+ * Each set is scored -- highest score wins.
+ */
+/**
+ * Strong indicators: Section names that are near-unique to one Room type.
+ * Presence of ANY strong indicator adds a large bonus (weight: 10).
+ * This prevents generic sections (market-analysis, team-execution) from
+ * drowning out domain-specific sections (clinical-pathway, literature).
+ */
+const STRONG_INDICATORS = {
+  venture: ['financial-model', 'opportunity-bank', 'funding-strategy'],
+  website: ['design-system', 'ui-components', 'components', 'pages'],
+  research: ['clinical-pathway', 'literature', 'findings', 'methodology', 'experiments'],
+};
+
+const TYPE_SIGNALS = {
+  venture: {
+    sectionKeywords: [
+      'financial-model', 'competitive-analysis', 'business-model',
+      'funding-strategy', 'opportunity-bank', 'team-execution',
+      'legal-ip',
+    ],
+    contentKeywords: [
+      'investor', 'funding', 'revenue', 'TAM', 'SAM', 'SOM',
+      'valuation', 'pitch', 'startup', 'venture', 'equity',
+      'cap table', 'burn rate', 'runway',
+    ],
+  },
+  website: {
+    sectionKeywords: [
+      'components', 'pages', 'design-system', 'navigation',
+      'layouts', 'styles', 'responsive', 'ui-components',
+    ],
+    contentKeywords: [
+      'responsive', 'breakpoint', 'component', 'CSS', 'layout',
+      'navigation', 'wireframe', 'figma', 'typography', 'color palette',
+      'accessibility', 'WCAG', 'viewport',
+    ],
+  },
+  research: {
+    sectionKeywords: [
+      'literature', 'methodology', 'findings', 'clinical-pathway',
+      'data-collection', 'hypothesis', 'experiments', 'results',
+    ],
+    contentKeywords: [
+      'hypothesis', 'methodology', 'findings', 'citation', 'peer review',
+      'abstract', 'literature review', 'sample size', 'p-value',
+      'clinical', 'experiment', 'IRB', 'protocol', 'randomized',
+    ],
+  },
+};
+
+/**
+ * Detect Room type from State content and Section metadata.
+ * Pure function -- no file I/O, no side effects.
+ *
+ * Detection cascade:
+ *   1. Explicit type in State frontmatter (room_type: or venture_type:)
+ *   2. Section name heuristics (weighted keyword match)
+ *   3. Entry content sampling (keyword frequency in first N entries)
+ *   4. Fallback to 'general'
+ *
+ * @param {string} stateContent - Raw STATE.md content (or empty string)
+ * @param {Array<{name: string, entries?: Array<{content?: string}>}>} sections - Section metadata
+ * @returns {string} One of: 'venture', 'website', 'research', 'general'
+ */
+function detectRoomType(stateContent, sections) {
+  stateContent = stateContent || '';
+  sections = sections || [];
+
+  // Step 1: Explicit type declaration in State frontmatter
+  const explicitType = parseExplicitType(stateContent);
+  if (explicitType && VALID_ROOM_TYPES.includes(explicitType)) {
+    return explicitType;
+  }
+
+  // Step 2 + 3: Score-based detection from Section names + Entry content
+  const scores = { venture: 0, website: 0, research: 0 };
+  const sectionNames = sections.map(s => (s.name || '').toLowerCase());
+
+  // Strong indicators: domain-unique sections get a large bonus (weight: 10)
+  for (const [type, indicators] of Object.entries(STRONG_INDICATORS)) {
+    for (const indicator of indicators) {
+      if (sectionNames.includes(indicator)) {
+        scores[type] += 10;
+      }
+    }
+  }
+
+  for (const [type, signals] of Object.entries(TYPE_SIGNALS)) {
+    // Section name matches (weight: 3 per match)
+    for (const keyword of signals.sectionKeywords) {
+      if (sectionNames.includes(keyword)) {
+        scores[type] += 3;
+      }
+      // Partial match (section name contains keyword)
+      for (const name of sectionNames) {
+        if (name !== keyword && name.includes(keyword)) {
+          scores[type] += 1;
+        }
+      }
+    }
+
+    // Entry content keyword matches (weight: 1 per match, sampled)
+    const contentSample = buildContentSample(sections);
+    const contentLower = contentSample.toLowerCase();
+    for (const keyword of signals.contentKeywords) {
+      if (contentLower.includes(keyword.toLowerCase())) {
+        scores[type] += 1;
+      }
+    }
+  }
+
+  // Find highest scoring type
+  let bestType = 'general';
+  let bestScore = 0;
+  for (const [type, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+
+  // Minimum threshold: need at least 3 points to declare a type
+  if (bestScore < 3) return 'general';
+
+  return bestType;
+}
+
+/**
+ * Parse explicit Room type from State frontmatter.
+ * Looks for: room_type, venture_type, project_type
+ * @param {string} stateContent - Raw STATE.md content
+ * @returns {string|null} Explicit type or null
+ */
+function parseExplicitType(stateContent) {
+  // Match frontmatter block
+  const fmMatch = stateContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    // Also check inline patterns outside frontmatter
+    const inlineMatch = stateContent.match(/(?:room_type|project_type|venture_type):\s*(\S+)/i);
+    return inlineMatch ? normalizeType(inlineMatch[1]) : null;
+  }
+
+  const frontmatter = fmMatch[1];
+  const typeMatch = frontmatter.match(/(?:room_type|project_type):\s*(\S+)/i);
+  if (typeMatch) return normalizeType(typeMatch[1]);
+
+  // venture_type implies 'venture'
+  const ventureMatch = frontmatter.match(/venture_type:\s*(\S+)/i);
+  if (ventureMatch) return 'venture';
+
+  return null;
+}
+
+/**
+ * Normalize a raw type string to a recognized Room type.
+ * @param {string} raw - Raw type value from frontmatter
+ * @returns {string} Normalized type
+ */
+function normalizeType(raw) {
+  const cleaned = (raw || '').toLowerCase().replace(/['"]/g, '').trim();
+  if (VALID_ROOM_TYPES.includes(cleaned)) return cleaned;
+
+  // Fuzzy matching for common aliases
+  if (['startup', 'company', 'business', 'venture-capital'].includes(cleaned)) return 'venture';
+  if (['web', 'site', 'design', 'ui', 'frontend'].includes(cleaned)) return 'website';
+  if (['academic', 'science', 'study', 'lab', 'clinical'].includes(cleaned)) return 'research';
+
+  return cleaned; // Let caller check VALID_ROOM_TYPES
+}
+
+/**
+ * Build a content sample string from Section entries for keyword detection.
+ * Samples up to 3 entries per Section, first 500 chars each.
+ * @param {Array} sections - Section metadata with optional entries
+ * @returns {string} Concatenated content sample
+ */
+function buildContentSample(sections) {
+  const chunks = [];
+  for (const section of sections) {
+    if (!section.entries || !Array.isArray(section.entries)) continue;
+    const sample = section.entries.slice(0, 3);
+    for (const entry of sample) {
+      if (entry.content) {
+        chunks.push(entry.content.slice(0, 500));
+      }
+    }
+  }
+  return chunks.join(' ');
+}
+
+/**
+ * Get the full ROOM_TYPE_CONFIG for a detected Room type.
+ * @param {string} roomType - One of VALID_ROOM_TYPES
+ * @returns {Object} Config object with statsBar, hubTitle, sectionLabels, insightTypes, graphLabel
+ */
+function getRoomTypeConfig(roomType) {
+  return ROOM_TYPE_CONFIG[roomType] || ROOM_TYPE_CONFIG.general;
+}
+
+/**
+ * Get the display label for a Section within a Room type context.
+ * Falls back to Title Case of the section id.
+ * @param {string} roomType - Room type
+ * @param {string} sectionId - Section directory name (kebab-case)
+ * @returns {string} Display label
+ */
+function getSectionLabel(roomType, sectionId) {
+  const config = getRoomTypeConfig(roomType);
+  if (config.sectionLabels[sectionId]) {
+    return config.sectionLabels[sectionId];
+  }
+  // Fallback: Title Case from kebab-case
+  return sectionId.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+
+// CLI interface
+if (require.main === module) {
+  const fs = require('fs');
+  const path = require('path');
+
+  const args = process.argv.slice(2);
+  if (args.length < 1) {
+    process.stderr.write('Usage: node room-type-detector.cjs <ROOM_PATH>\n');
+    process.exit(1);
+  }
+
+  const roomDir = path.resolve(args[0]);
+  const statePath = path.join(roomDir, 'STATE.md');
+
+  let stateContent = '';
+  try { stateContent = fs.readFileSync(statePath, 'utf-8'); } catch (_) {}
+
+  // Build section list from directory scan
+  const sections = [];
+  try {
+    const entries = fs.readdirSync(roomDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+      const sectionDir = path.join(roomDir, entry.name);
+      const sectionEntries = [];
+      try {
+        const files = fs.readdirSync(sectionDir).filter(f => f.endsWith('.md'));
+        for (const f of files.slice(0, 3)) {
+          try {
+            const content = fs.readFileSync(path.join(sectionDir, f), 'utf-8');
+            sectionEntries.push({ content });
+          } catch (_) {}
+        }
+      } catch (_) {}
+      sections.push({ name: entry.name, entries: sectionEntries });
+    }
+  } catch (_) {}
+
+  const roomType = detectRoomType(stateContent, sections);
+  const config = getRoomTypeConfig(roomType);
+
+  const result = { roomType, config };
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
+
+module.exports = {
+  ROOM_TYPE_CONFIG,
+  VALID_ROOM_TYPES,
+  detectRoomType,
+  getRoomTypeConfig,
+  getSectionLabel,
+};

package/lib/core/rs-brain-substrate-prompts.cjs

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.1a Plan 01 -- substrate query prompt allow-list.
+ *
+ * Frozen vocabulary + validateCtx + FORBIDDEN_PATTERNS re-export.
+ * This module is the SECOND layer of the Phase 89.1a Canon Part 8
+ * chokepoint (first layer is buildBrainSubstrateQuery in
+ * rs-brain-substrate.cjs). validateCtx is called at the top of
+ * buildBrainSubstrateQuery and any consumer extension.
+ *
+ * Pure CJS, zero npm deps. Re-exports FORBIDDEN_PATTERNS from
+ * lib/core/cross-room-aggregator.cjs byte-for-byte to avoid drift
+ * (per Phase 90-08 A1 sweep design).
+ */
+'use strict';
+
+const crossRoomAggregator = require('./cross-room-aggregator.cjs');
+
+// ---------- Frozen vocabulary ----------
+
+const ALLOWED_CTX_KEYS = Object.freeze([
+  'framework_ids',   // string[] each matching SLUG_REGEX
+  'phase_ids',       // string[] each matching SLUG_REGEX
+  'problem_types',   // string[] each in PROBLEM_TYPE_ENUM
+  'domains',         // string[] each matching SLUG_REGEX
+  'namespace',       // string one of NAMESPACE_ENUM
+  'limit',           // integer in [1, 10000]
+]);
+
+const PROBLEM_TYPE_ENUM = Object.freeze(['udp', 'idp', 'wdp', 'wicked']);
+
+const NAMESPACE_ENUM = Object.freeze(['core', 'tools', 'reference', 'materials', 'graphrag']);
+
+const SLUG_REGEX = /^[a-z0-9_-]{1,64}$/;
+
+const LIMIT_MIN = 1;
+const LIMIT_MAX = 10000;
+
+const PROMPT_VERSION = 1;
+
+// FORBIDDEN_PATTERNS is re-exported BYTE-FOR-BYTE from cross-room-aggregator.
+// The aggregator is the Canon authoritative source (Phase 90-06 lines 87-94).
+// Re-exporting (instead of redefining) eliminates drift risk: one update site,
+// one truth. Defensive guard at require-time so refactors are loud, not silent.
+const FORBIDDEN_PATTERNS = crossRoomAggregator.FORBIDDEN_PATTERNS;
+if (!Array.isArray(FORBIDDEN_PATTERNS) || FORBIDDEN_PATTERNS.length < 6) {
+  throw new Error(
+    'rs-brain-substrate-prompts: FORBIDDEN_PATTERNS re-export failed; ' +
+    'Canon Part 8 drift risk (expected >= 6 patterns from cross-room-aggregator)'
+  );
+}
+
+// ---------- validateCtx (the Canon Part 8 chokepoint allow-list) ----------
+//
+// Throws TypeError on any violation. Never returns a boolean. Callers rely on
+// the throw so a silent false-return cannot smuggle user-specific bytes past
+// buildBrainSubstrateQuery.
+
+function validateCtx(ctx) {
+  if (!ctx || typeof ctx !== 'object' || Array.isArray(ctx)) {
+    throw new TypeError('validateCtx: ctx must be a plain object');
+  }
+  for (const key of Object.keys(ctx)) {
+    if (!ALLOWED_CTX_KEYS.includes(key)) {
+      throw new TypeError('validateCtx: forbidden ctx key: ' + key);
+    }
+  }
+  // framework_ids / phase_ids / domains: optional string[] of slug-safe values
+  for (const listKey of ['framework_ids', 'phase_ids', 'domains']) {
+    if (ctx[listKey] === undefined) continue;
+    if (!Array.isArray(ctx[listKey])) {
+      throw new TypeError('validateCtx: ' + listKey + ' must be array');
+    }
+    for (const v of ctx[listKey]) {
+      if (typeof v !== 'string' || !SLUG_REGEX.test(v)) {
+        throw new TypeError(
+          'validateCtx: ' + listKey + ' value fails slug regex: ' +
+          String(v).slice(0, 80)
+        );
+      }
+    }
+  }
+  // problem_types: optional string[] of enum values
+  if (ctx.problem_types !== undefined) {
+    if (!Array.isArray(ctx.problem_types)) {
+      throw new TypeError('validateCtx: problem_types must be array');
+    }
+    for (const v of ctx.problem_types) {
+      if (!PROBLEM_TYPE_ENUM.includes(v)) {
+        throw new TypeError(
+          'validateCtx: problem_types value not in enum: ' +
+          String(v).slice(0, 80)
+        );
+      }
+    }
+  }
+  // namespace: optional enum scalar
+  if (ctx.namespace !== undefined) {
+    if (typeof ctx.namespace !== 'string' || !NAMESPACE_ENUM.includes(ctx.namespace)) {
+      throw new TypeError(
+        'validateCtx: namespace not in enum: ' +
+        String(ctx.namespace).slice(0, 80)
+      );
+    }
+  }
+  // limit: optional integer in range
+  if (ctx.limit !== undefined) {
+    if (!Number.isInteger(ctx.limit) || ctx.limit < LIMIT_MIN || ctx.limit > LIMIT_MAX) {
+      throw new TypeError(
+        'validateCtx: limit out of range [' + LIMIT_MIN + ',' + LIMIT_MAX + ']: ' +
+        String(ctx.limit)
+      );
+    }
+  }
+}
+
+// ---------- Exports ----------
+
+module.exports = {
+  ALLOWED_CTX_KEYS,
+  PROBLEM_TYPE_ENUM,
+  NAMESPACE_ENUM,
+  SLUG_REGEX,
+  FORBIDDEN_PATTERNS,
+  PROMPT_VERSION,
+  LIMIT_MIN,
+  LIMIT_MAX,
+  validateCtx,
+};