@mindrian_os/install 1.13.0-beta.11

package/lib/statusline/surface-detect.cjs

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 106 Plan 04 -- statusline surface-detect helper.
+ *
+ * Returns 'CLI' | 'DESKTOP' | 'COWORK' for hook-time / doctor-time
+ * surface routing. NOT TO BE CONFUSED with lib/mcp/surface-detect.cjs
+ * (that helper picks MCP transport at server startup; signature and
+ * consumer set are different -- lowercase strings + transport field).
+ *
+ * Detection priority (highest first):
+ *   1. MINDRIAN_STATUSLINE_SURFACE env (explicit override; one of
+ *      'CLI' / 'DESKTOP' / 'COWORK')
+ *   2. COWORK_SESSION_ID env, or fs.existsSync('/sessions') -> 'COWORK'
+ *   3. CLAUDE_DESKTOP=1 env -> 'DESKTOP'
+ *   4. CLAUDE_CODE_ENTRYPOINT='cli' env -> 'CLI' (the canonical CC-CLI
+ *      signal; survives non-TTY sub-process invocation -- Bash tool,
+ *      statusline shell-exec, hooks, doctor.cjs all see it inherited
+ *      from the parent CC process. Claude Desktop's spawned stdio MCP
+ *      servers do NOT inherit this var, so it is CLI-exclusive.)
+ *   5. process.stdin.isTTY === true -> 'CLI' (raw shell fallback)
+ *   6. Default -> 'DESKTOP' (safe default; non-TTY child process is the
+ *      most common Desktop pattern per lib/mcp/surface-detect.cjs:62-64)
+ *
+ * Never returns null/undefined; never throws. Pure-ish (reads env + one
+ * fs.existsSync); no network; no writes. Canon Part 8.
+ *
+ * Pure CJS, node built-ins only, zero npm deps (Phase 87 invariant).
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+
+const VALID_SURFACES = ['CLI', 'DESKTOP', 'COWORK'];
+
+function detectStatuslineSurface() {
+  // 1. Explicit override (highest priority for testability + power-user opt-in).
+  const explicit = process.env.MINDRIAN_STATUSLINE_SURFACE;
+  if (explicit && VALID_SURFACES.indexOf(explicit) !== -1) {
+    return explicit;
+  }
+
+  // 2. Cowork signals.
+  if (process.env.COWORK_SESSION_ID) {
+    return 'COWORK';
+  }
+  try {
+    if (fs.existsSync('/sessions')) {
+      return 'COWORK';
+    }
+  } catch (_e) {
+    // Never let an fs error block surface detection.
+  }
+
+  // 3. Desktop signal.
+  if (process.env.CLAUDE_DESKTOP === '1') {
+    return 'DESKTOP';
+  }
+
+  // 4. Claude Code CLI entrypoint -- definitive CLI signal that survives
+  // non-TTY sub-process invocation (Bash tool, statusline shell-exec,
+  // hooks, doctor.cjs). Claude Code sets CLAUDE_CODE_ENTRYPOINT='cli'
+  // on the parent process and it propagates to every child. Claude
+  // Desktop's spawned stdio MCP servers do NOT inherit this var; Cowork
+  // uses its own signals (handled at step 2). Therefore this read is
+  // CLI-exclusive. Without this step, every CC-CLI Bash/hook invocation
+  // falls through to the default-DESKTOP branch and the statusline
+  // broadcast (D-02) plus visibility check (D-03) silently no-op.
+  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'cli') {
+    return 'CLI';
+  }
+
+  // 5. Interactive TTY -> CLI (raw shell fallback for non-CC contexts).
+  if (process.stdin && process.stdin.isTTY === true) {
+    return 'CLI';
+  }
+
+  // 6. Safe default. Non-TTY child process is the most common Desktop
+  // spawn pattern; defaulting to DESKTOP keeps Larry's prose echo on
+  // (better than the rich line never showing).
+  return 'DESKTOP';
+}
+
+module.exports = { detectStatuslineSurface, VALID_SURFACES };

