@soleri/core 9.4.0 → 9.5.0

package/src/curator/curator.ts

@@ -17,14 +17,17 @@ import type {
 } from './types.js';
 
 import {
-  detectDuplicates as detectDuplicatesPure,
   DEFAULT_DUPLICATE_THRESHOLD,
+  MERGE_SUGGESTION_THRESHOLD,
+  buildVocabulary,
+  entryToText,
 } from './duplicate-detector.js';
 import {
   findContradictions,
   DEFAULT_CONTRADICTION_THRESHOLD,
   type ContradictionCandidate,
 } from './contradiction-detector.js';
+import { tokenize, calculateTfIdf, cosineSimilarity } from '../text/similarity.js';
 import {
   normalizeTag as normalizeTagPure,
   normalizeAndDedup,
@@ -40,6 +43,7 @@ import { enrichEntryMetadata } from './metadata-enricher.js';
 // ─── Constants ──────────────────────────────────────────────────────
 
 const DEFAULT_STALE_DAYS = 90;
+const DEFAULT_BATCH_SIZE = 100;
 
 // ─── Curator Class ──────────────────────────────────────────────────
 
@@ -151,19 +155,101 @@ export class Curator {
   // ─── Duplicates (delegates to duplicate-detector) ─────────────
 
   detectDuplicates(entryId?: string, threshold?: number): DuplicateDetectionResult[] {
-    const results = detectDuplicatesPure(this.vault.list({ limit: 100000 }), entryId, threshold);
-    // Filter out dismissed pairs
+    const effectiveThreshold = threshold ?? DEFAULT_DUPLICATE_THRESHOLD;
     const dismissed = this.getDismissedPairs();
-    if (dismissed.size === 0) return results;
-    return results
-      .map((r) => ({
-        ...r,
-        matches: r.matches.filter((m) => {
-          const key = [r.entryId, m.entryId].sort().join('::');
-          return !dismissed.has(key);
-        }),
-      }))
-      .filter((r) => r.matches.length > 0);
+
+    // --- Phase 1: Content-hash exact duplicates (O(n) via GROUP BY) ---
+    const exactDupes = this.provider.all<{ content_hash: string; ids: string }>(
+      `SELECT content_hash, GROUP_CONCAT(id) as ids FROM entries
+       WHERE content_hash IS NOT NULL
+       GROUP BY content_hash HAVING COUNT(*) > 1`,
+    );
+
+    const results: DuplicateDetectionResult[] = [];
+    const seenPairs = new Set<string>();
+
+    for (const { ids } of exactDupes) {
+      const idList = ids.split(',');
+      if (entryId && !idList.includes(entryId)) continue;
+      const targets = entryId ? [entryId] : idList;
+      for (const targetId of targets) {
+        const matches: DuplicateCandidate[] = [];
+        for (const otherId of idList) {
+          if (otherId === targetId) continue;
+          const pairKey = [targetId, otherId].sort().join('::');
+          if (dismissed.has(pairKey) || seenPairs.has(pairKey)) continue;
+          seenPairs.add(pairKey);
+          const other = this.vault.get(otherId);
+          if (!other) continue;
+          matches.push({
+            entryId: otherId,
+            title: other.title,
+            similarity: 1.0,
+            suggestMerge: true,
+          });
+        }
+        if (matches.length > 0) {
+          results.push({ entryId: targetId, matches, scannedCount: idList.length - 1 });
+        }
+      }
+    }
+
+    // --- Phase 2: FTS5 fuzzy candidate matching ---
+    // For each entry, use FTS5 MATCH to find top candidates, then TF-IDF cosine similarity.
+    // Complexity is O(n * k) where k = FTS5 candidate limit (10), not O(n^2).
+    const exactDupeEntryIds = new Set(results.map((r) => r.entryId));
+    const targetEntries = entryId
+      ? ([this.vault.get(entryId)].filter(Boolean) as IntelligenceEntry[])
+      : this.listBatched();
+
+    // Build vocabulary from all entries (batched)
+    const allEntries = entryId ? this.listBatched() : targetEntries;
+    const vocabulary = buildVocabulary(allEntries);
+
+    for (const entry of targetEntries) {
+      // Skip entries already fully handled by exact-hash matches
+      if (exactDupeEntryIds.has(entry.id)) continue;
+
+      // FTS5 candidate retrieval: find top-10 similar entries
+      let candidates: IntelligenceEntry[];
+      try {
+        candidates = this.vault
+          .search(entry.title, { domain: entry.domain, limit: 10 })
+          .map((r) => r.entry)
+          .filter((c) => c.id !== entry.id);
+      } catch {
+        candidates = [];
+      }
+      if (candidates.length === 0) continue;
+
+      const entryVec = calculateTfIdf(tokenize(entryToText(entry)), vocabulary);
+      const matches: DuplicateCandidate[] = [];
+
+      for (const candidate of candidates) {
+        // Skip cross-domain pairs
+        if (entry.domain !== candidate.domain) continue;
+        const pairKey = [entry.id, candidate.id].sort().join('::');
+        if (dismissed.has(pairKey)) continue;
+
+        const candidateVec = calculateTfIdf(tokenize(entryToText(candidate)), vocabulary);
+        const similarity = cosineSimilarity(entryVec, candidateVec);
+        if (similarity >= effectiveThreshold) {
+          matches.push({
+            entryId: candidate.id,
+            title: candidate.title,
+            similarity,
+            suggestMerge: similarity >= MERGE_SUGGESTION_THRESHOLD,
+          });
+        }
+      }
+
+      if (matches.length > 0) {
+        matches.sort((a, b) => b.similarity - a.similarity);
+        results.push({ entryId: entry.id, matches, scannedCount: candidates.length });
+      }
+    }
+
+    return results;
   }
 
   dismissDuplicate(entryIdA: string, entryIdB: string, reason?: string): { dismissed: boolean } {
@@ -187,9 +273,11 @@ export class Curator {
   detectContradictions(threshold?: number): Contradiction[] {
     const searchFn = (title: string) =>
       this.vault.search(title, { type: 'pattern', limit: 20 }).map((r) => r.entry);
-    return this.persistContradictions(
-      findContradictions(this.vault.list({ limit: 100000 }), threshold, searchFn),
-    );
+    // Load only anti-patterns and patterns (bounded by type), not the entire vault
+    const antipatterns = this.vault.list({ type: 'anti-pattern', limit: 10000 });
+    const patterns = this.vault.list({ type: 'pattern', limit: 10000 });
+    const entries = [...antipatterns, ...patterns];
+    return this.persistContradictions(findContradictions(entries, threshold, searchFn));
   }
 
   getContradictions(status?: ContradictionStatus): Contradiction[] {
@@ -218,10 +306,12 @@ export class Curator {
   ): Promise<{ contradictions: Contradiction[]; method: 'tfidf-only' }> {
     const searchFn = (title: string) =>
       this.vault.search(title, { type: 'pattern', limit: 20 }).map((r) => r.entry);
+    // Load only anti-patterns and patterns (bounded by type), not the entire vault
+    const antipatterns = this.vault.list({ type: 'anti-pattern', limit: 10000 });
+    const patterns = this.vault.list({ type: 'pattern', limit: 10000 });
+    const entries = [...antipatterns, ...patterns];
     return {
-      contradictions: this.persistContradictions(
-        findContradictions(this.vault.list({ limit: 100000 }), threshold, searchFn),
-      ),
+      contradictions: this.persistContradictions(findContradictions(entries, threshold, searchFn)),
       method: 'tfidf-only',
     };
   }
@@ -249,19 +339,28 @@ export class Curator {
 
   groomAll(): GroomAllResult {
     const start = Date.now();
-    const entries = this.vault.list({ limit: 100000 });
     let tagsNormalized = 0,
-      staleCount = 0;
-    for (const entry of entries) {
-      const result = this.groomEntry(entry.id);
-      if (result) {
-        tagsNormalized += result.tagsNormalized.filter((t) => t.wasAliased).length;
-        if (result.stale) staleCount++;
+      staleCount = 0,
+      totalEntries = 0;
+    // Batch pagination — process entries in batches instead of loading all at once
+    let offset = 0;
+    while (true) {
+      const batch = this.vault.list({ limit: DEFAULT_BATCH_SIZE, offset });
+      if (batch.length === 0) break;
+      totalEntries += batch.length;
+      for (const entry of batch) {
+        const result = this.groomEntry(entry.id);
+        if (result) {
+          tagsNormalized += result.tagsNormalized.filter((t) => t.wasAliased).length;
+          if (result.stale) staleCount++;
+        }
       }
+      if (batch.length < DEFAULT_BATCH_SIZE) break;
+      offset += DEFAULT_BATCH_SIZE;
     }
     return {
-      totalEntries: entries.length,
-      groomedCount: entries.length,
+      totalEntries,
+      groomedCount: totalEntries,
       tagsNormalized,
       staleCount,
       durationMs: Date.now() - start,
@@ -343,7 +442,8 @@ export class Curator {
   // ─── Health Audit (delegates to health-audit) ─────────────────
 
   healthAudit(): HealthAuditResult {
-    const entries = this.vault.list({ limit: 100000 });
+    // Load entries in batches instead of all at once
+    const entries = this.listBatched();
     const dataProvider: HealthDataProvider = {
       getStaleCount: (threshold) =>
         (
@@ -480,6 +580,22 @@ export class Curator {
 
   // ─── Private Helpers ──────────────────────────────────────────
 
+  /**
+   * Load all vault entries using batched pagination instead of a single 100k query.
+   */
+  private listBatched(batchSize: number = DEFAULT_BATCH_SIZE): IntelligenceEntry[] {
+    const all: IntelligenceEntry[] = [];
+    let offset = 0;
+    while (true) {
+      const batch = this.vault.list({ limit: batchSize, offset });
+      if (batch.length === 0) break;
+      all.push(...batch);
+      if (batch.length < batchSize) break;
+      offset += batchSize;
+    }
+    return all;
+  }
+
   private persistContradictions(candidates: ContradictionCandidate[]): Contradiction[] {
     const detected: Contradiction[] = [];
     for (const c of candidates) {

package/src/hooks/candidate-scorer.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { scoreCandidateForConversion } from './candidate-scorer.js';
+import type { CandidateDimensions } from './candidate-scorer.js';
+
+describe('scoreCandidateForConversion', () => {
+  it('should identify strong candidate (4/4 HIGH)', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'HIGH',
+      eventCorrelation: 'HIGH',
+      determinism: 'HIGH',
+      autonomy: 'HIGH',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.highCount).toBe(4);
+    expect(result.candidate).toBe(true);
+  });
+
+  it('should identify borderline candidate (3/4 HIGH)', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'HIGH',
+      eventCorrelation: 'HIGH',
+      determinism: 'HIGH',
+      autonomy: 'LOW',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.highCount).toBe(3);
+    expect(result.candidate).toBe(true);
+  });
+
+  it('should reject non-candidate (2/4 HIGH)', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'HIGH',
+      eventCorrelation: 'LOW',
+      determinism: 'HIGH',
+      autonomy: 'LOW',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.highCount).toBe(2);
+    expect(result.candidate).toBe(false);
+  });
+
+  it('should reject weak candidate (1/4 HIGH)', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'LOW',
+      eventCorrelation: 'LOW',
+      determinism: 'LOW',
+      autonomy: 'HIGH',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.highCount).toBe(1);
+    expect(result.candidate).toBe(false);
+  });
+
+  it('should reject zero score (0/4 HIGH)', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'LOW',
+      eventCorrelation: 'LOW',
+      determinism: 'LOW',
+      autonomy: 'LOW',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.highCount).toBe(0);
+    expect(result.candidate).toBe(false);
+  });
+
+  it('should preserve dimension values in result', () => {
+    const dimensions: CandidateDimensions = {
+      frequency: 'HIGH',
+      eventCorrelation: 'LOW',
+      determinism: 'HIGH',
+      autonomy: 'HIGH',
+    };
+    const result = scoreCandidateForConversion(dimensions);
+    expect(result.dimensions).toEqual(dimensions);
+  });
+});

package/src/hooks/candidate-scorer.ts

@@ -0,0 +1,39 @@
+/**
+ * Candidate scoring rubric for skill-to-hook conversion.
+ * 4-dimension scoring: frequency, eventCorrelation, determinism, autonomy.
+ * Threshold: >= 3 HIGH dimensions = candidate for conversion.
+ */
+
+export type DimensionLevel = 'HIGH' | 'LOW';
+
+export interface CandidateDimensions {
+  /** 3+ manual calls per session for same event type → HIGH */
+  frequency: DimensionLevel;
+  /** Skill consistently triggers on a recognizable hook event → HIGH */
+  eventCorrelation: DimensionLevel;
+  /** Skill produces consistent, non-exploratory guidance → HIGH */
+  determinism: DimensionLevel;
+  /** Skill requires no interactive user decisions mid-execution → HIGH */
+  autonomy: DimensionLevel;
+}
+
+export interface CandidateScore {
+  dimensions: CandidateDimensions;
+  highCount: number;
+  candidate: boolean;
+}
+
+/**
+ * Score a skill for hook conversion candidacy.
+ * @param dimensions - The 4 scored dimensions (each HIGH or LOW)
+ * @returns Score with candidate boolean (true if >= 3 HIGH)
+ */
+export function scoreCandidateForConversion(dimensions: CandidateDimensions): CandidateScore {
+  const values = Object.values(dimensions);
+  const highCount = values.filter((v) => v === 'HIGH').length;
+  return {
+    dimensions,
+    highCount,
+    candidate: highCount >= 3,
+  };
+}

package/src/hooks/index.ts

@@ -0,0 +1,6 @@
+export {
+  scoreCandidateForConversion,
+  type CandidateDimensions,
+  type CandidateScore,
+  type DimensionLevel,
+} from './candidate-scorer.js';

package/src/index.ts

@@ -551,6 +551,8 @@ export { createSemanticFacades } from './runtime/facades/index.js';
 export { createDomainFacade, createDomainFacades } from './runtime/domain-ops.js';
 export { FeatureFlags } from './runtime/feature-flags.js';
 export type { FlagDefinition } from './runtime/feature-flags.js';
+export { ShutdownRegistry } from './runtime/shutdown-registry.js';
+export type { ShutdownCallback } from './runtime/shutdown-registry.js';
 export type { AgentRuntimeConfig, AgentRuntime } from './runtime/types.js';
 export {
   deprecationWarning,

package/src/llm/llm-client.ts

@@ -237,6 +237,7 @@ export class LLMClient {
           temperature: options.temperature ?? 0.3,
           max_completion_tokens: options.maxTokens ?? 500,
         }),
+        signal: AbortSignal.timeout(60_000),
       });
 
       if (response.headers) {

package/src/persistence/sqlite-provider.ts

@@ -20,6 +20,7 @@ export function applyPerformancePragmas(db: Database.Database): void {
   db.pragma('cache_size = -64000'); // 64MB
   db.pragma('temp_store = MEMORY');
   db.pragma('mmap_size = 268435456'); // 256MB
+  db.pragma('synchronous = NORMAL');
 }
 
 export class SQLitePersistenceProvider implements PersistenceProvider {

package/src/planning/github-projection.ts

@@ -7,7 +7,10 @@
  * The plan is the source of truth; GitHub issues are the projection.
  */
 
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
 
 // ---------------------------------------------------------------------------
 // Types
@@ -88,15 +91,14 @@ export function parseGitHubRemote(remoteUrl: string): GitHubRepo | null {
  * Detect the GitHub remote from a project directory.
  * Returns null if no GitHub remote found or not a git repo.
  */
-export function detectGitHubRemote(projectPath: string): GitHubRepo | null {
+export async function detectGitHubRemote(projectPath: string): Promise<GitHubRepo | null> {
   try {
-    const output = execFileSync('git', ['remote', 'get-url', 'origin'], {
+    const { stdout } = await execFileAsync('git', ['remote', 'get-url', 'origin'], {
       cwd: projectPath,
-      encoding: 'utf-8',
       timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-    return parseGitHubRemote(output);
+      signal: AbortSignal.timeout(5000),
+    });
+    return parseGitHubRemote(stdout.trim());
   } catch {
     return null;
   }
@@ -105,12 +107,11 @@ export function detectGitHubRemote(projectPath: string): GitHubRepo | null {
 /**
  * Check if the `gh` CLI is authenticated.
  */
-export function isGhAuthenticated(): boolean {
+export async function isGhAuthenticated(): Promise<boolean> {
   try {
-    execFileSync('gh', ['auth', 'status'], {
-      encoding: 'utf-8',
+    await execFileAsync('gh', ['auth', 'status'], {
       timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
+      signal: AbortSignal.timeout(5000),
     });
     return true;
   } catch {
@@ -125,9 +126,9 @@ export function isGhAuthenticated(): boolean {
 /**
  * List milestones for a GitHub repo.
  */
-export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
+export async function listMilestones(repo: GitHubRepo): Promise<GitHubMilestone[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       [
         'api',
@@ -136,12 +137,12 @@ export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
         '.[] | {number, title, state}',
       ],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
 
     // gh --jq outputs one JSON object per line
@@ -157,9 +158,12 @@ export function listMilestones(repo: GitHubRepo): GitHubMilestone[] {
 /**
  * List open issues for a GitHub repo.
  */
-export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIssue[] {
+export async function listOpenIssues(
+  repo: GitHubRepo,
+  limit: number = 100,
+): Promise<GitHubIssue[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       [
         'issue',
@@ -174,12 +178,12 @@ export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIss
         'number,title,state,body',
       ],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
     return JSON.parse(output) as GitHubIssue[];
   } catch {
@@ -190,18 +194,18 @@ export function listOpenIssues(repo: GitHubRepo, limit: number = 100): GitHubIss
 /**
  * List labels for a GitHub repo.
  */
-export function listLabels(repo: GitHubRepo): GitHubLabel[] {
+export async function listLabels(repo: GitHubRepo): Promise<GitHubLabel[]> {
   try {
-    const output = execFileSync(
+    const { stdout } = await execFileAsync(
       'gh',
       ['label', 'list', '--repo', `${repo.owner}/${repo.repo}`, '--json', 'name,color'],
       {
-        encoding: 'utf-8',
         timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(10000),
       },
-    ).trim();
+    );
 
+    const output = stdout.trim();
     if (!output) return [];
     return JSON.parse(output) as GitHubLabel[];
   } catch {
@@ -217,16 +221,18 @@ export function listLabels(repo: GitHubRepo): GitHubLabel[] {
  * Detect full GitHub context for a project.
  * Returns null if not a GitHub project or gh CLI not available.
  */
-export function detectGitHubContext(projectPath: string): GitHubContext | null {
-  const repo = detectGitHubRemote(projectPath);
+export async function detectGitHubContext(projectPath: string): Promise<GitHubContext | null> {
+  const repo = await detectGitHubRemote(projectPath);
   if (!repo) return null;
 
-  const authenticated = isGhAuthenticated();
+  const authenticated = await isGhAuthenticated();
   if (!authenticated) return null;
 
-  const milestones = listMilestones(repo);
-  const existingIssues = listOpenIssues(repo);
-  const labels = listLabels(repo);
+  const [milestones, existingIssues, labels] = await Promise.all([
+    listMilestones(repo),
+    listOpenIssues(repo),
+    listLabels(repo),
+  ]);
 
   return { repo, authenticated, milestones, existingIssues, labels };
 }
@@ -370,7 +376,7 @@ export function formatIssueBody(
  * Create a GitHub issue using the `gh` CLI.
  * Returns the issue number, or null on failure.
  */
-export function createGitHubIssue(
+export async function createGitHubIssue(
   repo: GitHubRepo,
   title: string,
   body: string,
@@ -378,7 +384,7 @@ export function createGitHubIssue(
     milestone?: number;
     labels?: string[];
   },
-): number | null {
+): Promise<number | null> {
   try {
     const args = [
       'issue',
@@ -399,14 +405,13 @@ export function createGitHubIssue(
       args.push('--label', options.labels.join(','));
     }
 
-    const output = execFileSync('gh', args, {
-      encoding: 'utf-8',
+    const { stdout } = await execFileAsync('gh', args, {
       timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
+      signal: AbortSignal.timeout(15000),
+    });
 
     // gh issue create returns the issue URL: https://github.com/owner/repo/issues/123
-    const match = output.match(/\/issues\/(\d+)/);
+    const match = stdout.trim().match(/\/issues\/(\d+)/);
     return match ? parseInt(match[1], 10) : null;
   } catch {
     return null;
@@ -416,13 +421,13 @@ export function createGitHubIssue(
 /**
  * Update an existing GitHub issue body (for linking plans to existing issues).
  */
-export function updateGitHubIssueBody(
+export async function updateGitHubIssueBody(
   repo: GitHubRepo,
   issueNumber: number,
   body: string,
-): boolean {
+): Promise<boolean> {
   try {
-    execFileSync(
+    await execFileAsync(
       'gh',
       [
         'issue',
@@ -434,9 +439,8 @@ export function updateGitHubIssueBody(
         body,
       ],
       {
-        encoding: 'utf-8',
         timeout: 15000,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        signal: AbortSignal.timeout(15000),
       },
     );
     return true;

package/src/planning/plan-lifecycle.ts

@@ -380,7 +380,20 @@ export function createPlanObject(params: {
     scope: params.scope,
     status: params.initialStatus ?? 'draft',
     decisions: params.decisions ?? [],
-    tasks: (params.tasks ?? []).map((t, i) => (Object.assign({id:`task-${i+1}`,title:t.title,description:t.description,status:`pending` as TaskStatus}, t.phase!==undefined&&{phase:t.phase}, t.milestone!==undefined&&{milestone:t.milestone}, t.parentTaskId!==undefined&&{parentTaskId:t.parentTaskId}, {updatedAt:now}))),
+    tasks: (params.tasks ?? []).map((t, i) =>
+      Object.assign(
+        {
+          id: `task-${i + 1}`,
+          title: t.title,
+          description: t.description,
+          status: `pending` as TaskStatus,
+        },
+        t.phase !== undefined && { phase: t.phase },
+        t.milestone !== undefined && { milestone: t.milestone },
+        t.parentTaskId !== undefined && { parentTaskId: t.parentTaskId },
+        { updatedAt: now },
+      ),
+    ),
     ...(params.approach !== undefined && { approach: params.approach }),
     ...(params.context !== undefined && { context: params.context }),
     ...(params.success_criteria !== undefined && { success_criteria: params.success_criteria }),

package/src/queue/pipeline-runner.ts

@@ -58,6 +58,10 @@ export class PipelineRunner {
     if (this.running) return;
     this.running = true;
     this.timer = setInterval(() => this.tick(), this.pollIntervalMs);
+    // Don't prevent process exit for background polling
+    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+      (this.timer as NodeJS.Timeout).unref();
+    }
   }
 
   /**

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;
 }