@soleri/core 9.4.0 → 9.6.0

package/src/subagent/types.ts

@@ -0,0 +1,138 @@
+/**
+ * Subagent runtime engine — types for spawning, managing, and aggregating
+ * results from child agent processes.
+ *
+ * The SubagentDispatcher composes: TaskCheckout, WorkspaceResolver,
+ * ConcurrencyManager, OrphanReaper, and RuntimeAdapterRegistry.
+ */
+
+import type { AdapterSessionState, AdapterTokenUsage } from '../adapters/types.js';
+
+// ─── Task ───────────────────────────────────────────────────────────
+
+/** A task to be dispatched to a subagent */
+export interface SubagentTask {
+  /** Unique task identifier */
+  taskId: string;
+  /** The prompt or task description for the subagent */
+  prompt: string;
+  /** Working directory for execution */
+  workspace: string;
+  /** Runtime adapter type (e.g., 'claude-code', 'codex'). Falls back to registry default. */
+  runtime?: string;
+  /** Task IDs this task depends on (must complete first) */
+  dependencies?: string[];
+  /** Timeout in milliseconds. Default: 300_000 (5 min) */
+  timeout?: number;
+  /** Additional context to pass to the adapter */
+  config?: Record<string, unknown>;
+}
+
+// ─── Status ─────────────────────────────────────────────────────────
+
+/** Lifecycle status of a subagent task */
+export type SubagentStatus = 'queued' | 'claimed' | 'running' | 'completed' | 'failed' | 'orphaned';
+
+// ─── Result ─────────────────────────────────────────────────────────
+
+/** Result from a single subagent execution */
+export interface SubagentResult {
+  /** Task ID this result belongs to */
+  taskId: string;
+  /** Final status */
+  status: SubagentStatus;
+  /** Exit code from the adapter (0 = success) */
+  exitCode: number;
+  /** Human-readable summary of what the subagent did */
+  summary?: string;
+  /** Token usage */
+  usage?: AdapterTokenUsage;
+  /** Session state for potential resume */
+  sessionState?: AdapterSessionState;
+  /** Files changed by this subagent */
+  filesChanged?: string[];
+  /** Error message if failed */
+  error?: string;
+  /** Duration in milliseconds */
+  durationMs: number;
+  /** PID of the child process (if spawned) */
+  pid?: number;
+}
+
+// ─── Dispatch Options ───────────────────────────────────────────────
+
+/** Options controlling how tasks are dispatched */
+export interface DispatchOptions {
+  /** Run tasks in parallel (default: true) */
+  parallel?: boolean;
+  /** Max concurrent subagents (default: 3) */
+  maxConcurrent?: number;
+  /** Isolate each task in a git worktree (default: false) */
+  worktreeIsolation?: boolean;
+  /** Global timeout per task in ms (default: 300_000) */
+  timeout?: number;
+  /** Callback for per-task status updates */
+  onTaskUpdate?: (taskId: string, status: SubagentStatus) => void;
+}
+
+// ─── Aggregated Result ──────────────────────────────────────────────
+
+/** Aggregated result from multiple subagent executions */
+export interface AggregatedResult {
+  /** Overall status */
+  status: 'all-passed' | 'partial' | 'all-failed';
+  /** Total tasks dispatched */
+  totalTasks: number;
+  /** Count of completed tasks */
+  completed: number;
+  /** Count of failed tasks */
+  failed: number;
+  /** Sum of all token usage */
+  totalUsage: AdapterTokenUsage;
+  /** Deduplicated list of all files changed */
+  filesChanged: string[];
+  /** Combined summary from all tasks */
+  combinedSummary: string;
+  /** Total duration in milliseconds */
+  durationMs: number;
+  /** Per-task results */
+  results: SubagentResult[];
+}
+
+// ─── Claim Info ─────────────────────────────────────────────────────
+
+/** Information about a task claim */
+export interface ClaimInfo {
+  /** Task ID */
+  taskId: string;
+  /** Agent/process that claimed this task */
+  claimerId: string;
+  /** When the claim was made */
+  claimedAt: number;
+}
+
+// ─── Worktree Info ──────────────────────────────────────────────────
+
+/** Information about an active git worktree */
+export interface WorktreeInfo {
+  /** Task ID this worktree is for */
+  taskId: string;
+  /** Absolute path to the worktree */
+  path: string;
+  /** Branch name (if created) */
+  branch?: string;
+  /** When the worktree was created */
+  createdAt: number;
+}
+
+// ─── Tracked Process ────────────────────────────────────────────────
+
+/** A tracked child process for orphan detection */
+export interface TrackedProcess {
+  /** Process ID */
+  pid: number;
+  /** Task ID this process is executing */
+  taskId: string;
+  /** When the process was registered */
+  registeredAt: number;
+}

