@soleri/core 9.2.0 → 9.3.0

package/src/planning/task-verifier.test.ts

@@ -11,8 +11,12 @@ import {
 import type { PlanTask, TaskEvidence, TaskDeliverable, ReviewEvidence } from './planner-types.js';
 
 const makeTask = (overrides: Partial<PlanTask> = {}): PlanTask => ({
-  id: 'task-1', title: 'Test task', description: 'Do something',
-  status: 'pending', updatedAt: 0, ...overrides,
+  id: 'task-1',
+  title: 'Test task',
+  description: 'Do something',
+  status: 'pending',
+  updatedAt: 0,
+  ...overrides,
 });
 
 describe('task-verifier', () => {
@@ -21,7 +25,11 @@ describe('task-verifier', () => {
       const existing: TaskEvidence[] = [
         { criterion: 'cr1', content: 'result', type: 'description', submittedAt: 100 },
       ];
-      const result = createEvidence(existing, { criterion: 'cr2', content: 'output', type: 'command_output' });
+      const result = createEvidence(existing, {
+        criterion: 'cr2',
+        content: 'output',
+        type: 'command_output',
+      });
       expect(result).toHaveLength(2);
       expect(result[1].criterion).toBe('cr2');
       expect(result[1].submittedAt).toBeGreaterThan(0);
@@ -66,22 +74,50 @@ describe('task-verifier', () => {
     it('returns verified=true when task has approved review', () => {
       const task = makeTask({ status: 'completed' });
       const reviews: ReviewEvidence[] = [
-        { planId: 'p1', taskId: 'task-1', reviewer: 'r', outcome: 'approved', comments: '', reviewedAt: 0 },
+        {
+          planId: 'p1',
+          taskId: 'task-1',
+          reviewer: 'r',
+          outcome: 'approved',
+          comments: '',
+          reviewedAt: 0,
+        },
       ];
       expect(verifyTaskLogic(task, reviews).verified).toBe(true);
     });
     it('returns verified=false when task has rejected review', () => {
       const task = makeTask({ status: 'completed' });
       const reviews: ReviewEvidence[] = [
-        { planId: 'p1', taskId: 'task-1', reviewer: 'r', outcome: 'rejected', comments: '', reviewedAt: 0 },
+        {
+          planId: 'p1',
+          taskId: 'task-1',
+          reviewer: 'r',
+          outcome: 'rejected',
+          comments: '',
+          reviewedAt: 0,
+        },
       ];
       expect(verifyTaskLogic(task, reviews).verified).toBe(false);
     });
     it('uses latest review outcome', () => {
       const task = makeTask({ status: 'completed' });
       const reviews: ReviewEvidence[] = [
-        { planId: 'p1', taskId: 'task-1', reviewer: 'r', outcome: 'rejected', comments: '', reviewedAt: 0 },
-        { planId: 'p1', taskId: 'task-1', reviewer: 'r', outcome: 'approved', comments: '', reviewedAt: 1 },
+        {
+          planId: 'p1',
+          taskId: 'task-1',
+          reviewer: 'r',
+          outcome: 'rejected',
+          comments: '',
+          reviewedAt: 0,
+        },
+        {
+          planId: 'p1',
+          taskId: 'task-1',
+          reviewer: 'r',
+          outcome: 'approved',
+          comments: '',
+          reviewedAt: 1,
+        },
       ];
       expect(verifyTaskLogic(task, reviews).verified).toBe(true);
     });
@@ -110,9 +146,13 @@ describe('task-verifier', () => {
       expect(result.issues[0].issue).toContain('pending');
     });
     it('flags missing evidence for completed tasks with acceptance criteria', () => {
-      const tasks: PlanTask[] = [makeTask({
-        status: 'completed', acceptanceCriteria: ['cr1'], evidence: [],
-      })];
+      const tasks: PlanTask[] = [
+        makeTask({
+          status: 'completed',
+          acceptanceCriteria: ['cr1'],
+          evidence: [],
+        }),
+      ];
       const result = verifyPlanLogic('plan-1', tasks);
       expect(result.issues[0].issue).toContain('Missing evidence');
     });
@@ -138,35 +178,27 @@ describe('task-verifier', () => {
       expect(result.staleCount).toBe(0);
     });
     it('marks file deliverables as stale when file does not exist', () => {
-      const deliverables: TaskDeliverable[] = [
-        { type: 'file', path: '/nonexistent/path/file.ts' },
-      ];
+      const deliverables: TaskDeliverable[] = [{ type: 'file', path: '/nonexistent/path/file.ts' }];
       const result = verifyDeliverablesLogic(deliverables);
       expect(result.verified).toBe(false);
       expect(result.staleCount).toBe(1);
       expect(result.deliverables[0].stale).toBe(true);
     });
     it('marks vault_entry deliverables as stale when vault returns null', () => {
-      const deliverables: TaskDeliverable[] = [
-        { type: 'vault_entry', path: 'entry-123' },
-      ];
+      const deliverables: TaskDeliverable[] = [{ type: 'vault_entry', path: 'entry-123' }];
       const vault = { get: () => null };
       const result = verifyDeliverablesLogic(deliverables, vault);
       expect(result.staleCount).toBe(1);
     });
     it('marks vault_entry deliverables as valid when vault returns non-null', () => {
-      const deliverables: TaskDeliverable[] = [
-        { type: 'vault_entry', path: 'entry-123' },
-      ];
+      const deliverables: TaskDeliverable[] = [{ type: 'vault_entry', path: 'entry-123' }];
       const vault = { get: () => ({ id: 'entry-123' }) };
       const result = verifyDeliverablesLogic(deliverables, vault);
       expect(result.verified).toBe(true);
       expect(result.staleCount).toBe(0);
     });
     it('skips url deliverables (no verification)', () => {
-      const deliverables: TaskDeliverable[] = [
-        { type: 'url', path: 'https://example.com' },
-      ];
+      const deliverables: TaskDeliverable[] = [{ type: 'url', path: 'https://example.com' }];
       const result = verifyDeliverablesLogic(deliverables);
       expect(result.verified).toBe(true);
     });
@@ -214,17 +246,17 @@ describe('task-verifier', () => {
       expect(prompt).toContain('2. No regressions');
     });
     it('omits criteria section when empty', () => {
-      const prompt = buildSpecReviewPrompt(
-        { title: 'T', description: 'd' },
-        'Objective',
-      );
+      const prompt = buildSpecReviewPrompt({ title: 'T', description: 'd' }, 'Objective');
       expect(prompt).not.toContain('Acceptance Criteria');
     });
   });
 
   describe('buildQualityReviewPrompt', () => {
     it('includes task info and quality checklist', () => {
-      const prompt = buildQualityReviewPrompt({ title: 'Refactor X', description: 'Clean up code' });
+      const prompt = buildQualityReviewPrompt({
+        title: 'Refactor X',
+        description: 'Clean up code',
+      });
       expect(prompt).toContain('Refactor X');
       expect(prompt).toContain('Clean up code');
       expect(prompt).toContain('Code Quality Review');

package/src/planning/task-verifier.ts

@@ -268,14 +268,18 @@ export function buildSpecReviewPrompt(
     ? `\n\nAcceptance Criteria:\n${task.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}`
     : '';
   return [
-    `# Spec Compliance Review`, ``, `## Task: ${task.title}`,
+    `# Spec Compliance Review`,
+    ``,
+    `## Task: ${task.title}`,
     `**Description:** ${task.description}`,
-    `**Plan Objective:** ${planObjective}${criteria}`, ``,
+    `**Plan Objective:** ${planObjective}${criteria}`,
+    ``,
     `## Review Checklist`,
     `1. Does the implementation match the task description?`,
     `2. Are all acceptance criteria satisfied?`,
     `3. Does it align with the plan's overall objective?`,
-    `4. Are there any spec deviations?`, ``,
+    `4. Are there any spec deviations?`,
+    ``,
     `Provide: outcome (approved/rejected/needs_changes) and detailed comments.`,
   ].join('\n');
 }
@@ -284,12 +288,13 @@ export function buildSpecReviewPrompt(
  * Generate a code quality review prompt for a task.
  * Pure function — no persistence side-effects.
  */
-export function buildQualityReviewPrompt(
-  task: Pick<PlanTask, 'title' | 'description'>,
-): string {
+export function buildQualityReviewPrompt(task: Pick<PlanTask, 'title' | 'description'>): string {
   return [
-    `# Code Quality Review`, ``, `## Task: ${task.title}`,
-    `**Description:** ${task.description}`, ``,
+    `# Code Quality Review`,
+    ``,
+    `## Task: ${task.title}`,
+    `**Description:** ${task.description}`,
+    ``,
     `## Quality Checklist`,
     `1. **Correctness** — Does it work as intended?`,
     `2. **Security** — No injection, XSS, or OWASP top 10 vulnerabilities?`,
@@ -297,7 +302,8 @@ export function buildQualityReviewPrompt(
     `4. **Maintainability** — Clear naming, appropriate abstractions, documented intent?`,
     `5. **Testing** — Adequate test coverage for the changes?`,
     `6. **Error Handling** — Graceful degradation, no swallowed errors?`,
-    `7. **Conventions** — Follows project coding standards?`, ``,
+    `7. **Conventions** — Follows project coding standards?`,
+    ``,
     `Provide: outcome (approved/rejected/needs_changes) and detailed comments.`,
   ].join('\n');
 }

package/src/playbooks/playbook-executor.test.ts

@@ -19,9 +19,7 @@ function makePlaybook(overrides: Partial<PlaybookDefinition> = {}): PlaybookDefi
     tags: [],
     matchIntents: ['BUILD'],
     matchKeywords: [],
-    gates: [
-      { phase: 'completion', requirement: 'Tests pass', checkType: 'test-pass' },
-    ],
+    gates: [{ phase: 'completion', requirement: 'Tests pass', checkType: 'test-pass' }],
     taskTemplates: [],
     toolInjections: ['search_intelligent'],
     verificationCriteria: ['All tests pass'],

package/src/plugins/plugin-loader.test.ts

@@ -13,7 +13,10 @@ import type { LoadedPlugin, PluginManifest } from './types.js';
 let testDirs: string[] = [];
 
 function makeTempDir(): string {
-  const dir = join(tmpdir(), `soleri-loader-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const dir = join(
+    tmpdir(),
+    `soleri-loader-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
   mkdirSync(dir, { recursive: true });
   testDirs.push(dir);
   return dir;
@@ -26,13 +29,15 @@ function writePlugin(parentDir: string, id: string, manifest: Record<string, unk
   return dir;
 }
 
-function makeLoaded(overrides: Partial<LoadedPlugin & { manifest: Partial<PluginManifest> }> = {}): LoadedPlugin {
+function makeLoaded(
+  overrides: Partial<LoadedPlugin & { manifest: Partial<PluginManifest> }> = {},
+): LoadedPlugin {
   return {
     manifest: pluginManifestSchema.parse({
       id: 'test-plugin',
       name: 'Test',
       version: '1.0.0',
-      ...(overrides.manifest),
+      ...overrides.manifest,
     }),
     directory: overrides.directory ?? '/tmp/test',
     provenance: overrides.provenance ?? 'global',
@@ -41,7 +46,11 @@ function makeLoaded(overrides: Partial<LoadedPlugin & { manifest: Partial<Plugin
 
 afterEach(() => {
   for (const dir of testDirs) {
-    try { rmSync(dir, { recursive: true, force: true }); } catch { /* noop */ }
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* noop */
+    }
   }
   testDirs = [];
 });
@@ -62,11 +71,11 @@ describe('loadPlugins — colocated', () => {
     const result = loadPlugins('test-agent', undefined, [dir1, dir2]);
 
     expect(result.loaded).toHaveLength(2);
-    const ids = result.loaded.map(p => p.manifest.id);
+    const ids = result.loaded.map((p) => p.manifest.id);
     expect(ids).toContain('alpha');
     expect(ids).toContain('beta');
     // First occurrence wins
-    expect(result.loaded.find(p => p.manifest.id === 'alpha')!.manifest.name).toBe('Alpha');
+    expect(result.loaded.find((p) => p.manifest.id === 'alpha')!.manifest.name).toBe('Alpha');
   });
 
   it('skips files (non-directories) inside plugin dir', () => {
@@ -154,18 +163,14 @@ describe('validateDependencies — colocated', () => {
   });
 
   it('detects multiple missing dependencies', () => {
-    const plugins = [
-      makeLoaded({ manifest: { id: 'lonely', dependencies: ['dep-a', 'dep-b'] } }),
-    ];
+    const plugins = [makeLoaded({ manifest: { id: 'lonely', dependencies: ['dep-a', 'dep-b'] } })];
     const errors = validateDependencies(plugins);
     expect(errors).toHaveLength(2);
-    expect(errors.map(e => e.missingDep)).toEqual(['dep-a', 'dep-b']);
+    expect(errors.map((e) => e.missingDep)).toEqual(['dep-a', 'dep-b']);
   });
 
   it('handles plugins with no dependencies', () => {
-    const plugins = [
-      makeLoaded({ manifest: { id: 'standalone' } }),
-    ];
+    const plugins = [makeLoaded({ manifest: { id: 'standalone' } })];
     expect(validateDependencies(plugins)).toEqual([]);
   });
 });
@@ -181,7 +186,7 @@ describe('sortByDependencies — colocated', () => {
     const a = makeLoaded({ manifest: { id: 'a' } });
 
     const sorted = sortByDependencies([c, b, a]);
-    const ids = sorted.map(p => p.manifest.id);
+    const ids = sorted.map((p) => p.manifest.id);
 
     expect(ids.indexOf('a')).toBeLessThan(ids.indexOf('b'));
     expect(ids.indexOf('b')).toBeLessThan(ids.indexOf('c'));

package/src/plugins/plugin-registry.test.ts

@@ -73,14 +73,16 @@ describe('PluginRegistry — colocated', () => {
     it('builds static facades from manifest when no index.js exists', async () => {
       const loaded = makeLoaded({
         manifest: makeManifest({
-          facades: [{
-            name: 'my_facade',
-            description: 'Test facade',
-            ops: [
-              { name: 'do_thing', description: 'Does a thing', auth: 'read' },
-              { name: 'admin_thing', description: 'Admin action', auth: 'admin' },
-            ],
-          }],
+          facades: [
+            {
+              name: 'my_facade',
+              description: 'Test facade',
+              ops: [
+                { name: 'do_thing', description: 'Does a thing', auth: 'read' },
+                { name: 'admin_thing', description: 'Admin action', auth: 'admin' },
+              ],
+            },
+          ],
         }),
       });
 
@@ -98,11 +100,13 @@ describe('PluginRegistry — colocated', () => {
     it('static facade ops return error message when called', async () => {
       const loaded = makeLoaded({
         manifest: makeManifest({
-          facades: [{
-            name: 'f',
-            description: '',
-            ops: [{ name: 'op1', description: '', auth: 'read' }],
-          }],
+          facades: [
+            {
+              name: 'f',
+              description: '',
+              ops: [{ name: 'op1', description: '', auth: 'read' }],
+            },
+          ],
         }),
       });
 
@@ -126,9 +130,9 @@ describe('PluginRegistry — colocated', () => {
     });
 
     it('throws for unregistered plugin', async () => {
-      await expect(
-        registry.activate('ghost', makeContext(makeLoaded())),
-      ).rejects.toThrow('not registered');
+      await expect(registry.activate('ghost', makeContext(makeLoaded()))).rejects.toThrow(
+        'not registered',
+      );
     });
 
     it('sets error status when index.js fails to load', async () => {
@@ -152,11 +156,13 @@ describe('PluginRegistry — colocated', () => {
     it('deactivates an active plugin and clears facades', async () => {
       const loaded = makeLoaded({
         manifest: makeManifest({
-          facades: [{
-            name: 'f',
-            description: '',
-            ops: [{ name: 'op', description: '', auth: 'read' }],
-          }],
+          facades: [
+            {
+              name: 'f',
+              description: '',
+              ops: [{ name: 'op', description: '', auth: 'read' }],
+            },
+          ],
         }),
       });
 
@@ -203,11 +209,13 @@ describe('PluginRegistry — colocated', () => {
       const active = makeLoaded({
         manifest: makeManifest({
           id: 'active-one',
-          facades: [{
-            name: 'af',
-            description: '',
-            ops: [{ name: 'aop', description: '', auth: 'read' }],
-          }],
+          facades: [
+            {
+              name: 'af',
+              description: '',
+              ops: [{ name: 'aop', description: '', auth: 'read' }],
+            },
+          ],
         }),
       });
       const inactive = makeLoaded({ manifest: makeManifest({ id: 'inactive-one' }) });
@@ -227,10 +235,14 @@ describe('PluginRegistry — colocated', () => {
           id: 'multi',
           facades: [
             { name: 'f1', description: '', ops: [{ name: 'a', description: '', auth: 'read' }] },
-            { name: 'f2', description: '', ops: [
-              { name: 'b', description: '', auth: 'write' },
-              { name: 'c', description: '', auth: 'admin' },
-            ]},
+            {
+              name: 'f2',
+              description: '',
+              ops: [
+                { name: 'b', description: '', auth: 'write' },
+                { name: 'c', description: '', auth: 'admin' },
+              ],
+            },
           ],
         }),
       });
@@ -240,7 +252,7 @@ describe('PluginRegistry — colocated', () => {
 
       const ops = registry.getActiveOps();
       expect(ops).toHaveLength(3);
-      expect(ops.map(o => o.name)).toEqual(['a', 'b', 'c']);
+      expect(ops.map((o) => o.name)).toEqual(['a', 'b', 'c']);
     });
 
     it('returns empty when no active plugins', () => {
@@ -265,8 +277,8 @@ describe('PluginRegistry — colocated', () => {
 
       const list = registry.list();
       expect(list).toHaveLength(2);
-      expect(list.find(p => p.id === 'a')!.status).toBe('active');
-      expect(list.find(p => p.id === 'b')!.status).toBe('registered');
+      expect(list.find((p) => p.id === 'a')!.status).toBe('active');
+      expect(list.find((p) => p.id === 'b')!.status).toBe('registered');
     });
   });
 });

package/src/project/project-registry.test.ts

@@ -33,9 +33,7 @@ function createMockProvider(): PersistenceProvider {
         // Check for duplicate
         const existing = store.project_links.find(
           (r) =>
-            r.source_project_id === p[0] &&
-            r.target_project_id === p[1] &&
-            r.link_type === p[2],
+            r.source_project_id === p[0] && r.target_project_id === p[1] && r.link_type === p[2],
         );
         if (existing) return { changes: 0, lastInsertRowid: existing.id as number };
         autoIncrementId++;
@@ -97,7 +95,11 @@ function createMockProvider(): PersistenceProvider {
         return { changes: before - store.project_rules.length, lastInsertRowid: 0 };
       }
 
-      if (sql.startsWith('DELETE FROM project_links WHERE source_project_id = ? AND target_project_id = ? AND link_type')) {
+      if (
+        sql.startsWith(
+          'DELETE FROM project_links WHERE source_project_id = ? AND target_project_id = ? AND link_type',
+        )
+      ) {
         const before = store.project_links.length;
         store.project_links = store.project_links.filter(
           (r) =>
@@ -106,16 +108,23 @@ function createMockProvider(): PersistenceProvider {
         return { changes: before - store.project_links.length, lastInsertRowid: 0 };
       }
 
-      if (sql.startsWith('DELETE FROM project_links WHERE source_project_id = ? AND target_project_id = ?')) {
+      if (
+        sql.startsWith(
+          'DELETE FROM project_links WHERE source_project_id = ? AND target_project_id = ?',
+        )
+      ) {
         const before = store.project_links.length;
         store.project_links = store.project_links.filter(
-          (r) =>
-            !(r.source_project_id === p[0] && r.target_project_id === p[1]),
+          (r) => !(r.source_project_id === p[0] && r.target_project_id === p[1]),
         );
         return { changes: before - store.project_links.length, lastInsertRowid: 0 };
       }
 
-      if (sql.startsWith('DELETE FROM project_links WHERE source_project_id = ? OR target_project_id = ?')) {
+      if (
+        sql.startsWith(
+          'DELETE FROM project_links WHERE source_project_id = ? OR target_project_id = ?',
+        )
+      ) {
         const before = store.project_links.length;
         store.project_links = store.project_links.filter(
           (r) => r.source_project_id !== p[0] && r.target_project_id !== p[1],
@@ -141,12 +150,14 @@ function createMockProvider(): PersistenceProvider {
       if (sql.includes('FROM registered_projects WHERE path')) {
         return store.registered_projects.find((r) => r.path === p[0]) as T | undefined;
       }
-      if (sql.includes('FROM project_links WHERE source_project_id = ? AND target_project_id = ? AND link_type')) {
+      if (
+        sql.includes(
+          'FROM project_links WHERE source_project_id = ? AND target_project_id = ? AND link_type',
+        )
+      ) {
         return store.project_links.find(
           (r) =>
-            r.source_project_id === p[0] &&
-            r.target_project_id === p[1] &&
-            r.link_type === p[2],
+            r.source_project_id === p[0] && r.target_project_id === p[1] && r.link_type === p[2],
         ) as T | undefined;
       }
 

package/src/prompts/template-manager.test.ts

@@ -8,7 +8,10 @@ describe('TemplateManager', () => {
   let tempDir: string;
 
   beforeEach(() => {
-    tempDir = join(tmpdir(), `tmpl-mgr-colocated-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    tempDir = join(
+      tmpdir(),
+      `tmpl-mgr-colocated-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
     mkdirSync(tempDir, { recursive: true });
   });
 

package/src/queue/job-queue.test.ts

@@ -57,7 +57,11 @@ function createMockProvider(): PersistenceProvider {
           row.completed_at = new Date().toISOString();
         }
       }
-      if (sql.includes('UPDATE') && sql.includes("status = 'pending'") && sql.includes('retry_count')) {
+      if (
+        sql.includes('UPDATE') &&
+        sql.includes("status = 'pending'") &&
+        sql.includes('retry_count')
+      ) {
         const id = p[0] as string;
         const row = rows.get(id);
         if (row) {
@@ -144,15 +148,7 @@ describe('JobQueue', () => {
       queue.enqueue('groom');
       expect(provider.run).toHaveBeenCalledWith(
         expect.stringContaining('INSERT INTO job_queue'),
-        expect.arrayContaining([
-          expect.any(String),
-          'groom',
-          null,
-          '{}',
-          '[]',
-          null,
-          3,
-        ]),
+        expect.arrayContaining([expect.any(String), 'groom', null, '{}', '[]', null, 3]),
       );
     });
 
@@ -219,10 +215,10 @@ describe('JobQueue', () => {
       const id = queue.enqueue('groom');
       queue.dequeue();
       queue.complete(id);
-      expect(provider.run).toHaveBeenCalledWith(
-        expect.stringContaining("status = 'completed'"),
-        [null, id],
-      );
+      expect(provider.run).toHaveBeenCalledWith(expect.stringContaining("status = 'completed'"), [
+        null,
+        id,
+      ]);
     });
   });
 

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

@@ -67,9 +67,7 @@ function createMockRuntime(): AgentRuntime {
         overall: 'healthy',
         subsystems: { vault: { status: 'healthy' }, brain: { status: 'healthy' } },
       })),
-      get: vi.fn((name: string) =>
-        name === 'vault' ? { status: 'healthy', failures: 0 } : null,
-      ),
+      get: vi.fn((name: string) => (name === 'vault' ? { status: 'healthy', failures: 0 } : null)),
     },
     flags: {
       getAll: vi.fn(() => ({
@@ -396,10 +394,7 @@ describe('createAdminExtraOps', () => {
 
   describe('admin_hot_reload', () => {
     it('reloads brain, vault FTS, and templates', async () => {
-      const result = (await findOp(ops, 'admin_hot_reload').handler({})) as Record<
-        string,
-        unknown
-      >;
+      const result = (await findOp(ops, 'admin_hot_reload').handler({})) as Record<string, unknown>;
       expect((result.reloaded as string[]).length).toBe(3);
       expect(result.brainTerms).toBe(500);
       expect(result.templateCount).toBe(2);
@@ -409,10 +404,7 @@ describe('createAdminExtraOps', () => {
       vi.mocked(runtime.vault.rebuildFtsIndex).mockImplementation(() => {
         throw new Error('fail');
       });
-      const result = (await findOp(ops, 'admin_hot_reload').handler({})) as Record<
-        string,
-        unknown
-      >;
+      const result = (await findOp(ops, 'admin_hot_reload').handler({})) as Record<string, unknown>;
       expect(result.reloaded).not.toContain('vault_fts');
     });
   });
@@ -455,10 +447,7 @@ describe('createAdminExtraOps', () => {
 
   describe('admin_list_flags', () => {
     it('returns all feature flags', async () => {
-      const result = (await findOp(ops, 'admin_list_flags').handler({})) as Record<
-        string,
-        unknown
-      >;
+      const result = (await findOp(ops, 'admin_list_flags').handler({})) as Record<string, unknown>;
       expect(result).toHaveProperty('auth-enforcement');
     });
   });
@@ -516,10 +505,7 @@ describe('createAdminExtraOps', () => {
 
   describe('admin_setup_run', () => {
     it('runs setup actions', async () => {
-      const result = (await findOp(ops, 'admin_setup_run').handler({})) as Record<
-        string,
-        unknown
-      >;
+      const result = (await findOp(ops, 'admin_setup_run').handler({})) as Record<string, unknown>;
       expect(result.setup).toBe(true);
       expect((result.actions as string[]).length).toBeGreaterThan(0);
     });

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

@@ -135,9 +135,7 @@ describe('createAdminOps', () => {
 
     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 allOps = [{ name: 'admin_health', description: 'Health check', auth: 'read' }];
       const result = (await op.handler({
         _allOps: allOps,
         verbose: true,

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

@@ -42,9 +42,7 @@ vi.mock('./claude-md-helpers.js', () => ({
 }));
 
 vi.mock('../skills/sync-skills.js', () => ({
-  discoverSkills: vi.fn(() => [
-    { name: 'skill-1', path: '/mock/skills/skill-1' },
-  ]),
+  discoverSkills: vi.fn(() => [{ name: 'skill-1', path: '/mock/skills/skill-1' }]),
   syncSkillsToClaudeCode: vi.fn(() => ({
     installed: ['skill-1'],
     updated: [],
@@ -158,7 +156,8 @@ describe('createAdminSetupOps', () => {
     });
 
     it('updates existing agent sections', async () => {
-      mockFs['/some/project/CLAUDE.md'] = '# Project\n<!-- agent:test-agent -->\nOld\n<!-- /agent:test-agent -->';
+      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({