@soleri/core 9.11.0 → 9.13.0

package/src/subagent/orphan-reaper.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { OrphanReaper } from './orphan-reaper.js';
+
+describe('OrphanReaper', () => {
+  describe('killProcessGroup', () => {
+    let reaper: OrphanReaper;
+    let killSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+      reaper = new OrphanReaper();
+      killSpy = vi.spyOn(process, 'kill');
+    });
+
+    afterEach(() => {
+      killSpy.mockRestore();
+    });
+
+    it('kills the entire process group with -pid', () => {
+      killSpy.mockImplementation(() => true);
+
+      const result = reaper.killProcessGroup(1234);
+
+      expect(killSpy).toHaveBeenCalledWith(-1234, 'SIGTERM');
+      expect(result).toEqual({ killed: true, method: 'group' });
+    });
+
+    it('accepts a custom signal', () => {
+      killSpy.mockImplementation(() => true);
+
+      const result = reaper.killProcessGroup(1234, 'SIGKILL');
+
+      expect(killSpy).toHaveBeenCalledWith(-1234, 'SIGKILL');
+      expect(result).toEqual({ killed: true, method: 'group' });
+    });
+
+    it('falls back to single-process kill when group ESRCH', () => {
+      killSpy.mockImplementation((pid: number) => {
+        if (pid < 0) {
+          const err = new Error('No such process') as NodeJS.ErrnoException;
+          err.code = 'ESRCH';
+          throw err;
+        }
+        return true;
+      });
+
+      const result = reaper.killProcessGroup(1234);
+
+      expect(killSpy).toHaveBeenCalledWith(-1234, 'SIGTERM');
+      expect(killSpy).toHaveBeenCalledWith(1234, 'SIGTERM');
+      expect(result).toEqual({ killed: true, method: 'single' });
+    });
+
+    it('returns killed:false when both group and single fail', () => {
+      killSpy.mockImplementation(() => {
+        const err = new Error('No such process') as NodeJS.ErrnoException;
+        err.code = 'ESRCH';
+        throw err;
+      });
+
+      const result = reaper.killProcessGroup(1234);
+
+      expect(result).toEqual({ killed: false, method: 'single' });
+    });
+
+    it('returns killed:false on EPERM for group kill', () => {
+      killSpy.mockImplementation(() => {
+        const err = new Error('Operation not permitted') as NodeJS.ErrnoException;
+        err.code = 'EPERM';
+        throw err;
+      });
+
+      const result = reaper.killProcessGroup(1234);
+
+      expect(result).toEqual({ killed: false, method: 'group' });
+    });
+  });
+
+  describe('killAll', () => {
+    let reaper: OrphanReaper;
+    let killSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+      reaper = new OrphanReaper();
+      killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
+    });
+
+    afterEach(() => {
+      killSpy.mockRestore();
+    });
+
+    it('kills all tracked processes and clears tracking', () => {
+      reaper.register(100, 'task-a');
+      reaper.register(200, 'task-b');
+
+      const results = reaper.killAll();
+
+      expect(results.size).toBe(2);
+      expect(results.get(100)).toEqual({ killed: true, method: 'group' });
+      expect(results.get(200)).toEqual({ killed: true, method: 'group' });
+      // Tracking is cleared
+      expect(reaper.listTracked()).toEqual([]);
+    });
+
+    it('returns empty map when nothing is tracked', () => {
+      const results = reaper.killAll();
+      expect(results.size).toBe(0);
+    });
+
+    it('uses custom signal for all kills', () => {
+      reaper.register(100, 'task-a');
+
+      reaper.killAll('SIGKILL');
+
+      expect(killSpy).toHaveBeenCalledWith(-100, 'SIGKILL');
+    });
+
+    it('handles mixed success/failure', () => {
+      reaper.register(100, 'task-a');
+      reaper.register(200, 'task-b');
+
+      killSpy.mockImplementation((pid: number) => {
+        // PID 100 group kill works, PID 200 is already dead
+        if (pid === -100) return true;
+        const err = new Error('No such process') as NodeJS.ErrnoException;
+        err.code = 'ESRCH';
+        throw err;
+      });
+
+      const results = reaper.killAll();
+
+      expect(results.get(100)).toEqual({ killed: true, method: 'group' });
+      expect(results.get(200)).toEqual({ killed: false, method: 'single' });
+    });
+  });
+});

