@soleri/core 9.15.0 → 9.16.7

package/src/runtime/facades/plan-facade.ts

@@ -10,6 +10,7 @@ import { createPlanningExtraOps } from '../planning-extra-ops.js';
 import { createGradingOps } from '../grading-ops.js';
 import { createChainOps } from '../chain-ops.js';
 import { PlanGradeRejectionError } from '../../planning/planner.js';
+import { matchPlaybooks } from '../../playbooks/playbook-registry.js';
 
 export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
   const { planner, vault } = runtime;
@@ -64,16 +65,73 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           // Vault search failed — proceed without enrichment
         }
 
+        // Playbook matching: inject task templates + start executor session
+        const userTasks = (params.tasks as Array<{ title: string; description: string }>) ?? [];
+        const matchResult = matchPlaybooks('BUILD', objective);
+        const playbook = matchResult.playbook;
+        const playbookTasks: Array<{ title: string; description: string }> = [];
+        let playbookSessionId: string | undefined;
+        let playbookMatch: { label: string; genericId?: string; domainId?: string } | undefined;
+
+        if (playbook) {
+          playbookMatch = {
+            label: playbook.label,
+            genericId: playbook.generic?.id,
+            domainId: playbook.domain?.id,
+          };
+
+          // Inject task templates (before-implementation first, then user tasks)
+          for (const tmpl of playbook.mergedTasks) {
+            const title = tmpl.titleTemplate.replace('{objective}', objective);
+            playbookTasks.push({ title, description: tmpl.acceptanceCriteria.join('\n') });
+          }
+
+          // Start executor session to track gate enforcement
+          if (runtime.playbookExecutor) {
+            const startResult = runtime.playbookExecutor.start(playbook);
+            playbookSessionId = startResult.sessionId;
+          }
+        }
+
+        const beforeTasks = playbookTasks.filter((_, i) => {
+          const tmpl = playbook?.mergedTasks[i];
+          return !tmpl || tmpl.order === 'before-implementation';
+        });
+        const afterTasks = playbookTasks.filter((_, i) => {
+          const tmpl = playbook?.mergedTasks[i];
+          return tmpl?.order === 'after-implementation';
+        });
+
+        const allTasks = [...beforeTasks, ...userTasks, ...afterTasks];
+
         const plan = planner.create({
           objective,
           scope: params.scope as string,
           decisions,
-          tasks: (params.tasks as Array<{ title: string; description: string }>) ?? [],
+          tasks: allTasks,
           alternatives: params.alternatives as
             | Array<{ approach: string; pros: string[]; cons: string[]; rejected_reason: string }>
             | undefined,
         });
