monomind 2.7.4 → 2.7.6

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/pin.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Pin/unpin sub-commands as standalone skill shortcuts.
+ *
+ * Usage:
+ *   node <scripts_path>/pin.mjs pin <command>
+ *   node <scripts_path>/pin.mjs unpin <command>
+ *
+ * `pin audit` creates a lightweight audit skill that redirects to Monodesign's audit workflow.
+ * `unpin audit` removes that shortcut.
+ *
+ * The script discovers harness directories (.claude/skills, .cursor/skills, etc.)
+ * in the project root and creates/removes the pin in all of them.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { basename, join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// All known harness directories
+const HARNESS_DIRS = [
+  '.claude', '.cursor', '.gemini', '.codex', '.agents',
+  '.trae', '.trae-cn', '.pi', '.opencode', '.kiro', '.rovodev',
+];
+
+const CODEX_HARNESSES = new Set(['.codex', '.agents']);
+
+// Valid sub-command names
+const VALID_COMMANDS = [
+  'craft', 'init', 'extract', 'document', 'shape',
+  'critique', 'audit',
+  'polish', 'bolder', 'quieter', 'distill', 'harden', 'onboard', 'live',
+  'animate', 'colorize', 'typeset', 'layout', 'delight', 'overdrive',
+  'clarify', 'adapt', 'optimize',
+];
+
+// Marker to identify pinned skills (so unpin doesn't delete user skills)
+const PIN_MARKER = '<!-- monodesign-pinned-skill -->';
+
+/**
+ * Walk up from startDir to find a project root.
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  while (dir !== '/') {
+    if (
+      existsSync(join(dir, 'package.json')) ||
+      existsSync(join(dir, '.git')) ||
+      existsSync(join(dir, 'skills-lock.json'))
+    ) {
+      return dir;
+    }
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(startDir);
+}
+
+/**
+ * Find harness skill directories that have an monodesign skill installed.
+ */
+function findHarnessDirs(projectRoot) {
+  const dirs = [];
+  for (const harness of HARNESS_DIRS) {
+    const skillsDir = join(projectRoot, harness, 'skills');
+    // Only pin in harness dirs that already have monodesign installed
+    const monodesignDir = join(skillsDir, 'monodesign');
+    if (existsSync(monodesignDir) || existsSync(join(skillsDir, 'i-monodesign'))) {
+      dirs.push(skillsDir);
+    }
+  }
+  return dirs;
+}
+
+/**
+ * Load command metadata (descriptions for pinned skills).
+ */
+function loadCommandMetadata() {
+  const metadataPath = join(__dirname, 'command-metadata.json');
+  if (existsSync(metadataPath)) {
+    return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+  }
+  return {};
+}
+
+/**
+ * Generate a pinned skill's SKILL.md content.
+ */
+function commandPrefixForSkillsDir(skillsDir) {
+  return CODEX_HARNESSES.has(basename(dirname(skillsDir))) ? '$' : '/';
+}
+
+function generatePinnedSkill(command, metadata, commandPrefix) {
+  const desc = metadata[command]?.description || `Shortcut for ${commandPrefix}monodesign ${command}.`;
+  const hint = metadata[command]?.argumentHint || '[target]';
+
+  return `---
+name: ${command}
+description: "${desc}"
+argument-hint: "${hint}"
+user-invocable: true
+---
+
+${PIN_MARKER}
+
+This is a pinned shortcut for \`${commandPrefix}monodesign ${command}\`.
+
+Invoke ${commandPrefix}monodesign ${command}, passing along any arguments provided here, and follow its instructions.
+`;
+}
+
+/**
+ * Pin a command: create shortcut skill in all harness dirs.
+ */
+function pin(command, projectRoot) {
+  const metadata = loadCommandMetadata();
+  const harnessDirs = findHarnessDirs(projectRoot);
+
+  if (harnessDirs.length === 0) {
+    console.log('No harness directories with monodesign installed found.');
+    return false;
+  }
+
+  let created = 0;
+
+  for (const skillsDir of harnessDirs) {
+    const commandPrefix = commandPrefixForSkillsDir(skillsDir);
+    const content = generatePinnedSkill(command, metadata, commandPrefix);
+    // Check if skill already exists (and isn't a pin)
+    const skillDir = join(skillsDir, command);
+    if (existsSync(skillDir)) {
+      const existingMd = join(skillDir, 'SKILL.md');
+      if (existsSync(existingMd)) {
+        const existing = readFileSync(existingMd, 'utf-8');
+        if (!existing.includes(PIN_MARKER)) {
+          console.log(`  SKIP: ${skillDir} (non-pinned skill already exists)`);
+          continue;
+        }
+      }
+    }
+
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), content, 'utf-8');
+    console.log(`  + ${skillDir}`);
+    created++;
+  }
+
+  if (created > 0) {
+    console.log(`\nPinned '${command}' as a standalone shortcut in ${created} location(s).`);
+    console.log('Use the pinned command directly in each harness.');
+  }
+
+  return created > 0;
+}
+
+/**
+ * Unpin a command: remove shortcut skill from all harness dirs.
+ */
+function unpin(command, projectRoot) {
+  const harnessDirs = findHarnessDirs(projectRoot);
+  let removed = 0;
+
+  for (const skillsDir of harnessDirs) {
+    const skillDir = join(skillsDir, command);
+    if (!existsSync(skillDir)) continue;
+
+    const skillMd = join(skillDir, 'SKILL.md');
+    if (!existsSync(skillMd)) continue;
+
+    // Safety: only remove if it's a pinned skill
+    const content = readFileSync(skillMd, 'utf-8');
+    if (!content.includes(PIN_MARKER)) {
+      console.log(`  SKIP: ${skillDir} (not a pinned skill)`);
+      continue;
+    }
+
+    rmSync(skillDir, { recursive: true, force: true });
+    console.log(`  - ${skillDir}`);
+    removed++;
+  }
+
+  if (removed > 0) {
+    console.log(`\nUnpinned '${command}' from ${removed} location(s).`);
+    console.log(`Use Monodesign's '${command}' workflow directly to access it.`);
+  } else {
+    console.log(`No pinned '${command}' shortcut found.`);
+  }
+
+  return removed > 0;
+}
+
+// --- CLI ---
+const [,, action, command] = process.argv;
+
+if (!action || !command) {
+  console.log('Usage: node pin.mjs <pin|unpin> <command>');
+  console.log(`\nAvailable commands: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+if (action !== 'pin' && action !== 'unpin') {
+  console.error(`Unknown action: ${action}. Use 'pin' or 'unpin'.`);
+  process.exit(1);
+}
+
+if (!VALID_COMMANDS.includes(command)) {
+  console.error(`Unknown command: ${command}`);
+  console.error(`Available commands: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+const root = findProjectRoot();
+
+if (action === 'pin') {
+  pin(command, root);
+} else {
+  unpin(command, root);
+}

package/packages/@monomind/cli/.claude/skills/monodesign/shape.md

@@ -0,0 +1,71 @@
+---
+name: monodesign-shape
+description: Shape the UX and UI for a feature before any code is written — produces a structured design brief through discovery, not guesswork. Design planning only; no code written. Output is a brief for monodesign:craft.
+type: design-sub-command
+argument-hint: "[feature description]"
+user-invocable: true
+---
+
+# Monodesign: Shape
+
+Shape the UX and UI for a feature before any code is written. This command produces a **design brief**: a structured artifact that guides implementation through discovery.
+
+**Scope**: Design planning only. No code written. Output: a design brief for `/monodesign craft`.
+
+## Setup
+Read `PRODUCT.md` and (if present) `DESIGN.md` from the project root before starting. These are required anchors.
+
+Read `reference/shape.md` from the monodesign skill directory for the full command flow.
+
+## Phase 1: Discovery Interview
+
+Do NOT write any code or make design decisions during this phase. Ask 2–3 questions per round, then wait for answers. Have a natural dialogue; don't dump all questions at once.
+
+**Purpose & Context**
+- What is this feature for? What problem does it solve?
+- Who specifically will use it? (Role, context, frequency — not "users")
+- What's the user's state of mind when they reach this? (Rushed? Exploring? Anxious?)
+
+**Content & Data**
+- What content or data does this display or collect?
+- What are the realistic ranges? (0 items, typical, max, edge cases)
+- What are the empty state, error state, first-time use, power-user scenarios?
+
+**Design Direction** — force a visual decision on three fronts:
+- **Color strategy**: Restrained / Committed / Full palette / Drenched
+- **Theme via scene sentence**: one sentence of physical context that forces dark vs. light
+- **Two or three named anchor references** — specific products, brands, objects (not adjectives)
+
+**Scope** — always ask explicitly:
+- Fidelity: Sketch / mid-fi / high-fi / production-ready?
+- Breadth: One screen / a flow / a whole surface?
+- Time intent: Quick exploration or polish until it ships?
+
+## Phase 2: Brief Synthesis
+
+After the discovery round, synthesize and present a structured **Design Brief**:
+
+```
+## Design Brief: [Feature Name]
+
+**User**: [concrete description]
+**Problem**: [one sentence]
+**Success**: [measurable outcome]
+**User state**: [emotional/contextual state]
+
+**Content**: [what's displayed/collected + realistic ranges]
+**Edge cases**: [empty, error, overload, first-use]
+
+**Visual direction**:
+- Color strategy: [Restrained|Committed|Full palette|Drenched]
+- Theme: [dark|light] — [scene sentence]
+- References: [3 named references]
+
+**Scope**: [fidelity] / [breadth] / [time intent]
+```
+
+Stop and wait for explicit user confirmation before advancing to `/monodesign craft`. Do not start coding until the brief is approved.
+
+## Assert-then-confirm
+
+When PRODUCT.md and the prompt make one option obvious, name it and ask the user to confirm or override. Don't present four-option menus when the answer is already clear.

package/packages/@monomind/cli/.claude/skills/monodesign/teach.md

@@ -0,0 +1,18 @@
+---
+name: monodesign-teach
+description: Alias of /monodesign init — set up a project for monodesign by producing PRODUCT.md (strategic context), optionally DESIGN.md (visual system), and pre-configuring live mode.
+type: design-sub-command
+argument-hint: "[project path or description]"
+user-invocable: true
+---
+
+# Monodesign: Teach (alias of Init)
+
+`teach` is the historical name for the setup command and remains fully supported; it is an alias of `init`. Both invocations behave identically.
+
+Follow `commands/init.md` and the authoritative flow in `reference/init.md` from the monodesign skill directory: one codebase crawl plus a short strategic interview produces **PRODUCT.md** (register, users, purpose, brand personality, anti-references, design principles), offers **DESIGN.md** via `/monodesign document`, and pre-configures `.monodesign/live/config.json` for `/monodesign live`.
+
+Notes preserved from the teach era:
+
+- A legacy `.monodesign.md` at the project root is auto-renamed to `PRODUCT.md` by the context loader; mention this once and merge into that content rather than starting fresh.
+- If teach was invoked as a setup blocker by another monodesign command, complete the init flow, then resume the original task with the fresh context.

package/packages/@monomind/cli/.claude/skills/monodesign/typeset.md

@@ -0,0 +1,59 @@
+---
+name: monodesign-typeset
+description: Replace generic type defaults with fonts that reflect the brand and scale with intentional contrast — font selection, hierarchy, scale, and responsive type systems.
+type: design-sub-command
+argument-hint: "[target page, component, or whole site]"
+user-invocable: true
+---
+
+# Monodesign: Typeset
+
+Typography carries most of the information on the page. Replace generic defaults (Inter, Roboto, system fallback at flat scale) with type that reflects the brand and scales with intentional contrast.
+
+Read `reference/typeset.md` and `reference/typography.md` from the monodesign skill directory for the full protocol.
+
+## Register
+
+**Brand**: font selection procedure in `reference/brand.md`. Fluid `clamp()` scale, ≥1.25 ratio between steps.
+
+**Product**: system fonts and familiar sans stacks are legitimate. One well-tuned family typically carries the whole UI. Fixed `rem` scale, 1.125–1.2 ratio.
+
+## Assess Current Typography
+
+**Font choices**
+- Are we using invisible defaults? (Inter, Roboto, Arial, Open Sans, system defaults)
+- Does the font match the brand personality?
+- Are there too many families? (More than 2–3 is almost always a mess)
+
+**Hierarchy**
+- Can you tell headings from body from captions at a glance?
+- Are sizes too close together? (14px, 15px, 16px = muddy hierarchy)
+- Are weight contrasts strong enough? (Medium vs Regular is barely visible)
+
+**Sizing & scale**
+- Is there a consistent type scale, or are sizes arbitrary?
+- Body text ≥16px?
+- Fixed `rem` scales for app UIs; fluid `clamp()` for marketing/content page headings
+
+## Typographic Rules (non-negotiable)
+
+- Cap body line length at **65–75ch**
+- Hero/display heading ceiling: `clamp()` max ≤ **6rem (~96px)**
+- Display letter-spacing floor: **≥ -0.04em** (anything tighter makes letters touch)
+- Use `text-wrap: balance` on h1–h3; `text-wrap: pretty` on long prose
+- Pair fonts on a contrast axis (serif + sans, geometric + humanist) — NOT similar families
+- Hierarchy through scale + weight contrast (≥1.25 ratio between steps)
+
+## Font Selection Process
+
+1. Load brand context from PRODUCT.md and DESIGN.md
+2. Identify brand personality from 3 words or the product description
+3. Propose 2–3 Google Fonts / variable font pairings with rationale
+4. Load one via `<link>` and demonstrate it on a real page section
+5. Iterate until the type feels native to the brand
+
+## Output
+
+- Updated CSS custom properties or tokens for `--font-heading`, `--font-body`, `--font-mono`
+- Fluid or fixed type scale as CSS custom properties
+- Applied to all heading levels and body copy on the target

package/packages/@monomind/cli/bin/cli.js

@@ -287,7 +287,30 @@ if (isMCPMode) {
   const isDaemonChild = cliArgs.includes('--foreground-worker-internal');
   cli.run().then(() => {
     if (!isDaemonChild) {
-      process.exit(process.exitCode ?? 0);
+      // Do NOT call process.exit() here. See
+      // docs/adrs/ADR-R001-onnxruntime-process-teardown.md.
+      //
+      // Any command that touched embeddings has onnxruntime-node's thread pool
+      // loaded in-process (memory-bridge -> @huggingface/transformers), and
+      // forcing exit out from under it aborts:
+      //   libc++abi: terminating due to uncaught exception of type
+      //   std::__1::system_error: mutex lock failed: Invalid argument
+      // — exit code 134 on `doctor`, `memory store`, `memory search` etc.,
+      // despite the command itself having succeeded. Disposing the pipeline
+      // first does NOT help; only letting the loop drain does. (v2.7.4 bug,
+      // fixed 2.7.5. Guarded by src/__tests__/bin-cli-exit-path.test.ts.)
+      //
+      // NOTE the rule inverts for short-lived worker children, where onnx
+      // instead keeps the loop alive forever and you MUST force-exit — see
+      // src/routing/embed-worker.ts. Do not "unify" the two.
+      //
+      // So: publish the exit code and let node exit on its own once the loop
+      // empties. The unref'd timer below still fires if something lingers
+      // (it does not itself hold the process open), preserving the original
+      // guarantee that the CLI never hangs forever on a stray handle.
+      process.exitCode = process.exitCode ?? 0;
+      const FORCE_EXIT_MS = 5000;
+      setTimeout(() => process.exit(process.exitCode ?? 0), FORCE_EXIT_MS).unref();
     }
     // Daemon child: let the event loop stay alive on its own ref'd interval.
   }).catch((error) => {

package/packages/@monomind/cli/dist/src/commands/cleanup.js

@@ -7,6 +7,11 @@
 import { output } from '../output.js';
 import { existsSync, lstatSync, rmSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
+// Static imports: this package is ESM ("type": "module"), so a bare require()
+// here throws "require is not defined" in the built output even though it
+// typechecks and passes tests. Guarded by no-cjs-require-in-esm.test.ts.
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
 /**
  * Artifact directories and files that monomind/monomind may create
  */
@@ -381,7 +386,6 @@ export const cleanupCommand = {
             // process actually looks like ours before signaling it.
             const looksLikeOurProcess = (pid) => {
                 try {
-                    const { execSync } = require('child_process');
                     const cmd = execSync(`ps -p ${pid} -o command=`, { timeout: 2000, encoding: 'utf-8' }).trim();
                     // Covers direct `node ...` spawns as well as the npx fallback in
                     // control-start.cjs's findCliPath(), which shows up in `ps` as
@@ -427,7 +431,7 @@ export const cleanupCommand = {
             }
             // Kill stale MCP server processes
             const mcpPidPaths = [
-                join(require('os').homedir(), '.monomind', 'mcp.pid'),
+                join(homedir(), '.monomind', 'mcp.pid'),
                 join(cwd, '.monomind', 'mcp-server.pid'),
             ];
             for (const pp of mcpPidPaths) {

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -23,6 +23,9 @@ export declare function fixStaleHelpers(): Promise<boolean>;
 export declare function checkHelpersFresh(): Promise<HealthCheck>;
 export declare function checkMonoesIntegration(): Promise<HealthCheck>;
 export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
+/** Creates or appends the missing gitignore entries. Returns true if it wrote.
+ *  Append-only and idempotent: never rewrites lines the user already has. */
+export declare function fixGitignoreCoverage(): Promise<boolean>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 /**

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -2,7 +2,7 @@
  * Doctor — project/monomind health checks
  * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
-import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, writeFileSync, appendFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
@@ -476,24 +476,97 @@ const REQUIRED_GITIGNORE_PATTERNS = [
     { pattern: '.hive-mind/', reason: 'hive-mind state with session info' },
     { pattern: '.swarm/', reason: 'swarm state files' },
 ];
+/** Strip the parts that don't change what a pattern matches, so `**​/.monomind/`,
+ *  `.monomind/` and `.monomind` all compare equal. A gitignore pattern with no
+ *  leading slash already matches at every depth, so `**​/` is redundant. */
+function normalizeGitignorePattern(p) {
+    return p.replace(/^\/+/, '').replace(/^\*\*\//, '').replace(/\/+$/, '');
+}
+/** True when ignoring `line` already protects everything `required` covers.
+ *  Beyond exact matches this understands directory containment: a repo with a
+ *  blanket `.monomind/` is fully covered for `.monomind/sessions/`,
+ *  `.monomind/*.json` and friends, and should not be nagged to add each one. */
+function gitignoreLineCovers(line, required) {
+    const l = normalizeGitignorePattern(line);
+    const r = normalizeGitignorePattern(required);
+    if (!l)
+        return false;
+    if (l === r)
+        return true;
+    // A bare directory entry covers every path beneath it, but only when the
+    // entry itself is literal — `.monomind/*.json` must not be treated as an
+    // ancestor of `.monomind/sessions`.
+    return !l.includes('*') && r.startsWith(`${l}/`);
+}
 export async function checkGitignoreCoverage() {
     const gitignorePath = join(process.cwd(), '.gitignore');
     if (!existsSync(gitignorePath)) {
-        return { name: 'Gitignore Coverage', status: 'warn', message: 'No .gitignore found — all monomind runtime paths are unprotected', fix: 'echo ".monomind/\\n**/.monomind/" >> .gitignore' };
+        // The old hint was `echo ".monomind/\n**/.monomind/" >> .gitignore`, which
+        // writes a literal backslash-n (sh/bash echo does not interpret escapes
+        // without -e) — one junk line matching nothing. `--fix` now writes the file
+        // directly, so point at that rather than at a command to copy-paste.
+        return { name: 'Gitignore Coverage', status: 'warn', message: 'No .gitignore found — all monomind runtime paths are unprotected', fix: 'monomind doctor --fix   (creates .gitignore covering .monomind/ and secrets)' };
     }
     if (statSync(gitignorePath).size > MAX_DOCTOR_GITIGNORE_BYTES) {
         return { name: 'Gitignore Coverage', status: 'warn', message: '.gitignore too large to parse' };
     }
     const lines = readFileSync(gitignorePath, 'utf-8').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
-    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => {
-        const base = pattern.replace(/\*\*\//g, '').replace(/\*/g, '');
-        return !lines.some(l => l === pattern || l === pattern.replace(/\/$/, '') ||
-            (l.includes('**') && base && l.replace(/\*\*\//g, '').replace(/\*/g, '') === base));
-    });
+    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => !lines.some(l => gitignoreLineCovers(l, pattern)));
     if (missing.length === 0)
         return { name: 'Gitignore Coverage', status: 'pass', message: 'All monomind runtime paths are gitignored' };
     const missingList = missing.map(m => m.pattern).join(', ');
-    return { name: 'Gitignore Coverage', status: 'warn', message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`, fix: `printf "${missing.map(m => m.pattern).join('\\n')}\\n" >> .gitignore` };
+    return { name: 'Gitignore Coverage', status: 'warn', message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`, fix: 'monomind doctor --fix   (appends the missing entries)' };
+}
+/** Patterns written by `doctor --fix` when there is no .gitignore at all.
+ *  Covers monomind runtime state plus the standard secrets files, since a repo
+ *  with no .gitignore has nothing protecting those either. */
+const GITIGNORE_FIX_PATTERNS = [
+    '# monomind runtime state',
+    '.monomind/',
+    '**/.monomind/',
+    '.hive-mind/',
+    '.swarm/',
+    '**/.claude-flow/',
+    'data/sessions/',
+    'data/mastermind-*.json',
+    'data/mastermind-*.jsonl',
+    '',
+    '# secrets / local env',
+    '.env',
+    '.env.*',
+    '!.env.example',
+    '*.pem',
+    '*.key',
+    '',
+    '# dependencies / build output',
+    'node_modules/',
+    'dist/',
+];
+/** Creates or appends the missing gitignore entries. Returns true if it wrote.
+ *  Append-only and idempotent: never rewrites lines the user already has. */
+export async function fixGitignoreCoverage() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    try {
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, GITIGNORE_FIX_PATTERNS.join('\n') + '\n', 'utf-8');
+            return true;
+        }
+        if (statSync(gitignorePath).size > MAX_DOCTOR_GITIGNORE_BYTES)
+            return false;
+        const existing = readFileSync(gitignorePath, 'utf-8');
+        const lines = existing.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+        const missing = REQUIRED_GITIGNORE_PATTERNS
+            .map(m => m.pattern)
+            .filter(pattern => !lines.some(l => gitignoreLineCovers(l, pattern)));
+        if (missing.length === 0)
+            return false;
+        const prefix = existing.endsWith('\n') || existing === '' ? '' : '\n';
+        appendFileSync(gitignorePath, `${prefix}\n# monomind runtime state\n${missing.join('\n')}\n`, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export async function checkAgentRegistry() {
     try {