@cleocode/core 2026.9.7 → 2026.9.9

package/dist/store/tasks-sqlite.js

@@ -1,8 +1,10 @@
 /**
  * SQLite-backed task store operations.
  *
- * CRUD operations for tasks, dependencies, and relations backed by tasks.db.
+ * CRUD operations for tasks, dependencies, and relations backed by the project cleo.db.
  * Implements the same interface as the JSON store for StoreProvider compatibility.
+ * Every public operation captures canonical project scope before opening a handle;
+ * direct SQL, safety checks and accessor transactions retain that same ownership.
  *
  * @epic T4454
  * @task W1-T3
@@ -10,12 +12,20 @@
 import { ARCHIVE_REASON_TOMBSTONE, ArchiveReasonTombstoneError, ExitCode, isArchiveTombstoneAllowed, isStorableTaskId, } from '@cleocode/contracts';
 import { and, asc, count, eq, inArray, isNull, ne, sql } from 'drizzle-orm';
 import { CleoError } from '../errors.js';
+import { getProjectRoot, worktreeScope } from '../project-scope.js';
+import { applyAcPlan, planAcUpdate } from '../tasks/ac-table.js';
 import { rowToTask, taskToRow } from './converters.js';
 import { cleanupBrainRefsOnTaskDelete } from './cross-db-cleanup.js';
 import { safeCreateTask, safeDeleteTask, safeUpdateTask, } from './data-safety-central.js';
 import { parseLabels, updateTaskLabels } from './db-helpers.js';
 import { getDb, getNativeDb } from './sqlite.js';
+import { captureTaskAccessorScope, createSqliteDataAccessor } from './sqlite-data-accessor.js';
 import * as schema from './tasks-schema.js';
+/** Capture one legacy operation before opening a handle or crossing an await. */
+function inTaskStoreScope(cwd, operation) {
+    const scope = captureTaskAccessorScope(cwd ?? getProjectRoot(), worktreeScope.getStore());
+    return worktreeScope.run(scope, () => operation(scope.worktreeRoot));
+}
 // === CRUD OPERATIONS ===
 /** Insert a task row directly. Internal use only — call createTask for the safe path. */
 async function insertTaskRow(task, cwd) {
@@ -34,168 +44,156 @@ async function insertTaskRow(task, cwd) {
         });
     }
     const db = await getDb(cwd);
