@soleri/core 9.2.0 → 9.3.0

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

@@ -1,24 +1,31 @@
 /**
  * Vault facade — knowledge management ops.
- * search, CRUD, import/export, intake, sharing, linking.
+ * search, CRUD, capture, sharing scope.
  * Archival and lifecycle ops are in archive-facade.ts.
  * Sync ops (git, obsidian, packs) are in sync-facade.ts.
  * Review ops are in review-facade.ts.
+ *
+ * Backward-compat stubs are appended at the end for ops that moved
+ * to new facades, so existing agents/CLAUDE.md files keep working.
  */
 
 import { z } from 'zod';
 import type { OpDefinition } from '../../facades/types.js';
 import type { IntelligenceEntry } from '../../intelligence/types.js';
-import type { VaultTier } from '../../vault/vault-types.js';
 import type { AgentRuntime } from '../types.js';
 import { createVaultExtraOps } from '../vault-extra-ops.js';
 import { createCaptureOps } from '../capture-ops.js';
-import { createIntakeOps } from '../intake-ops.js';
 import { createVaultSharingOps } from '../vault-sharing-ops.js';
+import { createArchiveOps } from '../archive-ops.js';
+import { createSyncOps } from '../sync-ops.js';
+import { createReviewOps } from '../review-ops.js';
 import { createVaultLinkingOps } from '../vault-linking-ops.js';
+import { createBranchingOps } from '../branching-ops.js';
+import { createTierOps } from '../tier-ops.js';
+import { deprecationWarning } from '../deprecation.js';
 
 export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, intakePipeline, textIngester, vaultManager } = runtime;
+  const { vault, brain } = runtime;
 
   return [
     // ─── Search / Vault (inline from core-ops.ts) ───────────────
@@ -101,9 +108,21 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           return entries;
         }
         // Return lightweight summaries to reduce response size
