monomind 2.5.1 → 2.5.3

package/packages/@monomind/cli/.claude/commands/mastermind/runorgv1.md

@@ -60,7 +60,7 @@ Scan `$ARGUMENTS` for these flags and store their values. Remove them from the a
 | `--wait <N>` | `wait_seconds = N` | 60 |
 | `--repeat <N>` | `repeat_count = N` | 0 |
 
-⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind-skills:runorgv1") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind-skills:_repeat")` at the end.
+⚠️ **CRITICAL — CONTINUATION RUNS DO NOT SKIP WORK.** When `--rep N` is present, this is a scheduled continuation triggered by ScheduleWakeup. The org's FULL work cycle MUST still execute every time: session variables → session:start event → Skill("mastermind-runorgv1") → session:complete event. NEVER short-circuit or skip the org work because `--rep` is present. The `--rep` / `--loop` flags are only consumed by `Skill("mastermind-repeat")` at the end.
 
 ---
 
@@ -88,7 +88,7 @@ Verify the org file exists before proceeding:
 ```
 If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
 
-Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+Load brain context for the `ops` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure, namespace: `ops`).
 
 Resolve session ID and project root:
 ```bash
@@ -123,7 +123,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-Invoke `Skill("mastermind-skills:runorgv1")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
+Invoke `Skill("mastermind-runorgv1")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
 
 After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
 ```bash
@@ -136,10 +136,10 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],project:$proj,ts:(now*1000|floor)}')" || true
 ```
 
-Follow _protocol.md Brain Write Procedure for domain `ops`.
+Follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
 
 
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
+**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
 
 After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
 ```bash

package/packages/@monomind/cli/.claude/commands/mastermind/sales.md

@@ -1,6 +1,6 @@
 <!-- Mastermind sales domain — outreach sequences, proposals, pipeline management. Default mode: confirm. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
 
 Parse `$ARGUMENTS` for:
 - `--auto` flag → mode = auto
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 If prompt is empty: ask "What sales task would you like to tackle?"
 
-Load brain context for the `sales` domain (follow _protocol.md Brain Load Procedure).
+Load brain context for the `sales` domain (follow mastermind-protocol/SKILL.md Brain Load Procedure).
 
-Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `sales`).
+Run intake if prompt is vague (follow mastermind-intake/SKILL.md — stop at Q3, domain is already known as `sales`).
 
 Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
 
-Invoke `Skill("mastermind-skills:sales")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+Invoke `Skill("mastermind-sales")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
-After skill returns: follow _protocol.md Brain Write Procedure for domain `sales`.
+After skill returns: follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `sales`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/skill-builder.md

@@ -1,17 +1,17 @@
 <!-- Use when creating, editing, or verifying mastermind skills — guides the full TDD-for-docs cycle from baseline test through deployment -->
 
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **auto**.
 
 ---
 
-Invoke `Skill("mastermind-skills:skill-builder")` passing: brain_context, params, mode.
+Invoke `Skill("mastermind-skill-builder")` passing: brain_context, params, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.
+Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

package/packages/@monomind/cli/.claude/commands/mastermind/stoporg.md

@@ -62,7 +62,7 @@ session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
 CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
 ```
 
-Invoke `Skill("mastermind-skills:stoporg")` passing: org_name: `$org_name`, session_id: `$session_id`, caller: "command".
+Invoke `Skill("mastermind-stoporg")` passing: org_name: `$org_name`, session_id: `$session_id`, caller: "command".
 
 After skill returns: emit `session:complete`:
 ```bash