-    const row = taskToRow(task);
-    db.insert(schema.tasks).values(row).run();
-    // Insert dependencies
-    if (task.depends && task.depends.length > 0) {
-        for (const depId of task.depends) {
+    const accessor = await createSqliteDataAccessor(cwd);
+    return accessor.transaction(async (tx) => {
+        const row = taskToRow(task);
+        // Retain INSERT's collision rejection rather than converting creation to
+        // an upsert that could overwrite a concurrently-created identity.
+        db.insert(schema.tasks).values(row).run();
+        for (const depId of task.depends ?? []) {
             db.insert(schema.taskDependencies).values({ taskId: task.id, dependsOn: depId }).run();
         }
-    }
-    // T11356: keep the task_labels junction in sync with labels_json.
-    await updateTaskLabels(db, task.id, parseLabels(row.labelsJson));
-    return task;
+        await updateTaskLabels(db, task.id, parseLabels(row.labelsJson));
+        if (task.acceptance !== undefined) {
+            await applyAcPlan(tx, task.id, planAcUpdate(task.id, [], task.acceptance));
+        }
+        for (const relation of task.relates ?? []) {
+            await tx.addRelation(task.id, relation.taskId, relation.type, relation.reason);
+        }
+        return task;
+    });
 }
 /** Get a task by ID, including its dependencies. */
 export async function getTask(taskId, cwd) {
-    const db = await getDb(cwd);
-    const rows = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
-    if (rows.length === 0)
-        return null;
-    const task = rowToTask(rows[0]);
-    // Load dependencies
-    const deps = await db
-        .select()
-        .from(schema.taskDependencies)
-        .where(eq(schema.taskDependencies.taskId, taskId))
-        .all();
-    if (deps.length > 0) {
-        task.depends = deps.map((d) => d.dependsOn);
-    }
-    return task;
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const rows = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
+        if (rows.length === 0)
+            return null;
+        const task = rowToTask(rows[0]);
+        // Load dependencies
+        const deps = await db
+            .select()
+            .from(schema.taskDependencies)
+            .where(eq(schema.taskDependencies.taskId, taskId))
+            .all();
+        if (deps.length > 0) {
+            task.depends = deps.map((d) => d.dependsOn);
+        }
+        return task;
+    });
 }
 /** Update an existing task. */
 export async function updateTask(taskId, updates, cwd) {
-    const db = await getDb(cwd);
-    const existing = await getTask(taskId, cwd);
-    if (!existing)
-        return null;
-    // Build update object (only changed fields)
-    const updateRow = {
-        updatedAt: new Date().toISOString(),
-    };
-    if (updates.title !== undefined)
-        updateRow.title = updates.title;
-    if (updates.description !== undefined)
-        updateRow.description = updates.description;
-    if (updates.status !== undefined) {
-        updateRow.status = updates.status;
-        // Clear stale timestamps when status resets to non-terminal state
-        if (updates.status === 'pending' || updates.status === 'active') {
-            if (updates.cancelledAt === undefined)
-                updateRow.cancelledAt = null;
-            if (updates.completedAt === undefined)
-                updateRow.completedAt = null;
+    return inTaskStoreScope(cwd, async (cwd) => {
+        if (updates.id !== undefined && updates.id !== taskId) {
+            throw new CleoError(ExitCode.INVALID_INPUT, 'A task update cannot change its identity');
         }
-    }
-    if (updates.priority !== undefined)
-        updateRow.priority = updates.priority;
-    if (updates.type !== undefined)
-        updateRow.type = updates.type;
-    if (updates.parentId !== undefined)
-        updateRow.parentId = updates.parentId;
-    if (updates.phase !== undefined)
-        updateRow.phase = updates.phase;
-    if (updates.size !== undefined)
-        updateRow.size = updates.size;
-    if (updates.position !== undefined)
-        updateRow.position = updates.position;
-    if (updates.labels !== undefined)
-        updateRow.labelsJson = JSON.stringify(updates.labels);
-    if (updates.notes !== undefined)
-        updateRow.notesJson = JSON.stringify(updates.notes);
-    if (updates.acceptance !== undefined)
-        updateRow.acceptanceJson = JSON.stringify(updates.acceptance);
-    if (updates.files !== undefined)
-        updateRow.filesJson = JSON.stringify(updates.files);
-    if (updates.origin !== undefined)
-        updateRow.origin = updates.origin;
-    if (updates.blockedBy !== undefined)
-        updateRow.blockedBy = updates.blockedBy;
-    if (updates.epicLifecycle !== undefined)
-        updateRow.epicLifecycle = updates.epicLifecycle;
-    if (updates.completedAt !== undefined)
-        updateRow.completedAt = updates.completedAt;
-    if (updates.cancelledAt !== undefined)
-        updateRow.cancelledAt = updates.cancelledAt;
-    if (updates.cancellationReason !== undefined)
-        updateRow.cancellationReason = updates.cancellationReason;
-    if (updates.verification !== undefined)
-        updateRow.verificationJson = JSON.stringify(updates.verification);
-    if (updates.assignee !== undefined)
-        updateRow.assignee = updates.assignee;
-    db.update(schema.tasks).set(updateRow).where(eq(schema.tasks.id, taskId)).run();
-    // Update dependencies if provided
-    if (updates.depends !== undefined) {
-        db.delete(schema.taskDependencies).where(eq(schema.taskDependencies.taskId, taskId)).run();
-        for (const depId of updates.depends) {
-            db.insert(schema.taskDependencies).values({ taskId, dependsOn: depId }).run();
+        if (updates.gates !== undefined || updates.abortReason !== undefined) {
+            throw new CleoError(ExitCode.INVALID_INPUT, 'gates and abortReason are not persisted task fields');
         }
-    }
-    // T11356: keep the task_labels junction in sync when labels change.
-    if (updates.labels !== undefined) {
-        await updateTaskLabels(db, taskId, parseLabels(updateRow.labelsJson));
-    }
-    return getTask(taskId, cwd);
+        const accessor = await createSqliteDataAccessor(cwd);
+        return accessor.transaction(async (tx) => {
+            const existing = await getTask(taskId, cwd);
+            if (!existing)
+                return null;
+            const provided = { ...updates };
+            for (const [key, value] of Object.entries(provided)) {
+                if (value === undefined)
+                    Reflect.deleteProperty(provided, key);
+            }
+            const updated = {
+                ...existing,
+                ...provided,
+                id: taskId,
+                updatedAt: updates.updatedAt ?? new Date().toISOString(),
+            };
+            if (updates.status === 'pending' || updates.status === 'active') {
+                if (updates.cancelledAt === undefined)
+                    updated.cancelledAt = undefined;
+                if (updates.completedAt === undefined)
+                    updated.completedAt = undefined;
+            }
+            // The canonical Task converter is shared with add and rich update. Never
+            // maintain another partial field list that silently drops accepted values.
+            await tx.upsertSingleTask(updated);
+            if (updates.acceptance !== undefined) {
+                await applyAcPlan(tx, taskId, planAcUpdate(taskId, await tx.getAcRows(taskId), updates.acceptance));
+            }
+            if (updates.relates !== undefined) {
+                await tx.clearRelations(taskId);
+                for (const relation of updates.relates) {
+                    await tx.addRelation(taskId, relation.taskId, relation.type, relation.reason);
+                }
+            }
+            return getTask(taskId, cwd);
+        });
+    });
 }
 /** Delete a task by ID. */
 export async function deleteTask(taskId, cwd) {
-    const db = await getDb(cwd);
-    const existing = await db
-        .select({ id: schema.tasks.id })
-        .from(schema.tasks)
-        .where(eq(schema.tasks.id, taskId))
-        .all();
-    if (existing.length === 0)
-        return false;
-    db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
-    // T033 Part 4: Cross-DB cleanup — nullify brain.db soft FK refs to this task.
-    // Runs after deletion to avoid blocking the task delete path on brain errors.
-    void cleanupBrainRefsOnTaskDelete(taskId, cwd);
-    return true;
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const existing = await db
+            .select({ id: schema.tasks.id })
+            .from(schema.tasks)
+            .where(eq(schema.tasks.id, taskId))
+            .all();
+        if (existing.length === 0)
+            return false;
+        db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
+        // T033 Part 4: Cross-DB cleanup — nullify brain.db soft FK refs to this task.
+        // Runs after deletion to avoid blocking the task delete path on brain errors.
+        void cleanupBrainRefsOnTaskDelete(taskId, cwd);
+        return true;
+    });
 }
 /** List tasks with optional filters. */
 export async function listTasks(filters, cwd) {
-    const db = await getDb(cwd);
-    const conditions = [];
-    // Exclude archived by default
-    conditions.push(ne(schema.tasks.status, 'archived'));
-    if (filters?.status)
-        conditions.push(eq(schema.tasks.status, filters.status));
-    if (filters?.parentId !== undefined) {
-        if (filters.parentId === null) {
-            conditions.push(isNull(schema.tasks.parentId));
-        }
-        else {
-            conditions.push(eq(schema.tasks.parentId, filters.parentId));
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const conditions = [];
+        // Exclude archived by default
+        conditions.push(ne(schema.tasks.status, 'archived'));
+        if (filters?.status)
+            conditions.push(eq(schema.tasks.status, filters.status));
+        if (filters?.parentId !== undefined) {
+            if (filters.parentId === null) {
+                conditions.push(isNull(schema.tasks.parentId));
+            }
+            else {
+                conditions.push(eq(schema.tasks.parentId, filters.parentId));
+            }
         }
-    }
-    if (filters?.type)
-        conditions.push(eq(schema.tasks.type, filters.type));
-    if (filters?.phase)
-        conditions.push(eq(schema.tasks.phase, filters.phase));
-    const query = db
-        .select()
-        .from(schema.tasks)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(asc(schema.tasks.position), asc(schema.tasks.createdAt));
-    const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
-    // Load dependencies for all tasks
-    const tasks = rows.map(rowToTask);
-    await loadDependencies(tasks, cwd);
-    return tasks;
+        if (filters?.type)
+            conditions.push(eq(schema.tasks.type, filters.type));
+        if (filters?.phase)
+            conditions.push(eq(schema.tasks.phase, filters.phase));
+        const query = db
+            .select()
+            .from(schema.tasks)
+            .where(conditions.length > 0 ? and(...conditions) : undefined)
+            .orderBy(asc(schema.tasks.position), asc(schema.tasks.createdAt));
+        const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
+        // Load dependencies for all tasks
+        const tasks = rows.map(rowToTask);
+        await loadDependencies(tasks, cwd);
+        return tasks;
+    });
 }
 /** Find tasks by fuzzy text search. */
 export async function findTasks(query, limit = 20, cwd) {
-    const db = await getDb(cwd);
-    const pattern = `%${query}%`;
-    const rows = await db
-        .select()
-        .from(schema.tasks)
-        .where(and(ne(schema.tasks.status, 'archived'), sql `(${schema.tasks.id} LIKE ${pattern} OR ${schema.tasks.title} LIKE ${pattern} OR ${schema.tasks.description} LIKE ${pattern})`))
-        .limit(limit)
-        .all();
-    return rows.map(rowToTask);
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const pattern = `%${query}%`;
+        const rows = await db
+            .select()
+            .from(schema.tasks)
+            .where(and(ne(schema.tasks.status, 'archived'), sql `(${schema.tasks.id} LIKE ${pattern} OR ${schema.tasks.title} LIKE ${pattern} OR ${schema.tasks.description} LIKE ${pattern})`))
+            .limit(limit)
+            .all();
+        return rows.map(rowToTask);
+    });
 }
 /**
  * Archive a task (sets status to 'archived' with metadata).
@@ -207,58 +205,60 @@ export async function findTasks(query, limit = 20, cwd) {
  * to `'completed-unverified'` to preserve forward compat.
  */
 export async function archiveTask(taskId, reason, cwd) {
-    const db = await getDb(cwd);
-    const task = await getTask(taskId, cwd);
-    if (!task)
-        return false;
-    const now = new Date().toISOString();
-    const cycleTime = task.createdAt
-        ? Math.floor((Date.now() - new Date(task.createdAt).getTime()) / (1000 * 60 * 60 * 24))
-        : null;
-    // Normalize any caller-supplied legacy reason ('completed', 'deleted',
-    // arbitrary strings) into the T1408 enum. NULL stays NULL via undefined.
-    //
-    // T1409: enforce the tombstone guard. Direct callers MAY NOT write the
-    // tombstone value `'completed-unverified'` unless the migration-backfill
-    // env flag is set. The fallback when no reason is supplied still maps to
-    // the tombstone (since DB CHECK requires one of the 6 enum values), but
-    // explicit caller-supplied tombstones from non-migration code are rejected.
-    // T11578 · AC1: the consolidated `tasks_tasks.archive_reason` column is
-    // CHECK-backed by the T1408 enum, so the writer must produce a value typed as
-    // `ArchiveReasonValue` (the prefixed schema narrows the column type). The
-    // normalization already only ever yields canonical enum values; the explicit
-    // return type makes that guarantee visible to the drizzle `.set()` overload.
-    const normalizedReason = (() => {
-        if (!reason)
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const task = await getTask(taskId, cwd);
+        if (!task)
+            return false;
+        const now = new Date().toISOString();
+        const cycleTime = task.createdAt
+            ? Math.floor((Date.now() - new Date(task.createdAt).getTime()) / (1000 * 60 * 60 * 24))
+            : null;
+        // Normalize any caller-supplied legacy reason ('completed', 'deleted',
+        // arbitrary strings) into the T1408 enum. NULL stays NULL via undefined.
+        //
+        // T1409: enforce the tombstone guard. Direct callers MAY NOT write the
+        // tombstone value `'completed-unverified'` unless the migration-backfill
+        // env flag is set. The fallback when no reason is supplied still maps to
+        // the tombstone (since DB CHECK requires one of the 6 enum values), but
+        // explicit caller-supplied tombstones from non-migration code are rejected.
+        // T11578 · AC1: the consolidated `tasks_tasks.archive_reason` column is
+        // CHECK-backed by the T1408 enum, so the writer must produce a value typed as
+        // `ArchiveReasonValue` (the prefixed schema narrows the column type). The
+        // normalization already only ever yields canonical enum values; the explicit
+        // return type makes that guarantee visible to the drizzle `.set()` overload.
+        const normalizedReason = (() => {
+            if (!reason)
+                return ARCHIVE_REASON_TOMBSTONE;
+            const valid = new Set([
+                'verified',
+                'reconciled',
+                'superseded',
+                'shadowed',
+                'cancelled',
+                ARCHIVE_REASON_TOMBSTONE,
+            ]);
+            if (reason === ARCHIVE_REASON_TOMBSTONE && !isArchiveTombstoneAllowed()) {
+                throw new ArchiveReasonTombstoneError(taskId);
+            }
+            if (valid.has(reason))
+                return reason;
+            if (reason === 'deleted')
+                return 'cancelled';
             return ARCHIVE_REASON_TOMBSTONE;
-        const valid = new Set([
-            'verified',
-            'reconciled',
-            'superseded',
-            'shadowed',
-            'cancelled',
-            ARCHIVE_REASON_TOMBSTONE,
-        ]);
-        if (reason === ARCHIVE_REASON_TOMBSTONE && !isArchiveTombstoneAllowed()) {
-            throw new ArchiveReasonTombstoneError(taskId);
-        }
-        if (valid.has(reason))
-            return reason;
-        if (reason === 'deleted')
-            return 'cancelled';
-        return ARCHIVE_REASON_TOMBSTONE;
-    })();
-    db.update(schema.tasks)
-        .set({
-        status: 'archived',
-        archivedAt: now,
-        archiveReason: normalizedReason,
-        cycleTimeDays: cycleTime,
-        updatedAt: now,
-    })
-        .where(eq(schema.tasks.id, taskId))
-        .run();
-    return true;
+        })();
+        db.update(schema.tasks)
+            .set({
+            status: 'archived',
+            archivedAt: now,
+            archiveReason: normalizedReason,
+            cycleTimeDays: cycleTime,
+            updatedAt: now,
+        })
+            .where(eq(schema.tasks.id, taskId))
+            .run();
+        return true;
+    });
 }
 // === DEPENDENCY & RELATION OPERATIONS ===
 /** Load dependencies for a list of tasks. */
