@soleri/core 9.5.0 → 9.7.0

package/src/runtime/context-health.ts

@@ -4,8 +4,18 @@
  *
  * Heuristic: tool calls x average payload size x 1.5 overhead factor.
  * Assumes ~200K token context window for fill estimation.
+ *
+ * Also integrates with CompactionPolicy to trigger session rotation
+ * when policy thresholds are breached.
  */
 
+import type {
+  CompactionPolicy,
+  CompactionResult,
+  SessionState,
+} from '../session/compaction-policy.js';
+import { shouldCompact } from '../session/compaction-evaluator.js';
+
 // =============================================================================
 // TYPES
 // =============================================================================
@@ -18,6 +28,8 @@ export interface ContextHealthStatus {
   toolCallCount: number;
   estimatedTokens: number;
   recommendation: string;
+  /** When a compaction policy is set, this contains the evaluation result. */
+  compaction?: CompactionResult;
 }
 
 export interface TrackEvent {
@@ -47,6 +59,17 @@ const RECOMMENDATIONS: Record<HealthLevel, string> = {
 export class ContextHealthMonitor {
   private toolCallCount = 0;
   private totalPayloadSize = 0;
+  private compactionPolicy: CompactionPolicy | undefined;
+  private sessionStartedAt: string | undefined;
+
+  /**
+   * Set the compaction policy and session start time.
+   * When set, `check()` will evaluate compaction thresholds.
+   */
+  setCompactionPolicy(policy: CompactionPolicy, startedAt?: string): void {
+    this.compactionPolicy = policy;
+    this.sessionStartedAt = startedAt ?? new Date().toISOString();
+  }
 
   /** Track a tool call event. */
   track(event: TrackEvent): void {
@@ -54,19 +77,36 @@ export class ContextHealthMonitor {
     this.totalPayloadSize += event.payloadSize;
   }
 
-  /** Check current context health status. */
+  /** Check current context health status (including compaction policy). */
   check(): ContextHealthStatus {
     const estimatedTokens = Math.round(this.totalPayloadSize * OVERHEAD_FACTOR);
     const estimatedFill = Math.min(estimatedTokens / CONTEXT_WINDOW, 1.0);
     const level = this.classifyLevel(estimatedFill);
 
-    return {
+    const status: ContextHealthStatus = {
       level,
       estimatedFill: Math.round(estimatedFill * 1000) / 1000,
       toolCallCount: this.toolCallCount,
       estimatedTokens,
       recommendation: RECOMMENDATIONS[level],
     };
+
+    // Evaluate compaction policy if configured
+    if (this.compactionPolicy && this.sessionStartedAt) {
+      const session: SessionState = {
+        runCount: this.toolCallCount,
+        inputTokens: estimatedTokens,
+        startedAt: this.sessionStartedAt,
+      };
+      status.compaction = shouldCompact(session, this.compactionPolicy);
+
+      // Escalate recommendation when compaction is triggered
+      if (status.compaction.compact) {
+        status.recommendation = `Compaction triggered: ${status.compaction.reason}`;
+      }
+    }
+
+    return status;
   }
 
   /** Reset all tracking (on session clear). */

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 {

package/src/runtime/runtime.ts

@@ -61,6 +61,9 @@ import { generatePersonaInstructions } from '../persona/prompt-generator.js';
 import { OperatorProfileStore } from '../operator/operator-profile.js';
 import { ContextHealthMonitor } from './context-health.js';
 import { ShutdownRegistry } from './shutdown-registry.js';
+import { RuntimeAdapterRegistry } from '../adapters/registry.js';
+import { ClaudeCodeRuntimeAdapter } from '../adapters/claude-code-adapter.js';
+import { SubagentDispatcher } from '../subagent/dispatcher.js';
 
 /**
  * Create a fully initialized agent runtime.
@@ -322,6 +325,8 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   shutdownRegistry.register('pipelineRunner', () => pipelineRunner.stop());
   // Agency manager — close FSWatchers and debounce timers
   shutdownRegistry.register('agencyManager', () => agencyManager.disable());
+
+  shutdownRegistry.register('subagentDispatcher', () => subagentDispatcher.cleanup());
   // Loop manager — clear accumulated state
   shutdownRegistry.register('loopManager', () => {
     if (loop.isActive()) {
@@ -333,6 +338,14 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     }
   });
 
+  // Runtime Adapter Registry — dispatch work to different AI CLIs
+  const adapterRegistry = new RuntimeAdapterRegistry();
+  adapterRegistry.register('claude-code', new ClaudeCodeRuntimeAdapter());
+  adapterRegistry.setDefault('claude-code');
+
+  // Subagent Dispatcher — spawn and manage child agent processes
+  const subagentDispatcher = new SubagentDispatcher({ adapterRegistry });
+
   return {
     config,
     logger,
@@ -379,6 +392,8 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
       const p = loadPersona(agentId, config.persona ?? undefined);
       return generatePersonaInstructions(p);
     })(),
+    adapterRegistry,
+    subagentDispatcher,
     contextHealth: new ContextHealthMonitor(),
     shutdownRegistry,
     createdAt: Date.now(),

package/src/runtime/session-briefing.test.ts

@@ -17,6 +17,14 @@ function makeRuntime(overrides?: {
     toolsUsed: string[];
     filesModified: string[];
   }>;
+  memories?: Array<{
+    id?: string;
+    createdAt: number;
+    projectPath?: string;
+    summary?: string;
+    context?: string;
+    type?: string;
+  }>;
   plans?: Array<{
     id: string;
     status: string;
@@ -45,6 +53,7 @@ function makeRuntime(overrides?: {
     vault: {
       stats: () => o.vaultStats ?? { totalEntries: 50, byType: { playbook: 5 } },
       getRecent: (_n: number) => o.recentEntries ?? [],
+      listMemories: () => o.memories ?? [],
     },
     curator: {
       healthAudit: () => ({
@@ -95,11 +104,34 @@ describe('session-briefing', () => {
       expect(data.sections.find((s) => s.label === 'Welcome')).toBeUndefined();
     });
 
-    it('includes Last session section', async () => {
+    it('includes Last session from cross-project memories when fresh', async () => {
+      const runtime = makeRuntime({
+        memories: [
+          {
+            id: 'mem-1',
+            createdAt: Date.now() - 600_000, // 10 min ago (ms)
+            projectPath: '/Users/me/projects/other-app',
+            summary: 'Fixed KPI card layout in the dashboard',
+            type: 'session',
+          },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const session = data.sections.find((s) => s.label === 'Last session');
+      expect(session).toBeDefined();
+      expect(session!.content).toContain('other-app');
+      expect(session!.content).toContain('Fixed KPI card layout');
+    });
+
+    it('falls back to brain sessions when no fresh memories exist', async () => {
       const runtime = makeRuntime({
+        memories: [], // no memories
         sessions: [
           {
-            endedAt: new Date(Date.now() - 3600000).toISOString(),
+            endedAt: new Date(Date.now() - 3600_000).toISOString(), // 1h ago
             domain: 'frontend',
             context: 'Refactored button component',
             toolsUsed: ['vault_search', 'brain_recommend'],
@@ -117,6 +149,63 @@ describe('session-briefing', () => {
       expect(session!.content).toContain('Refactored button component');
     });
 
+    it('skips Last session when all sessions are stale', async () => {
+      const staleTs = Date.now() - 72 * 3600_000; // 72h ago — beyond default 48h
+      const runtime = makeRuntime({
+        memories: [
+          {
+            id: 'mem-old',
+            createdAt: staleTs,
+            projectPath: '/old-project',
+            summary: 'Ancient session',
+            type: 'session',
+          },
+        ],
+        sessions: [
+          {
+            endedAt: new Date(staleTs).toISOString(),
+            domain: 'old',
+            context: 'Ancient brain session',
+            toolsUsed: [],
+            filesModified: [],
+          },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+      const res = await executeOp(ops, 'session_briefing', {});
+
+      const data = res.data as { sections: Array<{ label: string; content: string }> };
+      const session = data.sections.find((s) => s.label === 'Last session');
+      expect(session).toBeUndefined();
+    });
+
+    it('respects custom recencyHours parameter', async () => {
+      const runtime = makeRuntime({
+        memories: [
+          {
+            id: 'mem-3h',
+            createdAt: Date.now() - 3 * 3600_000, // 3h ago
+            projectPath: '/recent-project',
+            summary: 'Recent work',
+            type: 'session',
+          },
+        ],
+      });
+      const ops = captureOps(createSessionBriefingOps(runtime));
+
+      // With 1h window — should skip
+      const narrow = await executeOp(ops, 'session_briefing', { recencyHours: 1 });
+      const narrowData = narrow.data as { sections: Array<{ label: string }> };
+      expect(narrowData.sections.find((s) => s.label === 'Last session')).toBeUndefined();
+
+      // With 4h window — should include
+      const wide = await executeOp(ops, 'session_briefing', { recencyHours: 4 });
+      const wideData = wide.data as { sections: Array<{ label: string; content: string }> };
+      const session = wideData.sections.find((s) => s.label === 'Last session');
+      expect(session).toBeDefined();
+      expect(session!.content).toContain('Recent work');
+    });
+
     it('includes Active plans section', async () => {
       const runtime = makeRuntime({
         plans: [
@@ -234,6 +323,9 @@ describe('session-briefing', () => {
           getRecent: () => {
             throw new Error('no vault');
           },
+          listMemories: () => {
+            throw new Error('no vault');
+          },
         },
         curator: {
           healthAudit: () => {

package/src/runtime/session-briefing.ts

@@ -57,22 +57,58 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
           // Vault stats unavailable — skip
         }
 
-        // 1. Last session
+        // 1. Last session — cross-project, with staleness threshold
         try {
-          const sessions = brainIntelligence.listSessions({ limit: 1, active: false });
-          dataPoints += sessions.length;
-          if (sessions.length > 0) {
-            const last = sessions[0];
-            const ago = formatTimeAgo(last.endedAt ? new Date(last.endedAt).getTime() : Date.now());
-            const domain = last.domain ? ` [${last.domain}]` : '';
-            const context = last.context ? `: ${last.context.slice(0, 80)}` : '';
-            const tools = last.toolsUsed.length > 0 ? `, used ${last.toolsUsed.length} tools` : '';
-            const files =
-              last.filesModified.length > 0 ? `, modified ${last.filesModified.length} files` : '';
+          const recencyMs = (params.recencyHours as number) * 3600_000;
+          const cutoff = Date.now() - recencyMs;
+
+          // Try cross-project memories first (most recent work, any project)
+          const recentMemories = vault.listMemories({ type: 'session', limit: 3 });
+          const freshMemory = recentMemories.find((m) => {
+            const ts = m.createdAt > 1e12 ? m.createdAt : m.createdAt * 1000;
+            return ts > cutoff;
+          });
+
+          if (freshMemory) {
+            const ts =
+              freshMemory.createdAt > 1e12 ? freshMemory.createdAt : freshMemory.createdAt * 1000;
+            const ago = formatTimeAgo(ts);
+            const project = freshMemory.projectPath
+              ? ` [${freshMemory.projectPath.split('/').pop()}]`
+              : '';
+            const summary = freshMemory.summary
+              ? `: ${freshMemory.summary.slice(0, 100)}`
+              : freshMemory.context
+                ? `: ${freshMemory.context.slice(0, 100)}`
+                : '';
+            dataPoints += recentMemories.length;
             sections.push({
               label: 'Last session',
-              content: `(${ago})${domain}${context}${tools}${files}`,
+              content: `(${ago})${project}${summary}`,
             });
+          } else {
+            // Fall back to brain sessions (same-project only) if no fresh memory
+            const sessions = brainIntelligence.listSessions({ limit: 1, active: false });
+            dataPoints += sessions.length;
+            if (sessions.length > 0) {
+              const last = sessions[0];
+              const endTs = last.endedAt ? new Date(last.endedAt).getTime() : 0;
+              if (endTs > cutoff) {
+                const ago = formatTimeAgo(endTs);
+                const domain = last.domain ? ` [${last.domain}]` : '';
+                const context = last.context ? `: ${last.context.slice(0, 80)}` : '';
+                const tools =
+                  last.toolsUsed.length > 0 ? `, used ${last.toolsUsed.length} tools` : '';
+                const files =
+                  last.filesModified.length > 0
+                    ? `, modified ${last.filesModified.length} files`
+                    : '';
+                sections.push({
+                  label: 'Last session',
+                  content: `(${ago})${domain}${context}${tools}${files}`,
+                });
+              }
+            }
           }
         } catch {
           // Session data unavailable — skip

package/src/runtime/types.ts

@@ -37,6 +37,8 @@ import type { OperatorProfileStore } from '../operator/operator-profile.js';
 import type { OperatorContextStore } from '../operator/operator-context-store.js';
 import type { ContextHealthMonitor } from './context-health.js';
 import type { ShutdownRegistry } from './shutdown-registry.js';
+import type { RuntimeAdapterRegistry } from '../adapters/registry.js';
+import type { SubagentDispatcher } from '../subagent/dispatcher.js';
 
 /**
  * Configuration for creating an agent runtime.
@@ -129,6 +131,10 @@ export interface AgentRuntime {
   persona: import('../persona/types.js').PersonaConfig;
   /** Generated persona system instructions for LLM context. */
   personaInstructions: import('../persona/types.js').PersonaSystemInstructions;
+  /** Runtime adapter registry — dispatch work to different AI CLIs. */
+  adapterRegistry: RuntimeAdapterRegistry;
+  /** Subagent dispatcher — spawn and manage child agent processes. */
+  subagentDispatcher: SubagentDispatcher;
   /** Context health monitor — tracks tool call volume and context window fill. */
   contextHealth: ContextHealthMonitor;
   /** Shutdown registry — centralized cleanup for timers, watchers, child processes. */

package/src/session/compaction-evaluator.ts

@@ -0,0 +1,87 @@
+/**
+ * Compaction Evaluator — checks session state against a compaction policy
+ * and determines whether the session should be rotated.
+ */
+
+import type { CompactionPolicy, CompactionResult, SessionState } from './compaction-policy.js';
+
+// =============================================================================
+// DURATION PARSER
+// =============================================================================
+
+const DURATION_RE = /^(\d+)(ms|s|m|h|d)$/;
+
+const MULTIPLIERS: Record<string, number> = {
+  ms: 1,
+  s: 1_000,
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+};
+
+/**
+ * Parse a simple duration string (e.g. '72h', '30m', '7d') into milliseconds.
+ * Returns `undefined` for invalid input.
+ */
+export function parseDuration(duration: string): number | undefined {
+  const match = DURATION_RE.exec(duration.trim());
+  if (!match) return undefined;
+  const [, value, unit] = match;
+  return Number(value) * MULTIPLIERS[unit];
+}
+
+// =============================================================================
+// EVALUATOR
+// =============================================================================
+
+/**
+ * Evaluate whether a session should be compacted based on policy thresholds.
+ *
+ * Returns the first triggered threshold as the reason. Checks in order:
+ * 1. maxRuns
+ * 2. maxInputTokens
+ * 3. maxAge
+ */
+export function shouldCompact(
+  session: SessionState,
+  policy: CompactionPolicy,
+  now: Date = new Date(),
+): CompactionResult {
+  const noCompact: CompactionResult = { compact: false, reason: '', handoff: '' };
+
+  // Check maxRuns
+  if (policy.maxRuns !== undefined && session.runCount >= policy.maxRuns) {
+    return {
+      compact: true,
+      reason: `Run count (${session.runCount}) reached threshold (${policy.maxRuns})`,
+      handoff: '',
+    };
+  }
+
+  // Check maxInputTokens
+  if (policy.maxInputTokens !== undefined && session.inputTokens >= policy.maxInputTokens) {
+    return {
+      compact: true,
+      reason: `Input tokens (${session.inputTokens}) reached threshold (${policy.maxInputTokens})`,
+      handoff: '',
+    };
+  }
+
+  // Check maxAge
+  if (policy.maxAge !== undefined) {
+    const maxMs = parseDuration(policy.maxAge);
+    if (maxMs !== undefined) {
+      const startedAt = new Date(session.startedAt).getTime();
+      const elapsed = now.getTime() - startedAt;
+      if (elapsed >= maxMs) {
+        return {
+          compact: true,
+          reason: `Session age (${Math.round(elapsed / 60_000)}m) reached threshold (${policy.maxAge})`,
+          handoff: '',
+        };
+      }
+    }
+  }
+
+  return noCompact;
+}