-        return { created: true, plan, vaultEntryIds };
+
+        if (playbookMatch) plan.playbookMatch = playbookMatch;
+        if (playbookSessionId) {
+          planner.patchPlan(plan.id, { playbookSessionId });
+          plan.playbookSessionId = playbookSessionId;
+        }
+
+        return {
+          created: true,
+          plan,
+          vaultEntryIds,
+          playbook: playbook
+            ? {
+                label: playbook.label,
+                tasksInjected: playbookTasks.length,
+                sessionId: playbookSessionId ?? null,
+              }
+            : null,
+        };
       },
     },
     {
@@ -144,10 +202,43 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         status: z.enum(['pending', 'in_progress', 'completed', 'skipped', 'failed']),
       }),
       handler: async (params) => {
+        const targetStatus = params.status as
+          | 'pending'
+          | 'in_progress'
+          | 'completed'
+          | 'skipped'
+          | 'failed';
+
+        // Gate check: enforce blocking post-task gates before allowing completion
+        if (targetStatus === 'completed') {
+          const currentPlan = planner.get(params.planId as string);
+          if (currentPlan?.playbookSessionId && runtime.playbookExecutor) {
+            const session = runtime.playbookExecutor.getSession(currentPlan.playbookSessionId);
+            if (session) {
+              const blockingPostTaskGates = session.gates.filter(
+                (g) =>
+                  g.phase === 'post-task' &&
+                  (g.severity === 'blocking' || g.severity === undefined),
+              );
+              if (blockingPostTaskGates.length > 0) {
+                return {
+                  updated: false,
+                  blocked: true,
+                  reason: 'post-task gates unsatisfied',
+                  gates: blockingPostTaskGates.map((g) => ({
+                    checkType: g.checkType,
+                    requirement: g.requirement,
+                  })),
+                };
+              }
+            }
+          }
+        }
+
         const plan = planner.updateTask(
           params.planId as string,
           params.taskId as string,
-          params.status as 'pending' | 'in_progress' | 'completed' | 'skipped' | 'failed',
+          targetStatus,
         );
         const task = plan.tasks.find((t) => t.id === params.taskId);
         return { updated: true, task, plan: { id: plan.id, status: plan.status } };
@@ -162,6 +253,43 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         planId: z.string(),
       }),
       handler: async (params) => {
+        // Enforce playbook completion gates before allowing plan completion
+        const currentPlan = planner.get(params.planId as string);
+        if (currentPlan?.playbookSessionId && runtime.playbookExecutor) {
+          const completeResult = runtime.playbookExecutor.complete(
+            currentPlan.playbookSessionId,
+            {},
+          );
+          if ('error' in completeResult) {
+            // Session not found — executor may have been reset; proceed without gate check
+          } else if (!completeResult.gatesPassed && completeResult.unsatisfiedGates.length > 0) {
+            // Session is consumed after complete() — use the result's unsatisfied gate list
+            // All completion gates are blocking unless marked advisory
+            return {
+              completed: false,
+              blocked: true,
+              reason: 'completion gates unsatisfied',
+              unsatisfiedGates: completeResult.unsatisfiedGates,
+              recommendation:
+                'Satisfy the listed playbook gates before completing this plan. Pass gate results via the playbook executor if checks were completed externally.',
+            };
+          }
+        }
+
+        // Collect unenforced playbook warnings before completing
+        const playbookWarnings: string[] = [];
+        if (currentPlan?.playbookMatch) {
+          if (!currentPlan.playbookSessionId) {
+            // Playbook was matched at create_plan time but executor session was never started
+            playbookWarnings.push(
+              `WARNING: Playbook "${currentPlan.playbookMatch.label}" was matched but its gates were never evaluated — enforcement was entirely skipped.`,
+            );
+          }
+          // If session existed, the blocking gate check above already ran.
+          // Advisory gates that were unsatisfied become warnings here (non-blocking).
+          // (Future: track per-gate evaluation status for richer reporting)
+        }
+
         const plan = planner.complete(params.planId as string);
         const taskSummary = {
           completed: plan.tasks.filter((t) => t.status === 'completed').length,
@@ -169,7 +297,12 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           failed: plan.tasks.filter((t) => t.status === 'failed').length,
           total: plan.tasks.length,
         };
-        return { completed: true, plan, taskSummary };
+        return {
+          completed: true,
+          plan,
+          taskSummary,
+          ...(playbookWarnings.length > 0 ? { playbookWarnings } : {}),
+        };
       },
     },
 

package/src/runtime/facades/review-facade.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { createReviewFacadeOps } from './review-facade.js';
 import type { AgentRuntime } from '../types.js';
 