@@ -73,6 +73,6 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "x-monomind-token: $(cat "
     '{type:"session:complete",session:$session,domain:"ops",status:"complete",domains:["ops"],ts:(now*1000|floor)}')" || true
 ```
 
-Follow _protocol.md Brain Write Procedure for domain `ops`.
+Follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/taskdev.md

@@ -1,6 +1,6 @@
 <!-- Execute an implementation plan task-by-task using fresh subagents with two-stage review per task. Default mode: auto. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check and intake below.
 
 Parse `$ARGUMENTS` for:
 - `--auto` flag → mode = auto
@@ -10,14 +10,14 @@ Parse `$ARGUMENTS` for:
 
 If plan_file is empty: ask "Which plan file should I execute? (provide an absolute path)"
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **auto** (unless `--confirm` flag is present).
 
 ---
 
-Invoke `Skill("mastermind-skills:taskdev")` passing: brain_context, plan_file, project_name, mode.
+Invoke `Skill("mastermind-taskdev")` passing: brain_context, plan_file, project_name, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
+**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/tdd.md

@@ -1,10 +1,10 @@
 <!-- Implement a feature or bugfix using Test-Driven Development — Red-Green-Refactor with the Iron Law enforced. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = feature_or_bug.
 
-Load brain context for the `tdd` domain (follow `_protocol.md` Brain Load Procedure).
+Load brain context for the `tdd` domain (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 If feature_or_bug is empty: ask "What feature or bug should be implemented with TDD?"
 
@@ -12,8 +12,8 @@ Default mode: **auto**.
 
 ---
 
-Invoke `Skill("mastermind-skills:tdd")` passing: brain_context, feature_or_bug, project_name, mode.
+Invoke `Skill("mastermind-tdd")` passing: brain_context, feature_or_bug, project_name, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `tdd`.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure for domain `tdd`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
+**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/techport.md

@@ -1,6 +1,6 @@
 <!-- Tech Port — deep-analyzes a foreign project folder and recommends porting valuable features, patterns, or infrastructure into the current monomind base project. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check below.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing. If `is_continuation = true`, skip the empty-prompt check below.
 
 Parse `$ARGUMENTS` for:
 - First path-like token (starts with `/`, `./`, `../`, or `~`) → source_path
@@ -11,7 +11,7 @@ Parse `$ARGUMENTS` for:
 
 If source_path is empty: ask "What is the path to the project you want to analyze?"
 
-Load brain context for the `techport` domain (follow `_protocol.md` Brain Load Procedure).
+Load brain context for the `techport` domain (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **confirm** (show analysis + port plan, wait before executing anything).
 
@@ -20,8 +20,8 @@ Default mode: **confirm** (show analysis + port plan, wait before executing anyt
 > /mastermind:techport --tillend --auto /path/to/project
 > ```
 
