@soleri/core 9.2.0 → 9.3.0

package/src/runtime/memory-cross-project-ops.test.ts

@@ -8,9 +8,7 @@ function makeMockRuntime(overrides: Record<string, unknown> = {}) {
     vault: {
       get: vi.fn().mockReturnValue({ id: 'e1', tags: ['pattern'] }),
       update: vi.fn(),
-      searchMemories: vi.fn().mockReturnValue([
-        { id: 'm1', content: 'memory 1' },
-      ]),
+      searchMemories: vi.fn().mockReturnValue([{ id: 'm1', content: 'memory 1' }]),
       search: vi.fn().mockReturnValue([
         { entry: { id: 'g1', tags: ['_global'] }, score: 0.9 },
         { entry: { id: 'g2', tags: ['other'] }, score: 0.8 },
@@ -25,9 +23,9 @@ function makeMockRuntime(overrides: Record<string, unknown> = {}) {
         metadata: { memoryConfig: { crossProjectEnabled: true, extraPaths: ['/extra'] } },
       }),
       register: vi.fn(),
-      getLinkedProjects: vi.fn().mockReturnValue([
-        { project: { path: '/linked', name: 'linked-project' } },
-      ]),
+      getLinkedProjects: vi
+        .fn()
+        .mockReturnValue([{ project: { path: '/linked', name: 'linked-project' } }]),
     },
   } as unknown as AgentRuntime;
 }
