@cleocode/core 2026.3.42 → 2026.3.44

package/src/skills/orchestrator/startup.ts

@@ -11,8 +11,9 @@
 
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import type { Task, TaskRef, TaskRefPriority } from '@cleocode/contracts';
-import { getCleoDirAbsolute, getSessionsPath, getTaskPath } from '../../paths.js';
+import type { Task, TaskRef, TaskRefPriority, TaskWorkState } from '@cleocode/contracts';
+import { getCleoDirAbsolute } from '../../paths.js';
+import { getAccessor } from '../../store/data-accessor.js';
 import type {
   DependencyAnalysis,
   DependencyWave,
@@ -134,47 +135,65 @@ export interface SessionInitResult {
  * Determines the recommended action based on current state.
  * @task T4519
  */
-export async function sessionInit(_epicId?: string, cwd?: string): Promise<SessionInitResult> {
-  const sessionsPath = getSessionsPath(cwd);
-  const cleoDirAbs = getCleoDirAbsolute(cwd);
-  const focusPath = join(cleoDirAbs, 'focus.json');
+export async function sessionInit(epicId?: string, cwd?: string): Promise<SessionInitResult> {
+  const acc = await getAccessor(cwd);
 
-  // Check active sessions
+  // Check active sessions from SQLite (ADR-006/ADR-020)
   let activeSessions = 0;
   let activeSessionId: string | null = null;
   let activeScope: string | null = null;
 
-  if (existsSync(sessionsPath)) {
-    try {
-      const data = JSON.parse(readFileSync(sessionsPath, 'utf-8'));
-      const active = (data.sessions ?? []).filter((s: { status: string }) => s.status === 'active');
-      activeSessions = active.length;
-      if (activeSessions > 0) {
-        activeSessionId = active[0].id ?? null;
-        activeScope = active[0].scope?.rootId ?? active[0].scope?.epicId ?? null;
+  try {
+    const sessions = await acc.loadSessions();
+    let active = sessions.filter((s) => s.status === 'active');
+
+    // If epicId provided, prefer sessions scoped to that epic
+    if (epicId && active.length > 0) {
+      const epicScoped = active.filter(
+        (s) => s.scope?.rootTaskId === epicId || s.scope?.epicId === epicId,
+      );
+      if (epicScoped.length > 0) {
+        active = epicScoped;
       }
-    } catch {
-      // Invalid sessions file
     }
+
+    activeSessions = active.length;
+    if (activeSessions > 0) {
+      activeSessionId = active[0].id ?? null;
+      activeScope = active[0].scope?.rootTaskId ?? active[0].scope?.epicId ?? null;
+    }
+  } catch {
+    // DB unavailable
+  }
+
+  // If epicId provided and no active session found, set activeScope to the epic
+  if (epicId && !activeScope) {
+    activeScope = epicId;
   }
 
-  // Check focus
+  // Check focus state from SQLite meta KV
   let hasFocus = false;
   let focusedTask: string | null = null;
 
-  if (existsSync(focusPath)) {
+  try {
+    const focus = await acc.getMetaValue<TaskWorkState>('focus_state');
+    focusedTask = focus?.currentTask ?? null;
+    hasFocus = !!focusedTask;
+  } catch {
+    // Focus unavailable
+  }
+
+  // Determine pending work: check if the epic has ready tasks via DataAccessor
+  let hasPending = false;
+  if (epicId) {
     try {
-      const focus = JSON.parse(readFileSync(focusPath, 'utf-8'));
-      focusedTask = focus.focusedTaskId ?? null;
-      hasFocus = !!focusedTask;
+      const children = await acc.getChildren(epicId);
+      hasPending = children.some((t) => t.status === 'pending');
     } catch {
-      // Invalid focus file
+      // Tasks unavailable
     }
   }
 
-  // Determine pending work (simplified - check manifest for needs_followup)
-  const hasPending = false; // Will be populated by manifest checks
-
   // Decision matrix
   let recommendedAction: SessionInitResult['recommendedAction'];
   let actionReason: string;
@@ -187,7 +206,9 @@ export async function sessionInit(_epicId?: string, cwd?: string): Promise<Sessi
     actionReason = 'Active session without focus - query manifest and spawn next agent';
   } else if (hasPending) {
     recommendedAction = 'create_and_spawn';
-    actionReason = 'No session but manifest has followups - create session and spawn';
+    actionReason = epicId
+      ? `No session but epic ${epicId} has pending tasks - create session and spawn`
+      : 'No session but manifest has followups - create session and spawn';
   } else {
     recommendedAction = 'request_direction';
     actionReason = 'No session, no pending work - await user direction';
@@ -275,9 +296,10 @@ export async function analyzeDependencies(
   epicId: string,
   cwd?: string,
 ): Promise<DependencyAnalysis> {
-  const taskPath = getTaskPath(cwd);
+  const acc = await getAccessor(cwd);
+  const epicTasks = await acc.getChildren(epicId);
 
-  if (!existsSync(taskPath)) {
+  if (epicTasks.length === 0) {
     return {
       epicId,
       totalTasks: 0,
@@ -290,10 +312,9 @@ export async function analyzeDependencies(
     };
   }
 
-  const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-  const tasks: Task[] = data.tasks ?? [];
-  const epicTasks = tasks.filter((t) => t.parentId === epicId);
-  const doneIds = new Set(tasks.filter((t) => t.status === 'done').map((t) => t.id));
+  // Need full task set to resolve cross-epic dependency status
+  const { tasks: allTasks } = await acc.queryTasks({});
+  const doneIds = new Set(allTasks.filter((t) => t.status === 'done').map((t) => t.id));
   const epicIds = new Set(epicTasks.map((t) => t.id));
 
   // Compute waves iteratively
@@ -389,12 +410,10 @@ export async function getNextTask(
     return { task: null, readyCount: 0 };
   }
 
-  // Load full task details for the first ready task
-  const taskPath = getTaskPath(cwd);
-  const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-  const tasks: Task[] = data.tasks ?? [];
+  // Load full task details from SQLite
+  const acc = await getAccessor(cwd);
   const nextId = analysis.readyToSpawn[0].id;
-  const task = tasks.find((t) => t.id === nextId) ?? null;
+  const task = await acc.loadSingleTask(nextId);
 
   return { task, readyCount: analysis.readyToSpawn.length };
 }
@@ -407,16 +426,13 @@ export async function getReadyTasks(epicId: string, cwd?: string): Promise<TaskR
   const analysis = await analyzeDependencies(epicId, cwd);
   const readyIds = new Set(analysis.readyToSpawn.map((t) => t.id));
 
-  // Filter out tasks that depend on other ready tasks
-  const taskPath = getTaskPath(cwd);
-  if (!existsSync(taskPath)) return [];
-
-  const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-  const tasks: Task[] = data.tasks ?? [];
+  // Load full task details from SQLite to check inter-ready dependencies
+  const acc = await getAccessor(cwd);
+  const readyTasksFull = await acc.loadTasks([...readyIds]);
 
   return analysis.readyToSpawn
     .filter((ready) => {
-      const task = tasks.find((t) => t.id === ready.id);
+      const task = readyTasksFull.find((t) => t.id === ready.id);
       if (!task) return false;
       const deps = task.depends ?? [];
       // Only include if no deps are also in the ready set
@@ -438,31 +454,29 @@ export async function generateHitlSummary(
   stopReason: string = 'context-limit',
   cwd?: string,
 ): Promise<HitlSummary> {
-  const taskPath = getTaskPath(cwd);
-  const cleoDirAbs = getCleoDirAbsolute(cwd);
+  const acc = await getAccessor(cwd);
 
-  // Session info
+  // Session info from SQLite (ADR-006/ADR-020)
   let sessionId: string | null = null;
-  const currentSessionFile = join(cleoDirAbs, '.current-session');
-  if (existsSync(currentSessionFile)) {
-    sessionId = readFileSync(currentSessionFile, 'utf-8').trim() || null;
+  try {
+    const activeSession = await acc.getActiveSession();
+    sessionId = activeSession?.id ?? null;
+  } catch {
+    // DB unavailable
   }
 
-  // Focus info
+  // Focus info from SQLite meta KV
   let focusedTask: string | null = null;
   let progressNote: string | null = null;
-  const focusPath = join(cleoDirAbs, 'focus.json');
-  if (existsSync(focusPath)) {
-    try {
-      const focus = JSON.parse(readFileSync(focusPath, 'utf-8'));
-      focusedTask = focus.focusedTaskId ?? null;
-      progressNote = focus.sessionNote ?? null;
-    } catch {
-      // ignore
-    }
+  try {
+    const focus = await acc.getMetaValue<TaskWorkState>('focus_state');
+    focusedTask = focus?.currentTask ?? null;
+    progressNote = focus?.sessionNote ?? null;
+  } catch {
+    // Focus unavailable
   }
 
-  // Task statistics
+  // Task statistics from SQLite via DataAccessor
   let completed = 0,
     pending = 0,
     active = 0,
@@ -471,9 +485,8 @@ export async function generateHitlSummary(
   let remainingTasks: Array<TaskRef & { priority?: string }> = [];
   let readyToSpawn: TaskRefPriority[] = [];
 
-  if (existsSync(taskPath) && epicId) {
-    const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-    const tasks: Task[] = (data.tasks ?? []).filter((t: Task) => t.parentId === epicId);
+  if (epicId) {
+    const tasks = await acc.getChildren(epicId);
 
     completed = tasks.filter((t) => t.status === 'done').length;
     pending = tasks.filter((t) => t.status === 'pending').length;

package/src/skills/orchestrator/validator.ts

@@ -11,13 +11,12 @@
 
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import type { Task } from '@cleocode/contracts';
 import { MANIFEST_STATUSES } from '@cleocode/contracts';
 import {
   getAgentOutputsAbsolute,
   getManifestPath as getManifestPathFromPaths,
-  getTaskPath,
 } from '../../paths.js';
+import { getAccessor } from '../../store/data-accessor.js';
 import type { ComplianceResult, ManifestEntry, ManifestValidationResult } from '../types.js';
 
 // ============================================================================
@@ -310,14 +309,14 @@ export function verifyCompliance(
  * Validate orchestrator compliance (post-hoc behavioral checks).
  * @task T4519
  */
-export function validateOrchestratorCompliance(
+export async function validateOrchestratorCompliance(
   epicId?: string,
   cwd?: string,
-): {
+): Promise<{
   compliant: boolean;
   violations: string[];
   warnings: string[];
-} {
+}> {
   const violations: string[] = [];
   const warnings: string[] = [];
 
@@ -333,36 +332,32 @@ export function validateOrchestratorCompliance(
     }
   }
 
-  // Check dependency order (ORC-004) for completed tasks
+  // Check dependency order (ORC-004) for completed tasks via DataAccessor
   if (epicId) {
-    const taskPath = getTaskPath(cwd);
-    if (existsSync(taskPath)) {
-      try {
-        const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-        const tasks: Task[] = (data.tasks ?? []).filter(
-          (t: Task) => t.parentId === epicId && t.status === 'done',
-        );
-
-        // Sort by updatedAt and check for dependency violations
-        const sorted = tasks.sort(
-          (a, b) => new Date(a.updatedAt ?? '').getTime() - new Date(b.updatedAt ?? '').getTime(),
-        );
-        const completionOrder = sorted.map((t) => t.id);
-
-        for (let i = 0; i < sorted.length; i++) {
-          const deps = sorted[i].depends ?? [];
-          for (const dep of deps) {
-            const depIdx = completionOrder.indexOf(dep);
-            if (depIdx >= 0 && depIdx >= i) {
-              violations.push(
-                `ORC-004_DEPENDENCY_ORDER: Task ${sorted[i].id} completed before dependency ${dep}`,
-              );
-            }
+    try {
+      const acc = await getAccessor(cwd);
+      const children = await acc.getChildren(epicId);
+      const tasks = children.filter((t) => t.status === 'done');
+
+      // Sort by updatedAt and check for dependency violations
+      const sorted = tasks.sort(
+        (a, b) => new Date(a.updatedAt ?? '').getTime() - new Date(b.updatedAt ?? '').getTime(),
+      );
+      const completionOrder = sorted.map((t) => t.id);
+
+      for (let i = 0; i < sorted.length; i++) {
+        const deps = sorted[i].depends ?? [];
+        for (const dep of deps) {
+          const depIdx = completionOrder.indexOf(dep);
+          if (depIdx >= 0 && depIdx >= i) {
+            violations.push(
+              `ORC-004_DEPENDENCY_ORDER: Task ${sorted[i].id} completed before dependency ${dep}`,
+            );
           }
         }
-      } catch {
-        // Skip on parse error
       }
+    } catch {
+      // Skip on DB error
     }
   }
 

package/src/skills/precedence-types.ts

@@ -1,6 +1,14 @@
 /**
  * Skills Precedence Types - Phase 3B of T5238
- * Re-exports CAAMP precedence types and adds CLEO-specific wrapper types.
+ *
+ * Re-exports CAAMP precedence types and adds CLEO-specific wrapper types
+ * for skill path resolution and installation context.
+ *
+ * These types complement the skill types in `./types.ts`:
+ * - `./types.ts` defines the CLEO skill domain model (Skill, SkillFrontmatter, etc.)
+ * - This file defines CAAMP precedence integration types used when resolving
+ *   which skill version takes priority across providers and scopes.
+ *
  * @task T5238
  */
 
@@ -21,23 +29,38 @@ export {
 
 import type { SkillsPrecedence } from '@cleocode/caamp';
 
+/** Configuration for skill precedence resolution across providers. */
 export interface SkillsPrecedenceConfig {
+  /** Default precedence mode when no provider-specific override exists. */
   defaultPrecedence?: SkillsPrecedence;
+  /** Per-provider precedence overrides (provider ID -> precedence). */
   providerOverrides?: Record<string, SkillsPrecedence>;
 }
 
+/** A resolved skill path with full provenance metadata. */
 export interface ResolvedSkillPath {
+  /** Absolute filesystem path to the skill directory. */
   path: string;
+  /** Where the skill was sourced from. */
   source: 'vendor' | 'agents' | 'marketplace';
+  /** Whether this is a global or project-scoped skill. */
   scope: 'global' | 'project';
+  /** The precedence mode that selected this path. */
   precedence: SkillsPrecedence;
+  /** The provider that owns this skill path. */
   providerId: string;
 }
 
+/** Context for a skill installation operation. */
 export interface SkillInstallationContext {
+  /** Name of the skill being installed. */
   skillName: string;
+  /** Source URL or path to install from. */
   source: string;
+  /** Provider IDs to install the skill for. */
   targetProviders: string[];
+  /** Precedence mode for the installation. */
   precedenceMode?: SkillsPrecedence;
+  /** Project root for project-scoped installations. */
   projectRoot?: string;
 }

package/src/skills/types.ts

@@ -1,13 +1,46 @@
 /**
  * Type definitions for the skills system.
- * Re-exports overlapping CAAMP types for downstream consumers.
+ *
+ * ## Dual Type System: CAAMP vs CLEO Skills
+ *
+ * The skill type system has two layers reflecting the CAAMP/CLEO split:
+ *
+ * ### CAAMP types (re-exported as `CaampSkillMetadata`, `CtSkillEntry`, etc.)
+ * - Defined in `@cleocode/caamp` -- the cross-agent skill standard.
+ * - **`CaampSkillMetadata`**: Minimal metadata parsed from SKILL.md YAML header
+ *   by CAAMP's `parseSkillFile()`. Contains: name, description, version, license,
+ *   compatibility, metadata, allowedTools.
+ * - **`CtSkillEntry`**: A discovered skill with location + metadata. Used by CAAMP's
+ *   discovery and install pipeline.
+ * - Use CAAMP types when interacting with CAAMP APIs (skill discovery, install,
+ *   provider lock files, skill precedence resolution).
+ *
+ * ### CLEO types (`Skill`, `SkillFrontmatter`, `SkillSummary`, `SkillManifest`)
+ * - Defined here -- CLEO's extended skill domain model.
+ * - **`SkillFrontmatter`**: Superset of CaampSkillMetadata. Adds CLEO-specific
+ *   fields: tags, triggers, dispatchPriority, model, invocable, command, protocol.
+ *   Parsed by CLEO's own SKILL.md reader with richer YAML support.
+ * - **`Skill`**: Full in-memory skill object with filesystem paths and parsed content.
+ * - **`SkillSummary`**: Lightweight projection for listings (cached in SkillManifest).
+ * - Use CLEO types for skill dispatch, orchestration, CLI display, and manifest caching.
+ *
+ * ### Relationship
+ * - `SkillFrontmatter` is a functional superset of `CaampSkillMetadata`:
+ *   every field in CaampSkillMetadata exists in SkillFrontmatter (name, description,
+ *   version, allowedTools). SkillFrontmatter adds CLEO-specific extension fields.
+ * - A `Skill` (CLEO) wraps a `SkillFrontmatter` with filesystem context, whereas
+ *   a `CtSkillEntry` (CAAMP) wraps a `CaampSkillMetadata` with install metadata.
+ * - When converting between layers, map `CaampSkillMetadata` -> `SkillFrontmatter`
+ *   (all CAAMP fields carry over; CLEO-specific fields default to undefined).
+ *
  * @epic T4454
  * @task T4516
  */
 
 import type { TaskRef, TaskRefPriority } from '@cleocode/contracts';
 
-// Re-export CAAMP types where they overlap with CLEO's domain
+// Re-export CAAMP types where they overlap with CLEO's domain.
+// See module JSDoc above for guidance on which type to use where.
 export type {
   CtDispatchMatrix,
   CtManifest,
@@ -25,23 +58,52 @@ export type {
 // Skill Types
 // ============================================================================
 
-/** Skill frontmatter parsed from SKILL.md YAML header. */
+/**
+ * Skill frontmatter parsed from SKILL.md YAML header.
+ *
+ * This is CLEO's extended skill metadata -- a functional superset of CAAMP's
+ * `SkillMetadata`. All fields from `CaampSkillMetadata` (name, description,
+ * version, allowedTools) are present here. CLEO adds: tags, triggers,
+ * dispatchPriority, model, invocable, command, protocol.
+ *
+ * Use this type when working with CLEO's skill loading, dispatch, and
+ * orchestration systems. Use `CaampSkillMetadata` when interfacing directly
+ * with CAAMP's discovery/install APIs.
+ */
 export interface SkillFrontmatter {
+  /** Skill name (lowercase, hyphens). Maps to CaampSkillMetadata.name. */
   name: string;
+  /** Human-readable description. Maps to CaampSkillMetadata.description. */
   description: string;
+  /** Semantic version string. Maps to CaampSkillMetadata.version. */
   version?: string;
+  /** Skill author (CLEO extension). */
   author?: string;
+  /** Classification tags for search/filter (CLEO extension). */
   tags?: string[];
+  /** Trigger patterns for auto-dispatch (CLEO extension). */
   triggers?: string[];
+  /** Priority for dispatch selection (CLEO extension). */
   dispatchPriority?: number;
+  /** Preferred LLM model (CLEO extension). */
   model?: string;
+  /** Allowed tool names. Maps to CaampSkillMetadata.allowedTools. */
   allowedTools?: string[];
+  /** Whether the skill can be invoked directly (CLEO extension). */
   invocable?: boolean;
+  /** CLI command for direct invocation (CLEO extension). */
   command?: string;
+  /** RCASD-IVTR+C protocol type (CLEO extension). */
   protocol?: SkillProtocolType;
 }
 
-/** Skill definition loaded from disk. */
+/**
+ * Skill definition loaded from disk.
+ *
+ * CLEO-specific type that wraps a {@link SkillFrontmatter} with filesystem
+ * context. For CAAMP's equivalent, see `CtSkillEntry` which wraps
+ * `CaampSkillMetadata` with install/discovery metadata instead.
+ */
 export interface Skill {
   name: string;
   dirName: string;
@@ -51,7 +113,12 @@ export interface Skill {
   content?: string;
 }
 
-/** Lightweight skill summary for manifest/listing. */
+/**
+ * Lightweight skill summary for manifest/listing.
+ *
+ * Projected from {@link Skill} for efficient caching in {@link SkillManifest}.
+ * Contains only the fields needed for CLI display and dispatch selection.
+ */
 export interface SkillSummary {
   name: string;
   dirName: string;

package/src/store/__tests__/test-db-helper.d.ts

@@ -7,7 +7,7 @@
  *
  * @task T5244
  */
-import type { Task, TaskFile } from '@cleocode/contracts';
+import type { Task } from '@cleocode/contracts';
 import type { DataAccessor } from '../data-accessor.js';
 /** Result of creating a test database environment. */
 export interface TestDbEnv {
@@ -32,16 +32,16 @@ export interface TestDbEnv {
  */
 export declare function createTestDb(): Promise<TestDbEnv>;
 /**
- * Build a TaskFile structure from a list of task partials.
+ * Build full Task objects from a list of task partials.
  * Useful for seeding test data via accessor.upsertSingleTask().
  */
-export declare function makeTaskFile(
+export declare function makeTasks(
   tasks: Array<
     Partial<Task> & {
       id: string;
     }
   >,
-): TaskFile;
+): Task[];
 /**
  * Seed tasks into the test database via the accessor.
  *

package/src/store/__tests__/test-db-helper.js

@@ -40,11 +40,11 @@ export async function createTestDb() {
     };
 }
 /**
- * Build a TaskFile structure from a list of task partials.
+ * Build full Task objects from a list of task partials.
  * Useful for seeding test data via accessor.upsertSingleTask().
  */
-export function makeTaskFile(tasks) {
-    const fullTasks = tasks.map((t) => ({
+export function makeTasks(tasks) {
+    return tasks.map((t) => ({
         title: t.title ?? `Task ${t.id}`,
         description: t.description ?? undefined,
         status: t.status ?? 'pending',
@@ -52,17 +52,6 @@ export function makeTaskFile(tasks) {
         createdAt: t.createdAt ?? new Date().toISOString(),
         ...t,
     }));
-    return {
-        version: '2.10.0',
-        project: { name: 'test', phases: {} },
-        lastUpdated: new Date().toISOString(),
-        _meta: {
-            schemaVersion: '2.10.0',
-            checksum: '0000000000000000',
-            configVersion: '1.0.0',
-        },
-        tasks: fullTasks,
-    };
 }
 /**
  * Seed tasks into the test database via the accessor.
@@ -79,8 +68,8 @@ export async function seedTasks(accessor, tasks) {
         return;
     }
     // Build full Task objects from partials
-    const tf = makeTaskFile(tasks);
-    const fullTasks = tf.tasks;
+    const fullTasks = makeTasks(tasks);
+    
     // Pass 1: Upsert all tasks without dependencies so FK targets exist
     for (const task of fullTasks) {
         await accessor.upsertSingleTask({ ...task, depends: undefined });

package/src/store/__tests__/test-db-helper.ts

@@ -11,7 +11,7 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import type { Task, TaskFile } from '@cleocode/contracts';
+import type { Task } from '@cleocode/contracts';
 import type { DataAccessor } from '../data-accessor.js';
 import { resetDbState } from '../sqlite.js';
 import { createSqliteDataAccessor } from '../sqlite-data-accessor.js';
@@ -59,11 +59,11 @@ export async function createTestDb(): Promise<TestDbEnv> {
 }
 
 /**
- * Build a TaskFile structure from a list of task partials.
+ * Build full Task objects from a list of task partials.
  * Useful for seeding test data via accessor.upsertSingleTask().
  */
-export function makeTaskFile(tasks: Array<Partial<Task> & { id: string }>): TaskFile {
-  const fullTasks: Task[] = tasks.map(
+export function makeTasks(tasks: Array<Partial<Task> & { id: string }>): Task[] {
+  return tasks.map(
     (t) =>
       ({
         title: t.title ?? `Task ${t.id}`,
@@ -74,18 +74,6 @@ export function makeTaskFile(tasks: Array<Partial<Task> & { id: string }>): Task
         ...t,
       }) as Task,
   );
-
-  return {
-    version: '2.10.0',
-    project: { name: 'test', phases: {} },
-    lastUpdated: new Date().toISOString(),
-    _meta: {
-      schemaVersion: '2.10.0',
-      checksum: '0000000000000000',
-      configVersion: '1.0.0',
-    },
-    tasks: fullTasks,
-  };
 }
 
 /**
@@ -108,8 +96,7 @@ export async function seedTasks(
   }
 
   // Build full Task objects from partials
-  const tf = makeTaskFile(tasks);
-  const fullTasks = tf.tasks;
+  const fullTasks = makeTasks(tasks);
 
   // Pass 1: Upsert all tasks without dependencies so FK targets exist
   for (const task of fullTasks) {

package/src/store/chain-schema.ts

@@ -46,7 +46,7 @@ export const warpChainInstances = sqliteTable(
     id: text('id').primaryKey(),
     chainId: text('chain_id')
       .notNull()
-      .references(() => warpChains.id),
+      .references(() => warpChains.id, { onDelete: 'cascade' }),
     epicId: text('epic_id').notNull(),
     variables: text('variables'), // JSON
     stageToTask: text('stage_to_task'), // JSON