@@ -24,54 +24,6 @@ function mockRuntime(): AgentRuntime {
 // ---------------------------------------------------------------------------
 
 describe('createReviewFacadeOps', () => {
-  let ops: ReturnType<typeof createReviewFacadeOps>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    ops = createReviewFacadeOps(mockRuntime());
-  });
-
-  it('returns 5 ops matching review-ops', () => {
-    expect(ops.length).toBe(5);
-  });
-
-  it('includes all expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('vault_submit_review');
-    expect(names).toContain('vault_approve');
-    expect(names).toContain('vault_reject');
-    expect(names).toContain('vault_pending_reviews');
-    expect(names).toContain('vault_review_stats');
-  });
-
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeDefined();
-      expect(op.description).toBeDefined();
-      expect(op.auth).toBeDefined();
-      expect(typeof op.handler).toBe('function');
-    }
-  });
-
-  it('approve and reject require admin auth', () => {
-    const approveOp = ops.find((o) => o.name === 'vault_approve');
-    const rejectOp = ops.find((o) => o.name === 'vault_reject');
-    expect(approveOp!.auth).toBe('admin');
-    expect(rejectOp!.auth).toBe('admin');
-  });
-
-  it('submit uses write auth', () => {
-    const op = ops.find((o) => o.name === 'vault_submit_review');
-    expect(op!.auth).toBe('write');
-  });
-
-  it('pending_reviews and review_stats use read auth', () => {
-    const pending = ops.find((o) => o.name === 'vault_pending_reviews');
-    const stats = ops.find((o) => o.name === 'vault_review_stats');
-    expect(pending!.auth).toBe('read');
-    expect(stats!.auth).toBe('read');
-  });
-
   it('handlers are callable', async () => {
     const rt = mockRuntime();
     const rtOps = createReviewFacadeOps(rt);

package/src/runtime/facades/sync-facade.test.ts

@@ -64,50 +64,33 @@ describe('createSyncFacadeOps', () => {
     ops = createSyncFacadeOps(mockRuntime());
   });
 
-  it('returns 8 ops matching sync-ops', () => {
-    expect(ops.length).toBe(8);
+  describe('vault_git_push', () => {
+    it('pushes vault entries and returns pushed count', async () => {
+      const op = ops.find((o) => o.name === 'vault_git_push')!;
+      const result = (await op.handler({ remote: 'origin', branch: 'main' })) as {
+        pushed: number;
+      };
+      expect(result.pushed).toBe(5);
+    });
   });
 
-  it('includes all expected op names', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('vault_git_push');
-    expect(names).toContain('vault_git_pull');
-    expect(names).toContain('vault_git_sync');
-    expect(names).toContain('obsidian_export');
-    expect(names).toContain('obsidian_import');
-    expect(names).toContain('obsidian_sync');
-    expect(names).toContain('vault_export_pack');
-    expect(names).toContain('vault_import_pack');
+  describe('vault_git_pull', () => {
+    it('pulls from remote and returns imported count', async () => {
+      const op = ops.find((o) => o.name === 'vault_git_pull')!;
+      const result = (await op.handler({ remote: 'origin', branch: 'main' })) as {
+        imported: number;
+        conflicts: number;
+      };
+      expect(result.imported).toBe(3);
+      expect(result.conflicts).toBe(0);
+    });
   });
 
-  it('all ops have required fields', () => {
-    for (const op of ops) {
-      expect(op.name).toBeDefined();
-      expect(op.description).toBeDefined();
-      expect(op.auth).toBeDefined();
-      expect(typeof op.handler).toBe('function');
-    }
-  });
-
-  it('git ops use write auth', () => {
-    const gitOps = ops.filter((o) => o.name.startsWith('vault_git_'));
-    for (const op of gitOps) {
-      expect(op.auth).toBe('write');
-    }
-  });
-
-  it('obsidian_export uses read auth', () => {
-    const op = ops.find((o) => o.name === 'obsidian_export');
-    expect(op!.auth).toBe('read');
-  });
-
-  it('vault_export_pack uses read auth', () => {
-    const op = ops.find((o) => o.name === 'vault_export_pack');
-    expect(op!.auth).toBe('read');
-  });
-
-  it('vault_import_pack uses write auth', () => {
-    const op = ops.find((o) => o.name === 'vault_import_pack');
-    expect(op!.auth).toBe('write');
+  describe('obsidian_export', () => {
+    it('exports entries and returns exported count', async () => {
+      const op = ops.find((o) => o.name === 'obsidian_export')!;
+      const result = (await op.handler({ vaultPath: '/tmp/obsidian' })) as { exported: number };
+      expect(result.exported).toBe(10);
+    });
   });
 });

package/src/runtime/facades/tier-facade.test.ts

@@ -1,6 +1,5 @@
 /**
  * Colocated contract tests for tier-facade.ts.
- * Verifies the facade wrapper delegates to tier-ops.
  */
 
 import { describe, it, expect, vi } from 'vitest';
@@ -12,36 +11,45 @@ function makeRuntime(): AgentRuntime {
     vaultManager: {
       open: vi.fn(),
       disconnect: vi.fn().mockReturnValue(true),
-      listTiers: vi.fn().mockReturnValue([]),
-      search: vi.fn().mockReturnValue([]),
+      listTiers: vi.fn().mockReturnValue([{ name: 'agent', count: 10 }]),
+      search: vi.fn().mockReturnValue([{ entry: { id: 'e1' }, score: 0.9 }]),
       connect: vi.fn(),
       disconnectNamed: vi.fn().mockReturnValue(true),
-      listConnected: vi.fn().mockReturnValue([]),
+      listConnected: vi.fn().mockReturnValue([{ name: 'team-vault', priority: 2 }]),
     },
     config: { agentId: 'test-agent' },
   } as unknown as AgentRuntime;
 }
 
 describe('tier-facade', () => {
-  it('returns all 7 tier/source ops', () => {
-    const ops = createTierFacadeOps(makeRuntime());
-    expect(ops).toHaveLength(7);
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('vault_connect');
-    expect(names).toContain('vault_disconnect');
-    expect(names).toContain('vault_tiers');
-    expect(names).toContain('vault_search_all');
-    expect(names).toContain('vault_connect_source');
-    expect(names).toContain('vault_disconnect_source');
-    expect(names).toContain('vault_list_sources');
+  describe('vault_tiers', () => {
+    it('returns all vault tiers', async () => {
+      const ops = createTierFacadeOps(makeRuntime());
+      const op = ops.find((o) => o.name === 'vault_tiers')!;
+      const result = (await op.handler({})) as { tiers: unknown[] };
+      expect(result.tiers).toHaveLength(1);
+    });
   });
 
-  it('every op has name, handler, and auth', () => {
-    const ops = createTierFacadeOps(makeRuntime());
-    for (const op of ops) {
-      expect(typeof op.name).toBe('string');
-      expect(typeof op.handler).toBe('function');
-      expect(typeof op.auth).toBe('string');
-    }
+  describe('vault_search_all', () => {
+    it('returns search results with count', async () => {
+      const ops = createTierFacadeOps(makeRuntime());
+      const op = ops.find((o) => o.name === 'vault_search_all')!;
+      const result = (await op.handler({ query: 'test', limit: 5 })) as {
+        results: unknown[];
+        count: number;
+      };
+      expect(result.count).toBe(1);
+      expect(result.results).toHaveLength(1);
+    });
+  });
+
+  describe('vault_list_sources', () => {
+    it('returns connected sources', async () => {
+      const ops = createTierFacadeOps(makeRuntime());
+      const op = ops.find((o) => o.name === 'vault_list_sources')!;
+      const result = (await op.handler({})) as { sources: unknown[] };
+      expect(result.sources).toHaveLength(1);
+    });
   });
 });

package/src/runtime/facades/vault-facade.test.ts

@@ -164,47 +164,6 @@ describe('vault-facade', () => {
     ops = captureOps(createVaultFacadeOps(runtime));
   });
 
-  // ─── Registration ─────────────────────────────────────────────────
-
-  it('registers ops from all groups', () => {
-    // The facade includes inline ops + satellite ops from 5 modules.
-    // We check the inline ops explicitly, satellite ops just need to exist.
-    expect(ops.size).toBeGreaterThan(20);
-  });
-
-  it('includes core inline op names', () => {
-    const coreOps = [
-      'search',
-      'load_entries',
-      'vault_stats',
-      'list_all',
-      'export',
-      'capture_enriched',
-    ];
-    for (const name of coreOps) {
-      expect(ops.has(name), `missing op: ${name}`).toBe(true);
-    }
-  });
-
-  it('includes satellite ops', () => {
-    // Spot-check a few ops from each satellite module
-    expect(ops.has('vault_get')).toBe(true); // vault-extra-ops
-    expect(ops.has('capture_knowledge')).toBe(true); // capture-ops
-    expect(ops.has('search_intelligent')).toBe(true); // capture-ops
-    // link_entries moved to vault-linking-facade
-  });
-
-  // ─── Auth levels ─────────────────────────────────────────────────
-
-  it('has correct auth levels for inline ops', () => {
-    expect(ops.get('search')!.auth).toBe('read');
-    expect(ops.get('load_entries')!.auth).toBe('read');
-    expect(ops.get('vault_stats')!.auth).toBe('read');
-    expect(ops.get('list_all')!.auth).toBe('read');
-    expect(ops.get('export')!.auth).toBe('read');
-    expect(ops.get('capture_enriched')!.auth).toBe('write');
-  });
-
   // ─── search ────────────────────────────────────────────────────────
 
   describe('search', () => {

package/src/runtime/facades/vault-facade.ts

@@ -66,13 +66,36 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     {
       name: 'load_entries',
       description:
-        'Two-pass retrieval — Pass 2: Load full entries by IDs (from a previous scan search).',
+        'Two-pass retrieval — Pass 2: Load full entries by IDs (from a previous scan search). ' +
+        'Alternative: pass domain + limit to list entries by domain without a prior scan.',
       auth: 'read',
       schema: z.object({
-        ids: z.array(z.string()).min(1).describe('Entry IDs from a previous scan search'),
+        ids: z
+          .array(z.string())
+          .min(1)
+          .optional()
+          .describe('Entry IDs from a previous scan search'),
+        domain: z.string().optional().describe('Alternative to ids: filter entries by domain'),
+        limit: z
+          .number()
+          .optional()
+          .default(20)
+          .describe('Max entries when using domain filter (default: 20)'),
       }),
       handler: async (params) => {
-        return brain.loadEntries(params.ids as string[]);
+        const ids = params.ids as string[] | undefined;
+        if (ids && ids.length > 0) {
+          return brain.loadEntries(ids);
+        }
+        const domain = params.domain as string | undefined;
+        if (domain) {
+          const entries = vault.list({ domain, limit: (params.limit as number) ?? 20 });
+          return { entries, total: entries.length };
+        }
+        throw new Error(
+          'Provide ids (from search_intelligent scan) or domain to filter entries. ' +
+            'Example: { ids: ["entry-id-1"] } or { domain: "testing", limit: 10 }',
+        );
       },
     },
     {

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

@@ -52,33 +52,6 @@ describe('createGradingOps', () => {
     return op;
   }
 
-  it('returns 5 ops', () => {
-    runtime = makeMockRuntime();
-    ops = createGradingOps(runtime);
-    expect(ops).toHaveLength(5);
-  });
-
-  it('has correct op names', () => {
-    runtime = makeMockRuntime();
-    ops = createGradingOps(runtime);
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'plan_grade',
-      'plan_check_history',
-      'plan_latest_check',
-      'plan_meets_grade',
-      'plan_auto_improve',
-    ]);
-  });
-
-  it('all ops have read auth', () => {
-    runtime = makeMockRuntime();
-    ops = createGradingOps(runtime);
-    for (const op of ops) {
-      expect(op.auth).toBe('read');
-    }
-  });
-
   describe('plan_grade', () => {
     it('delegates to planner.grade', async () => {
       runtime = makeMockRuntime();

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

@@ -28,25 +28,6 @@ describe('createIntakeOps', () => {
     return op;
   }
 
-  it('returns 7 ops', () => {
-    const ops = createIntakeOps(makeMockPipeline() as never);
-    expect(ops).toHaveLength(7);
-  });
-
-  it('has all expected op names', () => {
-    const ops = createIntakeOps(makeMockPipeline() as never);
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'intake_ingest_book',
-      'intake_process',
-      'intake_status',
-      'intake_preview',
-      'ingest_url',
-      'ingest_text',
-      'ingest_batch',
-    ]);
-  });
-
   describe('when pipeline is null', () => {
     it('intake_ingest_book returns error', async () => {
       const ops = createIntakeOps(null);

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

@@ -50,29 +50,6 @@ describe('createLoopOps', () => {
     return op;
   }
 
-  it('returns 9 ops', () => {
-    runtime = makeMockRuntime();
-    ops = createLoopOps(runtime);
-    expect(ops).toHaveLength(9);
-  });
-
-  it('has all expected op names', () => {
-    runtime = makeMockRuntime();
-    ops = createLoopOps(runtime);
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'loop_start',
-      'loop_iterate',
-      'loop_iterate_gate',
-      'loop_status',
-      'loop_cancel',
-      'loop_history',
-      'loop_is_active',
-      'loop_complete',
-      'loop_anomaly_check',
-    ]);
-  });
-
   describe('loop_start', () => {
     it('starts a loop with defaults for custom mode', async () => {
       runtime = makeMockRuntime();
@@ -125,24 +102,6 @@ describe('createLoopOps', () => {
     });
   });
 
-  describe('loop_iterate_gate', () => {
-    it('delegates to loop.iterateWithGate', async () => {
-      runtime = makeMockRuntime();
-      ops = createLoopOps(runtime);
-      const result = await findOp('loop_iterate_gate').handler({
-        lastOutput: 'some output',
-        knowledge: { items: ['learned something'] },
-        durationMs: 5000,
-      });
-      expect(runtime.loop.iterateWithGate).toHaveBeenCalledWith(
-        'some output',
-        { items: ['learned something'] },
-        5000,
-      );
-      expect(result).toEqual({ decision: 'block', reason: 'continue' });
-    });
-  });
-
   describe('loop_status', () => {
     it('returns active loop status', async () => {
       runtime = makeMockRuntime();
@@ -187,13 +146,6 @@ describe('createLoopOps', () => {
   });
 
   describe('loop_is_active', () => {
-    it('returns active true', async () => {
-      runtime = makeMockRuntime();
-      ops = createLoopOps(runtime);
-      const result = (await findOp('loop_is_active').handler({})) as Record<string, unknown>;
-      expect(result.active).toBe(true);
-    });
-
     it('returns active false when no loop', async () => {
       runtime = makeMockRuntime();
       (runtime.loop.isActive as ReturnType<typeof vi.fn>).mockReturnValue(false);

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

@@ -40,20 +40,6 @@ describe('createMemoryCrossProjectOps', () => {
     return op;
   }
 
-  it('returns 3 ops', () => {
-    ops = createMemoryCrossProjectOps(makeMockRuntime());
-    expect(ops).toHaveLength(3);
-  });
-
-  it('has correct op names', () => {
-    ops = createMemoryCrossProjectOps(makeMockRuntime());
-    expect(ops.map((o) => o.name)).toEqual([
-      'memory_promote_to_global',
-      'memory_configure',
-      'memory_cross_project_search',
-    ]);
-  });
-
   describe('memory_promote_to_global', () => {
     it('promotes entry by adding _global tag', async () => {
       const runtime = makeMockRuntime();

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

@@ -73,10 +73,6 @@ describe('createMemoryExtraOps', () => {
     ops = createMemoryExtraOps(rt);
   });
 
-  it('returns all 18 ops', () => {
-    expect(ops.length).toBe(18);
-  });
-
   // ─── memory_delete ────────────────────────────────────────────
 
   describe('memory_delete', () => {
@@ -249,8 +245,8 @@ describe('createMemoryExtraOps', () => {
     it('returns results without archived by default', async () => {
       const op = findOp(ops, 'session_search');
       vi.mocked(rt.vault.searchMemories).mockReturnValue([{ id: 's1' }] as never);
-      const result = (await op.handler({ query: 'test', limit: 10 })) as Record<string, unknown>;
-      expect(result.results).toBeDefined();
+      const result = (await op.handler({ query: 'test', limit: 10 })) as { results: unknown[] };
+      expect(result.results).toHaveLength(1); // mock returns exactly one session result
     });
 
     it('includes archived when includeArchived is true', async () => {
@@ -264,8 +260,8 @@ describe('createMemoryExtraOps', () => {
         includeArchived: true,
         limit: 10,
       })) as Record<string, unknown>;
-      expect(result.active).toBeDefined();
-      expect(result.archived).toBeDefined();
+      expect((result as { active: unknown[] }).active).toHaveLength(1); // mock searchMemories returns 1
+      expect((result as { archived: unknown[] }).archived).toHaveLength(1); // mock provider.all returns 1
     });
   });