@soleri/core 9.15.0 → 9.16.7

package/src/flows/types.ts

@@ -75,6 +75,11 @@ export const flowSchema = z.object({
     'min-confidence': z.enum(['HIGH', 'MEDIUM', 'LOW']).optional(),
   }),
   steps: z.array(flowStepSchema),
+  /**
+   * Scoring weights declared per step — parsed but not yet computed by the executor.
+   * Weighted-sum formula is not implemented; gate thresholds in steps are the active enforcement.
+   * @see https://github.com/adrozdenko/soleri/issues/632
+   */
   scoring: z
     .object({
       weights: z.record(z.number()),
@@ -100,7 +105,7 @@ export const flowSchema = z.object({
     })
     .optional(),
   /** Strategy when a step's capability requirement is not satisfied */
-  onMissingCapability: z
+  'on-missing-capability': z
     .object({
       default: z.enum(['skip-with-warning', 'fail', 'ask-user']).default('skip-with-warning'),
       blocking: z.array(z.string()).optional().default([]),
@@ -130,7 +135,8 @@ export type ProbeName =
   | 'designSystem'
   | 'sessionStore'
   | 'projectRules'
-  | 'active';
+  | 'active'
+  | 'test';
 
 export interface ProbeResults {
   vault: boolean;
@@ -139,6 +145,7 @@ export interface ProbeResults {
   sessionStore: boolean;
   projectRules: boolean;
   active: boolean;
+  test: boolean;
 }
 
 // ---------------------------------------------------------------------------
@@ -158,6 +165,8 @@ export interface PlanStep {
     min?: number;
     onFail?: { action: string; goto?: string; message?: string };
   };
+  /** Output keys this step produces — merged into stepContext for subsequent steps. */
+  output?: string[];
   status:
     | 'pending'
     | 'running'
@@ -175,6 +184,22 @@ export interface SkippedStep {
   reason: string;
 }
 
+/**
+ * A vault knowledge entry surfaced as a planning constraint.
+ * Replaces gate-step injection — constraints are carried as metadata
+ * so the executor can apply judgment rather than mechanical evaluation.
+ */
+export interface VaultRecommendation {
+  entryId: string;
+  title: string;
+  context?: string;
+  example?: string;
+  mandatory: boolean;
+  entryType?: 'pattern' | 'anti-pattern' | 'rule' | 'playbook';
+  source: 'vault';
+  strength: number;
+}
+
 export interface ToolDeviation {
   stepId: string;
   expectedTools: string[];
@@ -198,6 +223,10 @@ export interface OrchestrationPlan {
   workflowPrompt?: string;
   /** Name of the matched workflow */
   workflowName?: string;
+  /** True when a blocking capability is unavailable — plan cannot run */
+  blocked?: boolean;
+  /** Vault knowledge constraints relevant to this plan — executor reads these as context */
+  recommendations?: VaultRecommendation[];
 }
 
 export interface OrchestrationContext {

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

@@ -21,6 +21,7 @@ describe('HealthRegistry', () => {
   });
 
   it('tracks transitions: healthy -> degraded -> healthy', () => {
+    const before = Date.now();
     const reg = new HealthRegistry();
     reg.register('svc');
     reg.update('svc', 'degraded', 'timeout');
@@ -31,7 +32,8 @@ describe('HealthRegistry', () => {
     reg.update('svc', 'healthy');
     expect(reg.get('svc')!.failureCount).toBe(0);
     expect(reg.get('svc')!.lastError).toBeNull();
-    expect(reg.get('svc')!.lastHealthyAt).toBeGreaterThan(0);
+    expect(reg.get('svc')!.lastHealthyAt).toBeGreaterThanOrEqual(before);
+    expect(reg.get('svc')!.lastHealthyAt).toBeLessThanOrEqual(Date.now());
   });
 
   it('auto-registers on update if not previously registered', () => {

package/src/index.ts

@@ -18,6 +18,8 @@ export { WorkspaceResolver } from './subagent/workspace-resolver.js';
 export { ConcurrencyManager } from './subagent/concurrency-manager.js';
 export { OrphanReaper } from './subagent/orphan-reaper.js';
 export type { ReapResult } from './subagent/orphan-reaper.js';
+export { worktreeReap, worktreeStatus } from './utils/worktree-reaper.js';
+export type { ReapReport, WorktreeStatus } from './utils/worktree-reaper.js';
 export { aggregate as aggregateResults } from './subagent/result-aggregator.js';
 export type {
   SubagentTask,
@@ -956,3 +958,18 @@ export type { WorkflowGate, WorkflowOverride } from './workflows/index.js';
 // ─── Update Check ────────────────────────────────────────────────────
 export { checkForUpdate, buildChangelogUrl, detectBreakingChanges } from './update-check.js';
 export type { UpdateInfo } from './update-check.js';
+
+// ─── Settings Hooks Sync ─────────────────────────────────────────────
+export { syncHooksToClaudeSettings } from './runtime/admin-setup-ops.js';
+
+// ─── Scheduler ───────────────────────────────────────────────────────
+export { Scheduler, InMemorySchedulerStore } from './scheduler/scheduler.js';
+export type { SchedulerStore } from './scheduler/scheduler.js';
+export { createSchedulerOps } from './scheduler/scheduler-ops.js';
+export { validateCron, estimateMinIntervalHours } from './scheduler/cron-validator.js';
+export type {
+  ScheduledTask,
+  CreateTaskInput,
+  TaskListEntry,
+  PlatformAdapter,
+} from './scheduler/types.js';

package/src/intake/dedup-gate.test.ts

@@ -135,13 +135,9 @@ describe('dedupItems — colocated', () => {
     const results = dedupItems(items, vault);
 
     expect(results).toHaveLength(2);
-    // First should be duplicate or at least high similarity
-    expect(results[0].similarity).toBeGreaterThan(0.5);
+    // First should be a high-similarity match (near-exact duplicate)
+    expect(results[0].similarity).toBeGreaterThanOrEqual(DEDUP_THRESHOLD);
     // Second should be non-duplicate
     expect(results[1].isDuplicate).toBe(false);
   });
-
-  it('DEDUP_THRESHOLD is 0.85', () => {
-    expect(DEDUP_THRESHOLD).toBe(0.85);
-  });
 });

package/src/intake/text-ingester.test.ts

@@ -86,7 +86,7 @@ describe('TextIngester — ingestText', () => {
     expect(result.duplicates).toBe(0);
     expect(result.entries).toHaveLength(1);
     expect(result.entries[0].title).toBe('Pattern A');
-    expect(vault._seeded.length).toBeGreaterThan(0);
+    expect(vault._seeded.length).toBe(1);
   });
 
   it('returns empty result when LLM is null', async () => {
@@ -120,8 +120,7 @@ describe('TextIngester — ingestText', () => {
     const result = await ingester.ingestText('text', { type: 'documentation', title: 'Doc' }, opts);
 
     expect(result.ingested).toBe(1);
-    // Seeded entries should exist
-    expect(vault._seeded.length).toBeGreaterThan(0);
+    expect(vault._seeded.length).toBe(1);
   });
 
   it('splits long text into chunks based on chunkSize option', async () => {
@@ -155,7 +154,7 @@ describe('TextIngester — ingestText', () => {
     const longText = 'A'.repeat(100);
     await ingester.ingestText(longText, { type: 'notes', title: 'Test' }, { chunkSize: 30 });
 
-    expect(callCount.n).toBeGreaterThan(1);
+    expect(callCount.n).toBe(4);
   });
 });
 

package/src/llm/llm-client.test.ts

@@ -119,7 +119,7 @@ describe('LLMClient — colocated', () => {
         expect(result.provider).toBe('openai');
         expect(result.inputTokens).toBe(10);
         expect(result.outputTokens).toBe(5);
-        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+        expect(typeof result.durationMs).toBe('number');
       } finally {
         globalThis.fetch = originalFetch;
       }

package/src/llm/utils.test.ts

@@ -224,7 +224,7 @@ describe('computeDelay', () => {
   it('should never return negative delay', () => {
     vi.spyOn(Math, 'random').mockReturnValue(0);
     const config = { maxAttempts: 3, baseDelayMs: 1, maxDelayMs: 30000, jitter: 1 };
-    expect(computeDelay({}, 0, config)).toBeGreaterThanOrEqual(0);
+    expect(typeof computeDelay({}, 0, config)).toBe('number');
     vi.restoreAllMocks();
   });
 });

package/src/migrations/migration-runner.test.ts

@@ -137,7 +137,6 @@ describe('MigrationRunner', () => {
 
       // Assert
       expect(typeof results[0].durationMs).toBe('number');
-      expect(results[0].durationMs).toBeGreaterThanOrEqual(0);
     });
   });
 

package/src/operator/operator-context-store.test.ts

@@ -51,19 +51,6 @@ describe('OperatorContextStore', () => {
     vault.close();
   });
 
-  // ─── Table Creation ─────────────────────────────────────────────────
-
-  describe('init', () => {
-    it('creates table without error on a fresh database', () => {
-      expect(store).toBeDefined();
-    });
-
-    it('is idempotent — second init does not throw', () => {
-      const store2 = new OperatorContextStore(vault.getProvider());
-      expect(store2).toBeDefined();
-    });
-  });
-
   // ─── Empty State ──────────────────────────────────────────────────
 
   describe('getContext (empty)', () => {

package/src/operator/operator-profile.test.ts

@@ -47,15 +47,6 @@ describe('OperatorProfileStore', () => {
     vault.close();
   });
 
-  // ─── Table Creation ─────────────────────────────────────────────
-
-  it('creates tables without error on new runtime', () => {
-    // Constructor ran initTables — no error means tables exist.
-    // Creating a second instance also succeeds (IF NOT EXISTS).
-    const store2 = new OperatorProfileStore(vault);
-    expect(store2).toBeDefined();
-  });
-
   // ─── getProfile ─────────────────────────────────────────────────
 
   it('returns null when no profile exists', () => {
@@ -186,8 +177,8 @@ describe('OperatorProfileStore', () => {
       'SELECT trigger, version FROM operator_profile_history WHERE profile_id = ?',
       [profileBefore!.id],
     );
-    expect(history.length).toBeGreaterThanOrEqual(1);
-    expect(history.some((h) => h.trigger === 'correction')).toBe(true);
+    expect(history.length).toBe(1);
+    expect(history[0].trigger).toBe('correction');
   });
 
   // ─── snapshot ───────────────────────────────────────────────────
@@ -320,13 +311,4 @@ describe('OperatorProfileStore', () => {
     expect(section.signalWords).toContain('please');
     expect(section.adaptationRules).toHaveLength(1);
   });
-
-  // ─── No `any` types ────────────────────────────────────────────
-
-  it('type system enforced — file compiles with strict TypeScript', () => {
-    // This test is a compile-time assertion:
-    // if operator-profile.ts had `any` types, tsc --noEmit would catch it.
-    // The fact that this test file compiles is the proof.
-    expect(true).toBe(true);
-  });
 });

package/src/packs/pack-installer.ts

@@ -9,8 +9,9 @@
  * 5. Return install summary
  */
 
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
 import {
   packManifestSchema,
   type InstalledPack,
@@ -200,10 +201,19 @@ export class PackInstaller {
         facadesRegistered = true;
       }
 
-      // 3. Discover skills
+      // 3. Discover skills and sync to .claude/skills/<packId>:<skill>/
       const skillsDir = join(packDir, manifest.skills?.dir ?? 'skills');
       const skills = existsSync(skillsDir) ? listMarkdownFiles(skillsDir) : [];
 
+      if (skills.length > 0) {
+        try {
+          const { syncSkillsToClaudeCode } = await import('../skills/sync-skills.js');
+          syncSkillsToClaudeCode([skillsDir], manifest.id, { global: true });
+        } catch {
+          // Skill sync is best-effort — never blocks install
+        }
+      }
+
       // 4. Discover hooks
       const hooksDir = join(packDir, manifest.hooks?.dir ?? 'hooks');
       const hooks = existsSync(hooksDir) ? listMarkdownFiles(hooksDir) : [];
@@ -281,6 +291,22 @@ export class PackInstaller {
       this.pluginRegistry.deactivate(packId);
     }
 
+    // Remove pack skills from .claude/skills/
+    if (pack.skills.length > 0) {
+      try {
+        const claudeSkillsDir = join(homedir(), '.claude', 'skills');
+        for (const skillPath of pack.skills) {
+          const skillName = basename(skillPath, '.md');
+          const registeredPath = join(claudeSkillsDir, `${packId}:${skillName}`);
+          if (existsSync(registeredPath)) {
+            rmSync(registeredPath, { recursive: true, force: true });
+          }
+        }
+      } catch {
+        // Skill cleanup is best-effort
+      }
+    }
+
     // Transition to uninstalled
     try {
       this.lifecycle.transition(packId, 'uninstalled', 'User uninstall');

package/src/packs/pack-system.test.ts

@@ -233,7 +233,7 @@ describe('PackInstaller', () => {
 
       const result = installer.validate(packDir);
       expect(result.valid).toBe(true);
-      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings.length).toBe(2);
     });
   });
 
@@ -271,7 +271,7 @@ describe('PackInstaller', () => {
 
       // Verify vault was seeded
       const entries = vault.list({ domain: 'test' });
-      expect(entries.length).toBeGreaterThan(0);
+      expect(entries.length).toBe(1);
     });
 
     it('should install a pack with facades', async () => {

package/src/persona/defaults.test.ts

@@ -12,21 +12,21 @@ describe('ITALIAN_CRAFTSPERSON', () => {
   });
 
   it('has non-empty voice, culture, and inspiration', () => {
-    expect(ITALIAN_CRAFTSPERSON.voice.length).toBeGreaterThan(0);
+    expect(ITALIAN_CRAFTSPERSON.voice).toContain('Italian mentor');
     expect(ITALIAN_CRAFTSPERSON.culture).toBe('Italian');
-    expect(ITALIAN_CRAFTSPERSON.inspiration.length).toBeGreaterThan(0);
+    expect(ITALIAN_CRAFTSPERSON.inspiration).toContain('Paolo Soleri');
   });
 
   it('provides greetings and signoffs pools', () => {
-    expect(ITALIAN_CRAFTSPERSON.greetings.length).toBeGreaterThan(0);
-    expect(ITALIAN_CRAFTSPERSON.signoffs.length).toBeGreaterThan(0);
+    expect(ITALIAN_CRAFTSPERSON.greetings).toHaveLength(5);
+    expect(ITALIAN_CRAFTSPERSON.signoffs).toHaveLength(5);
   });
 
   it('includes expected trait and quirk arrays', () => {
-    expect(ITALIAN_CRAFTSPERSON.traits.length).toBeGreaterThan(0);
-    expect(ITALIAN_CRAFTSPERSON.quirks.length).toBeGreaterThan(0);
-    expect(ITALIAN_CRAFTSPERSON.metaphors.length).toBeGreaterThan(0);
-    expect(ITALIAN_CRAFTSPERSON.opinions.length).toBeGreaterThan(0);
+    expect(ITALIAN_CRAFTSPERSON.traits).toHaveLength(7);
+    expect(ITALIAN_CRAFTSPERSON.quirks).toHaveLength(6);
+    expect(ITALIAN_CRAFTSPERSON.metaphors).toHaveLength(8);
+    expect(ITALIAN_CRAFTSPERSON.opinions).toHaveLength(6);
   });
 });
 
@@ -36,26 +36,26 @@ describe('NEUTRAL_PERSONA', () => {
   });
 
   it('has non-empty voice and inspiration', () => {
-    expect(NEUTRAL_PERSONA.voice.length).toBeGreaterThan(0);
-    expect(NEUTRAL_PERSONA.inspiration.length).toBeGreaterThan(0);
+    expect(NEUTRAL_PERSONA.voice).toContain('helpful assistant');
+    expect(NEUTRAL_PERSONA.inspiration).toContain('reliable professional');
   });
 
   it('has no cultural flavor', () => {
     expect(NEUTRAL_PERSONA.culture).toBe('');
   });
 
-  it('has all arrays populated with minimum counts', () => {
-    expect(NEUTRAL_PERSONA.traits.length).toBeGreaterThanOrEqual(3);
-    expect(NEUTRAL_PERSONA.quirks.length).toBeGreaterThanOrEqual(3);
-    expect(NEUTRAL_PERSONA.opinions.length).toBeGreaterThanOrEqual(3);
-    expect(NEUTRAL_PERSONA.metaphors.length).toBeGreaterThanOrEqual(3);
-    expect(NEUTRAL_PERSONA.greetings.length).toBeGreaterThanOrEqual(2);
-    expect(NEUTRAL_PERSONA.signoffs.length).toBeGreaterThanOrEqual(2);
+  it('has all arrays populated with exact counts', () => {
+    expect(NEUTRAL_PERSONA.traits).toHaveLength(6);
+    expect(NEUTRAL_PERSONA.quirks).toHaveLength(4);
+    expect(NEUTRAL_PERSONA.opinions).toHaveLength(6);
+    expect(NEUTRAL_PERSONA.metaphors).toHaveLength(5);
+    expect(NEUTRAL_PERSONA.greetings).toHaveLength(3);
+    expect(NEUTRAL_PERSONA.signoffs).toHaveLength(3);
   });
 
   it('has non-empty language and name rules', () => {
-    expect(NEUTRAL_PERSONA.languageRule.length).toBeGreaterThan(0);
-    expect(NEUTRAL_PERSONA.nameRule.length).toBeGreaterThan(0);
+    expect(NEUTRAL_PERSONA.languageRule).toContain("user's language");
+    expect(NEUTRAL_PERSONA.nameRule).toContain('name changes');
   });
 });
 

package/src/planning/gap-passes.test.ts

@@ -10,12 +10,6 @@ import {
   analyzeSemanticQuality,
   analyzeKnowledgeDepth,
   analyzeAlternatives,
-  AMBIGUOUS_WORDS,
-  GENERIC_OBJECTIVE_PATTERNS,
-  RATIONALE_INDICATORS,
-  SHALLOW_INDICATORS,
-  KNOWLEDGE_INDICATORS,
-  NAMED_PATTERN_REGEX,
 } from './gap-passes.js';
 
 function makePlan(overrides: Partial<Plan> = {}): Plan {
@@ -77,46 +71,6 @@ function makeAlternative(overrides: Partial<PlanAlternative> = {}): PlanAlternat
   };
 }
 
-describe('Pattern constants (passes 5-8)', () => {
-  it('AMBIGUOUS_WORDS contains common vague terms', () => {
-    expect(AMBIGUOUS_WORDS).toContain('maybe');
-    expect(AMBIGUOUS_WORDS).toContain('probably');
-    expect(AMBIGUOUS_WORDS).toContain('etc');
-  });
-
-  it('GENERIC_OBJECTIVE_PATTERNS matches simple verb-noun objectives', () => {
-    expect(GENERIC_OBJECTIVE_PATTERNS.some((p) => p.test('Create something'))).toBe(true);
-    expect(GENERIC_OBJECTIVE_PATTERNS.some((p) => p.test('Fix bug'))).toBe(true);
-  });
-
-  it('GENERIC_OBJECTIVE_PATTERNS does not match detailed objectives', () => {
-    expect(
-      GENERIC_OBJECTIVE_PATTERNS.some((p) => p.test('Create a user auth module with JWT')),
-    ).toBe(false);
-  });
-
-  it('RATIONALE_INDICATORS contains reasoning words', () => {
-    expect(RATIONALE_INDICATORS).toContain('because');
-    expect(RATIONALE_INDICATORS).toContain('due to');
-  });
-
-  it('SHALLOW_INDICATORS contains subjective words', () => {
-    expect(SHALLOW_INDICATORS).toContain('better');
-    expect(SHALLOW_INDICATORS).toContain('good');
-  });
-
-  it('KNOWLEDGE_INDICATORS match domain patterns', () => {
-    expect(KNOWLEDGE_INDICATORS.some((p) => p.test('vault pattern'))).toBe(true);
-    expect(KNOWLEDGE_INDICATORS.some((p) => p.test('WCAG 2.1'))).toBe(true);
-    expect(KNOWLEDGE_INDICATORS.some((p) => p.test('aria-label'))).toBe(true);
-  });
-
-  it('NAMED_PATTERN_REGEX matches hyphenated identifiers', () => {
-    expect(NAMED_PATTERN_REGEX.test('zod-form-validation')).toBe(true);
-    expect(NAMED_PATTERN_REGEX.test('simple')).toBe(false);
-  });
-});
-
 describe('Pass 5: Clarity', () => {
   it('flags ambiguous language in objective', () => {
     const plan = makePlan({

package/src/planning/gap-patterns.test.ts

@@ -14,13 +14,6 @@ import {
   analyzeCompleteness,
   analyzeFeasibility,
   analyzeRisk,
-  METRIC_PATTERNS,
-  EXCLUSION_KEYWORDS,
-  OVERLY_BROAD_PATTERNS,
-  DEPENDENCY_KEYWORDS,
-  BREAKING_CHANGE_KEYWORDS,
-  MITIGATION_KEYWORDS,
-  VERIFICATION_KEYWORDS,
 } from './gap-patterns.js';
 
 function makePlan(overrides: Partial<Plan> = {}): Plan {
@@ -161,41 +154,6 @@ describe('Helper functions', () => {
   });
 });
 
-describe('Pattern constants', () => {
-  it('METRIC_PATTERNS matches numbers', () => {
-    expect(METRIC_PATTERNS.some((p) => p.test('reduce latency by 50%'))).toBe(true);
-  });
-
-  it('EXCLUSION_KEYWORDS includes common exclusion words', () => {
-    expect(EXCLUSION_KEYWORDS).toContain('exclude');
-    expect(EXCLUSION_KEYWORDS).toContain('not');
-  });
-
-  it('OVERLY_BROAD_PATTERNS includes dangerous scope terms', () => {
-    expect(OVERLY_BROAD_PATTERNS).toContain('complete rewrite');
-  });
-
-  it('DEPENDENCY_KEYWORDS includes ordering terms', () => {
-    expect(DEPENDENCY_KEYWORDS).toContain('depends');
-    expect(DEPENDENCY_KEYWORDS).toContain('prerequisite');
-  });
-
-  it('BREAKING_CHANGE_KEYWORDS includes migration terms', () => {
-    expect(BREAKING_CHANGE_KEYWORDS).toContain('breaking change');
-    expect(BREAKING_CHANGE_KEYWORDS).toContain('database migration');
-  });
-
-  it('MITIGATION_KEYWORDS includes safety terms', () => {
-    expect(MITIGATION_KEYWORDS).toContain('rollback');
-    expect(MITIGATION_KEYWORDS).toContain('feature flag');
-  });
-
-  it('VERIFICATION_KEYWORDS includes testing terms', () => {
-    expect(VERIFICATION_KEYWORDS).toContain('test');
-    expect(VERIFICATION_KEYWORDS).toContain('coverage');
-  });
-});
-
 describe('Pass 1: Structure', () => {
   it('returns no gaps for a well-structured plan', () => {
     const gaps = analyzeStructure(makePlan());

package/src/planning/goal-ancestry.test.ts

@@ -287,8 +287,10 @@ describe('JsonGoalRepository', () => {
   });
 
   it('should create and retrieve a goal', () => {
+    const before = Date.now();
     const goal = repo.create({ id: 'g1', title: 'Ship it', level: 'objective', status: 'planned' });
-    expect(goal.createdAt).toBeGreaterThan(0);
+    expect(goal.createdAt).toBeGreaterThanOrEqual(before);
+    expect(goal.createdAt).toBeLessThanOrEqual(Date.now());
     expect(repo.getById('g1')?.title).toBe('Ship it');
   });
 

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.ts

@@ -185,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');

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' });