package/src/subagent/orphan-reaper.ts

@@ -5,9 +5,34 @@
  * - No error → process is alive
  * - ESRCH → process is dead (reap it)
  * - EPERM → process is alive but we lack permission to signal it
+ *
+ * Process group management:
+ * - `killProcessGroup()` sends a signal to the entire process group (-pid)
+ * - `killAll()` kills all tracked processes via process groups
+ * - Group kill only works if the child was spawned with `detached: true`
+ *   or is otherwise a process group leader. Falls back to single-process
+ *   kill when the group doesn't exist (ESRCH on -pid).
  */
 
-import type { TrackedProcess } from './types.js';
+import type { TrackedProcess, KillResult } from './types.js';
+
+const KILL_GRACE_PERIOD_MS = 5_000;
+
+/** Result of a reap cycle. */
+export interface ReapResult {
+  /** Task IDs of processes that were found dead and cleaned up. */
+  reaped: string[];
+  /** Task IDs of processes that are still alive. */
+  alive: string[];
+}
+
+/** Result of a process group kill attempt */
+export interface ProcessGroupKillResult {
+  /** Whether the kill signal was delivered */
+  killed: boolean;
+  /** Whether the group or single-process kill path was used */
+  method: 'group' | 'single';
+}
 
 export class OrphanReaper {
   private readonly tracked = new Map<number, TrackedProcess>();
@@ -29,20 +54,68 @@ export class OrphanReaper {
 
   /**
    * Check each tracked PID for liveness. Dead processes are removed from
-   * tracking, the onOrphan callback is invoked, and they are returned.
+   * tracking, the onOrphan callback is invoked, and the result summarises
+   * which task IDs were reaped vs still alive.
    */
-  reap(): TrackedProcess[] {
-    const reaped: TrackedProcess[] = [];
+  reap(): ReapResult {
+    const reaped: string[] = [];
+    const alive: string[] = [];
 
     for (const [pid, entry] of this.tracked) {
       if (!this.isAlive(pid)) {
         this.tracked.delete(pid);
         this.onOrphan?.(entry.taskId, pid);
-        reaped.push(entry);
+        reaped.push(entry.taskId);
+      } else {
+        alive.push(entry.taskId);
       }
     }
 
-    return reaped;
+    return { reaped, alive };
+  }
+
+  /**
+   * Kill a process by PID. Sends SIGTERM first; if `escalate` is true
+   * (default), waits 5 seconds and sends SIGKILL if still alive.
+   *
+   * Handles gracefully: process already dead, EPERM, etc.
+   */
+  async killProcess(pid: number, escalate = true): Promise<KillResult> {
+    // If already dead, report as killed via SIGTERM (no-op)
+    if (!this.isAlive(pid)) {
+      return { killed: true, signal: 'SIGTERM' };
+    }
+
+    // Send SIGTERM
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      // ESRCH = already dead, EPERM = can't signal
+      return { killed: !this.isAlive(pid), signal: 'SIGTERM' };
+    }
+
+    // If not escalating, check once and return
+    if (!escalate) {
+      // Give a brief moment for the signal to take effect
+      return { killed: !this.isAlive(pid), signal: 'SIGTERM' };
+    }
+
+    // Wait grace period, then check if still alive
+    await new Promise<void>((resolve) => setTimeout(resolve, KILL_GRACE_PERIOD_MS));
+
+    if (!this.isAlive(pid)) {
+      return { killed: true, signal: 'SIGTERM' };
+    }
+
+    // Escalate to SIGKILL
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Process may have died between check and kill
+      return { killed: !this.isAlive(pid), signal: 'SIGKILL' };
+    }
+
+    return { killed: true, signal: 'SIGKILL' };
   }
 
   /** Return all currently tracked processes. */
@@ -60,6 +133,56 @@ export class OrphanReaper {
     this.tracked.clear();
   }
 
+  /**
+   * Kill an entire process group by negating the PID.
+   *
+   * Attempts `process.kill(-pid, signal)` first to kill the whole group.
+   * Falls back to `process.kill(pid, signal)` if the group kill fails
+   * (e.g., ESRCH when the process isn't a group leader).
+   *
+   * **Limitation:** Group kill only works if the child was spawned with
+   * `detached: true` or is otherwise a process group leader. On macOS,
+   * `process.kill(-pid)` works for process group leaders.
+   */
+  killProcessGroup(pid: number, signal: NodeJS.Signals = 'SIGTERM'): ProcessGroupKillResult {
+    // Try group kill first
+    try {
+      process.kill(-pid, signal);
+      return { killed: true, method: 'group' };
+    } catch (groupErr: unknown) {
+      const groupCode = (groupErr as NodeJS.ErrnoException).code;
+      // ESRCH on the group means it's not a group leader — fall back to single
+      if (groupCode === 'ESRCH') {
+        try {
+          process.kill(pid, signal);
+          return { killed: true, method: 'single' };
+        } catch {
+          // Process is already dead
+          return { killed: false, method: 'single' };
+        }
+      }
+      // EPERM means the process group exists but we can't signal it
+      // Any other error — process is dead or inaccessible
+      return { killed: false, method: 'group' };
+    }
+  }
+
+  /**
+   * Kill all tracked processes via process groups and clear tracking.
+   *
+   * Returns a summary of kill results keyed by PID.
+   */
+  killAll(signal: NodeJS.Signals = 'SIGTERM'): Map<number, ProcessGroupKillResult> {
+    const results = new Map<number, ProcessGroupKillResult>();
+
+    for (const [pid] of this.tracked) {
+      results.set(pid, this.killProcessGroup(pid, signal));
+    }
+
+    this.tracked.clear();
+    return results;
+  }
+
   // ── internals ──────────────────────────────────────────────────────
 
   /**
@@ -68,7 +191,7 @@ export class OrphanReaper {
    * - EPERM   → alive (exists but we can't signal it)
    * - ESRCH   → dead
    */
-  private isAlive(pid: number): boolean {
+  isAlive(pid: number): boolean {
     try {
       process.kill(pid, 0);
       return true;

package/src/subagent/types.ts

@@ -136,3 +136,13 @@ export interface TrackedProcess {
   /** When the process was registered */
   registeredAt: number;
 }
+
+// ─── Kill Result ───────────────────────────────────────────────────
+
+/** Result of attempting to kill a process */
+export interface KillResult {
+  /** Whether the process was successfully killed */
+  killed: boolean;
+  /** Which signal ultimately killed the process */
+  signal: 'SIGTERM' | 'SIGKILL';
+}

package/src/subagent/workspace-resolver.ts

@@ -72,6 +72,8 @@ export class WorkspaceResolver {
 
   /**
    * Remove the worktree for a given task.
+   * Deletes the worktree directory and local branch.
+   * Worktree branches are local-only — never pushed to remote.
    * Silently handles errors (e.g., worktree already removed).
    */
   cleanup(taskId: string): void {
@@ -86,7 +88,7 @@ export class WorkspaceResolver {
       // Silently ignore — worktree may already be gone
     }
 
-    // Clean up the branch as well
+    // Clean up the local branch (worktree branches are local-only)
     if (info.branch) {
       try {
         execSync(`git branch -D "${info.branch}"`, { ...EXEC_OPTS, cwd: this.baseDir });

package/src/vault/vault-entries.ts

@@ -4,6 +4,7 @@
  */
 import type { PersistenceProvider } from '../persistence/types.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
+import type { StoredVector } from '../embeddings/types.js';
 import type { LinkManager } from './linking.js';
 import { computeContentHash } from './content-hash.js';
 import type { SearchResult, VaultStats } from './vault.js';
@@ -377,6 +378,117 @@ export function contentHashStats(provider: PersistenceProvider): {
   return { total, hashed, uniqueHashes };
 }
 
+// ── Vector Operations ────────────────────────────────────────────────────
+
+/** Store a vector for an entry. Upserts — replaces if exists. */
+export function storeVector(
+  provider: PersistenceProvider,
+  entryId: string,
+  vector: number[],
+  model: string,
+  dimensions: number,
+): void {
+  const blob = Buffer.from(new Float32Array(vector).buffer);
+  provider.run(
+    `INSERT INTO entry_vectors (entry_id, vector, model, dimensions, created_at)
+     VALUES (@entryId, @vector, @model, @dimensions, @createdAt)
+     ON CONFLICT(entry_id) DO UPDATE SET
+       vector = excluded.vector, model = excluded.model,
+       dimensions = excluded.dimensions, created_at = excluded.created_at`,
+    {
+      entryId,
+      vector: blob,
+      model,
+      dimensions,
+      createdAt: Date.now(),
+    },
+  );
+}
+
+/** Get the stored vector for an entry, or null. */
+export function getVector(provider: PersistenceProvider, entryId: string): StoredVector | null {
+  const row = provider.get<{
+    entry_id: string;
+    vector: Buffer;
+    model: string;
+    dimensions: number;
+    created_at: number;
+  }>('SELECT * FROM entry_vectors WHERE entry_id = ?', [entryId]);
+  if (!row) return null;
+  return {
+    entryId: row.entry_id,
+    vector: Array.from(
+      new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4),
+    ),
+    model: row.model,
+    dimensions: row.dimensions,
+    createdAt: row.created_at,
+  };
+}
+
+/** Delete the vector for an entry. */
+export function deleteVector(provider: PersistenceProvider, entryId: string): void {
+  provider.run('DELETE FROM entry_vectors WHERE entry_id = ?', [entryId]);
+}
+
+/** Get IDs of entries that have no vector for the given model. */
+export function getEntriesWithoutVectors(provider: PersistenceProvider, model: string): string[] {
+  const rows = provider.all<{ id: string }>(
+    `SELECT e.id FROM entries e
+     LEFT JOIN entry_vectors ev ON e.id = ev.entry_id AND ev.model = @model
+     WHERE ev.entry_id IS NULL`,
+    { model },
+  );
+  return rows.map((r) => r.id);
+}
+
+/**
+ * Brute-force cosine similarity search over all stored vectors.
+ * Returns top-K entries sorted by similarity descending.
+ * For <100K entries, brute-force is fast enough (~50ms).
+ */
+export function cosineSearch(
+  provider: PersistenceProvider,
+  queryVector: number[],
+  topK: number,
+): Array<{ entryId: string; similarity: number }> {
+  const rows = provider.all<{
+    entry_id: string;
+    vector: Buffer;
+  }>('SELECT entry_id, vector FROM entry_vectors');
+
+  // Precompute query norm
+  let queryNorm = 0;
+  for (let i = 0; i < queryVector.length; i++) {
+    queryNorm += queryVector[i] * queryVector[i];
+  }
+  queryNorm = Math.sqrt(queryNorm);
+  if (queryNorm === 0) return [];
+
+  const results: Array<{ entryId: string; similarity: number }> = [];
+
+  for (const row of rows) {
+    const stored = new Float32Array(
+      row.vector.buffer,
+      row.vector.byteOffset,
+      row.vector.byteLength / 4,
+    );
+    let dot = 0;
+    let storedNorm = 0;
+    for (let i = 0; i < stored.length; i++) {
+      dot += queryVector[i] * stored[i];
+      storedNorm += stored[i] * stored[i];
+    }
+    storedNorm = Math.sqrt(storedNorm);
+    if (storedNorm === 0) continue;
+    const similarity = dot / (queryNorm * storedNorm);
+    results.push({ entryId: row.entry_id, similarity });
+  }
+
+  results.sort((a, b) => b.similarity - a.similarity);
+  return results.slice(0, topK);
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────────
 
 function gc(provider: PersistenceProvider, col: string): Record<string, number> {

package/src/vault/vault-manager.ts

@@ -188,6 +188,7 @@ export class VaultManager {
     return merged.slice(0, limit).map((r) => ({
       entry: r.entry,
       score: r.weightedScore,
+      source: r.source,
     }));
   }
 

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

@@ -11,6 +11,7 @@ import { Brain } from '../brain/brain.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
 const isCI = !!process.env.CI;
+const isWindows = process.platform === 'win32';
 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'];
@@ -77,7 +78,7 @@ describe('Vault Scaling — 10K entries', () => {
       const elapsed = performance.now() - start;
 
       expect(results.length).toBeGreaterThan(0);
-      expect(elapsed).toBeLessThan(isCI ? 500 : 50);
+      expect(elapsed).toBeLessThan(isCI ? (isWindows ? 2000 : 500) : 50);
     }
   });
 
@@ -90,7 +91,7 @@ describe('Vault Scaling — 10K entries', () => {
     const elapsed = performance.now() - start;
 
     expect(results.length).toBeGreaterThan(0);
-    expect(elapsed).toBeLessThan(isCI ? 500 : 50);
+    expect(elapsed).toBeLessThan(isCI ? (isWindows ? 2000 : 1000) : 200);
   });
 
   test('list with filters under 200ms at 10K', () => {

package/src/vault/vault-schema.ts

@@ -28,6 +28,7 @@ export function initializeSchema(provider: PersistenceProvider): void {
   migrateContentHash(provider);
   migrateTierColumn(provider);
   migratePerformanceIndexes(provider);
+  migrateVectorStorage(provider);
 }
 
 function createCoreTables(provider: PersistenceProvider): void {
@@ -257,3 +258,17 @@ export function migratePerformanceIndexes(provider: PersistenceProvider): void {
     /* brain_sessions table doesn't exist yet — indexes will be created on next init */
   }
 }
+
+function migrateVectorStorage(provider: PersistenceProvider): void {
+  provider.execSql(`
+    CREATE TABLE IF NOT EXISTS entry_vectors (
+      entry_id TEXT PRIMARY KEY,
+      vector BLOB NOT NULL,
+      model TEXT NOT NULL,
+      dimensions INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (entry_id) REFERENCES entries(id) ON DELETE CASCADE
+    );
+  `);
+  provider.execSql('CREATE INDEX IF NOT EXISTS idx_entry_vectors_model ON entry_vectors(model)');
+}

package/src/vault/vault.ts

@@ -11,6 +11,7 @@ import type { AutoLinkConfig, EntryUpdateFields } from './vault-entries.js';
 export interface SearchResult {
   entry: IntelligenceEntry;
   score: number;
+  source?: string;
 }
 export interface VaultStats {
   totalEntries: number;

package/vitest.config.ts

@@ -6,7 +6,8 @@ export default defineConfig({
     pool: 'forks',
     poolOptions: { forks: { singleFork: true } },
     testTimeout: 30_000,
-    exclude: ['**/node_modules/**', '**/.claude/worktrees/**'],
+    include: ['src/**/*.test.ts'],
+    exclude: ['**/node_modules/**'],
     coverage: {
       provider: 'v8',
       include: ['src/**/*.ts'],

package/dist/brain/strength-scorer.d.ts

@@ -1,31 +0,0 @@
-/**
- * Strength Scorer — computes pattern strength scores from brain feedback data.
- *
- * Extracted from intelligence.ts (Phase 1, Wave 1A).
- * Responsible for: computeStrengths, getStrengths, recommend, buildGlobalRegistry, buildDomainProfiles.
- */
-import type { Vault } from '../vault/vault.js';
-import type { PatternStrength, StrengthsQuery, GlobalPattern, DomainProfile } from './types.js';
-export declare class StrengthScorer {
-    private vault;
-    private provider;
-    constructor(vault: Vault);
-    computeStrengths(): PatternStrength[];
-    getStrengths(query?: StrengthsQuery): PatternStrength[];
-    recommend(context: {
-        domain?: string;
-        task?: string;
-        source?: string;
-        limit?: number;
-    }): PatternStrength[];
-    buildGlobalRegistry(strengths: PatternStrength[]): number;
-    buildDomainProfiles(strengths: PatternStrength[]): number;
-    getGlobalPatterns(limit?: number): GlobalPattern[];
-    getDomainProfile(domain: string): DomainProfile | null;
-    private scoreFromFeedback;
-    private persistStrength;
-    private expandWithFallback;
-    private boostByTaskContext;
-    private boostBySource;
-}
-//# sourceMappingURL=strength-scorer.d.ts.map

package/dist/brain/strength-scorer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strength-scorer.d.ts","sourceRoot":"","sources":["../../src/brain/strength-scorer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2EhG,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAAsB;gBAE1B,KAAK,EAAE,KAAK;IAKxB,gBAAgB,IAAI,eAAe,EAAE;IA8BrC,YAAY,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,eAAe,EAAE;IAyBvD,SAAS,CAAC,OAAO,EAAE;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,eAAe,EAAE;IAyBrB,mBAAmB,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,MAAM;IA4BzD,mBAAmB,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,MAAM;IAuDzD,iBAAiB,CAAC,KAAK,SAAK,GAAG,aAAa,EAAE;IAkB9C,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAsBtD,OAAO,CAAC,iBAAiB;IA+BzB,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,aAAa;CAqBtB"}