@monoes/monomindcli 2.16.3 → 2.16.4

package/.claude/commands/mastermind/createorg.md

@@ -1,4 +1,4 @@
-<!-- Define and save an autonomous agent organization (Org Runtime v2) — roles and hierarchy. Suggest or confirm roles, then persist the org config for `monomind org run`/`serve`. -->
+<!-- Define and save an autonomous agent organization (Org Runtime) — roles and hierarchy. Suggest or confirm roles, then persist the org config for `monomind org run`/`serve`. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 
@@ -6,7 +6,7 @@
 
 **MASTERMIND: CREATE ORG**
 
-An org is a named, persistent agent team, run by the Org Runtime v2 daemon — not a one-shot Mastermind run and not a Task-tool-spawned boss. Once created, every role in the config starts as its own live agent session the moment you run the org; roles message each other directly (no shared task board) and the org keeps running until stopped.
+An org is a named, persistent agent team, run by the Org Runtime daemon — not a one-shot Mastermind run and not a Task-tool-spawned boss. Once created, every role in the config starts as its own live agent session the moment you run the org; roles message each other directly (no shared task board) and the org keeps running until stopped.
 
 Use orgs when the work is ongoing, not single-shot. A content team that ships 10 posts a month. A research squad that runs competitive scans weekly. A dev team with a permanent backlog.
 

package/.claude/commands/mastermind/help.md

@@ -18,23 +18,17 @@ Quick reference for all Mastermind skills and CLI commands available in this pro
 | `mastermind:swarm` | Swarm coordination reference — topologies, strategies, init patterns |
 | `mastermind:memory` | Memory CLI quick reference |
 
-## Org Runtime (v2 default)
+## Org Runtime
 
 | Command | Description |
 |-------|-------------|
-| `/mastermind:createorg` | Define and save an org (always v2-shaped) |
-| `/mastermind:runorg` | Start a saved org via the Org Runtime v2 daemon (`monomind org run`/`serve`) — auto-migrates v1-shaped configs first |
-| `/mastermind:stoporg` | Stop a running scheduled org loop |
+| `/mastermind:createorg` | Define and save an org |
+| `/mastermind:runorg` | Start a saved org via the Org Runtime daemon (`monomind org run`/`serve`) — converts legacy-format config files first |
+| `/mastermind:stoporg` | Stop a running org (`monomind org stop`) |
 | `/mastermind:orgstatus` | Detailed status for a single org |
 | `/mastermind:orgs` | List all saved orgs |
 
