@mindrian_os/install 1.13.0-beta.11

package/lib/mcp/resources.cjs

@@ -0,0 +1,227 @@
+/**
+ * MindrianOS MCP Resources — Read-only room browsing via room:// and reasoning:// URI schemes
+ *
+ * Resources let Desktop users browse room state without tool calls
+ * (application-controlled, zero token cost).
+ *
+ * Registered resources:
+ *   1. room-state        — room://state              (room STATE.md)
+ *   2. room-sections     — room://sections            (section listing with metadata)
+ *   3. room-section      — room://section/{name}      (template: section contents)
+ *   4. room-meetings     — room://meetings            (meeting folder listing)
+ *   5. room-intelligence — room://intelligence         (MEETINGS-INTELLIGENCE.md)
+ *   6. reasoning-state   — reasoning://state           (reasoning status across all sections)
+ *   7. reasoning-section — reasoning://section/{name}  (reasoning analysis for a section)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ResourceTemplate } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { getState } = require('../core/state-ops.cjs');
+const { discoverSections } = require('../core/section-registry.cjs');
+const { safeReadFile } = require('../core/index.cjs');
+const reasoningOps = require('../core/reasoning-ops.cjs');
+
+/**
+ * Register all MCP Resources on the server.
+ *
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {string} roomDir - Absolute path to the Data Room directory
+ */
+function registerResources(server, roomDir) {
+  // -------------------------------------------------------------------------
+  // 1. room-state (static) — room://state
+  // -------------------------------------------------------------------------
+  server.resource(
+    'room-state',
+    'room://state',
+    { description: 'Current Data Room state (STATE.md)', mimeType: 'text/markdown' },
+    async (uri) => {
+      const state = getState(roomDir);
+      const text = state || 'No room initialized. Run /mos:new-project to create one.';
+      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 2. room-sections (static) — room://sections
+  // -------------------------------------------------------------------------
+  server.resource(
+    'room-sections',
+    'room://sections',
+    { description: 'All discovered sections with metadata (name, type, label, color)', mimeType: 'application/json' },
+    async (uri) => {
+      const sections = discoverSections(roomDir);
+      const listing = sections.all.map((name) => {
+        const meta = sections.getMeta(name);
+        return { name, type: meta.type, label: meta.label, color: meta.color };
+      });
+      const text = JSON.stringify(listing, null, 2);
+      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 3. room-section (template) — room://section/{sectionName}
+  // -------------------------------------------------------------------------
+  const sectionTemplate = new ResourceTemplate('room://section/{sectionName}', {
+    list: async () => {
+      const sections = discoverSections(roomDir);
+      return {
+        resources: sections.all.map((name) => ({
+          name: `room-section-${name}`,
+          uri: `room://section/${name}`,
+          description: `Contents of the ${name} section`,
+          mimeType: 'text/markdown',
+        })),
+      };
+    },
+  });
+
+  server.resource(
+    'room-section',
+    sectionTemplate,
+    { description: 'Contents of a specific Data Room section (all .md files)', mimeType: 'text/markdown' },
+    async (uri, params) => {
+      const sectionName = params.sectionName;
+      const sectionDir = path.join(roomDir, sectionName);
+
+      if (!fs.existsSync(sectionDir) || !fs.statSync(sectionDir).isDirectory()) {
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'text/markdown',
+            text: `Section "${sectionName}" not found in this Data Room.`,
+          }],
+        };
+      }
+
+      // Read all .md files in the section directory
+      let files;
+      try {
+        files = fs.readdirSync(sectionDir).filter((f) => f.endsWith('.md')).sort();
+      } catch (e) {
+        files = [];
+      }
+
+      if (files.length === 0) {
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'text/markdown',
+            text: `Section "${sectionName}" exists but contains no markdown files yet.`,
+          }],
+        };
+      }
+
+      const combined = files.map((f) => {
+        const content = safeReadFile(path.join(sectionDir, f)) || '';
+        return `# ${f}\n\n${content}`;
+      }).join('\n\n---\n\n');
+
+      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text: combined }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 4. room-meetings (static) — room://meetings
+  // -------------------------------------------------------------------------
+  server.resource(
+    'room-meetings',
+    'room://meetings',
+    { description: 'List of filed meeting folders', mimeType: 'application/json' },
+    async (uri) => {
+      const meetingsDir = path.join(roomDir, 'meetings');
+
+      if (!fs.existsSync(meetingsDir) || !fs.statSync(meetingsDir).isDirectory()) {
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'application/json',
+            text: 'No meetings filed yet.',
+          }],
+        };
+      }
+
+      let folders;
+      try {
+        folders = fs.readdirSync(meetingsDir, { withFileTypes: true })
+          .filter((d) => d.isDirectory())
+          .map((d) => d.name)
+          .sort();
+      } catch (e) {
+        folders = [];
+      }
+
+      if (folders.length === 0) {
+        return {
+          contents: [{
+            uri: uri.href,
+            mimeType: 'application/json',
+            text: 'No meetings filed yet.',
+          }],
+        };
+      }
+
+      const text = JSON.stringify(folders, null, 2);
+      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 5. room-intelligence (static) — room://intelligence
+  // -------------------------------------------------------------------------
+  server.resource(
+    'room-intelligence',
+    'room://intelligence',
+    { description: 'Cross-meeting intelligence analysis', mimeType: 'text/markdown' },
+    async (uri) => {
+      const intel = safeReadFile(path.join(roomDir, 'MEETINGS-INTELLIGENCE.md'));
+      const text = intel || 'No meeting intelligence generated yet. File meetings first.';
+      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 6. reasoning-state (static) — reasoning://state
+  // -------------------------------------------------------------------------
+  server.resource(
+    'reasoning-state',
+    'reasoning://state',
+    { description: 'Reasoning status across all room sections', mimeType: 'application/json' },
+    async (uri) => {
+      const listing = reasoningOps.listReasoning(roomDir);
+      const text = (listing && listing.length > 0)
+        ? JSON.stringify(listing, null, 2)
+        : 'No reasoning generated yet. Run /mos:reason generate to create reasoning for room sections.';
+      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 7. reasoning-section (template) — reasoning://section/{name}
+  // -------------------------------------------------------------------------
+  const reasoningTemplate = new ResourceTemplate('reasoning://section/{name}', {
+    list: undefined,
+  });
+
+  server.resource(
+    'reasoning-section',
+    reasoningTemplate,
+    { description: 'Reasoning analysis for a specific room section', mimeType: 'text/markdown' },
+    async (uri, params) => {
+      const name = params.name;
+      const result = reasoningOps.getReasoning(roomDir, name);
+
+      const text = result.error
+        ? `No reasoning generated for ${name}. Run /mos:reason generate ${name} to create.`
+        : result.content;
+
+      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
+    }
+  );
+}
+
+module.exports = { registerResources };

package/lib/mcp/session-catchup.cjs

@@ -0,0 +1,327 @@
+'use strict';
+
+/**
+ * MindrianOS Plugin -- Session Catch-Up (SCHED-01)
+ *
+ * On MCP server init (Cowork), reads room/.mindrian/last-session.json,
+ * computes what changed since the last session:
+ *   - Hours since last scout run
+ *   - Predictions approaching deadline
+ *   - New files added since last session
+ *   - Stale sections (no updates in 7+ days)
+ *
+ * Returns a structured catch-up summary for the first resource notification.
+ * Writes last-session.json on SIGTERM / graceful shutdown.
+ *
+ * @module session-catchup
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STALE_THRESHOLD_DAYS = 7;
+const MS_PER_HOUR = 3600000;
+const MS_PER_DAY = 86400000;
+
+/**
+ * Path to last-session.json inside a room.
+ * @param {string} roomDir
+ * @returns {string}
+ */
+function lastSessionPath(roomDir) {
+  return path.join(roomDir, '.mindrian', 'last-session.json');
+}
+
+/**
+ * Read the last session record.
+ * @param {string} roomDir
+ * @returns {{ timestamp: string, scoutTimestamp: string|null, fileSnapshot: string[], activeMethodology: string|null } | null}
+ */
+function readLastSession(roomDir) {
+  const p = lastSessionPath(roomDir);
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    return JSON.parse(raw);
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Write the last session record.
+ * @param {string} roomDir
+ * @param {object} data
+ */
+function writeLastSession(roomDir, data) {
+  const p = lastSessionPath(roomDir);
+  const dir = path.dirname(p);
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(data, null, 2));
+  } catch (e) {
+    process.stderr.write(`[session-catchup] Failed to write last-session.json: ${e.message}\n`);
+  }
+}
+
+/**
+ * Recursively collect all .md files in a directory with their mtimes.
+ * @param {string} dir
+ * @param {string} baseDir - root for relative paths
+ * @returns {Array<{relPath: string, mtime: number}>}
+ */
+function collectFiles(dir, baseDir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...collectFiles(fullPath, baseDir));
+      } else if (entry.name.endsWith('.md') && entry.name !== 'STATE.md' && entry.name !== 'ROOM.md') {
+        try {
+          const stat = fs.statSync(fullPath);
+          results.push({
+            relPath: path.relative(baseDir, fullPath),
+            mtime: stat.mtimeMs,
+          });
+        } catch (_e) { /* skip */ }
+      }
+    }
+  } catch (_e) { /* skip */ }
+
+  return results;
+}
+
+/**
+ * Read prediction registry and find approaching deadlines.
+ * @param {string} roomDir
+ * @returns {Array<{title: string, deadline: string, daysRemaining: number}>}
+ */
+function getApproachingPredictions(roomDir) {
+  const registryPath = path.join(roomDir, '.predictions', 'REGISTRY.json');
+  if (!fs.existsSync(registryPath)) return [];
+
+  try {
+    const raw = fs.readFileSync(registryPath, 'utf8');
+    const registry = JSON.parse(raw);
+    const predictions = registry.predictions || registry.entries || [];
+    const now = Date.now();
+    const approaching = [];
+
+    for (const pred of predictions) {
+      if (!pred.deadline && !pred.due_date) continue;
+      const deadline = pred.deadline || pred.due_date;
+      const deadlineMs = new Date(deadline).getTime();
+      if (isNaN(deadlineMs)) continue;
+
+      const daysRemaining = Math.floor((deadlineMs - now) / MS_PER_DAY);
+      // Show predictions due within 14 days (including overdue)
+      if (daysRemaining <= 14) {
+        approaching.push({
+          title: pred.title || pred.description || pred.id || 'Untitled prediction',
+          deadline,
+          daysRemaining,
+        });
+      }
+    }
+
+    // Sort: overdue first, then by soonest
+    approaching.sort((a, b) => a.daysRemaining - b.daysRemaining);
+    return approaching;
+  } catch (_e) {
+    return [];
+  }
+}
+
+/**
+ * Detect stale sections (no file updates in 7+ days).
+ * @param {string} roomDir
+ * @returns {Array<{section: string, daysSinceUpdate: number}>}
+ */
+function getStaleSections(roomDir) {
+  const stale = [];
+  const now = Date.now();
+
+  try {
+    const entries = fs.readdirSync(roomDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') || entry.name === 'exports' || entry.name === 'intelligence') continue;
+
+      const sectionDir = path.join(roomDir, entry.name);
+      const files = collectFiles(sectionDir, sectionDir);
+      if (files.length === 0) continue;
+
+      const latestMtime = Math.max(...files.map(f => f.mtime));
+      const daysSince = Math.floor((now - latestMtime) / MS_PER_DAY);
+
+      if (daysSince >= STALE_THRESHOLD_DAYS) {
+        stale.push({
+          section: entry.name,
+          daysSinceUpdate: daysSince,
+        });
+      }
+    }
+  } catch (_e) { /* skip */ }
+
+  // Sort by stalest first
+  stale.sort((a, b) => b.daysSinceUpdate - a.daysSinceUpdate);
+  return stale;
+}
+
+/**
+ * Compute the full catch-up summary for this session.
+ *
+ * @param {string} roomDir - Absolute path to room directory
+ * @returns {{ hasCatchUp: boolean, hoursSinceLastSession: number|null, hoursSinceScout: number|null, newFiles: string[], predictionsApproaching: Array, staleSections: Array, summary: string }}
+ */
+function computeCatchUp(roomDir) {
+  const result = {
+    hasCatchUp: false,
+    hoursSinceLastSession: null,
+    hoursSinceScout: null,
+    newFiles: [],
+    predictionsApproaching: [],
+    staleSections: [],
+    summary: '',
+  };
+
+  if (!fs.existsSync(roomDir)) {
+    result.summary = 'No room directory found.';
+    return result;
+  }
+
+  const lastSession = readLastSession(roomDir);
+  const now = Date.now();
+
+  // Hours since last session
+  if (lastSession && lastSession.timestamp) {
+    const lastMs = new Date(lastSession.timestamp).getTime();
+    if (!isNaN(lastMs)) {
+      result.hoursSinceLastSession = Math.round((now - lastMs) / MS_PER_HOUR * 10) / 10;
+      result.hasCatchUp = true;
+    }
+  }
+
+  // Hours since last scout
+  if (lastSession && lastSession.scoutTimestamp) {
+    const scoutMs = new Date(lastSession.scoutTimestamp).getTime();
+    if (!isNaN(scoutMs)) {
+      result.hoursSinceScout = Math.round((now - scoutMs) / MS_PER_HOUR * 10) / 10;
+    }
+  }
+
+  // New files since last session
+  if (lastSession && lastSession.fileSnapshot) {
+    const previousFiles = new Set(lastSession.fileSnapshot);
+    const currentFiles = collectFiles(roomDir, roomDir);
+    result.newFiles = currentFiles
+      .filter(f => !previousFiles.has(f.relPath))
+      .map(f => f.relPath);
+  }
+
+  // Approaching predictions
+  result.predictionsApproaching = getApproachingPredictions(roomDir);
+
+  // Stale sections
+  result.staleSections = getStaleSections(roomDir);
+
+  // Build human-readable summary
+  const parts = [];
+
+  if (result.hoursSinceLastSession !== null) {
+    parts.push(`Last session was ${result.hoursSinceLastSession} hours ago.`);
+  } else {
+    parts.push('This is the first session (no previous session data).');
+  }
+
+  if (result.hoursSinceScout !== null && result.hoursSinceScout > 24) {
+    parts.push(`Scout hasn't run in ${Math.round(result.hoursSinceScout)} hours - consider running /mos:scout.`);
+  }
+
+  if (result.newFiles.length > 0) {
+    parts.push(`${result.newFiles.length} new file(s) since last session: ${result.newFiles.slice(0, 5).join(', ')}${result.newFiles.length > 5 ? '...' : ''}`);
+  }
+
+  const overdue = result.predictionsApproaching.filter(p => p.daysRemaining < 0);
+  const urgent = result.predictionsApproaching.filter(p => p.daysRemaining >= 0 && p.daysRemaining <= 3);
+  if (overdue.length > 0) {
+    parts.push(`${overdue.length} OVERDUE prediction(s): ${overdue.map(p => p.title).join(', ')}`);
+  }
+  if (urgent.length > 0) {
+    parts.push(`${urgent.length} prediction(s) due within 3 days: ${urgent.map(p => p.title).join(', ')}`);
+  }
+
+  if (result.staleSections.length > 0) {
+    parts.push(`${result.staleSections.length} stale section(s) (7+ days): ${result.staleSections.map(s => `${s.section} (${s.daysSinceUpdate}d)`).join(', ')}`);
+  }
+
+  result.summary = parts.join(' ');
+  if (result.predictionsApproaching.length > 0 || result.staleSections.length > 0 || result.newFiles.length > 0) {
+    result.hasCatchUp = true;
+  }
+
+  return result;
+}
+
+/**
+ * Create a snapshot of the current session state for later comparison.
+ * Call this on SIGTERM or session end.
+ *
+ * @param {string} roomDir
+ * @param {object} [extra] - Additional fields to persist (scoutTimestamp, activeMethodology)
+ */
+function snapshotSession(roomDir, extra = {}) {
+  const currentFiles = collectFiles(roomDir, roomDir);
+  const data = {
+    timestamp: new Date().toISOString(),
+    scoutTimestamp: extra.scoutTimestamp || null,
+    activeMethodology: extra.activeMethodology || null,
+    fileSnapshot: currentFiles.map(f => f.relPath),
+    fileCount: currentFiles.length,
+  };
+  writeLastSession(roomDir, data);
+}
+
+/**
+ * Register SIGTERM handler to snapshot session on server shutdown.
+ * Safe to call multiple times (idempotent).
+ *
+ * @param {string} roomDir
+ */
+let _shutdownRegistered = false;
+function registerShutdownHandler(roomDir) {
+  if (_shutdownRegistered) return;
+  _shutdownRegistered = true;
+
+  // I-4 fix: guard against double-fire when SIGINT triggers followed by beforeExit
+  let _shutdownDone = false;
+  const handler = () => {
+    if (_shutdownDone) return;
+    _shutdownDone = true;
+    try {
+      snapshotSession(roomDir);
+      process.stderr.write('[session-catchup] Session state saved on shutdown.\n');
+    } catch (e) {
+      process.stderr.write(`[session-catchup] Failed to save on shutdown: ${e.message}\n`);
+    }
+  };
+
+  process.on('SIGTERM', handler);
+  process.on('SIGINT', handler);
+  // Also handle graceful exit
+  process.on('beforeExit', handler);
+}
+
+module.exports = {
+  computeCatchUp,
+  snapshotSession,
+  readLastSession,
+  writeLastSession,
+  registerShutdownHandler,
+  getApproachingPredictions,
+  getStaleSections,
+};