-        return (entries as Array<{ id: string; title: string; type: string; domain: string; tags?: string[] }>).map(
-          (e) => ({ id: e.id, title: e.title, type: e.type, domain: e.domain, tags: e.tags ?? [] }),
-        );
+        return (
+          entries as Array<{
+            id: string;
+            title: string;
+            type: string;
+            domain: string;
+            tags?: string[];
+          }>
+        ).map((e) => ({
+          id: e.id,
+          title: e.title,
+          type: e.type,
+          domain: e.domain,
+          tags: e.tags ?? [],
+        }));
       },
     },
     {
@@ -253,201 +272,38 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
-    // ─── Multi-vault ops ────────────────────────────────────────
-    {
-      name: 'vault_connect',
-      description:
-        'Connect an additional vault tier (project or team). Opens a separate SQLite database.',
-      auth: 'admin',
-      schema: z.object({
-        tier: z.enum(['project', 'team']).describe('Vault tier to connect'),
-        path: z.string().describe('Path to the SQLite database file'),
-      }),
-      handler: async (params) => {
-        const tier = params.tier as VaultTier;
-        const path = params.path as string;
-        vaultManager.open(tier, path);
-        return { connected: true, tier, path };
-      },
-    },
-    {
-      name: 'vault_disconnect',
-      description: 'Disconnect a vault tier. Cannot disconnect the agent tier.',
-      auth: 'admin',
-      schema: z.object({
-        tier: z.enum(['project', 'team']).describe('Vault tier to disconnect'),
-      }),
-      handler: async (params) => {
-        const tier = params.tier as VaultTier;
-        const removed = vaultManager.disconnect(tier);
-        return { disconnected: removed, tier };
-      },
-    },
-    {
-      name: 'vault_tiers',
-      description: 'List all vault tiers with connection status and entry counts.',
-      auth: 'read',
-      handler: async () => {
-        return { tiers: vaultManager.listTiers() };
-      },
-    },
-    {
-      name: 'vault_search_all',
-      description:
-        'Search across all connected vault tiers with priority-weighted cascading. Agent tier results ranked highest.',
-      auth: 'read',
-      schema: z.object({
-        query: z.string(),
-        limit: z.number().optional(),
-      }),
-      handler: async (params) => {
-        const results = vaultManager.search(params.query as string, (params.limit as number) ?? 20);
-        return { results, count: results.length };
-      },
-    },
-
-    // ─── Named vault connections ────────────────────────────────
-    {
-      name: 'vault_connect_source',
-      description:
-        'Connect a named vault source (e.g., shared team knowledge base) with a configurable search priority.',
-      auth: 'admin',
-      schema: z.object({
-        name: z.string().describe('Unique name for this vault connection'),
-        path: z.string().describe('Path to the SQLite database file'),
-        priority: z
-          .number()
-          .min(0)
-          .max(2)
-          .optional()
-          .describe('Search priority weight (default: 0.5)'),
-      }),
-      handler: async (params) => {
-        const name = params.name as string;
-        const path = params.path as string;
-        const priority = (params.priority as number) ?? 0.5;
-        vaultManager.connect(name, path, priority);
-        return { connected: true, name, path, priority };
-      },
-    },
-    {
-      name: 'vault_disconnect_source',
-      description: 'Disconnect a named vault source.',
-      auth: 'admin',
-      schema: z.object({
-        name: z.string().describe('Name of the vault connection to remove'),
-      }),
-      handler: async (params) => {
-        const name = params.name as string;
-        const removed = vaultManager.disconnectNamed(name);
-        return { disconnected: removed, name };
-      },
-    },
-    {
-      name: 'vault_list_sources',
-      description: 'List all dynamically connected vault sources with their priorities.',
-      auth: 'read',
-      handler: async () => {
-        return { sources: vaultManager.listConnected() };
-      },
-    },
-
-    // ─── Branching ─────────────────────────────────────────────
-    {
-      name: 'vault_branch',
-      description:
-        'Create a named vault branch for experimentation. Changes can be reviewed and merged later.',
-      auth: 'write',
-      schema: z.object({
-        name: z.string().describe('Unique branch name'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          vaultBranching.branch(params.name as string);
-          return { created: true, name: params.name };
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_branch_add',
-      description: 'Add an operation (add/modify/remove) to a vault branch.',
-      auth: 'write',
-      schema: z.object({
-        branchName: z.string().describe('Branch to add the operation to'),
-        entryId: z.string().describe('Entry ID'),
-        action: z.enum(['add', 'modify', 'remove']).describe('Operation type'),
-        entryData: z
-          .record(z.unknown())
-          .optional()
-          .describe('Full entry data (required for add/modify)'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          vaultBranching.addOperation(
-            params.branchName as string,
-            params.entryId as string,
-            params.action as 'add' | 'modify' | 'remove',
-            params.entryData as IntelligenceEntry | undefined,
-          );
-          return {
-            added: true,
-            branchName: params.branchName,
-            entryId: params.entryId,
-            action: params.action,
-          };
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_branch_list',
-      description: 'List all vault branches with entry counts and merge status.',
-      auth: 'read',
-      handler: async () => {
-        const { vaultBranching } = runtime;
-        return { branches: vaultBranching.listBranches() };
-      },
-    },
-    {
-      name: 'vault_merge_branch',
-      description: 'Merge a branch into the main vault. Branch entries win on conflict.',
-      auth: 'admin',
-      schema: z.object({
-        branchName: z.string().describe('Branch to merge'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        try {
-          return vaultBranching.merge(params.branchName as string);
-        } catch (err) {
-          return { error: (err as Error).message };
-        }
-      },
-    },
-    {
-      name: 'vault_delete_branch',
-      description: 'Delete a vault branch and all its operations.',
-      auth: 'admin',
-      schema: z.object({
-        branchName: z.string().describe('Branch to delete'),
-      }),
-      handler: async (params) => {
-        const { vaultBranching } = runtime;
-        const deleted = vaultBranching.deleteBranch(params.branchName as string);
-        return { deleted, branchName: params.branchName };
-      },
-    },
-
     // ─── Satellite ops ───────────────────────────────────────────
     ...createVaultExtraOps(runtime),
     ...createCaptureOps(runtime),
-    ...createIntakeOps(intakePipeline, textIngester),
     ...createVaultSharingOps(runtime),
-    ...createVaultLinkingOps(runtime),
+
+    // ─── Backward-compat stubs for ops that moved to new facades ─
+    ...deprecateOps(createArchiveOps(runtime), 'archive'),
+    ...deprecateOps(createSyncOps(runtime), 'sync'),
+    ...deprecateOps(createReviewOps(runtime), 'review'),
+    ...deprecateOps(createVaultLinkingOps(runtime), 'links'),
+    ...deprecateOps(createBranchingOps(runtime), 'branching'),
+    ...deprecateOps(createTierOps(runtime), 'tier'),
   ];
 }
+
+// ─── Deprecation wrapper ────────────────────────────────────────────
+
+/**
+ * Wrap an array of ops with deprecation warnings.
+ * Each op's handler logs a one-time warning before forwarding to the real handler.
+ */
+export function deprecateOps(ops: OpDefinition[], newFacade: string): OpDefinition[] {
+  return ops.map((op) => ({
+    ...op,
+    handler: async (params: Record<string, unknown>) => {
+      deprecationWarning({
+        name: op.name,
+        since: '0.5.0',
+        replacement: `${newFacade}.${op.name}`,
+        message: `Op "${op.name}" has moved to the ${newFacade} facade. Update your calls.`,
+      });
+      return op.handler(params);
+    },
+  }));
+}

package/src/runtime/github-integration.ts

@@ -102,9 +102,13 @@ export async function getIssueDetails(
     const { stdout } = await execFileAsync(
       'gh',
       [
-        'issue', 'view', String(issueNumber),
-        '--repo', `${owner}/${repo}`,
-        '--json', 'title,body,labels',
+        'issue',
+        'view',
+        String(issueNumber),
+        '--repo',
+        `${owner}/${repo}`,
+        '--json',
+        'title,body,labels',
       ],
       {
         timeout: 10_000,
@@ -148,11 +152,10 @@ export async function closeIssueWithComment(
       ['issue', 'comment', String(issueNumber), '--repo', repoSlug, '--body', comment],
       { timeout: 10_000, signal: AbortSignal.timeout(10_000) },
     );
-    await execFileAsync(
-      'gh',
-      ['issue', 'close', String(issueNumber), '--repo', repoSlug],
-      { timeout: 10_000, signal: AbortSignal.timeout(10_000) },
-    );
+    await execFileAsync('gh', ['issue', 'close', String(issueNumber), '--repo', repoSlug], {
+      timeout: 10_000,
+      signal: AbortSignal.timeout(10_000),
+    });
   } catch {
     // Graceful degradation — gh not available or auth expired
   }

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

@@ -11,9 +11,25 @@ function makeMockRuntime() {
         score: 82,
         iteration: 1,
         gaps: [
-          { severity: 'major', category: 'scope', description: 'Missing scope', recommendation: 'Add scope', location: 'plan.scope' },
-          { severity: 'minor', category: 'detail', description: 'Low detail', recommendation: 'Add detail' },
-          { severity: 'critical', category: 'risk', description: 'No risk analysis', recommendation: 'Add risks' },
+          {
+            severity: 'major',
+            category: 'scope',
+            description: 'Missing scope',
+            recommendation: 'Add scope',
+            location: 'plan.scope',
+          },
+          {
+            severity: 'minor',
+            category: 'detail',
+            description: 'Low detail',
+            recommendation: 'Add detail',
+          },
+          {
+            severity: 'critical',
+            category: 'risk',
+            description: 'No risk analysis',
+            recommendation: 'Add risks',
+          },
         ],
       }),
       getCheckHistory: vi.fn().mockReturnValue([
@@ -77,7 +93,10 @@ describe('createGradingOps', () => {
     it('returns count and checks array', async () => {
       runtime = makeMockRuntime();
       ops = createGradingOps(runtime);
-      const result = (await findOp('plan_check_history').handler({ planId: 'p1' })) as Record<string, unknown>;
+      const result = (await findOp('plan_check_history').handler({ planId: 'p1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.planId).toBe('p1');
       expect(result.count).toBe(2);
       expect(result.checks).toHaveLength(2);
@@ -96,7 +115,10 @@ describe('createGradingOps', () => {
       runtime = makeMockRuntime();
       (runtime.planner.getLatestCheck as ReturnType<typeof vi.fn>).mockReturnValue(null);
       ops = createGradingOps(runtime);
-      const result = (await findOp('plan_latest_check').handler({ planId: 'p1' })) as Record<string, unknown>;
+      const result = (await findOp('plan_latest_check').handler({ planId: 'p1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.message).toBe('No checks found for this plan.');
     });
   });
@@ -115,7 +137,10 @@ describe('createGradingOps', () => {
     it('sorts gaps by severity and groups them', async () => {
       runtime = makeMockRuntime();
       ops = createGradingOps(runtime);
-      const result = (await findOp('plan_auto_improve').handler({ planId: 'p1' })) as Record<string, unknown>;
+      const result = (await findOp('plan_auto_improve').handler({ planId: 'p1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.grade).toBe('B');
       expect(result.score).toBe(82);
       expect(result.totalGaps).toBe(3);
@@ -130,10 +155,16 @@ describe('createGradingOps', () => {
     it('returns approve as nextAction when score >= 90', async () => {
       runtime = makeMockRuntime();
       (runtime.planner.grade as ReturnType<typeof vi.fn>).mockReturnValue({
-        grade: 'A', score: 92, iteration: 3, gaps: [],
+        grade: 'A',
+        score: 92,
+        iteration: 3,
+        gaps: [],
       });
       ops = createGradingOps(runtime);
-      const result = (await findOp('plan_auto_improve').handler({ planId: 'p1' })) as Record<string, unknown>;
+      const result = (await findOp('plan_auto_improve').handler({ planId: 'p1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.nextAction).toBe('approve');
       expect(result.totalGaps).toBe(0);
     });

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

@@ -51,14 +51,19 @@ describe('createIntakeOps', () => {
     it('intake_ingest_book returns error', async () => {
       const ops = createIntakeOps(null);
       const result = (await findOp(ops, 'intake_ingest_book').handler({
-        pdfPath: '/test.pdf', title: 'T', domain: 'd',
+        pdfPath: '/test.pdf',
+        title: 'T',
+        domain: 'd',
       })) as Record<string, unknown>;
       expect(result.error).toBe('Intake pipeline not configured');
     });
 
     it('intake_process returns error', async () => {
       const ops = createIntakeOps(null);
-      const result = (await findOp(ops, 'intake_process').handler({ jobId: 'j1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'intake_process').handler({ jobId: 'j1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toBe('Intake pipeline not configured');
     });
 
@@ -71,7 +76,11 @@ describe('createIntakeOps', () => {
     it('intake_preview returns error', async () => {
       const ops = createIntakeOps(null);
       const result = (await findOp(ops, 'intake_preview').handler({
-        pdfPath: '/x.pdf', title: 'T', domain: 'd', pageStart: 1, pageEnd: 5,
+        pdfPath: '/x.pdf',
+        title: 'T',
+        domain: 'd',
+        pageStart: 1,
+        pageEnd: 5,
       })) as Record<string, unknown>;
       expect(result.error).toBe('Intake pipeline not configured');
     });
@@ -80,14 +89,17 @@ describe('createIntakeOps', () => {
   describe('when textIngester is null', () => {
     it('ingest_url returns error', async () => {
       const ops = createIntakeOps(makeMockPipeline() as never, null);
-      const result = (await findOp(ops, 'ingest_url').handler({ url: 'https://example.com' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'ingest_url').handler({
+        url: 'https://example.com',
+      })) as Record<string, unknown>;
       expect(result.error).toContain('Text ingester not configured');
     });
 
     it('ingest_text returns error', async () => {
       const ops = createIntakeOps(makeMockPipeline() as never, null);
       const result = (await findOp(ops, 'ingest_text').handler({
-        text: 'hello', title: 'T',
+        text: 'hello',
+        title: 'T',
       })) as Record<string, unknown>;
       expect(result.error).toContain('Text ingester not configured');
     });
@@ -106,10 +118,20 @@ describe('createIntakeOps', () => {
       const pipeline = makeMockPipeline();
       const ops = createIntakeOps(pipeline as never);
       const result = await findOp(ops, 'intake_ingest_book').handler({
-        pdfPath: '/book.pdf', title: 'My Book', domain: 'design', author: 'Author', chunkPageSize: 15, tags: ['tag1'],
+        pdfPath: '/book.pdf',
+        title: 'My Book',
+        domain: 'design',
+        author: 'Author',
+        chunkPageSize: 15,
+        tags: ['tag1'],
       });
       expect(pipeline.ingestBook).toHaveBeenCalledWith({
-        pdfPath: '/book.pdf', title: 'My Book', domain: 'design', author: 'Author', chunkPageSize: 15, tags: ['tag1'],
+        pdfPath: '/book.pdf',
+        title: 'My Book',
+        domain: 'design',
+        author: 'Author',
+        chunkPageSize: 15,
+        tags: ['tag1'],
       });
       expect(result).toEqual({ jobId: 'j1', chunks: 5 });
     });
@@ -128,7 +150,10 @@ describe('createIntakeOps', () => {
     it('returns job and chunks when jobId provided', async () => {
       const pipeline = makeMockPipeline();
       const ops = createIntakeOps(pipeline as never);
-      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'j1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'j1' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.job).toEqual({ id: 'j1', status: 'active' });
       expect(result.chunks).toHaveLength(2);
     });
@@ -137,7 +162,10 @@ describe('createIntakeOps', () => {
       const pipeline = makeMockPipeline();
       pipeline.getJob.mockReturnValue(null);
       const ops = createIntakeOps(pipeline as never);
-      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'missing' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'intake_status').handler({ jobId: 'missing' })) as Record<
+        string,
+        unknown
+      >;
       expect(result.error).toContain('Job not found');
     });
 
@@ -154,10 +182,16 @@ describe('createIntakeOps', () => {
       const pipeline = makeMockPipeline();
       const ops = createIntakeOps(pipeline as never);
       await findOp(ops, 'intake_preview').handler({
-        pdfPath: '/x.pdf', title: 'T', domain: 'd', pageStart: 1, pageEnd: 10,
+        pdfPath: '/x.pdf',
+        title: 'T',
+        domain: 'd',
+        pageStart: 1,
+        pageEnd: 10,
       });
       expect(pipeline.preview).toHaveBeenCalledWith(
-        { pdfPath: '/x.pdf', title: 'T', domain: 'd' }, 1, 10,
+        { pdfPath: '/x.pdf', title: 'T', domain: 'd' },
+        1,
+        10,
       );
     });
   });
@@ -167,9 +201,14 @@ describe('createIntakeOps', () => {
       const ingester = makeMockTextIngester();
       const ops = createIntakeOps(makeMockPipeline() as never, ingester as never);
       const result = await findOp(ops, 'ingest_url').handler({
-        url: 'https://example.com', domain: 'test', tags: ['t1'],
+        url: 'https://example.com',
+        domain: 'test',
+        tags: ['t1'],
+      });
+      expect(ingester.ingestUrl).toHaveBeenCalledWith('https://example.com', {
+        domain: 'test',
+        tags: ['t1'],
       });
-      expect(ingester.ingestUrl).toHaveBeenCalledWith('https://example.com', { domain: 'test', tags: ['t1'] });
       expect(result).toEqual({ ingested: 3, duplicates: 1 });
     });
   });
@@ -179,7 +218,13 @@ describe('createIntakeOps', () => {
       const ingester = makeMockTextIngester();
       const ops = createIntakeOps(makeMockPipeline() as never, ingester as never);
       await findOp(ops, 'ingest_text').handler({
-        text: 'content', title: 'My Notes', sourceType: 'transcript', url: 'https://x.com', author: 'A', domain: 'd', tags: ['t'],
+        text: 'content',
+        title: 'My Notes',
+        sourceType: 'transcript',
+        url: 'https://x.com',
+        author: 'A',
+        domain: 'd',
+        tags: ['t'],
       });
       expect(ingester.ingestText).toHaveBeenCalledWith(
         'content',
@@ -200,8 +245,16 @@ describe('createIntakeOps', () => {
         ],
       });
       expect(ingester.ingestBatch).toHaveBeenCalledWith([
-        { text: 'a', source: { type: 'article', title: 'A', url: undefined, author: undefined }, opts: { domain: 'x', tags: undefined } },
-        { text: 'b', source: { type: 'notes', title: 'B', url: undefined, author: undefined }, opts: { domain: undefined, tags: undefined } },
+        {
+          text: 'a',
+          source: { type: 'article', title: 'A', url: undefined, author: undefined },
+          opts: { domain: 'x', tags: undefined },
+        },
+        {
+          text: 'b',
+          source: { type: 'notes', title: 'B', url: undefined, author: undefined },
+          opts: { domain: undefined, tags: undefined },
+        },
       ]);
     });
   });

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

@@ -61,9 +61,15 @@ describe('createLoopOps', () => {
     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',
+      'loop_start',
+      'loop_iterate',
+      'loop_iterate_gate',
+      'loop_status',
+      'loop_cancel',
+      'loop_history',
+      'loop_is_active',
+      'loop_complete',
+      'loop_anomaly_check',
     ]);
   });
 
@@ -72,7 +78,8 @@ describe('createLoopOps', () => {
       runtime = makeMockRuntime();
       ops = createLoopOps(runtime);
       const result = (await findOp('loop_start').handler({
-        mode: 'custom', prompt: 'fix the thing',
+        mode: 'custom',
+        prompt: 'fix the thing',
       })) as Record<string, unknown>;
 
       expect(runtime.loop.startLoop).toHaveBeenCalledWith(
@@ -108,7 +115,8 @@ describe('createLoopOps', () => {
       runtime = makeMockRuntime();
       ops = createLoopOps(runtime);
       const result = (await findOp('loop_iterate').handler({
-        passed: false, validationScore: 70,
+        passed: false,
+        validationScore: 70,
       })) as Record<string, unknown>;
 
       expect(result.iteration).toBe(1);
@@ -232,7 +240,9 @@ describe('createLoopOps', () => {
       const result = (await findOp('loop_anomaly_check').handler({})) as Record<string, unknown>;
       expect(result.active).toBe(true);
       expect(result.hasAnomalies).toBe(true);
-      expect((result.anomalies as string[]).some((a) => a.includes('consecutive failing'))).toBe(true);
+      expect((result.anomalies as string[]).some((a) => a.includes('consecutive failing'))).toBe(
+        true,
+      );
     });
   });
 });