-Invoke `Skill("mastermind-skills:techport")` passing: source_path, focus_hint, mode.
+Invoke `Skill("mastermind-techport")` passing: source_path, focus_hint, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `techport`.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure for domain `techport`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+Invoke `Skill("mastermind-repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.

package/packages/@monomind/cli/.claude/commands/mastermind/verify.md

@@ -1,10 +1,10 @@
 <!-- Run the verification gate before claiming any work is complete, fixed, or passing — evidence before assertions always. -->
 
-**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text = claim_or_task.
 
-Load brain context for the `verify` domain (follow `_protocol.md` Brain Load Procedure).
+Load brain context for the `verify` domain (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 If claim_or_task is empty: ask "What claim or task needs verification?"
 
@@ -12,8 +12,8 @@ Default mode: **auto**.
 
 ---
 
-Invoke `Skill("mastermind-skills:verify")` passing: brain_context, claim_or_task, project_name, mode.
+Invoke `Skill("mastermind-verify")` passing: brain_context, claim_or_task, project_name, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure for domain `verify`.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure for domain `verify`.
 
-**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
+**MANDATORY — invoke `Skill("mastermind-repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/worktree.md

@@ -1,17 +1,17 @@
 <!-- Use when starting feature work that needs isolation from the current workspace or before executing implementation plans — sets up an isolated git worktree -->
 
-**First — extract repeat flags:** Follow REPEAT PREAMBLE from `_repeat.md`.
+**First — extract repeat flags:** Follow REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`.
 
 Parse `$ARGUMENTS` for `--auto`, `--confirm`, `--project <name>`, and remaining text.
 
-Load brain context (follow `_protocol.md` Brain Load Procedure).
+Load brain context (follow `mastermind-protocol/SKILL.md` Brain Load Procedure).
 
 Default mode: **auto**.
 
 ---
 
-Invoke `Skill("mastermind-skills:worktree")` passing: brain_context, params, mode.
+Invoke `Skill("mastermind-worktree")` passing: brain_context, params, mode.
 
-After skill returns: follow `_protocol.md` Brain Write Procedure.
+After skill returns: follow `mastermind-protocol/SKILL.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now. Required — do not skip.
+Invoke `Skill("mastermind-repeat")` now. Required — do not skip.

package/packages/@monomind/cli/.claude/helpers/control-start.cjs

@@ -261,6 +261,36 @@ async function main() {
       process.stdout.write(`[control] port ${DEFAULT_PORT} is served by another project's control server — reusing it (killed redundant child)\n`);
       const foreignPid = await probePort(DEFAULT_PORT);
       writeStatus(typeof foreignPid === 'number' ? foreignPid : 0, DEFAULT_PORT);
+      // Pair with the foreign server: resolve its project dir from its pid,
+      // copy its dashboard-token beside OUR control.json (ingest is
+      // default-deny — without this every event from this project 401s
+      // silently), and self-register in its known-projects so future token
+      // rotations propagate back here on server restart.
+      try {
+        if (typeof foreignPid === 'number' && foreignPid > 0) {
+          const { execFileSync } = require('child_process');
+          const out = execFileSync('lsof', ['-a', '-p', String(foreignPid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', timeout: 3000 });
+          const nLine = out.split('\n').find((l) => l.startsWith('n'));
+          const serverHome = nLine ? nLine.slice(1) : null;
+          if (serverHome) {
+            const srcTok = path.join(serverHome, '.monomind', 'dashboard-token');
+            const dstTok = path.join(CWD, '.monomind', 'dashboard-token');
+            if (fs.existsSync(srcTok)) {
+              fs.copyFileSync(srcTok, dstTok);
+              fs.chmodSync(dstTok, 0o600);
+            }
+            const kpFile = path.join(serverHome, 'data', 'known-projects.json');
+            try {
+              const kp = fs.existsSync(kpFile) ? JSON.parse(fs.readFileSync(kpFile, 'utf8')) : [];
+              if (Array.isArray(kp) && !kp.includes(CWD)) {
+                kp.push(CWD);
+                fs.writeFileSync(kpFile, JSON.stringify(kp));
+              }
+            } catch { /* registry unreadable — token copy alone still unblocks events */ }
+            process.stdout.write('[control] paired dashboard token and registered this project with the shared server\n');
+          }
+        }
+      } catch { /* pairing is best-effort; propagation-on-restart is the fallback */ }
       return;
     }
     // Server never became reachable on any expected port — kill the child

package/packages/@monomind/cli/.claude/helpers/event-logger.cjs

@@ -194,7 +194,7 @@ async function main() {
 
   // Detect route changes and worker metric updates by mtime and forward them too.
   // These aren't Claude Code hook events — they're file writes from route-handler.cjs
-  // and the @monomind/hooks workers respectively — so we poll cheaply on every hook invocation.
+  // and the @monoes/hooks workers respectively — so we poll cheaply on every hook invocation.
   forwardFileChanges(monoDir, CWD);
 
   clearTimeout(safety);
@@ -221,7 +221,7 @@ function forwardFileChanges(monoDir, workDir) {
       }
     } catch {}
 
-    // Worker-complete: newest mtime among .monomind/metrics/*.json (written by @monomind/hooks workers)
+    // Worker-complete: newest mtime among .monomind/metrics/*.json (written by @monoes/hooks workers)
     const metricsDir = path.join(workDir, '.monomind', 'metrics');
     try {
       const files = fs.readdirSync(metricsDir).filter(f => f.endsWith('.json') && !f.startsWith('.'));

package/packages/@monomind/cli/.claude/helpers/extras-registry.json

@@ -3686,7 +3686,7 @@
     {
       "slug": "v1-integration-architect",
       "name": "v1-integration-architect",
-      "description": "v1 Integration Architect for cross-package integration work within the Monomind monorepo. Owns the wiring between @monomind/cli, @monomind/hooks, @monomind/memory, @monomind/security, and @monoes/monograph \u2014 ensuring MCP tool contracts, hook event flows, and inter-package APIs stay coherent as each package evolves.",
+      "description": "v1 Integration Architect for cross-package integration work within the Monomind monorepo. Owns the wiring between @monomind/cli, @monoes/hooks, @monomind/memory, @monomind/security, and @monoes/monograph \u2014 ensuring MCP tool contracts, hook event flows, and inter-package APIs stay coherent as each package evolves.",
       "category": "specialists",
       "filePath": "../agents/specialists/integration-architect.md",
       "keywords": [

package/packages/@monomind/cli/.claude/helpers/handlers/agent-start-handler.cjs

@@ -106,7 +106,7 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Bridge to @monomind/hooks registry — fires AgentSpawn hooks (was previously never
+    // Bridge to @monoes/hooks registry — fires AgentSpawn hooks (was previously never
     // wired: HookEvent.AgentSpawn existed but no CJS handler ever fired it).
     try {
       var _hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null;
@@ -125,7 +125,7 @@ module.exports = {
               description: agentDescBridge.slice(0, 500),
             },
           }, { continueOnError: true, timeout: 1500 });
-        }, '@monomind/hooks.AgentSpawn');
+        }, '@monoes/hooks.AgentSpawn');
       }
     } catch (e) { /* non-fatal */ }
   },

