@soleri/core 9.3.0 → 9.4.0

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

@@ -12,7 +12,7 @@ import { createChainOps } from '../chain-ops.js';
 import { PlanGradeRejectionError } from '../../planning/planner.js';
 
 export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { planner } = runtime;
+  const { planner, vault } = runtime;
 
   return [
     // ─── Planning (inline from core-ops.ts) ─────────────────────
@@ -45,16 +45,35 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           .describe('Rejected alternative approaches — plans with 2+ alternatives score higher'),
       }),
       handler: async (params) => {
+        const objective = params.objective as string;
+        const decisions = ((params.decisions as string[]) ?? []).slice();
+
+        // Vault enrichment: search for patterns matching the objective
+        let vaultEntryIds: string[] = [];
+        try {
+          const results = vault.search(objective, { limit: 5 });
+          if (results.length > 0) {
+            vaultEntryIds = results.map((r) => r.entry.id);
+            for (const r of results) {
+              decisions.push(
+                `Vault pattern: ${r.entry.title ?? r.entry.id} (score: ${r.score.toFixed(2)}) [entryId:${r.entry.id}]`,
+              );
+            }
+          }
+        } catch {
+          // Vault search failed — proceed without enrichment
+        }
+
         const plan = planner.create({
-          objective: params.objective as string,
+          objective,
           scope: params.scope as string,
-          decisions: (params.decisions as string[]) ?? [],
+          decisions,
           tasks: (params.tasks as Array<{ title: string; description: string }>) ?? [],
           alternatives: params.alternatives as
             | Array<{ approach: string; pros: string[]; cons: string[]; rejected_reason: string }>
             | undefined,
         });
-        return { created: true, plan };
+        return { created: true, plan, vaultEntryIds };
       },
     },
     {

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

@@ -1,7 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createOrchestrateOps } from './orchestrate-ops.js';
+import { assessTaskComplexity } from '../planning/task-complexity-assessor.js';
 import type { AgentRuntime } from './types.js';
 
+vi.mock('node:fs', () => ({
+  default: {
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+  },
+}));
+
 // ---------------------------------------------------------------------------
 // Mocks for external modules
 // ---------------------------------------------------------------------------
@@ -241,6 +251,73 @@ describe('createOrchestrateOps', () => {
       await op.handler({ planId: 'plan-1', sessionId: 'session-1' });
       expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-1');
     });
+
+    it('works without a preceding plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        summary: 'Fixed a typo in the README',
+      })) as Record<string, unknown>;
+
+      // Should not call planner.complete
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // Should return a lightweight completion record
+      const plan = result.plan as Record<string, unknown>;
+      expect(plan.status).toBe('completed');
+      expect(plan.objective).toBe('Fixed a typo in the README');
+    });
+
+    it('captures knowledge even without plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        summary: 'Refactored utility function',
+      });
+
+      // Brain session end and knowledge extraction still run
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-1' }),
+      );
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-1');
+    });
+
+    it('skips anti-rationalization gate when no criteria', async () => {
+      const { detectRationalizations } = await import('../planning/rationalization-detector.js');
+      const op = findOp(ops, 'orchestrate_complete');
+
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        summary: 'This was basically done already',
+      });
+
+      // detectRationalizations should never be called since there are no criteria
+      expect(detectRationalizations).not.toHaveBeenCalled();
+      // Should still complete successfully
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalled();
+    });
+
+    it('still runs brain session end without plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        toolsUsed: ['grep', 'edit'],
+        filesModified: [],
+      })) as Record<string, unknown>;
+
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({
+          action: 'end',
+          sessionId: 'session-1',
+          planOutcome: 'completed',
+          toolsUsed: ['grep', 'edit'],
+        }),
+      );
+      expect(result.session).toBeDefined();
+    });
   });
 
   // ─── orchestrate_status ───────────────────────────────────────
@@ -299,4 +376,331 @@ describe('createOrchestrateOps', () => {
       await expect(op.handler({ planId: 'missing' })).rejects.toThrow('not found');
     });
   });