@@ -287,63 +287,74 @@ async function loadDependencies(tasks, cwd) {
 }
 /** Add a dependency between tasks. */
 export async function addDependency(taskId, dependsOn, cwd) {
-    const db = await getDb(cwd);
-    db.insert(schema.taskDependencies).values({ taskId, dependsOn }).onConflictDoNothing().run();
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        db.insert(schema.taskDependencies).values({ taskId, dependsOn }).onConflictDoNothing().run();
+    });
 }
 /** Remove a dependency. */
 export async function removeDependency(taskId, dependsOn, cwd) {
-    const db = await getDb(cwd);
-    db.delete(schema.taskDependencies)
-        .where(and(eq(schema.taskDependencies.taskId, taskId), eq(schema.taskDependencies.dependsOn, dependsOn)))
-        .run();
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        db.delete(schema.taskDependencies)
+            .where(and(eq(schema.taskDependencies.taskId, taskId), eq(schema.taskDependencies.dependsOn, dependsOn)))
+            .run();
+    });
 }
 /** Add a relation between tasks. */
 export async function addRelation(taskId, relatedTo, relationType = 'related', cwd, reason) {
-    const db = await getDb(cwd);
-    await db
-        .insert(schema.taskRelations)
-        .values({ taskId, relatedTo, relationType, reason: reason ?? null })
-        .onConflictDoNothing()
-        .run();
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        await db
+            .insert(schema.taskRelations)
+            .values({ taskId, relatedTo, relationType, reason: reason ?? null })
+            .onConflictDoNothing()
+            .run();
+    });
 }
 /** Remove a relation between tasks. */
 export async function removeRelation(taskId, relatedTo, relationType, cwd) {
-    const db = await getDb(cwd);
-    const conditions = [
-        eq(schema.taskRelations.taskId, taskId),
-        eq(schema.taskRelations.relatedTo, relatedTo),
-    ];
-    if (relationType !== undefined) {
-        conditions.push(eq(schema.taskRelations.relationType, relationType));
-    }
-    await db
-        .delete(schema.taskRelations)
-        .where(and(...conditions))
-        .run();
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const conditions = [
+            eq(schema.taskRelations.taskId, taskId),
+            eq(schema.taskRelations.relatedTo, relatedTo),
+        ];
+        if (relationType !== undefined) {
+            conditions.push(eq(schema.taskRelations.relationType, relationType));
+        }
+        await db
+            .delete(schema.taskRelations)
+            .where(and(...conditions))
+            .run();
+    });
 }
 /** Get relations for a task. */
 export async function getRelations(taskId, cwd) {
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.taskRelations)
-        .where(eq(schema.taskRelations.taskId, taskId))
-        .all();
-    return rows.map((r) => ({
-        relatedTo: r.relatedTo,
-        type: r.relationType,
-        reason: r.reason ?? undefined,
-    }));
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const rows = await db
+            .select()
+            .from(schema.taskRelations)
+            .where(eq(schema.taskRelations.taskId, taskId))
+            .all();
+        return rows.map((r) => ({
+            relatedTo: r.relatedTo,
+            type: r.relationType,
+            reason: r.reason ?? undefined,
+        }));
+    });
 }
 // === GRAPH OPERATIONS ===
 /** Get the dependency chain (blockers) for a task using recursive CTE. */
 export async function getBlockerChain(taskId, cwd) {
-    await getDb(cwd);
-    const nativeDb = getNativeDb(cwd);
-    if (!nativeDb)
-        return [];
-    const result = nativeDb
-        .prepare(`
+    return inTaskStoreScope(cwd, async (cwd) => {
+        await getDb(cwd);
+        const nativeDb = getNativeDb(cwd);
+        if (!nativeDb)
+            return [];
+        const result = nativeDb
+            .prepare(`
     WITH RECURSIVE blocker_chain(id) AS (
       SELECT depends_on FROM tasks_task_dependencies WHERE task_id = ?
       UNION
@@ -352,86 +363,105 @@ export async function getBlockerChain(taskId, cwd) {
     )
     SELECT id FROM blocker_chain
   `)
-        .all(taskId);
-    return result.map((r) => r.id);
+            .all(taskId);
+        return result.map((r) => r.id);
+    });
 }
 /** Get children of a task (hierarchy). */
 export async function getChildren(parentId, cwd) {
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.tasks)
-        .where(eq(schema.tasks.parentId, parentId))
-        .orderBy(asc(schema.tasks.position), asc(schema.tasks.createdAt))
-        .all();
-    return rows.map(rowToTask);
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const rows = await db
+            .select()
+            .from(schema.tasks)
+            .where(eq(schema.tasks.parentId, parentId))
+            .orderBy(asc(schema.tasks.position), asc(schema.tasks.createdAt))
+            .all();
+        return rows.map(rowToTask);
+    });
 }
 /** Build a tree from a root task using recursive CTE. */
 export async function getSubtree(rootId, cwd) {
-    await getDb(cwd);
-    const nativeDb = getNativeDb(cwd);
-    if (!nativeDb)
-        return [];
-    const rows = nativeDb
-        .prepare(`
+    return inTaskStoreScope(cwd, async (cwd) => {
+        await getDb(cwd);
+        const nativeDb = getNativeDb(cwd);
+        if (!nativeDb)
+            return [];
+        const rows = nativeDb
+            .prepare(`
+    -- T12307: UNION, not UNION ALL — see getAncestorChain in
+    -- sqlite-data-accessor.ts. A self-parented row recurses forever under
+    -- UNION ALL; every column repeats verbatim on a revisit, so the dedupe
+    -- terminates it without dropping any legitimate descendant.
     WITH RECURSIVE subtree AS (
       SELECT * FROM tasks_tasks WHERE id = ?
-      UNION ALL
+      UNION
       SELECT t.* FROM tasks_tasks t
       JOIN subtree s ON t.parent_id = s.id
     )
     SELECT * FROM subtree
   `)
-        .all(rootId);
-    return rows.map(rowToTask);
+            .all(rootId);
+        return rows.map(rowToTask);
+    });
 }
 /** Count tasks by status. */
 export async function countByStatus(cwd) {
-    const db = await getDb(cwd);
-    const rows = await db
-        .select({
-        status: schema.tasks.status,
-        count: count(),
-    })
-        .from(schema.tasks)
-        .where(ne(schema.tasks.status, 'archived'))
-        .groupBy(schema.tasks.status)
-        .all();
-    const result = {};
-    for (const row of rows) {
-        result[row.status] = row.count;
-    }
-    return result;
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const rows = await db
+            .select({
+            status: schema.tasks.status,
+            count: count(),
+        })
+            .from(schema.tasks)
+            .where(ne(schema.tasks.status, 'archived'))
+            .groupBy(schema.tasks.status)
+            .all();
+        const result = {};
+        for (const row of rows) {
+            result[row.status] = row.count;
+        }
+        return result;
+    });
 }
 /** Get total task count (excluding archived). */
 export async function countTasks(cwd) {
-    const db = await getDb(cwd);
-    const result = await db
-        .select({ count: count() })
-        .from(schema.tasks)
-        .where(ne(schema.tasks.status, 'archived'))
-        .get();
-    return result?.count ?? 0;
+    return inTaskStoreScope(cwd, async (cwd) => {
+        const db = await getDb(cwd);
+        const result = await db
+            .select({ count: count() })
+            .from(schema.tasks)
+            .where(ne(schema.tasks.status, 'archived'))
+            .get();
+        return result?.count ?? 0;
+    });
 }
 /**
  * Create a task with full safety protections.
  * Includes: collision detection, write verification, sequence validation, auto-checkpoint.
  */
 export async function createTask(task, cwd, config) {
-    return safeCreateTask(() => insertTaskRow(task, cwd), task, cwd, config);
+    return inTaskStoreScope(cwd, async (cwd) => {
+        return safeCreateTask(() => insertTaskRow(task, cwd), task, cwd, config);
+    });
 }
 /**
  * Update a task with full safety protections.
  * Includes: write verification, auto-checkpoint.
  */
 export async function updateTaskSafe(taskId, updates, cwd, config) {
-    return safeUpdateTask(() => updateTask(taskId, updates, cwd), taskId, updates, cwd, config);
+    return inTaskStoreScope(cwd, async (cwd) => {
+        return safeUpdateTask(() => updateTask(taskId, updates, cwd), taskId, updates, cwd, config);
+    });
 }
 /**
  * Delete a task with full safety protections.
  * Includes: delete verification, auto-checkpoint.
  */
 export async function deleteTaskSafe(taskId, cwd, config) {
-    return safeDeleteTask(() => deleteTask(taskId, cwd), taskId, cwd, config);
+    return inTaskStoreScope(cwd, async (cwd) => {
+        return safeDeleteTask(() => deleteTask(taskId, cwd), taskId, cwd, config);
+    });
 }
 //# sourceMappingURL=tasks-sqlite.js.map