package/packages/@monomind/cli/.claude/helpers/handlers/edit-handler.cjs

@@ -152,7 +152,7 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Bridge to @monomind/hooks registry — fires PostEdit hooks (observability bus, guidance provider).
+    // Bridge to @monoes/hooks registry — fires PostEdit hooks (observability bus, guidance provider).
     // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
     // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
     var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
@@ -169,7 +169,7 @@ module.exports = {
             file: { path: editFileBridge, operation: 'modify' },
             duration: 0,
           }, { continueOnError: true, timeout: 1500 });
-        }, '@monomind/hooks.PostEdit');
+        }, '@monoes/hooks.PostEdit');
       } catch (e) { /* non-fatal */ }
     }
 

package/packages/@monomind/cli/.claude/helpers/handlers/gates-handler.cjs

@@ -23,7 +23,7 @@ const path = require('path');
 //
 // monofence-ai (packages/monofence-ai) has real prompt-injection / evasion
 // detection but is never wired into the live Claude Code PreToolUse path —
-// it only registers hooks on @monomind/hooks' internal HookRegistry, which
+// it only registers hooks on @monoes/hooks' internal HookRegistry, which
 // this CJS dispatch path does not use. This loads it lazily (so a missing
 // or unbuilt package never breaks the existing regex gates), bounds it with
 // a hard timeout, and fails open on any error.

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -111,7 +111,7 @@ module.exports = {
       var result = await Promise.resolve(routeFn(prompt));
 
       // ── Enrichment: when router.cjs falls to the broad "coder" catch-all,
-      //    try @monomind/routing's richer keyword pre-filter (30+ specialized
+      //    try @monoes/routing's richer keyword pre-filter (30+ specialized
       //    rules for Solidity, game engines, DevOps, embedded, etc.) for a
       //    more specific agent match. This bridges the hooks layer (router.cjs)
       //    with the CLI routing package without requiring ESM imports. ─────────

package/packages/@monomind/cli/.claude/helpers/handlers/session-handler.cjs

@@ -166,7 +166,7 @@ module.exports = {
       }
     } catch (e) { console.log('[WARN] Session end failed: ' + e.message); }
 
-    // Bridge to @monomind/hooks registry — fires SessionEnd hooks (episode-binner closeEpisode, observability bus).
+    // Bridge to @monoes/hooks registry — fires SessionEnd hooks (episode-binner closeEpisode, observability bus).
     // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
     // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
     var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);

package/packages/@monomind/cli/.claude/helpers/handlers/session-restore-handler.cjs

@@ -30,20 +30,20 @@ module.exports = {
       }
     } catch (e) { console.log('[WARN] Session restore failed: ' + e.message); }
 