-### Legacy v1 (marker `LEGACY-ORG-V1` — reachable only under these explicit names)
-
-| Command | Description |
-|-------|-------------|
-| `/mastermind:runorgv1` | Legacy prompt-orchestrated org runner — superseded by `/mastermind:runorg` |
-| `/mastermind:approvev1` | Legacy approval queue for v1 orgs — v2 approvals arrive as dashboard question events instead |
-| `/mastermind:heartbeatv1` | Legacy manual agent wake-up for v1 orgs — v2 roles are live SDK sessions with no wake cycle |
+Pending tool approvals from a running org: `monomind org approvals <org>`, then `monomind org approve` / `monomind org deny` (or the dashboard's Human Input tab).
 
 ## Core CLI Commands
 

package/.claude/commands/mastermind/master.md

@@ -249,8 +249,7 @@ Describe your goal. Mastermind identifies the relevant domains, spawns specialis
 
 **Persistent agent orgs** — named teams that coordinate across sessions
 `/mastermind:createorg` — define an org: roles, hierarchy, goal
-`/mastermind:runorg` — start a saved org via the Org Runtime v2 daemon (auto-migrates v1 configs); legacy prompt-orchestrated path: `/mastermind:runorgv1`
-`/mastermind:approvev1` — review and action pending approval requests from running org agents (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab)
+`/mastermind:runorg` — start a saved org via the Org Runtime daemon (converts legacy-format config files first); pending tool approvals: `monomind org approvals <org>` or the dashboard Human Input tab
 
 **Autonomous & advanced**
 `/mastermind:repeat` — wrap any mastermind command in a loop (`--tillend` supported)

package/.claude/commands/mastermind/orgs.md

@@ -1,4 +1,4 @@
-<!-- List all saved orgs with their status, schedule interval, and last/next run times. Shows stopped/active/paused state for scheduled orgs. -->
+<!-- List all saved orgs with their runtime status, schedule, and last run time. Flags crashed runs and legacy-format config files. -->
 
 **If $ARGUMENTS is empty:** Execute the listing below directly.
 

package/.claude/commands/mastermind/orgstatus.md

@@ -1,4 +1,4 @@
-<!-- Show detailed status for a single org — lifecycle state, schedule, last/next run, recent activity, and roles. For scheduled orgs shows loop health. -->
+<!-- Show detailed status for a single org — runtime state, schedule, config health, pending approvals, recent activity, and roles. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 

package/.claude/commands/mastermind/runorg.md

@@ -1,4 +1,4 @@
-<!-- Start a saved org via the Org Runtime v2 daemon (monomind org run/serve). Validates the config, auto-migrates v1-shaped configs, starts the daemon, and confirms liveness. The legacy prompt-orchestrated path lives at /mastermind:runorgv1. -->
+<!-- Start a saved org via the Org Runtime daemon (monomind org run/serve). Validates the config, converts legacy-format config files, starts the daemon, and confirms liveness. -->
 
 **If $ARGUMENTS is empty:** Output the following and wait.
 
@@ -6,7 +6,7 @@
 
 **MASTERMIND: RUN ORG**
 
-Running an org starts it through the Org Runtime v2 daemon. Every role becomes
+Running an org starts it through the Org Runtime daemon. Every role becomes
 a live SDK session; the daemon forwards dashboard events itself — no boss
 agent, no monotask board, no manual curl emissions.
 

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/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,
+};

package/.claude/helpers/handlers/pick-core.cjs

