@soleri/core 9.14.4 → 9.16.7

package/src/runtime/facades/chat-service-ops.test.ts

@@ -121,30 +121,6 @@ describe('chat-service-ops', () => {
     ops = createChatServiceOps(state);
   });
 
-  it('exports 18 service ops', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'chat_cancel_create',
-      'chat_cancel_stop',
-      'chat_cancel_status',
-      'chat_update_init',
-      'chat_update_request',
-      'chat_update_confirm',
-      'chat_file_detect_intent',
-      'chat_file_build_content',
-      'chat_file_cleanup',
-      'chat_notify_init',
-      'chat_notify_start',
-      'chat_notify_stop',
-      'chat_notify_poll',
-      'chat_notify_status',
-      'chat_browser_init',
-      'chat_browser_acquire',
-      'chat_browser_release',
-      'chat_browser_status',
-    ]);
-  });
-
   // ─── Task Cancellation ─────────────────────────────────────────
 
   describe('chat_cancel_create', () => {

package/src/runtime/facades/chat-session-ops.test.ts

@@ -68,18 +68,6 @@ describe('chat-session-ops', () => {
     ops = createChatSessionOps(state);
   });
 
-  it('exports 6 session ops', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'chat_session_init',
-      'chat_session_get',
-      'chat_session_append',
-      'chat_session_clear',
-      'chat_session_delete',
-      'chat_session_list',
-    ]);
-  });
-
   describe('chat_session_init', () => {
     it('initializes session manager and returns status', async () => {
       const op = findOp(ops, 'chat_session_init');

package/src/runtime/facades/chat-transport-ops.test.ts

@@ -111,29 +111,6 @@ describe('chat-transport-ops', () => {
     ops = createChatTransportOps(state);
   });
 
-  it('exports 17 transport ops', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toEqual([
-      'chat_chunk_response',
-      'chat_auth_init',
-      'chat_auth_check',
-      'chat_auth_authenticate',
-      'chat_auth_revoke',
-      'chat_auth_status',
-      'chat_bridge_init',
-      'chat_bridge_register',
-      'chat_bridge_list',
-      'chat_bridge_execute',
-      'chat_compress_output',
-      'chat_voice_transcribe',
-      'chat_voice_synthesize',
-      'chat_queue_init',
-      'chat_queue_inbox',
-      'chat_queue_reply',
-      'chat_queue_drain',
-    ]);
-  });
-
   // ─── Chunking ──────────────────────────────────────────────────
 
   describe('chat_chunk_response', () => {

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

@@ -51,23 +51,6 @@ describe('context-facade', () => {
     ops = captureOps(createContextFacadeOps(makeRuntime(mockEngine)));
   });
 
-  it('registers all 3 ops', () => {
-    expect(ops.size).toBe(3);
-    expect([...ops.keys()]).toEqual(
-      expect.arrayContaining([
-        'context_extract_entities',
-        'context_retrieve_knowledge',
-        'context_analyze',
-      ]),
-    );
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('context_extract_entities')!.auth).toBe('read');
-    expect(ops.get('context_retrieve_knowledge')!.auth).toBe('read');
-    expect(ops.get('context_analyze')!.auth).toBe('read');
-  });
-
   // ─── context_extract_entities ──────────────────────────────────
 
   it('context_extract_entities calls engine with prompt', async () => {

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

@@ -15,11 +15,18 @@ export function createContextFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       description:
         'Extract named entities from a prompt — files, functions, domains, actions, technologies, patterns.',
       auth: 'read',
-      schema: z.object({
-        prompt: z.string().describe('The user prompt to analyze.'),
-      }),
+      schema: z
+        .object({
+          prompt: z.string().optional().describe('The user prompt to analyze.'),
+          text: z.string().optional().describe('Alias for prompt — use either field.'),
+        })
+        .refine((v) => v.prompt !== undefined || v.text !== undefined, {
+          message: 'Provide either "prompt" or "text"',
+        }),
       handler: async (params) => {
-        return contextEngine.extractEntities(params.prompt as string);
+        const input =
+          (params.prompt as string | undefined) ?? (params.text as string | undefined) ?? '';
+        return contextEngine.extractEntities(input);
       },
     },
     {

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

@@ -51,36 +51,6 @@ describe('createControlFacadeOps', () => {
     ops = createControlFacadeOps(runtime);
   });
 
-  it('returns all expected ops', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('get_identity');
-    expect(names).toContain('update_identity');
-    expect(names).toContain('add_guideline');
-    expect(names).toContain('remove_guideline');
-    expect(names).toContain('rollback_identity');
-    expect(names).toContain('route_intent');
-    expect(names).toContain('morph');
-    expect(names).toContain('get_behavior_rules');
-    expect(names).toContain('governance_policy');
-    expect(names).toContain('governance_proposals');
-    expect(names).toContain('governance_stats');
-    expect(names).toContain('governance_expire');
-    expect(names).toContain('governance_dashboard');
-    expect(names).toContain('routing_feedback');
-    expect(names).toContain('routing_accuracy');
-  });
-
-  it('assigns correct auth levels', () => {
-    expect(findOp(ops, 'get_identity').auth).toBe('read');
-    expect(findOp(ops, 'update_identity').auth).toBe('write');
-    expect(findOp(ops, 'route_intent').auth).toBe('read');
-    expect(findOp(ops, 'morph').auth).toBe('write');
-    expect(findOp(ops, 'governance_policy').auth).toBe('write');
-    expect(findOp(ops, 'governance_stats').auth).toBe('read');
-    expect(findOp(ops, 'routing_feedback').auth).toBe('write');
-    expect(findOp(ops, 'routing_accuracy').auth).toBe('read');
-  });
-
   describe('get_identity', () => {
     it('returns identity when found', async () => {
       const identity = { agentId: 'test', name: 'Test Agent', version: 1 };

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

@@ -74,39 +74,6 @@ describe('createCuratorFacadeOps', () => {
     ops = createCuratorFacadeOps(runtime);
   });
 
-  it('returns all expected ops', () => {
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('curator_status');
-    expect(names).toContain('curator_detect_duplicates');
-    expect(names).toContain('curator_contradictions');
-    expect(names).toContain('curator_resolve_contradiction');
-    expect(names).toContain('curator_groom');
-    expect(names).toContain('curator_groom_all');
-    expect(names).toContain('curator_consolidate');
-    expect(names).toContain('curator_health_audit');
-    // Extra ops
-    expect(names).toContain('curator_entry_history');
-    expect(names).toContain('curator_record_snapshot');
-    expect(names).toContain('curator_queue_stats');
-    expect(names).toContain('curator_enrich');
-    expect(names).toContain('curator_hybrid_contradictions');
-    expect(names).toContain('curator_pipeline_status');
-    expect(names).toContain('curator_enqueue_pipeline');
-    expect(names).toContain('curator_schedule_start');
-    expect(names).toContain('curator_schedule_stop');
-  });
-
-  it('assigns correct auth levels', () => {
-    expect(findOp(ops, 'curator_status').auth).toBe('read');
-    expect(findOp(ops, 'curator_detect_duplicates').auth).toBe('read');
-    expect(findOp(ops, 'curator_contradictions').auth).toBe('read');
-    expect(findOp(ops, 'curator_resolve_contradiction').auth).toBe('write');
-    expect(findOp(ops, 'curator_groom').auth).toBe('write');
-    expect(findOp(ops, 'curator_groom_all').auth).toBe('write');
-    expect(findOp(ops, 'curator_consolidate').auth).toBe('write');
-    expect(findOp(ops, 'curator_health_audit').auth).toBe('read');
-  });
-
   describe('curator_status', () => {
     it('returns curator status', async () => {
       const result = await findOp(ops, 'curator_status').handler({});

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

@@ -50,39 +50,6 @@ describe('intake-facade', () => {
     ops = captureOps(createIntakeFacadeOps(runtime));
   });
 
-  // ─── Registration ─────────────────────────────────────────────────
-
-  it('returns exactly 7 ops', () => {
-    expect(ops.size).toBe(7);
-  });
-
-  it('includes all expected op names', () => {
-    const expected = [
-      'intake_ingest_book',
-      'intake_process',
-      'intake_status',
-      'intake_preview',
-      'ingest_url',
-      'ingest_text',
-      'ingest_batch',
-    ];
-    for (const name of expected) {
-      expect(ops.has(name), `missing op: ${name}`).toBe(true);
-    }
-  });
-
-  // ─── Auth levels ─────────────────────────────────────────────────
-
-  it('has correct auth levels', () => {
-    expect(ops.get('intake_ingest_book')!.auth).toBe('write');
-    expect(ops.get('intake_process')!.auth).toBe('write');
-    expect(ops.get('intake_status')!.auth).toBe('read');
-    expect(ops.get('intake_preview')!.auth).toBe('read');
-    expect(ops.get('ingest_url')!.auth).toBe('write');
-    expect(ops.get('ingest_text')!.auth).toBe('write');
-    expect(ops.get('ingest_batch')!.auth).toBe('write');
-  });
-
   // ─── Delegation ─────────────────────────────────────────────────
 
   describe('intake_ingest_book', () => {

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

@@ -50,43 +50,6 @@ describe('links-facade', () => {
     ops = captureOps(createLinksFacadeOps(runtime));
   });
 
-  // ─── Registration ──────────────────────────────────────────────────
-
-  it('registers exactly 9 ops', () => {
-    expect(ops.size).toBe(9);
-  });
-
-  it('includes all expected op names', () => {
-    const expected = [
-      'link_entries',
-      'unlink_entries',
-      'get_links',
-      'traverse',
-      'suggest_links',
-      'get_orphans',
-      'relink_vault',
-      'backfill_links',
-      'link_stats',
-    ];
-    for (const name of expected) {
-      expect(ops.has(name), `missing op: ${name}`).toBe(true);
-    }
-  });
-
-  // ─── Auth levels ───────────────────────────────────────────────────
-
-  it('has correct auth levels', () => {
-    expect(ops.get('link_entries')!.auth).toBe('write');
-    expect(ops.get('unlink_entries')!.auth).toBe('write');
-    expect(ops.get('get_links')!.auth).toBe('read');
-    expect(ops.get('traverse')!.auth).toBe('read');
-    expect(ops.get('suggest_links')!.auth).toBe('read');
-    expect(ops.get('get_orphans')!.auth).toBe('read');
-    expect(ops.get('relink_vault')!.auth).toBe('write');
-    expect(ops.get('backfill_links')!.auth).toBe('write');
-    expect(ops.get('link_stats')!.auth).toBe('read');
-  });
-
   // ─── Handler delegation ───────────────────────────────────────────
 
   describe('link_entries', () => {

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

@@ -87,32 +87,6 @@ describe('loop-facade', () => {
     ops = captureOps(createLoopFacadeOps(makeRuntime(mockLoop)));
   });
 
-  it('registers all 9 ops', () => {
-    expect(ops.size).toBe(9);
-    const names = [...ops.keys()];
-    expect(names).toContain('loop_start');
-    expect(names).toContain('loop_iterate');
-    expect(names).toContain('loop_iterate_gate');
-    expect(names).toContain('loop_status');
-    expect(names).toContain('loop_cancel');
-    expect(names).toContain('loop_history');
-    expect(names).toContain('loop_is_active');
-    expect(names).toContain('loop_complete');
-    expect(names).toContain('loop_anomaly_check');
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('loop_start')!.auth).toBe('write');
-    expect(ops.get('loop_iterate')!.auth).toBe('write');
-    expect(ops.get('loop_iterate_gate')!.auth).toBe('write');
-    expect(ops.get('loop_status')!.auth).toBe('read');
-    expect(ops.get('loop_cancel')!.auth).toBe('write');
-    expect(ops.get('loop_history')!.auth).toBe('read');
-    expect(ops.get('loop_is_active')!.auth).toBe('read');
-    expect(ops.get('loop_complete')!.auth).toBe('write');
-    expect(ops.get('loop_anomaly_check')!.auth).toBe('read');
-  });
-
   // ─── loop_start ────────────────────────────────────────────────
 
   it('loop_start creates a loop with defaults', async () => {

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

@@ -30,24 +30,6 @@ describe('memory-facade', () => {
     vault.close();
   });
 
-  it('registers base + extra + cross-project ops', () => {
-    // 4 base + 18 extra + 3 cross-project = 25
-    expect(ops.size).toBeGreaterThanOrEqual(25);
-    expect([...ops.keys()]).toContain('memory_search');
-    expect([...ops.keys()]).toContain('memory_capture');
-    expect([...ops.keys()]).toContain('memory_list');
-    expect([...ops.keys()]).toContain('session_capture');
-    expect([...ops.keys()]).toContain('memory_delete');
-    expect([...ops.keys()]).toContain('memory_promote_to_global');
-  });
-
-  it('has correct auth levels for base ops', () => {
-    expect(ops.get('memory_search')!.auth).toBe('read');
-    expect(ops.get('memory_capture')!.auth).toBe('write');
-    expect(ops.get('memory_list')!.auth).toBe('read');
-    expect(ops.get('session_capture')!.auth).toBe('write');
-  });
-
   // ─── memory_capture ────────────────────────────────────────────
 
   it('memory_capture stores a memory', async () => {

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

@@ -60,21 +60,37 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       name: 'memory_capture',
       description: 'Capture a memory — session summary, lesson learned, or preference.',
       auth: 'write',
-      schema: z.object({
-        projectPath: z.string(),
-        type: z.enum(['session', 'lesson', 'preference']),
-        context: z.string(),
-        summary: z.string(),
-        topics: z.array(z.string()).optional().default([]),
-        filesModified: z.array(z.string()).optional().default([]),
-        toolsUsed: z.array(z.string()).optional().default([]),
-      }),
+      schema: z
+        .object({
+          projectPath: z.string().optional().default('.'),
+          type: z
+            .enum(['session', 'lesson', 'preference'])
+            .optional()
+            .default('lesson')
+            .describe('Memory type: session | lesson | preference (default: "lesson")'),
+          context: z.string().optional().describe('What was happening — situation or task context'),
+          summary: z.string().optional().describe('What was learned or decided'),
+          content: z
+            .string()
+            .optional()
+            .describe('Alias: sets both context and summary when neither is provided'),
+          topics: z.array(z.string()).optional().default([]),
+          filesModified: z.array(z.string()).optional().default([]),
+          toolsUsed: z.array(z.string()).optional().default([]),
+        })
+        .refine(
+          (v) => v.context !== undefined || v.summary !== undefined || v.content !== undefined,
+          {
+            message: 'Provide at least one of: context, summary, or content',
+          },
+        ),
       handler: async (params) => {
+        const rawContent = params.content as string | undefined;
         const memory = vault.captureMemory({
           projectPath: params.projectPath as string,
           type: params.type as 'session' | 'lesson' | 'preference',
-          context: params.context as string,
-          summary: params.summary as string,
+          context: (params.context as string | undefined) ?? rawContent ?? '',
+          summary: (params.summary as string | undefined) ?? rawContent ?? '',
           topics: (params.topics as string[]) ?? [],
           filesModified: (params.filesModified as string[]) ?? [],
           toolsUsed: (params.toolsUsed as string[]) ?? [],

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

@@ -41,37 +41,6 @@ describe('operator-facade (colocated)', () => {
     vault.close();
   });
 
-  it('registers all 10 ops', () => {
-    expect(ops.size).toBe(10);
-    expect([...ops.keys()]).toEqual(
-      expect.arrayContaining([
-        'profile_get',
-        'profile_update_section',
-        'profile_correct',
-        'profile_delete',
-        'profile_export',
-        'signal_accumulate',
-        'signal_list',
-        'signal_stats',
-        'synthesis_check',
-        'profile_snapshot',
-      ]),
-    );
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('profile_get')!.auth).toBe('read');
-    expect(ops.get('profile_update_section')!.auth).toBe('write');
-    expect(ops.get('profile_correct')!.auth).toBe('write');
-    expect(ops.get('profile_delete')!.auth).toBe('admin');
-    expect(ops.get('profile_export')!.auth).toBe('read');
-    expect(ops.get('signal_accumulate')!.auth).toBe('write');
-    expect(ops.get('signal_list')!.auth).toBe('read');
-    expect(ops.get('signal_stats')!.auth).toBe('read');
-    expect(ops.get('synthesis_check')!.auth).toBe('read');
-    expect(ops.get('profile_snapshot')!.auth).toBe('write');
-  });
-
   // ─── profile_get ───────────────────────────────────────────────
 
   it('profile_get returns null when no profile', async () => {

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

@@ -62,27 +62,6 @@ describe('orchestrate-facade', () => {
     vault.close();
   });
 
-  it('registers session_start + satellite ops', () => {
-    expect(ops.size).toBeGreaterThanOrEqual(20);
-    expect([...ops.keys()]).toContain('session_start');
-    expect([...ops.keys()]).toContain('orchestrate_plan');
-    expect([...ops.keys()]).toContain('orchestrate_execute');
-    expect([...ops.keys()]).toContain('orchestrate_complete');
-    expect([...ops.keys()]).toContain('orchestrate_status');
-    expect([...ops.keys()]).toContain('orchestrate_quick_capture');
-    expect([...ops.keys()]).toContain('project_get');
-    expect([...ops.keys()]).toContain('project_list');
-    expect([...ops.keys()]).toContain('playbook_list');
-  });
-
-  it('has correct auth levels', () => {
-    expect(ops.get('session_start')!.auth).toBe('write');
-    expect(ops.get('orchestrate_plan')!.auth).toBe('write');
-    expect(ops.get('orchestrate_status')!.auth).toBe('read');
-    expect(ops.get('project_get')!.auth).toBe('read');
-    expect(ops.get('project_list')!.auth).toBe('read');
-  });
-
   // ─── session_start ─────────────────────────────────────────────
 
   it('session_start registers project and returns stats', async () => {

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

@@ -24,7 +24,7 @@ import {
 import type { SkillStep, EvidenceType } from '../../skills/step-tracker.js';
 
 export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, governance, projectRegistry } = runtime;
+  const { vault, governance, projectRegistry, brainIntelligence } = runtime;
 
   return [
     // ─── Session Start (inline from core-ops.ts) ─────────────────────
@@ -120,6 +120,18 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
           /* dream module not available — skip silently */
         }
 
+        // Auto-reap stale worktrees — best-effort, non-blocking
+        try {
+          const { worktreeReap } = await import('../../utils/worktree-reaper.js');
+          Promise.resolve()
+            .then(() => worktreeReap(projectPath))
+            .catch(() => {
+              /* best-effort */
+            });
+        } catch {
+          /* worktree-reaper not available — skip silently */
+        }
+
         // ─── Pre-flight manifest ───────────────────────────────
         let skills: string[] = [];
         try {
@@ -150,6 +162,31 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
           vaultStats: stats,
         });
 
+        // Auto-close orphaned brain sessions (endedAt IS NULL, startedAt < now - 2h)
+        let orphansClosed = 0;
+        try {
+          const TWO_HOURS_MS = 2 * 60 * 60 * 1000;
+          const cutoff = new Date(Date.now() - TWO_HOURS_MS);
+          const activeSessions = brainIntelligence.listSessions({ active: true, limit: 1000 });
+          for (const s of activeSessions) {
+            if (new Date(s.startedAt) < cutoff) {
+              try {
+                brainIntelligence.lifecycle({
+                  action: 'end',
+                  sessionId: s.id,
+                  planOutcome: 'abandoned',
+                  context: 'auto-closed: orphan from previous conversation',
+                });
+                orphansClosed++;
+              } catch {
+                // Best-effort per session — never let one failure abort the rest
+              }
+            }
+          }
+        } catch {
+          // Non-critical — don't fail session start over orphan cleanup
+        }
+
         return {
           project,
           is_new: isNew,
@@ -167,6 +204,7 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
             expiredThisSession: expired,
           },
           preflight,
+          orphansClosed,
           ...(stagingWarning ? { stagingWarning } : {}),
           ...(dreamInfo ? { dream: dreamInfo } : {}),
         };

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

@@ -48,26 +48,6 @@ describe('plan-facade', () => {
     vault.close();
   });
 
-  it('registers base + extra + grading + chain ops', () => {
-    // 5 base + 22 extra + 5 grading + 5 chain = 37
-    expect(ops.size).toBeGreaterThanOrEqual(32);
-    expect([...ops.keys()]).toContain('create_plan');
-    expect([...ops.keys()]).toContain('get_plan');
-    expect([...ops.keys()]).toContain('approve_plan');
-    expect([...ops.keys()]).toContain('update_task');
-    expect([...ops.keys()]).toContain('complete_plan');
-    expect([...ops.keys()]).toContain('plan_grade');
-    expect([...ops.keys()]).toContain('chain_execute');
-  });
-
-  it('has correct auth levels for base ops', () => {
-    expect(ops.get('create_plan')!.auth).toBe('write');
-    expect(ops.get('get_plan')!.auth).toBe('read');
-    expect(ops.get('approve_plan')!.auth).toBe('write');
-    expect(ops.get('update_task')!.auth).toBe('write');
-    expect(ops.get('complete_plan')!.auth).toBe('write');
-  });
-
   // ─── create_plan ───────────────────────────────────────────────
 
   it('create_plan creates a draft plan', async () => {
@@ -91,7 +71,7 @@ describe('plan-facade', () => {
     });
     expect(result.success).toBe(true);
     const plan = (result.data as Record<string, unknown>).plan as Record<string, unknown>;
-    expect((plan.tasks as unknown[]).length).toBe(1);
+    expect((plan.tasks as unknown[]).length).toBeGreaterThanOrEqual(1);
   });
 
   // ─── get_plan ──────────────────────────────────────────────────
@@ -366,11 +346,11 @@ describe('plan-facade', () => {
       vaultEntryIds: string[];
     };
     expect(data.created).toBe(true);
-    expect(data.vaultEntryIds.length).toBeGreaterThan(0);
+    expect(data.vaultEntryIds).toHaveLength(1); // exactly one seeded entry matches
     // Decisions should contain vault pattern references with entryId markers
     const decisions = data.plan.decisions as string[];
     const vaultDecisions = decisions.filter((d) => d.startsWith('Vault pattern:'));
-    expect(vaultDecisions.length).toBeGreaterThan(0);
+    expect(vaultDecisions).toHaveLength(1); // one vault entry injected one decision
     // Each vault decision should have an [entryId:...] marker for brain feedback
     for (const vd of vaultDecisions) {
       expect(vd).toMatch(/\[entryId:[^\]]+\]/);
@@ -413,19 +393,14 @@ describe('plan-facade', () => {
     const decisions = data.plan.decisions as string[];
     // User decision preserved
     expect(decisions).toContain('Use vitest as test runner');
-    // Vault enrichment added
-    if (data.vaultEntryIds.length > 0) {
-      const vaultDecisions = decisions.filter((d) => d.startsWith('Vault pattern:'));
-      expect(vaultDecisions.length).toBeGreaterThan(0);
-    }
+    // Vault enrichment added — one seeded entry matches the 'testing' query
+    expect(data.vaultEntryIds).toHaveLength(1);
+    const vaultDecisions = decisions.filter((d) => d.startsWith('Vault pattern:'));
+    expect(vaultDecisions).toHaveLength(1);
   });
 
   // ─── plan_close_stale ─────────────────────────────────────────
 
-  it('plan_close_stale op is registered', () => {
-    expect([...ops.keys()]).toContain('plan_close_stale');
-  });
-
   it('plan_close_stale returns no plans when none are stale', async () => {
     const result = await executeOp(ops, 'plan_close_stale', {});
     expect(result.success).toBe(true);