package/lib/update-bootstrap.sh.template

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+# update-bootstrap.sh -- J-5 self-update install handoff (Phase 85-09).
+#
+# Purpose: perform the final install + post-install steps AFTER
+# scripts/self-update has exec'd away. Because this script runs from a
+# fixed path under $HOME/.mindrian/ (not inside the plugin tree), it is
+# NOT overwritten when the install replaces the plugin cache directory.
+# This sidesteps the "bash buffers by byte offset" self-overwrite hazard
+# documented in Finding J-5 of LASZLO-001.
+#
+# Arguments (positional):
+#   $1 STAGE              absolute path to staging dir containing plugin/
+#   $2 TARGET_DIR         absolute path to final install sibling directory
+#   $3 PLATFORM_OS        one of: win32 | darwin | linux
+#   $4 CACHE_ROOT         parent directory of semver-named sibling installs
+#   $5 DOWNLOADED_VERSION the version being installed
+#   $6 CURRENT_VERSION    the version being replaced
+#   $7 CHANGELOG_FILE     path to file containing CHANGELOG_DIFF text
+#   $8 TEST_MODE          "test" to skip npm install/marketplace update
+#
+# Install method branch (J-3):
+#   win32          cp -a + rm -rf  (Windows cannot rename in-use dirs)
+#   darwin|linux   mv              (atomic rename, fast, correct on POSIX)
+
+set -uo pipefail
+
+STAGE="${1:-}"
+TARGET_DIR="${2:-}"
+PLATFORM_OS="${3:-linux}"
+CACHE_ROOT="${4:-}"
+DOWNLOADED_VERSION="${5:-}"
+CURRENT_VERSION="${6:-}"
+CHANGELOG_FILE="${7:-}"
+TEST_MODE="${8:-}"
+
+if [ -z "$STAGE" ] || [ -z "$TARGET_DIR" ]; then
+  echo "UPDATE_FAILED"
+  echo "update-bootstrap: missing STAGE or TARGET_DIR argument"
+  exit 1
+fi
+
+cleanup_on_error() {
+  local ec=$?
+  rm -rf "$TARGET_DIR" 2>/dev/null || true
+  echo "UPDATE_FAILED"
+  echo "update-bootstrap: install step failed (exit $ec); TARGET_DIR rolled back"
+  rm -rf "$STAGE" 2>/dev/null || true
+  exit "$ec"
+}
+trap cleanup_on_error ERR
+
+# Step C: install via platform-aware method.
+echo "STATUS=installing"
+mkdir -p "$CACHE_ROOT"
+case "$PLATFORM_OS" in
+  win32)
+    mkdir -p "$TARGET_DIR"
+    cp -a "$STAGE/plugin/." "$TARGET_DIR/"
+    rm -rf "$STAGE/plugin"
+    ;;
+  *)
+    mv "$STAGE/plugin" "$TARGET_DIR"
+    ;;
+esac
+
+# Disarm rollback: past this point, $TARGET_DIR exists and must be kept
+# even if later best-effort steps (npm, pruning, marketplace) fail.
+trap - ERR
+
+# Step D: preserve .env from previous highest-semver sibling.
+echo "STATUS=preserving_env"
+PREV_DIR=""
+if [ -d "$CACHE_ROOT" ]; then
+  PREV_DIR=$(find "$CACHE_ROOT" -maxdepth 1 -mindepth 1 -type d 2>/dev/null \
+    | grep -E '/[0-9]+\.[0-9]+\.[0-9]+$' \
+    | grep -v "/${DOWNLOADED_VERSION}\$" \
+    | sort -V | tail -1 || true)
+fi
+if [ -n "$PREV_DIR" ] && [ -f "$PREV_DIR/.env" ]; then
+  cp -n "$PREV_DIR/.env" "$TARGET_DIR/.env" 2>/dev/null || true
+fi
+
+# Step E: npm install (skipped in test mode).
+if [ "$TEST_MODE" != "test" ] && [ -f "$TARGET_DIR/package.json" ]; then
+  echo "STATUS=npm_install"
+  ( cd "$TARGET_DIR" && npm install --production --silent 2>/dev/null ) || {
+    echo "UPDATE_WARNING"
+    echo "npm install failed in $TARGET_DIR. You can still use the version read-only until 'cd \"$TARGET_DIR\" && npm install' succeeds."
+  }
+fi
+
+# Step F: prune old cache siblings, keep 3 most recent. Best-effort.
+echo "STATUS=pruning"
+(
+  set +e
+  ALL_VERS=$(find "$CACHE_ROOT" -maxdepth 1 -mindepth 1 -type d 2>/dev/null \
+    | grep -E '/[0-9]+\.[0-9]+\.[0-9]+$' | sort -V)
+  COUNT=$(echo "$ALL_VERS" | grep -c . || true)
+  if [ "${COUNT:-0}" -gt 3 ]; then
+    TO_REMOVE=$(echo "$ALL_VERS" | head -n $((COUNT - 3)))
+    for d in $TO_REMOVE; do rm -rf "$d" 2>/dev/null || true; done
+  fi
+) || true
+
+find "$CACHE_ROOT" -maxdepth 1 -mindepth 1 -type d -name '*.old-*' 2>/dev/null \
+  | while read -r stale; do rm -rf "$stale" 2>/dev/null || true; done
+
+rm -f "$HOME/.mindrian/bridge/update-check.json" 2>/dev/null || true
+
+# Marketplace cache version pointer (best-effort, skipped in test mode).
+if [ "$TEST_MODE" != "test" ]; then
+  MARKETPLACE_CACHE=$(find "$HOME/.claude" -path "*/mindrian-marketplace*marketplace.json" 2>/dev/null | head -1)
+  if [ -n "$MARKETPLACE_CACHE" ]; then
+    node -e "
+const fs = require('fs');
+try {
+  const m = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
+  if (m && Array.isArray(m.plugins) && m.plugins[0]) {
+    m.plugins[0].version = process.argv[2];
+    fs.writeFileSync(process.argv[1], JSON.stringify(m, null, 2) + '\n');
+  }
+} catch (e) {}
+" "$MARKETPLACE_CACHE" "$DOWNLOADED_VERSION" 2>/dev/null || true
+  fi
+fi
+
+POST_COMMANDS=0
+if [ -d "$TARGET_DIR/commands" ]; then
+  POST_COMMANDS=$(ls "$TARGET_DIR/commands/"*.md 2>/dev/null | wc -l)
+fi
+
+echo "UPDATED"
+echo "OLD_VERSION=${CURRENT_VERSION}"
+echo "NEW_VERSION=${DOWNLOADED_VERSION}"
+echo "TARGET_DIR=${TARGET_DIR}"
+echo "COMMANDS=${POST_COMMANDS}"
+echo "---CHANGELOG---"
+if [ -n "$CHANGELOG_FILE" ] && [ -f "$CHANGELOG_FILE" ]; then
+  cat "$CHANGELOG_FILE"
+  rm -f "$CHANGELOG_FILE" 2>/dev/null || true
+fi
+
+rm -rf "$STAGE" 2>/dev/null || true
+rm -f "$0" 2>/dev/null || true
+exit 0

