@soleri/core 2.4.0 → 2.6.0

package/src/__tests__/loop-ops.test.ts

@@ -269,15 +269,17 @@ describe('createLoopOps', () => {
     return op;
   }
 
-  it('exports 7 loop ops', () => {
-    expect(ops).toHaveLength(7);
+  it('exports 9 loop ops', () => {
+    expect(ops).toHaveLength(9);
     const names = ops.map((o) => o.name).sort();
     expect(names).toEqual([
+      'loop_anomaly_check',
       'loop_cancel',
       'loop_complete',
       'loop_history',
       'loop_is_active',
       'loop_iterate',
+      'loop_iterate_gate',
       'loop_start',
       'loop_status',
     ]);
@@ -384,8 +386,77 @@ describe('createLoopOps', () => {
     expect(result.active).toBe(false);
   });
 
+  it('loop_iterate_gate accepts durationMs parameter', async () => {
+    await findOp('loop_start').handler({ mode: 'token-migration', prompt: 'Test with timing' });
+
+    const result = (await findOp('loop_iterate_gate').handler({
+      lastOutput: 'Some LLM output that does not complete',
+      durationMs: 15000,
+    })) as Record<string, unknown>;
+
+    expect(result.decision).toBeDefined();
+    // Should not have anomaly warning for normal duration
+    expect(result.anomalyWarning).toBeUndefined();
+  });
+
+  it('loop_iterate_gate reports anomaly for fast + low-score iteration', async () => {
+    await findOp('loop_start').handler({ mode: 'token-migration', prompt: 'Test anomaly' });
+
+    // First iterate to set a low score baseline, then gate with fast duration
+    await findOp('loop_iterate').handler({ passed: false, validationScore: 20 });
+
+    const result = (await findOp('loop_iterate_gate').handler({
+      lastOutput: 'Quick response with low quality',
+      durationMs: 500, // Very fast — below 5000ms threshold for token-migration
+    })) as Record<string, unknown>;
+
+    // The gate still works, anomaly warning may or may not appear depending on score
+    expect(result.decision).toBeDefined();
+  });
+
+  it('loop_anomaly_check returns inactive when no loop', async () => {
+    const result = (await findOp('loop_anomaly_check').handler({})) as Record<string, unknown>;
+    expect(result.active).toBe(false);
+    expect(result.anomalies).toEqual([]);
+    expect(result.summary).toBe('No active loop');
+  });
+
+  it('loop_anomaly_check detects consecutive failures', async () => {
+    await findOp('loop_start').handler({ mode: 'custom', prompt: 'Failing loop' });
+    await findOp('loop_iterate').handler({ passed: false, validationScore: 20 });
+    await findOp('loop_iterate').handler({ passed: false, validationScore: 25 });
+    await findOp('loop_iterate').handler({ passed: false, validationScore: 30 });
+
+    const result = (await findOp('loop_anomaly_check').handler({})) as {
+      active: boolean;
+      hasAnomalies: boolean;
+      anomalies: string[];
+      totalIterations: number;
+    };
+
+    expect(result.active).toBe(true);
+    expect(result.totalIterations).toBe(3);
+    expect(result.hasAnomalies).toBe(true);
+    expect(result.anomalies.some((a) => a.includes('consecutive failing'))).toBe(true);
+  });
+
+  it('loop_anomaly_check returns no anomalies for passing loop', async () => {
+    await findOp('loop_start').handler({ mode: 'custom', prompt: 'Good loop' });
+    await findOp('loop_iterate').handler({ passed: true, validationScore: 90 });
+
+    const result = (await findOp('loop_anomaly_check').handler({})) as {
+      active: boolean;
+      hasAnomalies: boolean;
+      anomalies: string[];
+    };
+
+    expect(result.active).toBe(true);
+    expect(result.hasAnomalies).toBe(false);
+    expect(result.anomalies).toEqual([]);
+  });
+
   it('assigns correct auth levels', () => {
-    const readOps = ['loop_status', 'loop_history', 'loop_is_active'];
+    const readOps = ['loop_status', 'loop_history', 'loop_is_active', 'loop_anomaly_check'];
     const writeOps = ['loop_start', 'loop_iterate', 'loop_cancel', 'loop_complete'];
 
     for (const name of readOps) {

package/src/__tests__/memory-cross-project-ops.test.ts

@@ -125,7 +125,9 @@ describe('Memory Cross-Project Ops', () => {
 
       const project = runtime.projectRegistry.getByPath('/test/project-b');
       expect(project!.metadata.custom).toBe('value');
-      expect((project!.metadata.memoryConfig as Record<string, unknown>).crossProjectEnabled).toBe(false);
+      expect((project!.metadata.memoryConfig as Record<string, unknown>).crossProjectEnabled).toBe(
+        false,
+      );
     });
   });
 

package/src/__tests__/orchestrate-ops.test.ts

@@ -64,7 +64,10 @@ describe('createOrchestrateOps', () => {
         objective: 'Build a new button component',
         scope: 'src/components/Button',
         domain: 'component',
-      })) as { plan: { id: string; objective: string; decisions: string[] }; recommendations: unknown[] };
+      })) as {
+        plan: { id: string; objective: string; decisions: string[] };
+        recommendations: unknown[];
+      };
 
       expect(result.plan).toBeDefined();
       expect(result.plan.objective).toBe('Build a new button component');
@@ -130,7 +133,7 @@ describe('createOrchestrateOps', () => {
       });
 
       const op = findOp('orchestrate_execute');
-      await expect(op.handler({ planId: plan.id })).rejects.toThrow(/must be 'approved'/);
+      await expect(op.handler({ planId: plan.id })).rejects.toThrow(/Invalid transition/);
     });
   });
 
