@soleri/core 9.0.4 → 9.3.0

package/src/{__tests__ → health}/health-registry.test.ts

@@ -1,45 +1,46 @@
 import { describe, it, expect, vi } from 'vitest';
-import { HealthRegistry, withDegradation } from '../health/health-registry.js';
+import { HealthRegistry, withDegradation } from './health-registry.js';
 
 describe('HealthRegistry', () => {
-  it('registers subsystems with default healthy status', () => {
+  it('registers a subsystem with default healthy status', () => {
     const reg = new HealthRegistry();
     reg.register('vault');
     const sub = reg.get('vault');
     expect(sub).toBeDefined();
     expect(sub!.status).toBe('healthy');
     expect(sub!.failureCount).toBe(0);
+    expect(sub!.lastError).toBeNull();
   });
 
-  it('ignores duplicate registration', () => {
+  it('ignores duplicate registration (does not reset)', () => {
     const reg = new HealthRegistry();
     reg.register('vault', 'healthy');
-    reg.update('vault', 'degraded', 'test');
-    reg.register('vault'); // should NOT reset
+    reg.update('vault', 'degraded', 'err');
+    reg.register('vault');
     expect(reg.get('vault')!.status).toBe('degraded');
   });
 
-  it('tracks status transitions', () => {
+  it('tracks transitions: healthy -> degraded -> healthy', () => {
     const reg = new HealthRegistry();
-    reg.register('external');
-    reg.update('external', 'degraded', 'timeout');
-    expect(reg.get('external')!.status).toBe('degraded');
-    expect(reg.get('external')!.failureCount).toBe(1);
-    expect(reg.get('external')!.lastError).toBe('timeout');
-
-    reg.update('external', 'healthy');
-    expect(reg.get('external')!.failureCount).toBe(0);
-    expect(reg.get('external')!.lastError).toBeNull();
-    expect(reg.get('external')!.lastHealthyAt).toBeGreaterThan(0);
+    reg.register('svc');
+    reg.update('svc', 'degraded', 'timeout');
+    expect(reg.get('svc')!.status).toBe('degraded');
+    expect(reg.get('svc')!.failureCount).toBe(1);
+    expect(reg.get('svc')!.lastError).toBe('timeout');
+
+    reg.update('svc', 'healthy');
+    expect(reg.get('svc')!.failureCount).toBe(0);
+    expect(reg.get('svc')!.lastError).toBeNull();
+    expect(reg.get('svc')!.lastHealthyAt).toBeGreaterThan(0);
   });
 
-  it('auto-registers on update if not registered', () => {
+  it('auto-registers on update if not previously registered', () => {
     const reg = new HealthRegistry();
-    reg.update('new-sub', 'degraded', 'oops');
-    expect(reg.get('new-sub')!.status).toBe('degraded');
+    reg.update('new', 'degraded', 'oops');
+    expect(reg.get('new')!.status).toBe('degraded');
   });
 
-  it('computes overall status', () => {
+  it('computes overall: healthy, degraded, down', () => {
     const reg = new HealthRegistry();
     reg.register('a', 'healthy');
     reg.register('b', 'healthy');
@@ -52,63 +53,58 @@ describe('HealthRegistry', () => {
     expect(reg.snapshot().overall).toBe('down');
   });
 
-  it('fires status change listeners', () => {
+  it('fires status change listeners on transitions', () => {
     const reg = new HealthRegistry();
-    reg.register('vault');
-    const changes: Array<[string, string, string]> = [];
-    reg.onStatusChange((name, prev, next) => {
-      changes.push([name, prev, next]);
-    });
+    reg.register('x');
+    const changes: string[][] = [];
+    reg.onStatusChange((name, prev, next) => changes.push([name, prev, next]));
 
-    reg.update('vault', 'degraded');
-    reg.update('vault', 'degraded'); // same status — no listener
-    reg.update('vault', 'down');
-    reg.update('vault', 'healthy');
+    reg.update('x', 'degraded');
+    reg.update('x', 'degraded'); // same status, no fire
+    reg.update('x', 'down');
+    reg.update('x', 'healthy');
 
     expect(changes).toEqual([
-      ['vault', 'healthy', 'degraded'],
-      ['vault', 'degraded', 'down'],
-      ['vault', 'down', 'healthy'],
+      ['x', 'healthy', 'degraded'],
+      ['x', 'degraded', 'down'],
+      ['x', 'down', 'healthy'],
     ]);
   });
 
-  it('does not fire listener for same status', () => {
+  it('does not fire listener for same-status update', () => {
     const reg = new HealthRegistry();
     reg.register('llm', 'healthy');
     const listener = vi.fn();
     reg.onStatusChange(listener);
-
     reg.update('llm', 'healthy');
     expect(listener).not.toHaveBeenCalled();
   });
 
-  it('fires recovery hooks when transitioning to healthy', () => {
+  it('fires recovery hooks on transition to healthy', () => {
     const reg = new HealthRegistry();
-    reg.register('external', 'down');
+    reg.register('ext', 'down');
     const hook = vi.fn();
-    reg.onRecovery('external', hook);
-
-    reg.update('external', 'healthy');
-    expect(hook).toHaveBeenCalledWith('external');
+    reg.onRecovery('ext', hook);
+    reg.update('ext', 'healthy');
+    expect(hook).toHaveBeenCalledWith('ext');
   });
 
   it('does not fire recovery hooks for non-recovery transitions', () => {
     const reg = new HealthRegistry();
-    reg.register('external', 'healthy');
+    reg.register('ext', 'healthy');
     const hook = vi.fn();
-    reg.onRecovery('external', hook);
-
-    reg.update('external', 'degraded');
-    reg.update('external', 'down');
+    reg.onRecovery('ext', hook);
+    reg.update('ext', 'degraded');
+    reg.update('ext', 'down');
     expect(hook).not.toHaveBeenCalled();
   });
 
-  it('snapshot returns copies', () => {
+  it('snapshot returns defensive copies', () => {
     const reg = new HealthRegistry();
     reg.register('vault', 'healthy');
     const snap = reg.snapshot();
-    snap.subsystems['vault'].status = 'down'; // mutate copy
-    expect(reg.get('vault')!.status).toBe('healthy'); // original unchanged
+    snap.subsystems['vault'].status = 'down';
+    expect(reg.get('vault')!.status).toBe('healthy');
   });
 
   it('listener errors do not crash the registry', () => {
@@ -117,17 +113,28 @@ describe('HealthRegistry', () => {
     reg.onStatusChange(() => {
       throw new Error('bad listener');
     });
-    // Should not throw
     reg.update('vault', 'degraded');
     expect(reg.get('vault')!.status).toBe('degraded');
   });
+
+  it('returns undefined for unregistered subsystem', () => {
+    const reg = new HealthRegistry();
+    expect(reg.get('nonexistent')).toBeUndefined();
+  });
+
+  it('snapshot includes registeredAt timestamp', () => {
+    const before = Date.now();
+    const reg = new HealthRegistry();
+    const snap = reg.snapshot();
+    expect(snap.registeredAt).toBeGreaterThanOrEqual(before);
+    expect(snap.registeredAt).toBeLessThanOrEqual(Date.now());
+  });
 });
 
 describe('withDegradation', () => {
   it('returns result on success and marks healthy', async () => {
     const reg = new HealthRegistry();
     reg.register('test', 'degraded');
-
     const result = await withDegradation(reg, 'test', async () => 42, 0);
     expect(result).toBe(42);
     expect(reg.get('test')!.status).toBe('healthy');
@@ -136,7 +143,6 @@ describe('withDegradation', () => {
   it('returns fallback on failure and marks degraded', async () => {
     const reg = new HealthRegistry();
     reg.register('test');
-
     const result = await withDegradation(
       reg,
       'test',
@@ -164,10 +170,24 @@ describe('withDegradation', () => {
         null,
       );
 
-    await fail(); // healthy → degraded
+    await fail();
     expect(reg.get('test')!.status).toBe('degraded');
-
-    await fail(); // degraded → down
+    await fail();
     expect(reg.get('test')!.status).toBe('down');
   });
+
+  it('handles non-Error thrown values', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test');
+    const result = await withDegradation(
+      reg,
+      'test',
+      async () => {
+        throw 'string error';
+      },
+      'default',
+    );
+    expect(result).toBe('default');
+    expect(reg.get('test')!.lastError).toBe('string error');
+  });
 });

package/src/health/vault-integrity.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi } from 'vitest';
+import { checkVaultIntegrity } from './vault-integrity.js';
+import type { PersistenceProvider } from '../persistence/types.js';
+
+function createMockProvider(overrides: Partial<PersistenceProvider> = {}): PersistenceProvider {
+  return {
+    backend: 'sqlite' as const,
+    execSql: vi.fn(),
+    run: vi.fn().mockReturnValue({ changes: 0, lastInsertRowid: 0 }),
+    get: vi.fn().mockReturnValue({ count: 0 }),
+    all: vi.fn().mockReturnValue([]),
+    transaction: vi.fn((fn) => fn()),
+    ftsSearch: vi.fn().mockReturnValue([]),
+    ...overrides,
+  } as unknown as PersistenceProvider;
+}
+
+describe('checkVaultIntegrity', () => {
+  it('reports healthy when all tables exist and FTS is in sync', () => {
+    const provider = createMockProvider({
+      get: vi.fn().mockReturnValue({ count: 5 }),
+    });
+
+    const result = checkVaultIntegrity(provider);
+    expect(result.schemaValid).toBe(true);
+    expect(result.ftsValid).toBe(true);
+    expect(result.ftsRebuilt).toBe(false);
+    expect(result.missingTables).toEqual([]);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('detects missing tables', () => {
+    const getMock = vi.fn().mockImplementation((sql: string) => {
+      if (sql.includes('brain_vocabulary')) throw new Error('no such table');
+      if (sql.includes('entries_fts')) throw new Error('no such table');
+      return { count: 0 };
+    });
+
+    const provider = createMockProvider({ get: getMock });
+    const result = checkVaultIntegrity(provider);
+
+    expect(result.schemaValid).toBe(false);
+    expect(result.missingTables).toContain('brain_vocabulary');
+    expect(result.missingTables).toContain('entries_fts');
+  });
+
+  it('detects FTS row count mismatch and attempts rebuild', () => {
+    const getMock = vi.fn().mockImplementation((sql: string) => {
+      if (sql.includes('SELECT 1 FROM')) return { exists: 1 };
+      if (sql.includes('COUNT(*)') && sql.includes('entries_fts')) return { count: 3 };
+      if (sql.includes('COUNT(*)') && sql.includes('entries')) return { count: 5 };
+      return { count: 0 };
+    });
+    const runMock = vi.fn().mockReturnValue({ changes: 0, lastInsertRowid: 0 });
+
+    const provider = createMockProvider({ get: getMock, run: runMock });
+    const result = checkVaultIntegrity(provider);
+
+    expect(result.ftsValid).toBe(false);
+    expect(result.errors.some((e) => e.includes('FTS index out of sync'))).toBe(true);
+    expect(result.ftsRebuilt).toBe(true);
+    expect(runMock).toHaveBeenCalledWith("INSERT INTO entries_fts(entries_fts) VALUES('rebuild')");
+  });
+
+  it('reports FTS rebuild failure', () => {
+    const getMock = vi.fn().mockImplementation((sql: string) => {
+      if (sql.includes('SELECT 1 FROM')) return { exists: 1 };
+      if (sql.includes('COUNT(*)') && sql.includes('entries_fts')) return { count: 1 };
+      if (sql.includes('COUNT(*)') && sql.includes('entries')) return { count: 5 };
+      return { count: 0 };
+    });
+    const runMock = vi.fn().mockImplementation(() => {
+      throw new Error('rebuild failed');
+    });
+
+    const provider = createMockProvider({ get: getMock, run: runMock });
+    const result = checkVaultIntegrity(provider);
+
+    expect(result.ftsRebuilt).toBe(false);
+    expect(result.errors.some((e) => e.includes('rebuild failed'))).toBe(true);
+  });
+
+  it('skips FTS check when entries_fts table is missing', () => {
+    const getMock = vi.fn().mockImplementation((sql: string) => {
+      if (sql.includes('entries_fts')) throw new Error('no such table');
+      return { count: 0 };
+    });
+
+    const provider = createMockProvider({ get: getMock });
+    const result = checkVaultIntegrity(provider);
+
+    expect(result.missingTables).toContain('entries_fts');
+    // FTS validity should remain default true since check was skipped
+    expect(result.ftsValid).toBe(true);
+  });
+
+  it('handles FTS count query failure gracefully', () => {
+    const getMock = vi.fn().mockImplementation((sql: string) => {
+      if (sql.includes('SELECT 1 FROM')) return { exists: 1 };
+      if (sql.includes('COUNT(*)')) throw new Error('query failed');
+      return { count: 0 };
+    });
+
+    const provider = createMockProvider({ get: getMock });
+    const result = checkVaultIntegrity(provider);
+
+    expect(result.ftsValid).toBe(false);
+    expect(result.errors.some((e) => e.includes('FTS check failed'))).toBe(true);
+  });
+});

package/src/index.ts

@@ -1,3 +1,17 @@
+// ─── Paths ──────────────────────────────────────────────────────────
+export {
+  SOLERI_HOME,
+  agentHome,
+  legacyAgentHome,
+  usedLegacyFallback,
+  agentVaultPath,
+  agentPlansPath,
+  agentKeysPath,
+  agentTemplatesDir,
+  agentFlagsPath,
+  sharedVaultPath,
+} from './paths.js';
+
 // ─── Intelligence ────────────────────────────────────────────────────
 export type {
   IntelligenceEntry,
@@ -280,6 +294,7 @@ export {
   LIFECYCLE_TRANSITIONS,
   NON_EXPIRING_STATUSES,
   DRIFT_WEIGHTS,
+  PlanGradeRejectionError,
 } from './planning/planner.js';
 export type {
   PlanStatus,
@@ -288,6 +303,8 @@ export type {
   TaskMetrics,
   TaskDeliverable,
   ExecutionSummary,
+  VerificationFinding,
+  TaskVerification,
   PlanTask,
   PlanDecision,
   Plan,
@@ -297,6 +314,7 @@ export type {
   ReviewEvidence,
   PlanGrade,
   PlanCheck,
+  PlannerOptions,
 } from './planning/planner.js';
 
 // ─── Plan Gap Analysis ──────────────────────────────────────────────
@@ -317,6 +335,32 @@ export {
 } from './planning/gap-types.js';
 export type { GapSeverity, GapCategory, PlanGap } from './planning/gap-types.js';
 
+// ─── GitHub Projection ───────────────────────────────────────────────
+export {
+  parseGitHubRemote,
+  detectGitHubRemote,
+  isGhAuthenticated,
+  detectGitHubContext,
+  findMatchingMilestone,
+  findDuplicateIssue,
+  formatIssueBody,
+  createGitHubIssue,
+  updateGitHubIssueBody,
+  listMilestones,
+  listOpenIssues,
+  listLabels,
+} from './planning/github-projection.js';
+export type {
+  GitHubRepo,
+  GitHubMilestone,
+  GitHubIssue,
+  GitHubLabel,
+  GitHubContext,
+  GitHubProjection,
+  ProjectedIssue,
+  PlanMetadataForIssue,
+} from './planning/github-projection.js';
+
 // ─── Loop ────────────────────────────────────────────────────────────
 export {
   LoopManager,
@@ -699,3 +743,51 @@ export {
   createDispatcher,
   runEpilogue,
 } from './flows/index.js';
+
+// ─── Operator Profile ───────────────────────────────────────────────
+export { OperatorProfileStore } from './operator/operator-profile.js';
+export { SignalType } from './operator/operator-types.js';
+export {
+  extractFromSession,
+  extractFromRadar,
+  extractFromBrainStrengths,
+} from './operator/operator-signals.js';
+export type { SessionCaptureData } from './operator/operator-signals.js';
+export type {
+  CommandStyleData,
+  WorkRhythmData,
+  ToolPreferenceData,
+  SessionDepthData,
+  DomainExpertiseData,
+  CorrectionData,
+  FrustrationData,
+  PersonalShareData,
+  CommunicationPrefData,
+  ReactionToOutputData,
+  SignalDataMap,
+  OperatorSignal,
+  ProfileEvidence,
+  IdentitySection,
+  CognitivePattern,
+  CognitiveDerivation,
+  CognitionSection,
+  CommunicationAdaptationRule,
+  CommunicationSection,
+  WorkingRule,
+  WorkingRulesSection,
+  TrustEvent,
+  TrustModelSection,
+  TasteEntry,
+  TasteProfileSection,
+  GrowthEdge,
+  GrowthEdgesSection,
+  TechnicalTool,
+  TechnicalBlindSpot,
+  TechnicalContextSection,
+  ProfileSection,
+  ProfileSectionKey,
+  OperatorProfile,
+  SynthesisCheckResult,
+  ProfileSnapshot,
+  OperatorProfileHistory,
+} from './operator/operator-types.js';