@soleri/core 9.4.0 → 9.6.0

package/src/runtime/curator-extra-ops.test.ts

@@ -28,6 +28,13 @@ function mockRuntime() {
       start: vi.fn(),
       stop: vi.fn(),
     },
+    shutdownRegistry: {
+      register: vi.fn(),
+      closeAll: vi.fn(),
+      closeAllSync: vi.fn(),
+      size: 0,
+      isClosed: false,
+    },
   } as unknown as AgentRuntime;
 }
 

package/src/runtime/curator-extra-ops.ts

@@ -10,9 +10,18 @@ import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 
 export function createCuratorExtraOps(runtime: AgentRuntime): OpDefinition[] {
-  const { curator, jobQueue, pipelineRunner } = runtime;
+  const { curator, jobQueue, pipelineRunner, shutdownRegistry } = runtime;
   let consolidationInterval: ReturnType<typeof setInterval> | null = null;
 
+  // Register cleanup for any consolidation interval started during this session
+  shutdownRegistry.register('curatorConsolidation', () => {
+    if (consolidationInterval) {
+      clearInterval(consolidationInterval);
+      consolidationInterval = null;
+    }
+    pipelineRunner.stop();
+  });
+
   return [
     // ─── Entry History ──────────────────────────────────────────────
     {

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

@@ -30,6 +30,13 @@ function mockRuntime(): AgentRuntime {
       start: vi.fn(),
       stop: vi.fn(),
     },
+    shutdownRegistry: {
+      register: vi.fn(),
+      closeAll: vi.fn(),
+      closeAllSync: vi.fn(),
+      size: 0,
+      isClosed: false,
+    },
   } as unknown as AgentRuntime;
 }
 

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

@@ -195,6 +195,193 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Handoff ────────────────────────────────────────────────
+    {
+      name: 'handoff_generate',
+      description:
+        'Generate a structured handoff document for context transitions. ' +
+        'Pulls from active plan (if any) and recent session memories to produce ' +
+        'a markdown document that can bootstrap a new context window. ' +
+        'Ephemeral — NOT persisted to vault.',
+      auth: 'read',
+      schema: z.object({
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project path for filtering memories'),
+        sessionLimit: z
+          .number()
+          .optional()
+          .default(3)
+          .describe('Number of recent session memories to include'),
+      }),
+      handler: async (params) => {
+        const { planner } = runtime;
+        const projectPath = params.projectPath as string;
+        const sessionLimit = (params.sessionLimit as number) ?? 3;
+
+        const sections: string[] = [];
+        const now = new Date().toISOString();
+
+        sections.push('# Handoff Document');
+        sections.push('');
+        sections.push(`Generated: ${now}`);
+        sections.push('');
+
+        // ─── Active Plan Context ───────────────────────────
+        const activePlans = planner.getActive();
+        if (activePlans.length > 0) {
+          const plan = activePlans[0]; // Most relevant active plan
+          sections.push('## Active Plan');
+          sections.push('');
+          sections.push(`| Field | Value |`);
+          sections.push(`|-------|-------|`);
+          sections.push(`| **Plan ID** | ${plan.id} |`);
+          sections.push(`| **Objective** | ${plan.objective} |`);
+          sections.push(`| **Status** | ${plan.status} |`);
+          sections.push(`| **Scope** | ${plan.scope} |`);
+          sections.push('');
+
+          // Decisions
+          if (plan.decisions.length > 0) {
+            sections.push('### Decisions');
+            sections.push('');
+            for (const d of plan.decisions) {
+              if (typeof d === 'string') {
+                sections.push(`- ${d}`);
+              } else {
+                sections.push(`- **${d.decision}** — ${d.rationale}`);
+              }
+            }
+            sections.push('');
+          }
+
+          // Task status summary
+          if (plan.tasks.length > 0) {
+            sections.push('### Tasks');
+            sections.push('');
+            sections.push('| # | Task | Status |');
+            sections.push('|---|------|--------|');
+            for (let i = 0; i < plan.tasks.length; i++) {
+              const t = plan.tasks[i];
+              sections.push(`| ${i + 1} | ${t.title} | ${t.status} |`);
+            }
+            sections.push('');
+          }
+
+          // Approach
+          if (plan.approach) {
+            sections.push('### Approach');
+            sections.push('');
+            sections.push(plan.approach);
+            sections.push('');
+          }
+
+          // Additional active plans (just IDs)
+          if (activePlans.length > 1) {
+            sections.push('### Other Active Plans');
+            sections.push('');
+            for (let i = 1; i < activePlans.length; i++) {
+              const p = activePlans[i];
+              sections.push(`- **${p.id}**: ${p.objective} (${p.status})`);
+            }
+            sections.push('');
+          }
+        } else {
+          sections.push('## Active Plan');
+          sections.push('');
+          sections.push('No active plans.');
+          sections.push('');
+        }
+
+        // ─── Recent Session Context ────────────────────────
+        const recentSessions = vault.listMemories({
+          type: 'session',
+          projectPath,
+          limit: sessionLimit,
+        });
+
+        if (recentSessions.length > 0) {
+          sections.push('## Recent Sessions');
+          sections.push('');
+          for (const session of recentSessions) {
+            sections.push(`### ${session.createdAt}`);
+            sections.push('');
+            if (session.summary) {
+              sections.push(session.summary);
+              sections.push('');
+            }
+            if (session.nextSteps && session.nextSteps.length > 0) {
+              sections.push('**Next steps:**');
+              for (const step of session.nextSteps) {
+                sections.push(`- ${step}`);
+              }
+              sections.push('');
+            }
+            if (session.decisions && session.decisions.length > 0) {
+              sections.push('**Decisions:**');
+              for (const d of session.decisions) {
+                sections.push(`- ${d}`);
+              }
+              sections.push('');
+            }
+            if (session.filesModified && session.filesModified.length > 0) {
+              sections.push(`**Files modified:** ${session.filesModified.join(', ')}`);
+              sections.push('');
+            }
+          }
+        } else {
+          sections.push('## Recent Sessions');
+          sections.push('');
+          sections.push('No recent session memories found.');
+          sections.push('');
+        }
+
+        // ─── Resumption Hints ──────────────────────────────
+        sections.push('## Resumption');
+        sections.push('');
+        sections.push('Use this document to restore context after a context window transition.');
+        sections.push('');
+        if (activePlans.length > 0) {
+          const plan = activePlans[0];
+          const pendingTasks = plan.tasks.filter(
+            (t) => t.status === 'pending' || t.status === 'in_progress',
+          );
+          if (pendingTasks.length > 0) {
+            sections.push('**Immediate next actions:**');
+            for (const t of pendingTasks.slice(0, 5)) {
+              sections.push(
+                `- ${t.status === 'in_progress' ? '[IN PROGRESS]' : '[PENDING]'} ${t.title}`,
+              );
+            }
+            sections.push('');
+          }
+          if (plan.status === 'executing') {
+            sections.push(
+              '> Plan is in `executing` state. Continue with pending tasks or call `op:plan_reconcile` if complete.',
+            );
+          } else if (plan.status === 'reconciling') {
+            sections.push(
+              '> Plan is in `reconciling` state. Call `op:plan_complete_lifecycle` to finalize.',
+            );
+          }
+        }
+
+        const markdown = sections.join('\n');
+
+        return {
+          handoff: markdown,
+          meta: {
+            activePlanCount: activePlans.length,
+            activePlanId: activePlans.length > 0 ? activePlans[0].id : null,
+            recentSessionCount: recentSessions.length,
+            generatedAt: now,
+          },
+        };
+      },
+    },
+
     // ─── Satellite ops ───────────────────────────────────────────
     ...createMemoryExtraOps(runtime),
     ...createMemoryCrossProjectOps(runtime),

package/src/runtime/orchestrate-ops.ts

@@ -38,6 +38,7 @@ import {
 import { detectRationalizations } from '../planning/rationalization-detector.js';
 import { ImpactAnalyzer } from '../planning/impact-analyzer.js';
 import type { ImpactReport } from '../planning/impact-analyzer.js';
+import { recordPlanFeedback } from './plan-feedback-helper.js';
 
 // ---------------------------------------------------------------------------
 // Intent detection — keyword-based mapping from prompt to intent
@@ -235,7 +236,7 @@ export function createOrchestrateOps(
   runtime: AgentRuntime,
   facades?: FacadeConfig[],
 ): OpDefinition[] {
-  const { planner, brainIntelligence, vault, contextHealth } = runtime;
+  const { planner, brain, brainIntelligence, vault, contextHealth } = runtime;
   const agentId = runtime.config.agentId;
 
   return [
@@ -385,11 +386,149 @@ export function createOrchestrateOps(
         planId: z.string().describe('ID of the plan to execute (flow planId or legacy planId)'),
         domain: z.string().optional().describe('Domain for brain session tracking'),
         context: z.string().optional().describe('Additional context for the brain session'),
+        runtime: z
+          .string()
+          .optional()
+          .describe(
+            'Runtime adapter type (e.g. "claude-code", "codex"). ' +
+              'When provided, dispatches via the adapter instead of the flow engine.',
+          ),
+        subagent: z
+          .boolean()
+          .optional()
+          .describe(
+            'When true, dispatches plan tasks via SubagentDispatcher instead of FlowExecutor. ' +
+              'Each task runs as a separate subagent process.',
+          ),
+        parallel: z
+          .boolean()
+          .optional()
+          .describe(
+            'Run subagent tasks in parallel (default: true). Only applies when subagent=true.',
+          ),
+        maxConcurrent: z
+          .number()
+          .optional()
+          .describe('Max concurrent subagents (default: 3). Only applies when subagent=true.'),
       }),
       handler: async (params) => {
         const planId = params.planId as string;
         const domain = params.domain as string | undefined;
         const context = params.context as string | undefined;
+        const runtimeType = params.runtime as string | undefined;
+        const useSubagent = params.subagent as boolean | undefined;
+        const parallelMode = params.parallel as boolean | undefined;
+        const maxConcurrentParam = params.maxConcurrent as number | undefined;
+
+        // ── Subagent dispatch path ───────────────────────────────────
+        // When subagent=true, dispatch plan tasks via SubagentDispatcher.
+        // Each task runs as a separate child process via the adapter layer.
+        if (useSubagent && runtime.subagentDispatcher) {
+          const entry = planStore.get(planId);
+          const legacyPlan = !entry ? planner.get(planId) : undefined;
+          const tasks =
+            entry?.plan.steps.map((s) => ({
+              taskId: s.id,
+              prompt: s.name,
+              workspace: process.cwd(),
+              runtime: runtimeType,
+              timeout: 300_000,
+            })) ??
+            legacyPlan?.tasks?.map((t) => ({
+              taskId: t.id,
+              prompt: t.title ?? t.description ?? '',
+              workspace: process.cwd(),
+              runtime: runtimeType,
+              timeout: 300_000,
+            })) ??
+            [];
+
+          const aggregated = await runtime.subagentDispatcher.dispatch(tasks, {
+            parallel: parallelMode ?? true,
+            maxConcurrent: maxConcurrentParam ?? 3,
+          });
+
+          // Track in brain session
+          const existingSession = brainIntelligence.getSessionByPlanId(planId);
+          const session =
+            existingSession && !existingSession.endedAt
+              ? existingSession
+              : brainIntelligence.lifecycle({
+                  action: 'start',
+                  domain,
+                  context,
+                  planId,
+                });
+
+          contextHealth.track({
+            type: 'orchestrate_execute',
+            payloadSize: JSON.stringify(aggregated).length,
+          });
+          const healthStatus = contextHealth.check();
+          const healthWarning = buildHealthWarning(healthStatus, vault);
+
+          return {
+            plan: { id: planId, status: 'executing' },
+            session,
+            subagent: {
+              status: aggregated.status,
+              totalTasks: aggregated.totalTasks,
+              completed: aggregated.completed,
+              failed: aggregated.failed,
+              durationMs: aggregated.durationMs,
+              totalUsage: aggregated.totalUsage,
+            },
+            ...(healthWarning ? { contextHealth: healthWarning } : {}),
+          };
+        }
+
+        // ── Adapter dispatch path ────────────────────────────────────
+        // When a runtime is specified, dispatch the plan's prompt via the
+        // adapter instead of the flow engine. This is the integration point
+        // for multi-runtime support (GH #410).
+        if (runtimeType && runtime.adapterRegistry) {
+          const adapter = runtime.adapterRegistry.get(runtimeType);
+          const entry = planStore.get(planId);
+          const prompt = entry?.plan.summary ?? `Execute plan ${planId}`;
+
+          const adapterResult = await adapter.execute({
+            runId: `${planId}-${Date.now()}`,
+            prompt,
+            workspace: process.cwd(),
+            config: { planId, domain },
+          });
+
+          // Track in brain session
+          const existingSession = brainIntelligence.getSessionByPlanId(planId);
+          const session =
+            existingSession && !existingSession.endedAt
+              ? existingSession
+              : brainIntelligence.lifecycle({
+                  action: 'start',
+                  domain,
+                  context,
+                  planId,
+                });
+
+          contextHealth.track({
+            type: 'orchestrate_execute',
+            payloadSize: JSON.stringify(adapterResult).length,
+          });
+          const healthStatus = contextHealth.check();
+          const healthWarning = buildHealthWarning(healthStatus, vault);
+
+          return {
+            plan: { id: planId, status: 'executing' },
+            session,
+            adapter: {
+              type: runtimeType,
+              exitCode: adapterResult.exitCode,
+              summary: adapterResult.summary,
+              usage: adapterResult.usage,
+            },
+            ...(healthWarning ? { contextHealth: healthWarning } : {}),
+          };
+        }
 
         // Look up flow plan
         const entry = planStore.get(planId);
@@ -636,6 +775,19 @@ export function createOrchestrateOps(
           filesModified,
         });
 
+        // Record brain feedback for vault entries referenced in plan decisions
+        if (planObj && planObj.decisions) {
+          try {
+            recordPlanFeedback(
+              { objective: planObj.objective, decisions: planObj.decisions },
+              brain,
+              brainIntelligence,
+            );
+          } catch {
+            // Brain feedback is best-effort
+          }
+        }
+
         // Extract knowledge — runs regardless of plan existence
         let extraction = null;
         try {
@@ -847,7 +999,7 @@ export function createOrchestrateOps(
         }
 
         // 2. Detect GitHub context
-        const ctx = detectGitHubContext(projectPath);
+        const ctx = await detectGitHubContext(projectPath);
         if (!ctx) {
           return {
             status: 'skipped',
@@ -885,7 +1037,7 @@ export function createOrchestrateOps(
             };
           }
 
-          const updated = updateGitHubIssueBody(ctx.repo, linkToIssue, body);
+          const updated = await updateGitHubIssueBody(ctx.repo, linkToIssue, body);
           if (!updated) {
             return {
               status: 'error',
@@ -949,7 +1101,7 @@ export function createOrchestrateOps(
             continue;
           }
 
-          const issueNumber = createGitHubIssue(ctx.repo, task.title, body, {
+          const issueNumber = await createGitHubIssue(ctx.repo, task.title, body, {
             milestone: milestoneNumber,
             labels: labels.length > 0 ? labels : undefined,
           });

package/src/runtime/runtime.test.ts

@@ -81,7 +81,10 @@ vi.mock('../governance/governance.js', () => ({
 }));
 
 vi.mock('../loop/loop-manager.js', () => ({
-  LoopManager: mockClass(),
+  LoopManager: vi.fn(function (this: Record<string, unknown>) {
+    this.isActive = vi.fn().mockReturnValue(false);
+    this.cancelLoop = vi.fn();
+  }),
 }));
 
 vi.mock('../control/identity-manager.js', () => ({
@@ -185,7 +188,9 @@ vi.mock('../context/context-engine.js', () => ({
 }));
 
 vi.mock('../agency/agency-manager.js', () => ({
-  AgencyManager: mockClass(),
+  AgencyManager: vi.fn(function (this: Record<string, unknown>) {
+    this.disable = vi.fn();
+  }),
 }));
 
 vi.mock('../vault/knowledge-review.js', () => ({
@@ -220,6 +225,7 @@ vi.mock('../queue/job-queue.js', () => ({
 vi.mock('../queue/pipeline-runner.js', () => ({
   PipelineRunner: vi.fn(function (this: Record<string, unknown>) {
     this.registerHandler = vi.fn();
+    this.stop = vi.fn();
   }),
 }));
 
@@ -261,6 +267,18 @@ vi.mock('./context-health.js', () => ({
   }),
 }));
 
+vi.mock('./shutdown-registry.js', () => ({
+  ShutdownRegistry: vi.fn(function (this: Record<string, unknown>) {
+    this.register = vi.fn();
+    this.closeAll = vi.fn().mockResolvedValue(undefined);
+    this.closeAllSync = vi.fn();
+    this.size = 0;
+    this.isClosed = false;
+    this.entries = [];
+    this.closed = false;
+  }),
+}));
+
 vi.mock('node:fs', () => ({
   existsSync: vi.fn().mockReturnValue(false),
   mkdirSync: vi.fn(),
@@ -360,4 +378,34 @@ describe('createAgentRuntime', () => {
   it('initializes context health monitor', () => {
     expect(runtime.contextHealth).toBeDefined();
   });
+
+  it('initializes shutdown registry', () => {
+    expect(runtime.shutdownRegistry).toBeDefined();
+    expect(runtime.shutdownRegistry.register).toBeDefined();
+  });
+
+  it('registers cleanup callbacks with shutdown registry', () => {
+    // vaultManager, pipelineRunner, agencyManager, loopManager
+    expect(runtime.shutdownRegistry.register).toHaveBeenCalledWith(
+      'vaultManager',
+      expect.any(Function),
+    );
+    expect(runtime.shutdownRegistry.register).toHaveBeenCalledWith(
+      'pipelineRunner',
+      expect.any(Function),
+    );
+    expect(runtime.shutdownRegistry.register).toHaveBeenCalledWith(
+      'agencyManager',
+      expect.any(Function),
+    );
+    expect(runtime.shutdownRegistry.register).toHaveBeenCalledWith(
+      'loopManager',
+      expect.any(Function),
+    );
+  });
+
+  it('close() calls shutdownRegistry.closeAllSync()', () => {
+    runtime.close();
+    expect(runtime.shutdownRegistry.closeAllSync).toHaveBeenCalled();
+  });
 });