@soleri/core 9.2.0 → 9.3.1

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);

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

@@ -10,7 +10,10 @@ import type { AgentRuntime } from './types.js';
 /** Minimal in-memory project registry stub. */
 function makeProjectRegistryStub() {
   const projects = new Map<string, { id: string; name: string; lastAccessed: number }>();
-  const rules = new Map<string, Array<{ id: string; category: string; text: string; priority: number }>>();
+  const rules = new Map<
+    string,
+    Array<{ id: string; category: string; text: string; priority: number }>
+  >();
   const links: Array<{ sourceId: string; targetId: string; linkType: string }> = [];
   let ruleCounter = 0;
 
@@ -39,7 +42,10 @@ function makeProjectRegistryStub() {
     removeRule: (ruleId: string) => {
       for (const [, arr] of rules) {
         const idx = arr.findIndex((r) => r.id === ruleId);
-        if (idx >= 0) { arr.splice(idx, 1); return true; }
+        if (idx >= 0) {
+          arr.splice(idx, 1);
+          return true;
+        }
       }
       return false;
     },
@@ -52,14 +58,19 @@ function makeProjectRegistryStub() {
       let count = 0;
       for (let i = links.length - 1; i >= 0; i--) {
         const l = links[i];
-        if (l.sourceId === sourceId && l.targetId === targetId && (!linkType || l.linkType === linkType)) {
+        if (
+          l.sourceId === sourceId &&
+          l.targetId === targetId &&
+          (!linkType || l.linkType === linkType)
+        ) {
           links.splice(i, 1);
           count++;
         }
       }
       return count;
     },
-    getLinks: (projectId: string) => links.filter((l) => l.sourceId === projectId || l.targetId === projectId),
+    getLinks: (projectId: string) =>
+      links.filter((l) => l.sourceId === projectId || l.targetId === projectId),
     getLinkedProjects: (projectId: string) => {
       return links
         .filter((l) => l.sourceId === projectId || l.targetId === projectId)
@@ -181,7 +192,12 @@ describe('project-ops', () => {
       const { ops, registry } = setup();
       registry._seed('a', 'A');
       registry._seed('b', 'B');
-      await executeOp(ops, 'project_add_rule', { projectId: 'a', category: 'behavior', text: 'r1', priority: 0 });
+      await executeOp(ops, 'project_add_rule', {
+        projectId: 'a',
+        category: 'behavior',
+        text: 'r1',
+        priority: 0,
+      });
 
       const res = await executeOp(ops, 'project_list_rules');
       const data = res.data as { count: number; projects: Array<{ ruleCount: number }> };
@@ -207,7 +223,11 @@ describe('project-ops', () => {
       registry._seed('b', 'B');
       await executeOp(ops, 'project_link', { sourceId: 'a', targetId: 'b', linkType: 'parent' });
 
-      const res = await executeOp(ops, 'project_unlink', { sourceId: 'a', targetId: 'b', linkType: 'parent' });
+      const res = await executeOp(ops, 'project_unlink', {
+        sourceId: 'a',
+        targetId: 'b',
+        linkType: 'parent',
+      });
       expect((res.data as { removed: number }).removed).toBe(1);
     });
 

package/src/runtime/runtime.ts

@@ -210,7 +210,9 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
         logger.info(`Markdown sync: ${result.synced} entries synced, ${result.skipped} skipped`);
       }
     },
-    () => { /* best-effort — never block boot */ },
+    () => {
+      /* best-effort — never block boot */
+    },
   );
 
   // ─── Auto-signal pipeline wiring ───────────────────────────────────