@@ -62,11 +62,12 @@ function isSystemPrompt(prompt) {
 }
 
 /** True for a prompt with fewer than MIN_PICK_TOKENS content words
- *  (pick-rank tokens: stopwords dropped, any script). */
+ *  (pick-rank queryTokens: stopwords and words the prompt rules out dropped,
+ *  any script), so "anything else pending rather than release" is a reply. */
 function isTrivialPrompt(prompt) {
   if (!pickRank || typeof prompt !== 'string') return false;
   var text = prompt.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ').slice(0, 2000);
-  return pickRank.tokens(text).length < MIN_PICK_TOKENS;
+  return pickRank.queryTokens(text).length < MIN_PICK_TOKENS;
 }
 
 function promptHash(prompt) {
@@ -422,6 +423,22 @@ function ensureSkillRegistryFresh(root, builder) {
   return 'rebuilt';
 }
 
+/** Rebuild .monomind/registry.json when agent-registry.cjs says it is stale
+ *  (missing, or older than an agent in .claude/agents, ~/.claude/agents or an
+ *  extra root), so a new user agent is routed from the next session on. Only
+ *  inside a project (findProjectRoot: never the home directory, never a
+ *  folder without .monomind or .claude/agents). opts.home overrides the home
+ *  directory. Returns what it did. */
+function ensureAgentRegistryFresh(root, builder, opts) {
+  if (builder === undefined) {
+    try { builder = require('../agent-registry.cjs'); } catch (e) { builder = null; }
+  }
+  if (!builder || typeof builder.isStale !== 'function' || typeof builder.ensure !== 'function') return 'no-builder';
+  if (builder.findProjectRoot(root, opts && opts.home) !== path.resolve(root)) return 'not-a-project';
+  if (!builder.isStale(root, opts)) return 'fresh';
+  return builder.ensure(root, opts) ? 'rebuilt' : 'failed';
+}
+
 module.exports = {
   KEYWORD_MIN_AGENT_SCORE: KEYWORD_MIN_AGENT_SCORE,
   KEYWORD_AGENT_LEAD: KEYWORD_AGENT_LEAD,
@@ -442,4 +459,5 @@ module.exports = {
   joinOutcome: joinOutcome,
   recordAdherence: recordAdherence,
   ensureSkillRegistryFresh: ensureSkillRegistryFresh,
+  ensureAgentRegistryFresh: ensureAgentRegistryFresh,
 };

package/.claude/helpers/handlers/session-restore-handler.cjs

@@ -39,6 +39,9 @@ module.exports = {
     // Keep skill-registry.json (the skill catalog routing and Jev read) in
     // step with .claude/skills: rebuilt when missing or older than any skill.
     try { require('./pick-core.cjs').ensureSkillRegistryFresh(CWD); } catch (e) { /* non-fatal */ }
+    // Same for .monomind/registry.json (the agent catalog): rebuilt when an
+    // agent in .claude/agents or ~/.claude/agents is newer.
+    try { require('./pick-core.cjs').ensureAgentRegistryFresh(CWD); } catch (e) { /* non-fatal */ }
 
     // ── Non-blocking security scan via @monoes/hooks worker ─────────────
     // The hooks package ships a security worker (worker-security.ts) that scans
@@ -135,7 +138,7 @@ module.exports = {
         if (bundledDir) {
           var healed = [];
           // Top-level critical files — mirrors executor.ts's `criticalHelpers` list.
-          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs', 'router.cjs', 'monograph-freshen.cjs', 'control-start.cjs', 'intelligence.cjs', 'auto-memory-hook.mjs', 'build-skill-registry.cjs', 'org-skill-index.cjs', 'jev-picker.cjs', 'jev-catalog.cjs', 'redact-secrets.cjs', 'pick-rank.cjs', 'pick-stats.cjs'];
+          var helpersToCheck = ['hook-handler.cjs', 'statusline.cjs', 'router.cjs', 'monograph-freshen.cjs', 'control-start.cjs', 'intelligence.cjs', 'auto-memory-hook.mjs', 'build-skill-registry.cjs', 'agent-registry.cjs', 'org-skill-index.cjs', 'jev-picker.cjs', 'jev-catalog.cjs', 'redact-secrets.cjs', 'pick-rank.cjs', 'pick-stats.cjs'];
           for (var hi = 0; hi < helpersToCheck.length; hi++) {
             var hName = helpersToCheck[hi];
             var healedName = _healIfStale(

package/.claude/helpers/jev-catalog.cjs

@@ -4,7 +4,8 @@
  * prompt hook (via jev-picker.cjs) and the CLI (`monomind pick`, MCP pick via
  * src/decision/catalogs.ts), so both rank exactly the same agents and skills.
  *
- *   agents  .monomind/registry.json            (src/agents/registry-builder.ts)
+ *   agents  .monomind/registry.json            (agent-registry.cjs: project,
+ *           ~/.claude/agents and extra roots)
  *   skills  .claude/helpers/skill-registry.json (build-skill-registry.cjs):
  *           `skills` = platform commands/skills, `orgSkills` = Org library
  */
@@ -60,7 +61,7 @@ function loadAgentCatalog(root, opts) {
     var category = typeof a.category === 'string' ? a.category : '';
     var description = typeof a.description === 'string' ? a.description : '';
     var when = typeof a.whenToUse === 'string' ? a.whenToUse.trim() : '';
-    out.push({
+    var item = {
       id: a.slug,
       name: typeof a.name === 'string' ? a.name : a.slug,
       category: category,
@@ -69,7 +70,10 @@ function loadAgentCatalog(root, opts) {
         .concat(strings(a.tags), strings(a.capabilities), strings(a.taskTypes), typeof a.vibe === 'string' ? [a.vibe] : [])
         .filter(Boolean)
         .join(' '),
-    });
+    };
+    // 'project' | 'user' (~/.claude/agents) | 'extra'; shown by `pick --json`, never sent to the model.
+    if (typeof a.origin === 'string') item.origin = a.origin;
+    out.push(item);
   });
   return out;
 }