@@ -138,13 +141,14 @@ describe('createOrchestrateOps', () => {
 
   describe('orchestrate_complete', () => {
     it('should complete plan, end session, and extract knowledge', async () => {
-      // Full lifecycle: create -> approve -> execute -> complete
+      // Full lifecycle: create -> approve -> execute -> reconciling -> complete
       const plan = runtime.planner.create({
         objective: 'Full lifecycle test',
         scope: 'test',
       });
       runtime.planner.approve(plan.id);
       runtime.planner.startExecution(plan.id);
+      runtime.planner.startReconciliation(plan.id);
 
       // Start a brain session
       const session = runtime.brainIntelligence.lifecycle({
@@ -176,6 +180,7 @@ describe('createOrchestrateOps', () => {
       const plan = runtime.planner.create({ objective: 'Abandoned test', scope: 'test' });
       runtime.planner.approve(plan.id);
       runtime.planner.startExecution(plan.id);
+      runtime.planner.startReconciliation(plan.id);
 
       const session = runtime.brainIntelligence.lifecycle({
         action: 'start',

package/src/__tests__/persistence.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect } from 'vitest';
+import { SQLitePersistenceProvider } from '../persistence/sqlite-provider.js';
+import { Vault } from '../vault/vault.js';
+
+// ─── SQLitePersistenceProvider ────────────────────────────────────────
+
+describe('SQLitePersistenceProvider', () => {
+  it('execSql creates tables', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE test (id TEXT PRIMARY KEY, val TEXT)');
+    p.run('INSERT INTO test (id, val) VALUES (?, ?)', ['a', 'hello']);
+    const row = p.get<{ id: string; val: string }>('SELECT * FROM test WHERE id = ?', ['a']);
+    expect(row).toEqual({ id: 'a', val: 'hello' });
+    p.close();
+  });
+
+  it('run with named params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY, name TEXT)');
+    const result = p.run('INSERT INTO t (id, name) VALUES (@id, @name)', {
+      id: '1',
+      name: 'test',
+    });
+    expect(result.changes).toBe(1);
+    p.close();
+  });
+
+  it('run with positional params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const result = p.run('INSERT INTO t (id) VALUES (?)', ['x']);
+    expect(result.changes).toBe(1);
+    p.close();
+  });
+
+  it('run with no params', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT)');
+    const result = p.run('INSERT INTO t DEFAULT VALUES');
+    expect(result.changes).toBe(1);
+    expect(result.lastInsertRowid).toBe(1);
+    p.close();
+  });
+
+  it('get returns undefined for no match', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const row = p.get('SELECT * FROM t WHERE id = ?', ['nonexistent']);
+    expect(row).toBeUndefined();
+    p.close();
+  });
+
+  it('all returns empty for no matches', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toEqual([]);
+    p.close();
+  });
+
+  it('all returns multiple rows', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY, val INTEGER)');
+    p.run('INSERT INTO t VALUES (?, ?)', ['a', 1]);
+    p.run('INSERT INTO t VALUES (?, ?)', ['b', 2]);
+    p.run('INSERT INTO t VALUES (?, ?)', ['c', 3]);
+    const rows = p.all<{ id: string; val: number }>('SELECT * FROM t ORDER BY id');
+    expect(rows).toHaveLength(3);
+    expect(rows[0].id).toBe('a');
+    expect(rows[2].val).toBe(3);
+    p.close();
+  });
+
+  it('transaction commits on success', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    p.transaction(() => {
+      p.run('INSERT INTO t VALUES (?)', ['a']);
+      p.run('INSERT INTO t VALUES (?)', ['b']);
+    });
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toHaveLength(2);
+    p.close();
+  });
+
+  it('transaction rolls back on error', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    expect(() =>
+      p.transaction(() => {
+        p.run('INSERT INTO t VALUES (?)', ['a']);
+        throw new Error('rollback');
+      }),
+    ).toThrow('rollback');
+    const rows = p.all('SELECT * FROM t');
+    expect(rows).toHaveLength(0);
+    p.close();
+  });
+
+  it('transaction returns value', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql('CREATE TABLE t (id TEXT PRIMARY KEY)');
+    const result = p.transaction(() => {
+      p.run('INSERT INTO t VALUES (?)', ['a']);
+      return 42;
+    });
+    expect(result).toBe(42);
+    p.close();
+  });
+
+  it('getDatabase returns raw db', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    const db = p.getDatabase();
+    expect(db).toBeDefined();
+    // Verify it's a real better-sqlite3 database
+    expect(typeof db.prepare).toBe('function');
+    p.close();
+  });
+
+  it('close prevents further operations', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.close();
+    expect(() => p.run('SELECT 1')).toThrow();
+  });
+
+  it('backend returns sqlite', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    expect(p.backend).toBe('sqlite');
+    p.close();
+  });
+
+  it('ftsSearch returns matches', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql(`
+      CREATE TABLE docs (rowid INTEGER PRIMARY KEY, title TEXT, body TEXT);
+      CREATE VIRTUAL TABLE docs_fts USING fts5(title, body, content=docs, content_rowid=rowid);
+      INSERT INTO docs (rowid, title, body) VALUES (1, 'Hello World', 'This is a test document');
+      INSERT INTO docs (rowid, title, body) VALUES (2, 'Goodbye', 'Another test here');
+      INSERT INTO docs_fts (rowid, title, body) VALUES (1, 'Hello World', 'This is a test document');
+      INSERT INTO docs_fts (rowid, title, body) VALUES (2, 'Goodbye', 'Another test here');
+    `);
+    const results = p.ftsSearch<{ title: string; body: string }>('docs', 'hello');
+    expect(results).toHaveLength(1);
+    expect(results[0].title).toBe('Hello World');
+    p.close();
+  });
+
+  it('ftsSearch respects limit/offset', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql(`
+      CREATE TABLE items (rowid INTEGER PRIMARY KEY, name TEXT);
+      CREATE VIRTUAL TABLE items_fts USING fts5(name, content=items, content_rowid=rowid);
+      INSERT INTO items (rowid, name) VALUES (1, 'test alpha');
+      INSERT INTO items (rowid, name) VALUES (2, 'test beta');
+      INSERT INTO items (rowid, name) VALUES (3, 'test gamma');
+      INSERT INTO items_fts (rowid, name) VALUES (1, 'test alpha');
+      INSERT INTO items_fts (rowid, name) VALUES (2, 'test beta');
+      INSERT INTO items_fts (rowid, name) VALUES (3, 'test gamma');
+    `);
+    const limited = p.ftsSearch<{ name: string }>('items', 'test', { limit: 2 });
+    expect(limited).toHaveLength(2);
+    const offset = p.ftsSearch<{ name: string }>('items', 'test', { limit: 1, offset: 2 });
+    expect(offset).toHaveLength(1);
+    p.close();
+  });
+
+  it('ftsSearch applies filters', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    p.execSql(`
+      CREATE TABLE notes (rowid INTEGER PRIMARY KEY, title TEXT, category TEXT);
+      CREATE VIRTUAL TABLE notes_fts USING fts5(title, content=notes, content_rowid=rowid);
+      INSERT INTO notes (rowid, title, category) VALUES (1, 'design pattern', 'arch');
+      INSERT INTO notes (rowid, title, category) VALUES (2, 'design review', 'process');
+      INSERT INTO notes_fts (rowid, title) VALUES (1, 'design pattern');
+      INSERT INTO notes_fts (rowid, title) VALUES (2, 'design review');
+    `);
+    const filtered = p.ftsSearch<{ title: string; category: string }>('notes', 'design', {
+      filters: { category: 'arch' },
+    });
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0].category).toBe('arch');
+    p.close();
+  });
+
+  it('ftsRebuild no-ops gracefully', () => {
+    const p = new SQLitePersistenceProvider(':memory:');
+    // No FTS table exists — should not throw
+    expect(() => p.ftsRebuild('nonexistent')).not.toThrow();
+    p.close();
+  });
+});
+
+// ─── Vault with PersistenceProvider ───────────────────────────────────
+
+describe('Vault with PersistenceProvider', () => {
+  it('accepts string path (backward compat)', () => {
+    const vault = new Vault(':memory:');
+    expect(vault.stats().totalEntries).toBe(0);
+    vault.close();
+  });
+
+  it('accepts SQLitePersistenceProvider', () => {
+    const provider = new SQLitePersistenceProvider(':memory:');
+    provider.run('PRAGMA journal_mode = WAL');
+    provider.run('PRAGMA foreign_keys = ON');
+    const vault = new Vault(provider);
+    expect(vault.stats().totalEntries).toBe(0);
+    vault.close();
+  });
+
+  it('createWithSQLite factory works', () => {
+    const vault = Vault.createWithSQLite(':memory:');
+    vault.add({
+      id: 'test-1',
+      type: 'pattern',
+      domain: 'core',
+      title: 'Test Pattern',
+      severity: 'suggestion',
+      description: 'A test',
+      tags: ['test'],
+    });
+    expect(vault.stats().totalEntries).toBe(1);
+    vault.close();
+  });
+
+  it('getProvider returns the provider', () => {
+    const provider = new SQLitePersistenceProvider(':memory:');
+    provider.run('PRAGMA journal_mode = WAL');
+    provider.run('PRAGMA foreign_keys = ON');
+    const vault = new Vault(provider);
+    expect(vault.getProvider()).toBe(provider);
+    vault.close();
+  });
+
+  it('getDb works with SQLite provider', () => {
+    const vault = new Vault(':memory:');
+    const db = vault.getDb();
+    expect(typeof db.prepare).toBe('function');
+    vault.close();
+  });
+
+  it('all vault operations work through provider', () => {
+    const vault = new Vault(':memory:');
+
+    // seed + get
+    vault.seed([
+      {
+        id: 'e1',
+        type: 'pattern',
+        domain: 'test',
+        title: 'Pattern One',
+        severity: 'suggestion',
+        description: 'First pattern',
+        tags: ['a', 'b'],
+      },
+      {
+        id: 'e2',
+        type: 'anti-pattern',
+        domain: 'test',
+        title: 'Anti Pattern',
+        severity: 'warning',
+        description: 'Avoid this',
+        tags: ['c'],
+      },
+    ]);
+    expect(vault.get('e1')?.title).toBe('Pattern One');
+    expect(vault.stats().totalEntries).toBe(2);
+
+    // search
+    const results = vault.search('pattern');
+    expect(results.length).toBeGreaterThan(0);
+
+    // list
+    const all = vault.list({ domain: 'test' });
+    expect(all).toHaveLength(2);
+
+    // update
+    const updated = vault.update('e1', { title: 'Updated' });
+    expect(updated?.title).toBe('Updated');
+
+    // remove
+    expect(vault.remove('e2')).toBe(true);
+    expect(vault.stats().totalEntries).toBe(1);
+
+    // bulk remove
+    expect(vault.bulkRemove(['e1'])).toBe(1);
+    expect(vault.stats().totalEntries).toBe(0);
+
+    vault.close();
+  });
+});

