@soleri/core 9.2.0 → 9.3.1

package/src/planning/planner.ts

@@ -11,19 +11,40 @@ export * from './reconciliation-engine.js';
 export * from './task-verifier.js';
 export * from './planner-types.js';
 import type {
-  TaskStatus, PlanTask, Plan, PlanStore, PlanCheck, PlannerOptions,
+  TaskStatus,
+  PlanTask,
+  Plan,
+  PlanStore,
+  PlanCheck,
+  PlannerOptions,
 } from './planner-types.js';
 import {
-  applyTransition, scoreToGrade, gradeToMinScore, PlanGradeRejectionError,
-  hasCircularDependencies, applyIteration, applySplitTasks, calculateScore,
-  applyTaskStatusUpdate, createPlanObject,
+  applyTransition,
+  scoreToGrade,
+  gradeToMinScore,
+  PlanGradeRejectionError,
+  hasCircularDependencies,
+  applyIteration,
+  applySplitTasks,
+  calculateScore,
+  applyTaskStatusUpdate,
+  createPlanObject,
 } from './plan-lifecycle.js';
 import type { PlanStatus, PlanGrade, IterateChanges } from './plan-lifecycle.js';
-import { buildReconciliationReport, buildAutoReconcileInput, computeExecutionSummary } from './reconciliation-engine.js';
+import {
+  buildReconciliationReport,
+  buildAutoReconcileInput,
+  computeExecutionSummary,
+} from './reconciliation-engine.js';
 import type { ReconcileInput } from './reconciliation-engine.js';
 import {
-  createEvidence, verifyTaskLogic, verifyPlanLogic, verifyDeliverablesLogic,
-  createDeliverable, buildSpecReviewPrompt, buildQualityReviewPrompt,
+  createEvidence,
+  verifyTaskLogic,
+  verifyPlanLogic,
+  verifyDeliverablesLogic,
+  createDeliverable,
+  buildSpecReviewPrompt,
+  buildQualityReviewPrompt,
 } from './task-verifier.js';
 
 export class Planner {
@@ -51,7 +72,9 @@ export class Planner {
       const store = JSON.parse(data) as PlanStore;
       for (const plan of store.plans) plan.checks = plan.checks ?? [];
       return store;
-    } catch { return { version: '1.0', plans: [] }; }
+    } catch {
+      return { version: '1.0', plans: [] };
+    }
   }
 
   private save(): void {
@@ -88,7 +111,9 @@ export class Planner {
     return this.store.plans.find((p) => p.id === planId) ?? null;
   }
 
-  list(): Plan[] { return [...this.store.plans]; }
+  list(): Plan[] {
+    return [...this.store.plans];
+  }
 
   remove(planId: string): boolean {
     const idx = this.store.plans.findIndex((p) => p.id === planId);
@@ -109,7 +134,12 @@ export class Planner {
     const plan = this.requirePlan(planId);
     const check = plan.latestCheck;
     if (check && check.score < gradeToMinScore(this.minGradeForApproval)) {
-      throw new PlanGradeRejectionError(check.grade, check.score, this.minGradeForApproval, check.gaps);
+      throw new PlanGradeRejectionError(
+        check.grade,
+        check.score,
+        this.minGradeForApproval,
+        check.gaps,
+      );
     }
     this.transition(plan, 'approved');
     this.save();
@@ -140,7 +170,9 @@ export class Planner {
   updateTask(planId: string, taskId: string, status: TaskStatus): Plan {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'executing' && plan.status !== 'validating')
-      throw new Error(`Cannot update tasks on plan in '${plan.status}' status — must be 'executing' or 'validating'`);
+      throw new Error(
+        `Cannot update tasks on plan in '${plan.status}' status — must be 'executing' or 'validating'`,
+      );
     applyTaskStatusUpdate(this.requireTask(plan, taskId), status);
     plan.updatedAt = Date.now();
     this.save();
@@ -149,8 +181,14 @@ export class Planner {
 
   reconcile(planId: string, report: ReconcileInput): Plan {
     const plan = this.requirePlan(planId);
-    if (plan.status !== 'executing' && plan.status !== 'validating' && plan.status !== 'reconciling')
-      throw new Error(`Cannot reconcile plan in '${plan.status}' status — must be 'executing', 'validating', or 'reconciling'`);
+    if (
+      plan.status !== 'executing' &&
+      plan.status !== 'validating' &&
+      plan.status !== 'reconciling'
+    )
+      throw new Error(
+        `Cannot reconcile plan in '${plan.status}' status — must be 'executing', 'validating', or 'reconciling'`,
+      );
     plan.reconciliation = buildReconciliationReport(planId, report);
     plan.executionSummary = computeExecutionSummary(plan.tasks);
     if (plan.status === 'executing' || plan.status === 'validating') plan.status = 'reconciling';
@@ -173,7 +211,9 @@ export class Planner {
   autoReconcile(planId: string): Plan | null {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'executing' && plan.status !== 'validating')
-      throw new Error(`Cannot auto-reconcile plan in '${plan.status}' status — must be 'executing' or 'validating'`);
+      throw new Error(
+        `Cannot auto-reconcile plan in '${plan.status}' status — must be 'executing' or 'validating'`,
+      );
     const result = buildAutoReconcileInput(plan.tasks);
     if (!result.canAutoReconcile || !result.input) return null;
     return this.reconcile(planId, result.input);
@@ -184,51 +224,81 @@ export class Planner {
   }
 
   getActive(): Plan[] {
-    return this.store.plans.filter((p) =>
-      p.status === 'brainstorming' || p.status === 'draft' || p.status === 'approved' ||
-      p.status === 'executing' || p.status === 'validating' || p.status === 'reconciling');
+    return this.store.plans.filter(
+      (p) =>
+        p.status === 'brainstorming' ||
+        p.status === 'draft' ||
+        p.status === 'approved' ||
+        p.status === 'executing' ||
+        p.status === 'validating' ||
+        p.status === 'reconciling',
+    );
   }
 
   iterate(planId: string, changes: IterateChanges): Plan {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'draft' && plan.status !== 'brainstorming')
-      throw new Error(`Cannot iterate plan in '${plan.status}' status — must be 'draft' or 'brainstorming'`);
+      throw new Error(
+        `Cannot iterate plan in '${plan.status}' status — must be 'draft' or 'brainstorming'`,
+      );
     applyIteration(plan, changes);
     this.save();
     return plan;
   }
 
-  splitTasks(planId: string, tasks: Array<{
-    title: string; description: string; dependsOn?: string[]; acceptanceCriteria?: string[];
-  }>): Plan {
+  splitTasks(
+    planId: string,
+    tasks: Array<{
+      title: string;
+      description: string;
+      dependsOn?: string[];
+      acceptanceCriteria?: string[];
+    }>,
+  ): Plan {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'brainstorming' && plan.status !== 'draft' && plan.status !== 'approved')
-      throw new Error(`Cannot split tasks on plan in '${plan.status}' status — must be 'brainstorming', 'draft', or 'approved'`);
+      throw new Error(
+        `Cannot split tasks on plan in '${plan.status}' status — must be 'brainstorming', 'draft', or 'approved'`,
+      );
     applySplitTasks(plan, tasks);
     this.save();
     return plan;
   }
 
-  addReview(planId: string, review: {
-    taskId?: string; reviewer: string;
-    outcome: 'approved' | 'rejected' | 'needs_changes'; comments: string;
-  }): Plan {
+  addReview(
+    planId: string,
+    review: {
+      taskId?: string;
+      reviewer: string;
+      outcome: 'approved' | 'rejected' | 'needs_changes';
+      comments: string;
+    },
+  ): Plan {
     const plan = this.requirePlan(planId);
     if (review.taskId) this.requireTask(plan, review.taskId);
     if (!plan.reviews) plan.reviews = [];
     plan.reviews.push({
-      planId, taskId: review.taskId, reviewer: review.reviewer,
-      outcome: review.outcome, comments: review.comments, reviewedAt: Date.now(),
+      planId,
+      taskId: review.taskId,
+      reviewer: review.reviewer,
+      outcome: review.outcome,
+      comments: review.comments,
+      reviewedAt: Date.now(),
     });
     plan.updatedAt = Date.now();
     this.save();
     return plan;
   }
 
-  setGitHubProjection(planId: string, projection: {
-    repo: string; milestone?: number;
-    issues: Array<{ taskId: string; issueNumber: number }>; projectedAt: number;
-  }): Plan {
+  setGitHubProjection(
+    planId: string,
+    projection: {
+      repo: string;
+      milestone?: number;
+      issues: Array<{ taskId: string; issueNumber: number }>;
+      projectedAt: number;
+    },
+  ): Plan {
     const plan = this.requirePlan(planId);
     plan.githubProjection = projection;
     plan.updatedAt = Date.now();
@@ -236,8 +306,13 @@ export class Planner {
     return plan;
   }
 
-  getDispatch(planId: string, taskId: string): {
-    task: PlanTask; unmetDependencies: PlanTask[]; ready: boolean;
+  getDispatch(
+    planId: string,
+    taskId: string,
+  ): {
+    task: PlanTask;
+    unmetDependencies: PlanTask[];
+    ready: boolean;
     deliverableStatus?: { count: number; staleCount: number };
   } {
     const plan = this.requirePlan(planId);
@@ -248,14 +323,21 @@ export class Planner {
       if (dep && dep.status !== 'completed') unmetDeps.push(dep);
     }
     return {
-      task, unmetDependencies: unmetDeps, ready: unmetDeps.length === 0,
+      task,
+      unmetDependencies: unmetDeps,
+      ready: unmetDeps.length === 0,
       ...(task.deliverables?.length && {
-        deliverableStatus: { count: task.deliverables.length, staleCount: task.deliverables.filter((d) => d.stale).length },
+        deliverableStatus: {
+          count: task.deliverables.length,
+          staleCount: task.deliverables.filter((d) => d.stale).length,
+        },
       }),
     };
   }
 
-  submitDeliverable(planId: string, taskId: string,
+  submitDeliverable(
+    planId: string,
+    taskId: string,
     deliverable: { type: 'file' | 'vault_entry' | 'url'; path: string; hash?: string },
   ): PlanTask {
     const plan = this.requirePlan(planId);
@@ -268,9 +350,15 @@ export class Planner {
     return task;
   }
 
-  verifyDeliverables(planId: string, taskId: string,
+  verifyDeliverables(
+    planId: string,
+    taskId: string,
     vault?: { get(id: string): unknown | null },
-  ): { verified: boolean; deliverables: import('./planner-types.js').TaskDeliverable[]; staleCount: number } {
+  ): {
+    verified: boolean;
+    deliverables: import('./planner-types.js').TaskDeliverable[];
+    staleCount: number;
+  } {
     const plan = this.requirePlan(planId);
     const task = this.requireTask(plan, taskId);
     const result = verifyDeliverablesLogic(task.deliverables ?? [], vault);
@@ -280,8 +368,14 @@ export class Planner {
     return result;
   }
 
-  submitEvidence(planId: string, taskId: string,
-    evidence: { criterion: string; content: string; type: import('./planner-types.js').TaskEvidence['type'] },
+  submitEvidence(
+    planId: string,
+    taskId: string,
+    evidence: {
+      criterion: string;
+      content: string;
+      type: import('./planner-types.js').TaskEvidence['type'];
+    },
   ): PlanTask {
     const plan = this.requirePlan(planId);
     const task = this.requireTask(plan, taskId);
@@ -292,8 +386,13 @@ export class Planner {
     return task;
   }
 
-  verifyTask(planId: string, taskId: string): {
-    verified: boolean; task: PlanTask; missingCriteria: string[];
+  verifyTask(
+    planId: string,
+    taskId: string,
+  ): {
+    verified: boolean;
+    task: PlanTask;
+    missingCriteria: string[];
     reviewStatus: 'approved' | 'rejected' | 'needs_changes' | 'no_reviews';
   } {
     const plan = this.requirePlan(planId);
@@ -312,35 +411,65 @@ export class Planner {
     return verifyPlanLogic(planId, this.requirePlan(planId).tasks);
   }
 
-  generateReviewSpec(planId: string, taskId: string): { prompt: string; task: PlanTask; plan: Plan } {
+  generateReviewSpec(
+    planId: string,
+    taskId: string,
+  ): { prompt: string; task: PlanTask; plan: Plan } {
     const plan = this.requirePlan(planId);
     const task = this.requireTask(plan, taskId);
     return { prompt: buildSpecReviewPrompt(task, plan.objective), task, plan };
   }
 
-  generateReviewQuality(planId: string, taskId: string): { prompt: string; task: PlanTask; plan: Plan } {
+  generateReviewQuality(
+    planId: string,
+    taskId: string,
+  ): { prompt: string; task: PlanTask; plan: Plan } {
     const plan = this.requirePlan(planId);
     const task = this.requireTask(plan, taskId);
     return { prompt: buildQualityReviewPrompt(task), task, plan };
   }
 
   archive(olderThanDays?: number): Plan[] {
-    const cutoff = olderThanDays !== undefined
-      ? Date.now() - olderThanDays * 24 * 60 * 60 * 1000 : Date.now() + 1;
-    const toArchive = this.store.plans.filter((p) => p.status === 'completed' && p.updatedAt < cutoff);
-    for (const plan of toArchive) { plan.status = 'archived'; plan.updatedAt = Date.now(); }
+    const cutoff =
+      olderThanDays !== undefined
+        ? Date.now() - olderThanDays * 24 * 60 * 60 * 1000
+        : Date.now() + 1;
+    const toArchive = this.store.plans.filter(
+      (p) => p.status === 'completed' && p.updatedAt < cutoff,
+    );
+    for (const plan of toArchive) {
+      plan.status = 'archived';
+      plan.updatedAt = Date.now();
+    }
     if (toArchive.length > 0) this.save();
     return toArchive;
   }
 
   stats(): {
-    total: number; byStatus: Record<PlanStatus, number>;
-    avgTasksPerPlan: number; totalTasks: number; tasksByStatus: Record<TaskStatus, number>;
+    total: number;
+    byStatus: Record<PlanStatus, number>;
+    avgTasksPerPlan: number;
+    totalTasks: number;
+    tasksByStatus: Record<TaskStatus, number>;
   } {
     const plans = this.store.plans;
-    const byStatus = { brainstorming: 0, draft: 0, approved: 0, executing: 0,
-      validating: 0, reconciling: 0, completed: 0, archived: 0 } as Record<PlanStatus, number>;
-    const tasksByStatus = { pending: 0, in_progress: 0, completed: 0, skipped: 0, failed: 0 } as Record<TaskStatus, number>;
+    const byStatus = {
+      brainstorming: 0,
+      draft: 0,
+      approved: 0,
+      executing: 0,
+      validating: 0,
+      reconciling: 0,
+      completed: 0,
+      archived: 0,
+    } as Record<PlanStatus, number>;
+    const tasksByStatus = {
+      pending: 0,
+      in_progress: 0,
+      completed: 0,
+      skipped: 0,
+      failed: 0,
+    } as Record<TaskStatus, number>;
     let totalTasks = 0;
     for (const p of plans) {
       byStatus[p.status]++;
@@ -348,7 +477,10 @@ export class Planner {
       for (const t of p.tasks) tasksByStatus[t.status]++;
     }
     return {
-      total: plans.length, byStatus, totalTasks, tasksByStatus,
+      total: plans.length,
+      byStatus,
+      totalTasks,
+      tasksByStatus,
       avgTasksPerPlan: plans.length > 0 ? Math.round((totalTasks / plans.length) * 100) / 100 : 0,
     };
   }
@@ -358,17 +490,25 @@ export class Planner {
     const gaps = runGapAnalysis(plan, this.gapOptions);
     if (hasCircularDependencies(plan.tasks)) {
       gaps.push({
-        id: `gap_${Date.now()}_circ`, severity: 'critical', category: 'structure',
+        id: `gap_${Date.now()}_circ`,
+        severity: 'critical',
+        category: 'structure',
         description: 'Circular dependencies detected among tasks.',
         recommendation: 'Remove circular dependency chains so tasks can be executed in order.',
-        location: 'tasks', _trigger: 'circular_dependencies',
+        location: 'tasks',
+        _trigger: 'circular_dependencies',
       });
     }
     const iteration = plan.checks.length + 1;
     const score = calculateScore(gaps, iteration);
     const check: PlanCheck = {
       checkId: `chk-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      planId, grade: scoreToGrade(score), score, gaps, iteration, checkedAt: Date.now(),
+      planId,
+      grade: scoreToGrade(score),
+      score,
+      gaps,
+      iteration,
+      checkedAt: Date.now(),
     };
     plan.checks.push(check);
     plan.latestCheck = check;

package/src/planning/rationalization-detector.test.ts

@@ -31,10 +31,7 @@ describe('detectRationalizations', () => {
   });
 
   it('detects "follow-up PR" pattern', () => {
-    const report = detectRationalizations(
-      CRITERIA,
-      'Test coverage bump deferred to follow-up PR.',
-    );
+    const report = detectRationalizations(CRITERIA, 'Test coverage bump deferred to follow-up PR.');
     expect(report.detected).toBe(true);
     expect(report.items[0].pattern).toBe('follow-up-ticket');
   });
@@ -98,19 +95,13 @@ describe('detectRationalizations', () => {
   // ─── Case-insensitive matching ──────────────────────────────
 
   it('matches case-insensitively (uppercase)', () => {
-    const report = detectRationalizations(
-      CRITERIA,
-      'This is OUT OF SCOPE for the current work.',
-    );
+    const report = detectRationalizations(CRITERIA, 'This is OUT OF SCOPE for the current work.');
     expect(report.detected).toBe(true);
     expect(report.items[0].pattern).toBe('out-of-scope');
   });
 
   it('matches case-insensitively (mixed case)', () => {
-    const report = detectRationalizations(
-      CRITERIA,
-      'That is a Pre-Existing Issue we inherited.',
-    );
+    const report = detectRationalizations(CRITERIA, 'That is a Pre-Existing Issue we inherited.');
     expect(report.detected).toBe(true);
     expect(report.items[0].pattern).toBe('pre-existing-issue');
   });
@@ -118,10 +109,7 @@ describe('detectRationalizations', () => {
   // ─── Empty/skip cases ──────────────────────────────────────
 
   it('skips detection when acceptance criteria are empty', () => {
-    const report = detectRationalizations(
-      [],
-      'This is out of scope and a pre-existing issue.',
-    );
+    const report = detectRationalizations([], 'This is out of scope and a pre-existing issue.');
     expect(report.detected).toBe(false);
     expect(report.items).toHaveLength(0);
   });
@@ -158,10 +146,7 @@ describe('detectRationalizations', () => {
   // ─── Suggestion is always present ──────────────────────────
 
   it('provides actionable suggestions for each item', () => {
-    const report = detectRationalizations(
-      CRITERIA,
-      'This is out of scope and over-engineering.',
-    );
+    const report = detectRationalizations(CRITERIA, 'This is out of scope and over-engineering.');
     expect(report.detected).toBe(true);
     for (const item of report.items) {
       expect(item.suggestion).toBeTruthy();

package/src/planning/rationalization-detector.ts

@@ -37,32 +37,38 @@ const PATTERNS: RationalizationPattern[] = [
   {
     name: 'out-of-scope',
     regex: /out\s+of\s+scope/i,
-    suggestion: 'If it was in the acceptance criteria, it is in scope. Remove from criteria or complete it.',
+    suggestion:
+      'If it was in the acceptance criteria, it is in scope. Remove from criteria or complete it.',
   },
   {
     name: 'follow-up-ticket',
     regex: /follow[- ]?up\s+(ticket|issue|pr|task)/i,
-    suggestion: 'Deferring to a follow-up means the criterion is unmet. Complete it now or revise the plan.',
+    suggestion:
+      'Deferring to a follow-up means the criterion is unmet. Complete it now or revise the plan.',
   },
   {
     name: 'pre-existing-issue',
     regex: /pre[- ]?existing\s+(issue|bug|problem)/i,
-    suggestion: 'Pre-existing or not, the criterion expects it resolved. Fix it or remove the criterion.',
+    suggestion:
+      'Pre-existing or not, the criterion expects it resolved. Fix it or remove the criterion.',
   },
   {
     name: 'over-engineering',
     regex: /over[- ]?engineering/i,
-    suggestion: 'Meeting acceptance criteria is not over-engineering. Implement what was agreed upon.',
+    suggestion:
+      'Meeting acceptance criteria is not over-engineering. Implement what was agreed upon.',
   },
   {
     name: 'separate-pr',
     regex: /separate\s+(pr|task|ticket|issue)/i,
-    suggestion: 'Splitting into a separate PR defers the work. Complete the criterion or update the plan.',
+    suggestion:
+      'Splitting into a separate PR defers the work. Complete the criterion or update the plan.',
   },
   {
     name: 'too-complex',
     regex: /too\s+complex\s+for\s+this\s+(task|pr|ticket|issue|scope)/i,
-    suggestion: 'Complexity was known at planning time. Revisit the plan or complete the criterion.',
+    suggestion:
+      'Complexity was known at planning time. Revisit the plan or complete the criterion.',
   },
 ];
 
@@ -91,11 +97,7 @@ export function detectRationalizations(
     if (!match) continue;
 
     // Find which criterion is being rationalized (nearest mention)
-    const criterion = findRelatedCriterion(
-      acceptanceCriteria,
-      completionClaim,
-      match.index,
-    );
+    const criterion = findRelatedCriterion(acceptanceCriteria, completionClaim, match.index);
 
     items.push({
       criterion,
@@ -114,11 +116,7 @@ export function detectRationalizations(
  * Find the acceptance criterion most related to the rationalization phrase
  * by checking which criterion text appears closest to the match position.
  */
-function findRelatedCriterion(
-  criteria: string[],
-  claim: string,
-  matchIndex: number,
-): string {
+function findRelatedCriterion(criteria: string[], claim: string, matchIndex: number): string {
   const claimLower = claim.toLowerCase();
   let bestCriterion = criteria[0];
   let bestDistance = Infinity;

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

@@ -36,7 +36,10 @@ describe('reconciliation-engine', () => {
     });
     it('floors at 0', () => {
       const items: DriftItem[] = Array.from({ length: 10 }, () => ({
-        type: 'skipped' as const, description: 'x', impact: 'high' as const, rationale: 'r',
+        type: 'skipped' as const,
+        description: 'x',
+        impact: 'high' as const,
+        rationale: 'r',
       }));
       expect(calculateDriftScore(items)).toBe(0);
     });
@@ -63,8 +66,22 @@ describe('reconciliation-engine', () => {
     });
     it('computes average duration from tasks with metrics', () => {
       const tasks: PlanTask[] = [
-        { id: 't1', title: '', description: '', status: 'completed', updatedAt: 0, metrics: { durationMs: 100 } },
-        { id: 't2', title: '', description: '', status: 'completed', updatedAt: 0, metrics: { durationMs: 200 } },
+        {
+          id: 't1',
+          title: '',
+          description: '',
+          status: 'completed',
+          updatedAt: 0,
+          metrics: { durationMs: 100 },
+        },
+        {
+          id: 't2',
+          title: '',
+          description: '',
+          status: 'completed',
+          updatedAt: 0,
+          metrics: { durationMs: 200 },
+        },
         { id: 't3', title: '', description: '', status: 'completed', updatedAt: 0 }, // no metrics
       ];
       const summary = computeExecutionSummary(tasks);

package/src/planning/reconciliation-engine.ts

@@ -65,8 +65,7 @@ export function computeExecutionSummary(tasks: ReadonlyArray<PlanTask>): Executi
     tasksCompleted,
     tasksSkipped,
     tasksFailed,
-    avgTaskDurationMs:
-      tasksWithDuration > 0 ? Math.round(totalDurationMs / tasksWithDuration) : 0,
+    avgTaskDurationMs: tasksWithDuration > 0 ? Math.round(totalDurationMs / tasksWithDuration) : 0,
   };
 }