@monoes/monomindcli 2.16.2 → 2.16.4

package/.claude/commands/mastermind/stoporg.md

@@ -1,4 +1,4 @@
-<!-- Stop a running scheduled org loop. Sets status to "stopped" — the next scheduled wakeup reads the status, skips all work, and does not reschedule. Loop dies within one interval. -->
+<!-- Stop a running org. Wraps `monomind org stop`, which writes the stop file the org daemon polls — the daemon exits within about 2s. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 
@@ -6,7 +6,7 @@
 
 **MASTERMIND: STOP ORG**
 
-Stops a scheduled org loop cleanly. The org's `status` is set to `"stopped"` — the next scheduled wakeup will read the status, skip all work, and not reschedule itself. The loop is guaranteed to die within one interval (no orphaned wakeups).
+Stops a running org cleanly. Runs `monomind org stop <name>`, which writes `.monomind/orgs/<name>/stop`; the org daemon polls for that file and exits within about 2 seconds.
 
 **Usage:**
 
@@ -23,16 +23,12 @@ Stops a scheduled org loop cleanly. The org's `status` is set to `"stopped"` —
 
 **Lifecycle:**
 ```
-stopped  →  (runorg)   →  active
-active   →  (stoporg)  →  stopped
-active   →  (HIL)      →  paused    (set manually in .monomind/orgs/<name>.json)
-paused   →  (set active) →  active  (resume by setting status back to "active" in the JSON)
+stopped  →  (runorg / monomind org run)  →  running
+running  →  (stoporg / monomind org stop) →  stopped
+running  →  (monomind org pause)         →  paused
+paused   →  (monomind org resume)        →  running
 ```
 
-**Note:** v2 orgs (the default) are stopped via `monomind org stop <name>` — this
-command handles both: it routes v2 orgs to the CLI and legacy `.loop` orgs
-through the v1 status-flip path.
-
 Your orgs (with live runtime status):
 
 ```bash
@@ -48,7 +44,7 @@ npx -y monomind@latest org list 2>/dev/null || echo "(none — run /mastermind:c
 Parse `$ARGUMENTS` for:
 - `--org <name>` → org_name = <name>
 
-If `--org` is not provided, list orgs with schedules and ask which to stop.
+If `--org` is not provided, list orgs and ask which to stop.
 
 Verify the org file exists:
 ```bash

package/.claude/commands/mastermind.md

@@ -56,7 +56,7 @@ Match the intent against this catalog. Pick ONE primary route, plus supporting s
 | Autonomous improve-loop | `Skill("mastermind-execute")`, re-invoking `Skill("mastermind-review")` between passes until clean |
 | Finish/merge/PR a branch | `Skill("mastermind-review")`; release/versioning: `Skill("mastermind-release")` |
 | Isolate risky work | `Skill("mastermind-worktree")` |
-| Spec → agent task file/board | `Skill("mastermind-createtask")`, execute with `Skill("mastermind-do")` |
+| Spec → agent task file/board | `Skill("mastermind:createtask")`, execute with `Skill("mastermind:do")` |
 
 ### Design, animation, frontend
 | Intent | Primary route |
@@ -79,11 +79,11 @@ Match the intent against this catalog. Pick ONE primary route, plus supporting s
 ### Research, ideas, content, business
 | Intent | Primary route |
 |---|---|
-| Market/competitor/user research | `Skill("mastermind-research")`; deep cited web report: `Skill("deep-research")` |
-| Ideation, feature brainstorm | `Skill("mastermind-idea")` / `Skill("mastermind-ideate")` (evaluate + decompose) |
-| Improve an existing component | `Skill("mastermind-improve")` |
-| Blog/docs/newsletter/threads | `Skill("mastermind-content")`; docs generation: `npx monomind doc` |
-| Marketing / sales / ops / finance | `Skill("mastermind-marketing")` / `-sales` / `-ops` / `-finance` |
+| Market/competitor/user research | `Skill("mastermind-research")`; multi-agent research swarm: `Skill("monoswarm:research")` |
+| Ideation, feature brainstorm | `Skill("mastermind-idea")` / `Skill("mastermind:ideate")` (evaluate + decompose) |
+| Improve an existing component | `Skill("mastermind:improve")` |
+| Blog/docs/newsletter/threads | `Skill("mastermind:content")`; docs generation: `npx monomind doc` |
+| Marketing / sales / ops / finance | `Skill("mastermind:marketing")` / `:sales` / `:ops` / `:finance` |
 | Port capability from another project | `Skill("mastermind-techport")` |
 
 ### Agents, orgs, orchestration