+
+  // ─── task auto-assessment routing ────────────────────────────
+  //
+  // Integration-style tests that verify the full assess → route → complete flow:
+  // 1. Use TaskComplexityAssessor to classify the task
+  // 2. Route to direct execution (simple) or planning (complex)
+  // 3. Complete via orchestrate_complete in both paths
+
+  describe('task auto-assessment routing', () => {
+    it('simple task routes to direct execution + complete', async () => {
+      // Step 1: Assess — "fix typo in README" should be simple
+      const assessment = assessTaskComplexity({ prompt: 'fix typo in README' });
+      expect(assessment.classification).toBe('simple');
+
+      // Step 2: Skip planning, go straight to complete without a planId
+      const completeOp = findOp(ops, 'orchestrate_complete');
+      const result = (await completeOp.handler({
+        sessionId: 'session-simple',
+        outcome: 'completed',
+        summary: 'Fixed typo in README',
+      })) as Record<string, unknown>;
+
+      // Should not touch the planner at all
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // Should still produce a valid completion record
+      const plan = result.plan as Record<string, unknown>;
+      expect(plan.status).toBe('completed');
+      expect(plan.objective).toBe('Fixed typo in README');
+
+      // Knowledge should still be captured
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-simple');
+    });
+
+    it('complex task routes through planning + complete', async () => {
+      // Step 1: Assess — cross-cutting auth task should be complex
+      const assessment = assessTaskComplexity({
+        prompt: 'add authentication across all API routes',
+        filesEstimated: 8,
+      });
+      expect(assessment.classification).toBe('complex');
+
+      // Step 2: Create a plan via orchestrate_plan
+      const planOp = findOp(ops, 'orchestrate_plan');
+      const planResult = (await planOp.handler({
+        prompt: 'add authentication across all API routes',
+      })) as Record<string, unknown>;
+      expect(planResult).toHaveProperty('plan');
+      expect(planResult).toHaveProperty('flow');
+
+      // Step 3: Complete with the planId
+      const completeOp = findOp(ops, 'orchestrate_complete');
+      const result = (await completeOp.handler({
+        planId: 'plan-1',
+        sessionId: 'session-complex',
+        outcome: 'completed',
+        summary: 'Added authentication middleware to all API routes',
+      })) as Record<string, unknown>;
+
+      // Should complete via the planner lifecycle
+      expect(rt.planner.complete).toHaveBeenCalledWith('plan-1');
+
+      // Knowledge should be captured
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-complex' }),
+      );
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-complex');
+
+      // Plan should be marked completed
+      const completedPlan = result.plan as Record<string, unknown>;
+      expect(completedPlan.status).toBe('completed');
+    });
+
+    it('orchestrate_complete captures knowledge in both paths', async () => {
+      // ── Simple path (no planId) ──
+      vi.clearAllMocks();
+      rt = mockRuntime();
+      ops = createOrchestrateOps(rt);
+
+      await findOp(ops, 'orchestrate_complete').handler({
+        sessionId: 'session-simple',
+        outcome: 'completed',
+        summary: 'Renamed a variable',
+      });
+
+      // Brain session end called
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-simple' }),
+      );
+      // Knowledge extraction called
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-simple');
+      // Planner.complete NOT called (no plan)
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // ── Complex path (with planId) ──
+      vi.clearAllMocks();
+      rt = mockRuntime();
+      ops = createOrchestrateOps(rt);
+
+      await findOp(ops, 'orchestrate_complete').handler({
+        planId: 'plan-1',
+        sessionId: 'session-complex',
+        outcome: 'completed',
+        summary: 'Implemented full auth layer',
+      });
+
+      // Brain session end called
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-complex' }),
+      );
+      // Knowledge extraction called
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-complex');
+      // Planner.complete IS called (has plan)
+      expect(rt.planner.complete).toHaveBeenCalledWith('plan-1');
+    });
+
+    it('assessment result includes non-empty reasoning for simple tasks', () => {
+      const result = assessTaskComplexity({ prompt: 'fix typo in README' });
+      expect(result.classification).toBe('simple');
+      expect(typeof result.reasoning).toBe('string');
+      expect(result.reasoning.length).toBeGreaterThan(0);
+    });
+
+    it('orchestrate_complete compounds operator signals when provided', async () => {
+      const compoundSignalsMock = vi.fn();
+      (rt as Record<string, unknown>).operatorContextStore = {
+        compoundSignals: compoundSignalsMock,
+        hasDrifted: vi.fn().mockReturnValue(false),
+        renderContextFile: vi.fn(),
+      };
+      ops = createOrchestrateOps(rt);
+
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {
+          expertise: [{ topic: 'typescript', level: 'expert', confidence: 0.9 }],
+          corrections: [{ rule: 'use conventional commits', scope: 'global' }],
+          interests: [{ tag: 'coffee' }],
+          patterns: [{ pattern: 'prefers small PRs', frequency: 'frequent' }],
+        },
+      });
+
+      expect(compoundSignalsMock).toHaveBeenCalledWith(
+        {
+          expertise: [{ topic: 'typescript', level: 'expert', confidence: 0.9 }],
+          corrections: [{ rule: 'use conventional commits', scope: 'global' }],
+          interests: [{ tag: 'coffee' }],
+          patterns: [{ pattern: 'prefers small PRs', frequency: 'frequent' }],
+        },
+        'session-1',
+      );
+    });
+
+    it('orchestrate_complete handles empty operator signals gracefully', async () => {
+      const compoundSignalsMock = vi.fn();
+      (rt as Record<string, unknown>).operatorContextStore = {
+        compoundSignals: compoundSignalsMock,
+        hasDrifted: vi.fn().mockReturnValue(false),
+        renderContextFile: vi.fn(),
+      };
+      ops = createOrchestrateOps(rt);
+
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {},
+      });
+
+      // Empty object with default arrays should be passed through
+      expect(compoundSignalsMock).toHaveBeenCalledTimes(1);
+      const [passedSignals, passedSessionId] = compoundSignalsMock.mock.calls[0];
+      expect(passedSessionId).toBe('session-1');
+      // Zod defaults produce empty arrays for each field
+      expect(passedSignals).toBeDefined();
+      expect(Array.isArray(passedSignals.expertise ?? [])).toBe(true);
+      expect(Array.isArray(passedSignals.corrections ?? [])).toBe(true);
+      expect(Array.isArray(passedSignals.interests ?? [])).toBe(true);
+      expect(Array.isArray(passedSignals.patterns ?? [])).toBe(true);
+    });
+
+    it('orchestrate_complete works when operatorContextStore not available', async () => {
+      // Ensure no operatorContextStore on runtime (backward compat)
+      delete (rt as Record<string, unknown>).operatorContextStore;
+      ops = createOrchestrateOps(rt);
+
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {
+          expertise: [{ topic: 'react', level: 'intermediate' }],
+          corrections: [],
+          interests: [],
+          patterns: [],
+        },
+      })) as Record<string, unknown>;
+
+      // Should complete normally without errors
+      expect(result).toHaveProperty('plan');
+      expect(result).toHaveProperty('session');
+    });
+
+    it('orchestrate_complete re-renders context file when drift detected', async () => {
+      const compoundSignalsMock = vi.fn();
+      const hasDriftedMock = vi.fn().mockReturnValue(true);
+      const renderContextFileMock = vi
+        .fn()
+        .mockReturnValue(
+          '# Operator Context\n\n**Expertise:** typescript (expert, 1 sessions, confidence 0.90).',
+        );
+      (rt as Record<string, unknown>).operatorContextStore = {
+        compoundSignals: compoundSignalsMock,
+        hasDrifted: hasDriftedMock,
+        renderContextFile: renderContextFileMock,
+      };
+      rt.config.agentDir = '/tmp/test-agent';
+      ops = createOrchestrateOps(rt);
+
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {
+          expertise: [{ topic: 'typescript', level: 'expert', confidence: 0.9 }],
+          corrections: [],
+          interests: [],
+          patterns: [],
+        },
+      });
+
+      expect(compoundSignalsMock).toHaveBeenCalled();
+      expect(hasDriftedMock).toHaveBeenCalled();
+      expect(renderContextFileMock).toHaveBeenCalled();
+      expect(fs.mkdirSync).toHaveBeenCalledWith(path.join('/tmp/test-agent', 'instructions'), {
+        recursive: true,
+      });
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.join('/tmp/test-agent', 'instructions', 'operator-context.md'),
+        '# Operator Context\n\n**Expertise:** typescript (expert, 1 sessions, confidence 0.90).',
+        'utf-8',
+      );
+    });
+
+    it('orchestrate_complete skips file write when no agentDir', async () => {
+      const compoundSignalsMock = vi.fn();
+      const hasDriftedMock = vi.fn().mockReturnValue(true);
+      const renderContextFileMock = vi.fn().mockReturnValue('# Operator Context');
+      (rt as Record<string, unknown>).operatorContextStore = {
+        compoundSignals: compoundSignalsMock,
+        hasDrifted: hasDriftedMock,
+        renderContextFile: renderContextFileMock,
+      };
+      // agentDir is NOT set
+      delete (rt.config as Record<string, unknown>).agentDir;
+      ops = createOrchestrateOps(rt);
+
+      vi.mocked(fs.mkdirSync).mockClear();
+      vi.mocked(fs.writeFileSync).mockClear();
+
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {
+          expertise: [{ topic: 'react', level: 'intermediate' }],
+          corrections: [],
+          interests: [],
+          patterns: [],
+        },
+      });
+
+      expect(compoundSignalsMock).toHaveBeenCalled();
+      expect(hasDriftedMock).toHaveBeenCalled();
+      // Should NOT write to disk since agentDir is missing
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('orchestrate_complete skips file write when no drift', async () => {
+      const compoundSignalsMock = vi.fn();
+      const hasDriftedMock = vi.fn().mockReturnValue(false);
+      const renderContextFileMock = vi.fn();
+      (rt as Record<string, unknown>).operatorContextStore = {
+        compoundSignals: compoundSignalsMock,
+        hasDrifted: hasDriftedMock,
+        renderContextFile: renderContextFileMock,
+      };
+      rt.config.agentDir = '/tmp/test-agent';
+      ops = createOrchestrateOps(rt);
+
+      vi.mocked(fs.mkdirSync).mockClear();
+      vi.mocked(fs.writeFileSync).mockClear();
+
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        operatorSignals: {
+          expertise: [],
+          corrections: [],
+          interests: [],
+          patterns: [],
+        },
+      });
+
+      expect(compoundSignalsMock).toHaveBeenCalled();
+      expect(hasDriftedMock).toHaveBeenCalled();
+      // No drift means no file write
+      expect(renderContextFileMock).not.toHaveBeenCalled();
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('assessment result includes non-empty reasoning for complex tasks', () => {
+      const result = assessTaskComplexity({
+        prompt: 'add authentication across all API routes',
+        filesEstimated: 8,
+        domains: ['auth', 'api', 'middleware'],
+      });
+      expect(result.classification).toBe('complex');
+      expect(typeof result.reasoning).toBe('string');
+      expect(result.reasoning.length).toBeGreaterThan(0);
+    });
+  });
 });