@soleri/core 9.15.0 → 9.16.7

package/src/runtime/admin-ops.ts

@@ -5,8 +5,9 @@
  * runtime state. No new modules needed — uses existing runtime parts.
  */
 
-import { readFileSync, statSync } from 'node:fs';
+import { readFileSync, statSync, existsSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
@@ -147,20 +148,21 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           };
         }
         // Fallback — just describe admin ops
+        const adminOps = [
+          'admin_health',
+          'admin_tool_list',
+          'admin_config',
+          'admin_vault_size',
+          'admin_uptime',
+          'admin_version',
+          'admin_reset_cache',
+          'admin_diagnostic',
+        ];
         return {
-          count: 8,
-          ops: {
-            admin: [
-              'admin_health',
-              'admin_tool_list',
-              'admin_config',
-              'admin_vault_size',
-              'admin_uptime',
-              'admin_version',
-              'admin_reset_cache',
-              'admin_diagnostic',
-            ],
-          },
+          count: adminOps.length,
+          scope: 'admin-only',
+          note: 'Pass _allOps for full system op count',
+          ops: { admin: adminOps },
           routing: buildRoutingHints(),
         };
       },
@@ -380,7 +382,7 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           });
         }
 
-        // 7. Skills
+        // 7. Skills — check discovered vs registered in .claude/skills/
         try {
           const agentDir = runtime.config.agentDir;
           const skillsDirs = agentDir ? [join(agentDir, 'skills')] : [];
@@ -388,12 +390,52 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           const installedPacks = packInstaller.list();
           const packSkillCount = installedPacks.reduce((sum, p) => sum + p.skills.length, 0);
           const totalSkills = agentSkills.length + packSkillCount;
-          const skillStatus = totalSkills > 0 ? 'ok' : agentDir ? 'warn' : 'ok';
-          checks.push({
-            name: 'skills',
-            status: skillStatus,
-            detail: `${totalSkills} skills (${agentSkills.length} agent, ${packSkillCount} pack)`,
-          });
+
+          // Check registration status in .claude/skills/
+          const claudeSkillsDir = join(homedir(), '.claude', 'skills');
+          let registeredCount = 0;
+          let brokenCount = 0;
+          const unregistered: string[] = [];
+
+          if (existsSync(claudeSkillsDir)) {
+            try {
+              const registered = readdirSync(claudeSkillsDir, { withFileTypes: true });
+              registeredCount = registered.length;
+              for (const entry of registered) {
+                if (entry.isSymbolicLink()) {
+                  try {
+                    statSync(join(claudeSkillsDir, entry.name));
+                  } catch {
+                    brokenCount++;
+                  }
+                }
+              }
+            } catch {
+              // Can't read .claude/skills/ — skip registration check
+            }
+          }
+
+          for (const skill of agentSkills) {
+            const skillRegisteredDir = join(claudeSkillsDir, skill.name);
+            if (!existsSync(skillRegisteredDir)) {
+              unregistered.push(skill.name);
+            }
+          }
+
+          const hasIssues = unregistered.length > 0 || brokenCount > 0;
+          // Warn only when agentDir is set but no skills exist anywhere (local OR global)
+          const hasAnySkills = totalSkills > 0 || registeredCount > 0;
+          const skillStatus = !hasAnySkills && agentDir ? 'warn' : hasIssues ? 'warn' : 'ok';
+          const detail = [
+            `${totalSkills} discovered (${agentSkills.length} agent, ${packSkillCount} pack)`,
+            `${registeredCount} registered in .claude/skills/`,
+            ...(unregistered.length > 0
+              ? [`${unregistered.length} unregistered: ${unregistered.join(', ')}`]
+              : []),
+            ...(brokenCount > 0 ? [`${brokenCount} broken links`] : []),
+          ].join(' — ');
+
+          checks.push({ name: 'skills', status: skillStatus, detail });
         } catch (err) {
           checks.push({
             name: 'skills',

package/src/runtime/admin-setup-ops.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createAdminSetupOps } from './admin-setup-ops.js';
+import { createAdminSetupOps, syncHooksToClaudeSettings } from './admin-setup-ops.js';
 import type { AgentRuntime } from './types.js';
 import type { OpDefinition } from '../facades/types.js';
 
@@ -106,18 +106,6 @@ describe('createAdminSetupOps', () => {
     ops = createAdminSetupOps(runtime);
   });
 
-  it('returns 4 ops', () => {
-    expect(ops).toHaveLength(4);
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.handler).toBeDefined();
-      expect(['read', 'write', 'admin']).toContain(op.auth);
-    }
-  });
-
   describe('admin_inject_claude_md', () => {
     it('returns error when CLAUDE.md not found and createIfMissing is false', async () => {
       const result = (await findOp(ops, 'admin_inject_claude_md').handler({
@@ -295,6 +283,190 @@ describe('createAdminSetupOps', () => {
     });
   });
 
+  describe('syncHooksToClaudeSettings', () => {
+    it('installs SessionStart, PreCompact, and Stop hooks on fresh settings', () => {
+      const result = syncHooksToClaudeSettings('test-agent');
+      const written = mockFs['/mock-home/.claude/settings.json'];
+      expect(written).toBeDefined();
+      const settings = JSON.parse(written);
+      expect(settings.hooks.SessionStart).toHaveLength(2);
+      expect(settings.hooks.PreCompact).toHaveLength(1);
+      expect(settings.hooks.Stop).toHaveLength(1);
+      expect(result.installed).toContain('SessionStart');
+      expect(result.installed).toContain('PreCompact');
+      expect(result.installed).toContain('Stop');
+      expect(result.updated).toHaveLength(0);
+      expect(result.skipped).toHaveLength(0);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('includes the {agentId}-mode skill hook in SessionStart', () => {
+      syncHooksToClaudeSettings('test-agent');
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const commands = settings.hooks.SessionStart.flatMap((g: { hooks: { command?: string }[] }) =>
+        g.hooks.map((h) => h.command),
+      );
+      expect(commands.some((c: string) => c.includes('test-agent-mode skill'))).toBe(true);
+    });
+
+    it('includes the admin_health hook in SessionStart', () => {
+      syncHooksToClaudeSettings('test-agent');
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const commands = settings.hooks.SessionStart.flatMap((g: { hooks: { command?: string }[] }) =>
+        g.hooks.map((h) => h.command),
+      );
+      expect(commands.some((c: string) => c.includes('admin_health'))).toBe(true);
+    });
+
+    it('is idempotent — running twice produces the same output', () => {
+      syncHooksToClaudeSettings('test-agent');
+      const after1 = mockFs['/mock-home/.claude/settings.json'];
+      const result2 = syncHooksToClaudeSettings('test-agent');
+      const after2 = mockFs['/mock-home/.claude/settings.json'];
+      expect(after1).toBe(after2);
+      expect(result2.skipped).toContain('SessionStart');
+      expect(result2.installed).toHaveLength(0);
+      expect(result2.updated).toHaveLength(0);
+    });
+
+    it('preserves non-agent hooks already in settings', () => {
+      mockFs['/mock-home/.claude/settings.json'] = JSON.stringify({
+        hooks: {
+          SessionStart: [{ hooks: [{ type: 'command', command: 'echo existing' }] }],
+        },
+      });
+      syncHooksToClaudeSettings('test-agent');
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const commands = settings.hooks.SessionStart.flatMap((g: { hooks: { command?: string }[] }) =>
+        g.hooks.map((h) => h.command),
+      );
+      expect(commands).toContain('echo existing');
+      expect(commands.some((c: string) => c.includes('admin_health'))).toBe(true);
+    });
+
+    it('updates stale agent hooks to match current defaults', () => {
+      // A stale hook contains the agent marker but outdated content
+      mockFs['/mock-home/.claude/settings.json'] = JSON.stringify({
+        hooks: {
+          SessionStart: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: `root=$(git rev-parse --show-toplevel 2>/dev/null || echo "."); if grep -q '"test-agent"' "$root/.mcp.json" 2>/dev/null; then echo 'Call mcp__test-agent__test-agent_admin op:OLD_STALE_OP'; fi`,
+                  timeout: 5000,
+                },
+              ],
+            },
+          ],
+        },
+      });
+      const result = syncHooksToClaudeSettings('test-agent');
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const commands = settings.hooks.SessionStart.flatMap((g: { hooks: { command?: string }[] }) =>
+        g.hooks.map((h) => h.command),
+      );
+      expect(commands.some((c: string) => c.includes('OLD_STALE_OP'))).toBe(false);
+      expect(commands.some((c: string) => c.includes('admin_health'))).toBe(true);
+      expect(result.updated).toContain('SessionStart');
+      expect(result.error).toBeUndefined();
+    });
+
+    it('returns error field when write fails', async () => {
+      const { writeFileSync } = await import('node:fs');
+      vi.mocked(writeFileSync).mockImplementationOnce(() => {
+        throw new Error('EACCES: permission denied');
+      });
+      const result = syncHooksToClaudeSettings('test-agent');
+      expect(result.error).toMatch(/EACCES/);
+      expect(result.installed).toHaveLength(0);
+      expect(result.updated).toHaveLength(0);
+      expect(result.skipped).toHaveLength(0);
+    });
+  });
+
+  describe('multi-agent hook coexistence', () => {
+    type HookGroup = { hooks: { command?: string }[] };
+
+    function getSessionStartCommands(): string[] {
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      return (settings.hooks.SessionStart as HookGroup[]).flatMap((g) =>
+        g.hooks.map((h) => h.command ?? ''),
+      );
+    }
+
+    function getAgentCommands(agentId: string): string[] {
+      const settings = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      return (settings.hooks.SessionStart as HookGroup[])
+        .flatMap((g) => g.hooks)
+        .map((h) => h.command ?? '')
+        .filter((c) => c.includes(agentId));
+    }
+
+    it('install A then B — both sets present, no overlap', () => {
+      syncHooksToClaudeSettings('agent-a');
+      syncHooksToClaudeSettings('agent-b');
+
+      const commands = getSessionStartCommands();
+
+      // Both agents must have hooks present
+      expect(commands.some((c) => c.includes('agent-a'))).toBe(true);
+      expect(commands.some((c) => c.includes('agent-b'))).toBe(true);
+
+      // agent-a commands must not mention agent-b and vice versa
+      const aCommands = getAgentCommands('agent-a');
+      const bCommands = getAgentCommands('agent-b');
+
+      expect(aCommands.every((c) => !c.includes('agent-b'))).toBe(true);
+      expect(bCommands.every((c) => !c.includes('agent-a'))).toBe(true);
+    });
+
+    it('re-install A after B — B hooks untouched', () => {
+      syncHooksToClaudeSettings('agent-a');
+      syncHooksToClaudeSettings('agent-b');
+
+      const beforeB = getAgentCommands('agent-b');
+
+      syncHooksToClaudeSettings('agent-a'); // re-run A (e.g. after update)
+
+      const afterB = getAgentCommands('agent-b');
+
+      expect(afterB).toEqual(beforeB);
+    });
+
+    it('no duplicates after running both twice', () => {
+      syncHooksToClaudeSettings('agent-a');
+      syncHooksToClaudeSettings('agent-b');
+
+      const settings1 = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const groupCountAfterTwo = (settings1.hooks.SessionStart as HookGroup[]).length;
+
+      syncHooksToClaudeSettings('agent-a');
+      syncHooksToClaudeSettings('agent-b');
+
+      const settings2 = JSON.parse(mockFs['/mock-home/.claude/settings.json']);
+      const groupCountAfterFour = (settings2.hooks.SessionStart as HookGroup[]).length;
+
+      expect(groupCountAfterFour).toBe(groupCountAfterTwo);
+    });
+
+    it('manually added non-agent hook survives all agent installs', () => {
+      // Pre-populate settings with a non-agent hook in SessionStart
+      mockFs['/mock-home/.claude/settings.json'] = JSON.stringify({
+        hooks: {
+          SessionStart: [{ hooks: [{ type: 'command', command: 'echo custom-non-agent-hook' }] }],
+        },
+      });
+
+      syncHooksToClaudeSettings('agent-a');
+      syncHooksToClaudeSettings('agent-b');
+      syncHooksToClaudeSettings('agent-a');
+
+      const commands = getSessionStartCommands();
+      expect(commands).toContain('echo custom-non-agent-hook');
+    });
+  });
+
   describe('admin_check_persistence', () => {
     it('returns NO_STORAGE_DIRECTORY when nothing exists', async () => {
       const result = (await findOp(ops, 'admin_check_persistence').handler({})) as Record<

package/src/runtime/admin-setup-ops.ts

@@ -145,6 +145,37 @@ function discoverHookifyFiles(dir: string): Array<{ name: string; path: string }
 
 // discoverSkills imported from '../skills/sync-skills.js'
 
+// ─── Deep Equality Helper ─────────────────────────────────────────────
+
+/** Recursively compare two values by structure, independent of key insertion order. */
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== 'object') return false;
+
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  const objA = a as Record<string, unknown>;
+  const objB = b as Record<string, unknown>;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+    if (!deepEqual(objA[key], objB[key])) return false;
+  }
+  return true;
+}
+
 // ─── Settings.json Hook Merging ───────────────────────────────────────
 
 interface SettingsHook {
@@ -167,7 +198,7 @@ interface SettingsHookGroup {
 function buildConditionalHookCommand(agentId: string, instruction: string): string {
   // Escape single quotes in instruction for safe shell embedding
   const escaped = instruction.replace(/'/g, "'\\''");
-  return `root=$(git rev-parse --show-toplevel 2>/dev/null || echo "."); if grep -q '"${agentId}"' "$root/.mcp.json" 2>/dev/null; then echo '${escaped}'; fi`;
+  return `root=$(git rev-parse --show-toplevel 2>/dev/null || echo "."); if grep -qF '"${agentId}"' "$root/.mcp.json" 2>/dev/null; then echo '${escaped}'; fi`;
 }
 
 /** Default lifecycle hooks for any Soleri agent */
@@ -189,6 +220,16 @@ function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookG
           },
         ],
       },
+      {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: `echo 'SESSION_START: Invoke the ${agentId}-mode skill now to load full routing context and command reference.'`,
+            timeout: 5,
+          },
+        ],
+      },
     ],
     PreCompact: [
       {
@@ -226,8 +267,11 @@ function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookG
 /** Check if a hook group belongs to this agent by inspecting prompts for the marker */
 function isAgentHookGroup(group: SettingsHookGroup, agentId: string): boolean {
   const marker = `mcp__${agentId}__${agentId}_`;
+  const skillMarker = `${agentId}-mode skill`;
   return group.hooks.some(
-    (h) => (h.prompt && h.prompt.includes(marker)) || (h.command && h.command.includes(marker)),
+    (h) =>
+      (h.prompt && (h.prompt.includes(marker) || h.prompt.includes(skillMarker))) ||
+      (h.command && (h.command.includes(marker) || h.command.includes(skillMarker))),
   );
 }
 
@@ -254,29 +298,55 @@ function mergeSettingsHooks(
       continue;
     }
 
-    // Check if agent group already exists
-    const existingIdx = merged[event].findIndex((g) => isAgentHookGroup(g, agentId));
+    // Remove all existing agent-owned groups, keep non-agent hooks
+    const nonAgentGroups = merged[event].filter((g) => !isAgentHookGroup(g, agentId));
+    const existingAgentGroups = merged[event].filter((g) => isAgentHookGroup(g, agentId));
 
-    if (existingIdx === -1) {
-      // Append agent hooks (don't touch non-agent hooks)
-      merged[event].push(...groups);
+    if (deepEqual(existingAgentGroups, groups)) {
+      skipped.push(event);
+    } else if (existingAgentGroups.length === 0) {
+      merged[event] = [...nonAgentGroups, ...groups];
       installed.push(event);
     } else {
-      // Check if template matches
-      const existing = JSON.stringify(merged[event][existingIdx]);
-      const template = JSON.stringify(groups[0]);
-      if (existing === template) {
-        skipped.push(event);
-      } else {
-        merged[event][existingIdx] = groups[0];
-        updated.push(event);
-      }
+      // Replace all agent groups with current defaults
+      merged[event] = [...nonAgentGroups, ...groups];
+      updated.push(event);
     }
   }
 
   return { hooks: merged, installed, updated, skipped };
 }
 
+/**
+ * Auto-sync lifecycle hooks into ~/.claude/settings.json at engine startup.
+ * Idempotent — skips hooks already present, updates stale ones.
+ * Returns a summary of what was installed, updated, or skipped.
+ */
+export function syncHooksToClaudeSettings(agentId: string): {
+  installed: string[];
+  updated: string[];
+  skipped: string[];
+  error?: string;
+} {
+  try {
+    const settings = readSettingsJson();
+    const currentHooks = (settings.hooks ?? {}) as Record<string, SettingsHookGroup[]>;
+    const { hooks, installed, updated, skipped } = mergeSettingsHooks(currentHooks, agentId);
+    if (installed.length > 0 || updated.length > 0) {
+      writeSettingsJson({ ...settings, hooks });
+    }
+    return { installed, updated, skipped };
+  } catch (err) {
+    // Non-fatal — hooks will be installed on next run or via admin_setup_global
+    return {
+      installed: [],
+      updated: [],
+      skipped: [],
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
 // ─── Op Definitions ───────────────────────────────────────────────────
 
 /**

package/src/runtime/archive-ops.test.ts

@@ -83,34 +83,6 @@ describe('createArchiveOps', () => {
     ops = createArchiveOps(runtime);
   });
 
-  it('returns 12 ops', () => {
-    expect(ops).toHaveLength(12);
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.handler).toBeDefined();
-      expect(['read', 'write', 'admin']).toContain(op.auth);
-    }
-  });
-
-  it('contains expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('vault_archive');
-    expect(names).toContain('vault_restore');
-    expect(names).toContain('vault_optimize');
-    expect(names).toContain('vault_backup');
-    expect(names).toContain('vault_age_report');
-    expect(names).toContain('vault_set_temporal');
-    expect(names).toContain('vault_find_expiring');
-    expect(names).toContain('vault_find_expired');
-    expect(names).toContain('knowledge_audit');
-    expect(names).toContain('knowledge_health');
-    expect(names).toContain('knowledge_merge');
-    expect(names).toContain('knowledge_reorganize');
-  });
-
   describe('vault_archive', () => {
     it('archives old entries', async () => {
       await findOp(ops, 'vault_archive').handler({

package/src/runtime/branching-ops.test.ts

@@ -35,23 +35,6 @@ describe('branching-ops', () => {
     ops = captureOps(createBranchingOps(runtime));
   });
 
-  it('registers all 5 branching ops', () => {
-    expect(ops.size).toBe(5);
-    expect(ops.has('vault_branch')).toBe(true);
-    expect(ops.has('vault_branch_add')).toBe(true);
-    expect(ops.has('vault_branch_list')).toBe(true);
-    expect(ops.has('vault_merge_branch')).toBe(true);
-    expect(ops.has('vault_delete_branch')).toBe(true);
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('vault_branch')!.auth).toBe('write');
-    expect(ops.get('vault_branch_add')!.auth).toBe('write');
-    expect(ops.get('vault_branch_list')!.auth).toBe('read');
-    expect(ops.get('vault_merge_branch')!.auth).toBe('admin');
-    expect(ops.get('vault_delete_branch')!.auth).toBe('admin');
-  });
-
   describe('vault_branch', () => {
     it('creates a branch', async () => {
       const result = await executeOp(ops, 'vault_branch', { name: 'experiment' });

package/src/runtime/capture-ops.test.ts

@@ -83,18 +83,6 @@ describe('createCaptureOps', () => {
     ops = createCaptureOps(runtime);
   });
 
-  it('returns 4 ops', () => {
-    expect(ops).toHaveLength(4);
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeTruthy();
-      expect(op.handler).toBeDefined();
-      expect(['read', 'write']).toContain(op.auth);
-    }
-  });
-
   describe('capture_knowledge', () => {
     it('captures a single entry with governance approval', async () => {
       const result = (await findOp(ops, 'capture_knowledge').handler({
@@ -191,7 +179,7 @@ describe('createCaptureOps', () => {
         entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
       })) as Record<string, unknown>;
       expect(result.autoLinkedCount).toBe(1);
-      expect(result.suggestedLinks).toBeDefined();
+      expect((result.suggestedLinks as unknown[]).length).toBe(1); // one suggestion returned by mock
     });
 
     it('maps extended types correctly', async () => {
@@ -252,7 +240,8 @@ describe('createCaptureOps', () => {
         description: 'A quick capture',
       })) as Record<string, unknown>;
       expect(result.captured).toBe(true);
-      expect(result.id).toBeDefined();
+      expect(typeof result.id).toBe('string');
+      expect((result.id as string).startsWith('testing-')).toBe(true); // id is generated as <domain>-<timestamp>-<random>
       expect((result.governance as Record<string, unknown>).action).toBe('capture');
     });
 
@@ -380,6 +369,43 @@ describe('createCaptureOps', () => {
       // Capture should still succeed despite sync error
       expect(result.captured).toBe(true);
     });
+
+    it('adds planningNote when type is anti-pattern', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'anti-pattern',
+        domain: 'testing',
+        title: 'No content body',
+        description: 'captured without context/example/why',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(true);
+      expect(typeof result.planningNote).toBe('string');
+      expect(result.planningNote as string).toContain('capture_knowledge');
+    });
+
+    it('adds planningNote when tags include planning-gate', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'rule',
+        domain: 'testing',
+        title: 'Gated rule',
+        description: 'should warn',
+        tags: ['planning-gate'],
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(true);
+      expect(typeof result.planningNote).toBe('string');
+      expect(result.planningNote as string).toContain('capture_knowledge');
+    });
+
+    it('does not add planningNote for non-planning types without planning tags', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'reference',
+        domain: 'docs',
+        title: 'A plain reference',
+        description: 'no planning intent',
+        tags: ['docs'],
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(true);
+      expect(result.planningNote).toBeUndefined();
+    });
   });
 
   describe('search_intelligent', () => {
@@ -387,8 +413,7 @@ describe('createCaptureOps', () => {
       const result = (await findOp(ops, 'search_intelligent').handler({
         query: 'auth patterns',
       })) as Array<Record<string, unknown>>;
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBeGreaterThan(0);
+      expect(result).toHaveLength(1); // brain.intelligentSearch mock returns exactly 1 result
       expect(result[0].source).toBe('vault');
     });