-    // ── Non-blocking security scan via @monomind/hooks worker ─────────────
+    // ── Non-blocking security scan via @monoes/hooks worker ─────────────
     // The hooks package ships a security worker (worker-security.ts) that scans
     // for hardcoded secrets and vulnerability patterns. We run it at session
     // start as a fire-and-forget check — failures are silently ignored since
     // the package may not be installed or built.
     try {
-      var hooksWorkersMod = require('@monomind/hooks/dist/workers/worker-security.js');
+      var hooksWorkersMod = require('@monoes/hooks/dist/workers/worker-security.js');
       var _createSecurityWorker = hooksWorkersMod.createSecurityWorker;
       if (typeof _createSecurityWorker === 'function') {
         var _securityScan = _createSecurityWorker(CWD);
         // Fire-and-forget: do not await — must not delay session restore
         Promise.resolve(_securityScan()).catch(function() {});
       }
-    } catch (e) { /* @monomind/hooks not available or not built — skip */ }
+    } catch (e) { /* @monoes/hooks not available or not built — skip */ }
 
     // Stale helper self-heal — silently refresh project helpers that drift from
     // the bundled npm copy, so a `npm i -g monomind@latest` (or npx picking up a
@@ -226,16 +226,16 @@ module.exports = {
       }
     }
 
-    // Bridge to @monomind/hooks compiled workers (GAP-001).
+    // Bridge to @monoes/hooks compiled workers (GAP-001).
     // Uses the shared hCtx._ensureHooksModule() (defined in hook-handler.cjs) so worker
     // registration happens exactly once per process instead of being duplicated here —
     // every other bridging handler (agent-start, pre-task, post-task, post-edit,
     // session-end) calls the same lazy loader since each hook event is its own process.
     try {
-      var hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : await import('@monomind/hooks');
+      var hooksModule = hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : await import('@monoes/hooks');
       if (hooksModule) {
         hCtx._hooksModule = hooksModule;
-        console.log('[INFO] @monomind/hooks workers initialized');
+        console.log('[INFO] @monoes/hooks workers initialized');
 
         // Gate enforcement lives entirely in gates-handler.cjs (its own regex
         // table, run on every PreToolUse). The @monomind/guidance package that
@@ -251,16 +251,16 @@ module.exports = {
                   startedAt: new Date(),
                 },
               }, { continueOnError: true, timeout: 1500 });
-            }, '@monomind/hooks.SessionStart');
+            }, '@monoes/hooks.SessionStart');
           } catch (e2) { /* non-fatal */ }
         }
       }
-    } catch (e) { /* @monomind/hooks not compiled yet — skip */ }
+    } catch (e) { /* @monoes/hooks not compiled yet — skip */ }
 
     // Refresh worker metrics once per session start — the statusline
     // (.claude/helpers/statusline.cjs) reads .monomind/metrics/ddd-progress.json,
     // route-handler.cjs and doctor read codebase-map/security-audit/performance/
-    // consolidation.json; the @monomind/hooks workers are never otherwise
+    // consolidation.json; the @monoes/hooks workers are never otherwise
     // scheduled on the live hook path (the worker daemon that used to produce
     // these files was deleted).
     //