package/src/subagent/workspace-resolver.ts

@@ -0,0 +1,117 @@
+/**
+ * WorkspaceResolver — Git worktree isolation for subagent tasks.
+ *
+ * When isolation is requested, creates a dedicated git worktree per task
+ * at `<baseDir>/.soleri/worktrees/<taskId>/`. Falls back gracefully to the
+ * original workspace if git worktree creation fails.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { WorktreeInfo } from './types.js';
+
+const EXEC_OPTS = { encoding: 'utf-8' as const, timeout: 30_000 };
+
+export class WorkspaceResolver {
+  private readonly baseDir: string;
+  private readonly worktrees = new Map<string, WorktreeInfo>();
+
+  constructor(baseDir: string) {
+    this.baseDir = baseDir;
+  }
+
+  /**
+   * Resolve a workspace path for a task.
+   *
+   * If `isolate` is true, creates a git worktree at
+   * `<baseDir>/.soleri/worktrees/<taskId>/` on branch `subagent/<taskId>`.
+   * Returns the worktree path on success, or the original `workspace` on failure.
+   *
+   * If `isolate` is false, returns `workspace` as-is.
+   */
+  resolve(taskId: string, workspace: string, isolate: boolean): string {
+    if (!isolate) {
+      return workspace;
+    }
+
+    try {
+      const worktreePath = join(this.baseDir, '.soleri', 'worktrees', taskId);
+      const branch = `subagent/${taskId}`;
+
+      // Ensure parent directory exists
+      const parentDir = join(this.baseDir, '.soleri', 'worktrees');
+      if (!existsSync(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+      }
+
+      execSync(`git worktree add "${worktreePath}" -b "${branch}"`, {
+        ...EXEC_OPTS,
+        cwd: this.baseDir,
+      });
+
+      const info: WorktreeInfo = {
+        taskId,
+        path: worktreePath,
+        branch,
+        createdAt: Date.now(),
+      };
+      this.worktrees.set(taskId, info);
+
+      return worktreePath;
+    } catch (err) {
+      // Graceful fallback — log warning and return original workspace
+      console.warn(
+        `[WorkspaceResolver] Failed to create worktree for task "${taskId}":`,
+        err instanceof Error ? err.message : err,
+      );
+      return workspace;
+    }
+  }
+
+  /**
+   * Remove the worktree for a given task.
+   * Silently handles errors (e.g., worktree already removed).
+   */
+  cleanup(taskId: string): void {
+    const info = this.worktrees.get(taskId);
+    if (!info) {
+      return;
+    }
+
+    try {
+      execSync(`git worktree remove "${info.path}" --force`, { ...EXEC_OPTS, cwd: this.baseDir });
+    } catch {
+      // Silently ignore — worktree may already be gone
+    }
+
+    // Clean up the branch as well
+    if (info.branch) {
+      try {
+        execSync(`git branch -D "${info.branch}"`, { ...EXEC_OPTS, cwd: this.baseDir });
+      } catch {
+        // Silently ignore — branch may not exist
+      }
+    }
+
+    this.worktrees.delete(taskId);
+  }
+
+  /** Remove all active worktrees. */
+  cleanupAll(): void {
+    for (const taskId of Array.from(this.worktrees.keys())) {
+      this.cleanup(taskId);
+    }
+  }
+
+  /** Return all currently active worktrees. */
+  listActive(): WorktreeInfo[] {
+    return [...this.worktrees.values()];
+  }
+
+  /** Check whether a worktree exists for the given task. */
+  isActive(taskId: string): boolean {
+    return this.worktrees.has(taskId);
+  }
+}

