@soleri/core 9.14.4 → 9.16.7

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

@@ -1,7 +1,7 @@
 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 { createOrchestrateOps, mapVaultResults } from './orchestrate-ops.js';
 import { assessTaskComplexity } from '../planning/task-complexity-assessor.js';
 import type { AgentRuntime } from './types.js';
 
@@ -104,6 +104,7 @@ function mockRuntime(): AgentRuntime {
     },
     brain: {
       recordFeedback: vi.fn(),
+      intelligentSearch: vi.fn().mockResolvedValue([]),
     },
     brainIntelligence: {
       recommend: vi.fn().mockReturnValue([]),
@@ -164,16 +165,6 @@ describe('createOrchestrateOps', () => {
     ops = createOrchestrateOps(rt);
   });
 
-  it('returns all orchestrate ops', () => {
-    expect(ops.length).toBeGreaterThanOrEqual(5);
-    const names = ops.map((o) => o.name);
-    expect(names).toContain('orchestrate_plan');
-    expect(names).toContain('orchestrate_execute');
-    expect(names).toContain('orchestrate_complete');
-    expect(names).toContain('orchestrate_status');
-    expect(names).toContain('orchestrate_quick_capture');
-  });
-
   // ─── orchestrate_plan ─────────────────────────────────────────
 
   describe('orchestrate_plan', () => {
@@ -190,18 +181,159 @@ describe('createOrchestrateOps', () => {
       expect(flow.intent).toBe('BUILD');
     });
 
-    it('falls back to vault search when brain has no recommendations', async () => {
+    it('vault results appear when brain recommend has no data', async () => {
+      // intelligentSearch succeeds; vault results appear even when brain.recommend throws.
       const op = findOp(ops, 'orchestrate_plan');
       vi.mocked(rt.brainIntelligence.recommend).mockImplementation(() => {
         throw new Error('no data');
       });
-      vi.mocked(rt.vault.search).mockReturnValue([
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
         { entry: { id: 'e1', title: 'Pattern A' }, score: 0.8 },
       ] as never);
       const result = (await op.handler({ prompt: 'fix a bug' })) as Record<string, unknown>;
       const recs = result.recommendations as Array<Record<string, unknown>>;
       expect(recs.length).toBe(1);
       expect(recs[0].pattern).toBe('Pattern A');
+      expect(recs[0].source).toBe('vault');
+    });
+
+    it('intelligentSearch is called for vault retrieval — semantic search is primary', async () => {
+      // The primary vault retrieval path must use semantic search, not keyword search.
+      // If intelligentSearch were not called, ranking would fall back to TF-IDF keyword
+      // frequency, missing semantically related entries.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brainIntelligence.recommend).mockReturnValue([
+        { pattern: 'Brain Pattern', strength: 70 },
+      ] as never);
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
+        { entry: { id: 'v1', title: 'Vault Pattern' }, score: 0.9 },
+      ] as never);
+      await op.handler({ prompt: 'build a feature' });
+      expect(rt.brain.intelligentSearch).toHaveBeenCalled();
+    });
+
+    it('vault results precede brain results and brain does not duplicate vault entries', async () => {
+      // Vault patterns come first; brain adds only novel patterns.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
+        { entry: { id: 'v1', title: 'Vault Pattern' }, score: 0.9 },
+      ] as never);
+      vi.mocked(rt.brainIntelligence.recommend).mockReturnValue([
+        { pattern: 'Vault Pattern', strength: 70 }, // duplicate — should be dropped
+        { pattern: 'Brain Pattern', strength: 60 }, // novel — should be appended
+      ] as never);
+      const result = (await op.handler({ prompt: 'build something' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs).toHaveLength(2);
+      expect(recs[0].source).toBe('vault');
+      expect(recs[0].pattern).toBe('Vault Pattern');
+      expect(recs[1].source).toBe('brain');
+      expect(recs[1].pattern).toBe('Brain Pattern');
+    });
+
+    it('falls back to vault.search when intelligentSearch throws', async () => {
+      // If the semantic layer is unavailable, keyword search covers it.
+      // Without this fallback, any intelligentSearch failure would silently drop all vault results.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockRejectedValue(new Error('embedding unavailable'));
+      vi.mocked(rt.vault.search).mockReturnValue([
+        { entry: { id: 'k1', title: 'Keyword Pattern' }, score: 0.6 },
+      ] as never);
+      const result = (await op.handler({ prompt: 'fix bug' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs).toHaveLength(1);
+      expect(recs[0].pattern).toBe('Keyword Pattern');
+      expect(recs[0].source).toBe('vault');
+    });
+
+    it('brain results used alone when both vault search paths are unavailable', async () => {
+      // If intelligentSearch and vault.search both fail, brain results cover the gap.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockRejectedValue(new Error('down'));
+      vi.mocked(rt.vault.search).mockImplementation(() => {
+        throw new Error('vault down');
+      });
+      vi.mocked(rt.brainIntelligence.recommend).mockReturnValue([
+        { pattern: 'Brain Only Pattern', strength: 65 },
+      ] as never);
+      const result = (await op.handler({ prompt: 'fix bug' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs).toHaveLength(1);
+      expect(recs[0].source).toBe('brain');
+      expect(recs[0].pattern).toBe('Brain Only Pattern');
+    });
+
+    it('includes context and example from vault entry body in recommendations', async () => {
+      // RankedResult.entry contains the full IntelligenceEntry — context and example
+      // must be forwarded into the recommendations payload, not dropped.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
+        {
+          entry: {
+            id: 'e-full',
+            title: 'Anti-Pattern: Skip Tests',
+            context: 'Never skip tests when under time pressure.',
+            example: 'Adding --passWithNoTests to CI.',
+          },
+          score: 0.9,
+        },
+      ] as never);
+      const result = (await op.handler({ prompt: 'write tests quickly' })) as Record<
+        string,
+        unknown
+      >;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs[0].context).toBe('Never skip tests when under time pressure.');
+      expect(recs[0].example).toBe('Adding --passWithNoTests to CI.');
+    });
+
+    it('omits context key when vault entry has no body', async () => {
+      // Title-only entries must not surface context: null or context: "" — the key should
+      // be absent so consumers can reliably check `if (rec.context)`.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
+        { entry: { id: 'e-bare', title: 'Pattern B' }, score: 0.7 },
+      ] as never);
+      const result = (await op.handler({ prompt: 'build something' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect('context' in recs[0]).toBe(false);
+      expect('example' in recs[0]).toBe(false);
+    });
+
+    it('sets mandatory:true for critical vault entries', async () => {
+      // A critical entry must surface as mandatory so gate injection can promote
+      // it to a hard stop. If severity is ignored, critical rules are treated
+      // identically to suggestions — the whole enforcement chain breaks.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([
+        { entry: { id: 'c1', title: 'Critical Rule', severity: 'critical' }, score: 0.95 },
+        { entry: { id: 'w1', title: 'Warning Rule', severity: 'warning' }, score: 0.75 },
+        { entry: { id: 's1', title: 'Suggestion', severity: 'suggestion' }, score: 0.5 },
+      ] as never);
+      const result = (await op.handler({ prompt: 'plan something' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      const critical = recs.find((r) => r.pattern === 'Critical Rule');
+      const warning = recs.find((r) => r.pattern === 'Warning Rule');
+      const suggestion = recs.find((r) => r.pattern === 'Suggestion');
+      expect(critical?.mandatory).toBe(true);
+      expect(critical?.strength).toBe(100);
+      expect(warning?.mandatory).toBe(false);
+      expect(suggestion?.mandatory).toBe(false);
+    });
+
+    it('sets mandatory:false for all brain-sourced recommendations', async () => {
+      // Brain learns from usage frequency, not from curated rules — it cannot
+      // declare a rule mandatory. If brain recs were mandatory, spurious patterns
+      // from frequent usage would block plans with no policy basis.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockResolvedValue([] as never);
+      vi.mocked(rt.brainIntelligence.recommend).mockReturnValue([
+        { pattern: 'Brain Pattern', strength: 75 },
+      ] as never);
+      const result = (await op.handler({ prompt: 'build feature' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs[0].source).toBe('brain');
+      expect(recs[0].mandatory).toBe(false);
     });
 
     it('creates a planner plan for lifecycle tracking', async () => {
@@ -209,6 +341,93 @@ describe('createOrchestrateOps', () => {
       await op.handler({ prompt: 'Build something' });
       expect(rt.planner.create).toHaveBeenCalled();
     });
+
+    it('builds plan with no recommendations when all three retrieval paths fail', async () => {
+      // Triple-failure: intelligentSearch down, vault.search down, brain.recommend down.
+      // The plan must still build — missing recommendations are non-fatal.
+      const op = findOp(ops, 'orchestrate_plan');
+      vi.mocked(rt.brain.intelligentSearch).mockRejectedValue(new Error('down'));
+      vi.mocked(rt.vault.search).mockImplementation(() => {
+        throw new Error('vault down');
+      });
+      vi.mocked(rt.brainIntelligence.recommend).mockImplementation(() => {
+        throw new Error('brain down');
+      });
+      const result = (await op.handler({ prompt: 'fix bug' })) as Record<string, unknown>;
+      const recs = result.recommendations as Array<Record<string, unknown>>;
+      expect(recs).toHaveLength(0);
+      expect(result.flow).toBeDefined();
+    });
+  });
+
+  // ─── mapVaultResults isolation ─────────────────────────────────
+
+  describe('mapVaultResults', () => {
+    it('maps critical severity to mandatory:true and strength:100', () => {
+      const results = [
+        {
+          entry: {
+            id: 'e1',
+            title: 'No skipping tests',
+            severity: 'critical',
+            type: 'anti-pattern',
+          },
+          score: 0.9,
+          breakdown: {} as never,
+        },
+      ];
+      const recs = mapVaultResults(results);
+      expect(recs[0].mandatory).toBe(true);
+      expect(recs[0].strength).toBe(100);
+      expect(recs[0].source).toBe('vault');
+      expect(recs[0].entryType).toBe('anti-pattern');
+    });
+
+    it('maps warning severity to mandatory:false and strength:80', () => {
+      const results = [
+        {
+          entry: { id: 'e2', title: 'Warning Rule', severity: 'warning', type: 'pattern' },
+          score: 0.7,
+          breakdown: {} as never,
+        },
+      ];
+      const recs = mapVaultResults(results);
+      expect(recs[0].mandatory).toBe(false);
+      expect(recs[0].strength).toBe(80);
+    });
+
+    it('forwards context and example when present', () => {
+      const results = [
+        {
+          entry: {
+            id: 'e3',
+            title: 'Rule',
+            severity: 'warning',
+            type: 'pattern',
+            context: 'ctx',
+            example: 'ex',
+          },
+          score: 0.5,
+          breakdown: {} as never,
+        },
+      ];
+      const recs = mapVaultResults(results);
+      expect(recs[0].context).toBe('ctx');
+      expect(recs[0].example).toBe('ex');
+    });
+
+    it('does not set context or example keys when absent', () => {
+      const results = [
+        {
+          entry: { id: 'e4', title: 'Bare Rule', severity: 'suggestion', type: 'pattern' },
+          score: 0.4,
+          breakdown: {} as never,
+        },
+      ];
+      const recs = mapVaultResults(results);
+      expect('context' in recs[0]).toBe(false);
+      expect('example' in recs[0]).toBe(false);
+    });
   });
 
   // ─── orchestrate_execute ──────────────────────────────────────
@@ -749,11 +968,10 @@ describe('createOrchestrateOps', () => {
       expect(rt.planner.complete).toHaveBeenCalledWith('plan-1');
     });
 
-    it('assessment result includes non-empty reasoning for simple tasks', () => {
+    it('assessment result includes default reasoning when no signals triggered', () => {
       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);
+      expect(result.reasoning).toBe('No complexity signals detected — treating as simple task');
     });
 
     it('orchestrate_complete compounds operator signals when provided', async () => {
@@ -949,15 +1167,16 @@ describe('createOrchestrateOps', () => {
       expect(fs.writeFileSync).not.toHaveBeenCalled();
     });
 
-    it('assessment result includes non-empty reasoning for complex tasks', () => {
+    it('assessment result lists triggered signals in 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);
+      expect(result.reasoning).toBe(
+        'Complex: file-count, cross-cutting-keywords, multi-domain (score 50)',
+      );
     });
   });
 });

package/src/runtime/orchestrate-ops.ts

@@ -14,7 +14,48 @@ import path from 'node:path';
 import { z } from 'zod';
 import type { OpDefinition, FacadeConfig } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
-import { buildPlan } from '../flows/plan-builder.js';
+import { buildPlan, type VaultConstraint } from '../flows/plan-builder.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+// ---------------------------------------------------------------------------
+// Recommendation types + helpers (module-level for testability)
+// ---------------------------------------------------------------------------
+
+export interface PlanRecommendation {
+  pattern: string;
+  strength: number;
+  entryId?: string;
+  source: 'vault' | 'brain';
+  context?: string;
+  example?: string;
+  mandatory: boolean;
+  entryType?: 'pattern' | 'anti-pattern' | 'rule' | 'playbook';
+}
+
+/**
+ * Map vault search results to PlanRecommendation[].
+ * Accepts both RankedResult[] (semantic search) and SearchResult[] (keyword fallback)
+ * since both share the same entry: IntelligenceEntry shape.
+ * Critical entries get strength:100 and mandatory:true; all others get 80/false.
+ */
+export function mapVaultResults(
+  results: Array<{ entry: IntelligenceEntry; score: number }>,
+): PlanRecommendation[] {
+  return results.map((r) => {
+    const isCritical = r.entry.severity === 'critical';
+    const rec: PlanRecommendation = {
+      pattern: r.entry.title,
+      strength: isCritical ? 100 : 80,
+      entryId: r.entry.id,
+      source: 'vault',
+      mandatory: isCritical,
+      entryType: r.entry.type,
+    };
+    if (r.entry.context) rec.context = r.entry.context;
+    if (r.entry.example) rec.example = r.entry.example;
+    return rec;
+  });
+}
 import { FlowExecutor, getPlanRunDir, loadManifest, saveManifest } from '../flows/executor.js';
 import { createDispatcher } from '../flows/dispatch-registry.js';
 import { runEpilogue } from '../flows/epilogue.js';
@@ -376,43 +417,67 @@ export function createOrchestrateOps(
         // 1. Detect intent from prompt
         const intent = detectIntent(prompt);
 
-        // 2. Get brain recommendations — graceful degradation
-        let recommendations: Array<{ pattern: string; strength: number; entryId?: string }> = [];
+        // 2. Build recommendations — vault first (authoritative), brain enriches (additive)
+        let recommendations: PlanRecommendation[] = [];
+
+        // Vault always runs first — curated explicit knowledge takes precedence.
+        // Prefer semantic search (vector-scored); fall back to keyword search.
+
         try {
-          const raw = brainIntelligence.recommend({
+          const vaultResults = await brain.intelligentSearch(prompt, {
             domain,
-            task: prompt,
             limit: 5,
           });
-          recommendations = raw.map((r) => {
-            // Look up vault entry ID by title for feedback tracking
-            const entries = vault.search(r.pattern, { limit: 1 });
-            const entryId =
-              entries.length > 0 && entries[0].entry.title === r.pattern
-                ? entries[0].entry.id
-                : undefined;
-            return { pattern: r.pattern, strength: r.strength, entryId };
-          });
+          recommendations = mapVaultResults(vaultResults);
         } catch {
-          // Brain has no data yet
-        }
-
-        // Fallback to vault if brain empty
-        if (recommendations.length === 0) {
+          // Semantic search unavailable — fall back to keyword search
           try {
             const vaultResults = vault.search(prompt, { domain, limit: 5 });
-            recommendations = vaultResults.map((r) => ({
-              pattern: r.entry.title,
-              strength: 50,
-              entryId: r.entry.id,
-            }));
+            recommendations = mapVaultResults(vaultResults);
           } catch {
-            // Vault search failed
+            // Vault unavailable — brain will cover below
+          }
+        }
+
+        // Brain enriches with learned usage patterns — additive, never replaces vault
+        try {
+          const brainResults = brainIntelligence.recommend({
+            domain,
+            task: prompt,
+            limit: 5,
+          });
+          for (const r of brainResults) {
+            if (!recommendations.find((rec) => rec.pattern === r.pattern)) {
+              recommendations.push({
+                pattern: r.pattern,
+                strength: r.strength,
+                source: 'brain',
+                mandatory: false,
+              });
+            }
           }
+        } catch {
+          // Brain has no data yet
         }
 
-        // 3. Build flow-engine plan
-        const plan = await buildPlan(intent, agentId, projectPath, runtime, prompt);
+        // 3. Build flow-engine plan — pass vault constraints for gate injection
+        const vaultConstraints: VaultConstraint[] = recommendations
+          .filter((r) => r.source === 'vault' && r.entryId)
+          .map((r) => ({
+            entryId: r.entryId!,
+            title: r.pattern,
+            context: r.context,
+            mandatory: r.mandatory,
+            entryType: r.entryType,
+          }));
+        const plan = await buildPlan(
+          intent,
+          agentId,
+          projectPath,
+          runtime,
+          prompt,
+          vaultConstraints,
+        );
 
         // 3b. Merge workflow overrides (gates + tools) if agent has a matching workflow
         let workflowApplied: string | undefined;
@@ -436,7 +501,8 @@ export function createOrchestrateOps(
 
         // 5. Also create a planner plan for lifecycle tracking (backward compat)
         const decisions = recommendations.map((r) => {
-          const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
+          const label = r.source === 'vault' ? 'Vault pattern' : 'Brain pattern';
+          const base = `${label}: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
           return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
         });
         const tasks = (params.tasks as Array<{ title: string; description: string }>) ?? [];
@@ -492,6 +558,7 @@ export function createOrchestrateOps(
             skippedCount: plan.skipped.length,
             warnings: plan.warnings,
             estimatedTools: plan.estimatedTools,
+            ...(plan.recommendations ? { vaultConstraints: plan.recommendations } : {}),
             ...(workflowApplied ? { workflowOverride: workflowApplied } : {}),
           },
         };
@@ -607,6 +674,27 @@ export function createOrchestrateOps(
           const healthStatus = contextHealth.check();
           const healthWarning = buildHealthWarning(healthStatus, vault);
 
+          // Check for subagent review stage requirements from matched playbook
+          const legacyPlanForReview = planner.get(planId);
+          let reviewStagesRequired: string[] | undefined;
+          if (legacyPlanForReview?.playbookSessionId && runtime.playbookExecutor) {
+            const session_ = runtime.playbookExecutor.getSession(
+              legacyPlanForReview.playbookSessionId,
+            );
+            if (session_) {
+              const postTaskGates = session_.gates.filter((g) => g.phase === 'post-task');
+              if (postTaskGates.length > 0) {
+                reviewStagesRequired = postTaskGates.map((g) => g.checkType);
+              }
+            }
+          } else if (
+            legacyPlanForReview?.playbookMatch?.genericId === 'generic-subagent-execution' ||
+            legacyPlanForReview?.playbookMatch?.label?.toLowerCase().includes('subagent')
+          ) {
+            // Playbook matched but no live session — surface known review stages
+            reviewStagesRequired = ['spec-review', 'quality-review'];
+          }
+
           return {
             plan: { id: planId, status: 'executing' },
             session,
@@ -618,6 +706,14 @@ export function createOrchestrateOps(
               durationMs: aggregated.durationMs,
               totalUsage: aggregated.totalUsage,
             },
+            ...(reviewStagesRequired
+              ? {
+                  reviewStagesRequired,
+                  reviewNote:
+                    'Subagent Execution playbook matched. Each completed task requires review evidence before status can be set to completed: ' +
+                    reviewStagesRequired.join(' → '),
+                }
+              : {}),
             ...(reapedOrphans.length > 0 ? { reapedOrphans } : {}),
             ...(healthWarning ? { contextHealth: healthWarning } : {}),
           };
@@ -775,7 +871,10 @@ export function createOrchestrateOps(
           .string()
           .optional()
           .describe('ID of the executing plan to complete (optional for direct tasks)'),
-        sessionId: z.string().describe('ID of the brain session to end'),
+        sessionId: z
+          .string()
+          .optional()
+          .describe('ID of the brain session to end (auto-resolved from planId if omitted)'),
         outcome: z
           .enum(['completed', 'abandoned', 'partial'])
           .optional()
@@ -842,7 +941,10 @@ export function createOrchestrateOps(
       }),
       handler: async (params) => {
         const planId = params.planId as string | undefined;
-        const sessionId = params.sessionId as string;
+        const sessionId =
+          (params.sessionId as string | undefined) ??
+          (planId ? brainIntelligence.getSessionByPlanId(planId)?.id : undefined) ??
+          '';
         const outcome = (params.outcome as string) ?? 'completed';
         const completionSummary = (params.summary as string) ?? '';
         const toolsUsed = (params.toolsUsed as string[]) ?? [];
@@ -945,17 +1047,19 @@ export function createOrchestrateOps(
           };
         }
 
-        // End brain session — runs regardless of plan existence
+        // End brain session — only if we have a valid sessionId
         const fixTrail = evidenceReport ? buildFixTrailSummary(evidenceReport) : undefined;
-        const session = brainIntelligence.lifecycle({
-          action: 'end',
-          sessionId,
-          planId,
-          planOutcome: outcome,
-          toolsUsed,
-          filesModified,
-          ...(fixTrail ? { context: `Fix trail: ${fixTrail}` } : {}),
-        });
+        const session = sessionId
+          ? brainIntelligence.lifecycle({
+              action: 'end',
+              sessionId,
+              planId,
+              planOutcome: outcome,
+              toolsUsed,
+              filesModified,
+              ...(fixTrail ? { context: `Fix trail: ${fixTrail}` } : {}),
+            })
+          : null;
 
         // Record brain feedback for vault entries referenced in plan decisions
         if (planObj && planObj.decisions) {
@@ -1018,6 +1122,11 @@ export function createOrchestrateOps(
                 entry.plan.context.probes,
                 entry.plan.context.projectPath,
                 summary,
+                {
+                  intent: entry.plan.intent,
+                  objective: completionSummary || entry.plan.summary,
+                  domain: entry.plan.context.entities?.technologies?.[0],
+                },
               );
             } catch {
               // Epilogue is best-effort
@@ -1043,11 +1152,27 @@ export function createOrchestrateOps(
           }
         }
 
+        // Best-effort worktree cleanup after plan completion
+        try {
+          const { worktreeReap } = await import('../utils/worktree-reaper.js');
+          Promise.resolve()
+            .then(() => worktreeReap((params.projectPath as string) ?? '.'))
+            .catch(() => {
+              /* best-effort */
+            });
+        } catch {
+          /* skip silently */
+        }
+
         return {
           plan: completedPlan,
           session,
           extraction,
-          epilogue: epilogueResult,
+          epilogue: epilogueResult ?? {
+            completed: true,
+            captured: false,
+            note: 'no flow plan in store',
+          },
           ...(impactReport ? { impactAnalysis: impactReport } : {}),
           evidenceReport,
           ...(warnings.length > 0 ? { warnings } : {}),

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

@@ -44,32 +44,6 @@ describe('createPackOps', () => {
     setHotRegister(null as never);
   });
 
-  it('returns 4 ops', () => {
-    runtime = makeMockRuntime();
-    ops = createPackOps(runtime);
-    expect(ops).toHaveLength(4);
-  });
-
-  it('has correct op names', () => {
-    runtime = makeMockRuntime();
-    ops = createPackOps(runtime);
-    expect(ops.map((o) => o.name)).toEqual([
-      'pack_validate',
-      'pack_install',
-      'pack_list',
-      'pack_uninstall',
-    ]);
-  });
-
-  it('assigns correct auth levels', () => {
-    runtime = makeMockRuntime();
-    ops = createPackOps(runtime);
-    expect(findOp('pack_validate').auth).toBe('read');
-    expect(findOp('pack_install').auth).toBe('admin');
-    expect(findOp('pack_list').auth).toBe('read');
-    expect(findOp('pack_uninstall').auth).toBe('admin');
-  });
-
   describe('pack_validate', () => {
     it('delegates to packInstaller.validate', async () => {
       runtime = makeMockRuntime();