package/src/__tests__/planner.test.ts

@@ -95,7 +95,7 @@ describe('Planner', () => {
     it('should throw when approving non-draft plan', () => {
       const plan = planner.create({ objective: 'Already approved', scope: 'test' });
       planner.approve(plan.id);
-      expect(() => planner.approve(plan.id)).toThrow('must be');
+      expect(() => planner.approve(plan.id)).toThrow('Invalid transition');
     });
 
     it('should throw for unknown plan', () => {
@@ -113,7 +113,7 @@ describe('Planner', () => {
 
     it('should throw when executing non-approved plan', () => {
       const plan = planner.create({ objective: 'Not approved', scope: 'test' });
-      expect(() => planner.startExecution(plan.id)).toThrow('must be');
+      expect(() => planner.startExecution(plan.id)).toThrow('Invalid transition');
     });
   });
 
@@ -178,17 +178,25 @@ describe('Planner', () => {
   });
 
   describe('complete', () => {
-    it('should transition executing to completed', () => {
+    it('should transition reconciling to completed', () => {
       const plan = planner.create({ objective: 'Complete me', scope: 'test' });
       planner.approve(plan.id);
       planner.startExecution(plan.id);
+      planner.startReconciliation(plan.id);
       const completed = planner.complete(plan.id);
       expect(completed.status).toBe('completed');
     });
 
-    it('should throw when completing non-executing plan', () => {
+    it('should throw when completing from executing (must go through reconciling)', () => {
+      const plan = planner.create({ objective: 'Not reconciling', scope: 'test' });
+      planner.approve(plan.id);
+      planner.startExecution(plan.id);
+      expect(() => planner.complete(plan.id)).toThrow('Invalid transition');
+    });
+
+    it('should throw when completing from draft', () => {
       const plan = planner.create({ objective: 'Not executing', scope: 'test' });
-      expect(() => planner.complete(plan.id)).toThrow('must be');
+      expect(() => planner.complete(plan.id)).toThrow('Invalid transition');
     });
   });
 
@@ -210,7 +218,7 @@ describe('Planner', () => {
   });
 
   describe('getActive', () => {
-    it('should return draft, approved, and executing plans', () => {
+    it('should return brainstorming, draft, approved, executing, validating, and reconciling plans', () => {
       planner.create({ objective: 'Draft', scope: 'a' });
       const p2 = planner.create({ objective: 'Approved', scope: 'b' });
       const p3 = planner.create({ objective: 'Executing', scope: 'c' });
@@ -220,6 +228,7 @@ describe('Planner', () => {
       planner.startExecution(p3.id);
       planner.approve(p4.id);
       planner.startExecution(p4.id);
+      planner.startReconciliation(p4.id);
       planner.complete(p4.id);
       const active = planner.getActive();
       expect(active).toHaveLength(3);
@@ -237,10 +246,22 @@ describe('Planner', () => {
           'Set TTL to 5 minutes since average data freshness requirement is 10 minutes',
         ],
         tasks: [
-          { title: 'Set up Redis client', description: 'Install and configure Redis connection pool' },
-          { title: 'Add cache middleware', description: 'Express middleware for transparent caching' },
-          { title: 'Add invalidation logic', description: 'Purge cache on write operations to ensure consistency' },
-          { title: 'Write integration tests', description: 'Test cache hit/miss scenarios with Redis' },
+          {
+            title: 'Set up Redis client',
+            description: 'Install and configure Redis connection pool',
+          },
+          {
+            title: 'Add cache middleware',
+            description: 'Express middleware for transparent caching',
+          },
+          {
+            title: 'Add invalidation logic',
+            description: 'Purge cache on write operations to ensure consistency',
+          },
+          {
+            title: 'Write integration tests',
+            description: 'Test cache hit/miss scenarios with Redis',
+          },
           { title: 'Add monitoring', description: 'Track and verify cache hit rate metrics' },
         ],
       });
@@ -325,13 +346,17 @@ describe('Planner', () => {
       const plan = planner.create({
         objective: 'Build a comprehensive authentication system for the application',
         scope: 'Backend authentication module',
-        decisions: [
-          'Use JWT tokens because they are stateless and work well with microservices',
-        ],
+        decisions: ['Use JWT tokens because they are stateless and work well with microservices'],
         tasks: [
           { title: 'Create auth middleware', description: 'JWT validation middleware for Express' },
-          { title: 'Add login endpoint', description: 'POST /auth/login with credential validation' },
-          { title: 'Add refresh tokens', description: 'Implement token refresh flow with rotation' },
+          {
+            title: 'Add login endpoint',
+            description: 'POST /auth/login with credential validation',
+          },
+          {
+            title: 'Add refresh tokens',
+            description: 'Implement token refresh flow with rotation',
+          },
           { title: 'Write auth tests', description: 'Integration tests for all auth endpoints' },
         ],
       });
@@ -354,9 +379,7 @@ describe('Planner', () => {
       const plan = planner.create({
         objective: 'Maybe perhaps build something simple and easy, possibly soon, etc',
         scope: 'Various things, probably several modules, somehow',
-        decisions: [
-          'Use some appropriate approach because it seems good due to various reasons',
-        ],
+        decisions: ['Use some appropriate approach because it seems good due to various reasons'],
         tasks: [
           { title: 'Do some stuff', description: 'Maybe implement various things somehow' },
           { title: 'Maybe test', description: 'Perhaps write some tests probably' },
@@ -374,7 +397,10 @@ describe('Planner', () => {
     });
 
     it('should store check in plan history', () => {
-      const plan = planner.create({ objective: 'History test plan objective', scope: 'test scope' });
+      const plan = planner.create({
+        objective: 'History test plan objective',
+        scope: 'test scope',
+      });
       planner.grade(plan.id);
       planner.grade(plan.id);
       const history = planner.getCheckHistory(plan.id);
@@ -383,7 +409,10 @@ describe('Planner', () => {
     });
 
     it('should persist latestCheck', () => {
-      const plan = planner.create({ objective: 'Persist test plan objective', scope: 'test scope' });
+      const plan = planner.create({
+        objective: 'Persist test plan objective',
+        scope: 'test scope',
+      });
       const check = planner.grade(plan.id);
       const latest = planner.getLatestCheck(plan.id);
       expect(latest).not.toBeNull();
@@ -557,7 +586,7 @@ describe('Planner', () => {
   });
 
   describe('full lifecycle', () => {
-    it('should support draft → approved → executing → completed with tasks', () => {
+    it('should support draft → approved → executing → reconciling → completed with tasks', () => {
       const plan = planner.create({
         objective: 'Full lifecycle test',
         scope: 'integration',
@@ -582,11 +611,60 @@ describe('Planner', () => {
       planner.updateTask(plan.id, 'task-2', 'completed');
       planner.updateTask(plan.id, 'task-3', 'skipped');
 
+      planner.startReconciliation(plan.id);
+      expect(planner.get(plan.id)!.status).toBe('reconciling');
+
       const final = planner.complete(plan.id);
       expect(final.status).toBe('completed');
       expect(final.tasks[0].status).toBe('completed');
       expect(final.tasks[1].status).toBe('completed');
       expect(final.tasks[2].status).toBe('skipped');
     });
+
+    it('should support brainstorming → draft → approved → executing lifecycle', () => {
+      const plan = planner.create({
+        objective: 'Brainstorming lifecycle test',
+        scope: 'integration',
+        initialStatus: 'brainstorming',
+      });
+      expect(plan.status).toBe('brainstorming');
+
+      planner.promoteToDraft(plan.id);
+      expect(planner.get(plan.id)!.status).toBe('draft');
+
+      planner.approve(plan.id);
+      expect(planner.get(plan.id)!.status).toBe('approved');
+    });
+
+    it('should support validating state', () => {
+      const plan = planner.create({
+        objective: 'Validation lifecycle test',
+        scope: 'integration',
+        tasks: [{ title: 'Task 1', description: 'Test task' }],
+      });
+      planner.approve(plan.id);
+      planner.startExecution(plan.id);
+      planner.startValidation(plan.id);
+      expect(planner.get(plan.id)!.status).toBe('validating');
+
+      // Can update tasks during validation
+      planner.updateTask(plan.id, 'task-1', 'completed');
+
+      // Can go back to executing from validating
+      planner.startExecution(plan.id);
+      expect(planner.get(plan.id)!.status).toBe('executing');
+    });
+
+    it('should support archiving completed plans', () => {
+      const plan = planner.create({ objective: 'Archive test', scope: 'test' });
+      planner.approve(plan.id);
+      planner.startExecution(plan.id);
+      planner.startReconciliation(plan.id);
+      planner.complete(plan.id);
+
+      const archived = planner.archive();
+      expect(archived).toHaveLength(1);
+      expect(archived[0].status).toBe('archived');
+    });
   });
 });