package/src/transport/http-server.ts

@@ -151,7 +151,18 @@ export class HttpMcpServer {
       const sessionId = req.headers['mcp-session-id'] as string | undefined;
 
       if (method === 'POST') {
-        const body = await this.readBody(req);
+        let body: unknown;
+        try {
+          body = await this.readBody(req);
+        } catch (err) {
+          const statusCode = (err as { statusCode?: number }).statusCode;
+          if (statusCode === 413) {
+            this.sendJSON(res, 413, { error: 'Request body too large' });
+            return;
+          }
+          this.sendJSON(res, 400, { error: 'Failed to read request body' });
+          return;
+        }
 
         if (sessionId) {
           const session = this.sessions.get(sessionId);
@@ -241,10 +252,41 @@ export class HttpMcpServer {
   }
 
   private readBody(req: IncomingMessage): Promise<unknown> {
+    const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10 MB
+    const BODY_TIMEOUT = 30_000; // 30 seconds
+
     return new Promise((resolve, reject) => {
+      let size = 0;
       const chunks: Buffer[] = [];
-      req.on('data', (chunk: Buffer) => chunks.push(chunk));
+      let settled = false;
+
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          req.destroy();
+          reject(new Error('Request body timeout'));
+        }
+      }, BODY_TIMEOUT);
+
+      const cleanup = () => clearTimeout(timer);
+
+      req.on('data', (chunk: Buffer) => {
+        size += chunk.length;
+        if (size > MAX_BODY_SIZE) {
+          if (!settled) {
+            settled = true;
+            cleanup();
+            req.destroy();
+            reject(Object.assign(new Error('Request body too large'), { statusCode: 413 }));
+          }
+          return;
+        }
+        chunks.push(chunk);
+      });
       req.on('end', () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
         try {
           const text = Buffer.concat(chunks).toString('utf-8');
           resolve(text.length > 0 ? JSON.parse(text) : {});
@@ -252,7 +294,12 @@ export class HttpMcpServer {
           reject(e);
         }
       });
-      req.on('error', reject);
+      req.on('error', (e) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(e);
+      });
     });
   }
 

package/src/transport/ws-server.ts

