@soleri/core 9.0.3 → 9.2.0

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

@@ -0,0 +1,433 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createCaptureOps } from './capture-ops.js';
+import type { AgentRuntime } from './types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+// ─── Mock External Modules ─────────────────────────────────────────────
+
+vi.mock('../vault/scope-detector.js', () => ({
+  detectScope: vi.fn(() => ({
+    tier: 'project',
+    confidence: 'HIGH',
+    reason: 'Content indicates project scope',
+    signals: [],
+  })),
+}));
+
+vi.mock('../vault/vault-markdown-sync.js', () => ({
+  syncEntryToMarkdown: vi.fn(() => Promise.resolve()),
+}));
+
+vi.mock('../paths.js', () => ({
+  agentKnowledgeDir: vi.fn(() => '/mock/knowledge'),
+}));
+
+// ─── Mock Runtime Factory ──────────────────────────────────────────────
+
+function createMockRuntime(): AgentRuntime {
+  return {
+    config: { agentId: 'test-agent' },
+    vault: {
+      isAutoLinkEnabled: vi.fn(() => false),
+      searchMemories: vi.fn(() => []),
+    },
+    brain: {
+      enrichAndCapture: vi.fn(() => ({
+        blocked: false,
+        entry: { id: 'captured-1' },
+      })),
+      intelligentSearch: vi.fn(async () => [
+        { id: 'r1', title: 'Result 1', score: 0.8 },
+      ]),
+      recordFeedback: vi.fn(),
+    },
+    governance: {
+      evaluateCapture: vi.fn(() => ({ action: 'capture' })),
+      propose: vi.fn(),
+    },
+    linkManager: {
+      suggestLinks: vi.fn(() => []),
+      addLink: vi.fn(),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op not found: ${name}`);
+  return op;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────
+
+describe('createCaptureOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    runtime = createMockRuntime();
+    ops = createCaptureOps(runtime);
+  });
+
+  it('returns 4 ops', () => {
+    expect(ops).toHaveLength(4);
+  });
+
+  it('all ops have required fields', () => {
+    for (const op of ops) {
+      expect(op.name).toBeTruthy();
+      expect(op.handler).toBeDefined();
+      expect(['read', 'write']).toContain(op.auth);
+    }
+  });
+
+  describe('capture_knowledge', () => {
+    it('captures a single entry with governance approval', async () => {
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          {
+            type: 'pattern',
+            domain: 'testing',
+            title: 'Test Pattern',
+            description: 'A useful pattern',
+            tags: ['test'],
+          },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(1);
+      expect(result.rejected).toBe(0);
+      expect(result.proposed).toBe(0);
+    });
+
+    it('captures multiple entries', async () => {
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+          { type: 'rule', domain: 'b', title: 'B', description: 'b', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(2);
+    });
+
+    it('uses manual tier override when provided', async () => {
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        tier: 'team',
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(1);
+      const results = result.results as Array<Record<string, unknown>>;
+      expect((results[0].scope as Record<string, unknown>).tier).toBe('team');
+      expect((results[0].scope as Record<string, unknown>).confidence).toBe('MANUAL');
+    });
+
+    it('handles governance proposal action', async () => {
+      vi.mocked(runtime.governance.evaluateCapture).mockReturnValue({
+        action: 'propose',
+        reason: 'Requires review',
+      } as unknown);
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.proposed).toBe(1);
+      expect(result.captured).toBe(0);
+      expect(runtime.governance.propose).toHaveBeenCalled();
+    });
+
+    it('handles governance reject action', async () => {
+      vi.mocked(runtime.governance.evaluateCapture).mockReturnValue({
+        action: 'reject',
+        reason: 'Not allowed',
+      } as unknown);
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.rejected).toBe(1);
+    });
+
+    it('detects duplicates from brain.enrichAndCapture', async () => {
+      vi.mocked(runtime.brain.enrichAndCapture).mockReturnValue({
+        blocked: true,
+        duplicate: { id: 'existing-1' },
+      } as unknown);
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.duplicated).toBe(1);
+      expect(result.captured).toBe(0);
+    });
+
+    it('handles enrichAndCapture errors gracefully', async () => {
+      vi.mocked(runtime.brain.enrichAndCapture).mockImplementation(() => {
+        throw new Error('Capture failed');
+      });
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.rejected).toBe(1);
+      const results = result.results as Array<Record<string, unknown>>;
+      expect(results[0].action).toBe('error');
+    });
+
+    it('auto-links when vault has auto-link enabled', async () => {
+      vi.mocked(runtime.vault.isAutoLinkEnabled).mockReturnValue(true);
+      vi.mocked(runtime.linkManager.suggestLinks).mockReturnValue([
+        { entryId: 'related-1', title: 'Related', suggestedType: 'related', score: 0.9 },
+      ]);
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      expect(result.autoLinkedCount).toBe(1);
+      expect(result.suggestedLinks).toBeDefined();
+    });
+
+    it('maps extended types correctly', async () => {
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'workflow', domain: 'a', title: 'A', description: 'a', tags: [] },
+          { type: 'principle', domain: 'b', title: 'B', description: 'b', tags: [] },
+        ],
+      })) as Record<string, unknown>;
+      // 'workflow' and 'principle' map to 'rule' — should still capture
+      expect(result.captured).toBe(2);
+    });
+
+    it('uses per-entry tier override over top-level', async () => {
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        tier: 'team',
+        entries: [
+          { type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [], tier: 'agent' },
+        ],
+      })) as Record<string, unknown>;
+      const results = result.results as Array<Record<string, unknown>>;
+      expect((results[0].scope as Record<string, unknown>).tier).toBe('agent');
+    });
+  });
+
+  describe('capture_quick', () => {
+    it('captures single entry with minimal fields', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick Pattern',
+        description: 'A quick capture',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(true);
+      expect(result.id).toBeDefined();
+      expect((result.governance as Record<string, unknown>).action).toBe('capture');
+    });
+
+    it('uses auto-detected scope when no tier provided', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick Pattern',
+        description: 'A quick capture',
+      })) as Record<string, unknown>;
+      expect((result.scope as Record<string, unknown>).tier).toBe('project');
+      expect((result.scope as Record<string, unknown>).confidence).toBe('HIGH');
+    });
+
+    it('uses manual tier when provided', async () => {
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick Pattern',
+        description: 'A quick capture',
+        tier: 'agent',
+      })) as Record<string, unknown>;
+      expect((result.scope as Record<string, unknown>).tier).toBe('agent');
+      expect((result.scope as Record<string, unknown>).confidence).toBe('MANUAL');
+    });
+
+    it('handles governance proposal', async () => {
+      vi.mocked(runtime.governance.evaluateCapture).mockReturnValue({
+        action: 'propose',
+        reason: 'Needs review',
+      } as unknown);
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick',
+        description: 'test',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(false);
+      expect((result.governance as Record<string, unknown>).action).toBe('propose');
+    });
+
+    it('handles governance rejection', async () => {
+      vi.mocked(runtime.governance.evaluateCapture).mockReturnValue({
+        action: 'reject',
+        reason: 'Blocked',
+      } as unknown);
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick',
+        description: 'test',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(false);
+      expect((result.governance as Record<string, unknown>).action).toBe('reject');
+    });
+
+    it('handles duplicate detection', async () => {
+      vi.mocked(runtime.brain.enrichAndCapture).mockReturnValue({
+        blocked: true,
+        duplicate: { id: 'existing-2' },
+      } as unknown);
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Dup',
+        description: 'duplicate',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(false);
+      expect((result.governance as Record<string, unknown>).action).toBe('duplicate');
+    });
+
+    it('handles enrichAndCapture errors', async () => {
+      vi.mocked(runtime.brain.enrichAndCapture).mockImplementation(() => {
+        throw new Error('Brain down');
+      });
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Fail',
+        description: 'fails',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(false);
+      expect((result.governance as Record<string, unknown>).action).toBe('error');
+    });
+
+    it('handles governance evaluation errors', async () => {
+      vi.mocked(runtime.governance.evaluateCapture).mockImplementation(() => {
+        throw new Error('Gov down');
+      });
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Fail',
+        description: 'fails',
+      })) as Record<string, unknown>;
+      expect(result.captured).toBe(false);
+      expect((result.governance as Record<string, unknown>).action).toBe('error');
+    });
+  });
+
+  describe('search_intelligent', () => {
+    it('searches vault via brain intelligent search', async () => {
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'auth patterns',
+      })) as Array<Record<string, unknown>>;
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0].source).toBe('vault');
+    });
+
+    it('includes memories when flag is set', async () => {
+      vi.mocked(runtime.vault.searchMemories).mockReturnValue([
+        { id: 'm1', summary: 'Auth discussion', score: 0.5 },
+      ] as unknown);
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'auth',
+        includeMemories: true,
+      })) as Array<Record<string, unknown>>;
+      expect(result.some((r) => r.source === 'memory')).toBe(true);
+    });
+
+    it('handles search failure gracefully', async () => {
+      vi.mocked(runtime.brain.intelligentSearch).mockRejectedValue(new Error('Search down'));
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'anything',
+      })) as Array<Record<string, unknown>>;
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(0);
+    });
+
+    it('respects limit parameter', async () => {
+      const manyResults = Array.from({ length: 30 }, (_, i) => ({
+        id: `r${i}`,
+        score: 1 - i * 0.01,
+      }));
+      vi.mocked(runtime.brain.intelligentSearch).mockResolvedValue(manyResults as unknown);
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'test',
+        limit: 5,
+      })) as Array<Record<string, unknown>>;
+      expect(result.length).toBeLessThanOrEqual(5);
+    });
+
+    it('sorts results by score descending', async () => {
+      vi.mocked(runtime.brain.intelligentSearch).mockResolvedValue([
+        { id: 'low', score: 0.3 },
+        { id: 'high', score: 0.9 },
+      ] as unknown);
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'test',
+      })) as Array<Record<string, unknown>>;
+      expect((result[0].score as number) >= (result[1].score as number)).toBe(true);
+    });
+  });
+
+  describe('search_feedback', () => {
+    it('records positive feedback', async () => {
+      const result = (await findOp(ops, 'search_feedback').handler({
+        query: 'auth patterns',
+        entryId: 'entry-1',
+        helpful: true,
+      })) as Record<string, unknown>;
+      expect(result.recorded).toBe(true);
+      expect(result.action).toBe('accepted');
+      expect(runtime.brain.recordFeedback).toHaveBeenCalledWith(
+        'auth patterns',
+        'entry-1',
+        'accepted',
+      );
+    });
+
+    it('records negative feedback', async () => {
+      const result = (await findOp(ops, 'search_feedback').handler({
+        query: 'auth',
+        entryId: 'entry-2',
+        helpful: false,
+      })) as Record<string, unknown>;
+      expect(result.recorded).toBe(true);
+      expect(result.action).toBe('dismissed');
+    });
+
+    it('handles feedback recording errors', async () => {
+      vi.mocked(runtime.brain.recordFeedback).mockImplementation(() => {
+        throw new Error('DB error');
+      });
+      const result = (await findOp(ops, 'search_feedback').handler({
+        query: 'auth',
+        entryId: 'entry-1',
+        helpful: true,
+      })) as Record<string, unknown>;
+      expect(result.recorded).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('includes optional context', async () => {
+      const result = (await findOp(ops, 'search_feedback').handler({
+        query: 'auth',
+        entryId: 'entry-1',
+        helpful: true,
+        context: 'Used for login flow',
+      })) as Record<string, unknown>;
+      expect(result.context).toBe('Used for login flow');
+    });
+  });
+});

package/src/runtime/capture-ops.ts

@@ -10,6 +10,9 @@ import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import { detectScope } from '../vault/scope-detector.js';
 import type { ScopeTier, ScopeDetectionResult } from '../vault/scope-detector.js';
+import { syncEntryToMarkdown } from '../vault/vault-markdown-sync.js';
+import { agentKnowledgeDir } from '../paths.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
 
 /**
  * Create the 4 intelligent capture operations for an agent runtime.
@@ -17,7 +20,7 @@ import type { ScopeTier, ScopeDetectionResult } from '../vault/scope-detector.js
  * Groups: capture (2), search (2).
  */
 export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, governance } = runtime;
+  const { vault, brain, governance, linkManager, config } = runtime;
 
   return [
     // ─── Capture ──────────────────────────────────────────────────
@@ -168,6 +171,25 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                         'Low confidence scope detection — consider reviewing tier assignment';
                     }
                     results.push(result);
+                    // Fire-and-forget markdown sync
+                    fireAndForgetSync(
+                      {
+                        id: entryId,
+                        type: mappedType as IntelligenceEntry['type'],
+                        domain: entry.domain,
+                        title: entry.title,
+                        severity: mappedSeverity,
+                        description: entry.description,
+                        tags: entry.tags ?? [],
+                        context: entry.context,
+                        example: entry.example,
+                        counterExample: entry.counterExample,
+                        why: entry.why,
+                        tier: finalTier,
+                        origin: 'user',
+                      },
+                      config.agentId,
+                    );
                   }
                 } catch (err) {
                   rejected++;
@@ -241,14 +263,11 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
           autoLinked: boolean;
         }> = [];
         try {
-          if (captured > 0) {
-            const { LinkManager } = await import('../vault/linking.js');
-            const lm = new LinkManager(vault.getProvider());
-
-            // Process ALL captured entries, not just the first
+          if (captured > 0 && vault.isAutoLinkEnabled()) {
+            // Use runtime's linkManager (respects vault auto-link setting)
             const capturedEntries = results.filter((r) => r.action === 'capture');
             for (const capturedEntry of capturedEntries) {
-              const suggestions = lm.suggestLinks(capturedEntry.id, AUTO_LINK_MAX + 2);
+              const suggestions = linkManager.suggestLinks(capturedEntry.id, AUTO_LINK_MAX + 2);
               const filtered = suggestions.filter(
                 (s) => s.entryId !== capturedEntry.id && !s.entryId.endsWith(capturedEntry.id),
               );
@@ -258,7 +277,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                 const aboveThreshold = s.score >= AUTO_LINK_THRESHOLD;
                 const canAutoLink = aboveThreshold && linkedForThisEntry < AUTO_LINK_MAX;
                 if (canAutoLink) {
-                  lm.addLink(capturedEntry.id, s.entryId, s.suggestedType);
+                  linkManager.addLink(capturedEntry.id, s.entryId, s.suggestedType);
                   linkedForThisEntry++;
                   autoLinkedCount++;
                 }
@@ -384,6 +403,21 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                   result.reviewNote =
                     'Low confidence scope detection — consider reviewing tier assignment';
                 }
+                // Fire-and-forget markdown sync
+                fireAndForgetSync(
+                  {
+                    id,
+                    type: mappedType as IntelligenceEntry['type'],
+                    domain,
+                    title,
+                    severity: mapSeverity(mappedSeverity),
+                    description,
+                    tags,
+                    tier: finalTier,
+                    origin: 'user',
+                  },
+                  config.agentId,
+                );
                 return result;
               } catch (err) {
                 return {
@@ -565,3 +599,11 @@ function mapType(type: string): 'pattern' | 'anti-pattern' | 'rule' | 'playbook'
       return 'rule';
   }
 }
+
+/** Fire-and-forget markdown sync — never blocks capture, logs errors silently. */
+function fireAndForgetSync(entry: IntelligenceEntry, agentId: string): void {
+  const knowledgeDir = agentKnowledgeDir(agentId);
+  syncEntryToMarkdown(entry, knowledgeDir).catch(() => {
+    /* non-blocking — markdown sync is best-effort */
+  });
+}

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

@@ -0,0 +1,149 @@
+/**
+ * Colocated unit tests for chain-ops.ts — mock-based, no real DB.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createChainOps } from './chain-ops.js';
+import type { AgentRuntime } from './types.js';
+import { captureOps } from '../engine/test-helpers.js';
+
+function mockRuntime(): AgentRuntime {
+  return {
+    chainRunner: {
+      execute: vi.fn().mockResolvedValue({ id: 'inst-1', status: 'completed' }),
+      getInstance: vi.fn().mockReturnValue(null),
+      resume: vi.fn().mockResolvedValue({ id: 'inst-1', status: 'completed' }),
+      list: vi.fn().mockReturnValue([]),
+      approve: vi.fn().mockResolvedValue({ id: 'inst-1', status: 'running' }),
+    },
+  } as unknown as AgentRuntime;
+}
+
+const VALID_CHAIN = {
+  id: 'c1',
+  steps: [{ id: 's1', op: 'some_op' }],
+};
+
+describe('createChainOps', () => {
+  it('returns exactly 5 ops', () => {
+    const ops = createChainOps(mockRuntime());
+    expect(ops).toHaveLength(5);
+    expect(ops.map((o) => o.name)).toEqual([
+      'chain_execute',
+      'chain_status',
+      'chain_resume',
+      'chain_list',
+      'chain_step_approve',
+    ]);
+  });
+
+  it('assigns correct auth levels', () => {
+    const ops = captureOps(createChainOps(mockRuntime()));
+    expect(ops.get('chain_execute')!.auth).toBe('write');
+    expect(ops.get('chain_status')!.auth).toBe('read');
+    expect(ops.get('chain_resume')!.auth).toBe('write');
+    expect(ops.get('chain_list')!.auth).toBe('read');
+    expect(ops.get('chain_step_approve')!.auth).toBe('write');
+  });
+
+  describe('chain_execute', () => {
+    it('calls chainRunner.execute with chain def and input', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      await ops.get('chain_execute')!.handler({ chain: VALID_CHAIN, input: { key: 'val' } });
+      expect(rt.chainRunner.execute).toHaveBeenCalledOnce();
+      const args = (rt.chainRunner.execute as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(args[0]).toEqual(VALID_CHAIN);
+      expect(args[1]).toEqual({ key: 'val' });
+    });
+
+    it('passes startFromStep when provided', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      await ops.get('chain_execute')!.handler({
+        chain: VALID_CHAIN,
+        input: {},
+        startFromStep: 's1',
+      });
+      const args = (rt.chainRunner.execute as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(args[4]).toBe('s1');
+    });
+  });
+
+  describe('chain_status', () => {
+    it('returns error when instance not found', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      const result = (await ops.get('chain_status')!.handler({ instanceId: 'nope' })) as {
+        error: string;
+      };
+      expect(result.error).toContain('nope');
+    });
+
+    it('returns instance when found', async () => {
+      const rt = mockRuntime();
+      const instance = { id: 'inst-1', status: 'running' };
+      (rt.chainRunner.getInstance as ReturnType<typeof vi.fn>).mockReturnValue(instance);
+      const ops = captureOps(createChainOps(rt));
+      const result = await ops.get('chain_status')!.handler({ instanceId: 'inst-1' });
+      expect(result).toBe(instance);
+    });
+  });
+
+  describe('chain_resume', () => {
+    it('delegates to chainRunner.resume', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      await ops.get('chain_resume')!.handler({ instanceId: 'inst-1', chain: VALID_CHAIN });
+      expect(rt.chainRunner.resume).toHaveBeenCalledWith('inst-1', VALID_CHAIN, expect.any(Function));
+    });
+  });
+
+  describe('chain_list', () => {
+    it('passes limit to chainRunner.list', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      await ops.get('chain_list')!.handler({ limit: 5 });
+      expect(rt.chainRunner.list).toHaveBeenCalledWith(5);
+    });
+  });
+
+  describe('chain_step_approve', () => {
+    it('delegates to chainRunner.approve', async () => {
+      const rt = mockRuntime();
+      const ops = captureOps(createChainOps(rt));
+      await ops.get('chain_step_approve')!.handler({ instanceId: 'inst-1', chain: VALID_CHAIN });
+      expect(rt.chainRunner.approve).toHaveBeenCalledWith('inst-1', VALID_CHAIN, expect.any(Function));
+    });
+  });
+
+  describe('_setAllOps wiring', () => {
+    it('exposes _setAllOps for cross-facade dispatch', () => {
+      const ops = createChainOps(mockRuntime());
+      const extended = ops as typeof ops & { _setAllOps: (o: unknown[]) => void };
+      expect(typeof extended._setAllOps).toBe('function');
+    });
+
+    it('dispatch routes to the correct op after _setAllOps', async () => {
+      const rt = mockRuntime();
+      const ops = createChainOps(rt);
+      const fakeOps = [
+        {
+          name: 'some_op',
+          handler: vi.fn().mockResolvedValue({ ok: true }),
+          auth: 'read' as const,
+          description: 'test',
+        },
+      ];
+      (ops as typeof ops & { _setAllOps: (o: typeof fakeOps) => void })._setAllOps(fakeOps);
+
+      // Execute chain — the dispatch should be able to find 'some_op'
+      await ops.find((o) => o.name === 'chain_execute')!.handler({
+        chain: VALID_CHAIN,
+        input: {},
+      });
+      // The dispatch function was passed to chainRunner.execute; verify it was called
+      expect(rt.chainRunner.execute).toHaveBeenCalledOnce();
+    });
+  });
+});