@soleri/core 9.0.4 → 9.3.0

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

@@ -16,6 +16,7 @@ import type { DriftItem, TaskEvidence } from '../planning/planner.js';
 import { collectGitEvidence } from '../planning/evidence-collector.js';
 import { matchPlaybooks, type PlaybookMatchResult } from '../playbooks/index.js';
 import { entryToPlaybookDefinition } from '../playbooks/index.js';
+import { closeIssueWithComment } from './github-integration.js';
 
 /**
  * Create 22 extended planning operations for an agent runtime.
@@ -29,7 +30,7 @@ import { entryToPlaybookDefinition } from '../playbooks/index.js';
  *             plan_brainstorm, plan_execution_metrics, plan_verify_deliverables
  */
 export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
-  const { planner, vault } = runtime;
+  const { planner, vault, brain, brainIntelligence } = runtime;
 
   return [
     // ─── Plan Iteration ───────────────────────────────────────────
@@ -43,9 +44,11 @@ export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
         objective: z.string().optional().describe('New objective (replaces existing)'),
         scope: z.string().optional().describe('New scope (replaces existing)'),
         decisions: z
-          .array(z.string())
+          .array(z.union([z.string(), z.object({ decision: z.string(), rationale: z.string() })]))
           .optional()
-          .describe('New decisions list (replaces existing)'),
+          .describe(
+            'New decisions list (replaces existing) — strings or {decision, rationale} objects',
+          ),
         addTasks: z
           .array(z.object({ title: z.string(), description: z.string() }))
           .optional()
@@ -92,7 +95,22 @@ export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
             params.planId as string,
             params.tasks as Array<{ title: string; description: string; dependsOn?: string[] }>,
           );
-          return { split: true, taskCount: plan.tasks.length, plan };
+
+          // Auto-start brain session linked to the plan for learning pipeline
+          let brainSessionId: string | null = null;
+          try {
+            const session = brainIntelligence.lifecycle({
+              action: 'start',
+              domain: plan.scope ?? undefined,
+              context: plan.objective,
+              planId: plan.id,
+            });
+            brainSessionId = session.id;
+          } catch {
+            // Non-critical — don't block plan execution
+          }
+
+          return { split: true, taskCount: plan.tasks.length, brainSessionId, plan };
         } catch (err) {
           return { error: (err as Error).message };
         }
@@ -191,12 +209,64 @@ export function createPlanningExtraOps(runtime: AgentRuntime): OpDefinition[] {
             captured++;
           }
 
