@soleri/core 9.2.0 → 9.3.1

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

@@ -25,7 +25,15 @@ const mockAuthManager = {
 };
 
 vi.mock('../../chat/auth-manager.js', () => ({
-  ChatAuthManager: vi.fn().mockImplementation(() => mockAuthManager),
+  ChatAuthManager: class {
+    enabled = mockAuthManager.enabled;
+    authenticatedCount = mockAuthManager.authenticatedCount;
+    isAuthenticated = mockAuthManager.isAuthenticated;
+    isLockedOut = mockAuthManager.isLockedOut;
+    authenticate = mockAuthManager.authenticate;
+    revoke = mockAuthManager.revoke;
+    listAuthenticated = mockAuthManager.listAuthenticated;
+  },
 }));
 
 const mockBridge = {
@@ -36,13 +44,18 @@ const mockBridge = {
 };
 
 vi.mock('../../chat/mcp-bridge.js', () => ({
-  McpToolBridge: vi.fn().mockImplementation(() => mockBridge),
+  McpToolBridge: class {
+    size = mockBridge.size;
+    register = mockBridge.register;
+    listTools = mockBridge.listTools;
+    execute = mockBridge.execute;
+  },
 }));
 
 vi.mock('../../chat/output-compressor.js', () => ({
-  createOutputCompressor: vi.fn().mockReturnValue(
-    (_name: string, output: string, _max?: number) => output.slice(0, 10),
-  ),
+  createOutputCompressor: vi
+    .fn()
+    .mockReturnValue((_name: string, output: string, _max?: number) => output.slice(0, 10)),
 }));
 
 vi.mock('../../chat/voice.js', () => ({
@@ -63,7 +76,14 @@ const mockQueue = {
 };
 
 vi.mock('../../chat/queue.js', () => ({
-  MessageQueue: vi.fn().mockImplementation(() => mockQueue),
+  MessageQueue: class {
+    inboxCount = mockQueue.inboxCount;
+    outboxCount = mockQueue.outboxCount;
+    readInbox = mockQueue.readInbox;
+    formatInbox = mockQueue.formatInbox;
+    sendResponse = mockQueue.sendResponse;
+    drainOutbox = mockQueue.drainOutbox;
+  },
 }));
 
 // Needed via chat-state imports
@@ -95,12 +115,22 @@ describe('chat-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_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',
+      'chat_voice_transcribe',
+      'chat_voice_synthesize',
+      'chat_queue_init',
+      'chat_queue_inbox',
+      'chat_queue_reply',
+      'chat_queue_drain',
     ]);
   });
 
@@ -109,7 +139,10 @@ describe('chat-transport-ops', () => {
   describe('chat_chunk_response', () => {
     it('chunks text and returns result', async () => {
       const op = findOp(ops, 'chat_chunk_response');
-      const result = (await op.handler({ text: 'hello world' })) as { chunks: string[]; count: number };
+      const result = (await op.handler({ text: 'hello world' })) as {
+        chunks: string[];
+        count: number;
+      };
       expect(result.chunks).toEqual(['chunk1', 'chunk2']);
       expect(result.count).toBe(2);
     });
@@ -130,7 +163,10 @@ describe('chat-transport-ops', () => {
 
   describe('chat_auth_check', () => {
     it('checks authentication status', async () => {
-      const result = await findOp(ops, 'chat_auth_check').handler({ userId: 'u1', storagePath: '/tmp/auth.json' });
+      const result = await findOp(ops, 'chat_auth_check').handler({
+        userId: 'u1',
+        storagePath: '/tmp/auth.json',
+      });
       expect(result).toEqual({ userId: 'u1', authenticated: true, lockedOut: false });
     });
   });
@@ -138,7 +174,9 @@ describe('chat-transport-ops', () => {
   describe('chat_auth_authenticate', () => {
     it('authenticates user with passphrase', async () => {
       const result = await findOp(ops, 'chat_auth_authenticate').handler({
-        userId: 'u1', passphrase: 'secret', storagePath: '/tmp/auth.json',
+        userId: 'u1',
+        passphrase: 'secret',
+        storagePath: '/tmp/auth.json',
       });
       expect(result).toEqual({ userId: 'u1', success: true, lockedOut: false });
       expect(mockAuthManager.authenticate).toHaveBeenCalledWith('u1', 'secret');
@@ -147,16 +185,22 @@ describe('chat-transport-ops', () => {
 
   describe('chat_auth_revoke', () => {
     it('revokes authentication', async () => {
-      const result = await findOp(ops, 'chat_auth_revoke').handler({ userId: 'u1', storagePath: '/tmp/auth.json' });
+      const result = await findOp(ops, 'chat_auth_revoke').handler({
+        userId: 'u1',
+        storagePath: '/tmp/auth.json',
+      });
       expect(result).toEqual({ revoked: true, userId: 'u1' });
     });
   });
 
   describe('chat_auth_status', () => {
     it('returns auth status', async () => {
-      const result = await findOp(ops, 'chat_auth_status').handler({ storagePath: '/tmp/auth.json' });
+      const result = await findOp(ops, 'chat_auth_status').handler({
+        storagePath: '/tmp/auth.json',
+      });
       expect(result).toEqual({
-        enabled: true, authenticatedCount: 1,
+        enabled: true,
+        authenticatedCount: 1,
         authenticatedUsers: [{ userId: 'u1', authenticatedAt: 1000 }],
       });
     });
@@ -174,7 +218,9 @@ describe('chat-transport-ops', () => {
   describe('chat_bridge_register', () => {
     it('registers a tool', async () => {
       const result = await findOp(ops, 'chat_bridge_register').handler({
-        name: 'my-tool', description: 'A tool', inputSchema: { type: 'object' },
+        name: 'my-tool',
+        description: 'A tool',
+        inputSchema: { type: 'object' },
       });
       expect(result).toEqual({ registered: true, name: 'my-tool', totalTools: 1 });
     });
@@ -187,27 +233,34 @@ describe('chat-transport-ops', () => {
 
     it('returns tools after init', async () => {
       await findOp(ops, 'chat_bridge_init').handler({});
-      expect(await findOp(ops, 'chat_bridge_list').handler({})).toEqual({ tools: [{ name: 'tool1' }], count: 1 });
+      expect(await findOp(ops, 'chat_bridge_list').handler({})).toEqual({
+        tools: [{ name: 'tool1' }],
+        count: 1,
+      });
     });
   });
 
   describe('chat_bridge_execute', () => {
     it('returns error when not initialized', async () => {
-      expect(await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1' }))
-        .toEqual({ output: 'Bridge not initialized', isError: true });
+      expect(await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1' })).toEqual({
+        output: 'Bridge not initialized',
+        isError: true,
+      });
     });
 
     it('executes tool after init', async () => {
       await findOp(ops, 'chat_bridge_init').handler({});
-      expect(await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1', input: { a: 1 } }))
-        .toEqual({ output: 'result' });
+      expect(
+        await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1', input: { a: 1 } }),
+      ).toEqual({ output: 'result' });
     });
   });
 
   describe('chat_compress_output', () => {
     it('compresses output', async () => {
       const result = (await findOp(ops, 'chat_compress_output').handler({
-        toolName: 'test', output: 'long output text here',
+        toolName: 'test',
+        output: 'long output text here',
       })) as { compressed: string; originalLength: number; compressedLength: number };
       expect(result.originalLength).toBe(21);
       expect(result.compressedLength).toBe(10);
@@ -219,7 +272,8 @@ describe('chat-transport-ops', () => {
   describe('chat_voice_transcribe', () => {
     it('transcribes audio', async () => {
       const result = await findOp(ops, 'chat_voice_transcribe').handler({
-        audioBase64: Buffer.from('test').toString('base64'), openaiApiKey: 'key-123',
+        audioBase64: Buffer.from('test').toString('base64'),
+        openaiApiKey: 'key-123',
       });
       expect(result).toEqual({ text: 'hello world', language: 'en' });
     });
@@ -228,7 +282,8 @@ describe('chat-transport-ops', () => {
   describe('chat_voice_synthesize', () => {
     it('synthesizes speech', async () => {
       const result = (await findOp(ops, 'chat_voice_synthesize').handler({
-        text: 'hello', openaiApiKey: 'key-123',
+        text: 'hello',
+        openaiApiKey: 'key-123',
       })) as Record<string, unknown>;
       expect(result.success).toBe(true);
       expect(result.audioBase64).toBeDefined();
@@ -239,14 +294,19 @@ describe('chat-transport-ops', () => {
 
   describe('chat_queue_init', () => {
     it('initializes queue', async () => {
-      expect(await findOp(ops, 'chat_queue_init').handler({ queueDir: '/tmp/queue' }))
-        .toEqual({ initialized: true, inbox: 2, outbox: 1 });
+      expect(await findOp(ops, 'chat_queue_init').handler({ queueDir: '/tmp/queue' })).toEqual({
+        initialized: true,
+        inbox: 2,
+        outbox: 1,
+      });
     });
   });
 
   describe('chat_queue_inbox', () => {
     it('reads inbox', async () => {
-      const result = (await findOp(ops, 'chat_queue_inbox').handler({ queueDir: '/tmp/queue' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_queue_inbox').handler({
+        queueDir: '/tmp/queue',
+      })) as Record<string, unknown>;
       expect(result.count).toBe(1);
       expect(result.formatted).toBe('formatted');
     });
@@ -254,16 +314,23 @@ describe('chat-transport-ops', () => {
 
   describe('chat_queue_reply', () => {
     it('sends reply', async () => {
-      expect(await findOp(ops, 'chat_queue_reply').handler({
-        messageId: 'm1', chatId: 'chat-1', text: 'response', queueDir: '/tmp/queue',
-      })).toEqual({ sent: true, response: { id: 'r1' } });
+      expect(
+        await findOp(ops, 'chat_queue_reply').handler({
+          messageId: 'm1',
+          chatId: 'chat-1',
+          text: 'response',
+          queueDir: '/tmp/queue',
+        }),
+      ).toEqual({ sent: true, response: { id: 'r1' } });
     });
   });
 
   describe('chat_queue_drain', () => {
     it('drains outbox', async () => {
-      expect(await findOp(ops, 'chat_queue_drain').handler({ queueDir: '/tmp/queue' }))
-        .toEqual({ responses: [{ id: 'r1' }], count: 1 });
+      expect(await findOp(ops, 'chat_queue_drain').handler({ queueDir: '/tmp/queue' })).toEqual({
+        responses: [{ id: 'r1' }],
+        count: 1,
+      });
     });
   });
 });

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

@@ -375,6 +375,5 @@ export function createChatTransportOps(state: ChatState): OpDefinition[] {
         return { responses, count: responses.length };
       },
     },
-
   ];
 }

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

@@ -21,7 +21,14 @@ function makeMockContextEngine() {
       total: 1,
     }),
     analyze: vi.fn().mockReturnValue({
-      entities: { files: ['src/app.ts'], functions: [], domains: ['general'], actions: ['build'], technologies: [], patterns: [] },
+      entities: {
+        files: ['src/app.ts'],
+        functions: [],
+        domains: ['general'],
+        actions: ['build'],
+        technologies: [],
+        patterns: [],
+      },
       knowledge: { items: [], total: 0 },
       confidence: 0.7,
       detectedDomains: ['general'],
@@ -47,7 +54,11 @@ describe('context-facade', () => {
   it('registers all 3 ops', () => {
     expect(ops.size).toBe(3);
     expect([...ops.keys()]).toEqual(
-      expect.arrayContaining(['context_extract_entities', 'context_retrieve_knowledge', 'context_analyze']),
+      expect.arrayContaining([
+        'context_extract_entities',
+        'context_retrieve_knowledge',
+        'context_analyze',
+      ]),
     );
   });
 
@@ -74,7 +85,9 @@ describe('context-facade', () => {
   // ─── context_retrieve_knowledge ────────────────────────────────
 
   it('context_retrieve_knowledge calls engine with prompt', async () => {
-    const result = await executeOp(ops, 'context_retrieve_knowledge', { prompt: 'contrast patterns' });
+    const result = await executeOp(ops, 'context_retrieve_knowledge', {
+      prompt: 'contrast patterns',
+    });
     expect(result.success).toBe(true);
     expect(mockEngine.retrieveKnowledge).toHaveBeenCalledWith('contrast patterns', undefined);
   });
@@ -100,7 +113,9 @@ describe('context-facade', () => {
   });
 
   it('context_analyze propagates engine errors', async () => {
-    mockEngine.analyze.mockImplementation(() => { throw new Error('Engine failure'); });
+    mockEngine.analyze.mockImplementation(() => {
+      throw new Error('Engine failure');
+    });
     const result = await executeOp(ops, 'context_analyze', { prompt: 'fail' });
     expect(result.success).toBe(false);
     expect(result.error).toContain('Engine failure');

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

@@ -402,9 +402,9 @@ describe('createControlFacadeOps', () => {
 
   describe('routing_feedback', () => {
     it('records feedback', async () => {
-      vi.mocked(runtime.intentRouter.recordRoutingFeedback).mockReturnValue(
-        { recorded: true } as never,
-      );
+      vi.mocked(runtime.intentRouter.recordRoutingFeedback).mockReturnValue({
+        recorded: true,
+      } as never);
 
       const result = await findOp(ops, 'routing_feedback').handler({
         initialIntent: 'BUILD',

package/src/runtime/facades/index.ts

@@ -20,6 +20,13 @@ import { createContextFacadeOps } from './context-facade.js';
 import { createAgencyFacadeOps } from './agency-facade.js';
 import { createChatFacadeOps } from './chat-facade.js';
 import { createOperatorFacadeOps } from './operator-facade.js';
+import { createArchiveFacadeOps } from './archive-facade.js';
+import { createSyncFacadeOps } from './sync-facade.js';
+import { createReviewFacadeOps } from './review-facade.js';
+import { createIntakeFacadeOps } from './intake-facade.js';
+import { createLinksFacadeOps } from './links-facade.js';
+import { createBranchingFacadeOps } from './branching-facade.js';
+import { createTierFacadeOps } from './tier-facade.js';
 
 export function createSemanticFacades(runtime: AgentRuntime, agentId: string): FacadeConfig[] {
   const facades: FacadeConfig[] = [
@@ -91,6 +98,41 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
       description: 'Operator profile — personality learning, signals, adaptation.',
       ops: createOperatorFacadeOps(runtime),
     },
+    {
+      name: `${agentId}_archive`,
+      description: 'Archival, lifecycle, and knowledge maintenance.',
+      ops: createArchiveFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_sync`,
+      description: 'Git, Obsidian, and pack sync operations.',
+      ops: createSyncFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_review`,
+      description: 'Knowledge review workflow.',
+      ops: createReviewFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_intake`,
+      description: 'Content ingestion — books, URLs, text, batch import.',
+      ops: createIntakeFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_links`,
+      description: 'Entry linking — create, traverse, suggest, orphan detection.',
+      ops: createLinksFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_branching`,
+      description: 'Vault branching — create, list, merge, delete branches.',
+      ops: createBranchingFacadeOps(runtime),
+    },
+    {
+      name: `${agentId}_tier`,
+      description: 'Multi-vault tiers — connect, disconnect, search across sources.',
+      ops: createTierFacadeOps(runtime),
+    },
   ];
 
   return facades;

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

@@ -0,0 +1,215 @@
+/**
+ * Colocated contract tests for intake-facade.ts.
+ * Verifies that createIntakeFacadeOps correctly delegates to createIntakeOps
+ * via the AgentRuntime. Detailed handler tests live in intake-ops.test.ts.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createIntakeFacadeOps } from './intake-facade.js';
+import { captureOps, executeOp } from '../../engine/test-helpers.js';
+import type { CapturedOp } from '../../engine/test-helpers.js';
+import type { AgentRuntime } from '../types.js';
+
+// ─── Mock factories ──────────────────────────────────────────────────
+
+function makeMockIntakePipeline() {
+  return {
+    ingestBook: vi.fn().mockResolvedValue({ jobId: 'j1', chunks: 5 }),
+    processChunks: vi.fn().mockResolvedValue({ processed: 3, stored: 2 }),
+    getJob: vi.fn().mockReturnValue({ id: 'j1', status: 'active' }),
+    getChunks: vi.fn().mockReturnValue([{ id: 'c1' }, { id: 'c2' }]),
+    listJobs: vi.fn().mockReturnValue([{ id: 'j1' }, { id: 'j2' }]),
+    preview: vi.fn().mockResolvedValue({ items: [{ text: 'sample' }] }),
+  };
+}
+
+function makeMockTextIngester() {
+  return {
+    ingestUrl: vi.fn().mockResolvedValue({ ingested: 3, duplicates: 1 }),
+    ingestText: vi.fn().mockResolvedValue({ ingested: 2, duplicates: 0 }),
+    ingestBatch: vi.fn().mockResolvedValue({ total: 4, ingested: 3, duplicates: 1 }),
+  };
+}
+
+function makeRuntime(overrides: Partial<Record<string, unknown>> = {}): AgentRuntime {
+  return {
+    intakePipeline: makeMockIntakePipeline(),
+    textIngester: makeMockTextIngester(),
+    ...overrides,
+  } as unknown as AgentRuntime;
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────
+
+describe('intake-facade', () => {
+  let runtime: AgentRuntime;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    runtime = makeRuntime();
+    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', () => {
+    it('delegates to pipeline.ingestBook', async () => {
+      const result = await executeOp(ops, 'intake_ingest_book', {
+        pdfPath: '/book.pdf',
+        title: 'My Book',
+        domain: 'design',
+      });
+      expect(result.success).toBe(true);
+      const pipeline = runtime.intakePipeline as ReturnType<typeof makeMockIntakePipeline>;
+      expect(pipeline.ingestBook).toHaveBeenCalled();
+    });
+  });
+
+  describe('intake_process', () => {
+    it('delegates to pipeline.processChunks', async () => {
+      const result = await executeOp(ops, 'intake_process', { jobId: 'j1' });
+      expect(result.success).toBe(true);
+      const pipeline = runtime.intakePipeline as ReturnType<typeof makeMockIntakePipeline>;
+      expect(pipeline.processChunks).toHaveBeenCalledWith('j1', undefined);
+    });
+  });
+
+  describe('intake_status', () => {
+    it('returns job and chunks when jobId provided', async () => {
+      const result = await executeOp(ops, 'intake_status', { jobId: 'j1' });
+      expect(result.success).toBe(true);
+      const data = result.data as { job: { id: string }; chunks: unknown[] };
+      expect(data.job.id).toBe('j1');
+      expect(data.chunks).toHaveLength(2);
+    });
+
+    it('lists all jobs when no jobId', async () => {
+      const result = await executeOp(ops, 'intake_status', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { jobs: unknown[] };
+      expect(data.jobs).toHaveLength(2);
+    });
+  });
+
+  describe('intake_preview', () => {
+    it('delegates to pipeline.preview', async () => {
+      const result = await executeOp(ops, 'intake_preview', {
+        pdfPath: '/x.pdf',
+        title: 'T',
+        domain: 'd',
+        pageStart: 1,
+        pageEnd: 10,
+      });
+      expect(result.success).toBe(true);
+      const pipeline = runtime.intakePipeline as ReturnType<typeof makeMockIntakePipeline>;
+      expect(pipeline.preview).toHaveBeenCalledWith(
+        { pdfPath: '/x.pdf', title: 'T', domain: 'd' },
+        1,
+        10,
+      );
+    });
+  });
+
+  describe('ingest_url', () => {
+    it('delegates to textIngester.ingestUrl', async () => {
+      const result = await executeOp(ops, 'ingest_url', {
+        url: 'https://example.com',
+        domain: 'test',
+        tags: ['t1'],
+      });
+      expect(result.success).toBe(true);
+      const ingester = runtime.textIngester as ReturnType<typeof makeMockTextIngester>;
+      expect(ingester.ingestUrl).toHaveBeenCalledWith('https://example.com', {
+        domain: 'test',
+        tags: ['t1'],
+      });
+    });
+  });
+
+  describe('ingest_text', () => {
+    it('delegates to textIngester.ingestText', async () => {
+      const result = await executeOp(ops, 'ingest_text', {
+        text: 'content',
+        title: 'My Notes',
+        sourceType: 'transcript',
+      });
+      expect(result.success).toBe(true);
+      const ingester = runtime.textIngester as ReturnType<typeof makeMockTextIngester>;
+      expect(ingester.ingestText).toHaveBeenCalled();
+    });
+  });
+
+  describe('ingest_batch', () => {
+    it('delegates to textIngester.ingestBatch', async () => {
+      const result = await executeOp(ops, 'ingest_batch', {
+        items: [{ text: 'a', title: 'A' }],
+      });
+      expect(result.success).toBe(true);
+      const ingester = runtime.textIngester as ReturnType<typeof makeMockTextIngester>;
+      expect(ingester.ingestBatch).toHaveBeenCalled();
+    });
+  });
+
+  // ─── Graceful degradation ──────────────────────────────────────────
+
+  describe('when pipeline is null', () => {
+    it('intake ops return error', async () => {
+      const rt = makeRuntime({ intakePipeline: null });
+      const nullOps = captureOps(createIntakeFacadeOps(rt));
+      const result = await executeOp(nullOps, 'intake_ingest_book', {
+        pdfPath: '/x.pdf',
+        title: 'T',
+        domain: 'd',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { error: string };
+      expect(data.error).toBe('Intake pipeline not configured');
+    });
+  });
+
+  describe('when textIngester is null', () => {
+    it('ingest ops return error', async () => {
+      const rt = makeRuntime({ textIngester: null });
+      const nullOps = captureOps(createIntakeFacadeOps(rt));
+      const result = await executeOp(nullOps, 'ingest_url', {
+        url: 'https://example.com',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { error: string };
+      expect(data.error).toContain('Text ingester not configured');
+    });
+  });
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Intake facade — content ingestion ops.
+ * intake_ingest_book, intake_process, intake_status, intake_preview,
+ * ingest_url, ingest_text, ingest_batch.
+ */
+
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+import { createIntakeOps } from '../intake-ops.js';
+
+export function createIntakeFacadeOps(runtime: AgentRuntime): OpDefinition[] {
+  const { intakePipeline, textIngester } = runtime;
+  return createIntakeOps(intakePipeline, textIngester);
+}