@mindrian_os/install 1.13.0-beta.11

package/lib/conversation/classifier.cjs

@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 99-02 -- conversation operator NL classifier
+ * ===================================================
+ * Heuristic, deterministic classifier. NO LLM round-trip
+ * (Phase 99 D-10). Same confidence threshold (transition_min_confidence
+ * sourced from classifier-rules.json) as Phase 100's JTBD classifier
+ * (D-12) -- single source of truth for "confident enough to act."
+ *
+ * Three input strata in order of weight (D-11):
+ *   1. Tool / command markers  (weight 0.95-1.0; short-circuit)
+ *   2. User-message intent patterns  (weight 0.3-0.7; accumulate per op)
+ *   3. Entity-introduction signals  (weight 0.3 each; boost EXPLORE_CAPTURE)
+ *
+ * Public API:
+ *   classify(input, currentState) -> { candidate_op, confidence, evidence, suggested_trigger }
+ *
+ * Rules externalized to lib/conversation/classifier-rules.json so the
+ * lexicon can be tuned without code edits. Schema documented in
+ * 99-02-PLAN.md task 1.
+ *
+ * Frame budget (Phase 99 D-23 corollary):  classify() < 5ms target.
+ * Regexes pre-compiled at module load.
+ *
+ * Canon Part 8 (LOCAL ONLY):
+ *   This module never queries Brain. Pure local string matching.
+ *
+ * Tier 0 fallback (Decision #8):
+ *   If classifier-rules.json is missing or corrupt, classify() returns
+ *   a null result with stratum='tier0' evidence. Never throws -- this
+ *   is hot-path code consumed by Phase 99-04 hooks.
+ *
+ * Pure CJS, node built-ins only, zero npm dependencies (Phase 87 invariant).
+ *
+ * License: BSL 1.1.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { OPERATORS, TRIGGERS } = require('./operator.cjs');
+
+const RULES_PATH = path.join(__dirname, 'classifier-rules.json');
+const HOOK_EVENT_TO_TRIGGER = {
+  PostToolUse: 'hook_post_tool_use',
+  Stop: 'hook_stop',
+  SessionStart: 'session_start',
+  UserPromptSubmit: 'user_message',
+  AskUserQuestion: 'hook_post_tool_use',
+};
+
+let RULES = null;
+let COMPILED = null; // { tool_markers: [{rule, matcher}], intent_patterns: [...], entity_signals: [...], thresholds }
+
+function loadRules() {
+  try {
+    const raw = fs.readFileSync(RULES_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed.schema_version !== '1.0.0') {
+      process.stderr.write('[classifier] schema_version mismatch in ' + RULES_PATH + '\n');
+      process.stderr.write('[classifier] got ' + parsed.schema_version + ', expected 1.0.0\n');
+      process.stderr.write('[classifier] tier-0 fallback engaged\n');
+      return null;
+    }
+    return parsed;
+  } catch (e) {
+    process.stderr.write('[classifier] cannot load rules at ' + RULES_PATH + '\n');
+    process.stderr.write('[classifier] ' + e.message + '\n');
+    process.stderr.write('[classifier] tier-0 fallback engaged\n');
+    return null;
+  }
+}
+
+function compileRule(rule) {
+  const pt = rule.pattern_type;
+  if (pt === 'regex') return new RegExp(rule.pattern);
+  if (pt === 'regex_ci') return new RegExp(rule.pattern, 'i');
+  if (pt === 'literal') return rule.pattern; // string for indexOf
+  if (pt === 'literal_ci') return rule.pattern.toLowerCase(); // lowercase for indexOf on lowercased input
+  throw new Error('unknown pattern_type: ' + pt);
+}
+
+function compileRules(rules) {
+  if (!rules) return null;
+  const compile = (arr) => arr.map((r) => ({ rule: r, matcher: compileRule(r) }));
+  return {
+    tool_markers: compile(rules.tool_markers),
+    intent_patterns: compile(rules.intent_patterns),
+    entity_signals: compile(rules.entity_signals),
+    thresholds: rules.thresholds,
+  };
+}
+
+RULES = loadRules();
+COMPILED = compileRules(RULES);
+
+function matches(text, rule, matcher) {
+  if (!text) return null;
+  const pt = rule.pattern_type;
+  if (pt === 'regex' || pt === 'regex_ci') {
+    const m = matcher.exec(text);
+    return m ? m[0] : null;
+  }
+  if (pt === 'literal') {
+    return text.indexOf(matcher) !== -1 ? matcher : null;
+  }
+  if (pt === 'literal_ci') {
+    return text.toLowerCase().indexOf(matcher) !== -1 ? matcher : null;
+  }
+  return null;
+}
+
+function exceptionFires(text, rule) {
+  if (!rule.exceptions || !Array.isArray(rule.exceptions)) return false;
+  for (const ex of rule.exceptions) {
+    if (text && text.indexOf(ex) === 0) return true;
+  }
+  return false;
+}
+
+function tier0Result() {
+  return {
+    candidate_op: null,
+    confidence: 0,
+    evidence: [{ stratum: 'tier0', match: 'rules_unavailable', weight: 0 }],
+    suggested_trigger: null,
+  };
+}
+
+function classify(input, currentState) {
+  if (!COMPILED) return tier0Result();
+  if (!input || typeof input !== 'object') return tier0Result();
+
+  const userMessage = input.user_message || '';
+  const toolInvocation = input.tool_invocation || '';
+  const hookEvent = input.hook_event || null;
+  const currentOp = (currentState && currentState.current) || 'JUST_TALK';
+
+  // --- Programmatic DECISION_GATE shortcut ---
+  if (hookEvent === 'AskUserQuestion') {
+    return {
+      candidate_op: 'DECISION_GATE',
+      confidence: 1.0,
+      evidence: [{ stratum: 'programmatic', match: 'AskUserQuestion', weight: 1.0 }],
+      suggested_trigger: 'hook_post_tool_use',
+    };
+  }
+
+  // --- Stratum 1: Tool / command markers (short-circuit on match) ---
+  // Check tool_invocation first, then user_message starting at position 0.
+  const sourcesForMarkers = [];
+  if (toolInvocation) sourcesForMarkers.push(toolInvocation);
+  if (userMessage) sourcesForMarkers.push(userMessage);
+
+  for (const src of sourcesForMarkers) {
+    for (const item of COMPILED.tool_markers) {
+      const rule = item.rule;
+      const matcher = item.matcher;
+      const m = matches(src, rule, matcher);
+      if (!m) continue;
+      if (exceptionFires(src, rule)) continue;
+      if (rule.from_required && rule.from_required !== currentOp) continue;
+      // target_op === null means "matched a /mos: command but no operator change" (e.g., /mos:status, /mos:operator)
+      if (rule.target_op === null) {
+        // Stop scanning more general /mos: markers below this one (e.g. /mos:operator should
+        // NOT then match the general /mos:[a-z-]+ METHODOLOGY rule). Return a no-transition result.
+        return {
+          candidate_op: null,
+          confidence: 0,
+          evidence: [{ stratum: 'tool_marker', match: m, weight: 0, target_op: null, comment: rule.comment || 'no-op tool marker' }],
+          suggested_trigger: null,
+        };
+      }
+      const trigger = rule.trigger || (hookEvent ? HOOK_EVENT_TO_TRIGGER[hookEvent] : 'user_message');
+      return {
+        candidate_op: rule.target_op,
+        confidence: rule.weight,
+        evidence: [{ stratum: 'tool_marker', match: m, weight: rule.weight, target_op: rule.target_op }],
+        suggested_trigger: trigger,
+      };
+    }
+  }
+
+  // --- Stratum 2: Intent patterns (accumulate per op) ---
+  const scores = {}; // { JUST_TALK: 0.7, BUILD_ROOM: 0.0, ... }
+  const evidence = [];
+  for (const op of OPERATORS) scores[op] = 0;
+
+  for (const item of COMPILED.intent_patterns) {
+    const rule = item.rule;
+    const matcher = item.matcher;
+    const m = matches(userMessage, rule, matcher);
+    if (!m) continue;
+    if (rule.from_required && rule.from_required !== currentOp) continue;
+    scores[rule.target_op] = Math.min(0.95, scores[rule.target_op] + rule.weight);
+    evidence.push({
+      stratum: 'intent_pattern',
+      match: rule.pattern,
+      weight: rule.weight,
+      target_op: rule.target_op,
+    });
+  }
+
+  // --- Stratum 3: Entity signals (boost EXPLORE_CAPTURE / boost_op) ---
+  for (const item of COMPILED.entity_signals) {
+    const rule = item.rule;
+    const matcher = item.matcher;
+    const m = matches(userMessage, rule, matcher);
+    if (!m) continue;
+    scores[rule.boost_op] = Math.min(1.0, scores[rule.boost_op] + rule.weight);
+    evidence.push({
+      stratum: 'entity_signal',
+      match: m,
+      weight: rule.weight,
+      target_op: rule.boost_op,
+      name: rule.name,
+    });
+  }
+
+  // --- Resolve candidate ---
+  let bestOp = null;
+  let bestScore = 0;
+  for (const op of OPERATORS) {
+    if (scores[op] > bestScore) {
+      bestScore = scores[op];
+      bestOp = op;
+    }
+  }
+
+  // Same op as current -> no transition (operator.validate rejects same->same anyway).
+  if (bestOp === currentOp) {
+    return {
+      candidate_op: null,
+      confidence: bestScore,
+      evidence: evidence.sort((a, b) => b.weight - a.weight),
+      suggested_trigger: null,
+    };
+  }
+
+  if (bestScore < COMPILED.thresholds.transition_min_confidence) {
+    return {
+      candidate_op: null,
+      confidence: bestScore,
+      evidence: evidence.sort((a, b) => b.weight - a.weight),
+      suggested_trigger: null,
+    };
+  }
+
+  const trigger = hookEvent ? HOOK_EVENT_TO_TRIGGER[hookEvent] || 'user_message' : 'user_message';
+  return {
+    candidate_op: bestOp,
+    confidence: bestScore,
+    evidence: evidence.sort((a, b) => b.weight - a.weight),
+    suggested_trigger: trigger,
+  };
+}
+
+module.exports = {
+  classify,
+  // Internal helpers exported for testability ONLY.
+  _internal: { loadRules, compileRules, RULES_PATH, HOOK_EVENT_TO_TRIGGER },
+};

package/lib/conversation/operator.cjs

@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 99-01 -- conversation operator state machine
+ * ===================================================
+ * Per-room conversation operator state primitive. Five operators
+ * (JUST_TALK, EXPLORE_CAPTURE, BUILD_ROOM, METHODOLOGY, DECISION_GATE)
+ * with 7 transition rules. State persists at
+ * <roomDir>/.mindrian/conversation-operator.json with schema_version
+ * "1.0.0". Atomic writes via mktemp + rename. Cold-start default
+ * JUST_TALK (Phase 99 D-04). History bounded at 50 entries with
+ * drop-oldest rotation (Phase 99 D-26).
+ *
+ * Every successful transition writes a typed OPERATOR_TRANSITION edge
+ * to the local graph (<roomDir>/.room-graph/room.db) per Canon Part 4.
+ * If the graph database is absent, the edge write is silently skipped;
+ * the state file write still succeeds (graceful degradation per
+ * Decision #8).
+ *
+ * Public API:
+ *   getCurrent(roomDir) -> state object (or JUST_TALK default if file absent)
+ *   transition(roomDir, to, trigger, contextDelta) -> { success, current, previous, entered_at } | { success: false, violations }
+ *   validate(from, to, trigger) -> { valid: true } | { valid: false, reason }
+ *
+ * Frame budget (Phase 99 D-23, D-24):
+ *   getCurrent < 1ms target
+ *   transition < 5ms target
+ *
+ * Canon Part 8 (LOCAL ONLY):
+ *   This module never queries Brain. Never writes to Brain. The
+ *   five-operator vocabulary is generic; even if a future phase
+ *   ever ships cross-room operator pattern queries, only the generic
+ *   names would egress -- never user content. Phase 99 ships zero
+ *   Brain surface.
+ *
+ * Pure CJS, node built-ins only, zero npm dependencies (Phase 87 invariant).
+ *
+ * License: BSL 1.1.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+// ---------- Constants ----------
+
+const SCHEMA_VERSION = '1.0.0';
+const OPERATORS = ['JUST_TALK', 'EXPLORE_CAPTURE', 'BUILD_ROOM', 'METHODOLOGY', 'DECISION_GATE'];
+const TRIGGERS = ['session_start', 'user_message', 'mos_command', 'operator_change', 'hook_post_tool_use', 'hook_stop', 'manual_set', 'manual_reset'];
+const HISTORY_MAX = 50;
+
+// Transition rules (Phase 99 CONTEXT.md D-08).
+// Format: { from: <operator>|'ANY', to: <operator>|'previous', triggers: [<allowed triggers>] }
+//
+// 9 rules total. The 2 ANY-source overrides (ANY -> BUILD_ROOM, ANY -> METHODOLOGY)
+// were added during Phase 99 wave-1 integration (Canon Part 3 Decision-Gate verbs
+// "Run Methodology" / "/mos:room <section>" are available at every gate; bypass the
+// strict pedagogy progression). Plan 99-02 classifier T4 cross-check depends on
+// these two rules existing.
+const TRANSITION_RULES = [
+  { from: 'ANY', to: 'JUST_TALK', triggers: ['user_message', 'manual_set', 'manual_reset'] },
+  { from: 'JUST_TALK', to: 'EXPLORE_CAPTURE', triggers: ['user_message', 'manual_set'] },
+  { from: 'EXPLORE_CAPTURE', to: 'BUILD_ROOM', triggers: ['user_message', 'mos_command', 'manual_set'] },
+  { from: 'ANY', to: 'BUILD_ROOM', triggers: ['mos_command', 'user_message', 'manual_set'] },
+  { from: 'BUILD_ROOM', to: 'METHODOLOGY', triggers: ['mos_command', 'hook_post_tool_use', 'manual_set'] },
+  { from: 'ANY', to: 'METHODOLOGY', triggers: ['mos_command', 'manual_set'] },
+  { from: 'METHODOLOGY', to: 'BUILD_ROOM', triggers: ['mos_command', 'hook_post_tool_use', 'manual_set'] },
+  { from: 'ANY', to: 'DECISION_GATE', triggers: ['mos_command', 'hook_post_tool_use', 'manual_set'] },
+  { from: 'DECISION_GATE', to: 'previous', triggers: ['user_message', 'hook_post_tool_use', 'manual_set'] },
+];
+
+// ---------- Validation ----------
+
+function validate(from, to, trigger) {
+  if (!OPERATORS.includes(from)) {
+    return { valid: false, reason: `invalid 'from' operator: ${from}` };
+  }
+  if (to !== 'previous' && !OPERATORS.includes(to)) {
+    return { valid: false, reason: `invalid 'to' operator: ${to}` };
+  }
+  if (!TRIGGERS.includes(trigger)) {
+    return { valid: false, reason: `invalid trigger: ${trigger}` };
+  }
+  if (from === to) {
+    return { valid: false, reason: `no-op transition: ${from} -> ${to}` };
+  }
+  for (const rule of TRANSITION_RULES) {
+    const fromOk = rule.from === 'ANY' || rule.from === from;
+    const toOk = rule.to === to;
+    const trigOk = rule.triggers.includes(trigger);
+    if (fromOk && toOk && trigOk) return { valid: true };
+  }
+  return { valid: false, reason: `no rule matches: ${from} -> ${to} via ${trigger}` };
+}
+
+// ---------- State path + default ----------
+
+function statePath(roomDir) {
+  return path.join(roomDir, '.mindrian', 'conversation-operator.json');
+}
+
+function defaultState(roomDir) {
+  return {
+    schema_version: SCHEMA_VERSION,
+    current: 'JUST_TALK',
+    previous: null,
+    entered_at: new Date().toISOString(),
+    context: {
+      active_room: path.basename(roomDir),
+      active_section: null,
+      methodology_in_flight: null,
+      decision_gate_pending: null,
+    },
+    history: [],
+  };
+}
+
+// ---------- getCurrent ----------
+
+function getCurrent(roomDir) {
+  const p = statePath(roomDir);
+  if (!fs.existsSync(p)) return defaultState(roomDir);
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf8');
+  } catch (e) {
+    process.stderr.write(`[operator] read error at ${p}\n`);
+    process.stderr.write(`[operator] ${e.message}\n`);
+    process.stderr.write(`[operator] falling back to JUST_TALK default\n`);
+    return defaultState(roomDir);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    process.stderr.write(`[operator] corrupt JSON at ${p}\n`);
+    process.stderr.write(`[operator] ${e.message}\n`);
+    process.stderr.write(`[operator] falling back to JUST_TALK default\n`);
+    return defaultState(roomDir);
+  }
+  if (parsed.schema_version !== SCHEMA_VERSION) {
+    process.stderr.write(`[operator] schema_version mismatch: got ${parsed.schema_version}, expected ${SCHEMA_VERSION}\n`);
+    process.stderr.write(`[operator] file ${p}\n`);
+    process.stderr.write(`[operator] falling back to JUST_TALK default\n`);
+    return defaultState(roomDir);
+  }
+  if (!OPERATORS.includes(parsed.current)) {
+    process.stderr.write(`[operator] invalid current operator: ${parsed.current}\n`);
+    process.stderr.write(`[operator] file ${p}\n`);
+    process.stderr.write(`[operator] falling back to JUST_TALK default\n`);
+    return defaultState(roomDir);
+  }
+  return parsed;
+}
+
+// ---------- Atomic write ----------
+
+function writeStateAtomic(roomDir, state) {
+  const dir = path.join(roomDir, '.mindrian');
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const finalPath = path.join(dir, 'conversation-operator.json');
+  // mktemp inside SAME directory for POSIX-atomic rename
+  const rand = crypto.randomBytes(6).toString('hex');
+  const tmpPath = path.join(dir, `.conversation-operator.json.${rand}`);
+  // Serialize with schema_version FIRST (D-06)
+  const ordered = {
+    schema_version: SCHEMA_VERSION,
+    current: state.current,
+    previous: state.previous,
+    entered_at: state.entered_at,
+    context: state.context,
+    history: state.history,
+  };
+  fs.writeFileSync(tmpPath, JSON.stringify(ordered, null, 2), 'utf8');
+  fs.renameSync(tmpPath, finalPath);
+}
+
+// ---------- OPERATOR_TRANSITION edge writer ----------
+
+function writeOperatorTransitionEdge(roomDir, from, to, trigger, contextDelta) {
+  const graphDir = path.join(roomDir, '.room-graph');
+  const dbPath = path.join(graphDir, 'room.db');
+  if (!fs.existsSync(dbPath)) return; // graceful: no graph yet, skip
+  let db;
+  try {
+    // node:sqlite is available in Node 22+ (matches lib/core/lazygraph-ops.cjs).
+    // Phase 87 invariant: zero new runtime deps. Use node:sqlite (built-in) only.
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(dbPath);
+  } catch (_e) {
+    // Either node:sqlite unavailable (older Node) OR DB locked. Silent skip.
+    return;
+  }
+  try {
+    const props = JSON.stringify({
+      trigger,
+      timestamp: new Date().toISOString(),
+      entities_introduced: contextDelta && Array.isArray(contextDelta.entities_introduced) ? contextDelta.entities_introduced : [],
+      methodology: contextDelta && contextDelta.methodology_in_flight ? contextDelta.methodology_in_flight : null,
+    });
+    // Insert nodes (idempotent) before edge
+    const insNode = db.prepare(`INSERT OR IGNORE INTO nodes(id, type) VALUES (?, ?)`);
+    insNode.run(from, 'operator');
+    insNode.run(to, 'operator');
+    const stmt = db.prepare(`INSERT OR IGNORE INTO edges(source, target, type, properties) VALUES (?, ?, 'OPERATOR_TRANSITION', ?)`);
+    stmt.run(from, to, props);
+  } catch (_e) {
+    // Schema mismatch (e.g., older graph without nodes table) -- silent skip
+  } finally {
+    try { db.close(); } catch (_) { /* best-effort */ }
+  }
+}
+
+// ---------- transition ----------
+
+function transition(roomDir, to, trigger, contextDelta = {}) {
+  const state = getCurrent(roomDir);
+  const from = state.current;
+
+  // Validate against the ORIGINAL `to` (which may be the literal string
+  // 'previous' for the DECISION_GATE -> previous rule per D-08). The rule
+  // table records `to: 'previous'` literally; resolving before validate
+  // would prevent the rule from matching.
+  const v = validate(from, to, trigger);
+  if (!v.valid) {
+    return { success: false, violations: [{ category: 'transition', severity: 'error', message: v.reason }] };
+  }
+
+  // Resolve `to === 'previous'` to state.previous for the actual write.
+  let resolvedTo = to;
+  if (to === 'previous') {
+    if (!state.previous) {
+      return { success: false, violations: [{ category: 'transition', severity: 'error', message: `cannot transition to 'previous': no previous operator recorded` }] };
+    }
+    resolvedTo = state.previous;
+  }
+
+  const now = new Date().toISOString();
+  const nextHistory = state.history.slice();
+  nextHistory.push({ op: resolvedTo, from, to: resolvedTo, trigger, ts: now });
+  if (nextHistory.length > HISTORY_MAX) {
+    nextHistory.splice(0, nextHistory.length - HISTORY_MAX); // drop-oldest (D-26)
+  }
+
+  const nextContext = Object.assign({}, state.context, contextDelta || {});
+  // Always reset active_room to current basename in case roomDir changed
+  nextContext.active_room = path.basename(roomDir);
+
+  const nextState = {
+    schema_version: SCHEMA_VERSION,
+    current: resolvedTo,
+    previous: from,
+    entered_at: now,
+    context: nextContext,
+    history: nextHistory,
+  };
+
+  try {
+    writeStateAtomic(roomDir, nextState);
+  } catch (e) {
+    return { success: false, violations: [{ category: 'io', severity: 'error', message: `atomic write failed: ${e.message}` }] };
+  }
+
+  // Best-effort graph edge write (silent on failure)
+  try { writeOperatorTransitionEdge(roomDir, from, resolvedTo, trigger, contextDelta); } catch (_) { /* graceful */ }
+
+  return { success: true, current: resolvedTo, previous: from, entered_at: now };
+}
+
+// ---------- Exports ----------
+
+module.exports = {
+  // Public API
+  getCurrent,
+  transition,
+  validate,
+  // Constants (consumed by 99-02 classifier, 99-04 hooks, 99-05 command)
+  OPERATORS,
+  TRIGGERS,
+  TRANSITION_RULES,
+  SCHEMA_VERSION,
+  HISTORY_MAX,
+  // Internal helpers exported for testability ONLY (do not consume from production code)
+  _internal: { statePath, defaultState, writeStateAtomic, writeOperatorTransitionEdge },
+};

package/lib/copy/115-spec-strings.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+/*
+ * Phase 115 -- Owned Emotion Spec Strings (single source of truth)
+ * =================================================================
+ * Per 115-RESEARCH.md `## Pitfalls and Failure Modes` Pitfall 1 mitigation,
+ * every downstream surface rewrite imports from this file rather than
+ * hardcoding spec strings. Frozen at ship; D-20 rollback only mutates
+ * the per-string values, never the module shape.
+ *
+ * Sources:
+ *   D-02..D-05 verbatim from the-owned-emotion.md `## Design implications`
+ *   D-06..D-09 from 115-CONTEXT.md `<decisions>`
+ *   D-17 default initialPrompt from 115-RESEARCH.md DISCRETION-02 Resolution
+ *
+ * Canon: Part 10 sub-claim 2 ("Conversation IS the surface").
+ *
+ * Hard rules (CLAUDE.md): no emoji, no em-dashes; hyphens only in copy.
+ *   The string "can't" uses U+0027 APOSTROPHE; "Let's" uses U+0027.
+ *   Spec strings are ASCII-7 except for the apostrophes which are U+0027.
+ */
+
+const SPEC_STRINGS = Object.freeze({
+  // D-02 /mos:splash copy
+  SPLASH_COPY: "Stuck on a decision you can't name? Let's find the shape of it.",
+
+  // D-03 /mos:new-project first message
+  NEW_PROJECT_OPENER: "I'm Larry. What decision is stuck?",
+
+  // D-04 marketing line (also used as D-08 README hero + D-09 website hero)
+  MARKETING_LINE: "For founders stuck on a decision they can't name.",
+
+  // D-05 Dror 2.0 test subject criteria
+  DROR_TEST_CRITERIA: "a founder who is stuck on a decision right now and cannot name it.",
+
+  // D-06 / D-17 default initialPrompt (the platform-fired turn-1 string for
+  // agents/larry-extended.md; persona_variants.default echoes this verbatim
+  // per RESEARCH DISCRETION-02 resolution)
+  INITIAL_PROMPT_DEFAULT: "I'm Larry. What decision is stuck? (Tell me, or paste a doc/CV.)",
+
+  // D-07 /mos:onboard opening framing (lead-with-emotion paragraph; lands
+  // BEFORE methodology pitch in commands/onboard.md Step 1)
+  ONBOARD_OPENING_FRAMING: "Very simply -- if you're here, you're probably stuck on a decision you can't quite name. That's the feeling MindrianOS is built for. Let's find the shape of it together.",
+
+  // D-08 README hero tagline (alias of MARKETING_LINE; surface is the GitHub
+  // front door + marketplace listing source)
+  README_HERO_TAGLINE: "For founders stuck on a decision they can't name.",
+
+  // D-09 website hero tagline (alias of MARKETING_LINE; out-of-repo
+  // deliverable applied manually to ~/mindrian-website/ post-merge per
+  // CHANGELOG action item -- Pitfall 4)
+  WEBSITE_HERO_TAGLINE: "For founders stuck on a decision they can't name.",
+});
+
+module.exports = SPEC_STRINGS;

package/lib/core/__nav-stub.cjs

@@ -0,0 +1,14 @@
+'use strict';
+// Auto-generated by shallow-doc-parser.test.cjs. DO NOT edit by hand; the
+// surface is defined to mirror lib/core/navigation.cjs as Phase 115-02
+// expects to consume it (sessionId/nodeId/setBy form for setFocus,
+// sessionId/eventType/payload form for recordMemoryEvent).
+const calls = { setFocus: [], memoryEvents: [], getActiveFocus: [] };
+function reset() { calls.setFocus.length = 0; calls.memoryEvents.length = 0; calls.getActiveFocus.length = 0; }
+module.exports = {
+  setFocus: function (sid, nid, sb) { calls.setFocus.push({ sid: sid, nid: nid, sb: sb }); return { ok: true, eventId: 'stub-evt-' + calls.setFocus.length }; },
+  recordMemoryEvent: function (sid, type, payload) { calls.memoryEvents.push({ sid: sid, type: type, payload: payload }); return { ok: true, eventId: 'stub-mem-' + calls.memoryEvents.length }; },
+  getActiveFocus: function (sid) { calls.getActiveFocus.push({ sid: sid }); return null; },
+  __calls: calls,
+  __reset: reset,
+};