@@ -99,7 +99,7 @@ Match the intent against this catalog. Pick ONE primary route, plus supporting s
 ### System, memory, quality
 | Intent | Primary route |
 |---|---|
-| "What does monomind know" / recall context | `mcp__monomind__knowledge_search`, `memory_kg_search`; inspect: `Skill("mastermind-brain")` |
+| "What does monomind know" / recall context | `mcp__monomind__knowledge_search`, `memory_kg_search`; inspect: `Skill("mastermind:brain")` |
 | Security scan/audit/secrets | `npx monomind security scan|cve|audit|secrets` |
 | Performance profiling | `npx monomind performance profile|benchmark` |
 | System health | `npx monomind doctor` (`--fix`) / `monomind status` |

package/.claude/commands/monoswarm/analysis.md

@@ -10,7 +10,7 @@ Comprehensive analysis through distributed agent coordination.
 ## How to Invoke
 
 ```
-Skill("swarm:analysis")
+Skill("monoswarm:analysis")
 ```
 
 Then describe what to analyze:

package/.claude/commands/monoswarm/development.md

@@ -10,7 +10,7 @@ Coordinated development through specialized agent teams.
 ## How to Invoke
 
 ```
-Skill("swarm:development")
+Skill("monoswarm:development")
 ```
 
 Then describe the feature to build:

package/.claude/commands/monoswarm/maintenance.md

@@ -10,7 +10,7 @@ System maintenance and updates through coordinated agents.
 ## How to Invoke
 
 ```
-Skill("swarm:maintenance")
+Skill("monoswarm:maintenance")
 ```
 
 Then describe the maintenance task:

package/.claude/commands/monoswarm/optimization.md

@@ -1,6 +1,7 @@
 ---
 name: swarm-optimization
 description: Optimization swarm strategy — performance profiling, bottleneck detection, and coordinated optimization through specialized mesh agents
+pick: low
 ---
 
 # Optimization Swarm Strategy
@@ -10,7 +11,7 @@ Performance optimization through specialized analysis agents.
 ## How to Invoke
 
 ```
-Skill("swarm:optimization")
+Skill("monoswarm:optimization")
 ```
 
 Then describe the optimization target:

package/.claude/commands/monoswarm/research.md

@@ -10,7 +10,7 @@ Deep research through parallel information gathering.
 ## How to Invoke
 
 ```
-Skill("swarm:research")
+Skill("monoswarm:research")
 ```
 
 Then describe the research topic:

package/.claude/commands/monoswarm/testing.md

@@ -10,7 +10,7 @@ Comprehensive testing through distributed execution.
 ## How to Invoke
 
 ```
-Skill("swarm:testing")
+Skill("monoswarm:testing")
 ```
 
 Then describe the testing scope:

package/.claude/commands/pair/examples.md

@@ -1,6 +1,7 @@
 ---
 name: pair:examples
 description: Real-world pair programming scenarios — JWT auth, memory leak debugging, TDD, code review, and refactoring with effective prompt patterns
+pick: low
 ---
 
 # Pair Programming Examples
@@ -45,7 +46,7 @@ npx monomind hooks post-task --task-id <id> --success true --quality 0.9
 
 **Setup:**
 ```
-Skill("superpowers:systematic-debugging")
+Skill("mastermind-debug")
 ```
 
 Or directly:
@@ -70,7 +71,7 @@ Apply the fix, verify:
 
 **Setup:**
 ```
-Skill("superpowers:test-driven-development")
+Skill("mastermind-debug")   # Phase 4: failing test first, then Red-Green-Refactor
 ```
 
 Or:

package/.claude/commands/pair/modes.md