package/lib/vault/frontmatter-schema.cjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+/**
+ * MindrianOS Plugin -- Vault Frontmatter Schema Enrichment
+ *
+ * Pure CJS, zero npm dependencies. Parses, enriches, and serializes
+ * YAML frontmatter for vault artifacts per RULES-09 and ARCH-04.
+ *
+ * Exports:
+ *   FRONTMATTER_SCHEMA  -- required fields per file type
+ *   detectFileType      -- classify a file by path + existing fm
+ *   enrichFrontmatter   -- add missing schema fields (never overwrite)
+ *   parseFrontmatter    -- split YAML fm from body
+ *   serializeFrontmatter -- round-trip fm + body back to string
+ */
+
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Schema definition (RULES-09)
+// ---------------------------------------------------------------------------
+
+const FRONTMATTER_SCHEMA = {
+  base: ['type', 'section', 'created', 'room'],
+  content: ['methodology', 'sources', 'related', 'parent-moc', 'status'],
+  meeting: ['speakers', 'filed-to'],
+  team: ['role', 'expertise', 'contributions'],
+  xref: ['source-artifact', 'target-artifacts', 'relationship-type'],
+  'filed-to': ['filed_to', 'artifact_type', 'source-meeting'],
+};
+
+// System files never get enriched or footered (BRAND-03)
+const SYSTEM_FILES = new Set([
+  'ROOM.md',
+  'STATE.md',
+  'TEAM-STATE.md',
+  'CLAUDE.md',
+  'COWORK-INSTRUCTIONS.md',
+  'TODOS.md',
+  'WHATS-NEXT.md',
+  'INDEX.md',
+  'MILESTONES.md',
+  'MEETINGS-INTELLIGENCE.md',
+  'action-items.md',
+  'metadata.yaml',
+]);
+
+const MEETING_FILENAMES = new Set([
+  'summary.md',
+  'transcript.md',
+  'action-items.md',
+  'decisions.md',
+  'speakers.md',
+]);
+
+// ---------------------------------------------------------------------------
+// File type detection
+// ---------------------------------------------------------------------------
+
+function detectFileType(relPath, frontmatter) {
+  const norm = String(relPath || '').replace(/\\/g, '/');
+  const parts = norm.split('/').filter(Boolean);
+  const basename = parts[parts.length - 1] || '';
+
+  if (SYSTEM_FILES.has(basename)) return 'system';
+
+  // Team profile: team/<category>/<person>/PROFILE.md
+  if (norm.includes('team/') && basename === 'PROFILE.md') return 'team';
+
+  // Filed-to stub lives under meetings/<slug>/filed-to/
+  if (norm.includes('meetings/') && norm.includes('filed-to/')) return 'filed-to';
+
+  // Meeting artifact (summary/transcript/etc.)
+  if (norm.includes('meetings/') && MEETING_FILENAMES.has(basename)) return 'meeting';
+
+  // Cross-reference: filename starts with xref-
+  if (/^xref-/i.test(basename)) return 'xref';
+
+  // AI personas
+  if (norm.includes('ai-personas/')) return 'persona';
+
+  return 'content';
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter parser (minimal YAML subset)
+// ---------------------------------------------------------------------------
+
+const FM_DELIM = /^---\s*\r?\n/;
+
+function parseFrontmatter(content) {
+  const src = String(content || '');
+  if (!FM_DELIM.test(src)) {
+    return { frontmatter: {}, body: src, raw: '' };
+  }
+  const afterFirst = src.replace(FM_DELIM, '');
+  const closeMatch = afterFirst.match(/\r?\n---\s*(\r?\n|$)/);
+  if (!closeMatch) {
+    return { frontmatter: {}, body: src, raw: '' };
+  }
+  const raw = afterFirst.slice(0, closeMatch.index);
+  const bodyStart = closeMatch.index + closeMatch[0].length;
+  const body = afterFirst.slice(bodyStart);
+  const frontmatter = parseYamlLite(raw);
+  return { frontmatter, body, raw };
+}
+
+// Minimal YAML parser: top-level scalars, inline [a, b], and nested 1-level maps.
+// Preserves unknown structures as raw strings so serialization round-trips.
+function parseYamlLite(raw) {
+  const fm = {};
+  const lines = raw.split(/\r?\n/);
+  let currentKey = null;
+  let currentMap = null;
+  let currentList = null;
+
+  const scalar = (v) => {
+    const t = v.trim();
+    if (t === '') return '';
+    if (/^\[.*\]$/.test(t)) {
+      const inner = t.slice(1, -1).trim();
+      if (!inner) return [];
+      return inner.split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, ''));
+    }
+    if (/^['"].*['"]$/.test(t)) return t.slice(1, -1);
+    return t;
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+
+    // Nested: two-space indent under a map key
+    if (/^\s{2}\S/.test(line) && currentMap) {
+      const m = line.match(/^\s{2}([^:]+):\s*(.*)$/);
+      if (m) {
+        currentMap[m[1].trim()] = scalar(m[2]);
+        continue;
+      }
+    }
+
+    // List continuation
+    if (/^\s*-\s/.test(line) && currentList) {
+      currentList.push(line.replace(/^\s*-\s+/, '').trim());
+      continue;
+    }
+
+    // Top-level key
+    const m = line.match(/^([A-Za-z0-9_\-]+):\s*(.*)$/);
+    if (!m) continue;
+    currentMap = null;
+    currentList = null;
+    currentKey = m[1];
+    const val = m[2];
+    if (val === '' || val === undefined) {
+      // Could be a map or list; look ahead
+      const next = lines[i + 1] || '';
+      if (/^\s*-\s/.test(next)) {
+        fm[currentKey] = [];
+        currentList = fm[currentKey];
+      } else if (/^\s{2}\S/.test(next)) {
+        fm[currentKey] = {};
+        currentMap = fm[currentKey];
+      } else {
+        fm[currentKey] = '';
+      }
+    } else {
+      fm[currentKey] = scalar(val);
+    }
+  }
+
+  return fm;
+}
+
+function serializeFrontmatter(frontmatter, body) {
+  const lines = ['---'];
+  for (const [k, v] of Object.entries(frontmatter)) {
+    lines.push(serializeKV(k, v));
+  }
+  lines.push('---');
+  const prefix = lines.join('\n') + '\n';
+  return prefix + (body || '');
+}
+
+function serializeKV(k, v) {
+  if (Array.isArray(v)) {
+    if (v.length === 0) return `${k}: []`;
+    return `${k}: [${v.map(formatScalar).join(', ')}]`;
+  }
+  if (v && typeof v === 'object') {
+    const parts = [`${k}:`];
+    for (const [ck, cv] of Object.entries(v)) {
+      parts.push(`  ${ck}: ${formatScalar(cv)}`);
+    }
+    return parts.join('\n');
+  }
+  return `${k}: ${formatScalar(v)}`;
+}
+
+function formatScalar(v) {
+  if (v === null || v === undefined) return '';
+  if (Array.isArray(v)) return `[${v.map(formatScalar).join(', ')}]`;
+  const s = String(v);
+  if (s === '') return '';
+  // Quote if contains special YAML chars
+  if (/[:#{}\[\],&*!|>'"%@`]/.test(s) && !/^\d{4}-\d{2}-\d{2}$/.test(s)) {
+    if (!s.includes("'")) return `'${s}'`;
+    return `"${s.replace(/"/g, '\\"')}"`;
+  }
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// Extraction helpers
+// ---------------------------------------------------------------------------
+
+function extractSection(relPath) {
+  const norm = String(relPath || '').replace(/\\/g, '/');
+  const parts = norm.split('/').filter(Boolean);
+  return parts[0] || '';
+}
+
+function extractDate(frontmatter, relPath) {
+  if (frontmatter.created) return String(frontmatter.created);
+  if (frontmatter.last_updated) return String(frontmatter.last_updated);
+  if (frontmatter.meeting_date) return String(frontmatter.meeting_date);
+  const norm = String(relPath || '');
+  const m = norm.match(/(\d{4}-\d{2}-\d{2})/);
+  if (m) return m[1];
+  return 'unknown';
+}
+
+function parentMocFor(section) {
+  if (!section) return '';
+  return `${section}/ROOM.md`;
+}
+
+// ---------------------------------------------------------------------------
+// Enrichment
+// ---------------------------------------------------------------------------
+
+function enrichFrontmatter(content, relPath, roomName) {
+  const parsed = parseFrontmatter(content);
+  const fm = Object.assign({}, parsed.frontmatter);
+  const type = detectFileType(relPath, fm);
+
+  if (type === 'system') return content;
+
+  const section = extractSection(relPath);
+  const created = extractDate(fm, relPath);
+
+  // Base fields (never overwrite)
+  if (!('type' in fm)) fm.type = type;
+  if (!('section' in fm)) fm.section = section;
+  if (!('created' in fm)) fm.created = created;
+  if (!('room' in fm)) fm.room = roomName || '';
+
+  // Type-specific defaults
+  if (type === 'content') {
+    if (!('methodology' in fm)) fm.methodology = '';
+    if (!('sources' in fm)) fm.sources = [];
+    if (!('related' in fm)) fm.related = [];
+    if (!('parent-moc' in fm)) fm['parent-moc'] = parentMocFor(section);
+    if (!('status' in fm)) fm.status = 'active';
+  } else if (type === 'meeting') {
+    if (!('speakers' in fm)) fm.speakers = [];
+    if (!('filed-to' in fm)) fm['filed-to'] = [];
+  } else if (type === 'team') {
+    if (!('role' in fm)) fm.role = '';
+    if (!('expertise' in fm)) fm.expertise = [];
+    if (!('contributions' in fm)) fm.contributions = [];
+  } else if (type === 'xref') {
+    if (!('source-artifact' in fm)) fm['source-artifact'] = '';
+    if (!('target-artifacts' in fm)) fm['target-artifacts'] = [];
+    if (!('relationship-type' in fm)) fm['relationship-type'] = '';
+  } else if (type === 'filed-to') {
+    if (!('filed_to' in fm)) fm.filed_to = '';
+    if (!('artifact_type' in fm)) fm.artifact_type = '';
+    if (!('source-meeting' in fm)) fm['source-meeting'] = '';
+  }
+
+  return serializeFrontmatter(fm, parsed.body);
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  FRONTMATTER_SCHEMA,
+  SYSTEM_FILES,
+  detectFileType,
+  enrichFrontmatter,
+  parseFrontmatter,
+  serializeFrontmatter,
+  extractSection,
+  extractDate,
+};