@cleocode/core 2026.3.43 → 2026.3.44

package/src/nexus/discover.ts

@@ -104,6 +104,7 @@ const STOP_WORDS = new Set([
  */
 export function extractKeywords(text: string): string[] {
   return text
+    .toLowerCase()
     .replace(/[^a-z0-9\s-]/g, ' ')
     .split(/\s+/)
     .filter((w) => w.length > 2 && !STOP_WORDS.has(w));

package/src/orchestration/bootstrap.ts

@@ -7,7 +7,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { BrainState } from '@cleocode/contracts';
-import { getSessionsPath } from '../paths.js';
 import type { DataAccessor } from '../store/data-accessor.js';
 import { getAccessor } from '../store/data-accessor.js';
 
@@ -26,29 +25,24 @@ export async function buildBrainState(
     },
   };
 
-  // --- Session (from sessions.json) ---
+  // --- Session (from SQLite, ADR-006/ADR-020) ---
+  const acc = accessor ?? (await getAccessor(projectRoot));
   try {
-    const sessionsPath = getSessionsPath(projectRoot);
-    if (existsSync(sessionsPath)) {
-      const sessionsData = JSON.parse(readFileSync(sessionsPath, 'utf-8'));
-      const activeSession = (sessionsData.sessions ?? []).find(
-        (s: { status: string }) => s.status === 'active',
-      );
-      if (activeSession) {
-        brain.session = {
-          id: activeSession.id,
-          name: activeSession.name || activeSession.id,
-          status: activeSession.status,
-          startedAt: activeSession.startedAt,
-        };
-      }
+    const sessions = await acc.loadSessions();
+    const activeSession = sessions.find((s) => s.status === 'active');
+    if (activeSession) {
+      brain.session = {
+        id: activeSession.id,
+        name: activeSession.name || activeSession.id,
+        status: activeSession.status,
+        startedAt: activeSession.startedAt,
+      };
     }
   } catch {
     // skip
   }
 
   // --- Tasks & Progress ---
-  const acc = accessor ?? (await getAccessor(projectRoot));
   const { tasks } = await acc.queryTasks({});
 
   brain.progress = {

package/src/orchestration/skill-ops.ts

@@ -25,52 +25,72 @@ export interface SkillContent {
   path: string;
 }
 
-/** List available skills. */
-export function listSkills(_projectRoot: string): { skills: SkillEntry[]; total: number } {
-  const skillsDir = getCanonicalSkillsDir();
+/** List available skills from canonical and project-local directories. */
+export function listSkills(projectRoot: string): { skills: SkillEntry[]; total: number } {
+  const seen = new Set<string>();
+  const allSkills: SkillEntry[] = [];
 
-  if (!existsSync(skillsDir)) {
-    return { skills: [], total: 0 };
-  }
+  // Scan a skills directory and collect entries
+  function scanSkillsDir(dir: string): void {
+    if (!existsSync(dir)) return;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const d of entries) {
+        if (!d.isDirectory() || d.name.startsWith('_') || seen.has(d.name)) continue;
+        seen.add(d.name);
+
+        const skillPath = join(dir, d.name, 'SKILL.md');
+        let description = '';
 
-  const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
-    .map((d) => {
-      const skillPath = join(skillsDir, d.name, 'SKILL.md');
-      let description = '';
-
-      if (existsSync(skillPath)) {
-        try {
-          const content = readFileSync(skillPath, 'utf-8');
-          const descMatch = content.match(/description:\s*[|>]?\s*\n?\s*(.+)/);
-          if (descMatch) {
-            description = descMatch[1]!.trim();
+        if (existsSync(skillPath)) {
+          try {
+            const content = readFileSync(skillPath, 'utf-8');
+            const descMatch = content.match(/description:\s*[|>]?\s*\n?\s*(.+)/);
+            if (descMatch) {
+              description = descMatch[1]!.trim();
+            }
+          } catch {
+            // ignore
           }
-        } catch {
-          // ignore
         }
+
+        allSkills.push({
+          name: d.name,
+          path: join(dir, d.name),
+          hasSkillFile: existsSync(skillPath),
+          description,
+        });
       }
+    } catch {
+      // ignore unreadable directories
+    }
+  }
 
-      return {
-        name: d.name,
-        path: join(skillsDir, d.name),
-        hasSkillFile: existsSync(skillPath),
-        description,
-      };
-    });
+  // 1. Scan project-local skills (higher priority, listed first)
+  scanSkillsDir(join(projectRoot, '.cleo', 'skills'));
 
-  return { skills: skillDirs, total: skillDirs.length };
+  // 2. Scan canonical (global) skills
+  scanSkillsDir(getCanonicalSkillsDir());
+
+  return { skills: allSkills, total: allSkills.length };
 }
 
-/** Read skill content for injection into agent context. */
-export function getSkillContent(skillName: string, _projectRoot: string): SkillContent {
+/** Read skill content for injection into agent context. Checks project-local skills first. */
+export function getSkillContent(skillName: string, projectRoot: string): SkillContent {
   if (!skillName) {
     throw new CleoError(ExitCode.INVALID_INPUT, 'skill name is required');
   }
 
-  const skillDir = join(getCanonicalSkillsDir(), skillName);
+  // Check project-local skills first, then canonical
+  const projectSkillDir = join(projectRoot, '.cleo', 'skills', skillName);
+  const canonicalSkillDir = join(getCanonicalSkillsDir(), skillName);
+  const skillDir = existsSync(projectSkillDir) ? projectSkillDir : canonicalSkillDir;
+
   if (!existsSync(skillDir)) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Skill '${skillName}' not found at ${skillDir}`);
+    throw new CleoError(
+      ExitCode.NOT_FOUND,
+      `Skill '${skillName}' not found at ${canonicalSkillDir} or ${projectSkillDir}`,
+    );
   }
 
   const skillFilePath = join(skillDir, 'SKILL.md');

package/src/otel/index.ts

@@ -125,14 +125,58 @@ export async function getOtelSpawns(opts: {
 }
 
 /** Get real token usage from Claude Code API. */
-export async function getRealTokenUsage(_opts: {
+export async function getRealTokenUsage(opts: {
   session?: string;
   since?: string;
 }): Promise<Record<string, unknown>> {
-  // Real token usage requires OTel integration - return placeholder
+  const otelEnabled = process.env.CLAUDE_CODE_ENABLE_TELEMETRY === '1';
+
+  // Read JSONL token data and filter by opts
+  const entries = readJsonlFile(getTokenFilePath());
+
+  if (entries.length === 0) {
+    return {
+      message: otelEnabled
+        ? 'OTel enabled but no token data recorded yet'
+        : 'Real token usage requires OpenTelemetry configuration',
+      otelEnabled,
+      totalEvents: 0,
+    };
+  }
+
+  let filtered = entries;
+
+  // Filter by session if provided
+  if (opts.session) {
+    filtered = filtered.filter((e) => {
+      const ctx = (e.context ?? {}) as Record<string, unknown>;
+      return ctx.session_id === opts.session || e.session_id === opts.session;
+    });
+  }
+
+  // Filter by since timestamp if provided
+  if (opts.since) {
+    const sinceDate = new Date(opts.since).getTime();
+    filtered = filtered.filter((e) => {
+      const ts = (e.timestamp ?? e.recorded_at) as string | undefined;
+      return ts ? new Date(ts).getTime() >= sinceDate : true;
+    });
+  }
+
+  const totalTokens = filtered.reduce((sum, e) => sum + ((e.estimated_tokens as number) ?? 0), 0);
+  const inputTokens = filtered.reduce((sum, e) => sum + ((e.input_tokens as number) ?? 0), 0);
+  const outputTokens = filtered.reduce((sum, e) => sum + ((e.output_tokens as number) ?? 0), 0);
+
   return {
-    message: 'Real token usage requires OpenTelemetry configuration',
-    otelEnabled: process.env.CLAUDE_CODE_ENABLE_TELEMETRY === '1',
+    otelEnabled,
+    totalEvents: filtered.length,
+    totalTokens,
+    inputTokens,
+    outputTokens,
+    filters: {
+      session: opts.session ?? null,
+      since: opts.since ?? null,
+    },
   };
 }
 

package/src/sessions/__tests__/briefing.test.ts

@@ -21,6 +21,12 @@ vi.mock('../handoff.js', () => ({
   getLastHandoff: vi.fn().mockResolvedValue(null),
 }));
 
+// Mock lifecycle pipeline — computePipelineStage dynamically imports this
+let mockPipeline: unknown = null;
+vi.mock('../../lifecycle/pipeline.js', () => ({
+  getPipeline: vi.fn().mockImplementation(() => Promise.resolve(mockPipeline)),
+}));
+
 import { getAccessor } from '../../store/data-accessor.js';
 import { computeBriefing } from '../briefing.js';
 
@@ -337,8 +343,28 @@ describe('computeBriefing scope filtering', () => {
     expect(briefing.currentTask!.title).toBe('Child 1');
   });
 
-  it('pipelineStage is included when metadata has lifecycle state', async () => {
-    setupMockAccessor(makeMockTasks(), { lifecycleState: 'implementation' });
+  it('pipelineStage is included when active lifecycle pipeline exists', async () => {
+    // Mock the lifecycle pipeline BEFORE calling computeBriefing
+    mockPipeline = { currentStage: 'implementation', status: 'active', isActive: true };
+
+    // Set up focus state pointing to a task that has a pipeline
+    const focus = { currentTask: 'T100', currentPhase: null };
+    const metaStore: Record<string, unknown> = { focus_state: focus };
+    const tasks = makeMockTasks();
+    const mockAccessor = {
+      loadSessions: vi.fn().mockResolvedValue([]),
+      queryTasks: vi.fn().mockResolvedValue({ tasks, total: tasks.length }),
+      getMetaValue: vi
+        .fn()
+        .mockImplementation((key: string) => Promise.resolve(metaStore[key] ?? null)),
+      setMetaValue: vi.fn().mockResolvedValue(undefined),
+      loadArchive: vi.fn().mockResolvedValue(null),
+      saveArchive: vi.fn().mockResolvedValue(undefined),
+      appendLog: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      engine: 'sqlite' as const,
+    };
+    (getAccessor as ReturnType<typeof vi.fn>).mockResolvedValue(mockAccessor);
 
     const briefing = await computeBriefing('/fake/project', {
       scope: 'global',
@@ -346,6 +372,9 @@ describe('computeBriefing scope filtering', () => {
 
     expect(briefing.pipelineStage).toBeDefined();
     expect(briefing.pipelineStage!.currentStage).toBe('implementation');
+
+    // Reset
+    mockPipeline = null;
   });
 
   it('blocked tasks include those with unresolved dependencies', async () => {

package/src/sessions/briefing.ts

@@ -17,13 +17,13 @@
  * @epic T4914
  */
 
-import type { FileMeta, TaskWorkState } from '@cleocode/contracts';
+import type { Task, TaskWorkState } from '@cleocode/contracts';
 import type { SessionMemoryContext } from '../memory/session-memory.js';
 import type { DataAccessor } from '../store/data-accessor.js';
 import { getAccessor } from '../store/data-accessor.js';
 import { depsReady } from '../tasks/deps-ready.js';
 import { getLastHandoff, type HandoffData } from './handoff.js';
-import type { TaskFileExt } from './types.js';
+import type { TaskWorkStateExt } from './types.js';
 
 /**
  * Task summary for briefing output.
@@ -138,15 +138,9 @@ export async function computeBriefing(
 ): Promise<SessionBriefing> {
   const accessor = await getAccessor(projectRoot);
   const { tasks } = await accessor.queryTasks({});
-  const focus = await accessor.getMetaValue<TaskWorkState>('focus_state');
-  const fileMeta = await accessor.getMetaValue<FileMeta>('file_meta');
-
-  // Build a TaskFileExt-compatible shape from targeted queries
-  const current = {
-    tasks,
-    focus: focus ?? undefined,
-    _meta: fileMeta ?? undefined,
-  } as unknown as TaskFileExt;
+  const focus = (await accessor.getMetaValue<TaskWorkState>('focus_state')) as
+    | TaskWorkStateExt
+    | undefined;
 
   // Build task map for quick lookups
   const taskMap = new Map(tasks.map((t) => [t.id, t]));
@@ -155,19 +149,16 @@ export async function computeBriefing(
   const scopeFilter = await parseScope(options.scope, accessor);
 
   // Compute in-scope task IDs (undefined = all tasks in scope)
-  const scopeTaskIds = getScopeTaskIdSet(
-    scopeFilter,
-    tasks as unknown as Array<{ id: string; parentId?: string; [key: string]: unknown }>,
-  );
+  const scopeTaskIds = getScopeTaskIdSet(scopeFilter, tasks);
 
   // 1. Last session handoff
   const lastSession = await computeLastSession(projectRoot, scopeFilter);
 
   // 2. Current active task
-  const currentTaskInfo = computeCurrentTask(current, taskMap);
+  const currentTaskInfo = computeCurrentTask(focus, taskMap);
 
   // 3. Next tasks (leverage-scored)
-  const nextTasks = computeNextTasks(tasks, taskMap, current, {
+  const nextTasks = computeNextTasks(tasks, taskMap, focus, {
     maxTasks: options.maxNextTasks ?? 5,
     scopeTaskIds,
   });
@@ -191,7 +182,7 @@ export async function computeBriefing(
   });
 
   // 7. Pipeline stage (optional - may not be available)
-  const pipelineStage = computePipelineStage(current);
+  const pipelineStage = await computePipelineStage(focus);
 
   // 8. Brain memory context (optional, best-effort)
   let memoryContext: SessionMemoryContext | undefined;
@@ -259,7 +250,7 @@ async function parseScope(
  */
 function getScopeTaskIdSet(
   scopeFilter: { type: 'global' | 'epic'; epicId?: string } | undefined,
-  tasks: Array<{ id: string; parentId?: string; [key: string]: unknown }>,
+  tasks: Task[],
 ): Set<string> | undefined {
   if (!scopeFilter || scopeFilter.type === 'global') {
     return undefined; // All tasks in scope
@@ -325,10 +316,10 @@ async function computeLastSession(
  * Compute current active task from task file.
  */
 function computeCurrentTask(
-  current: TaskFileExt,
+  focus: TaskWorkStateExt | undefined,
   taskMap: Map<string, unknown>,
 ): CurrentTaskInfo | null {
-  const focusTaskId = current.focus?.currentTask;
+  const focusTaskId = focus?.currentTask;
   if (!focusTaskId) return null;
 
   const task = taskMap.get(focusTaskId) as
@@ -376,7 +367,7 @@ function calculateLeverage(taskId: string, taskMap: Map<string, unknown>): numbe
 function computeNextTasks(
   tasks: unknown[],
   taskMap: Map<string, unknown>,
-  current: TaskFileExt,
+  focus: TaskWorkStateExt | undefined,
   options: { maxTasks: number; scopeTaskIds?: Set<string> },
 ): BriefingTask[] {
   const pendingTasks = tasks.filter((t) => {
@@ -387,7 +378,7 @@ function computeNextTasks(
   });
 
   const scored: BriefingTask[] = [];
-  const currentPhase = current.focus?.currentPhase;
+  const currentPhase = focus?.currentPhase;
 
   for (const task of pendingTasks) {
     const t = task as {
@@ -593,28 +584,22 @@ function calculateEpicCompletion(epicId: string, taskMap: Map<string, unknown>):
 /**
  * Compute pipeline stage info from task file metadata.
  */
-function computePipelineStage(current: TaskFileExt): PipelineStageInfo | undefined {
-  // Try to get from _meta or focus
-  const stage = (current._meta as Record<string, unknown>)?.pipelineStage as string | undefined;
-  const stageStatus = (current._meta as Record<string, unknown>)?.pipelineStageStatus as
-    | string
-    | undefined;
+async function computePipelineStage(
+  focus: TaskWorkStateExt | undefined,
+): Promise<PipelineStageInfo | undefined> {
+  const taskId = focus?.currentTask;
+  if (!taskId) return undefined;
 
-  if (stage) {
-    return {
-      currentStage: stage,
-      stageStatus: stageStatus || 'active',
-    };
-  }
+  try {
+    const { getPipeline } = await import('../lifecycle/pipeline.js');
+    const pipeline = await getPipeline(taskId);
+    if (!pipeline) return undefined;
 
-  // Try from lifecycle state if available
-  const lifecycleState = current._meta?.lifecycleState as string | undefined;
-  if (lifecycleState) {
     return {
-      currentStage: lifecycleState,
-      stageStatus: 'active',
+      currentStage: pipeline.currentStage,
+      stageStatus: pipeline.isActive ? 'active' : (pipeline.status ?? 'completed'),
     };
+  } catch {
+    return undefined;
   }
-
-  return undefined;
 }

package/src/sessions/handoff.ts

@@ -15,12 +15,11 @@
 
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import type { FileMeta, Session, TaskWorkState } from '@cleocode/contracts';
+import type { Session, Task } from '@cleocode/contracts';
 import { ExitCode } from '@cleocode/contracts';
 import { CleoError } from '../errors.js';
 import { getAccessor } from '../store/data-accessor.js';
 import { getDecisionLog } from './decisions.js';
-import type { TaskFileExt } from './types.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -77,15 +76,8 @@ export async function computeHandoff(
     throw new CleoError(ExitCode.SESSION_NOT_FOUND, `Session '${options.sessionId}' not found`);
   }
 
-  // Load task data for scope analysis
+  // Load tasks directly from SQLite via DataAccessor
   const { tasks } = await accessor.queryTasks({});
-  const focus = await accessor.getMetaValue<TaskWorkState>('focus_state');
-  const fileMeta = await accessor.getMetaValue<FileMeta>('file_meta');
-  const current = {
-    tasks,
-    focus: focus ?? undefined,
-    _meta: fileMeta ?? undefined,
-  } as unknown as TaskFileExt;
 
   // Get decisions recorded during this session
   const decisions = await getDecisionLog(projectRoot, { sessionId: options.sessionId });
@@ -97,9 +89,9 @@ export async function computeHandoff(
     tasksCompleted: session.tasksCompleted ?? [],
     tasksCreated: session.tasksCreated ?? [],
     decisionsRecorded: decisions.length,
-    nextSuggested: computeNextSuggested(session, current),
-    openBlockers: findOpenBlockers(current, session),
-    openBugs: findOpenBugs(current, session),
+    nextSuggested: computeNextSuggested(session, tasks),
+    openBlockers: findOpenBlockers(tasks, session),
+    openBugs: findOpenBugs(tasks, session),
   };
 
   // Apply human overrides
@@ -117,20 +109,15 @@ export async function computeHandoff(
  * Compute top-3 next suggested tasks.
  * Prioritizes uncompleted tasks within the session scope.
  */
-function computeNextSuggested(session: Session, current: TaskFileExt): string[] {
-  const suggestions: string[] = [];
-
-  if (!current.tasks) return suggestions;
-
+function computeNextSuggested(session: Session, tasks: Task[]): string[] {
   // Filter to tasks in scope
-  const scopeTaskIds = getScopeTaskIds(session, current);
+  const scopeTaskIds = getScopeTaskIds(session, tasks);
 
   // Get uncompleted tasks in scope
-  const pendingTasks = current.tasks.filter(
+  const pendingTasks = tasks.filter(
     (t) =>
       scopeTaskIds.has(t.id) &&
       t.status !== 'done' &&
-      t.status !== 'completed' &&
       t.status !== 'archived' &&
       t.status !== 'cancelled',
   );
@@ -145,11 +132,9 @@ function computeNextSuggested(session: Session, current: TaskFileExt): string[]
 
   pendingTasks.sort((a, b) => {
     const priorityDiff =
-      (priorityOrder[a.priority as string] ?? 99) - (priorityOrder[b.priority as string] ?? 99);
+      (priorityOrder[a.priority ?? 'medium'] ?? 99) - (priorityOrder[b.priority ?? 'medium'] ?? 99);
     if (priorityDiff !== 0) return priorityDiff;
-    const aCreated = typeof a.createdAt === 'string' ? a.createdAt : '1970-01-01T00:00:00Z';
-    const bCreated = typeof b.createdAt === 'string' ? b.createdAt : '1970-01-01T00:00:00Z';
-    return new Date(aCreated).getTime() - new Date(bCreated).getTime();
+    return (a.createdAt ?? '').localeCompare(b.createdAt ?? '');
   });
 
   // Take top 3
@@ -159,87 +144,68 @@ function computeNextSuggested(session: Session, current: TaskFileExt): string[]
 /**
  * Find tasks with blockers in the session scope.
  */
-function findOpenBlockers(current: TaskFileExt, session: Session): string[] {
-  const blockers: string[] = [];
-
-  if (!current.tasks) return blockers;
-
-  const scopeTaskIds = getScopeTaskIds(session, current);
+function findOpenBlockers(tasks: Task[], session: Session): string[] {
+  const scopeTaskIds = getScopeTaskIds(session, tasks);
 
-  // Find blocked tasks in scope
-  const blockedTasks = current.tasks.filter(
-    (t) => scopeTaskIds.has(t.id) && t.status === 'blocked',
-  );
-
-  return blockedTasks.map((t) => t.id);
+  return tasks.filter((t) => scopeTaskIds.has(t.id) && t.status === 'blocked').map((t) => t.id);
 }
 
 /**
  * Find open bugs in the session scope.
  */
-function findOpenBugs(current: TaskFileExt, session: Session): string[] {
-  const bugs: string[] = [];
-
-  if (!current.tasks) return bugs;
-
-  const scopeTaskIds = getScopeTaskIds(session, current);
-
-  // Find bug-type tasks that aren't closed
-  const bugTasks = current.tasks.filter(
-    (t) =>
-      scopeTaskIds.has(t.id) &&
-      (t.type === 'bug' ||
-        (Array.isArray(t.labels) && t.labels.some((l: string) => l === 'bug'))) &&
-      t.status !== 'done' &&
-      t.status !== 'completed' &&
-      t.status !== 'archived' &&
-      t.status !== 'cancelled',
-  );
-
-  return bugTasks.map((t) => t.id);
+function findOpenBugs(tasks: Task[], session: Session): string[] {
+  const scopeTaskIds = getScopeTaskIds(session, tasks);
+
+  return tasks
+    .filter(
+      (t) =>
+        scopeTaskIds.has(t.id) &&
+        (t.labels ?? []).includes('bug') &&
+        t.status !== 'done' &&
+        t.status !== 'archived' &&
+        t.status !== 'cancelled',
+    )
+    .map((t) => t.id);
 }
 
 /**
  * Get set of task IDs within the session scope.
  */
-function getScopeTaskIds(session: Session, current: TaskFileExt): Set<string> {
+function getScopeTaskIds(session: Session, tasks: Task[]): Set<string> {
   const taskIds = new Set<string>();
 
-  if (!current.tasks) return taskIds;
-
   if (session.scope.type === 'global') {
-    // Global scope: all tasks
-    for (const t of current.tasks) {
+    for (const t of tasks) {
       taskIds.add(t.id);
     }
-  } else {
-    // Epic/task scope: root task and descendants
-    // Prefer rootTaskId (engine-layer), fall back to epicId (core-layer)
-    const rootId = session.scope.rootTaskId ?? session.scope.epicId;
-    if (!rootId) {
-      // No root ID, fall back to global
-      for (const t of current.tasks) {
-        taskIds.add(t.id);
-      }
-      return taskIds;
+    return taskIds;
+  }
+
+  // Epic/task scope: root task and descendants
+  const rootId = session.scope.rootTaskId ?? session.scope.epicId;
+  if (!rootId) {
+    // No root ID, fall back to global
+    for (const t of tasks) {
+      taskIds.add(t.id);
     }
+    return taskIds;
+  }
 
-    const addDescendants = (taskId: string) => {
-      taskIds.add(taskId);
-      current.tasks?.forEach((t) => {
-        if (t.parentId === taskId) {
-          addDescendants(t.id);
-        }
-      });
-    };
+  const addDescendants = (taskId: string) => {
+    taskIds.add(taskId);
+    for (const t of tasks) {
+      if (t.parentId === taskId) {
+        addDescendants(t.id);
+      }
+    }
+  };
 
-    addDescendants(rootId);
+  addDescendants(rootId);
 
-    // Include explicitTaskIds if present in scope
-    if (session.scope.explicitTaskIds) {
-      for (const id of session.scope.explicitTaskIds) {
-        taskIds.add(id);
-      }
+  // Include explicitTaskIds if present in scope
+  if (session.scope.explicitTaskIds) {
+    for (const id of session.scope.explicitTaskIds) {
+      taskIds.add(id);
     }
   }
 

package/src/sessions/index.ts

@@ -471,4 +471,8 @@ export { getSessionStats } from './session-stats.js';
 export { suspendSession } from './session-suspend.js';
 export { switchSession } from './session-switch.js';
 export { SessionView } from './session-view.js';
-export type { AssumptionRecord, DecisionRecord, TaskFileExt, TaskWorkStateExt } from './types.js';
+export type {
+  AssumptionRecord,
+  DecisionRecord,
+  TaskWorkStateExt,
+} from './types.js';