@soleri/core 9.0.4 → 9.3.0

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

@@ -0,0 +1,255 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createAdminOps } from './admin-ops.js';
+import type { AgentRuntime } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Mock runtime
+// ---------------------------------------------------------------------------
+
+function mockRuntime(): AgentRuntime {
+  return {
+    config: {
+      agentId: 'test-agent',
+      vaultPath: '/tmp/vault.db',
+      plansPath: '/tmp/plans.json',
+      dataDir: null,
+      logLevel: 'info',
+    },
+    vault: {
+      stats: vi.fn().mockReturnValue({
+        totalEntries: 42,
+        byDomain: { general: 30, testing: 12 },
+        byType: { pattern: 25, 'anti-pattern': 17 },
+      }),
+    },
+    brain: {
+      getStats: vi.fn().mockReturnValue({ vocabularySize: 500, feedbackCount: 20 }),
+      rebuildVocabulary: vi.fn(),
+    },
+    brainIntelligence: {
+      getStats: vi.fn().mockReturnValue({ strengths: 10, sessions: 5 }),
+    },
+    llmClient: {
+      isAvailable: vi.fn().mockReturnValue({ openai: true, anthropic: false }),
+    },
+    curator: {
+      getStatus: vi.fn().mockReturnValue({ initialized: true }),
+    },
+    contextHealth: {
+      check: vi.fn().mockReturnValue({
+        level: 'green',
+        estimatedFill: 0.15,
+        toolCallCount: 10,
+        estimatedTokens: 5000,
+        recommendation: 'Context usage is healthy.',
+      }),
+    },
+    createdAt: Date.now() - 60_000, // 1 minute ago
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: ReturnType<typeof createAdminOps>, name: string) {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op "${name}" not found`);
+  return op;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('createAdminOps', () => {
+  let rt: AgentRuntime;
+  let ops: ReturnType<typeof createAdminOps>;
+
+  beforeEach(() => {
+    rt = mockRuntime();
+    ops = createAdminOps(rt);
+  });
+
+  it('returns 9 ops', () => {
+    expect(ops.length).toBe(9);
+  });
+
+  // ─── admin_health ─────────────────────────────────────────────
+
+  describe('admin_health', () => {
+    it('returns ok status with subsystem info', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.status).toBe('ok');
+      expect(result).toHaveProperty('vault');
+      expect(result).toHaveProperty('llm');
+      expect(result).toHaveProperty('brain');
+      expect(result).toHaveProperty('curator');
+    });
+
+    it('reports vault entries count', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const vault = result.vault as Record<string, unknown>;
+      expect(vault.entries).toBe(42);
+    });
+
+    it('reports LLM availability', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const llm = result.llm as Record<string, boolean>;
+      expect(llm.openai).toBe(true);
+      expect(llm.anthropic).toBe(false);
+    });
+  });
+
+  // ─── context_health ───────────────────────────────────────────
+
+  describe('context_health', () => {
+    it('returns context health status', async () => {
+      const op = findOp(ops, 'context_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.level).toBe('green');
+      expect(result.toolCallCount).toBe(10);
+    });
+  });
+
+  // ─── admin_tool_list ──────────────────────────────────────────
+
+  describe('admin_tool_list', () => {
+    it('returns fallback when no _allOps provided', async () => {
+      const op = findOp(ops, 'admin_tool_list');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.count).toBe(8);
+    });
+
+    it('returns grouped ops when _allOps provided', async () => {
+      const op = findOp(ops, 'admin_tool_list');
+      const allOps = [
+        { name: 'admin_health', description: 'Health check', auth: 'read' },
+        { name: 'vault_search', description: 'Search vault', auth: 'read' },
+      ];
+      const result = (await op.handler({ _allOps: allOps })) as Record<string, unknown>;
+      expect(result.count).toBe(2);
+      const grouped = result.ops as Record<string, string[]>;
+      expect(grouped.admin).toContain('admin_health');
+      expect(grouped.vault).toContain('vault_search');
+    });
+
+    it('returns verbose format when verbose=true', async () => {
+      const op = findOp(ops, 'admin_tool_list');
+      const allOps = [{ name: 'admin_health', description: 'Health check', auth: 'read' }];
+      const result = (await op.handler({
+        _allOps: allOps,
+        verbose: true,
+      })) as Record<string, unknown>;
+      const opsList = result.ops as Array<Record<string, string>>;
+      expect(opsList[0].name).toBe('admin_health');
+      expect(opsList[0].description).toBe('Health check');
+    });
+  });
+
+  // ─── admin_config ─────────────────────────────────────────────
+
+  describe('admin_config', () => {
+    it('returns runtime configuration', async () => {
+      const op = findOp(ops, 'admin_config');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.agentId).toBe('test-agent');
+      expect(result.vaultPath).toBe('/tmp/vault.db');
+      expect(result.logLevel).toBe('info');
+    });
+  });
+
+  // ─── admin_vault_size ─────────────────────────────────────────
+
+  describe('admin_vault_size', () => {
+    it('returns in-memory for :memory: vaults', async () => {
+      const rtMem = mockRuntime();
+      (rtMem.config as Record<string, unknown>).vaultPath = ':memory:';
+      const memOps = createAdminOps(rtMem);
+      const memOp = findOp(memOps, 'admin_vault_size');
+      const result = (await memOp.handler({})) as Record<string, unknown>;
+      expect(result.sizeHuman).toBe('in-memory');
+    });
+  });
+
+  // ─── admin_uptime ─────────────────────────────────────────────
+
+  describe('admin_uptime', () => {
+    it('returns uptime in seconds and human-readable', async () => {
+      const op = findOp(ops, 'admin_uptime');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.uptimeSec).toBeGreaterThanOrEqual(0);
+      expect(result.uptimeHuman).toBeDefined();
+      expect(result.createdAt).toBeDefined();
+    });
+  });
+
+  // ─── admin_version ────────────────────────────────────────────
+
+  describe('admin_version', () => {
+    it('returns version info', async () => {
+      const op = findOp(ops, 'admin_version');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.node).toMatch(/^v\d+/);
+      expect(result.platform).toBeDefined();
+      expect(result.arch).toBeDefined();
+    });
+  });
+
+  // ─── admin_reset_cache ────────────────────────────────────────
+
+  describe('admin_reset_cache', () => {
+    it('rebuilds brain vocabulary', async () => {
+      const op = findOp(ops, 'admin_reset_cache');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(rt.brain.rebuildVocabulary).toHaveBeenCalled();
+      expect(result.cleared).toContain('brain_vocabulary');
+    });
+  });
+
+  // ─── admin_diagnostic ─────────────────────────────────────────
+
+  describe('admin_diagnostic', () => {
+    it('runs all diagnostic checks and returns summary', async () => {
+      // Mock LLM as available for this test to get healthy status
+      vi.mocked(rt.llmClient.isAvailable).mockReturnValue({ openai: true, anthropic: true });
+      const op = findOp(ops, 'admin_diagnostic');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.overall).toBe('healthy');
+      expect(result).toHaveProperty('checks');
+      expect(result).toHaveProperty('summary');
+      const checks = result.checks as Array<Record<string, string>>;
+      expect(checks.length).toBeGreaterThanOrEqual(5);
+    });
+
+    it('reports degraded when LLM unavailable', async () => {
+      vi.mocked(rt.llmClient.isAvailable).mockReturnValue({ openai: false, anthropic: false });
+      const op = findOp(ops, 'admin_diagnostic');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      // At least one warn expected for missing LLM keys
+      expect(result.overall).toBe('degraded');
+    });
+
+    it('reports vault error when vault.stats throws', async () => {
+      vi.mocked(rt.vault.stats).mockImplementation(() => {
+        throw new Error('DB locked');
+      });
+      const op = findOp(ops, 'admin_diagnostic');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const checks = result.checks as Array<Record<string, string>>;
+      const vaultCheck = checks.find((c) => c.name === 'vault');
+      expect(vaultCheck?.status).toBe('error');
+    });
+
+    it('reports brain vocabulary warn when empty', async () => {
+      vi.mocked(rt.brain.getStats).mockReturnValue({
+        vocabularySize: 0,
+        feedbackCount: 0,
+      } as never);
+      const op = findOp(ops, 'admin_diagnostic');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const checks = result.checks as Array<Record<string, string>>;
+      const brainCheck = checks.find((c) => c.name === 'brain_vocabulary');
+      expect(brainCheck?.status).toBe('warn');
+    });
+  });
+});

package/src/runtime/admin-ops.ts

@@ -36,9 +36,9 @@ function getCoreVersion(): string {
 }
 
 /**
- * Create the 8 admin/infrastructure operations for an agent runtime.
+ * Create admin/infrastructure operations for an agent runtime.
  *
- * Groups: health (1), introspection (4), diagnostics (2), mutation (1).
+ * Groups: health (1–2), introspection (4), diagnostics (2), mutation (1).
  */
 export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
   const { vault, brain, brainIntelligence, llmClient, curator } = runtime;
@@ -68,40 +68,68 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Context Health ────────────────────────────────────────────
+    {
+      name: 'context_health',
+      description:
+        'Check context window health — estimated fill, tool call count, and recommendation.',
+      auth: 'read',
+      handler: async () => {
+        return runtime.contextHealth.check();
+      },
+    },
+
     // ─── Introspection ───────────────────────────────────────────────
     {
       name: 'admin_tool_list',
       description: 'List all available ops with descriptions and auth levels.',
       auth: 'read',
       handler: async (params) => {
+        const verbose = params.verbose === true;
         // The caller can pass in the full ops list via `_allOps` (injected by
         // the facade builder). If not provided, we return only admin ops.
         const allOps = params._allOps as
           | Array<{ name: string; description: string; auth: string }>
           | undefined;
         if (allOps) {
+          if (verbose) {
+            return {
+              count: allOps.length,
+              ops: allOps.map((op) => ({
+                name: op.name,
+                description: op.description,
+                auth: op.auth,
+              })),
+            };
+          }
+          // Group by facade prefix, truncate descriptions to 120 chars
+          const grouped: Record<string, string[]> = {};
+          for (const op of allOps) {
+            const parts = op.name.split('_');
+            const facade = parts.length > 1 ? parts[0] : 'core';
+            if (!grouped[facade]) grouped[facade] = [];
+            grouped[facade].push(op.name);
+          }
           return {
             count: allOps.length,
-            ops: allOps.map((op) => ({
-              name: op.name,
-              description: op.description,
-              auth: op.auth,
-            })),
+            ops: grouped,
           };
         }
         // Fallback — just describe admin ops
         return {
           count: 8,
-          ops: [
-            { name: 'admin_health', auth: 'read' },
-            { name: 'admin_tool_list', auth: 'read' },
-            { name: 'admin_config', auth: 'read' },
-            { name: 'admin_vault_size', auth: 'read' },
-            { name: 'admin_uptime', auth: 'read' },
-            { name: 'admin_version', auth: 'read' },
-            { name: 'admin_reset_cache', auth: 'write' },
-            { name: 'admin_diagnostic', auth: 'read' },
-          ],
+          ops: {
+            admin: [
+              'admin_health',
+              'admin_tool_list',
+              'admin_config',
+              'admin_vault_size',
+              'admin_uptime',
+              'admin_version',
+              'admin_reset_cache',
+              'admin_diagnostic',
+            ],
+          },
         };
       },
     },

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

@@ -0,0 +1,327 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createAdminSetupOps } from './admin-setup-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+// ─── Mock Node.js fs/os modules ────────────────────────────────────────
+
+const mockFs: Record<string, string> = {};
+const mockDirs = new Set<string>();
+
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn((p: string) => p in mockFs || mockDirs.has(p)),
+  readFileSync: vi.fn((p: string) => {
+    if (p in mockFs) return mockFs[p];
+    throw new Error(`ENOENT: ${p}`);
+  }),
+  writeFileSync: vi.fn((p: string, content: string) => {
+    mockFs[p] = content;
+  }),
+  mkdirSync: vi.fn((_p: string) => undefined),
+  copyFileSync: vi.fn(),
+  readdirSync: vi.fn(() => []),
+  unlinkSync: vi.fn(),
+  statSync: vi.fn(() => ({ size: 1024 })),
+}));
+
+vi.mock('node:os', () => ({
+  homedir: vi.fn(() => '/mock-home'),
+}));
+
+vi.mock('node:path', async () => {
+  const actual = await vi.importActual<typeof import('node:path')>('node:path');
+  return actual;
+});
+
+vi.mock('./claude-md-helpers.js', () => ({
+  hasSections: vi.fn(() => false),
+  removeSections: vi.fn((content: string) => content),
+  injectAtPosition: vi.fn((_existing: string, injection: string) => `INJECTED:${injection}`),
+  buildInjectionContent: vi.fn(() => '## Mock Agent Section'),
+  injectEngineRulesBlock: vi.fn((content: string) => content),
+}));
+
+vi.mock('../skills/sync-skills.js', () => ({
+  discoverSkills: vi.fn(() => [{ name: 'skill-1', path: '/mock/skills/skill-1' }]),
+  syncSkillsToClaudeCode: vi.fn(() => ({
+    installed: ['skill-1'],
+    updated: [],
+    skipped: [],
+    failed: [],
+  })),
+}));
+
+// ─── Mock Runtime Factory ──────────────────────────────────────────────
+
+function createMockRuntime(): AgentRuntime {
+  return {
+    config: {
+      agentId: 'test-agent',
+      vaultPath: '/mock-home/.test-agent/vault.db',
+      plansPath: '/mock-home/.test-agent/plans.json',
+      dataDir: '/mock/agent-data',
+      agentDir: '/mock/agent-dir',
+    },
+    persona: { name: 'TestBot' },
+    vault: {
+      getProvider: vi.fn(() => ({
+        backend: 'sqlite',
+        get: vi.fn(() => ({ count: 5 })),
+      })),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op not found: ${name}`);
+  return op;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────
+
+describe('createAdminSetupOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    // Reset mock filesystem
+    for (const key of Object.keys(mockFs)) delete mockFs[key];
+    mockDirs.clear();
+    vi.clearAllMocks();
+
+    runtime = createMockRuntime();
+    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({
+        projectPath: '/some/project',
+        createIfMissing: false,
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('error');
+      expect(result.error).toBe('CLAUDE.md not found');
+    });
+
+    it('creates new CLAUDE.md when createIfMissing is true', async () => {
+      const result = (await findOp(ops, 'admin_inject_claude_md').handler({
+        projectPath: '/some/project',
+        createIfMissing: true,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('created');
+      expect(result.agentId).toBe('test-agent');
+    });
+
+    it('dry run previews without writing', async () => {
+      const result = (await findOp(ops, 'admin_inject_claude_md').handler({
+        projectPath: '/some/project',
+        createIfMissing: true,
+        dryRun: true,
+        global: false,
+        includeIntegration: true,
+        position: 'after-title',
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('would_inject');
+      expect(result.preview).toBeDefined();
+    });
+
+    it('injects into existing CLAUDE.md', async () => {
+      mockFs['/some/project/CLAUDE.md'] = '# My Project\n\nExisting content.';
+      const result = (await findOp(ops, 'admin_inject_claude_md').handler({
+        projectPath: '/some/project',
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+        createIfMissing: false,
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('injected');
+    });
+
+    it('updates existing agent sections', async () => {
+      mockFs['/some/project/CLAUDE.md'] =
+        '# Project\n<!-- agent:test-agent -->\nOld\n<!-- /agent:test-agent -->';
+      const { hasSections } = await import('./claude-md-helpers.js');
+      vi.mocked(hasSections).mockReturnValueOnce(true);
+      const result = (await findOp(ops, 'admin_inject_claude_md').handler({
+        projectPath: '/some/project',
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        global: false,
+        createIfMissing: false,
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('updated');
+    });
+
+    it('injects into global CLAUDE.md', async () => {
+      mockFs['/mock-home/.claude/CLAUDE.md'] = '# Global\n';
+      // Ensure hasSections returns false for this test (fresh injection)
+      const { hasSections } = await import('./claude-md-helpers.js');
+      vi.mocked(hasSections).mockReturnValueOnce(false);
+      const result = (await findOp(ops, 'admin_inject_claude_md').handler({
+        projectPath: '.',
+        global: true,
+        includeIntegration: true,
+        position: 'after-title',
+        dryRun: false,
+        createIfMissing: false,
+      })) as Record<string, unknown>;
+      expect(result.action).toBe('injected');
+    });
+  });
+
+  describe('admin_setup_global', () => {
+    it('dry run returns preview of what would be installed', async () => {
+      const result = (await findOp(ops, 'admin_setup_global').handler({
+        install: false,
+        hooksOnly: false,
+        settingsJsonOnly: false,
+        skillsOnly: false,
+      })) as Record<string, unknown>;
+      expect(result.dryRun).toBe(true);
+      expect(result.agentId).toBe('test-agent');
+      expect(result.message).toContain('Dry run');
+    });
+
+    it('installs skills when install is true', async () => {
+      const result = (await findOp(ops, 'admin_setup_global').handler({
+        install: true,
+        hooksOnly: false,
+        settingsJsonOnly: false,
+        skillsOnly: true,
+      })) as Record<string, unknown>;
+      expect(result.dryRun).toBe(false);
+      const { syncSkillsToClaudeCode } = await import('../skills/sync-skills.js');
+      expect(syncSkillsToClaudeCode).toHaveBeenCalled();
+    });
+
+    it('installs settings.json hooks when install is true', async () => {
+      // Pre-populate settings.json
+      mockFs['/mock-home/.claude/settings.json'] = JSON.stringify({});
+      const result = (await findOp(ops, 'admin_setup_global').handler({
+        install: true,
+        hooksOnly: false,
+        settingsJsonOnly: true,
+        skillsOnly: false,
+      })) as Record<string, unknown>;
+      expect(result.dryRun).toBe(false);
+      expect((result.settingsJson as Record<string, string[]>).installed.length).toBeGreaterThan(0);
+    });
+
+    it('skips skills when hooksOnly is true', async () => {
+      const result = (await findOp(ops, 'admin_setup_global').handler({
+        install: false,
+        hooksOnly: true,
+        settingsJsonOnly: false,
+        skillsOnly: false,
+      })) as Record<string, unknown>;
+      expect((result.skills as Record<string, string[]>).installed).toHaveLength(0);
+    });
+  });
+
+  describe('admin_setup_project', () => {
+    it('analyze mode returns hook analysis', async () => {
+      mockDirs.add('/some/project');
+      const result = (await findOp(ops, 'admin_setup_project').handler({
+        projectPath: '/some/project',
+        cleanup: false,
+        install: false,
+      })) as Record<string, unknown>;
+      expect(result.mode).toBe('analyze');
+      expect(result).toHaveProperty('globalHooks');
+      expect(result).toHaveProperty('projectHooks');
+    });
+
+    it('returns error for non-existent project', async () => {
+      const result = (await findOp(ops, 'admin_setup_project').handler({
+        projectPath: '/nonexistent',
+        cleanup: false,
+        install: false,
+      })) as Record<string, unknown>;
+      expect(result.error).toBe('PROJECT_NOT_FOUND');
+    });
+
+    it('cleanup mode removes duplicates', async () => {
+      mockDirs.add('/some/project');
+      const result = (await findOp(ops, 'admin_setup_project').handler({
+        projectPath: '/some/project',
+        cleanup: true,
+        install: false,
+      })) as Record<string, unknown>;
+      expect(result.mode).toBe('cleanup');
+      expect(result).toHaveProperty('removed');
+    });
+
+    it('install mode copies hooks to project', async () => {
+      mockDirs.add('/some/project');
+      const result = (await findOp(ops, 'admin_setup_project').handler({
+        projectPath: '/some/project',
+        cleanup: false,
+        install: true,
+      })) as Record<string, unknown>;
+      expect(result.mode).toBe('install');
+      expect(result).toHaveProperty('installed');
+      expect(result).toHaveProperty('skipped');
+    });
+  });
+
+  describe('admin_check_persistence', () => {
+    it('returns NO_STORAGE_DIRECTORY when nothing exists', async () => {
+      const result = (await findOp(ops, 'admin_check_persistence').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.agentId).toBe('test-agent');
+      expect(result.status).toBe('NO_STORAGE_DIRECTORY');
+      expect(result.recommendation).toContain('Storage directory not found');
+    });
+
+    it('returns PERSISTENCE_ACTIVE when vault and plans exist', async () => {
+      mockDirs.add('/mock-home/.test-agent');
+      mockFs['/mock-home/.test-agent/vault.db'] = 'binary';
+      mockFs['/mock-home/.test-agent/plans.json'] = JSON.stringify({ items: {} });
+      const result = (await findOp(ops, 'admin_check_persistence').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.status).toBe('PERSISTENCE_ACTIVE');
+    });
+
+    it('detects active plans needing reconciliation', async () => {
+      mockDirs.add('/mock-home/.test-agent');
+      mockFs['/mock-home/.test-agent/vault.db'] = 'binary';
+      mockFs['/mock-home/.test-agent/plans.json'] = JSON.stringify({
+        items: {
+          'plan-1': { status: 'executing' },
+          'plan-2': { status: 'completed' },
+        },
+      });
+      const result = (await findOp(ops, 'admin_check_persistence').handler({})) as Record<
+        string,
+        unknown
+      >;
+      const activePlans = result.activePlans as Array<{ id: string; status: string }>;
+      expect(activePlans).toHaveLength(1);
+      expect(activePlans[0].status).toBe('executing');
+      expect(result.recommendation).toContain('need attention');
+    });
+  });
+});