@@ -64,7 +64,7 @@ Write failing tests, then implement just enough to pass, then refactor.
 
 **Invoke the TDD skill for full workflow:**
 ```
-Skill("superpowers:test-driven-development")
+Skill("mastermind-debug")   # Phase 4: failing test first, then Red-Green-Refactor
 ```
 
 ---
@@ -81,7 +81,7 @@ Work through existing code with Claude as reviewer.
 
 **Invoke the review skill:**
 ```
-Skill("superpowers:requesting-code-review")
+Skill("mastermind-review")
 ```
 
 ---
@@ -95,7 +95,7 @@ Systematic debugging as a pair.
 
 **Invoke the debugging skill:**
 ```
-Skill("superpowers:systematic-debugging")
+Skill("mastermind-debug")
 ```
 
 ---

package/.claude/helpers/agent-registry.cjs

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * The agent registry (.monomind/registry.json) — ONE implementation shared by
+ * the CLI (src/agents/registry-builder.ts and registry-freshness.ts load this
+ * file) and the SessionStart hook (handlers/pick-core.cjs), so an agent added
+ * to ~/.claude/agents or .claude/agents is indexed at the next session start
+ * without running the CLI, and both sides parse frontmatter the same way.
+ *
+ * Roots, in precedence order (the first definition of a slug wins):
+ *   extra    $MONOMIND_EXTRA_AGENT_PATHS (':'-separated), else a sibling
+ *            ../agency-agents directory — canonical, wins over the project
+ *   project  <root>/.claude/agents
+ *   user     ~/.claude/agents — Claude Code loads these in every project, so
+ *            they are valid Task subagent_types. As in Claude Code, a project
+ *            (or extra) agent wins: a user agent whose slug or frontmatter
+ *            `name` is already defined is left out (listed under `shadowed`).
+ *
+ * User entries record `~/.claude/agents/...` as filePath, never the absolute
+ * home path. The registry is rebuilt when missing or older than any agent file
+ * in those roots (an mtime scan, no parsing) or this builder.
+ *
+ * Usage:  node .claude/helpers/agent-registry.cjs [projectRoot]
+ */
+
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+
+/** Directories to skip during the scan. `reengineer-squad` is a repo-only
+ *  squad the package does not ship, and its `tester` would shadow the core
+ *  tester. */
+var SKIP_DIRS = new Set(['schemas', 'ephemeral', 'reengineer-squad']);
+var MAX_AGENT_BYTES = 512 * 1024;
+var USER_LABEL = '~/.claude/agents';
+
+function homeDir(opts) {
+  return (opts && opts.home) || os.homedir();
+}
+
+/** Every `.md` under `root` (recursively), skipping SKIP_DIRS and `._` forks. */
+function collectMdFiles(root) {
+  var results = [];
+  var entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch (e) {
+    return results;
+  }
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    var full = path.join(root, entry);
+    var stat;
+    try {
+      stat = fs.statSync(full);
+    } catch (e) {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (SKIP_DIRS.has(entry)) continue;
+      results.push.apply(results, collectMdFiles(full));
+    } else if (stat.isFile() && path.extname(entry) === '.md' && !entry.startsWith('._')) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function unquote(v) {
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) return v.slice(1, -1);
+  return v;
+}
+
+/**
+ * Nested YAML list items under a key whose value was empty
+ * (`triggers:\n  - pattern: ...`): a string array when every item is a plain
+ * scalar, an array of objects when items hold `key: value` pairs, null when
+ * there are no list items.
+ */
+function parseNestedYamlList(lines, startIdx, parentIndent) {
+  var objects = [];
+  var simpleItems = [];
+  var current = null;
+  var consumed = 0;
+  var hasObjects = false;
+  for (var i = startIdx; i < lines.length; i++) {
+    var line = lines[i];
+    var trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+      consumed++;
+      continue;
+    }
+    var indent = line.length - line.trimStart().length;
+    if (indent <= parentIndent) break;
+    if (trimmed.startsWith('- ')) {
+      var itemContent = trimmed.slice(2);
+      var colon = itemContent.indexOf(': ');
+      if (colon !== -1) {
+        hasObjects = true;
+        current = {};
+        current[itemContent.slice(0, colon).trim()] = unquote(itemContent.slice(colon + 2).trim());
+        objects.push(current);
+      } else {
+        simpleItems.push(unquote(itemContent.trim()));
+      }
+      consumed++;
+    } else if (current && hasObjects) {
+      var c = trimmed.indexOf(': ');
+      if (c !== -1) current[trimmed.slice(0, c).trim()] = unquote(trimmed.slice(c + 2).trim());
+      consumed++;
+    } else {
+      break;
+    }
+  }
+  if (hasObjects && objects.length > 0) return { value: objects, consumed: consumed };
+  if (simpleItems.length > 0) return { value: simpleItems, consumed: consumed };
+  return { value: null, consumed: consumed };
+}
+
+/** The leading `---` frontmatter block as a flat key → value map (scalars,
+ *  booleans, `[a, b]` and nested `- ` lists, `|`/`>` block scalars). */
+function parseFrontmatter(content) {
+  var match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!match) return {};
+  var result = {};
+  var lines = match[1].split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    var colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+    var key = trimmed.slice(0, colonIdx).trim();
+    var value = trimmed.slice(colonIdx + 1).trim();
+
+    var blockScalar = /^([|>])[+-]?$/.exec(value);
+    if (blockScalar) {
+      var blockIndent = line.length - line.trimStart().length;
+      var body = [];
+      while (i + 1 < lines.length) {
+        var next = lines[i + 1];
+        if (next.trim() && next.length - next.trimStart().length <= blockIndent) break;
+        body.push(next.trim());
+        i++;
+      }
+      result[key] = body.join(blockScalar[1] === '|' ? '\n' : ' ').trim();
+      continue;
+    }
+
+    if (value === '') {
+      var nested = parseNestedYamlList(lines, i + 1, line.length - line.trimStart().length);
+      if (nested.value !== null) {
+        result[key] = nested.value;
+        i += nested.consumed;
+        continue;
+      }
+    }
+
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value
+        .slice(1, -1)
+        .split(',')
+        .map(function (s) { return s.trim().replace(/^["']|["']$/g, ''); })
+        .filter(Boolean);
+    } else if (value === 'true') value = true;
+    else if (value === 'false') value = false;
+    else value = unquote(value);
+    result[key] = value;
+  }
+  return result;
+}
+
+/** The first argument that is not undefined/null (a `??` chain). */
+function first() {
+  for (var i = 0; i < arguments.length; i++) if (arguments[i] !== undefined && arguments[i] !== null) return arguments[i];
+  return undefined;
+}
+
+function toStringArray(val) {
+  if (Array.isArray(val)) return val.map(String);
+  if (typeof val === 'string' && val.length > 0) return [val];
+  return [];
+}
+
+function parseTriggers(val) {
+  if (!val) return [];
+  var arr = Array.isArray(val) ? val : [val];
+  return arr.map(function (t) {
+    if (typeof t === 'object' && t !== null && 'pattern' in t) {
+      return { pattern: String(t.pattern), mode: String(first(t.mode, 'glob')) };
+    }
+    return { pattern: String(t), mode: 'glob' };
+  });
+}
+
+function slugFromFilename(file) {
+  return path.basename(file, path.extname(file))
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '');
+}
+
+function categoryFromPath(file, root) {
+  var parts = path.relative(root, file).split(path.sep);
+  return parts.length > 1 ? parts[0] : 'default';
+}
+
+function isDir(p) {
+  try { return fs.statSync(p).isDirectory(); } catch (e) { return false; }
+}
+
+/**
+ * The agent roots for project `cwd`, in precedence order: extras, the
+ * project's .claude/agents, then ~/.claude/agents (opts.user === false leaves
+ * it out; opts.home overrides the home directory). When cwd is the home
+ * directory the two .claude/agents are one directory, listed once as `user`.
+ */
+function computeAgentRoots(cwd, opts) {
+  var env = (opts && opts.env) || process.env;
+  var extras = env.MONOMIND_EXTRA_AGENT_PATHS ? env.MONOMIND_EXTRA_AGENT_PATHS.split(':').filter(Boolean) : [];
+  var sibling = path.join(cwd, '..', 'agency-agents');
+  if (extras.length === 0 && isDir(sibling)) extras.push(sibling);
+  var roots = extras.map(function (dir) { return { dir: dir, origin: 'extra' }; });
+  var projectDir = path.join(cwd, '.claude', 'agents');
+  var userDir = path.join(homeDir(opts), '.claude', 'agents');
+  var withUser = !(opts && opts.user === false);
+  if (!withUser || path.resolve(projectDir) !== path.resolve(userDir)) roots.push({ dir: projectDir, origin: 'project' });
+  if (withUser) roots.push({ dir: userDir, origin: 'user', label: USER_LABEL });
+  return roots;
+}
+
+/** A root given as a plain path is a project-local definition directory. */
+function asRoot(r) {
+  return typeof r === 'string' ? { dir: r, origin: 'project' } : r;
+}
+
+/**
+ * Builds the registry from `roots` (first root wins a slug; a `user` agent
+ * also loses to any earlier agent with the same frontmatter `name` or slug),
+ * writing it to `outputPath` when given. opts.base: the directory project and
+ * extra filePaths are relative to (default cwd).
+ */
+function buildUnifiedRegistry(roots, outputPath, opts) {
+  var now = new Date().toISOString();
+  var base = (opts && opts.base) || process.cwd();
+  var seen = new Map();
+  var names = new Set();
+  var dupes = new Map();
+  var shadowed = [];
+  var counts = { project: 0, user: 0, extra: 0 };
+  (roots || []).map(asRoot).forEach(function (root) {
+    var files = collectMdFiles(root.dir);
+    files.forEach(function (file) {
+      var content;
+      try {
+        if (fs.statSync(file).size > MAX_AGENT_BYTES) return;
+        content = fs.readFileSync(file, 'utf-8');
+      } catch (e) {
+        return;
+      }
+      var fm = parseFrontmatter(content);
+      var slug = (typeof fm.slug === 'string' && fm.slug) || slugFromFilename(file);
+      var name = (typeof fm.name === 'string' && fm.name) || slug;
+      var filePath = root.label
+        ? root.label + '/' + path.relative(root.dir, file).split(path.sep).join('/')
+        : path.isAbsolute(file) ? path.relative(base, file) : file;
+      var prior = seen.get(slug);
+      if (root.origin === 'user' && (prior ? prior.origin !== 'user' : names.has(name) || names.has(slug))) {
+        shadowed.push({ slug: slug, name: name, filePath: filePath });
+        return;
+      }
+      if (prior) {
+        var d = dupes.get(slug) || { slug: slug, kept: prior.filePath, dropped: [] };
+        d.dropped.push(filePath);
+        dupes.set(slug, d);
+        return;
+      }
+      var str = function (v) { return typeof v === 'string' ? v : undefined; };
+      seen.set(slug, {
+        slug: slug,
+        name: name,
+        version: str(fm.version) || '0.0.0',
+        category: str(fm.category) || categoryFromPath(file, root.dir),
+        description: str(fm.description) || '',
+        whenToUse: str(first(fm.when_to_use, fm.whenToUse)),
+        tags: toStringArray(fm.tags),
+        vibe: str(fm.vibe),
+        // A `capability:` block is read flattened, so its `expertise:` list lands top-level
+        capabilities: toStringArray(first(fm.capabilities, fm.expertise)),
+        taskTypes: toStringArray(first(fm.taskTypes, fm['task-types'], fm.task_types)),
+        tools: toStringArray(fm.tools),
+        triggers: parseTriggers(fm.triggers),
+        deprecated: fm.deprecated === true,
+        deprecatedBy: str(fm.deprecatedBy),
+        dependencies: toStringArray(fm.dependencies),
+        origin: root.origin,
+        filePath: filePath,
+        registeredAt: now,
+        lastUpdated: now,
+      });
+      names.add(name);
+      names.add(slug);
+      counts[root.origin] = (counts[root.origin] || 0) + 1;
+    });
+  });
+  var agents = Array.from(seen.values());
+  var registry = {
+    version: '1.0.0',
+    generatedAt: now,
+    totalAgents: agents.length,
+    counts: counts,
+    agents: agents,
+    duplicates: Array.from(dupes.values()),
+    shadowed: shadowed,
+  };
+  if (outputPath) writeRegistryFile(outputPath, registry);
+  return registry;
+}
+
+function agentCountOnDisk(file) {
+  try {
+    var reg = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    return reg && Array.isArray(reg.agents) ? reg.agents.length : 0;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/** Writes `registry` atomically — except an empty registry never replaces a
+ *  non-empty one. Returns whether the file was written. */
+function writeRegistryFile(file, registry) {
+  if (registry.agents.length === 0 && agentCountOnDisk(file) > 0) return false;
+  var tmp = file + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(registry, null, 2), 'utf-8');
+  fs.renameSync(tmp, file);
+  return true;
+}
+
+/** Newest mtime (ms) of any agent `.md` under `dirs`; directories count too,
+ *  so a deleted file also marks the registry stale. 0 when there are none. */
+function newestAgentMtime(dirs) {
+  var newest = 0;
+  function walk(dir) {
+    var entries;
+    try {
+      newest = Math.max(newest, fs.statSync(dir).mtimeMs);
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (e) {
+      return;
+    }
+    entries.forEach(function (e) {
+      var full = path.join(dir, e.name);
+      if (e.isDirectory()) walk(full);
+      else if (e.isFile() && path.extname(e.name) === '.md') {
+        try { newest = Math.max(newest, fs.statSync(full).mtimeMs); } catch (err) { /* vanished */ }
+      }
+    });
+  }
+  (dirs || []).forEach(function (d) { walk(typeof d === 'string' ? d : d.dir); });
+  return newest;
+}
+
+function registryPath(root) {
+  return path.join(root, '.monomind', 'registry.json');
+}
+
+function mtime(p) {
+  try { return fs.statSync(p).mtimeMs; } catch (e) { return 0; }
+}
+
+/** True when `root`'s registry is missing or older than an agent definition
+ *  in any root (project, user, extra) or than this builder. */
+function isStale(root, opts) {
+  var at = mtime(registryPath(root));
+  if (at === 0) return true;
+  return Math.max(newestAgentMtime(computeAgentRoots(root, opts)), mtime(__filename)) > at;
+}
+
+/** Rebuilds `root`'s registry when stale; the built registry, or null when it
+ *  was fresh or the build failed. Never throws. */
+function ensure(root, opts) {
+  try {
+    if (!isStale(root, opts)) return null;
+    fs.mkdirSync(path.join(root, '.monomind'), { recursive: true });
+    return buildUnifiedRegistry(computeAgentRoots(root, opts), registryPath(root), { base: root });
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * The nearest directory at or above `cwd` holding `.claude/agents` or
+ * `.monomind`. The walk stops at the git root (inclusive) and never returns
+ * the home directory itself, whose ~/.monomind is the user's global state.
+ * Null when no project is found.
+ */
+function findProjectRoot(cwd, home) {
+  var stopAt = path.resolve(home || os.homedir());
+  var dir = path.resolve(cwd);
+  for (;;) {
+    if (dir === stopAt) return null;
+    if (fs.existsSync(path.join(dir, '.claude', 'agents')) || fs.existsSync(path.join(dir, '.monomind'))) return dir;
+    if (fs.existsSync(path.join(dir, '.git'))) return null;
+    var parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function main() {
+  var root = process.argv[2] || process.env.CLAUDE_PROJECT_DIR || findProjectRoot(process.cwd());
+  if (!root) {
+    process.stderr.write('registry.json: no project found at or above ' + process.cwd() + '; nothing written\n');
+    return;
+  }
+  fs.mkdirSync(path.join(root, '.monomind'), { recursive: true });
+  var reg = buildUnifiedRegistry(computeAgentRoots(root), registryPath(root), { base: root });
+  process.stdout.write('registry.json: ' + reg.totalAgents + ' agents (' + reg.counts.user + ' from ' + USER_LABEL + ')\n');
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  USER_LABEL: USER_LABEL,
+  parseFrontmatter: parseFrontmatter,
+  computeAgentRoots: computeAgentRoots,
+  buildUnifiedRegistry: buildUnifiedRegistry,
+  writeRegistryFile: writeRegistryFile,
+  newestAgentMtime: newestAgentMtime,
+  registryPath: registryPath,
+  isStale: isStale,
+  ensure: ensure,
+  findProjectRoot: findProjectRoot,
+};