@@ -60,7 +58,9 @@ describe('createMemoryCrossProjectOps', () => {
     it('promotes entry by adding _global tag', async () => {
       const runtime = makeMockRuntime();
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'e1',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(true);
       expect(result.tags).toContain('_global');
       expect(runtime.vault.update).toHaveBeenCalledWith('e1', { tags: ['pattern', '_global'] });
@@ -69,7 +69,9 @@ describe('createMemoryCrossProjectOps', () => {
     it('returns error when entry not found', async () => {
       const runtime = makeMockRuntime({ get: vi.fn().mockReturnValue(null) });
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'missing' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'missing',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(false);
       expect(result.error).toContain('Entry not found');
     });
@@ -79,7 +81,9 @@ describe('createMemoryCrossProjectOps', () => {
         get: vi.fn().mockReturnValue({ id: 'e1', tags: ['_global'] }),
       });
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'e1',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(false);
       expect(result.message).toContain('already promoted');
     });
@@ -132,12 +136,15 @@ describe('createMemoryCrossProjectOps', () => {
       const runtime = makeMockRuntime();
       ops = createMemoryCrossProjectOps(runtime);
       await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       });
 
       // Should search current project, linked project, and extra path
       const searchCalls = (runtime.vault.searchMemories as ReturnType<typeof vi.fn>).mock.calls;
-      const searchedPaths = searchCalls.map((c: unknown[]) => (c[1] as Record<string, unknown>).projectPath);
+      const searchedPaths = searchCalls.map(
+        (c: unknown[]) => (c[1] as Record<string, unknown>).projectPath,
+      );
       expect(searchedPaths).toContain('/test');
       expect(searchedPaths).toContain('/linked');
       expect(searchedPaths).toContain('/extra');
@@ -151,7 +158,8 @@ describe('createMemoryCrossProjectOps', () => {
       ]);
       ops = createMemoryCrossProjectOps(runtime);
       const result = (await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       })) as Record<string, unknown>;
 
       // linkedMemories should be empty because m1 was already in current results
@@ -162,12 +170,15 @@ describe('createMemoryCrossProjectOps', () => {
     it('skips linked search when cross-project disabled', async () => {
       const runtime = makeMockRuntime();
       (runtime.projectRegistry.getByPath as ReturnType<typeof vi.fn>).mockReturnValue({
-        id: 'proj-1', name: 'test', path: '/test',
+        id: 'proj-1',
+        name: 'test',
+        path: '/test',
         metadata: { memoryConfig: { crossProjectEnabled: false } },
       });
       ops = createMemoryCrossProjectOps(runtime);
       const result = (await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       })) as Record<string, unknown>;
 
       expect(runtime.projectRegistry.getLinkedProjects).not.toHaveBeenCalled();

package/src/runtime/orchestrate-ops.ts

@@ -182,10 +182,7 @@ function buildHealthWarning(
  * Collect all acceptance criteria from a plan's tasks.
  * Returns empty array if plan not found or has no criteria (graceful skip).
  */
-function collectAcceptanceCriteria(
-  plannerRef: AgentRuntime['planner'],
-  planId: string,
-): string[] {
+function collectAcceptanceCriteria(plannerRef: AgentRuntime['planner'], planId: string): string[] {
   const plan = plannerRef.get(planId);
   if (!plan) return [];
   const criteria: string[] = [];
@@ -210,7 +207,8 @@ function captureRationalizationAntiPattern(
     vaultRef.add({
       id: `antipattern-rationalization-${Date.now()}`,
       title: 'Rationalization detected in completion claim',
-      description: `Detected rationalization patterns: ${patterns}. ` +
+      description:
+        `Detected rationalization patterns: ${patterns}. ` +
         `Items: ${report.items.map((i) => `"${i.phrase}" (${i.pattern})`).join('; ')}.`,
       type: 'anti-pattern',
       domain: 'planning',
@@ -247,7 +245,10 @@ export function createOrchestrateOps(
         'a pruned orchestration plan with gate-guarded steps.',
       auth: 'write',
       schema: z.object({
-        prompt: z.string().optional().describe('Natural language description of what to do (or use objective)'),
+        prompt: z
+          .string()
+          .optional()
+          .describe('Natural language description of what to do (or use objective)'),
         projectPath: z.string().optional().default('.').describe('Project root path'),
         // Legacy params — still accepted for backward compat
         objective: z.string().optional().describe('(Legacy) Plan objective — use prompt instead'),
@@ -277,9 +278,10 @@ export function createOrchestrateOps(
           recommendations = raw.map((r) => {
             // Look up vault entry ID by title for feedback tracking
             const entries = vault.search(r.pattern, { limit: 1 });
-            const entryId = entries.length > 0 && entries[0].entry.title === r.pattern
-              ? entries[0].entry.id
-              : undefined;
+            const entryId =
+              entries.length > 0 && entries[0].entry.title === r.pattern
+                ? entries[0].entry.id
+                : undefined;
             return { pattern: r.pattern, strength: r.strength, entryId };
           });
         } catch {
@@ -307,12 +309,10 @@ export function createOrchestrateOps(
         planStore.set(plan.planId, { plan, createdAt: Date.now() });
 
         // 5. Also create a planner plan for lifecycle tracking (backward compat)
-        const decisions = recommendations.map(
-          (r) => {
-            const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
-            return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
-          },
-        );
+        const decisions = recommendations.map((r) => {
+          const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
+          return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
+        });
         const tasks = (params.tasks as Array<{ title: string; description: string }>) ?? [];
 
         // 5b. Extract GitHub issue context if prompt references #NNN
@@ -333,7 +333,8 @@ export function createOrchestrateOps(
           }
         }
 
-        const planObjective = (params as Record<string, unknown>)._enrichedObjective as string | undefined ?? prompt;
+        const planObjective =
+          ((params as Record<string, unknown>)._enrichedObjective as string | undefined) ?? prompt;
 
         let legacyPlan;
         try {
@@ -478,11 +479,21 @@ export function createOrchestrateOps(
           .optional()
           .default('completed')
           .describe('Plan outcome'),
-        summary: z.string().optional().describe('Completion summary — checked for rationalization language'),
+        summary: z
+          .string()
+          .optional()
+          .describe('Completion summary — checked for rationalization language'),
         toolsUsed: z.array(z.string()).optional().describe('Tools used during execution'),
         filesModified: z.array(z.string()).optional().describe('Files modified during execution'),
-        projectPath: z.string().optional().default('.').describe('Project root path for impact analysis'),
-        overrideRationalization: z.boolean().optional().default(false)
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project root path for impact analysis'),
+        overrideRationalization: z
+          .boolean()
+          .optional()
+          .default(false)
           .describe('Set true to bypass rationalization gate and impact warnings after review'),
       }),
       handler: async (params) => {
@@ -517,9 +528,7 @@ export function createOrchestrateOps(
           try {
             const analyzer = new ImpactAnalyzer();
             const planObj = planner.get(planId);
-            const scopeHints = planObj?.scope
-              ? [planObj.scope]
-              : undefined;
+            const scopeHints = planObj?.scope ? [planObj.scope] : undefined;
             impactReport = analyzer.analyzeImpact(
               filesModified,
               (params.projectPath as string) ?? '.',
@@ -710,11 +719,22 @@ export function createOrchestrateOps(
       auth: 'write',
       schema: z.object({
         planId: z.string().describe('ID of the plan to project to GitHub'),
-        projectPath: z.string().optional().default('.').describe('Project root path for git detection'),
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project root path for git detection'),
         milestone: z.number().optional().describe('GitHub milestone number to assign issues to'),
         labels: z.array(z.string()).optional().describe('Labels to apply to created issues'),
-        linkToIssue: z.number().optional().describe('Existing issue number to link plan to instead of creating new issues'),
-        dryRun: z.boolean().optional().default(false).describe('Preview what would be created without actually creating issues'),
+        linkToIssue: z
+          .number()
+          .optional()
+          .describe('Existing issue number to link plan to instead of creating new issues'),
+        dryRun: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Preview what would be created without actually creating issues'),
       }),
       handler: async (params) => {
         const planId = params.planId as string;
@@ -729,7 +749,9 @@ export function createOrchestrateOps(
         if (!plan) throw new Error(`Plan not found: ${planId}`);
 
         if (plan.tasks.length === 0) {
-          throw new Error('Plan has no tasks — run plan_split first to define tasks before projecting to GitHub');
+          throw new Error(
+            'Plan has no tasks — run plan_split first to define tasks before projecting to GitHub',
+          );
         }
 
         // 2. Detect GitHub context
@@ -807,7 +829,12 @@ export function createOrchestrateOps(
 
         // 6. Create issues per task (with duplicate detection)
         const created: Array<{ taskId: string; issueNumber: number; title: string }> = [];
-        const skipped: Array<{ taskId: string; title: string; existingIssue: number; reason: string }> = [];
+        const skipped: Array<{
+          taskId: string;
+          title: string;
+          existingIssue: number;
+          reason: string;
+        }> = [];
         const failed: Array<{ taskId: string; title: string; reason: string }> = [];
 
         for (const task of plan.tasks) {

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

@@ -54,7 +54,10 @@ describe('createPackOps', () => {
     runtime = makeMockRuntime();
     ops = createPackOps(runtime);
     expect(ops.map((o) => o.name)).toEqual([
-      'pack_validate', 'pack_install', 'pack_list', 'pack_uninstall',
+      'pack_validate',
+      'pack_install',
+      'pack_list',
+      'pack_uninstall',
     ]);
   });
 
@@ -91,7 +94,10 @@ describe('createPackOps', () => {
       const hotRegister = vi.fn();
       setHotRegister(hotRegister);
       ops = createPackOps(runtime);
-      const result = (await findOp('pack_install').handler({ packDir: '/packs/test' })) as Record<string, unknown>;
+      const result = (await findOp('pack_install').handler({ packDir: '/packs/test' })) as Record<
+        string,
+        unknown
+      >;
       expect(hotRegister).toHaveBeenCalledWith('test-agent_design', 'Design facade', []);
       expect(result.hotReloaded).toBe(true);
     });
@@ -99,14 +105,19 @@ describe('createPackOps', () => {
     it('skips hot-register when no callback set', async () => {
       runtime = makeMockRuntime();
       ops = createPackOps(runtime);
-      const result = (await findOp('pack_install').handler({ packDir: '/packs/test' })) as Record<string, unknown>;
+      const result = (await findOp('pack_install').handler({ packDir: '/packs/test' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.hotReloaded).toBeUndefined();
     });
 
     it('skips hot-register when no facades', async () => {
       runtime = makeMockRuntime();
       (runtime.packInstaller.install as ReturnType<typeof vi.fn>).mockResolvedValue({
-        installed: true, id: 'pack-1', facades: 0,
+        installed: true,
+        id: 'pack-1',
+        facades: 0,
       });
       const hotRegister = vi.fn();
       setHotRegister(hotRegister);
@@ -142,7 +153,10 @@ describe('createPackOps', () => {
     it('uninstalls a pack', async () => {
       runtime = makeMockRuntime();
       ops = createPackOps(runtime);
-      const result = (await findOp('pack_uninstall').handler({ packId: 'pack-1' })) as Record<string, unknown>;
+      const result = (await findOp('pack_uninstall').handler({ packId: 'pack-1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.uninstalled).toBe(true);
       expect(result.id).toBe('pack-1');
     });
@@ -151,7 +165,10 @@ describe('createPackOps', () => {
       runtime = makeMockRuntime();
       (runtime.packInstaller.uninstall as ReturnType<typeof vi.fn>).mockReturnValue(false);
       ops = createPackOps(runtime);
-      const result = (await findOp('pack_uninstall').handler({ packId: 'missing' })) as Record<string, unknown>;
+      const result = (await findOp('pack_uninstall').handler({ packId: 'missing' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toContain('Pack not found');
     });
   });

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

@@ -70,11 +70,17 @@ function createMockRuntime(): AgentRuntime {
   return {
     planner: {
       iterate: vi.fn(() => plan),
-      splitTasks: vi.fn(() => ({ ...plan, tasks: [plan.tasks[0], { id: 'task-2', title: 'Task 2' }] })),
+      splitTasks: vi.fn(() => ({
+        ...plan,
+        tasks: [plan.tasks[0], { id: 'task-2', title: 'Task 2' }],
+      })),
       reconcile: vi.fn(() => ({
         ...plan,
         status: 'reconciling',
-        reconciliation: { accuracy: 85, driftItems: [{ type: 'added', description: 'Extra test' }] },
+        reconciliation: {
+          accuracy: 85,
+          driftItems: [{ type: 'added', description: 'Extra test' }],
+        },
       })),
       get: vi.fn(() => plan),
       getDispatch: vi.fn(() => ({ task: plan.tasks[0], ready: true, unmetDeps: [] })),
@@ -147,14 +153,20 @@ describe('createPlanningExtraOps', () => {
         objective: 'New objective',
       })) as Record<string, unknown>;
       expect(result.iterated).toBe(true);
-      expect(runtime.planner.iterate).toHaveBeenCalledWith('plan-1', expect.objectContaining({ objective: 'New objective' }));
+      expect(runtime.planner.iterate).toHaveBeenCalledWith(
+        'plan-1',
+        expect.objectContaining({ objective: 'New objective' }),
+      );
     });
 
     it('returns error on failure', async () => {
       vi.mocked(runtime.planner.iterate).mockImplementation(() => {
         throw new Error('Not a draft');
       });
-      const result = (await findOp(ops, 'plan_iterate').handler({ planId: 'x' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'plan_iterate').handler({ planId: 'x' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toBe('Not a draft');
     });
   });
@@ -569,9 +581,7 @@ describe('createPlanningExtraOps', () => {
     });
 
     it('purges specific plans by ID', async () => {
-      vi.mocked(runtime.planner.list).mockReturnValue([
-        makePlan({ id: 'plan-1' }),
-      ] as unknown);
+      vi.mocked(runtime.planner.list).mockReturnValue([makePlan({ id: 'plan-1' })] as unknown);
       const result = (await findOp(ops, 'plan_purge').handler({
         mode: 'specific',
         planIds: ['plan-1'],

package/src/runtime/planning-extra-ops.ts

@@ -46,7 +46,9 @@ export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
         decisions: z
           .array(z.union([z.string(), z.object({ decision: z.string(), rationale: z.string() })]))
           .optional()
-          .describe('New decisions list (replaces existing) — strings or {decision, rationale} objects'),
+          .describe(
+            'New decisions list (replaces existing) — strings or {decision, rationale} objects',
+          ),
         addTasks: z
           .array(z.object({ title: z.string(), description: z.string() }))
           .optional()

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

@@ -9,7 +9,19 @@ import type { AgentRuntime } from './types.js';
 
 /** Minimal vault stub that stores entries in memory. */
 function makeVaultStub() {
-  const entries = new Map<string, { id: string; type: string; domain?: string; title: string; description: string; context?: string; tags?: string[]; severity?: string }>();
+  const entries = new Map<
+    string,
+    {
+      id: string;
+      type: string;
+      domain?: string;
+      title: string;
+      description: string;
+      context?: string;
+      tags?: string[];
+      severity?: string;
+    }
+  >();
   return {
     list: (opts: { type?: string; domain?: string; limit?: number }) => {
       let arr = [...entries.values()];
@@ -18,7 +30,16 @@ function makeVaultStub() {
       return arr.slice(0, opts.limit ?? 50);
     },
     get: (id: string) => entries.get(id) ?? null,
-    add: (entry: { id: string; type: string; title: string; description: string; domain?: string; context?: string; tags?: string[]; severity?: string }) => {
+    add: (entry: {
+      id: string;
+      type: string;
+      title: string;
+      description: string;
+      domain?: string;
+      context?: string;
+      tags?: string[];
+      severity?: string;
+    }) => {
       entries.set(entry.id, entry);
     },
     _entries: entries,
@@ -77,7 +98,9 @@ describe('playbook-ops', () => {
         domain: 'testing',
         title: 'TDD Workflow',
         description: 'Test-driven development playbook',
-        context: JSON.stringify({ steps: [{ order: 1, title: 'Write test', description: 'Write failing test' }] }),
+        context: JSON.stringify({
+          steps: [{ order: 1, title: 'Write test', description: 'Write failing test' }],
+        }),
         tags: ['tdd'],
       });
 

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

@@ -10,17 +10,28 @@ import type { OpDefinition } from '../facades/types.js';
 
 /** Minimal plugin registry stub. */
 function makePluginRegistryStub() {
-  const plugins = new Map<string, {
-    id: string;
-    manifest: { id: string; name: string; version: string; domain: string; description: string; dependencies: string[]; intelligence: unknown[] };
-    status: string;
-    provenance: string;
-    directory: string;
-    error?: string;
-    facades: Array<{ name: string; description: string; ops: OpDefinition[] }>;
-    registeredAt: number;
-    activatedAt?: number;
-  }>();
+  const plugins = new Map<
+    string,
+    {
+      id: string;
+      manifest: {
+        id: string;
+        name: string;
+        version: string;
+        domain: string;
+        description: string;
+        dependencies: string[];
+        intelligence: unknown[];
+      };
+      status: string;
+      provenance: string;
+      directory: string;
+      error?: string;
+      facades: Array<{ name: string; description: string; ops: OpDefinition[] }>;
+      registeredAt: number;
+      activatedAt?: number;
+    }
+  >();
 
   return {
     get: (id: string) => plugins.get(id) ?? null,
@@ -43,10 +54,24 @@ function makePluginRegistryStub() {
       plugin.status = 'registered';
       return true;
     }),
-    _seed: (id: string, overrides?: Partial<{ status: string; facades: Array<{ name: string; description: string; ops: OpDefinition[] }> }>) => {
+    _seed: (
+      id: string,
+      overrides?: Partial<{
+        status: string;
+        facades: Array<{ name: string; description: string; ops: OpDefinition[] }>;
+      }>,
+    ) => {
       plugins.set(id, {
         id,
-        manifest: { id, name: `Plugin ${id}`, version: '1.0.0', domain: 'test', description: 'Test plugin', dependencies: [], intelligence: [] },
+        manifest: {
+          id,
+          name: `Plugin ${id}`,
+          version: '1.0.0',
+          domain: 'test',
+          description: 'Test plugin',
+          dependencies: [],
+          intelligence: [],
+        },
         status: overrides?.status ?? 'registered',
         provenance: 'local',
         directory: `/plugins/${id}`,
@@ -63,10 +88,7 @@ describe('plugin-ops', () => {
     const config = { agentId: 'test-agent' };
     const opSink = opts?.opSink;
     const ops = captureOps(
-      createPluginOps(
-        { pluginRegistry, config } as unknown as AgentRuntime,
-        opSink,
-      ),
+      createPluginOps({ pluginRegistry, config } as unknown as AgentRuntime, opSink),
     );
     return { pluginRegistry, ops, opSink };
   }
@@ -83,11 +105,24 @@ describe('plugin-ops', () => {
 
     it('lists registered plugins with status', async () => {
       const { ops, pluginRegistry } = setup();
-      pluginRegistry._seed('plug-a', { status: 'active', facades: [{ name: 'f1', description: 'F1', ops: [{ name: 'op1', handler: async () => ({}), auth: 'read', description: '' }] }] });
+      pluginRegistry._seed('plug-a', {
+        status: 'active',
+        facades: [
+          {
+            name: 'f1',
+            description: 'F1',
+            ops: [{ name: 'op1', handler: async () => ({}), auth: 'read', description: '' }],
+          },
+        ],
+      });
       pluginRegistry._seed('plug-b', { status: 'registered' });
 
       const res = await executeOp(ops, 'plugin_list');
-      const data = res.data as { count: number; active: number; plugins: Array<{ id: string; status: string; facades: number; ops: number }> };
+      const data = res.data as {
+        count: number;
+        active: number;
+        plugins: Array<{ id: string; status: string; facades: number; ops: number }>;
+      };
       expect(data.count).toBe(2);
       expect(data.active).toBe(1);
       expect(data.plugins[0].facades).toBe(1);
@@ -108,7 +143,13 @@ describe('plugin-ops', () => {
       pluginRegistry._seed('my-plug');
 
       const res = await executeOp(ops, 'plugin_status', { pluginId: 'my-plug' });
-      const data = res.data as { id: string; name: string; version: string; status: string; directory: string };
+      const data = res.data as {
+        id: string;
+        name: string;
+        version: string;
+        status: string;
+        directory: string;
+      };
       expect(data.id).toBe('my-plug');
       expect(data.version).toBe('1.0.0');
       expect(data.directory).toBe('/plugins/my-plug');
@@ -140,7 +181,10 @@ describe('plugin-ops', () => {
       pluginRegistry._seed('p2', { status: 'registered', facades: [] });
 
       const res = await executeOp(ops, 'plugin_activate', {});
-      const data = res.data as { activated: number; results: Array<{ id: string; status: string }> };
+      const data = res.data as {
+        activated: number;
+        results: Array<{ id: string; status: string }>;
+      };
       expect(data.activated).toBe(2);
       expect(data.results).toHaveLength(2);
     });
@@ -148,8 +192,15 @@ describe('plugin-ops', () => {
     it('injects plugin ops into opSink on activation', async () => {
       const opSink: OpDefinition[] = [];
       const { ops, pluginRegistry } = setup({ opSink });
-      const testOp: OpDefinition = { name: 'injected_op', handler: async () => 'hi', auth: 'read', description: 'test' };
-      pluginRegistry._seed('plug-inject', { facades: [{ name: 'test-facade', description: 'TF', ops: [testOp] }] });
+      const testOp: OpDefinition = {
+        name: 'injected_op',
+        handler: async () => 'hi',
+        auth: 'read',
+        description: 'test',
+      };
+      pluginRegistry._seed('plug-inject', {
+        facades: [{ name: 'test-facade', description: 'TF', ops: [testOp] }],
+      });
 
       await executeOp(ops, 'plugin_activate', { pluginId: 'plug-inject' });
       expect(opSink.some((o) => o.name === 'injected_op')).toBe(true);
@@ -177,8 +228,15 @@ describe('plugin-ops', () => {
     it('removes injected ops from opSink on deactivation', async () => {
       const opSink: OpDefinition[] = [];
       const { ops, pluginRegistry } = setup({ opSink });
-      const testOp: OpDefinition = { name: 'to_remove', handler: async () => 'hi', auth: 'read', description: 'test' };
-      pluginRegistry._seed('plug-rm', { facades: [{ name: 'f', description: 'F', ops: [testOp] }] });
+      const testOp: OpDefinition = {
+        name: 'to_remove',
+        handler: async () => 'hi',
+        auth: 'read',
+        description: 'test',
+      };
+      pluginRegistry._seed('plug-rm', {
+        facades: [{ name: 'f', description: 'F', ops: [testOp] }],
+      });
 
       await executeOp(ops, 'plugin_activate', { pluginId: 'plug-rm' });
       expect(opSink.some((o) => o.name === 'to_remove')).toBe(true);