monomind 2.1.0 → 2.1.3

package/packages/@monomind/cli/README.md

@@ -5,8 +5,8 @@
 <h1 align="center">Monomind</h1>
 
 <p align="center">
-  <strong>Hire an AI team. Set a goal. Walk away.</strong><br/>
-  Autonomous Claude Code orchestration with persistent memory, self-coordinating agent orgs, and a codebase knowledge graph.
+  <strong>An open-source MCP server that extends Claude Code with a codebase knowledge graph, persistent memory, and multi-agent coordination.</strong><br/>
+  MIT licensed &middot; Fully local &middot; No data leaves your machine
 </p>
 
 <p align="center">
@@ -30,126 +30,105 @@
 
 ## What is Monomind?
 
-Claude Code is already powerful. Monomind makes it **run itself**.
+Monomind is an **open-source CLI and MCP server** that plugs into Claude Code via the standard [Model Context Protocol](https://modelcontextprotocol.io/). It adds capabilities that Claude Code doesn't ship with out of the box:
 
-Install once. Wire it into Claude Code. Then instead of prompting Claude to do individual tasks, you tell Monomind what outcome you want — and it assembles a team, coordinates the work, and delivers.
+- **Codebase knowledge graph** — tree-sitter parses your code into a SQLite-backed graph of files, functions, classes, and their relationships. Query imports, callers, and blast radius before making changes.
+- **Persistent memory** — a JSON pattern store with episodic recall that survives across sessions. Agents and orgs share context without re-prompting.
+- **Multi-agent coordination** — in-session, spawn ad-hoc agent teams via Claude Code's Task tool; for persistent background work, `monomind org run` starts a real SDK-backed daemon with policy-gated role agents and a live dashboard.
+- **Reusable slash commands** — 30+ development workflows (build, review, debug, TDD, architecture) available as `/mastermind:*` commands inside Claude Code.
 
 ```bash
-# Assemble an AI content team and let it run
-/mastermind:createorg content-team "publish 3 SEO-optimized posts per week"
-/mastermind:runorg --org content-team
-
-# Or run the autonomous code improvement loop
-/mastermind:autodev --tillend --focus security
+npm install -g monomind        # MIT licensed, 0 external API calls
+cd your-project && monomind init
+claude mcp add monomind npx monomind mcp start
 ```
 
-That's it. Come back later.
+### Trust & Security
+
+| Concern | Answer |
+|---|---|
+| **License** | [MIT](LICENSE) — use it however you want |
+| **Data privacy** | Everything runs locally. No telemetry, no phone-home, no external API calls from Monomind itself. Your code stays on your machine. |
+| **Dependencies** | Standard npm packages (tree-sitter, sql.js, zod). No native binaries. No post-install scripts that download code. |
+| **Permissions** | Registers as an MCP server — Claude Code controls what tools are available and prompts you before executing anything sensitive. |
+| **Source** | Fully open. Read every line at [github.com/monoes/monomind](https://github.com/monoes/monomind). |
+| **Maintenance** | Active development, regular releases on npm. |
 
 ---
 
 ## 🏢 Autonomous Organizations
 
-> **This is the headline feature.** Build a persistent AI organization — roles, hierarchy, shared task board — and start it as a background daemon that runs without you.
+> **This is the headline feature.** `monomind org run` starts a persistent, SDK-backed daemon that runs an autonomous agent organization — roles, hierarchy, policy-gated tool access, a live dashboard — until you stop it.
 
 ### The idea
 
-Every business function needs a team. Monomind lets you design that team in one command, then run it forever. The org persists across sessions. It checkpoints, recovers from failures, and coordinates its agents through a shared task board — all automatically.
+Every business function needs a team. Define the org once as a JSON file — goal, roles, who reports to whom, per-role tool/file/budget policy — then run it as a real background daemon backed by the Claude Agent SDK. It persists across sessions, serves a live WebSocket dashboard, and can discover and message other Monomind orgs running on the same machine.
 
 ```mermaid
 flowchart TD
     U(["You"])
-    CO["/mastermind:createorg\nDefine goal + roles"]
-    RO["/mastermind:runorg\nStart daemon"]
-    BOSS["Boss Agent\ncoordinator"]
-    W["Writer\nContent Creator"]
+    DEF["org.json\nGoal + roles + policy"]
+    RUN["monomind org run\nStart SDK daemon"]
+    BOSS["Boss Agent\nAgent SDK session"]
+    W["Writer"]
     S["SEO Specialist"]
     R["Reviewer"]
-    M["Growth Marketer"]
-    BOARD[("Shared\nTask Board")]
-    MEM[("Persistent\nMemory")]
+    DASH[("Live Dashboard\n:4243")]
+    XORG[("Other orgs\ncross-process")]
 
-    U --> CO --> RO --> BOSS
+    U --> DEF --> RUN --> BOSS
     BOSS -->|spawns| W
     BOSS -->|spawns| S
     BOSS -->|spawns| R
-    BOSS -->|spawns| M
-    BOSS <-->|claims + reports| BOARD
-    W <-->|stores output| MEM
-    S <-->|reads context| MEM
+    RUN <-->|serves| DASH
+    RUN <-.->|--cross-process| XORG
 
     style BOSS fill:#00D2AA22,stroke:#00D2AA
-    style BOARD fill:#F59E0B22,stroke:#F59E0B
-    style MEM fill:#8B5CF622,stroke:#8B5CF6
-```
-
-### Two commands to a running org
-
-**Step 1 — Design it:**
-
+    style DASH fill:#F59E0B22,stroke:#F59E0B
+    style XORG fill:#8B5CF622,stroke:#8B5CF6
 ```
-/ mastermind:createorg content-team
-  "Build and publish 3 blog posts per week on AI dev tools"
-
-Deriving roles from goal...
-
-╔ ORG: content-team
-║ TOPOLOGY: star (5 roles)
 
-  boss      → coordinator
-  writer    → Content Creator
-  reviewer  → reviewer
-  marketer  → Growth Hacker
-  seo       → SEO Specialist
+### Run one
 
-Type "go" to save, or describe changes.
-→ go
+```bash
+# .monomind/orgs/<name>.json defines the org: goal, roles, policy.
+# See .monomind/orgs/sample-team.json in a fresh `monomind init` for a working example.
 
-✓ Saved .monomind/orgs/content-team.json
-  → Run: /mastermind:runorg --org content-team
-```
+monomind org run content-team --task "Build and publish 3 blog posts per week"
 
-**Step 2 — Start it:**
+# ✓ Live dashboard: http://localhost:4243
+# ✓ Boss agent (Claude Agent SDK session) spawns, reads the org goal,
+#   assigns work to role agents, coordinates until the task completes
+#   or you stop it.
 
-```bash
-/mastermind:runorg --org content-team
-
-# Boss agent spawns in background
-# Coordinates all roles via shared task board
-# Checkpoints every 30 minutes
-# Loops until you stop it
+monomind org status content-team    # runtime state
+monomind org stop content-team      # request a graceful stop
+monomind org list                   # every org + status
 ```
 
 ### What runs under the hood
 
 | What | How |
 |---|---|
-| **Boss agent** | Coordinator type, no supervisor — owns the goal |
-| **Role agents** | Spawned on demand, specialized by task type |
-| **Task board** | Todo → Doing → Done, shared across all agents |
-| **Memory** | All output stored in an org-scoped memory namespace |
-| **Checkpoint** | State saved every 30 min — survives crashes and restarts |
-| **Governance** | `auto` (free), `board` (approve sensitive), `strict` (approve all external actions) |
-
-### Topology is auto-derived
-
-```mermaid
-graph LR
-    A["1-3 roles"] -->|mesh| B["All-to-all\ndirect comms"]
-    C["4-6 roles"] -->|star| D["Boss to workers\nfan-out"]
-    E["7+ roles"] -->|hierarchical| F["Boss to leads to workers\nmiddle management"]
-```
+| **OrgDaemon** | Hosts one or more orgs in a single process; real Claude Agent SDK sessions per role, not simulated |
+| **PolicyEngine** | Per-role gates on tool access, file read/write scope, web access, token budget — enforced, with a full audit trail |
+| **Live dashboard** | WebSocket-served at `:4243` by default (`--port` to change, `--serve=false` to disable) |
+| **Cross-process comms** | `--cross-process` (default on) lets orgs on different `monomind` processes/projects discover and message each other |
+| **Scheduling** | `monomind org serve` hosts orgs whose definition has a `schedule` field, running them on interval |
 
 ### Org management commands
 
 ```bash
-/mastermind:createorg <name> "<goal>"   # design org from a goal
-/mastermind:runorg --org <name>         # start as background daemon
-/mastermind:orgs                        # list all orgs + status
-/mastermind:orgstatus --org <name>      # detailed status for one org
-/mastermind:stoporg --org <name>        # stop a running org
-/mastermind:approve                     # review pending approval requests
+monomind org run <name> [--task "..."] [--port N] [--cross-process]  # start a daemon
+monomind org stop <name>            # request a running org to stop
+monomind org status [name]          # runtime state for one or all orgs
+monomind org list                   # list every org + status
+monomind org serve [--port N]       # host-only mode, runs scheduled orgs
+monomind org delete <name>          # remove an org
 ```
 
+> **Note:** the older `/mastermind:createorg` + `/mastermind:runorg` prompt-orchestrated flow is deprecated — it has no delivery guarantees or ground-truth event stream. It still runs for orgs not yet migrated, but new orgs should use `monomind org run` directly against a hand-authored `.monomind/orgs/<name>.json`.
+
 ---
 
 ## ⚡ The Autonomous Build Loop
@@ -206,11 +185,11 @@ claude mcp add monomind npx monomind mcp start
 monomind doctor --fix
 ```
 
-Open Claude Code. You now have 80+ slash commands available:
+Open Claude Code. You now have 60+ slash commands available:
 
 ```bash
 /mastermind:autodev --tillend     # start autonomous code loop
-/mastermind:createorg my-team     # create your first AI org
+monomind org run my-team          # run your first AI org (see .monomind/orgs/sample-team.json)
 /mastermind:help                  # show all commands
 ```
 
@@ -262,7 +241,7 @@ Before touching any file, Monomind queries **Monograph** — a SQLite-backed kno
 
 ## 🎣 Hooks & Workers
 
-Monomind wires 22 hook events into Claude Code. Every edit, task, command, and session fires hooks that log patterns, route agents, and train the intelligence system.
+Monomind wires 29 hook subcommands into Claude Code across edit, task, command, and session lifecycle events — logging patterns, routing agents, and feeding the intelligence system.
 
 ```mermaid
 flowchart LR
@@ -296,7 +275,7 @@ const result = await fence.detect(userInput);
 
 ---
 
-## 📋 80+ Slash Commands
+## 📋 60+ Slash Commands
 
 Everything runs from inside Claude Code via slash commands. Here's the highlight reel:
 
@@ -315,9 +294,9 @@ Everything runs from inside Claude Code via slash commands. Here's the highlight
 ### Organizations
 | Command | What it does |
 |---|---|
-| `/mastermind:createorg` | Design an autonomous agent org |
-| `/mastermind:runorg` | Start it as a background daemon |
-| `/mastermind:orgs` | List all orgs + status |
+| `monomind org run <name>` | Start an org as a real SDK-backed daemon |
+| `monomind org status` / `list` | Runtime state for one or all orgs |
+| `monomind org stop <name>` | Request a graceful stop |
 | `/mastermind:approve` | Action pending approval requests |
 
 ### Business Domains
@@ -329,7 +308,7 @@ Everything runs from inside Claude Code via slash commands. Here's the highlight
 | `/mastermind:finance` | Budgets, invoicing, modeling |
 | `/mastermind:ops` | Operations and workflow automation |
 
-**[→ Full reference (80+ commands)](https://monoes.github.io/monomind/#slash)**
+**[→ Full reference (60+ commands)](https://monoes.github.io/monomind/#slash)**
 
 ---
 
@@ -351,24 +330,27 @@ graph TD
     CC["Claude Code"]
     MCP["MCP Server\nmonomind mcp start"]
     D["Background Workers\n(@monomind/hooks, in-process)"]
+    ORG["OrgDaemon\nmonomind org run\nreal SDK sessions"]
 
-    CC <-->|"MCP tools: monograph, memory, swarm"| MCP
+    CC <-->|"MCP tools: monograph, memory"| MCP
     MCP <--> D
 
     D --> ADB[("Memory store\npatterns + episodes")]
     D --> MG[("Monograph\ncode graph")]
-    D --> HK["Hooks\n22 event types"]
-    D --> SW["Swarm\n4 topologies\n3 consensus strategies"]
+    D --> HK["Hooks\n29 subcommands"]
 
-    CC -->|"Task tool - spawns agents"| AG["Agent Swarm\narchitect, coder\ntester, reviewer\nsecurity, perf"]
+    CC -->|"Task tool - spawns agents"| AG["In-session agents\narchitect, coder\ntester, reviewer\nsecurity, perf"]
     AG <-->|reads and writes| ADB
+    ORG -->|"spawns, policy-gated"| RA["Role agents"]
+    ORG <-->|reads and writes| ADB
 
     style CC fill:#00D2AA22,stroke:#00D2AA
     style AG fill:#8B5CF622,stroke:#8B5CF6
     style ADB fill:#F59E0B22,stroke:#F59E0B
+    style ORG fill:#F59E0B22,stroke:#F59E0B
 ```
 
-**Claude Code handles all execution.** MCP tools only coordinate. Your data never leaves your machine.
+**Claude Code's Task tool drives in-session multi-agent work; `monomind org run` drives persistent background orgs.** Your data never leaves your machine.
 
 ---
 

package/packages/@monomind/cli/dist/src/browser/workflow/store.d.ts

@@ -1,7 +1,7 @@
 import type { WorkflowDef, RunRecord } from './types.js';
 export declare class WorkflowStoreError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
 }
 export declare function readWorkflow(filePath: string): Promise<WorkflowDef>;
 export declare function writeRunRecord(record: RunRecord): Promise<void>;

package/packages/@monomind/cli/dist/src/commands/browse.d.ts

@@ -1,5 +1,4 @@
 declare const browseCommand: {
-    subcommands: import("../types.js").Command[];
     name: string;
     description: string;
     aliases?: string[];
@@ -7,6 +6,7 @@ declare const browseCommand: {
     examples?: import("@monoes/monobrowse/cli/types").CommandExample[];
     action?: import("@monoes/monobrowse/cli/types").CommandAction;
     hidden?: boolean;
+    subcommands: import("../types.js").Command[];
 };
 export default browseCommand;
 //# sourceMappingURL=browse.d.ts.map

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

@@ -87,6 +87,11 @@ export async function checkDiskSpace() {
     }
 }
 export async function checkBuildTools() {
+    // Only meaningful for Node/TS projects — a Go, Python, or Rust repo has no
+    // reason to install TypeScript, and warning about it there is just noise.
+    if (!existsSync(join(process.cwd(), 'package.json'))) {
+        return { name: 'TypeScript', status: 'pass', message: 'N/A — no package.json (not a Node.js project)' };
+    }
     try {
         const tscVersion = await runCommand('npx tsc --version', 10000);
         if (!tscVersion || tscVersion.includes('not found')) {

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

@@ -19,12 +19,20 @@ function validateOrgName(name) {
     }
     return { ok: true, name };
 }
-/** Config filenames for real orgs under orgsDir — excludes org-internal
- * artifact files (state/goals/threads/etc) that share the .json extension. */
-const ORG_ARTIFACT_SUFFIXES = ['-state', '-goals', '-threads', '-activity', '-approvals', '-members', '-secrets', '-budgets'];
+/** Suffixes of org-internal artifact files (state/goals/threads/etc) that
+ * share the `<org>.json`/`.jsonl` naming pattern with the org's own config
+ * file. Single source of truth for both listOrgConfigFiles() (which must
+ * exclude them when discovering real org configs) and deleteAction (which
+ * must remove all of them when deleting an org). */
+const ORG_ARTIFACT_SUFFIXES = [
+    '-state', '-goals', '-threads', '-activity', '-approvals', '-members', '-secrets', '-budgets',
+    '-routines', '-issues', '-projects', '-workspaces', '-worktrees', '-environments',
+    '-plugins', '-adapters', '-join-requests', '-bootstrap', '-project-workspaces',
+    '-approval-comments', '-skills',
+];
 function listOrgConfigFiles(orgsDir) {
     return readdirSync(orgsDir)
-        .filter(f => f.endsWith('.json') && !ORG_ARTIFACT_SUFFIXES.some(suf => f.includes(suf)));
+        .filter(f => f.endsWith('.json') && !f.startsWith('._') && !ORG_ARTIFACT_SUFFIXES.some(suf => f.includes(suf)));
 }
 /** Remove a lingering stopfile so a fresh `org run` doesn't self-terminate. */
 export const clearStopfile = (cwd, name) => {
@@ -32,22 +40,27 @@ export const clearStopfile = (cwd, name) => {
 };
 const runAction = async (ctx) => {
     if (!ctx.args[0])
-        return { success: false, message: 'org name required: monomind org run <name> [--task "..."] [--serve] [--port N]' };
+        return { success: false, message: 'org name required: monomind org run <name> [--task "..."]' };
     const validated = validateOrgName(ctx.args[0]);
     if (!validated.ok)
         return validated.result;
     const name = validated.name;
+    // A repeated --task flag is promoted to an array by the parser (deliberate,
+    // documented behavior elsewhere — repeats never silently drop a value); a
+    // plain `as string` cast would let that array flow straight into the org's
+    // goal and get stringified as "a,b" with no warning. Checked before any
+    // side effects (starting the xdeliver listener) run.
+    const taskFlag = ctx.flags['task'];
+    if (Array.isArray(taskFlag))
+        return { success: false, message: '--task was passed more than once — pass it exactly once' };
     const crossProcess = ctx.flags['crossProcess'] !== false;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
     let srv;
-    if (ctx.flags['serve'] !== false) {
-        const port = Number(ctx.flags['port'] ?? 4243);
-        srv = await startOrgServer(daemon, port);
-        log(output.info(`org live view: http://localhost:${srv.port}`));
-        if (crossProcess)
-            daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
+    if (crossProcess) {
+        srv = await startOrgServer(daemon, 0);
+        daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
     }
-    const running = await daemon.startOrg(name, ctx.flags['task']);
+    const running = await daemon.startOrg(name, taskFlag);
     log(output.info(`org ${name} running (${running.def.roles.length} agents, run ${running.run}) — Ctrl-C or "monomind org stop ${name}" to stop`));
     // stopfile poll lets `org stop` work from another terminal;
     // clear any stale stopfile from a previous run before polling
@@ -101,10 +114,12 @@ const statusAction = async (ctx) => {
 const serveAction = async (ctx) => {
     const crossProcess = ctx.flags['crossProcess'] !== false;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
-    const srv = await startOrgServer(daemon, Number(ctx.flags['port'] ?? 4243));
-    log(output.info(`org daemon serving on http://localhost:${srv.port} — Ctrl-C to stop`));
-    if (crossProcess)
+    let srv;
+    if (crossProcess) {
+        srv = await startOrgServer(daemon, 0);
         daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
+    }
+    log(output.info('org daemon serving — Ctrl-C to stop'));
     // schedule orgs whose definition declares an interval (e.g. "15m", "2h")
     const { OrgScheduler, parseSchedule } = await import('../orgrt/scheduler.js');
     const sched = new OrgScheduler(async (name, intervalMs) => {
@@ -137,7 +152,7 @@ const serveAction = async (ctx) => {
     });
     const orgDir = join(ctx.cwd, ORG_DIR);
     if (existsSync(orgDir)) {
-        for (const f of readdirSync(orgDir).filter(f => f.endsWith('.json'))) {
+        for (const f of listOrgConfigFiles(orgDir)) {
             try {
                 const def = JSON.parse(readFileSync(join(orgDir, f), 'utf8'));
                 const ms = parseSchedule(def.schedule);
@@ -150,13 +165,15 @@ const serveAction = async (ctx) => {
                     log(output.info(`scheduled org ${stem} every ${Math.round(ms / 60_000)}m`));
                 }
             }
-            catch { /* skip unparseable org file */ }
+            catch (err) {
+                log(output.warning(`org file ${f}: could not parse — skipping (${err instanceof Error ? err.message : 'invalid JSON'})`));
+            }
         }
     }
     await new Promise(r => { process.once('SIGINT', () => r()); process.once('SIGTERM', () => r()); });
     sched.stop();
     await daemon.stopAll();
-    srv.close();
+    srv?.close();
     return { success: true };
 };
 const testLoopAction = async (ctx) => {
@@ -191,7 +208,7 @@ const deleteAction = async (ctx) => {
         log(output.error('Usage: monomind org delete <name>'));
         return { success: false, message: 'org name required' };
     }
-    if (!/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+    if (!ORG_NAME_RE.test(orgName)) {
         log(output.error(`Invalid org name: ${orgName}`));
         return { success: false, message: 'invalid org name' };
     }
@@ -208,12 +225,8 @@ const deleteAction = async (ctx) => {
         log(output.error(`Org not found: ${orgName}`));
         return { success: false, message: 'org not found' };
     }
-    const suffixes = ['', '-state', '-goals', '-routines', '-approvals', '-activity',
-        '-issues', '-members', '-projects', '-workspaces', '-worktrees', '-environments',
-        '-plugins', '-adapters', '-budgets', '-threads', '-secrets', '-join-requests',
-        '-bootstrap', '-project-workspaces', '-approval-comments', '-skills'];
     let removed = 0;
-    for (const suf of suffixes) {
+    for (const suf of ['', ...ORG_ARTIFACT_SUFFIXES]) {
         for (const ext of ['.json', '.jsonl']) {
             const f = join(orgsDir, `${orgName}${suf}${ext}`);
             try {
@@ -248,7 +261,7 @@ const deleteAction = async (ctx) => {
 };
 const markCompleteAction = async (ctx) => {
     const orgName = ctx.args[0];
-    if (!orgName || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+    if (!orgName || !ORG_NAME_RE.test(orgName)) {
         log(output.error('Usage: monomind org mark-complete <name>'));
         return { success: false, message: 'valid org name required' };
     }
@@ -284,8 +297,6 @@ export const orgCommand = {
             name: 'run', description: 'Start an org (foreground daemon)',
             options: [
                 { name: 'task', description: 'Override the org goal for this run', type: 'string' },
-                { name: 'serve', description: 'Serve the live dashboard (default true)', type: 'boolean', default: true },
-                { name: 'port', description: 'Live dashboard port', type: 'number', default: 4243 },
                 { name: 'cross-process', description: 'Discover and message orgs hosted by other monomind processes on this machine (default true)', type: 'boolean', default: true },
             ],
             examples: [{ command: 'monomind org run growth --task "weekly report"', description: 'Run the growth org once with a task' }],
@@ -296,7 +307,6 @@ export const orgCommand = {
         {
             name: 'serve', description: 'Start the daemon server only (hosts scheduled orgs)',
             options: [
-                { name: 'port', description: 'Port', type: 'number', default: 4243 },
                 { name: 'cross-process', description: 'Discover and message orgs hosted by other monomind processes on this machine (default true)', type: 'boolean', default: true },
             ],
             action: serveAction,
@@ -315,7 +325,14 @@ export const orgCommand = {
         { name: 'mark-complete', description: 'Manually close a stale/crashed run', action: markCompleteAction },
     ],
     examples: [{ command: 'monomind org run my-org', description: 'Run an org under full daemon control' }],
-    action: async () => ({ success: false, message: 'usage: monomind org <run|stop|status|serve|test-loop|list|delete|mark-complete>' }),
+    action: async () => {
+        // index.ts's dispatcher never prints result.message on a failed action —
+        // it only exits with result.exitCode — so this must log itself or bare
+        // `monomind org` exits silently with code 1 and zero output.
+        const message = 'usage: monomind org <run|stop|status|serve|test-loop|list|delete|mark-complete>';
+        log(output.error(message));
+        return { success: false, message };
+    },
 };
 export default orgCommand;
 //# sourceMappingURL=org.js.map

package/packages/@monomind/cli/dist/src/commands/platforms.d.ts

@@ -5,7 +5,7 @@
  * github.com/monoes/monomind
  */
 import type { Command } from '../types.js';
-export declare const SUPPORTED_PLATFORMS: readonly ["claude", "gemini", "cursor", "vscode", "copilot", "opencode", "aider", "kiro", "trae", "claw", "droid", "antigravity", "hermes", "codex"];
+export declare const SUPPORTED_PLATFORMS: readonly ['claude', 'gemini', 'cursor', 'vscode', 'copilot', 'opencode', 'aider', 'kiro', 'trae', 'claw', 'droid', 'antigravity', 'hermes', 'codex'];
 export type Platform = typeof SUPPORTED_PLATFORMS[number];
 export declare const platformsCommand: Command;
 //# sourceMappingURL=platforms.d.ts.map

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -575,6 +575,13 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             const destHelpersDir = path.join(targetDir, '.claude', 'helpers');
             // Copy top-level critical files atomically
             const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'statusline.cjs', 'graphify-freshen.cjs'];
+            // Generated fallback for any critical helper missing from the source dir itself
+            // (e.g. the published npm template lacking auto-memory-hook.mjs).
+            const criticalGenerators = {
+                'hook-handler.cjs': generateHookHandler,
+                'intelligence.cjs': generateIntelligenceStub,
+                'auto-memory-hook.mjs': generateAutoMemoryHook,
+            };
             for (const helperName of criticalHelpers) {
                 const targetPath = path.join(destHelpersDir, helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
@@ -594,6 +601,17 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                     catch { }
                     fs.renameSync(tmp, targetPath);
                 }
+                else if (!fs.existsSync(targetPath) && criticalGenerators[helperName]) {
+                    const content = criticalGenerators[helperName]();
+                    const tmp = `${targetPath}.${process.pid}.tmp`;
+                    fs.writeFileSync(tmp, content, 'utf-8');
+                    try {
+                        fs.chmodSync(tmp, 0o755);
+                    }
+                    catch { }
+                    fs.renameSync(tmp, targetPath);
+                    result.created.push(`.claude/helpers/${helperName}`);
+                }
             }
             // Always recursively sync subdirectories (utils/, handlers/) — required by hook-handler.cjs.
             // Uses recursive copy so any future nested subdirs are also covered.
@@ -1222,7 +1240,6 @@ async function writeHelpers(targetDir, options, result) {
     const sourceHelpersDir = findSourceHelpersDir(options.sourceBaseDir);
     // Try to copy existing helpers from source first (recursive — includes utils/ and handlers/)
     if (sourceHelpersDir && fs.existsSync(sourceHelpersDir)) {
-        let copiedCount = 0;
         const copyRecursive = (srcDir, destDir, relBase) => {
             fs.mkdirSync(destDir, { recursive: true });
             for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
@@ -1242,7 +1259,6 @@ async function writeHelpers(targetDir, options, result) {
                             fs.chmodSync(destPath, '755');
                         }
                         result.created.files.push(`.claude/helpers/${relPath}`);
-                        copiedCount++;
                     }
                     else {
                         result.skipped.push(`.claude/helpers/${relPath}`);
@@ -1251,11 +1267,12 @@ async function writeHelpers(targetDir, options, result) {
             }
         };
         copyRecursive(sourceHelpersDir, helpersDir, '');
-        if (copiedCount > 0) {
-            return; // Skip generating if we copied from source
-        }
     }
-    // Fall back to generating helpers if source not available
+    // Always run the fallback generator too — it only fills in files still missing
+    // after the source copy above (it no-ops on anything the copy already wrote).
+    // Without this, a source dir that's present but incomplete (e.g. missing
+    // auto-memory-hook.mjs) silently ships a project wired to hooks that reference
+    // a file that was never installed.
     const helpers = {
         'pre-commit': generatePreCommitHook(),
         'post-commit': generatePostCommitHook(),
@@ -1268,6 +1285,13 @@ async function writeHelpers(targetDir, options, result) {
     };
     for (const [name, content] of Object.entries(helpers)) {
         const filePath = path.join(helpersDir, name);
+        // If the source dir has this file, copyRecursive above already applied
+        // the correct (force-aware) copy — never let this generated fallback
+        // clobber it with a bare-bones stub. Only step in when source truly
+        // doesn't have the file, regardless of `force`.
+        const inSource = !!(sourceHelpersDir && fs.existsSync(path.join(sourceHelpersDir, name)));
+        if (inSource)
+            continue;
         if (!fs.existsSync(filePath) || options.force) {
             atomicWriteFile(filePath, content);
             // Make shell scripts executable

package/packages/@monomind/cli/dist/src/mcp-tools/auto-install.d.ts

@@ -47,12 +47,12 @@ export declare function resetInstallAttempts(): void;
  */
 export declare const OPTIONAL_PACKAGES: {
     readonly 'monofence-ai': {
-        readonly description: "AI manipulation defense (prompt injection, PII detection)";
-        readonly tools: readonly ["aidefence_scan", "aidefence_analyze", "aidefence_stats", "aidefence_learn"];
+        readonly description: 'AI manipulation defense (prompt injection, PII detection)';
+        readonly tools: readonly ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'];
     };
     readonly 'onnxruntime-node': {
-        readonly description: "ONNX runtime for neural network inference";
-        readonly tools: readonly ["neural_*"];
+        readonly description: 'ONNX runtime for neural network inference';
+        readonly tools: readonly ['neural_*'];
     };
 };
 declare const _default: {
@@ -62,12 +62,12 @@ declare const _default: {
     resetInstallAttempts: typeof resetInstallAttempts;
     OPTIONAL_PACKAGES: {
         readonly 'monofence-ai': {
-            readonly description: "AI manipulation defense (prompt injection, PII detection)";
-            readonly tools: readonly ["aidefence_scan", "aidefence_analyze", "aidefence_stats", "aidefence_learn"];
+            readonly description: 'AI manipulation defense (prompt injection, PII detection)';
+            readonly tools: readonly ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'];
         };
         readonly 'onnxruntime-node': {
-            readonly description: "ONNX runtime for neural network inference";
-            readonly tools: readonly ["neural_*"];
+            readonly description: 'ONNX runtime for neural network inference';
+            readonly tools: readonly ['neural_*'];
         };
     };
 };