@@ -295,7 +295,7 @@ module.exports = {
           var _create = (hooksModule && typeof hooksModule[_w.factory] === 'function')
             ? hooksModule[_w.factory] : null;
           if (!_create) {
-            // Dev-repo fallback: bare '@monomind/hooks' does not resolve from .claude/helpers
+            // Dev-repo fallback: bare '@monoes/hooks' does not resolve from .claude/helpers
             // in the monorepo (pnpm workspace link lives under packages/@monomind/cli), so
             // import the compiled worker directly by path.
             var _wDist = path.join(_hooksDistDir, _w.file);
@@ -307,7 +307,7 @@ module.exports = {
           if (_create) {
             var _wRun = _create(CWD);
             // runWithTimeout caps each at 1.5s so a slow worker can never block session start.
-            await runWithTimeout(function() { return _wRun(); }, '@monomind/hooks.' + _w.factory);
+            await runWithTimeout(function() { return _wRun(); }, '@monoes/hooks.' + _w.factory);
           }
         } catch (e) { /* non-fatal — worker unavailable */ }
       }

package/packages/@monomind/cli/.claude/helpers/handlers/task-handler.cjs

@@ -26,7 +26,7 @@ module.exports = {
     // - PromptVersioning experiments (unused feature)
     // - Monograph blast radius (already shown by post-edit hook on actual changes)
 
-    // Bridge to @monomind/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks.
+    // Bridge to @monoes/hooks registry — fires Tasks 26 (PromptAssembler) and any other PreTask hooks.
     // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
     // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
     var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);
@@ -114,7 +114,7 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
-    // Bridge to @monomind/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks.
+    // Bridge to @monoes/hooks registry — fires Tasks 39 (SpecializationScorer) and any other PostTask hooks.
     // Each hook event runs in a fresh process, so hCtx._hooksModule set by session-restore in an
     // earlier invocation is never visible here — must (re)load lazily via _ensureHooksModule().
     var _hooksModule = hCtx._hooksModule || (hCtx._ensureHooksModule ? await hCtx._ensureHooksModule() : null);

package/packages/@monomind/cli/.claude/helpers/hook-handler.cjs

@@ -12,7 +12,7 @@
  *    configuration. They are plain CommonJS scripts invoked directly
  *    by Claude Code's hook runtime. This is the "live" system.
  *
- * 2. @monomind/hooks TypeScript package (packages/@monomind/hooks/)
+ * 2. @monoes/hooks TypeScript package (packages/@monomind/hooks/)
  *    A full TypeScript package with workers, learning services, and
  *    a WorkerManager. It compiles to dist/ but is only loaded
  *    optionally, bridged at six lifecycle events: SessionStart (restore),
@@ -23,7 +23,7 @@
  *
  *    IMPORTANT: each hook event is dispatched as its OWN fresh `node`
  *    process (Claude Code spawns one invocation per event — this file
- *    does not stay resident across events). So the @monomind/hooks
+ *    does not stay resident across events). So the @monoes/hooks
  *    module, and anything it registers (trace collector spans, episode
  *    binner, etc.), cannot be set up once and reused across events —
  *    every bridging handler must call hCtx._ensureHooksModule() itself,
@@ -102,7 +102,7 @@ const session = safeRequire(path.join(helpersDir, 'session.cjs'));
 const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
 const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
 
-// Module-level reference to @monomind/hooks — populated lazily via
+// Module-level reference to @monoes/hooks — populated lazily via
 // _ensureHooksModule(). NOTE: hook-handler.cjs runs as a fresh `node` process
 // per hook event (Claude Code spawns one invocation per event, it does not
 // keep the process alive across events), so a value set during one event