@@ -230,11 +230,19 @@ export class WsMcpServer {
 
     // Set up frame reader
     const maxSize = this.config.maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE;
+    const maxBufferSize = maxSize; // raw buffer limit matches max message size (1 MB default)
     let buffer = Buffer.alloc(0);
 
     socket.on('data', (chunk: Buffer) => {
       buffer = Buffer.concat([buffer, chunk]);
 
+      // Guard against unbounded buffer growth (e.g. slow-drip DoS with no complete frames)
+      if (buffer.length > maxBufferSize) {
+        this.sendClose(socket, 1009, 'Buffer exceeded max size');
+        socket.destroy();
+        return;
+      }
+
       // Process all complete frames in the buffer
       while (buffer.length >= 2) {
         const frame = this.parseFrame(buffer);

package/src/vault/linking.test.ts

@@ -68,6 +68,12 @@ class LinkingMockDB implements PersistenceProvider {
   get<T>(sql: string, params?: unknown[]): T | undefined {
     const p = params ?? [];
     if (sql.includes('COUNT(*)')) {
+      if (sql.includes('NOT IN')) {
+        // Count orphan entries (no links)
+        const linkedIds = new Set(this.links.flatMap((l) => [l.source_id, l.target_id]));
+        const count = this.entries.filter((e) => !linkedIds.has(e.id)).length;
+        return { count } as T;
+      }
       const id = p[0] as string;
       const count = this.links.filter((l) => l.source_id === id || l.target_id === id).length;
       return { count } as T;
@@ -102,6 +108,12 @@ class LinkingMockDB implements PersistenceProvider {
       const ids = new Set(p.slice(0, half) as string[]);
       return this.links.filter((l) => ids.has(l.source_id) || ids.has(l.target_id)) as T[];
     }
+    if (sql.includes('FROM entries WHERE id IN')) {
+      const ids = new Set(p as string[]);
+      return this.entries
+        .filter((e) => ids.has(e.id))
+        .map((e) => ({ id: e.id, title: e.title, type: e.type, domain: e.domain })) as T[];
+    }
     if (sql.includes('NOT IN')) {
       const limit = p[0] as number;
       const linkedIds = new Set(this.links.flatMap((l) => [l.source_id, l.target_id]));

package/src/vault/linking.ts

@@ -145,6 +145,7 @@ export class LinkManager {
   /**
    * Walk the link graph from a starting entry up to `depth` hops.
    * BFS — walks both outgoing and incoming links (undirected).
+   * Batch-loads all links per frontier level to avoid N+1 queries.
    */
   traverse(entryId: string, depth: number = 2): LinkedEntry[] {
     const visited = new Set<string>([entryId]);
@@ -152,9 +153,47 @@ export class LinkManager {
     let frontier = [entryId];
 
     for (let d = 0; d < depth && frontier.length > 0; d++) {
+      // Batch-load all links for entire frontier in one query
+      const allLinks = this.getAllLinksForEntries(frontier);
+
+      // Collect unvisited neighbor IDs
+      const neighborMap = new Map<
+        string,
+        { link: VaultLink; direction: 'outgoing' | 'incoming' }
+      >();
+      for (const link of allLinks) {
+        // Outgoing: source is in frontier, target is the neighbor
+        if (frontier.includes(link.sourceId) && !visited.has(link.targetId)) {
+          if (!neighborMap.has(link.targetId)) {
+            neighborMap.set(link.targetId, { link, direction: 'outgoing' });
+          }
+        }
+        // Incoming: target is in frontier, source is the neighbor
+        if (frontier.includes(link.targetId) && !visited.has(link.sourceId)) {
+          if (!neighborMap.has(link.sourceId)) {
+            neighborMap.set(link.sourceId, { link, direction: 'incoming' });
+          }
+        }
+      }
+
+      if (neighborMap.size === 0) break;
+
+      // Batch-load entry metadata for all neighbors in one query
+      const neighborIds = [...neighborMap.keys()];
+      const metaMap = this.getEntryMetaBatch(neighborIds);
+
       const nextFrontier: string[] = [];
-      for (const currentId of frontier) {
-        this.collectNeighbors(currentId, visited, nextFrontier, result);
+      for (const [neighborId, { link, direction }] of neighborMap) {
+        visited.add(neighborId);
+        nextFrontier.push(neighborId);
+        const entry = metaMap.get(neighborId);
+        if (!entry) continue;
+        result.push({
+          ...entry,
+          linkType: link.linkType,
+          linkDirection: direction,
+          linkNote: link.note,
+        });
       }
       frontier = nextFrontier;
     }
@@ -162,43 +201,6 @@ export class LinkManager {
     return result;
   }
 
-  /** Collect unvisited outgoing and incoming neighbors for BFS. */
-  private collectNeighbors(
-    currentId: string,
-    visited: Set<string>,
-    nextFrontier: string[],
-    result: LinkedEntry[],
-  ): void {
-    for (const link of this.getLinks(currentId)) {
-      this.visitNeighbor(link.targetId, link, 'outgoing', visited, nextFrontier, result);
-    }
-    for (const link of this.getBacklinks(currentId)) {
-      this.visitNeighbor(link.sourceId, link, 'incoming', visited, nextFrontier, result);
-    }
-  }
-
-  /** Visit a single neighbor node if not already visited. */
-  private visitNeighbor(
-    neighborId: string,
-    link: VaultLink,
-    direction: 'outgoing' | 'incoming',
-    visited: Set<string>,
-    nextFrontier: string[],
-    result: LinkedEntry[],
-  ): void {
-    if (visited.has(neighborId)) return;
-    visited.add(neighborId);
-    nextFrontier.push(neighborId);
-    const entry = this.getEntryMeta(neighborId);
-    if (!entry) return;
-    result.push({
-      ...entry,
-      linkType: link.linkType,
-      linkDirection: direction,
-      linkNote: link.note,
-    });
-  }
-
   // ── Bulk Queries ────────────────────────────────────────────────────
 
   /** Get all links where either source or target is in the given ID set. */
@@ -317,20 +319,43 @@ export class LinkManager {
     const batchSize = opts?.batchSize ?? 50;
     const start = Date.now();
 
-    const orphans = this.getOrphans(10000);
     let processed = 0;
     let linksCreated = 0;
     const preview: Array<{ sourceId: string; targetId: string; linkType: string; score: number }> =
       [];
 
-    for (let i = 0; i < orphans.length; i += batchSize) {
-      const batch = orphans.slice(i, i + batchSize);
-      for (const entry of batch) {
+    // Estimate total for progress reporting (single COUNT query)
+    let totalEstimate = 0;
+    try {
+      const countRow = this.provider.get<{ count: number }>(
+        `SELECT COUNT(*) as count FROM entries
+         WHERE id NOT IN (SELECT source_id FROM vault_links)
+           AND id NOT IN (SELECT target_id FROM vault_links)`,
+      );
+      totalEstimate = countRow?.count ?? 0;
+    } catch {
+      // fall through with 0
+    }
+
+    // Process orphans in batches of batchSize instead of loading all at once.
+    // After each batch, successfully linked entries are no longer orphans,
+    // so the next getOrphans() call returns the next set.
+    // For dry-run mode, we must track processed IDs to avoid re-fetching the same orphans.
+    const processedIds = new Set<string>();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const batch = this.getOrphans(batchSize);
+      // Filter out already-processed entries (relevant for dry-run where orphan status doesn't change)
+      const unprocessed = batch.filter((e) => !processedIds.has(e.id));
+      if (unprocessed.length === 0) break;
+
+      for (const entry of unprocessed) {
+        processedIds.add(entry.id);
         const created = this.processOrphan(entry.id, threshold, maxLinks, dryRun, preview);
         linksCreated += created;
         processed++;
       }
-      opts?.onProgress?.({ processed, total: orphans.length, linksCreated });
+      opts?.onProgress?.({ processed, total: totalEstimate, linksCreated });
     }
 
     return {
@@ -381,6 +406,27 @@ export class LinkManager {
       return null;
     }
   }
+
+  /** Batch-load entry metadata for multiple IDs in a single query. */
+  private getEntryMetaBatch(
+    entryIds: string[],
+  ): Map<string, Omit<LinkedEntry, 'linkType' | 'linkDirection' | 'linkNote'>> {
+    const result = new Map<string, Omit<LinkedEntry, 'linkType' | 'linkDirection' | 'linkNote'>>();
+    if (entryIds.length === 0) return result;
+    try {
+      const placeholders = entryIds.map(() => '?').join(',');
+      const rows = this.provider.all<{ id: string; title: string; type: string; domain: string }>(
+        `SELECT id, title, type, domain FROM entries WHERE id IN (${placeholders})`,
+        entryIds,
+      );
+      for (const row of rows) {
+        result.set(row.id, row);
+      }
+    } catch {
+      // graceful degradation
+    }
+    return result;
+  }
 }
 
 // ── Free-standing helpers ─────────────────────────────────────────────

package/src/vault/vault-maintenance.ts

@@ -111,25 +111,18 @@ export function archive(
   const reason = options.reason ?? `Archived: older than ${options.olderThanDays} days`;
 
   return provider.transaction(() => {
-    const candidates = provider.all<{ id: string }>('SELECT id FROM entries WHERE updated_at < ?', [
-      cutoff,
-    ]);
-
-    if (candidates.length === 0) return { archived: 0 };
-
-    let archived = 0;
-    for (const { id } of candidates) {
-      provider.run(
-        `INSERT OR IGNORE INTO entries_archive (id, type, domain, title, severity, description, context, example, counter_example, why, tags, applies_to, created_at, updated_at, valid_from, valid_until, archive_reason)
-         SELECT id, type, domain, title, severity, description, context, example, counter_example, why, tags, applies_to, created_at, updated_at, valid_from, valid_until, ?
-         FROM entries WHERE id = ?`,
-        [reason, id],
-      );
-      const result = provider.run('DELETE FROM entries WHERE id = ?', [id]);
-      archived += result.changes;
-    }
+    // Bulk INSERT INTO ... SELECT — copies all matching entries to archive in one query
+    provider.run(
+      `INSERT OR IGNORE INTO entries_archive (id, type, domain, title, severity, description, context, example, counter_example, why, tags, applies_to, created_at, updated_at, valid_from, valid_until, archive_reason)
+       SELECT id, type, domain, title, severity, description, context, example, counter_example, why, tags, applies_to, created_at, updated_at, valid_from, valid_until, ?
+       FROM entries WHERE updated_at < ?`,
+      [reason, cutoff],
+    );
+
+    // Bulk DELETE — removes all archived entries in one query
+    const result = provider.run('DELETE FROM entries WHERE updated_at < ?', [cutoff]);
 
-    return { archived };
+    return { archived: result.changes };
   });
 }
 

package/src/vault/vault-memories.ts

@@ -299,21 +299,29 @@ export function memoryTopics(
 export function memoriesByProject(
   provider: PersistenceProvider,
 ): Array<{ project: string; count: number; memories: Memory[] }> {
-  const rows = provider.all<{ project: string; count: number }>(
-    'SELECT project_path as project, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY project_path ORDER BY count DESC',
+  // Single query fetching all non-archived memories, grouped client-side by project
+  const allRows = provider.all<Record<string, unknown>>(
+    'SELECT * FROM memories WHERE archived_at IS NULL ORDER BY project_path, created_at DESC',
   );
 
-  return rows.map((row) => {
-    const mems = provider.all<Record<string, unknown>>(
-      'SELECT * FROM memories WHERE project_path = ? AND archived_at IS NULL ORDER BY created_at DESC',
-      [row.project],
-    );
-    return {
-      project: row.project,
-      count: row.count,
-      memories: mems.map(rowToMemory),
-    };
-  });
+  const projectMap = new Map<string, Memory[]>();
+  for (const row of allRows) {
+    const memory = rowToMemory(row);
+    const project = memory.projectPath;
+    if (!projectMap.has(project)) {
+      projectMap.set(project, []);
+    }
+    projectMap.get(project)!.push(memory);
+  }
+
+  // Sort by count descending (matching original behavior)
+  return [...projectMap.entries()]
+    .map(([project, memories]) => ({
+      project,
+      count: memories.length,
+      memories,
+    }))
+    .sort((a, b) => b.count - a.count);
 }
 
 // ── Helper ──────────────────────────────────────────────────────────────

package/src/vault/vault-scaling.test.ts

@@ -10,6 +10,7 @@ import { Vault } from './vault.js';
 import { Brain } from '../brain/brain.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
+const isCI = !!process.env.CI;
 const DOMAINS = ['design', 'a11y', 'performance', 'security', 'architecture', 'testing', 'ux'];
 const TYPES: IntelligenceEntry['type'][] = ['pattern', 'anti-pattern', 'rule', 'playbook'];
 const SEVERITIES: IntelligenceEntry['severity'][] = ['critical', 'warning', 'suggestion'];
@@ -76,7 +77,7 @@ describe('Vault Scaling — 10K entries', () => {
       const elapsed = performance.now() - start;
 
       expect(results.length).toBeGreaterThan(0);
-      expect(elapsed).toBeLessThan(50);
+      expect(elapsed).toBeLessThan(isCI ? 500 : 50);
     }
   });
 
@@ -89,7 +90,7 @@ describe('Vault Scaling — 10K entries', () => {
     const elapsed = performance.now() - start;
 
     expect(results.length).toBeGreaterThan(0);
-    expect(elapsed).toBeLessThan(50);
+    expect(elapsed).toBeLessThan(isCI ? 500 : 50);
   });
 
   test('list with filters under 200ms at 10K', () => {