@soleri/core 9.14.4 → 9.16.7

package/src/planning/plan-lifecycle.test.ts

@@ -68,9 +68,11 @@ describe('plan-lifecycle', () => {
 
   describe('applyTransition', () => {
     it('returns new status and timestamp for valid transition', () => {
+      const before = Date.now();
       const result = applyTransition('draft', 'approved');
       expect(result.status).toBe('approved');
-      expect(result.updatedAt).toBeGreaterThan(0);
+      expect(result.updatedAt).toBeGreaterThanOrEqual(before);
+      expect(result.updatedAt).toBeLessThanOrEqual(Date.now());
     });
     it('throws for invalid transition', () => {
       expect(() => applyTransition('draft', 'executing')).toThrow('Invalid transition');
@@ -312,9 +314,11 @@ describe('plan-lifecycle', () => {
     });
 
     it('sets startedAt on first in_progress', () => {
+      const before = Date.now();
       const task = makeTask();
       applyTaskStatusUpdate(task, 'in_progress');
-      expect(task.startedAt).toBeGreaterThan(0);
+      expect(task.startedAt).toBeGreaterThanOrEqual(before);
+      expect(task.startedAt).toBeLessThanOrEqual(Date.now());
       expect(task.status).toBe('in_progress');
     });
     it('does not overwrite startedAt on repeated in_progress', () => {
@@ -324,22 +328,26 @@ describe('plan-lifecycle', () => {
       expect(task.startedAt).toBe(1000);
     });
     it('sets completedAt and durationMs on completed', () => {
+      const before = Date.now();
       const task = makeTask();
-      task.startedAt = Date.now() - 500;
+      task.startedAt = before - 500;
       applyTaskStatusUpdate(task, 'completed');
-      expect(task.completedAt).toBeGreaterThan(0);
-      expect(task.metrics?.durationMs).toBeGreaterThanOrEqual(0);
+      expect(task.completedAt).toBeGreaterThanOrEqual(before);
+      expect(task.completedAt).toBeLessThanOrEqual(Date.now());
+      expect(task.metrics?.durationMs).toBeGreaterThanOrEqual(500);
     });
     it('sets completedAt on skipped', () => {
+      const before = Date.now();
       const task = makeTask();
       applyTaskStatusUpdate(task, 'skipped');
-      expect(task.completedAt).toBeGreaterThan(0);
+      expect(task.completedAt).toBeGreaterThanOrEqual(before);
       expect(task.status).toBe('skipped');
     });
     it('sets completedAt on failed', () => {
+      const before = Date.now();
       const task = makeTask();
       applyTaskStatusUpdate(task, 'failed');
-      expect(task.completedAt).toBeGreaterThan(0);
+      expect(task.completedAt).toBeGreaterThanOrEqual(before);
       expect(task.status).toBe('failed');
     });
 

package/src/planning/planner-types.ts

@@ -193,6 +193,8 @@ export interface Plan {
     genericId?: string;
     domainId?: string;
   };
+  /** Active playbook executor session ID — used to enforce gates during task updates and plan completion. */
+  playbookSessionId?: string;
   /** Source GitHub issue this plan was created from (e.g., #NNN in prompt). */
   githubIssue?: { owner: string; repo: string; number: number };
   /** GitHub issue projection — populated by orchestrate_project_to_github. */

package/src/planning/planner.test.ts

@@ -74,6 +74,26 @@ describe('Planner', () => {
       const planner2 = new Planner(join(tempDir, 'plans.json'));
       expect(planner2.list()).toHaveLength(1);
     });
+
+    it('should make newly created plans visible to other planner instances', () => {
+      const planner2 = new Planner(join(tempDir, 'plans.json'));
+      const plan = planner.create({ objective: 'Shared plan', scope: 'sync' });
+
+      expect(planner2.get(plan.id)?.objective).toBe('Shared plan');
+    });
+
+    it('should merge plans created by multiple planner instances', () => {
+      const planner2 = new Planner(join(tempDir, 'plans.json'));
+      const planA = planner.create({ objective: 'Plan A', scope: 'sync-a' });
+      const planB = planner2.create({ objective: 'Plan B', scope: 'sync-b' });
+
+      const reloaded = new Planner(join(tempDir, 'plans.json'));
+      const ids = reloaded.list().map((plan) => plan.id);
+
+      expect(ids).toContain(planA.id);
+      expect(ids).toContain(planB.id);
+      expect(ids).toHaveLength(2);
+    });
   });
 
   describe('get', () => {
@@ -120,26 +140,36 @@ describe('Planner', () => {
 
     it('should approve a plan with A+ grade', () => {
       const plan = planner.create({
-        objective: 'Well-graded plan',
-        scope: 'test',
+        objective: 'Implement a Redis caching layer for the API to reduce DB load by 50%',
+        scope: 'Backend API services only. Does not include frontend caching or CDN.',
         tasks: [
-          { title: 'Task 1', description: 'A well-described task for implementation' },
-          { title: 'Task 2', description: 'Another well-described task for testing' },
+          {
+            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' },
         ],
-        decisions: ['Use TypeScript for type safety'],
-      });
-      // Grade the plan — set an A+ grade check
-      const p = planner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test-aplus',
-        planId: plan.id,
-        grade: 'A+',
-        score: 98,
-        gaps: [],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+        decisions: [
+          'Use Redis because it provides sub-millisecond latency and supports TTL natively',
+          'Set TTL to 5 minutes since average data freshness requirement is 10 minutes',
+        ],
+        alternatives: TWO_ALTERNATIVES,
+      });
+      const check = planner.grade(plan.id);
+      expect(check.score).toBeGreaterThanOrEqual(95);
+      expect(check.grade).toMatch(/^A/);
       const approved = planner.approve(plan.id);
       expect(approved.status).toBe('approved');
     });
@@ -149,27 +179,8 @@ describe('Planner', () => {
         objective: 'Bad plan',
         scope: 'test',
       });
-      // Manually set a B grade check on the plan
-      const p = planner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test',
-        planId: plan.id,
-        grade: 'B',
-        score: 82,
-        gaps: [
-          {
-            id: 'gap-1',
-            severity: 'major',
-            category: 'completeness',
-            description: 'Missing tasks',
-            recommendation: 'Add tasks',
-            location: 'tasks',
-          },
-        ],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+      const check = planner.grade(plan.id);
+      expect(check.score).toBeLessThan(90);
       expect(() => planner.approve(plan.id)).toThrow(PlanGradeRejectionError);
     });
 
@@ -184,68 +195,52 @@ describe('Planner', () => {
       const lenientPlanner = new Planner(join(tempDir, 'lenient-plans.json'), {
         minGradeForApproval: 'B',
       });
-      const plan = lenientPlanner.create({ objective: 'B-grade plan', scope: 'test' });
-      // Set a B grade check
-      const p = lenientPlanner.get(plan.id)!;
-      p.latestCheck = {
-        checkId: 'chk-test-b',
-        planId: plan.id,
-        grade: 'B',
-        score: 82,
-        gaps: [],
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
-      // B grade should pass with B threshold
+      const plan = lenientPlanner.create({
+        objective: 'B-grade plan with enough detail',
+        scope: 'Test scope with clear boundary',
+        decisions: ['Use TypeScript for compile-time safety'],
+        tasks: [
+          { title: 'Task 1', description: 'Implement the first part of the change' },
+          { title: 'Task 2', description: 'Validate the second part of the change' },
+        ],
+      });
+      const check = lenientPlanner.grade(plan.id);
+      expect(check.grade).toBe('B');
       const approved = lenientPlanner.approve(plan.id);
       expect(approved.status).toBe('approved');
     });
 
     it('should reject with PlanGradeRejectionError containing gap details', () => {
-      const plan = planner.create({ objective: 'Gap details', scope: 'test' });
-      const p = planner.get(plan.id)!;
-      const testGaps = [
-        {
-          id: 'gap-crit',
-          severity: 'critical' as const,
-          category: 'structure',
-          description: 'Missing critical structure',
-          recommendation: 'Fix structure',
-          location: 'tasks',
-        },
-        {
-          id: 'gap-maj',
-          severity: 'major' as const,
-          category: 'completeness',
-          description: 'Incomplete scope',
-          recommendation: 'Add scope details',
-          location: 'scope',
-        },
-      ];
-      p.latestCheck = {
-        checkId: 'chk-test-gaps',
-        planId: plan.id,
-        grade: 'C',
-        score: 65,
-        gaps: testGaps,
-        iteration: 1,
-        checkedAt: Date.now(),
-      };
-      p.checks = [p.latestCheck];
+      const plan = planner.create({ objective: '', scope: '' });
+      const check = planner.grade(plan.id);
       try {
         planner.approve(plan.id);
         expect.unreachable('Should have thrown');
       } catch (err) {
         expect(err).toBeInstanceOf(PlanGradeRejectionError);
         const rejection = err as PlanGradeRejectionError;
-        expect(rejection.grade).toBe('C');
-        expect(rejection.score).toBe(65);
+        expect(rejection.grade).toBe(check.grade);
+        expect(rejection.score).toBe(check.score);
         expect(rejection.minGrade).toBe('A');
-        expect(rejection.gaps).toHaveLength(2);
+        expect(rejection.gaps).toEqual(check.gaps);
         expect(rejection.message).toContain('below the minimum required grade A');
       }
     });
+
+    it('should respect grading performed by another planner instance', () => {
+      const strictPlanner = new Planner(join(tempDir, 'shared-plans.json'), {
+        minGradeForApproval: 'A',
+      });
+      const gradingPlanner = new Planner(join(tempDir, 'shared-plans.json'), {
+        minGradeForApproval: 'A',
+      });
+      const plan = strictPlanner.create({ objective: '', scope: '' });
+
+      const check = gradingPlanner.grade(plan.id);
+
+      expect(check.grade).toBe('F');
+      expect(() => strictPlanner.approve(plan.id)).toThrow(PlanGradeRejectionError);
+    });
   });
 
   describe('startExecution', () => {
@@ -592,10 +587,11 @@ describe('Planner', () => {
           { title: 'Task C', description: 'Third task (not in cycle)' },
         ],
       });
-      // Manually create circular deps
-      const p = planner.get(plan.id)!;
-      p.tasks[0].dependsOn = ['task-2'];
-      p.tasks[1].dependsOn = ['task-1'];
+      planner.splitTasks(plan.id, [
+        { title: 'Task A', description: 'First task in the cycle', dependsOn: ['task-2'] },
+        { title: 'Task B', description: 'Second task in the cycle', dependsOn: ['task-1'] },
+        { title: 'Task C', description: 'Third task (not in cycle)' },
+      ]);
       const check = planner.grade(plan.id);
       const circGap = check.gaps.find((g) => g.description.includes('Circular'));
       expect(circGap).toBeDefined();

package/src/planning/planner.ts

@@ -77,8 +77,38 @@ export class Planner {
     }
   }
 
-  private save(): void {
+  private refresh(): void {
+    this.store = this.load();
+  }
+
+  private mergeLatestStore(deletedPlanIds: string[] = []): void {
+    const deleted = new Set(deletedPlanIds);
+    const latest = this.load();
+    const merged = new Map<string, Plan>();
+
+    for (const plan of latest.plans) {
+      if (!deleted.has(plan.id)) {
+        merged.set(plan.id, plan);
+      }
+    }
+
+    for (const plan of this.store.plans) {
+      if (deleted.has(plan.id)) continue;
+      const existing = merged.get(plan.id);
+      if (!existing || plan.updatedAt >= existing.updatedAt) {
+        merged.set(plan.id, plan);
+      }
+    }
+
+    this.store = {
+      version: latest.version ?? this.store.version ?? '1.0',
+      plans: [...merged.values()],
+    };
+  }
+
+  private save(deletedPlanIds: string[] = []): void {
     mkdirSync(dirname(this.filePath), { recursive: true });
+    this.mergeLatestStore(deletedPlanIds);
     writeFileSync(this.filePath, JSON.stringify(this.store, null, 2), 'utf-8');
   }
 
@@ -88,8 +118,13 @@ export class Planner {
     plan.updatedAt = r.updatedAt;
   }
 
+  private findPlan(planId: string): Plan | null {
+    return this.store.plans.find((p) => p.id === planId) ?? null;
+  }
+
   private requirePlan(planId: string): Plan {
-    const plan = this.get(planId);
+    this.refresh();
+    const plan = this.findPlan(planId);
     if (!plan) throw new Error(`Plan not found: ${planId}`);
     return plan;
   }
@@ -101,6 +136,7 @@ export class Planner {
   }
 
   create(params: Parameters<typeof createPlanObject>[0]): Plan {
+    this.refresh();
     const plan = createPlanObject(params);
     this.store.plans.push(plan);
     this.save();
@@ -108,18 +144,21 @@ export class Planner {
   }
 
   get(planId: string): Plan | null {
-    return this.store.plans.find((p) => p.id === planId) ?? null;
+    this.refresh();
+    return this.findPlan(planId);
   }
 
   list(): Plan[] {
+    this.refresh();
     return [...this.store.plans];
   }
 
   remove(planId: string): boolean {
+    this.refresh();
     const idx = this.store.plans.findIndex((p) => p.id === planId);
     if (idx < 0) return false;
     this.store.plans.splice(idx, 1);
-    this.save();
+    this.save([planId]);
     return true;
   }
 
@@ -146,6 +185,14 @@ export class Planner {
     return plan;
   }
 
+  patchPlan(planId: string, fields: Partial<Plan>): Plan {
+    const plan = this.requirePlan(planId);
+    Object.assign(plan, fields);
+    plan.updatedAt = Date.now();
+    this.save();
+    return plan;
+  }
+
   startExecution(planId: string): Plan {
     const plan = this.requirePlan(planId);
     this.transition(plan, 'executing');
@@ -220,10 +267,12 @@ export class Planner {
   }
 
   getExecuting(): Plan[] {
+    this.refresh();
     return this.store.plans.filter((p) => p.status === 'executing' || p.status === 'validating');
   }
 
   getActive(): Plan[] {
+    this.refresh();
     return this.store.plans.filter(
       (p) =>
         p.status === 'brainstorming' ||
@@ -435,6 +484,7 @@ export class Planner {
   }
 
   archive(olderThanDays?: number): Plan[] {
+    this.refresh();
     const cutoff =
       olderThanDays !== undefined
         ? Date.now() - olderThanDays * 24 * 60 * 60 * 1000
@@ -460,6 +510,7 @@ export class Planner {
     closedIds: string[];
     closedPlans: Array<{ id: string; previousStatus: string; reason: string }>;
   } {
+    this.refresh();
     const now = Date.now();
     const forceAll = olderThanMs === 0;
     const defaultTtl = forceAll ? 0 : 30 * 60 * 1000; // 30 minutes for draft/approved
@@ -522,6 +573,7 @@ export class Planner {
     totalTasks: number;
     tasksByStatus: Record<TaskStatus, number>;
   } {
+    this.refresh();
     const plans = this.store.plans;
     const byStatus = {
       brainstorming: 0,

package/src/planning/reconciliation-engine.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest';
 import {
-  DRIFT_WEIGHTS,
   calculateDriftScore,
   computeExecutionSummary,
   buildReconciliationReport,
@@ -9,14 +8,6 @@ import {
 import type { DriftItem, PlanTask } from './planner-types.js';
 
 describe('reconciliation-engine', () => {
-  describe('DRIFT_WEIGHTS', () => {
-    it('has correct weights', () => {
-      expect(DRIFT_WEIGHTS.high).toBe(20);
-      expect(DRIFT_WEIGHTS.medium).toBe(10);
-      expect(DRIFT_WEIGHTS.low).toBe(5);
-    });
-  });
-
   describe('calculateDriftScore', () => {
     it('returns 100 for no drift items', () => {
       expect(calculateDriftScore([])).toBe(100);
@@ -92,6 +83,7 @@ describe('reconciliation-engine', () => {
 
   describe('buildReconciliationReport', () => {
     it('builds a report with accuracy score', () => {
+      const before = Date.now();
       const report = buildReconciliationReport('plan-1', {
         actualOutcome: 'Done',
         driftItems: [{ type: 'skipped', description: 'x', impact: 'low', rationale: 'r' }],
@@ -100,7 +92,8 @@ describe('reconciliation-engine', () => {
       expect(report.accuracy).toBe(95);
       expect(report.driftItems).toHaveLength(1);
       expect(report.summary).toBe('Done');
-      expect(report.reconciledAt).toBeGreaterThan(0);
+      expect(report.reconciledAt).toBeGreaterThanOrEqual(before);
+      expect(report.reconciledAt).toBeLessThanOrEqual(Date.now());
     });
     it('defaults to empty drift items', () => {
       const report = buildReconciliationReport('plan-2', { actualOutcome: 'OK' });

package/src/planning/task-complexity-assessor.test.ts

@@ -294,9 +294,4 @@ describe('assessTaskComplexity — reasoning', () => {
     const result = assess({ prompt: 'fix typo' });
     expect(result.reasoning).toContain('No complexity signals detected');
   });
-
-  it('always returns 6 signals', () => {
-    const result = assess({ prompt: 'anything' });
-    expect(result.signals).toHaveLength(6);
-  });
 });

package/src/planning/task-verifier.test.ts

@@ -25,6 +25,7 @@ describe('task-verifier', () => {
       const existing: TaskEvidence[] = [
         { criterion: 'cr1', content: 'result', type: 'description', submittedAt: 100 },
       ];
+      const before = Date.now();
       const result = createEvidence(existing, {
         criterion: 'cr2',
         content: 'output',
@@ -32,7 +33,8 @@ describe('task-verifier', () => {
       });
       expect(result).toHaveLength(2);
       expect(result[1].criterion).toBe('cr2');
-      expect(result[1].submittedAt).toBeGreaterThan(0);
+      expect(result[1].submittedAt).toBeGreaterThanOrEqual(before);
+      expect(result[1].submittedAt).toBeLessThanOrEqual(Date.now());
     });
     it('does not mutate original array', () => {
       const existing: TaskEvidence[] = [];

package/src/playbooks/generic/generic-playbooks.test.ts

@@ -181,10 +181,6 @@ describe('All generic playbooks', () => {
 // ─── Individual playbook tests ────────────────────────────────────
 
 describe('brainstormingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(brainstormingPlaybook.id).toBe('generic-brainstorming');
-  });
-
   it('should match BUILD and PLAN intents', () => {
     expect(brainstormingPlaybook.matchIntents).toContain('BUILD');
     expect(brainstormingPlaybook.matchIntents).toContain('PLAN');
@@ -221,10 +217,6 @@ describe('brainstormingPlaybook', () => {
 });
 
 describe('codeReviewPlaybook', () => {
-  it('should have correct id', () => {
-    expect(codeReviewPlaybook.id).toBe('generic-code-review');
-  });
-
   it('should match REVIEW intent only', () => {
     expect(codeReviewPlaybook.matchIntents).toEqual(['REVIEW']);
   });
@@ -260,10 +252,6 @@ describe('codeReviewPlaybook', () => {
 });
 
 describe('onboardingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(onboardingPlaybook.id).toBe('generic-onboarding');
-  });
-
   it('should match PLAN intent', () => {
     expect(onboardingPlaybook.matchIntents).toContain('PLAN');
   });
@@ -288,10 +276,6 @@ describe('onboardingPlaybook', () => {
 });
 
 describe('subagentExecutionPlaybook', () => {
-  it('should have correct id', () => {
-    expect(subagentExecutionPlaybook.id).toBe('generic-subagent-execution');
-  });
-
   it('should match BUILD and IMPROVE intents', () => {
     expect(subagentExecutionPlaybook.matchIntents).toContain('BUILD');
     expect(subagentExecutionPlaybook.matchIntents).toContain('IMPROVE');
@@ -314,10 +298,6 @@ describe('subagentExecutionPlaybook', () => {
 });
 
 describe('systematicDebuggingPlaybook', () => {
-  it('should have correct id', () => {
-    expect(systematicDebuggingPlaybook.id).toBe('generic-systematic-debugging');
-  });
-
   it('should match FIX intent only', () => {
     expect(systematicDebuggingPlaybook.matchIntents).toEqual(['FIX']);
   });
@@ -361,10 +341,6 @@ describe('systematicDebuggingPlaybook', () => {
 });
 
 describe('tddPlaybook', () => {
-  it('should have correct id', () => {
-    expect(tddPlaybook.id).toBe('generic-tdd');
-  });
-
   it('should match BUILD and FIX intents', () => {
     expect(tddPlaybook.matchIntents).toContain('BUILD');
     expect(tddPlaybook.matchIntents).toContain('FIX');
@@ -399,10 +375,6 @@ describe('tddPlaybook', () => {
 });
 
 describe('verificationPlaybook', () => {
-  it('should have correct id', () => {
-    expect(verificationPlaybook.id).toBe('generic-verification');
-  });
-
   it('should match BUILD, FIX, IMPROVE, and DELIVER intents', () => {
     expect(verificationPlaybook.matchIntents).toContain('BUILD');
     expect(verificationPlaybook.matchIntents).toContain('FIX');

package/src/playbooks/index.test.ts

@@ -9,61 +9,6 @@ import { describe, it, expect } from 'vitest';
 import * as playbooksModule from './index.js';
 
 describe('playbooks barrel export', () => {
-  it('should export getBuiltinPlaybook function', () => {
-    expect(typeof playbooksModule.getBuiltinPlaybook).toBe('function');
-  });
-
-  it('should export getAllBuiltinPlaybooks function', () => {
-    expect(typeof playbooksModule.getAllBuiltinPlaybooks).toBe('function');
-  });
-
-  it('should export scorePlaybook function', () => {
-    expect(typeof playbooksModule.scorePlaybook).toBe('function');
-  });
-
-  it('should export mergePlaybooks function', () => {
-    expect(typeof playbooksModule.mergePlaybooks).toBe('function');
-  });
-
-  it('should export matchPlaybooks function', () => {
-    expect(typeof playbooksModule.matchPlaybooks).toBe('function');
-  });
-
-  it('should export playbookDefinitionToEntry function', () => {
-    expect(typeof playbooksModule.playbookDefinitionToEntry).toBe('function');
-  });
-
-  it('should export entryToPlaybookDefinition function', () => {
-    expect(typeof playbooksModule.entryToPlaybookDefinition).toBe('function');
-  });
-
-  it('should export seedDefaultPlaybooks function', () => {
-    expect(typeof playbooksModule.seedDefaultPlaybooks).toBe('function');
-  });
-
-  it('should export PlaybookExecutor class', () => {
-    expect(typeof playbooksModule.PlaybookExecutor).toBe('function');
-    const executor = new playbooksModule.PlaybookExecutor();
-    expect(executor).toBeInstanceOf(playbooksModule.PlaybookExecutor);
-  });
-
-  it('should not export unexpected runtime values', () => {
-    const expectedExports = [
-      'getBuiltinPlaybook',
-      'getAllBuiltinPlaybooks',
-      'scorePlaybook',
-      'mergePlaybooks',
-      'matchPlaybooks',
-      'playbookDefinitionToEntry',
-      'entryToPlaybookDefinition',
-      'seedDefaultPlaybooks',
-      'PlaybookExecutor',
-    ];
-
-    const actualExports = Object.keys(playbooksModule);
-    expect(actualExports.sort()).toEqual(expectedExports.sort());
-  });
-
   it('should return playbooks from getAllBuiltinPlaybooks via barrel', () => {
     const playbooks = playbooksModule.getAllBuiltinPlaybooks();
     expect(playbooks.length).toBeGreaterThanOrEqual(6);