@cleocode/core 2026.3.44 → 2026.3.46

package/src/scaffold.ts

@@ -523,7 +523,7 @@ export async function ensureProjectContext(
   try {
     const schemaPath = join(
       dirname(fileURLToPath(import.meta.url)),
-      '../../schemas/project-context.schema.json',
+      '../schemas/project-context.schema.json',
     );
     if (existsSync(schemaPath)) {
       const AjvModule = await import('ajv');
@@ -1037,8 +1037,16 @@ export function checkMemoryBridge(projectRoot: string): CheckResult {
  * Required subdirectories under the global ~/.cleo/ home.
  * These are infrastructure directories managed by CLEO itself,
  * not project-specific data.
+ *
+ * Truly global:
+ *   - logs      — global log output
+ *   - templates — CLEO-INJECTION.md symlink target
+ *
+ * Note: nexus.db lives directly in ~/.cleo/, not a subdir.
+ * Schemas are read at runtime from getPackageRoot()/schemas/ — no copy needed.
+ * Project-level dirs (adrs/, rcasd/, agent-outputs/, backups/) live in .cleo/ only.
  */
-export const REQUIRED_GLOBAL_SUBDIRS = ['schemas', 'templates'] as const;
+export const REQUIRED_GLOBAL_SUBDIRS = ['logs', 'templates'] as const;
 
 /**
  * Ensure the global ~/.cleo/ home directory and its required
@@ -1111,9 +1119,13 @@ export async function ensureGlobalTemplates(): Promise<ScaffoldResult> {
 }
 
 /**
- * Perform a complete global scaffold operation: ensure home, schemas,
- * and templates are all present and current. This is the single entry
- * point for global infrastructure scaffolding.
+ * Perform a complete global scaffold operation: ensure home and templates
+ * are all present and current. This is the single entry point for global
+ * infrastructure scaffolding.
+ *
+ * Schemas are NOT copied here — they are read at runtime from the npm
+ * package path (getPackageRoot() + '/schemas/'). Use ensureGlobalSchemas()
+ * explicitly from init or upgrade if a copy is needed for a specific workflow.
  *
  * Used by:
  *   - MCP startup (via startupHealthCheck in health.ts)
@@ -1122,17 +1134,12 @@ export async function ensureGlobalTemplates(): Promise<ScaffoldResult> {
  */
 export async function ensureGlobalScaffold(): Promise<{
   home: ScaffoldResult;
-  schemas: { installed: number; updated: number; total: number };
   templates: ScaffoldResult;
 }> {
-  // Lazy import to avoid circular dependency
-  const { ensureGlobalSchemas } = await import('./schema-management.js');
-
   const home = await ensureGlobalHome();
-  const schemas = ensureGlobalSchemas();
   const templates = await ensureGlobalTemplates();
 
-  return { home, schemas, templates };
+  return { home, templates };
 }
 
 // ── Global check* functions (read-only diagnostics) ──────────────────

package/src/skills/__tests__/routing-table.test.ts

@@ -3,44 +3,16 @@ import {
   getOperationsByChannel,
   getPreferredChannel,
   getRoutingForDomain,
-  ROUTING_TABLE,
 } from '../routing-table.js';
 
 describe('routing-table', () => {
-  describe('ROUTING_TABLE structure', () => {
-    it('has entries for all 10 canonical domains', () => {
-      const domains = new Set(ROUTING_TABLE.map((e) => e.domain));
-      expect(domains.has('memory')).toBe(true);
-      expect(domains.has('tasks')).toBe(true);
-      expect(domains.has('session')).toBe(true);
-      expect(domains.has('admin')).toBe(true);
-      expect(domains.has('tools')).toBe(true);
-      expect(domains.has('check')).toBe(true);
-      expect(domains.has('pipeline')).toBe(true);
-      expect(domains.has('orchestrate')).toBe(true);
-      expect(domains.has('nexus')).toBe(true);
-      expect(domains.has('sticky')).toBe(true);
-    });
-
-    it('every entry has required fields', () => {
-      for (const entry of ROUTING_TABLE) {
-        expect(entry.domain).toBeTruthy();
-        expect(entry.operation).toBeTruthy();
-        expect(['mcp', 'cli', 'either']).toContain(entry.preferredChannel);
-        expect(entry.reason).toBeTruthy();
-      }
+  describe('getPreferredChannel (via capability matrix)', () => {
+    it('returns mcp for memory.find', () => {
+      expect(getPreferredChannel('memory', 'find')).toBe('mcp');
     });
 
-    it('has no duplicate domain+operation pairs', () => {
-      const keys = ROUTING_TABLE.map((e) => `${e.domain}.${e.operation}`);
-      const unique = new Set(keys);
-      expect(unique.size).toBe(keys.length);
-    });
-  });
-
-  describe('getPreferredChannel', () => {
-    it('returns mcp for memory.brain.search', () => {
-      expect(getPreferredChannel('memory', 'brain.search')).toBe('mcp');
+    it('returns mcp for memory.fetch', () => {
+      expect(getPreferredChannel('memory', 'fetch')).toBe('mcp');
     });
 
     it('returns cli for pipeline.release.ship', () => {
@@ -54,15 +26,56 @@ describe('routing-table', () => {
     it('returns either for unknown operations', () => {
       expect(getPreferredChannel('nonexistent', 'op')).toBe('either');
     });
+
+    it('returns mcp for tasks.show', () => {
+      expect(getPreferredChannel('tasks', 'show')).toBe('mcp');
+    });
+
+    it('returns mcp for session.status', () => {
+      expect(getPreferredChannel('session', 'status')).toBe('mcp');
+    });
+
+    it('returns mcp for admin.dash', () => {
+      expect(getPreferredChannel('admin', 'dash')).toBe('mcp');
+    });
   });
 
   describe('getRoutingForDomain', () => {
+    it('returns entries covering all 10 canonical domains', () => {
+      const domains = [
+        'memory',
+        'tasks',
+        'session',
+        'admin',
+        'tools',
+        'check',
+        'pipeline',
+        'orchestrate',
+        'nexus',
+        'sticky',
+      ];
+      for (const domain of domains) {
+        const entries = getRoutingForDomain(domain);
+        expect(entries.length).toBeGreaterThan(0);
+        expect(entries.every((e) => e.domain === domain)).toBe(true);
+      }
+    });
+
     it('returns all memory domain entries', () => {
       const entries = getRoutingForDomain('memory');
       expect(entries.length).toBeGreaterThan(0);
       expect(entries.every((e) => e.domain === 'memory')).toBe(true);
     });
 
+    it('every entry has required fields with valid channel', () => {
+      const entries = getRoutingForDomain('tasks');
+      for (const entry of entries) {
+        expect(entry.domain).toBeTruthy();
+        expect(entry.operation).toBeTruthy();
+        expect(['mcp', 'cli', 'either']).toContain(entry.preferredChannel);
+      }
+    });
+
     it('returns empty array for unknown domain', () => {
       expect(getRoutingForDomain('nonexistent')).toEqual([]);
     });
@@ -86,5 +99,12 @@ describe('routing-table', () => {
       const cliCount = getOperationsByChannel('cli').length;
       expect(mcpCount).toBeGreaterThan(cliCount);
     });
+
+    it('has no duplicate domain+operation pairs within a channel', () => {
+      const mcpOps = getOperationsByChannel('mcp');
+      const keys = mcpOps.map((e) => `${e.domain}.${e.operation}`);
+      const unique = new Set(keys);
+      expect(unique.size).toBe(keys.length);
+    });
   });
 });

package/src/skills/agents/install.ts

@@ -9,10 +9,18 @@
  */
 
 import { existsSync, mkdirSync, readdirSync, readlinkSync, symlinkSync, unlinkSync } from 'node:fs';
+import { platform } from 'node:os';
 import { basename, join } from 'node:path';
 import { getClaudeAgentsDir } from '../../paths.js';
 import { getAgentsDir } from './config.js';
 
+/**
+ * Symlink type for directory symlinks.
+ * On Windows, use 'junction' (no admin privileges required).
+ * On Unix, use 'dir'.
+ */
+const DIR_SYMLINK_TYPE: 'junction' | 'dir' = platform() === 'win32' ? 'junction' : 'dir';
+
 // ============================================================================
 // Agent Installation
 // ============================================================================
@@ -65,7 +73,7 @@ export function installAgent(agentDir: string): {
   }
 
   try {
-    symlinkSync(agentDir, targetPath, 'dir');
+    symlinkSync(agentDir, targetPath, DIR_SYMLINK_TYPE);
     return { installed: true, path: targetPath };
   } catch (err) {
     return { installed: false, path: targetPath, error: `Symlink failed: ${err}` };

package/src/skills/routing-table.ts

@@ -1,24 +1,31 @@
 /**
  * Dynamic Skill Routing Table
  *
- * Token-efficiency routing table that determines whether each operation
- * is more efficient via MCP (lower overhead) or CLI (more flexible).
- *
- * MCP operations avoid CLI process startup overhead (~200ms + ~50 tokens)
- * and are preferred for rapid, repeated queries. CLI is preferred for
- * operations that benefit from human-readable output or shell integration.
+ * Thin wrapper over the merged capability matrix. PreferredChannel data
+ * is now stored as part of OperationCapability in the capability matrix
+ * (packages/core/src/routing/capability-matrix.ts), which is the single
+ * SSoT for both execution mode and channel preference.
  *
  * @task T5240
  * @epic T5149
+ * @see packages/core/src/routing/capability-matrix.ts
  */
 
+import { getCapabilityMatrix } from '../routing/capability-matrix.js';
+
+export type { PreferredChannel } from '../routing/capability-matrix.js';
+
 /**
  * Routing entry describing the preferred channel for an operation.
+ *
+ * Derived from OperationCapability in the capability matrix.
+ * Use this type when consuming domain-level routing results from
+ * getRoutingForDomain() or getOperationsByChannel().
  */
 export interface RoutingEntry {
   /** Domain name (e.g. 'tasks', 'memory', 'session') */
   domain: string;
-  /** Operation name (e.g. 'brain.search', 'show') */
+  /** Operation name (e.g. 'show', 'find') */
   operation: string;
   /** Preferred channel for token efficiency */
   preferredChannel: 'mcp' | 'cli' | 'either';
@@ -26,277 +33,56 @@ export interface RoutingEntry {
   reason: string;
 }
 
-/**
- * Static routing table for all canonical operations.
- *
- * Operations are grouped by domain with channel preferences based on:
- * - MCP: lower overhead (no CLI startup), direct DB access, structured JSON
- * - CLI: human-readable output, shell integration, interactive prompts
- * - Either: no significant difference or context-dependent
- */
-export const ROUTING_TABLE: RoutingEntry[] = [
-  // === Memory domain -- MCP strongly preferred (direct DB, no CLI startup) ===
-  {
-    domain: 'memory',
-    operation: 'brain.search',
-    preferredChannel: 'mcp',
-    reason: 'Low overhead search, direct DB access',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.fetch',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB access, structured response',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.timeline',
-    preferredChannel: 'mcp',
-    reason: 'Complex multi-table query, direct DB',
-  },
-  {
-    domain: 'memory',
-    operation: 'brain.observe',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write, no CLI overhead',
-  },
-  {
-    domain: 'memory',
-    operation: 'find',
-    preferredChannel: 'mcp',
-    reason: 'Alias for brain.search',
-  },
-  { domain: 'memory', operation: 'show', preferredChannel: 'mcp', reason: 'Alias for brain.fetch' },
-  {
-    domain: 'memory',
-    operation: 'decision.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'decision.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-  {
-    domain: 'memory',
-    operation: 'learning.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'learning.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-  {
-    domain: 'memory',
-    operation: 'pattern.store',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB write',
-  },
-  {
-    domain: 'memory',
-    operation: 'pattern.find',
-    preferredChannel: 'mcp',
-    reason: 'Direct DB query',
-  },
-
-  // === Tasks domain -- MCP preferred for queries, CLI for complex ops ===
-  {
-    domain: 'tasks',
-    operation: 'show',
-    preferredChannel: 'mcp',
-    reason: 'Structured JSON response',
-  },
-  { domain: 'tasks', operation: 'find', preferredChannel: 'mcp', reason: 'Low overhead search' },
-  { domain: 'tasks', operation: 'list', preferredChannel: 'mcp', reason: 'Paginated response' },
-  {
-    domain: 'tasks',
-    operation: 'next',
-    preferredChannel: 'mcp',
-    reason: 'Algorithm runs in-process',
-  },
-  { domain: 'tasks', operation: 'current', preferredChannel: 'mcp', reason: 'Simple DB lookup' },
-  {
-    domain: 'tasks',
-    operation: 'plan',
-    preferredChannel: 'mcp',
-    reason: 'Composite view, in-process',
-  },
-  { domain: 'tasks', operation: 'add', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  { domain: 'tasks', operation: 'update', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  {
-    domain: 'tasks',
-    operation: 'complete',
-    preferredChannel: 'mcp',
-    reason: 'Atomic DB write with hooks',
-  },
-  { domain: 'tasks', operation: 'start', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-  { domain: 'tasks', operation: 'stop', preferredChannel: 'mcp', reason: 'Atomic DB write' },
-
-  // === Session domain -- MCP preferred (stateful, in-process) ===
-  { domain: 'session', operation: 'status', preferredChannel: 'mcp', reason: 'Quick state lookup' },
-  { domain: 'session', operation: 'start', preferredChannel: 'mcp', reason: 'State transition' },
-  {
-    domain: 'session',
-    operation: 'end',
-    preferredChannel: 'mcp',
-    reason: 'State transition with hooks',
-  },
-  {
-    domain: 'session',
-    operation: 'handoff.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured handoff data',
-  },
-  {
-    domain: 'session',
-    operation: 'briefing.show',
-    preferredChannel: 'mcp',
-    reason: 'Composite cold-start',
-  },
-
-  // === Admin domain -- either (human interaction common) ===
-  { domain: 'admin', operation: 'version', preferredChannel: 'either', reason: 'Simple lookup' },
-  { domain: 'admin', operation: 'health', preferredChannel: 'either', reason: 'Diagnostics' },
-  { domain: 'admin', operation: 'dash', preferredChannel: 'mcp', reason: 'Composite view' },
-  { domain: 'admin', operation: 'help', preferredChannel: 'mcp', reason: 'Operation discovery' },
-  {
-    domain: 'admin',
-    operation: 'map',
-    preferredChannel: 'mcp',
-    reason: 'Structured codebase analysis',
-  },
-
-  // === Tools domain -- MCP preferred (structured responses) ===
-  {
-    domain: 'tools',
-    operation: 'skill.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured catalog',
-  },
-  {
-    domain: 'tools',
-    operation: 'skill.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured skill data',
-  },
-  { domain: 'tools', operation: 'skill.find', preferredChannel: 'mcp', reason: 'Search response' },
-  {
-    domain: 'tools',
-    operation: 'skill.install',
-    preferredChannel: 'either',
-    reason: 'May need shell access',
-  },
-  {
-    domain: 'tools',
-    operation: 'provider.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured list',
-  },
-  {
-    domain: 'tools',
-    operation: 'provider.detect',
-    preferredChannel: 'mcp',
-    reason: 'Detection result',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.list',
-    preferredChannel: 'mcp',
-    reason: 'Structured list',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.show',
-    preferredChannel: 'mcp',
-    reason: 'Structured manifest',
-  },
-  {
-    domain: 'tools',
-    operation: 'adapter.activate',
-    preferredChannel: 'mcp',
-    reason: 'State transition',
-  },
-
-  // === Check domain -- MCP preferred (validation results) ===
-  {
-    domain: 'check',
-    operation: 'validate',
-    preferredChannel: 'mcp',
-    reason: 'Structured validation',
-  },
-  {
-    domain: 'check',
-    operation: 'compliance',
-    preferredChannel: 'mcp',
-    reason: 'Compliance report',
-  },
-
-  // === Pipeline domain -- MCP preferred (lifecycle gates) ===
-  {
-    domain: 'pipeline',
-    operation: 'lifecycle.status',
-    preferredChannel: 'mcp',
-    reason: 'Gate status',
-  },
-  {
-    domain: 'pipeline',
-    operation: 'release.ship',
-    preferredChannel: 'cli',
-    reason: 'Complex multi-step with git ops',
-  },
-
-  // === Orchestrate domain -- MCP preferred (agent coordination) ===
-  { domain: 'orchestrate', operation: 'spawn', preferredChannel: 'mcp', reason: 'Agent spawning' },
-  { domain: 'orchestrate', operation: 'plan', preferredChannel: 'mcp', reason: 'Decomposition' },
-
-  // === Nexus domain -- either (cross-project queries) ===
-  {
-    domain: 'nexus',
-    operation: 'search',
-    preferredChannel: 'either',
-    reason: 'Cross-project search',
-  },
-  { domain: 'nexus', operation: 'sync', preferredChannel: 'either', reason: 'Cross-project sync' },
-
-  // === Sticky domain -- MCP preferred (quick ephemeral notes) ===
-  { domain: 'sticky', operation: 'add', preferredChannel: 'mcp', reason: 'Quick DB write' },
-  { domain: 'sticky', operation: 'list', preferredChannel: 'mcp', reason: 'Quick DB read' },
-  { domain: 'sticky', operation: 'show', preferredChannel: 'mcp', reason: 'Quick DB read' },
-];
-
 /**
  * Look up the preferred channel for a given domain + operation.
  *
+ * Reads from the merged capability matrix (single SSoT).
+ *
  * @param domain - Domain name
  * @param operation - Operation name
  * @returns Preferred channel ('mcp', 'cli', or 'either' as fallback)
  */
 export function getPreferredChannel(domain: string, operation: string): 'mcp' | 'cli' | 'either' {
-  const entry = ROUTING_TABLE.find((e) => e.domain === domain && e.operation === operation);
+  const entry = getCapabilityMatrix().find(
+    (cap) => cap.domain === domain && cap.operation === operation,
+  );
   return entry?.preferredChannel ?? 'either';
 }
 
 /**
  * Get routing entries for a specific domain.
  *
+ * Derives entries from the capability matrix.
+ *
  * @param domain - Domain name
  * @returns All routing entries for the domain
  */
 export function getRoutingForDomain(domain: string): RoutingEntry[] {
-  return ROUTING_TABLE.filter((e) => e.domain === domain);
+  return getCapabilityMatrix()
+    .filter((cap) => cap.domain === domain)
+    .map((cap) => ({
+      domain: cap.domain,
+      operation: cap.operation,
+      preferredChannel: cap.preferredChannel,
+      reason: '',
+    }));
 }
 
 /**
  * Get all operations that prefer a specific channel.
  *
+ * Derives entries from the capability matrix.
+ *
  * @param channel - Channel preference to filter by
  * @returns Matching routing entries
  */
 export function getOperationsByChannel(channel: 'mcp' | 'cli' | 'either'): RoutingEntry[] {
-  return ROUTING_TABLE.filter((e) => e.preferredChannel === channel);
+  return getCapabilityMatrix()
+    .filter((cap) => cap.preferredChannel === channel)
+    .map((cap) => ({
+      domain: cap.domain,
+      operation: cap.operation,
+      preferredChannel: cap.preferredChannel,
+      reason: '',
+    }));
 }

package/src/skills/skill-paths.ts

@@ -15,7 +15,7 @@
 
 import { existsSync, lstatSync, readlinkSync, realpathSync } from 'node:fs';
 import { delimiter, join, resolve } from 'node:path';
-import { getAgentsHome } from '../paths.js';
+import { getCanonicalSkillsDir } from '@cleocode/caamp';
 
 /** Source type classification for a skill directory. */
 export type SkillSourceType = 'embedded' | 'caamp' | 'project-link' | 'global-link';
@@ -31,10 +31,11 @@ export interface SkillSearchPath {
 
 /**
  * Get the CAAMP canonical skill location.
+ * Delegates to caamp's getCanonicalSkillsDir() which is XDG-aware.
  * @task T4552
  */
 function getCaampCanonical(): string {
-  return join(getAgentsHome(), 'skills');
+  return getCanonicalSkillsDir();
 }
 
 /**

package/src/store/__tests__/project-detect.test.ts

@@ -14,7 +14,7 @@ import { detectProjectType } from '../project-detect.js';
 
 // ─── Schema validator setup ───────────────────────────────────────────────────
 const schemaPath = fileURLToPath(
-  new URL('../../../../../schemas/project-context.schema.json', import.meta.url),
+  new URL('../../../schemas/project-context.schema.json', import.meta.url),
 );
 const schema = JSON.parse(readFileSync(schemaPath, 'utf-8'));
 const Ajv = (AjvModule as any).default ?? AjvModule;

package/src/store/brain-sqlite.ts

@@ -50,13 +50,17 @@ export function getBrainDbPath(cwd?: string): string {
 
 /**
  * Resolve the path to the drizzle-brain migrations folder.
- * Works from both src/ (dev via tsx) and dist/ (compiled).
+ * Works from both src/ (dev via tsx) and dist/ (compiled via esbuild bundle).
+ *
+ * - Source layout: __dirname = src/store/ → need ../../migrations/drizzle-brain
+ * - Bundled layout: __dirname = dist/     → need ../migrations/drizzle-brain
  */
 export function resolveBrainMigrationsFolder(): string {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  // Both src/store/ and dist/store/ are 2 levels deep from package root
-  return join(__dirname, '..', '..', 'migrations', 'drizzle-brain');
+  const isBundled = __dirname.endsWith('/dist') || __dirname.endsWith('\\dist');
+  const pkgRoot = isBundled ? join(__dirname, '..') : join(__dirname, '..', '..');
+  return join(pkgRoot, 'migrations', 'drizzle-brain');
 }
 
 /**

package/src/store/nexus-sqlite.ts

@@ -46,13 +46,17 @@ export function getNexusDbPath(): string {
 
 /**
  * Resolve the path to the drizzle-nexus migrations folder.
- * Works from both src/ (dev via tsx) and dist/ (compiled).
+ * Works from both src/ (dev via tsx) and dist/ (compiled via esbuild bundle).
+ *
+ * - Source layout: __dirname = src/store/ → need ../../migrations/drizzle-nexus
+ * - Bundled layout: __dirname = dist/     → need ../migrations/drizzle-nexus
  */
 export function resolveNexusMigrationsFolder(): string {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  // Both src/store/ and dist/store/ are 2 levels deep from package root
-  return join(__dirname, '..', '..', 'migrations', 'drizzle-nexus');
+  const isBundled = __dirname.endsWith('/dist') || __dirname.endsWith('\\dist');
+  const pkgRoot = isBundled ? join(__dirname, '..') : join(__dirname, '..', '..');
+  return join(pkgRoot, 'migrations', 'drizzle-nexus');
 }
 
 /**

package/src/store/sqlite.ts

@@ -357,13 +357,19 @@ export async function getDb(cwd?: string): Promise<NodeSQLiteDatabase<typeof sch
 
 /**
  * Resolve the path to the drizzle migrations folder.
- * Works from both src/ (dev via tsx) and dist/ (compiled).
+ * Works from both src/ (dev via tsx) and dist/ (compiled via esbuild bundle).
+ *
+ * - Source layout: __dirname = src/store/ → need ../../migrations/drizzle-tasks
+ * - Bundled layout: __dirname = dist/     → need ../migrations/drizzle-tasks
  */
 export function resolveMigrationsFolder(): string {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  // Both src/store/ and dist/store/ are 2 levels deep from package root
-  return join(__dirname, '..', '..', 'migrations', 'drizzle-tasks');
+  // When esbuild bundles into dist/index.js, __dirname is dist/ (1 level deep).
+  // When running from source via tsx, __dirname is src/store/ (2 levels deep).
+  const isBundled = __dirname.endsWith('/dist') || __dirname.endsWith('\\dist');
+  const pkgRoot = isBundled ? join(__dirname, '..') : join(__dirname, '..', '..');
+  return join(pkgRoot, 'migrations', 'drizzle-tasks');
 }
 
 /**

package/src/store/tasks-schema.ts

@@ -127,7 +127,7 @@ export const TASK_RELATION_TYPES = [
 export const LIFECYCLE_TRANSITION_TYPES = ['automatic', 'manual', 'forced'] as const;
 
 /** External task link types matching DB constraint on external_task_links.link_type. */
-export const EXTERNAL_LINK_TYPES = ['created', 'matched', 'manual'] as const;
+export const EXTERNAL_LINK_TYPES = ['created', 'matched', 'manual', 'transferred'] as const;
 
 /** Sync direction types matching DB constraint on external_task_links.sync_direction. */
 export const SYNC_DIRECTIONS = ['inbound', 'outbound', 'bidirectional'] as const;