package/lib/mcp/surface-detect.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * Surface Detection for MindrianOS MCP Server
+ *
+ * Auto-detects CLI/Desktop/Cowork at server startup.
+ * Called once before McpServer creation to determine transport
+ * and capability set.
+ *
+ * Detection order (highest priority first):
+ *   1. MINDRIAN_TRANSPORT env (explicit override)
+ *   2. CLAUDE_SURFACE env (Anthropic-set)
+ *   3. COWORK_SESSION_ID env or /sessions dir (Cowork VM)
+ *   4. Non-TTY stdin with minimal argv (Desktop child process)
+ *   5. TTY stdin (interactive CLI)
+ *   6. Default: stdio (Desktop safe default)
+ */
+
+const fs = require('fs');
+
+/** @type {Record<string, { hooks: boolean, apps: boolean, tasks: boolean, scripts: boolean }>} */
+const CAPABILITY_MAP = {
+  cli:     { hooks: true,  apps: false, tasks: false, scripts: true  },
+  desktop: { hooks: false, apps: true,  tasks: false, scripts: false },
+  cowork:  { hooks: false, apps: true,  tasks: true,  scripts: false },
+};
+
+/**
+ * Detect the current surface (CLI, Desktop, Cowork) and return
+ * transport type plus capability flags.
+ *
+ * @returns {{ surface: 'cli'|'desktop'|'cowork', transport: 'stdio'|'http', capabilities: { hooks: boolean, apps: boolean, tasks: boolean, scripts: boolean } }}
+ */
+function detectSurface() {
+  // 1. Explicit override via env
+  const explicitTransport = process.env.MINDRIAN_TRANSPORT;
+  if (explicitTransport === 'http') {
+    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
+  }
+  if (explicitTransport === 'stdio') {
+    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
+  }
+
+  // 2. Anthropic-set surface env
+  const claudeSurface = process.env.CLAUDE_SURFACE;
+  if (claudeSurface === 'cowork') {
+    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
+  }
+  if (claudeSurface === 'desktop') {
+    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
+  }
+  if (claudeSurface === 'cli') {
+    return { surface: 'cli', transport: 'stdio', capabilities: CAPABILITY_MAP.cli };
+  }
+
+  // 3. Cowork VM indicators
+  if (process.env.COWORK_SESSION_ID || (fs.existsSync('/sessions'))) {
+    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
+  }
+
+  // 4. Non-TTY stdin with minimal argv = Desktop spawned child process
+  if (!process.stdin.isTTY && process.argv.length <= 2) {
+    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
+  }
+
+  // 5. Interactive TTY = CLI
+  if (process.stdin.isTTY) {
+    return { surface: 'cli', transport: 'stdio', capabilities: CAPABILITY_MAP.cli };
+  }
+
+  // 6. Default: Desktop (stdio is the safe default)
+  return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
+}
+
+module.exports = { detectSurface, CAPABILITY_MAP };