@cleocode/core 2026.3.43 → 2026.3.45

package/src/skills/orchestrator/__tests__/spawn-tier.test.ts

@@ -29,6 +29,22 @@ vi.mock('../../discovery.js', () => ({
   mapSkillName: vi.fn(() => ({ canonical: 'task-executor', mapped: true })),
 }));
 
+vi.mock('../../../store/data-accessor.js', () => ({
+  getAccessor: vi.fn().mockResolvedValue({
+    loadSingleTask: vi.fn().mockResolvedValue({
+      id: 'T100',
+      title: 'Test task',
+      status: 'active',
+      description: 'A test',
+      priority: 'medium',
+      labels: [],
+      depends: [],
+    }),
+    loadTasks: vi.fn().mockResolvedValue([]),
+    queryTasks: vi.fn().mockResolvedValue({ tasks: [], total: 0 }),
+  }),
+}));
+
 import { existsSync, readFileSync } from 'node:fs';
 import { findSkill } from '../../discovery.js';
 import { injectProtocol, orchestratorSpawnSkill } from '../../injection/subagent.js';
@@ -67,7 +83,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     } as any);
   });
 
-  it('passes tier 0 through — output excludes standard and orchestrator', () => {
+  it('passes tier 0 through — output excludes standard and orchestrator', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
@@ -75,7 +91,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
       return '';
     });
 
-    const result = orchestratorSpawnSkill(
+    const result = await orchestratorSpawnSkill(
       'T100',
       'test-skill',
       { TASK_ID: 'T100' },
@@ -89,7 +105,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     expect(result).toContain('Test Skill');
   });
 
-  it('passes tier 1 through — output includes minimal + standard', () => {
+  it('passes tier 1 through — output includes minimal + standard', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
@@ -97,7 +113,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
       return '';
     });
 
-    const result = orchestratorSpawnSkill(
+    const result = await orchestratorSpawnSkill(
       'T100',
       'test-skill',
       { TASK_ID: 'T100' },
@@ -110,7 +126,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     expect(result).not.toContain('Orchestrator Section');
   });
 
-  it('passes tier 2 through — output includes all tiers', () => {
+  it('passes tier 2 through — output includes all tiers', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
@@ -118,7 +134,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
       return '';
     });
 
-    const result = orchestratorSpawnSkill(
+    const result = await orchestratorSpawnSkill(
       'T100',
       'test-skill',
       { TASK_ID: 'T100' },
@@ -131,7 +147,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     expect(result).toContain('Orchestrator Section');
   });
 
-  it('omitting tier includes full protocol (backward compat)', () => {
+  it('omitting tier includes full protocol (backward compat)', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
@@ -140,7 +156,7 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     });
 
     // No tier parameter — should pass through unfiltered
-    const result = orchestratorSpawnSkill(
+    const result = await orchestratorSpawnSkill(
       'T100',
       'test-skill',
       { TASK_ID: 'T100' },
@@ -153,12 +169,12 @@ describe('orchestratorSpawnSkill tier passthrough', () => {
     expect(result).toContain('TIER:orchestrator');
   });
 
-  it('throws when skill not found', () => {
+  it('throws when skill not found', async () => {
     vi.mocked(findSkill).mockReturnValue(null);
 
-    expect(() => {
-      orchestratorSpawnSkill('T100', 'nonexistent', { TASK_ID: 'T100' }, '/mock/project', 0);
-    }).toThrow(/Skill not found/);
+    await expect(
+      orchestratorSpawnSkill('T100', 'nonexistent', { TASK_ID: 'T100' }, '/mock/project', 0),
+    ).rejects.toThrow(/Skill not found/);
   });
 });
 
@@ -168,29 +184,27 @@ describe('injectProtocol tier parameter', () => {
     vi.mocked(existsSync).mockReturnValue(true);
   });
 
-  it('tier undefined leaves protocol unfiltered', () => {
+  it('tier undefined leaves protocol unfiltered', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
-      if (p.includes('tasks.json')) return MOCK_TASKS_JSON;
       return '';
     });
 
-    const result = injectProtocol('# Skill', 'T100', {}, '/mock/project', undefined);
+    const result = await injectProtocol('# Skill', 'T100', {}, '/mock/project', undefined);
 
     expect(result).toContain('TIER:minimal');
     expect(result).toContain('TIER:orchestrator');
   });
 
-  it('tier 0 filters to minimal only', () => {
+  it('tier 0 filters to minimal only', async () => {
     vi.mocked(readFileSync).mockImplementation((path: unknown) => {
       const p = String(path);
       if (p.includes('subagent-protocol-base')) return TIERED_PROTOCOL;
-      if (p.includes('tasks.json')) return MOCK_TASKS_JSON;
       return '';
     });
 
-    const result = injectProtocol('# Skill', 'T100', {}, '/mock/project', 0);
+    const result = await injectProtocol('# Skill', 'T100', {}, '/mock/project', 0);
 
     expect(result).toContain('Minimal Section');
     expect(result).not.toContain('Standard Section');
@@ -218,43 +232,43 @@ describe('buildPrompt tier passthrough', () => {
     } as any);
   });
 
-  it('buildPrompt with tier 0 filters protocol to minimal only', () => {
-    const result = buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 0);
+  it('buildPrompt with tier 0 filters protocol to minimal only', async () => {
+    const result = await buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 0);
     expect(result.prompt).toContain('Minimal Section');
     expect(result.prompt).not.toContain('Standard Section');
     expect(result.prompt).not.toContain('Orchestrator Section');
     expect(result.prompt).toContain('SUBAGENT PROTOCOL');
   });
 
-  it('buildPrompt with tier 1 includes minimal + standard', () => {
-    const result = buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 1);
+  it('buildPrompt with tier 1 includes minimal + standard', async () => {
+    const result = await buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 1);
     expect(result.prompt).toContain('Minimal Section');
     expect(result.prompt).toContain('Standard Section');
     expect(result.prompt).not.toContain('Orchestrator Section');
   });
 
-  it('buildPrompt without tier includes full protocol', () => {
-    const result = buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project');
+  it('buildPrompt without tier includes full protocol', async () => {
+    const result = await buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project');
     // No tier = unfiltered, so tier markers present
     expect(result.prompt).toContain('TIER:minimal');
     expect(result.prompt).toContain('TIER:orchestrator');
   });
 
-  it('buildPrompt injects task context', () => {
-    const result = buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 0);
+  it('buildPrompt injects task context', async () => {
+    const result = await buildPrompt('T100', 'TASK-EXECUTOR', '/mock/project', 0);
     expect(result.prompt).toContain('Task Context');
     expect(result.prompt).toContain('T100');
   });
 
-  it('spawn passes tier through', () => {
-    const result = spawn('T100', 'TASK-EXECUTOR', '/mock/project', 0);
+  it('spawn passes tier through', async () => {
+    const result = await spawn('T100', 'TASK-EXECUTOR', '/mock/project', 0);
     expect(result.prompt).toContain('Minimal Section');
     expect(result.prompt).not.toContain('Orchestrator Section');
     expect(result.spawnTimestamp).toBeDefined();
   });
 
-  it('spawnBatch passes tier through', () => {
-    const result = spawnBatch(['T100'], 'TASK-EXECUTOR', '/mock/project', 0);
+  it('spawnBatch passes tier through', async () => {
+    const result = await spawnBatch(['T100'], 'TASK-EXECUTOR', '/mock/project', 0);
     expect(result.succeeded).toBe(1);
     expect(result.spawns[0].result!.prompt).toContain('Minimal Section');
     expect(result.spawns[0].result!.prompt).not.toContain('Orchestrator Section');

package/src/skills/orchestrator/spawn.ts

@@ -12,11 +12,11 @@
  * @task T4519
  */
 
-import { existsSync, readFileSync } from 'node:fs';
 import type { Task } from '@cleocode/contracts';
 import { ExitCode } from '@cleocode/contracts';
 import { CleoError } from '../../errors.js';
-import { getAgentOutputsDir, getTaskPath } from '../../paths.js';
+import { getAgentOutputsDir } from '../../paths.js';
+import { getAccessor } from '../../store/data-accessor.js';
 import { findSkill, mapSkillName } from '../discovery.js';
 import { injectProtocol } from '../injection/subagent.js';
 import type { TokenValues } from '../injection/token.js';
@@ -30,22 +30,14 @@ import type { SpawnPromptResult } from '../types.js';
  * Build a fully-resolved prompt for spawning a subagent.
  * @task T4519
  */
-export function buildPrompt(
+export async function buildPrompt(
   taskId: string,
   templateName: string = 'TASK-EXECUTOR',
   cwd?: string,
   tier?: 0 | 1 | 2,
-): SpawnPromptResult {
-  const taskPath = getTaskPath(cwd);
-
-  if (!existsSync(taskPath)) {
-    throw new CleoError(ExitCode.NOT_FOUND, 'Todo file not found. Run: cleo init');
-  }
-
-  // Load task
-  const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-  const tasks: Task[] = data.tasks ?? [];
-  const task = tasks.find((t) => t.id === taskId);
+): Promise<SpawnPromptResult> {
+  const acc = await getAccessor(cwd);
+  const task = await acc.loadSingleTask(taskId);
 
   if (!task) {
     throw new CleoError(ExitCode.NOT_FOUND, `Task ${taskId} not found`);
@@ -121,7 +113,7 @@ export function buildPrompt(
   }
 
   // Inject tokens and protocol into template
-  const promptContent = injectProtocol(skill.content, taskId, tokenValues, cwd, tier);
+  const promptContent = await injectProtocol(skill.content, taskId, tokenValues, cwd, tier);
 
   return {
     taskId,
@@ -138,13 +130,13 @@ export function buildPrompt(
  * Generate full spawn command with metadata.
  * @task T4519
  */
-export function spawn(
+export async function spawn(
   taskId: string,
   templateName: string = 'TASK-EXECUTOR',
   cwd?: string,
   tier?: 0 | 1 | 2,
-): SpawnPromptResult & { spawnTimestamp: string } {
-  const result = buildPrompt(taskId, templateName, cwd, tier);
+): Promise<SpawnPromptResult & { spawnTimestamp: string }> {
+  const result = await buildPrompt(taskId, templateName, cwd, tier);
 
   return {
     ...result,
@@ -156,25 +148,20 @@ export function spawn(
  * Check if tasks can be spawned in parallel (no inter-dependencies).
  * @task T4519
  */
-export function canParallelize(
+export async function canParallelize(
   taskIds: string[],
   cwd?: string,
-): {
+): Promise<{
   canParallelize: boolean;
   conflicts: Array<Pick<Task, 'id'> & { dependsOn: string[] }>;
   safeToSpawn: string[];
-} {
+}> {
   if (taskIds.length === 0) {
     return { canParallelize: true, conflicts: [], safeToSpawn: [] };
   }
 
-  const taskPath = getTaskPath(cwd);
-  if (!existsSync(taskPath)) {
-    return { canParallelize: true, conflicts: [], safeToSpawn: taskIds };
-  }
-
-  const data = JSON.parse(readFileSync(taskPath, 'utf-8'));
-  const tasks: Task[] = data.tasks ?? [];
+  const acc = await getAccessor(cwd);
+  const tasks = await acc.loadTasks(taskIds);
   const taskIdSet = new Set(taskIds);
 
   const conflicts: Array<Pick<Task, 'id'> & { dependsOn: string[] }> = [];
@@ -229,17 +216,17 @@ export interface BatchSpawnResult {
  * @task T4712
  * @epic T4663
  */
-export function spawnBatch(
+export async function spawnBatch(
   taskIds: string[],
   templateName?: string,
   cwd?: string,
   tier?: 0 | 1 | 2,
-): BatchSpawnResult {
+): Promise<BatchSpawnResult> {
   const spawns: BatchSpawnEntry[] = [];
 
   for (const taskId of taskIds) {
     try {
-      const result = spawn(taskId, templateName, cwd, tier);
+      const result = await spawn(taskId, templateName, cwd, tier);
       spawns.push({ taskId, success: true, result });
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err);

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
     }
   }