@soleri/core 9.0.3 → 9.2.0

package/src/health/health-registry.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi } from 'vitest';
+import { HealthRegistry, withDegradation } from './health-registry.js';
+
+describe('HealthRegistry', () => {
+  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 (does not reset)', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault', 'healthy');
+    reg.update('vault', 'degraded', 'err');
+    reg.register('vault');
+    expect(reg.get('vault')!.status).toBe('degraded');
+  });
+
+  it('tracks transitions: healthy -> degraded -> healthy', () => {
+    const reg = new HealthRegistry();
+    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 previously registered', () => {
+    const reg = new HealthRegistry();
+    reg.update('new', 'degraded', 'oops');
+    expect(reg.get('new')!.status).toBe('degraded');
+  });
+
+  it('computes overall: healthy, degraded, down', () => {
+    const reg = new HealthRegistry();
+    reg.register('a', 'healthy');
+    reg.register('b', 'healthy');
+    expect(reg.snapshot().overall).toBe('healthy');
+
+    reg.update('b', 'degraded');
+    expect(reg.snapshot().overall).toBe('degraded');
+
+    reg.update('a', 'down');
+    expect(reg.snapshot().overall).toBe('down');
+  });
+
+  it('fires status change listeners on transitions', () => {
+    const reg = new HealthRegistry();
+    reg.register('x');
+    const changes: string[][] = [];
+    reg.onStatusChange((name, prev, next) => changes.push([name, prev, next]));
+
+    reg.update('x', 'degraded');
+    reg.update('x', 'degraded'); // same status, no fire
+    reg.update('x', 'down');
+    reg.update('x', 'healthy');
+
+    expect(changes).toEqual([
+      ['x', 'healthy', 'degraded'],
+      ['x', 'degraded', 'down'],
+      ['x', 'down', 'healthy'],
+    ]);
+  });
+
+  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 on transition to healthy', () => {
+    const reg = new HealthRegistry();
+    reg.register('ext', 'down');
+    const hook = vi.fn();
+    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('ext', 'healthy');
+    const hook = vi.fn();
+    reg.onRecovery('ext', hook);
+    reg.update('ext', 'degraded');
+    reg.update('ext', 'down');
+    expect(hook).not.toHaveBeenCalled();
+  });
+
+  it('snapshot returns defensive copies', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault', 'healthy');
+    const snap = reg.snapshot();
+    snap.subsystems['vault'].status = 'down';
+    expect(reg.get('vault')!.status).toBe('healthy');
+  });
+
+  it('listener errors do not crash the registry', () => {
+    const reg = new HealthRegistry();
+    reg.register('vault');
+    reg.onStatusChange(() => {
+      throw new Error('bad listener');
+    });
+    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');
+  });
+
+  it('returns fallback on failure and marks degraded', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test');
+    const result = await withDegradation(
+      reg,
+      'test',
+      async () => {
+        throw new Error('boom');
+      },
+      'fallback',
+    );
+    expect(result).toBe('fallback');
+    expect(reg.get('test')!.status).toBe('degraded');
+    expect(reg.get('test')!.lastError).toBe('boom');
+  });
+
+  it('escalates to down on repeated failures', async () => {
+    const reg = new HealthRegistry();
+    reg.register('test');
+
+    const fail = () =>
+      withDegradation(reg, 'test', async () => { throw new Error('fail'); }, null);
+
+    await fail();
+    expect(reg.get('test')!.status).toBe('degraded');
+    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';

package/src/intake/content-classifier.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { classifyChunk, VALID_TYPES, CLASSIFICATION_PROMPT } from './content-classifier.js';
+import type { LLMClient } from '../llm/llm-client.js';
+import type { LLMCallResult } from '../llm/types.js';
+
+// =============================================================================
+// MOCK LLM
+// =============================================================================
+
+function mockLLM(response: string): LLMClient {
+  return {
+    complete: async (): Promise<LLMCallResult> => ({
+      text: response,
+      model: 'mock',
+      provider: 'openai',
+      durationMs: 0,
+    }),
+    isAvailable: () => ({ openai: true, anthropic: false }),
+    getRoutes: () => [],
+  } as unknown as LLMClient;
+}
+
+function throwingLLM(error: Error): LLMClient {
+  return {
+    complete: async () => { throw error; },
+    isAvailable: () => ({ openai: true, anthropic: false }),
+    getRoutes: () => [],
+  } as unknown as LLMClient;
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+describe('classifyChunk', () => {
+  it('parses valid JSON array response into ClassifiedItems', async () => {
+    const llm = mockLLM(JSON.stringify([
+      {
+        type: 'pattern',
+        title: 'Test Pattern',
+        description: 'A useful design pattern.',
+        tags: ['design', 'architecture'],
+        severity: 'suggestion',
+      },
+    ]));
+
+    const result = await classifyChunk(llm, 'some text', 'page 1');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe('pattern');
+    expect(result[0].title).toBe('Test Pattern');
+    expect(result[0].description).toBe('A useful design pattern.');
+    expect(result[0].tags).toEqual(['design', 'architecture']);
+    expect(result[0].severity).toBe('suggestion');
+    expect(result[0].citation).toBe('page 1');
+  });
+
+  it('handles markdown fenced JSON responses', async () => {
+    const llm = mockLLM('```json\n[{"type":"pattern","title":"Fenced","description":"Inside fences.","tags":["test"],"severity":"warning"}]\n```');
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Fenced');
+  });
+
+  it('returns empty array for non-array response', async () => {
+    const llm = mockLLM(JSON.stringify({ not: 'an array' }));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array on LLM error (graceful degradation)', async () => {
+    const llm = throwingLLM(new Error('API timeout'));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array for invalid JSON response', async () => {
+    const llm = mockLLM('this is not json at all');
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toEqual([]);
+  });
+
+  it('filters out items with invalid type', async () => {
+    const llm = mockLLM(JSON.stringify([
+      { type: 'invalid-type', title: 'Bad', description: 'Bad type', tags: [], severity: 'suggestion' },
+      { type: 'pattern', title: 'Good', description: 'Good item.', tags: [], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Good');
+  });
+
+  it('filters out items missing required fields (title, description)', async () => {
+    const llm = mockLLM(JSON.stringify([
+      { type: 'pattern', title: '', description: 'No title', tags: [], severity: 'suggestion' },
+      { type: 'pattern', title: 'No desc', description: '', tags: [], severity: 'suggestion' },
+      { type: 'pattern', title: 'Valid', description: 'Valid item.', tags: [], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Valid');
+  });
+
+  it('truncates title to 80 characters', async () => {
+    const longTitle = 'A'.repeat(100);
+    const llm = mockLLM(JSON.stringify([
+      { type: 'pattern', title: longTitle, description: 'Desc.', tags: [], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title.length).toBe(80);
+  });
+
+  it('caps tags at 5 and lowercases them', async () => {
+    const llm = mockLLM(JSON.stringify([
+      {
+        type: 'pattern',
+        title: 'Tagged',
+        description: 'Many tags.',
+        tags: ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven'],
+        severity: 'suggestion',
+      },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result[0].tags).toHaveLength(5);
+    expect(result[0].tags.every(t => t === t.toLowerCase())).toBe(true);
+  });
+
+  it('defaults severity to suggestion for invalid values', async () => {
+    const llm = mockLLM(JSON.stringify([
+      { type: 'pattern', title: 'Bad Sev', description: 'Unknown sev.', tags: [], severity: 'unknown' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result[0].severity).toBe('suggestion');
+  });
+
+  it('handles all valid severity values', async () => {
+    const llm = mockLLM(JSON.stringify([
+      { type: 'pattern', title: 'Critical', description: 'Crit.', tags: [], severity: 'critical' },
+      { type: 'pattern', title: 'Warning', description: 'Warn.', tags: [], severity: 'warning' },
+      { type: 'pattern', title: 'Suggestion', description: 'Sug.', tags: [], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result.map(r => r.severity)).toEqual(['critical', 'warning', 'suggestion']);
+  });
+
+  it('filters out non-object items in the array', async () => {
+    const llm = mockLLM(JSON.stringify([
+      null,
+      42,
+      'string',
+      { type: 'pattern', title: 'Valid', description: 'OK.', tags: [], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe('Valid');
+  });
+
+  it('filters non-string tags from the tags array', async () => {
+    const llm = mockLLM(JSON.stringify([
+      { type: 'pattern', title: 'Mixed Tags', description: 'OK.', tags: ['valid', 42, null, 'also-valid'], severity: 'suggestion' },
+    ]));
+
+    const result = await classifyChunk(llm, 'text', 'cite');
+
+    expect(result[0].tags).toEqual(['valid', 'also-valid']);
+  });
+});
+
+describe('VALID_TYPES and CLASSIFICATION_PROMPT', () => {
+  it('VALID_TYPES has all expected knowledge types', () => {
+    expect(VALID_TYPES).toContain('pattern');
+    expect(VALID_TYPES).toContain('anti-pattern');
+    expect(VALID_TYPES).toContain('principle');
+    expect(VALID_TYPES).toContain('concept');
+    expect(VALID_TYPES).toContain('reference');
+    expect(VALID_TYPES).toContain('workflow');
+    expect(VALID_TYPES).toContain('idea');
+    expect(VALID_TYPES).toContain('roadmap');
+    expect(VALID_TYPES).toHaveLength(8);
+  });
+
+  it('CLASSIFICATION_PROMPT includes valid types', () => {
+    expect(CLASSIFICATION_PROMPT).toContain('pattern');
+    expect(CLASSIFICATION_PROMPT).toContain('knowledge extraction');
+  });
+});