@@ -116,10 +116,10 @@ async function _ensureHooksModule() {
   if (_hooksModule) return _hooksModule;
   if (_hooksModuleLoadAttempted) return null; // already tried+failed this process
   _hooksModuleLoadAttempted = true;
-  // 1) Bare specifier — works when @monomind/hooks is installed/linked in a
+  // 1) Bare specifier — works when @monoes/hooks is installed/linked in a
   //    node_modules reachable from this file (e.g. an end-user install).
   try {
-    _hooksModule = await import('@monomind/hooks');
+    _hooksModule = await import('@monoes/hooks');
   } catch (e) {
     _hooksModule = null;
   }
@@ -141,11 +141,11 @@ async function _ensureHooksModule() {
   return _hooksModule;
 }
 
-// ── Visible one-time warning when the @monomind/hooks bridge fully fails ───
+// ── Visible one-time warning when the @monoes/hooks bridge fully fails ───
 // Both load paths above (bare specifier + dev-repo file:// fallback) failed:
 // the 15 background workers (metrics, security scan, DDD tracking, etc.) are
 // unavailable for the rest of this session. This is almost always because
-// @monomind/hooks was never resolvable from npm (it ships with
+// @monoes/hooks was never resolvable from npm (it ships with
 // optionalDependencies:"*", which npm silently skips) — NOT a problem with
 // the user's own project setup. Historically this failed completely
 // silently (see docs/AUDIT-BACKLOG.md P1-1), burning debugging time on the
@@ -166,7 +166,7 @@ function _warnHooksBridgeUnavailable() {
     }
     if (alreadyWarned) return;
     process.stderr.write(
-      '[WARN] @monomind/hooks could not be loaded (bare specifier and dev-repo fallback both failed) — ' +
+      '[WARN] @monoes/hooks could not be loaded (bare specifier and dev-repo fallback both failed) — ' +
       'background workers (metrics, security scan, DDD tracking, etc.) are unavailable this session. ' +
       'This is not a problem with your project configuration — the package is not resolvable via npm ' +
       'from this install. See docs/AUDIT-BACKLOG.md P1-1 or https://github.com/monoes/monomind/issues.\n'

package/packages/@monomind/cli/.claude/helpers/utils/monograph.cjs

@@ -301,27 +301,59 @@ function _graphGateStateFile() {
   return path.join(CWD, '.monomind', 'graph-gate-state.json');
 }
 
+// State is a per-session MAP ({ sessions: { [id]: {queried, blockedOnce, ts} } }).
+// It used to be a single {sessionId,...} record — with two Claude sessions open
+// on the same project, each session's grep clobbered the other's latch, so the
+// "once per session" cap ping-ponged into blocking every call in both sessions.
+// Legacy single-record files are migrated on read; entries are pruned to the
+// 20 most recent so the file can't grow unbounded.
+function _graphGateReadSessions() {
+  var d = {};
+  try { d = JSON.parse(fs.readFileSync(_graphGateStateFile(), 'utf-8')); } catch (e) {}
+  if (typeof d !== 'object' || d === null) d = {};
+  var sessions = (typeof d.sessions === 'object' && d.sessions !== null) ? d.sessions : {};
+  if (d.sessionId) { // legacy single-record shape — fold it in
+    sessions[d.sessionId] = { queried: !!d.queried, blockedOnce: !!d.blockedOnce, ts: Date.now() };
+  }
+  return sessions;
+}
+
+function _graphGateWriteSessions(sessions) {
+  var ids = Object.keys(sessions);
+  if (ids.length > 20) {
+    ids.sort(function (a, b) { return (sessions[a].ts || 0) - (sessions[b].ts || 0); });
+    for (var i = 0; i < ids.length - 20; i++) delete sessions[ids[i]];
+  }
+  fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
+  fs.writeFileSync(_graphGateStateFile(), JSON.stringify({ sessions: sessions }));
+}
+
 function _graphGateMarkQueried(sessionId) {
   if (!sessionId) return;
   try {
-    fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
-    fs.writeFileSync(_graphGateStateFile(), JSON.stringify({ sessionId: sessionId, queried: true }));
+    var sessions = _graphGateReadSessions();
+    var s = sessions[sessionId] || { blockedOnce: false };
+    s.queried = true;
+    s.ts = Date.now();
+    sessions[sessionId] = s;
+    _graphGateWriteSessions(sessions);
   } catch (e) { /* non-fatal */ }
 }
 
 function _graphGateShouldBlock(sessionId) {
+  // MONOMIND_GRAPH_GATE=off disables the gate entirely — for headless/CI runs
+  // (claude -p, org agents, scripted probes) where each run is a fresh session
+  // that would otherwise eat one deliberate block on its first grep/find.
+  if (String(process.env.MONOMIND_GRAPH_GATE || '').toLowerCase() === 'off') return false;
   if (!sessionId || !_isGraphFresh()) return false;
-  var f = _graphGateStateFile();
-  var d = {};
-  try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (e) {}
-  if (typeof d !== 'object' || d === null || d.sessionId !== sessionId) {
-    d = { sessionId: sessionId, queried: false, blockedOnce: false };
-  }
-  if (d.queried || d.blockedOnce) return false;
-  d.blockedOnce = true;
+  var sessions = _graphGateReadSessions();
+  var s = sessions[sessionId] || { queried: false, blockedOnce: false };
+  if (s.queried || s.blockedOnce) return false;
+  s.blockedOnce = true;
+  s.ts = Date.now();
+  sessions[sessionId] = s;
   try {
-    fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
-    fs.writeFileSync(f, JSON.stringify(d));
+    _graphGateWriteSessions(sessions);
   } catch (e) { return false; }
   return true;
 }