@soleri/core 9.14.4 → 9.16.7

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,
@@ -101,6 +103,13 @@ export type {
 } from './vault/vault-types.js';
 export { validatePlaybook, parsePlaybookFromEntry } from './vault/playbook.js';
 export type { Playbook, PlaybookStep, PlaybookValidationResult } from './vault/playbook.js';
+export { DEFAULT_CANONICAL_TAGS } from './vault/default-canonical-tags.js';
+export {
+  normalizeTag as normalizeTagCanonical,
+  normalizeTags as normalizeTagsCanonical,
+  isMetadataTag,
+  computeEditDistance,
+} from './vault/tag-normalizer.js';
 
 // ─── Playbook System (registry, matching, seeding) ─────────────────
 export {
@@ -949,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/content-classifier.ts

@@ -45,22 +45,40 @@ Rules:
 // CLASSIFIER
 // =============================================================================
 
+/**
+ * Build the classification system prompt, optionally injecting a canonical tag list.
+ * When canonical tags are provided, the LLM is guided to prefer them.
+ */
+export function buildClassificationPrompt(canonicalTags?: string[]): string {
+  if (!canonicalTags || canonicalTags.length === 0) {
+    return CLASSIFICATION_PROMPT;
+  }
+  const tagList = canonicalTags.join(', ');
+  return (
+    CLASSIFICATION_PROMPT +
+    `\n\nTag guidance: Use only tags from this approved list where possible: ${tagList}. Create a new tag only when nothing from the list fits the concept.`
+  );
+}
+
 /**
  * Classify a text chunk into structured knowledge items using an LLM.
  *
- * @param llm      - LLMClient instance
- * @param chunkText - The text to classify
- * @param citation  - Source citation (e.g. "book.pdf, pages 12-15")
+ * @param llm          - LLMClient instance
+ * @param chunkText    - The text to classify
+ * @param citation     - Source citation (e.g. "book.pdf, pages 12-15")
+ * @param canonicalTags - Optional canonical tag list to inject into the prompt
  * @returns Classified items, or [] on any error
  */
 export async function classifyChunk(
   llm: LLMClient,
   chunkText: string,
   citation: string,
+  canonicalTags?: string[],
 ): Promise<ClassifiedItem[]> {
   try {
+    const systemPrompt = buildClassificationPrompt(canonicalTags);
     const result = await llm.complete({
-      systemPrompt: CLASSIFICATION_PROMPT,
+      systemPrompt,
       userPrompt: chunkText,
       maxTokens: 4096,
       temperature: 0.3,

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/intake/text-ingester.ts

@@ -11,6 +11,7 @@ import type { IntelligenceEntry } from '../intelligence/types.js';
 import type { ClassifiedItem } from './types.js';
 import { classifyChunk } from './content-classifier.js';
 import { dedupItems } from './dedup-gate.js';
+import { normalizeTags as normalizeTagsCanonical } from '../vault/tag-normalizer.js';
 
 // ─── Types ───────────────────────────────────────────────────────────
 
@@ -26,6 +27,12 @@ export interface IngestOptions {
   tags?: string[];
   /** Max chars per chunk for LLM classification. Default 4000. */
   chunkSize?: number;
+  /** Canonical tag list for normalization. If omitted, no canonical normalization. */
+  canonicalTags?: string[];
+  /** Tag constraint mode. Default: 'suggest'. */
+  tagConstraintMode?: 'enforce' | 'suggest' | 'off';
+  /** Metadata tag prefixes exempt from canonical normalization. Default: ['source:']. */
+  metadataTagPrefixes?: string[];
 }
 
 export interface IngestResult {
@@ -42,15 +49,30 @@ const FETCH_TIMEOUT_MS = 15000;
 
 // ─── Class ───────────────────────────────────────────────────────────
 
+interface CanonicalTagConfig {
+  canonicalTags: string[];
+  tagConstraintMode: 'enforce' | 'suggest' | 'off';
+  metadataTagPrefixes: string[];
+}
+
 export class TextIngester {
   private vault: Vault;
   private llm: LLMClient | null;
+  private canonicalTagConfig: CanonicalTagConfig | null = null;
 
   constructor(vault: Vault, llm: LLMClient | null) {
     this.vault = vault;
     this.llm = llm;
   }
 
+  /**
+   * Wire canonical tag config from runtime — used as defaults for all ingest calls.
+   * Caller-provided options in ingestText/ingestUrl/ingestBatch still take precedence.
+   */
+  setCanonicalTagConfig(cfg: CanonicalTagConfig): void {
+    this.canonicalTagConfig = cfg;
+  }
+
   /**
    * Ingest a URL — fetch, strip HTML, classify, dedup, store.
    */
@@ -101,11 +123,19 @@ export class TextIngester {
     const domain = opts?.domain ?? 'general';
     const extraTags = opts?.tags ?? [];
 
+    // Resolve canonical config — caller opts take precedence over runtime-wired config
+    const canonicalTagsForClassify = opts?.canonicalTags ?? this.canonicalTagConfig?.canonicalTags;
+
     // Classify all chunks
     const allItems: ClassifiedItem[] = [];
     for (const chunk of chunks) {
       // oxlint-disable-next-line eslint(no-await-in-loop)
-      const items = await classifyChunk(this.llm, chunk, `${source.type}: ${source.title}`);
+      const items = await classifyChunk(
+        this.llm,
+        chunk,
+        `${source.type}: ${source.title}`,
+        canonicalTagsForClassify,
+      );
       allItems.push(...items);
     }
 
@@ -121,18 +151,37 @@ export class TextIngester {
     // Build source attribution for context field
     const attribution = buildAttribution(source);
 
+    // Metadata tags use 'source:' prefix so they're exempt from canonical normalization
+    const metadataTags = [`source:ingested`, `source:${source.type}`];
+
+    // Apply canonical tag normalization if configured
+    // Caller-provided options take precedence over runtime-wired config
+    const canonicalTags = opts?.canonicalTags ?? this.canonicalTagConfig?.canonicalTags;
+    const tagMode =
+      opts?.tagConstraintMode ?? this.canonicalTagConfig?.tagConstraintMode ?? 'suggest';
+
     // Store in vault
-    const entries: IntelligenceEntry[] = unique.map((item, i) => ({
-      id: `ingest-${source.type}-${Date.now()}-${i}-${Math.random().toString(36).slice(2, 6)}`,
-      type: mapType(item.type),
-      domain,
-      title: item.title,
-      description: item.description,
-      severity: mapSeverity(item.severity),
-      tags: [...(item.tags ?? []), ...extraTags, 'ingested', source.type],
-      context: attribution,
-      origin: 'user' as const,
-    }));
+    const entries: IntelligenceEntry[] = unique.map((item, i) => {
+      const rawTags = [...(item.tags ?? []), ...extraTags];
+      // metaPrefixes not passed here — source: tags are added after normalization,
+      // so there is nothing to exempt at this point.
+      const normalizedTags =
+        canonicalTags && tagMode !== 'off'
+          ? normalizeTagsCanonical(rawTags, canonicalTags, tagMode)
+          : rawTags;
+
+      return {
+        id: `ingest-${source.type}-${Date.now()}-${i}-${Math.random().toString(36).slice(2, 6)}`,
+        type: mapType(item.type),
+        domain,
+        title: item.title,
+        description: item.description,
+        severity: mapSeverity(item.severity),
+        tags: [...normalizedTags, ...metadataTags],
+        context: attribution,
+        origin: 'user' as const,
+      };
+    });
 
     if (entries.length > 0) {
       this.vault.seed(entries);

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