@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.44

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

@@ -1,70 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,386 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/*
- * 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,
-};