+          // End brain session so the learning pipeline can extract patterns
+          let session = null;
+          let extraction = null;
+          const brainSession = brainIntelligence.getSessionByPlanId(plan.id);
+          if (brainSession && !brainSession.endedAt) {
+            session = brainIntelligence.lifecycle({
+              action: 'end',
+              sessionId: brainSession.id,
+              planId: plan.id,
+              planOutcome: 'completed',
+            });
+            try {
+              extraction = brainIntelligence.extractKnowledge(brainSession.id);
+            } catch {
+              // Not enough signal — extraction is best-effort
+            }
+          }
+
+          // Auto-record positive feedback for vault entries used as recommendations
+          let feedbackRecorded = 0;
+          const entryIdRegex = /\[entryId:([^\]]+)\]/;
+          for (const d of plan.decisions) {
+            const decisionStr = typeof d === 'string' ? d : d.decision;
+            const match = entryIdRegex.exec(decisionStr);
+            if (match) {
+              try {
+                brain.recordFeedback(plan.objective, match[1], 'accepted');
+                feedbackRecorded++;
+              } catch {
+                // Graceful degradation — skip if entry not found or already recorded
+              }
+            }
+          }
+
+          // Auto-close linked GitHub issue if plan has one
+          let issueClosed = false;
+          if (plan.githubIssue) {
+            const { owner, repo, number: issueNum } = plan.githubIssue;
+            const accuracy = plan.reconciliation?.accuracy ?? 'N/A';
+            const comment =
+              `Plan \`${plan.id}\` completed.\n\n` +
+              `**Objective:** ${plan.objective}\n` +
+              `**Accuracy:** ${accuracy}/100\n` +
+              `**Knowledge captured:** ${captured} entries`;
+            await closeIssueWithComment(owner, repo, issueNum, comment);
+            issueClosed = true;
+          }
+
           return {
             completed: true,
             knowledgeCaptured: captured,
+            feedbackRecorded,
             patternsAdded: patterns.length,
             antiPatternsAdded: antiPatterns.length,
             reconciliation: plan.reconciliation ?? null,
+            brainSession: session?.id ?? brainSession?.id ?? null,
+            brainExtraction: extraction ? { proposals: extraction.proposals.length } : null,
+            githubIssueClosed: issueClosed ? plan.githubIssue?.number : null,
           };
         } catch (err) {
           return { error: (err as Error).message };

package/src/{__tests__ → runtime}/playbook-ops-execution.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createPlaybookOps } from '../runtime/playbook-ops.js';
-import type { AgentRuntime } from '../runtime/types.js';
+import { createAgentRuntime } from './runtime.js';
+import { createPlaybookOps } from './playbook-ops.js';
+import type { AgentRuntime } from './types.js';
 import type { OpDefinition } from '../facades/types.js';
 
 describe('playbook execution ops', () => {

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

@@ -0,0 +1,285 @@
+/**
+ * Unit tests for playbook-ops — 8 ops for playbook management and execution.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createPlaybookOps } from './playbook-ops.js';
+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;
+    }
+  >();
+  return {
+    list: (opts: { type?: string; domain?: string; limit?: number }) => {
+      let arr = [...entries.values()];
+      if (opts.type) arr = arr.filter((e) => e.type === opts.type);
+      if (opts.domain) arr = arr.filter((e) => e.domain === opts.domain);
+      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;
+    }) => {
+      entries.set(entry.id, entry);
+    },
+    _entries: entries,
+  };
+}
+
+/** Minimal playbook executor stub. */
+function makePlaybookExecutorStub() {
+  const sessions = new Map<string, { id: string; step: number; completed: boolean }>();
+  return {
+    start: vi.fn((def: { id: string; title: string }) => {
+      const sessionId = `session-${def.id}`;
+      sessions.set(sessionId, { id: sessionId, step: 0, completed: false });
+      return { sessionId, currentStep: 0, playbook: def };
+    }),
+    step: vi.fn((sessionId: string, opts: { output?: string; skip?: boolean }) => {
+      const session = sessions.get(sessionId);
+      if (!session) return { error: `Session not found: ${sessionId}` };
+      session.step++;
+      return { sessionId, currentStep: session.step, skipped: opts.skip ?? false };
+    }),
+    complete: vi.fn((sessionId: string, opts: { abort?: boolean }) => {
+      const session = sessions.get(sessionId);
+      if (!session) return { error: `Session not found: ${sessionId}` };
+      session.completed = true;
+      return { sessionId, status: opts.abort ? 'aborted' : 'completed' };
+    }),
+  };
+}
+
+describe('playbook-ops', () => {
+  function setup() {
+    const vault = makeVaultStub();
+    const playbookExecutor = makePlaybookExecutorStub();
+    const ops = captureOps(
+      createPlaybookOps({ vault, playbookExecutor } as unknown as AgentRuntime),
+    );
+    return { vault, playbookExecutor, ops };
+  }
+
+  describe('playbook_list', () => {
+    it('returns empty list when no playbooks exist', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_list', {});
+      expect(res.success).toBe(true);
+      const data = res.data as { playbooks: unknown[]; count: number };
+      expect(data.count).toBe(0);
+      expect(data.playbooks).toEqual([]);
+    });
+
+    it('lists playbook entries from vault', async () => {
+      const { ops, vault } = setup();
+      vault.add({
+        id: 'playbook-test-1',
+        type: 'playbook',
+        domain: 'testing',
+        title: 'TDD Workflow',
+        description: 'Test-driven development playbook',
+        context: JSON.stringify({
+          steps: [{ order: 1, title: 'Write test', description: 'Write failing test' }],
+        }),
+        tags: ['tdd'],
+      });
+
+      const res = await executeOp(ops, 'playbook_list', {});
+      expect(res.success).toBe(true);
+      // parsePlaybookFromEntry may return null if format doesn't match exactly,
+      // but we verify the op runs without error
+    });
+  });
+
+  describe('playbook_get', () => {
+    it('returns error for missing playbook', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_get', { id: 'nonexistent' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('returns error for non-playbook entry', async () => {
+      const { ops, vault } = setup();
+      vault.add({ id: 'entry-1', type: 'pattern', title: 'Not a playbook', description: 'nope' });
+
+      const res = await executeOp(ops, 'playbook_get', { id: 'entry-1' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not a playbook');
+    });
+  });
+
+  describe('playbook_create', () => {
+    it('creates a playbook with valid steps', async () => {
+      const { ops, vault } = setup();
+      const res = await executeOp(ops, 'playbook_create', {
+        title: 'My Playbook',
+        domain: 'testing',
+        description: 'A test playbook',
+        steps: [
+          { title: 'Step 1', description: 'Do first thing' },
+          { title: 'Step 2', description: 'Do second thing' },
+        ],
+        tags: ['test'],
+      });
+
+      expect(res.success).toBe(true);
+      const data = res.data as { created: boolean; id: string; steps: number };
+      expect(data.created).toBe(true);
+      expect(data.steps).toBe(2);
+      expect(data.id).toMatch(/^playbook-testing-/);
+      // Verify stored in vault
+      expect(vault._entries.has(data.id)).toBe(true);
+    });
+
+    it('uses provided id when given', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_create', {
+        id: 'custom-id',
+        title: 'Custom',
+        domain: 'dev',
+        description: 'Custom ID playbook',
+        steps: [{ title: 'Step', description: 'Do it' }],
+      });
+      expect((res.data as { id: string }).id).toBe('custom-id');
+    });
+  });
+
+  describe('playbook_match', () => {
+    it('returns match result for text query', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_match', {
+        text: 'I need to debug a performance issue',
+        intent: 'FIX',
+      });
+      // Even with no vault playbooks, matchPlaybooks should return built-in matches
+      expect(res.success).toBe(true);
+    });
+
+    it('handles text-only match without intent', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_match', { text: 'build a component' });
+      expect(res.success).toBe(true);
+    });
+  });
+
+  describe('playbook_seed', () => {
+    it('seeds default playbooks', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_seed');
+      expect(res.success).toBe(true);
+      // seedDefaultPlaybooks returns { seeded, skipped, errors }
+      const data = res.data as { seeded: number; skipped: number };
+      expect(typeof data.seeded).toBe('number');
+    });
+  });
+
+  describe('playbook_start', () => {
+    it('returns error when neither playbookId nor intent provided', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', {});
+      expect(res.success).toBe(true);
+      const data = res.data as { error: string; available: unknown[] };
+      expect(data.error).toContain('Provide playbookId or intent');
+      expect(data.available).toBeDefined();
+    });
+
+    it('returns error for unknown playbookId', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', { playbookId: 'nonexistent' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('starts a built-in playbook by id', async () => {
+      const { ops, playbookExecutor } = setup();
+      // Built-in playbooks: tdd, brainstorming, code-review, subagent-execution, debugging, verification
+      const res = await executeOp(ops, 'playbook_start', { playbookId: 'tdd' });
+      expect(res.success).toBe(true);
+      if (!(res.data as { error?: string }).error) {
+        expect(playbookExecutor.start).toHaveBeenCalled();
+      }
+    });
+
+    it('auto-matches by intent and text', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'playbook_start', { intent: 'FIX', text: 'debug crash' });
+      expect(res.success).toBe(true);
+      // Either starts a matched playbook or returns "no matching playbook"
+    });
+  });
+
+  describe('playbook_step', () => {
+    it('delegates to executor step', async () => {
+      const { ops, playbookExecutor } = setup();
+      const res = await executeOp(ops, 'playbook_step', {
+        sessionId: 'test-session',
+        output: 'Did the thing',
+      });
+      expect(res.success).toBe(true);
+      expect(playbookExecutor.step).toHaveBeenCalledWith('test-session', {
+        output: 'Did the thing',
+        skip: undefined,
+      });
+    });
+
+    it('supports skip option', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_step', { sessionId: 's1', skip: true });
+      expect(playbookExecutor.step).toHaveBeenCalledWith('s1', { output: undefined, skip: true });
+    });
+  });
+
+  describe('playbook_complete', () => {
+    it('delegates to executor complete', async () => {
+      const { ops, playbookExecutor } = setup();
+      const res = await executeOp(ops, 'playbook_complete', { sessionId: 's1' });
+      expect(res.success).toBe(true);
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: undefined,
+        gateResults: undefined,
+      });
+    });
+
+    it('supports abort option', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_complete', { sessionId: 's1', abort: true });
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: true,
+        gateResults: undefined,
+      });
+    });
+
+    it('passes gate results', async () => {
+      const { ops, playbookExecutor } = setup();
+      await executeOp(ops, 'playbook_complete', {
+        sessionId: 's1',
+        gateResults: { 'tests-pass': true, 'lint-clean': false },
+      });
+      expect(playbookExecutor.complete).toHaveBeenCalledWith('s1', {
+        abort: undefined,
+        gateResults: { 'tests-pass': true, 'lint-clean': false },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,259 @@
+/**
+ * Unit tests for plugin-ops — 5 ops for runtime plugin management.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { captureOps, executeOp } from '../engine/test-helpers.js';
+import { createPluginOps } from './plugin-ops.js';
+import type { AgentRuntime } from './types.js';
+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;
+    }
+  >();
+
+  return {
+    get: (id: string) => plugins.get(id) ?? null,
+    list: () => [...plugins.values()],
+    register: vi.fn((plugin: { manifest: { id: string } }) => {
+      const existing = plugins.get(plugin.manifest.id);
+      if (existing) throw new Error(`Already registered: ${plugin.manifest.id}`);
+      plugins.set(plugin.manifest.id, plugin as never);
+    }),
+    activate: vi.fn(async (pluginId: string, _ctx: unknown) => {
+      const plugin = plugins.get(pluginId);
+      if (!plugin) return { id: pluginId, status: 'error', error: 'Not found', facades: [] };
+      plugin.status = 'active';
+      plugin.activatedAt = Date.now();
+      return { id: pluginId, status: 'active', facades: plugin.facades, error: undefined };
+    }),
+    deactivate: vi.fn((pluginId: string) => {
+      const plugin = plugins.get(pluginId);
+      if (!plugin) return false;
+      plugin.status = 'registered';
+      return true;
+    }),
+    _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: [],
+        },
+        status: overrides?.status ?? 'registered',
+        provenance: 'local',
+        directory: `/plugins/${id}`,
+        facades: overrides?.facades ?? [],
+        registeredAt: Date.now(),
+      });
+    },
+  };
+}
+
+describe('plugin-ops', () => {
+  function setup(opts?: { opSink?: OpDefinition[] }) {
+    const pluginRegistry = makePluginRegistryStub();
+    const config = { agentId: 'test-agent' };
+    const opSink = opts?.opSink;
+    const ops = captureOps(
+      createPluginOps({ pluginRegistry, config } as unknown as AgentRuntime, opSink),
+    );
+    return { pluginRegistry, ops, opSink };
+  }
+
+  describe('plugin_list', () => {
+    it('returns empty when no plugins registered', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_list');
+      expect(res.success).toBe(true);
+      const data = res.data as { plugins: unknown[]; count: number; active: number };
+      expect(data.count).toBe(0);
+      expect(data.active).toBe(0);
+    });
+
+    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-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 }>;
+      };
+      expect(data.count).toBe(2);
+      expect(data.active).toBe(1);
+      expect(data.plugins[0].facades).toBe(1);
+      expect(data.plugins[0].ops).toBe(1);
+    });
+  });
+
+  describe('plugin_status', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_status', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('returns detailed status for existing plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      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;
+      };
+      expect(data.id).toBe('my-plug');
+      expect(data.version).toBe('1.0.0');
+      expect(data.directory).toBe('/plugins/my-plug');
+    });
+  });
+
+  describe('plugin_activate', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_activate', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('activates a specific plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('plug-a', { facades: [] });
+
+      const res = await executeOp(ops, 'plugin_activate', { pluginId: 'plug-a' });
+      expect(res.success).toBe(true);
+      const data = res.data as { id: string; status: string };
+      expect(data.status).toBe('active');
+      expect(pluginRegistry.activate).toHaveBeenCalled();
+    });
+
+    it('activates all registered (non-active) plugins when no pluginId', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('p1', { status: 'registered', facades: [] });
+      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 }>;
+      };
+      expect(data.activated).toBe(2);
+      expect(data.results).toHaveLength(2);
+    });
+
+    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] }],
+      });
+
+      await executeOp(ops, 'plugin_activate', { pluginId: 'plug-inject' });
+      expect(opSink.some((o) => o.name === 'injected_op')).toBe(true);
+    });
+  });
+
+  describe('plugin_deactivate', () => {
+    it('returns error for missing plugin', async () => {
+      const { ops } = setup();
+      const res = await executeOp(ops, 'plugin_deactivate', { pluginId: 'nope' });
+      expect(res.success).toBe(true);
+      expect((res.data as { error: string }).error).toContain('not found');
+    });
+
+    it('deactivates an active plugin', async () => {
+      const { ops, pluginRegistry } = setup();
+      pluginRegistry._seed('d-plug', { status: 'active' });
+
+      const res = await executeOp(ops, 'plugin_deactivate', { pluginId: 'd-plug' });
+      const data = res.data as { deactivated: boolean; removedOps: number };
+      expect(data.deactivated).toBe(true);
+      expect(pluginRegistry.deactivate).toHaveBeenCalledWith('d-plug');
+    });
+
+    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] }],
+      });
+
+      await executeOp(ops, 'plugin_activate', { pluginId: 'plug-rm' });
+      expect(opSink.some((o) => o.name === 'to_remove')).toBe(true);
+
+      await executeOp(ops, 'plugin_deactivate', { pluginId: 'plug-rm' });
+      expect(opSink.some((o) => o.name === 'to_remove')).toBe(false);
+    });
+  });
+
+  describe('plugin_load', () => {
+    it('runs without crashing (loadPlugins scans filesystem)', async () => {
+      const { ops } = setup();
+      // loadPlugins scans directories — with non-existent paths it returns empty
+      const res = await executeOp(ops, 'plugin_load', { projectPath: '/nonexistent' });
+      expect(res.success).toBe(true);
+      const data = res.data as { registered: string[]; registeredCount: number };
+      expect(data.registeredCount).toBe(0);
+    });
+  });
+});