@cleocode/core 2026.9.8 → 2026.9.9

package/dist/store/sqlite-data-accessor.js

@@ -10,11 +10,16 @@
  *
  * @epic T4454
  */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { resolve } from 'node:path';
 import { ARCHIVE_REASON_TOMBSTONE, } from '@cleocode/contracts';
-import { and, eq, inArray, isNull, like, ne, notInArray, or, sql } from 'drizzle-orm';
+import { and, eq, getTableColumns, inArray, isNull, like, ne, notInArray, or, sql, } from 'drizzle-orm';
+import { captureProjectScope as captureTaskAccessorScope, getProjectRoot, worktreeScope, } from '../project-scope.js';
+import { withBackgroundOpCommitBoundary } from './background-ops.js';
 import { archivedTaskToRow, rowToSession, rowToTask, taskToRow } from './converters.js';
 import { cleanupBrainRefsOnSessionDelete } from './cross-db-cleanup.js';
-import { batchUpdateDependencies, loadDependenciesForTasks, loadRelationsForTasks, updateDependencies, upsertSession, upsertTask, } from './db-helpers.js';
+import { batchUpdateDependencies, loadDependenciesForTasks, loadRelationsForTasks, parseLabels, updateDependencies, updateTaskLabels, upsertSession, upsertTask, } from './db-helpers.js';
+import { tasksAuditLog } from './schema/cleo-project/audit.js';
 import { resolveCurrentSession } from './session-store.js';
 import { closeDb, getDb, getNativeTasksDb } from './sqlite.js';
 import { TERMINAL_TASK_STATUSES } from './status-registry.js';
@@ -36,46 +41,6 @@ function generateAuditLogId() {
     const rand = Math.random().toString(36).slice(2, 8);
     return `log-${epoch}-${rand}`;
 }
-/**
- * Run `fn` inside an outermost `BEGIN IMMEDIATE` transaction, wrapped
- * in {@link withWriteRetry} so SQLITE_BUSY contention is absorbed at the
- * transaction boundary rather than mid-statement.
- *
- * - Acquires a RESERVED lock immediately so concurrent writers queue
- *   politely (or fall through to retry after `busy_timeout` expires).
- * - Commits on success; rolls back on any thrown error before
- *   propagating it. If the thrown error is SQLITE_BUSY,
- *   {@link withWriteRetry} re-runs the WHOLE function (BEGIN included)
- *   after backoff — better-sqlite3 / node:sqlite forbids nesting
- *   `BEGIN IMMEDIATE` inside an open transaction, so retry MUST start
- *   from this outer boundary.
- *
- * DO NOT call this from inside an already-open transaction. For nested
- * writes use `accessor.transaction()` which uses SAVEPOINTs (T9814).
- *
- * @bug gh-391 — SQLITE_BUSY contention on parallel writes.
- * @task T9839
- */
-async function runInImmediateTx(nativeDb, fn) {
-    return withWriteRetry(async () => {
-        nativeDb.prepare('BEGIN IMMEDIATE').run();
-        try {
-            const result = await fn();
-            nativeDb.prepare('COMMIT').run();
-            return result;
-        }
-        catch (err) {
-            try {
-                nativeDb.prepare('ROLLBACK').run();
-            }
-            catch {
-                // Secondary rollback failures are non-fatal — propagate the original
-                // error which captures the actual cause.
-            }
-            throw err;
-        }
-    });
-}
 // ---- Schema meta helpers ----
 /** Read a JSON blob from the schema_meta table by key. */
 async function getMetaValue(cwd, key) {
@@ -94,8 +59,13 @@ async function getMetaValue(cwd, key) {
         return null;
     }
 }
-/** Write a JSON blob to the schema_meta table by key. */
+/** Write metadata through the same ownership queue as task mutations. */
 export async function setMetaValue(cwd, key, value) {
+    const accessor = await createSqliteDataAccessor(cwd);
+    await accessor.setMetaValue(key, value);
+}
+/** Write metadata while the caller owns the transaction. */
+async function writeMetaValue(cwd, key, value) {
     const db = await getDb(cwd);
     const json = JSON.stringify(value);
     await db
@@ -107,17 +77,125 @@ export async function setMetaValue(cwd, key, value) {
     })
         .run();
 }
+// One queue per shared native handle, independent of accessor identity. These
+// hold coordination state only; the ProjectStore remains the owner of handles.
+const taskTransactionQueue = new WeakMap();
+/** One lexical transaction lifetime; its queue serializes sibling savepoints. */
+class TaskTransactionScope {
+    native;
+    parent;
+    active = true;
+    pending = Promise.resolve();
+    constructor(native, parent) {
+        this.native = native;
+        this.parent = parent;
+    }
+    assertActive() {
+        if (!this.active)
+            throw new Error('Transaction scope has ended');
+    }
+}
+const taskTransactionContext = new AsyncLocalStorage();
+function activeTransactionScope(native) {
+    let scope = taskTransactionContext.getStore();
+    while (scope) {
+        if (!scope.active)
+            return undefined;
+        if (scope.native === native)
+            return scope;
+        scope = scope.parent;
+    }
+    return undefined;
+}
+/** Serialize committed effects with foreground writers without opening a SQL transaction. */
+async function scheduleTaskBackground(native, work) {
+    const previous = taskTransactionQueue.get(native) ?? Promise.resolve();
+    const released = Promise.withResolvers();
+    const tail = previous.then(() => released.promise);
+    taskTransactionQueue.set(native, tail);
+    await previous;
+    const scope = new TaskTransactionScope(native);
+    try {
+        return await taskTransactionContext.run(scope, work);
+    }
+    finally {
+        await scope.pending;
+        scope.active = false;
+        released.resolve();
+        if (taskTransactionQueue.get(native) === tail)
+            taskTransactionQueue.delete(native);
+    }
+}
+/**
+ * Compatible task-accessor name for the shared project ownership capture policy.
+ * @remarks This is the same function as `captureProjectScope`; identity validation
+ * and routing policy live in the dependency-leaf project scope module.
+ * @example
+ * ```ts
+ * const scope = captureTaskAccessorScope(getProjectRoot(), worktreeScope.getStore());
+ * ```
+ */
+export { captureProjectScope as captureTaskAccessorScope } from '../project-scope.js';
+/**
+ * Bind all asynchronous accessor methods, including transaction ports, to one project.
+ * @typeParam T - Concrete accessor contract retained by the scoped wrapper.
+ * @param accessor - Canonical, safety-wrapped, or transaction accessor to bind.
+ * @param scope - Immutable project scope captured at construction.
+ * @returns An accessor preserving method arguments, results and receiver semantics.
+ * @remarks The wrapper changes only worktree path scope. The existing transaction
+ * AsyncLocalStorage, savepoint queues and postcommit result semantics remain authoritative.
+ * A newly inherited execution cannot bypass a captured operation's cancellation or ownership.
+ * @example
+ * ```ts
+ * const bound = bindTaskAccessorScope(accessor, scope);
+ * await bound.upsertSingleTask(task);
+ * ```
+ */
+export function bindTaskAccessorScope(accessor, scope) {
+    return new Proxy(accessor, {
+        get(target, property) {
+            const value = target[property];
+            if (typeof value !== 'function')
+                return value;
+            return new Proxy(value, {
+                async apply(method, _receiver, args) {
+                    const activeExecution = worktreeScope.getStore()?.execution;
+                    if (scope.execution && activeExecution && scope.execution !== activeExecution)
+                        throw new Error('Task accessor cannot replace another captured execution authority.');
+                    const invocationScope = captureTaskAccessorScope(scope.worktreeRoot, {
+                        ...scope,
+                        execution: scope.execution ?? activeExecution,
+                    });
+                    return worktreeScope.run(invocationScope, () => Reflect.apply(method, target, args));
+                },
+            });
+        },
+    });
+}
 // ---- Accessor factory ----
 /**
  * Create a SQLite-backed DataAccessor.
  *
- * Opens (or creates) the SQLite database at `.cleo/tasks.db` and returns
+ * Opens (or creates) the consolidated SQLite database at `.cleo/cleo.db` and returns
  * a DataAccessor that materializes/dematerializes whole-file structures
  * from the relational tables.
  *
- * @param cwd - Working directory for path resolution (defaults to process.cwd())
+ * @param cwd - Explicit project root, or canonical root captured before initialization.
+ * @returns An accessor whose methods and transaction ports retain captured ownership.
+ * @remarks Later ambient scope changes cannot redirect this accessor's I/O. Active
+ * execution ownership is checked against persisted identity before method entry.
+ * @example
+ * ```ts
+ * const accessor = await createSqliteDataAccessor('/projects/example');
+ * const task = await accessor.loadSingleTask('T001');
+ * ```
  */
 export async function createSqliteDataAccessor(cwd) {
+    const scope = captureTaskAccessorScope(resolve(cwd ?? getProjectRoot()), worktreeScope.getStore());
+    return worktreeScope.run(scope, async () => bindTaskAccessorScope(await createOwnedSqliteDataAccessor(scope.worktreeRoot, scope), scope));
+}
+/** Construct the raw implementation inside its already captured project scope. */
+async function createOwnedSqliteDataAccessor(cwd, accessorScope) {
     // Eagerly initialize the database to ensure tables exist
     await getDb(cwd);
     /** Load all task IDs for cross-task dependency validation. */
@@ -126,12 +204,13 @@ export async function createSqliteDataAccessor(cwd) {
         const rows = await db.select({ id: schema.tasks.id }).from(schema.tasks).all();
         return new Set(rows.map((r) => r.id));
     }
-    // Per-accessor transaction nesting depth (T9814).
-    // Tracks how many DataAccessor.transaction() calls are active on this
-    // accessor instance. Used to choose BEGIN IMMEDIATE (outer, depth=0) vs
-    // SAVEPOINT (nested, depth>0) so we preserve BEGIN IMMEDIATE locking
-    // semantics at the outermost level while enabling batch-insert nesting.
-    let _txDepth = 0;
+    async function requireNativeDb() {
+        await getDb(cwd);
+        const nativeDb = getNativeTasksDb(cwd);
+        if (!nativeDb)
+            throw new Error('Native database not initialized');
+        return nativeDb;
+    }
     const accessor = {
         engine: 'sqlite',
         // ---- loadArchive ----
@@ -180,22 +259,16 @@ export async function createSqliteDataAccessor(cwd) {
         },
         // ---- saveArchive ----
         async saveArchive(data) {
-            const db = await getDb(cwd);
-            // Pre-compute archive IDs + active task IDs for dependency validation
-            const archiveIds = new Set(data.archivedTasks.map((t) => t.id));
-            const activeRows = await db
-                .select({ id: schema.tasks.id })
-                .from(schema.tasks)
-                .where(ne(schema.tasks.status, 'archived'))
-                .all();
-            const validDepIds = new Set([...archiveIds, ...activeRows.map((r) => r.id)]);
-            // Wrap all upserts + dependency updates in a single transaction.
-            // Retry on SQLITE_BUSY contention via runInImmediateTx (gh#391).
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb) {
-                throw new Error('Native database not initialized');
-            }
-            await runInImmediateTx(nativeDb, async () => {
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // Pre-compute archive IDs + active task IDs for dependency validation
+                const archiveIds = new Set(data.archivedTasks.map((t) => t.id));
+                const activeRows = await db
+                    .select({ id: schema.tasks.id })
+                    .from(schema.tasks)
+                    .where(ne(schema.tasks.status, 'archived'))
+                    .all();
+                const validDepIds = new Set([...archiveIds, ...activeRows.map((r) => r.id)]);
                 // Collect dependency data for batch update
                 const depBatch = [];
                 for (const task of data.archivedTasks) {
@@ -227,67 +300,74 @@ export async function createSqliteDataAccessor(cwd) {
         },
         // ---- saveSessions ----
         async saveSessions(sessions) {
-            const db = await getDb(cwd);
-            // Get existing session IDs
-            const existingRows = await db.select({ id: schema.sessions.id }).from(schema.sessions).all();
-            const existingIds = new Set(existingRows.map((r) => r.id));
-            const incomingIds = new Set(sessions.map((s) => s.id));
-            // Delete sessions that are no longer in the data
-            for (const eid of existingIds) {
-                if (!incomingIds.has(eid)) {
-                    await db.delete(schema.sessions).where(eq(schema.sessions.id, eid)).run();
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // Get existing session IDs
+                const existingRows = await db
+                    .select({ id: schema.sessions.id })
+                    .from(schema.sessions)
+                    .all();
+                const existingIds = new Set(existingRows.map((r) => r.id));
+                const incomingIds = new Set(sessions.map((s) => s.id));
+                // Delete sessions that are no longer in the data
+                for (const eid of existingIds) {
+                    if (!incomingIds.has(eid)) {
+                        await db.delete(schema.sessions).where(eq(schema.sessions.id, eid)).run();
+                    }
                 }
-            }
-            // Upsert all sessions
-            for (const session of sessions) {
-                await upsertSession(db, session);
-            }
+                // Upsert all sessions
+                for (const session of sessions) {
+                    await upsertSession(db, session);
+                }
+            });
         },
         // ---- appendLog ----
         async appendLog(entry) {
-            const db = await getDb(cwd);
-            // gh#391: every task mutation appends one audit row; retry on contention.
-            await withWriteRetry(() => db
-                .insert(schema.auditLog)
-                .values({
-                id: entry.id ?? generateAuditLogId(),
-                timestamp: entry.timestamp ?? new Date().toISOString(),
-                action: entry.action ?? entry.operation ?? 'unknown',
-                taskId: entry.taskId ?? 'unknown',
-                actor: entry.actor ?? 'system',
-                detailsJson: entry.details ? JSON.stringify(entry.details) : '{}',
-                beforeJson: entry.before ? JSON.stringify(entry.before) : null,
-                afterJson: entry.after ? JSON.stringify(entry.after) : null,
-            })
-                .run());
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // gh#391: every task mutation appends one audit row; retry on contention.
+                await withWriteRetry(() => db
+                    .insert(tasksAuditLog)
+                    .values({
+                    id: entry.id ?? generateAuditLogId(),
+                    timestamp: entry.timestamp ?? new Date().toISOString(),
+                    action: entry.action ?? entry.operation ?? 'unknown',
+                    taskId: entry.taskId ?? 'unknown',
+                    actor: entry.actor ?? 'system',
+                    detailsJson: entry.details ? JSON.stringify(entry.details) : '{}',
+                    beforeJson: entry.before ? JSON.stringify(entry.before) : null,
+                    afterJson: entry.after ? JSON.stringify(entry.after) : null,
+                })
+                    .run());
+            });
         },
         async queryAuditLog(query) {
             const db = await getDb(cwd);
             const conditions = [];
             if (query.taskIds && query.taskIds.length > 0) {
-                conditions.push(inArray(schema.auditLog.taskId, [...query.taskIds]));
+                conditions.push(inArray(tasksAuditLog.taskId, [...query.taskIds]));
             }
             if (query.actions && query.actions.length > 0) {
-                conditions.push(inArray(schema.auditLog.action, [...query.actions]));
+                conditions.push(inArray(tasksAuditLog.action, [...query.actions]));
             }
             if (query.since) {
-                conditions.push(sql `${schema.auditLog.timestamp} >= ${query.since}`);
+                conditions.push(sql `${tasksAuditLog.timestamp} >= ${query.since}`);
             }
             const limit = Math.max(1, Math.floor(query.limit ?? 100));
             const rows = await db
                 .select({
-                id: schema.auditLog.id,
-                timestamp: schema.auditLog.timestamp,
-                action: schema.auditLog.action,
-                taskId: schema.auditLog.taskId,
-                actor: schema.auditLog.actor,
-                detailsJson: schema.auditLog.detailsJson,
-                beforeJson: schema.auditLog.beforeJson,
-                afterJson: schema.auditLog.afterJson,
+                id: tasksAuditLog.id,
+                timestamp: tasksAuditLog.timestamp,
+                action: tasksAuditLog.action,
+                taskId: tasksAuditLog.taskId,
+                actor: tasksAuditLog.actor,
+                detailsJson: tasksAuditLog.detailsJson,
+                beforeJson: tasksAuditLog.beforeJson,
+                afterJson: tasksAuditLog.afterJson,
             })
-                .from(schema.auditLog)
+                .from(tasksAuditLog)
                 .where(conditions.length > 0 ? and(...conditions) : undefined)
-                .orderBy(sql `${schema.auditLog.timestamp} DESC`)
+                .orderBy(sql `${tasksAuditLog.timestamp} DESC`)
                 .limit(limit)
                 .all();
             return rows.map((row) => ({
@@ -303,51 +383,12 @@ export async function createSqliteDataAccessor(cwd) {
         },
         // ---- Fine-grained task operations (T5034) ----
         async upsertSingleTask(task) {
-            const db = await getDb(cwd);
-            const row = taskToRow(task);
-            // gh#391: wrap multi-statement write (task row + dependency rows) in
-            // a retry loop. SQLite implicitly auto-commits each statement, but
-            // concurrent writers can still observe SQLITE_BUSY mid-sequence.
-            await withWriteRetry(async () => {
-                await upsertTask(db, row);
-                await updateDependencies(db, task.id, task.depends ?? []);
-            });
+            await accessor.transaction((tx) => tx.upsertSingleTask(task));
         },
         async addRelation(taskId, relatedTo, relationType, reason) {
-            const db = await getDb(cwd);
-            // Validate relation type - throw on invalid (T5168)
-            const validTypes = [
-                'related',
-                'blocks',
-                'duplicates',
-                'absorbs',
-                'fixes',
-                'extends',
-                'supersedes',
-                'groups', // ADR-073: Saga member linkage
-            ];
-            if (!validTypes.includes(relationType)) {
-                throw new Error(`Invalid relation type: ${relationType}. Valid types: ${validTypes.join(', ')}`);
-            }
-            // gh#391: retry on SQLITE_BUSY contention.
-            await withWriteRetry(() => db
-                .insert(schema.taskRelations)
-                .values({
-                taskId,
-                relatedTo,
-                relationType: relationType,
-                reason: reason ?? null,
-            })
-                .onConflictDoNothing()
-                .run());
-        },
-        async removeRelation(taskId, relatedTo, relationType) {
-            const db = await getDb(cwd);
-            const conditions = [
-                eq(schema.taskRelations.taskId, taskId),
-                eq(schema.taskRelations.relatedTo, relatedTo),
-            ];
-            if (relationType !== undefined) {
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // Validate relation type - throw on invalid (T5168)
                 const validTypes = [
                     'related',
                     'blocks',
@@ -361,13 +402,48 @@ export async function createSqliteDataAccessor(cwd) {
                 if (!validTypes.includes(relationType)) {
                     throw new Error(`Invalid relation type: ${relationType}. Valid types: ${validTypes.join(', ')}`);
                 }
-                conditions.push(eq(schema.taskRelations.relationType, relationType));
-            }
-            // gh#391: retry on SQLITE_BUSY contention.
-            await withWriteRetry(() => db
-                .delete(schema.taskRelations)
-                .where(and(...conditions))
-                .run());
+                // gh#391: retry on SQLITE_BUSY contention.
+                await withWriteRetry(() => db
+                    .insert(schema.taskRelations)
+                    .values({
+                    taskId,
+                    relatedTo,
+                    relationType: relationType,
+                    reason: reason ?? null,
+                })
+                    .onConflictDoNothing()
+                    .run());
+            });
+        },
+        async removeRelation(taskId, relatedTo, relationType) {
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                const conditions = [
+                    eq(schema.taskRelations.taskId, taskId),
+                    eq(schema.taskRelations.relatedTo, relatedTo),
+                ];
+                if (relationType !== undefined) {
+                    const validTypes = [
+                        'related',
+                        'blocks',
+                        'duplicates',
+                        'absorbs',
+                        'fixes',
+                        'extends',
+                        'supersedes',
+                        'groups', // ADR-073: Saga member linkage
+                    ];
+                    if (!validTypes.includes(relationType)) {
+                        throw new Error(`Invalid relation type: ${relationType}. Valid types: ${validTypes.join(', ')}`);
+                    }
+                    conditions.push(eq(schema.taskRelations.relationType, relationType));
+                }
+                // gh#391: retry on SQLITE_BUSY contention.
+                await withWriteRetry(() => db
+                    .delete(schema.taskRelations)
+                    .where(and(...conditions))
+                    .run());
+            });
         },
         // ---- AC rows (T10508) ----
         async getAcRows(taskId) {
@@ -429,46 +505,50 @@ export async function createSqliteDataAccessor(cwd) {
             }));
         },
         async archiveSingleTask(taskId, fields) {
-            const db = await getDb(cwd);
-            // Verify the task exists before archiving
-            const rows = await db
-                .select({ id: schema.tasks.id })
-                .from(schema.tasks)
-                .where(eq(schema.tasks.id, taskId))
-                .all();
-            if (rows.length === 0)
-                return;
-            // gh#391: retry on SQLITE_BUSY contention.
-            await withWriteRetry(() => db
-                .update(schema.tasks)
-                .set({
-                status: 'archived',
-                archivedAt: fields.archivedAt ?? new Date().toISOString(),
-                archiveReason: fields.archiveReason ?? ARCHIVE_REASON_TOMBSTONE,
-                cycleTimeDays: fields.cycleTimeDays ?? null,
-                updatedAt: new Date().toISOString(),
-            })
-                .where(eq(schema.tasks.id, taskId))
-                .run());
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // Verify the task exists before archiving
+                const rows = await db
+                    .select({ id: schema.tasks.id })
+                    .from(schema.tasks)
+                    .where(eq(schema.tasks.id, taskId))
+                    .all();
+                if (rows.length === 0)
+                    return;
+                // gh#391: retry on SQLITE_BUSY contention.
+                await withWriteRetry(() => db
+                    .update(schema.tasks)
+                    .set({
+                    status: 'archived',
+                    archivedAt: fields.archivedAt ?? new Date().toISOString(),
+                    archiveReason: fields.archiveReason ?? ARCHIVE_REASON_TOMBSTONE,
+                    cycleTimeDays: fields.cycleTimeDays ?? null,
+                    updatedAt: new Date().toISOString(),
+                })
+                    .where(eq(schema.tasks.id, taskId))
+                    .run());
+            });
         },
         async removeSingleTask(taskId) {
-            const db = await getDb(cwd);
-            // gh#391: wrap the three-statement delete sequence in one retry
-            // boundary. SQLITE_BUSY mid-sequence would leak dangling task_dependencies
-            // rows; retrying the whole sequence keeps the cleanup atomic at the
-            // application level (foreign-key cascade catches edge cases regardless).
-            await withWriteRetry(async () => {
-                // Delete dependencies first (both directions)
-                await db
-                    .delete(schema.taskDependencies)
-                    .where(eq(schema.taskDependencies.taskId, taskId))
-                    .run();
-                await db
-                    .delete(schema.taskDependencies)
-                    .where(eq(schema.taskDependencies.dependsOn, taskId))
-                    .run();
-                // Delete the task itself
-                await db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // gh#391: wrap the three-statement delete sequence in one retry
+                // boundary. SQLITE_BUSY mid-sequence would leak dangling task_dependencies
+                // rows; retrying the whole sequence keeps the cleanup atomic at the
+                // application level (foreign-key cascade catches edge cases regardless).
+                await withWriteRetry(async () => {
+                    // Delete dependencies first (both directions)
+                    await db
+                        .delete(schema.taskDependencies)
+                        .where(eq(schema.taskDependencies.taskId, taskId))
+                        .run();
+                    await db
+                        .delete(schema.taskDependencies)
+                        .where(eq(schema.taskDependencies.dependsOn, taskId))
+                        .run();
+                    // Delete the task itself
+                    await db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
+                });
             });
         },
         async loadSingleTask(taskId) {
@@ -509,14 +589,18 @@ export async function createSqliteDataAccessor(cwd) {
             return resolveCurrentSession(cwd);
         },
         async upsertSingleSession(session) {
-            const db = await getDb(cwd);
-            await upsertSession(db, session);
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                await upsertSession(db, session);
+            });
         },
         async removeSingleSession(sessionId) {
-            const db = await getDb(cwd);
-            await db.delete(schema.sessions).where(eq(schema.sessions.id, sessionId)).run();
-            // Best-effort cross-db cleanup: nullify brain.db references to this session
-            void cleanupBrainRefsOnSessionDelete(sessionId, cwd);
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                await db.delete(schema.sessions).where(eq(schema.sessions.id, sessionId)).run();
+                // Best-effort cross-db cleanup: nullify brain.db references to this session
+                void cleanupBrainRefsOnSessionDelete(sessionId, cwd);
+            });
         },
         // ---- Targeted query methods (Phase 2 modernization) ----
         async queryTasks(filters) {
@@ -685,16 +769,28 @@ export async function createSqliteDataAccessor(cwd) {
             return result?.count ?? 0;
         },
         async getAncestorChain(taskId) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb)
-                return [];
+            const nativeDb = await requireNativeDb();
             const idRows = nativeDb
-                .prepare(`WITH RECURSIVE ancestor_ids(id, depth) AS (
-            SELECT parent_id, 0 FROM tasks_tasks WHERE id = ? AND parent_id IS NOT NULL
+                .prepare(
+            // T12307: the `path` column is a cycle guard, not decoration. `depth`
+            // increments on every iteration, so with UNION ALL — and even with a
+            // plain UNION — (id, depth) is distinct on every revisit and a
+            // self-parented or cyclic row recurses forever. SQLite materialises
+            // that in NATIVE memory, which `--max-old-space-size` does not bound,
+            // so the symptom is a silent VM death rather than a heap error: one
+            // seeded `parentId === id` fixture row killed five CI runs and OOM-froze
+            // a workstation three times before the mechanism was found. A depth cap
+            // would also terminate, but it silently truncates a legitimately deep
+            // chain — unacceptable in the subsystem whose whole job is depth.
+            `WITH RECURSIVE ancestor_ids(id, depth, path) AS (
+            SELECT parent_id, 0, '/' || id || '/' || parent_id || '/'
+              FROM tasks_tasks WHERE id = ? AND parent_id IS NOT NULL
             UNION ALL
-            SELECT t.parent_id, a.depth + 1 FROM tasks_tasks t
-            JOIN ancestor_ids a ON t.id = a.id
-            WHERE t.parent_id IS NOT NULL
+            SELECT t.parent_id, a.depth + 1, a.path || t.parent_id || '/'
+              FROM tasks_tasks t
+              JOIN ancestor_ids a ON t.id = a.id
+             WHERE t.parent_id IS NOT NULL
+               AND a.path NOT LIKE '%/' || t.parent_id || '/%'
           )
           SELECT id FROM ancestor_ids ORDER BY depth DESC`)
                 .all(taskId);
@@ -719,14 +815,17 @@ export async function createSqliteDataAccessor(cwd) {
             return tasks;
         },
         async getSubtree(rootId) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb)
-                return [];
+            const nativeDb = await requireNativeDb();
             // Get IDs from the CTE, then load via Drizzle for proper conversion
             const idRows = nativeDb
-                .prepare(`WITH RECURSIVE subtree AS (
+                .prepare(
+            // T12307: UNION, not UNION ALL. Every column here repeats verbatim on
+            // a revisit, so the dedupe terminates a self-parented or cyclic row;
+            // UNION ALL recurses forever in native memory. A parent edge is
+            // single-valued, so no legitimate row is ever deduped away.
+            `WITH RECURSIVE subtree AS (
             SELECT id FROM tasks_tasks WHERE id = ?
-            UNION ALL
+            UNION
             SELECT t.id FROM tasks_tasks t
             JOIN subtree s ON t.parent_id = s.id
           )
@@ -770,9 +869,7 @@ export async function createSqliteDataAccessor(cwd) {
             return tasks;
         },
         async getDependencyChain(taskId) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb)
-                return [];
+            const nativeDb = await requireNativeDb();
             const rows = nativeDb
                 .prepare(`WITH RECURSIVE dep_chain(id) AS (
             SELECT depends_on FROM tasks_task_dependencies WHERE task_id = ?
@@ -813,7 +910,7 @@ export async function createSqliteDataAccessor(cwd) {
         },
         // ---- Position helpers (T024/T025) ----
         async getNextPosition(parentId) {
-            const nativeDb = getNativeTasksDb();
+            const nativeDb = await requireNativeDb();
             if (!nativeDb) {
                 throw new Error('Native database not initialized');
             }
@@ -827,66 +924,46 @@ export async function createSqliteDataAccessor(cwd) {
             return row?.next_pos ?? 1;
         },
         async shiftPositions(parentId, fromPosition, delta) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb) {
-                throw new Error('Native database not initialized');
-            }
-            if (parentId === null) {
-                nativeDb
-                    .prepare(`UPDATE tasks_tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id IS NULL AND position >= ? AND status != 'archived'`)
-                    .run(delta, new Date().toISOString(), fromPosition);
-            }
-            else {
-                nativeDb
-                    .prepare(`UPDATE tasks_tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id = ? AND position >= ? AND status != 'archived'`)
-                    .run(delta, new Date().toISOString(), parentId, fromPosition);
-            }
+            return accessor.transaction(async () => {
+                const nativeDb = await requireNativeDb();
+                if (!nativeDb) {
+                    throw new Error('Native database not initialized');
+                }
+                if (parentId === null) {
+                    nativeDb
+                        .prepare(`UPDATE tasks_tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id IS NULL AND position >= ? AND status != 'archived'`)
+                        .run(delta, new Date().toISOString(), fromPosition);
+                }
+                else {
+                    nativeDb
+                        .prepare(`UPDATE tasks_tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id = ? AND position >= ? AND status != 'archived'`)
+                        .run(delta, new Date().toISOString(), parentId, fromPosition);
+                }
+            });
         },
         // ---- Targeted write methods ----
         async updateTaskFields(taskId, fields) {
-            const db = await getDb(cwd);
-            const updateRow = {
-                updatedAt: fields.updatedAt ?? new Date().toISOString(),
-            };
-            // Copy only provided fields
-            const fieldMap = [
-                ['title', 'title'],
-                ['description', 'description'],
-                ['status', 'status'],
-                ['priority', 'priority'],
-                ['type', 'type'],
-                ['parentId', 'parentId'],
-                ['phase', 'phase'],
-                ['size', 'size'],
-                ['position', 'position'],
-                ['positionVersion', 'positionVersion'],
-                ['labelsJson', 'labelsJson'],
-                ['notesJson', 'notesJson'],
-                ['acceptanceJson', 'acceptanceJson'],
-                ['filesJson', 'filesJson'],
-                ['origin', 'origin'],
-                ['blockedBy', 'blockedBy'],
-                ['epicLifecycle', 'epicLifecycle'],
-                ['noAutoComplete', 'noAutoComplete'],
-                ['completedAt', 'completedAt'],
-                ['cancelledAt', 'cancelledAt'],
-                ['cancellationReason', 'cancellationReason'],
-                ['verificationJson', 'verificationJson'],
-                ['createdBy', 'createdBy'],
-                ['modifiedBy', 'modifiedBy'],
-                ['sessionId', 'sessionId'],
-                ['assignee', 'assignee'],
-                ['pipelineStage', 'pipelineStage'],
-            ];
-            for (const [key, col] of fieldMap) {
-                if (fields[key] !== undefined) {
-                    updateRow[col] = fields[key];
+            return accessor.transaction(async () => {
+                const db = await getDb(cwd);
+                // TaskFieldUpdates uses the schema's field names. Reject unsupported runtime
+                // input before Drizzle can silently omit it; no second field map can drift.
+                const columns = getTableColumns(schema.tasks);
+                for (const key of Object.keys(fields)) {
+                    if (!Object.hasOwn(columns, key) || key === 'id' || key === 'createdAt') {
+                        throw new Error(`Unsupported task update field: ${key}`);
+                    }
                 }
-            }
-            // gh#391: this is the chokepoint for `cleo update <id> --add-labels`.
-            // Parallel invocations from a single shell used to lose ~50% of writes
-            // to SQLITE_BUSY; withWriteRetry recovers them.
-            await withWriteRetry(() => db.update(schema.tasks).set(updateRow).where(eq(schema.tasks.id, taskId)).run());
+                const updateRow = { ...fields, updatedAt: fields.updatedAt ?? new Date().toISOString() };
+                // gh#391: this is the chokepoint for `cleo update <id> --add-labels`.
+                // Parallel invocations from a single shell used to lose ~50% of writes
+                // to SQLITE_BUSY; withWriteRetry recovers them.
+                const result = await withWriteRetry(() => db.update(schema.tasks).set(updateRow).where(eq(schema.tasks.id, taskId)).run());
+                if (Number(result.changes) !== 1)
+                    throw new Error(`Task not found: ${taskId}`);
+                if (fields.labelsJson !== undefined) {
+                    await updateTaskLabels(db, taskId, parseLabels(fields.labelsJson));
+                }
+            });
         },
         async transaction(fn) {
             // Await getDb first so _nativeDb is guaranteed to be the correct instance
@@ -898,225 +975,306 @@ export async function createSqliteDataAccessor(cwd) {
             if (!nativeDb) {
                 throw new Error('Native database not initialized');
             }
-            // Nested-transaction support (T9814 — batch insert):
-            // - Outermost call (depth=0): use BEGIN IMMEDIATE — preserves the
-            //   RESERVED lock semantics that callers and tests depend on.
-            // - Nested calls (depth>0): use SAVEPOINT — creates a logical
-            //   checkpoint inside the already-open transaction.
-            const isOuter = _txDepth === 0;
-            const spName = isOuter ? null : `_cleo_tx_${(_txSavepointCounter++).toString(36)}`;
-            if (isOuter) {
-                nativeDb.prepare('BEGIN IMMEDIATE').run();
-            }
-            else {
-                nativeDb.prepare(`SAVEPOINT ${spName}`).run();
-            }
-            _txDepth++;
+            const context = activeTransactionScope(nativeDb);
+            const previous = context?.pending ?? taskTransactionQueue.get(nativeDb) ?? Promise.resolve();
+            const released = Promise.withResolvers();
+            const tail = previous.then(() => released.promise);
+            if (context)
+                context.pending = tail;
+            else
+                taskTransactionQueue.set(nativeDb, tail);
+            await previous;
             try {
-                const tx = {
-                    async upsertSingleTask(task) {
-                        const row = taskToRow(task);
-                        await upsertTask(db, row);
-                        await updateDependencies(db, task.id, task.depends ?? []);
-                    },
-                    async archiveSingleTask(taskId, fields) {
-                        await db
-                            .update(schema.tasks)
-                            .set({
-                            status: 'archived',
-                            archivedAt: fields.archivedAt ?? new Date().toISOString(),
-                            archiveReason: fields.archiveReason ?? ARCHIVE_REASON_TOMBSTONE,
-                            cycleTimeDays: fields.cycleTimeDays ?? null,
-                            updatedAt: new Date().toISOString(),
-                        })
-                            .where(eq(schema.tasks.id, taskId))
-                            .run();
-                    },
-                    async removeSingleTask(taskId) {
-                        await db
-                            .delete(schema.taskDependencies)
-                            .where(eq(schema.taskDependencies.taskId, taskId))
-                            .run();
-                        await db
-                            .delete(schema.taskDependencies)
-                            .where(eq(schema.taskDependencies.dependsOn, taskId))
-                            .run();
-                        await db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
-                    },
-                    async setMetaValue(key, value) {
-                        await setMetaValue(cwd, key, value);
-                    },
-                    async updateTaskFields(taskId, flds) {
-                        // Delegate to the outer accessor's implementation
-                        await accessor.updateTaskFields(taskId, flds);
-                    },
-                    async getChildren(parentId) {
-                        const rows = await db
-                            .select()
-                            .from(schema.tasks)
-                            .where(and(eq(schema.tasks.parentId, parentId), ne(schema.tasks.status, 'archived')))
-                            .orderBy(sql `${schema.tasks.position} ASC, ${schema.tasks.createdAt} ASC`)
-                            .all();
-                        return rows.map(rowToTask);
-                    },
-                    async appendLog(entry) {
-                        await accessor.appendLog(entry);
-                    },
-                    // T9514: persist relates mutations inside the transaction
-                    async addRelation(taskId, relatedTo, relationType, reason) {
-                        await accessor.addRelation(taskId, relatedTo, relationType, reason);
-                    },
-                    async removeRelation(taskId, relatedTo, relationType) {
-                        await accessor.removeRelation(taskId, relatedTo, relationType);
-                    },
-                    async clearRelations(taskId) {
-                        await db
-                            .delete(schema.taskRelations)
-                            .where(eq(schema.taskRelations.taskId, taskId))
-                            .run();
-                    },
-                    // ---- AC rows (T10508) ----
-                    async insertAcRows(rows) {
-                        if (rows.length === 0)
-                            return;
-                        await db
-                            .insert(schema.taskAcceptanceCriteria)
-                            .values(rows.map((r) => ({
-                            id: r.id,
-                            taskId: r.taskId,
-                            ordinal: r.ordinal,
-                            kind: r.kind ?? 'text',
-                            sourceKey: r.sourceKey ?? `text:${r.ordinal}`,
-                            targetTaskId: r.targetTaskId ?? null,
-                            projection: r.projection ?? 'legacy',
-                            text: r.text,
-                            contentHash: r.contentHash ?? null,
-                        })))
-                            .run();
-                    },
-                    async getAcRows(taskId) {
-                        const out = await db
-                            .select({
-                            id: schema.taskAcceptanceCriteria.id,
-                            taskId: schema.taskAcceptanceCriteria.taskId,
-                            ordinal: schema.taskAcceptanceCriteria.ordinal,
-                            kind: schema.taskAcceptanceCriteria.kind,
-                            sourceKey: schema.taskAcceptanceCriteria.sourceKey,
-                            targetTaskId: schema.taskAcceptanceCriteria.targetTaskId,
-                            projection: schema.taskAcceptanceCriteria.projection,
-                            text: schema.taskAcceptanceCriteria.text,
-                            createdAt: schema.taskAcceptanceCriteria.createdAt,
-                            updatedAt: schema.taskAcceptanceCriteria.updatedAt,
-                            contentHash: schema.taskAcceptanceCriteria.contentHash,
-                        })
-                            .from(schema.taskAcceptanceCriteria)
-                            .where(eq(schema.taskAcceptanceCriteria.taskId, taskId))
-                            .orderBy(schema.taskAcceptanceCriteria.ordinal)
-                            .all();
-                        return out.map((r) => ({
-                            id: r.id,
-                            taskId: r.taskId,
-                            ordinal: r.ordinal,
-                            kind: r.kind,
-                            sourceKey: r.sourceKey ?? `text:${r.ordinal}`,
-                            targetTaskId: r.targetTaskId ?? null,
-                            projection: r.projection,
-                            text: r.text,
-                            createdAt: r.createdAt,
-                            updatedAt: r.updatedAt ?? null,
-                            contentHash: r.contentHash ?? null,
-                        }));
-                    },
-                    async deleteAcRowsForTask(taskId) {
-                        await db
-                            .delete(schema.taskAcceptanceCriteria)
-                            .where(eq(schema.taskAcceptanceCriteria.taskId, taskId))
-                            .run();
-                    },
-                    async appendAcHistory(rows) {
-                        if (rows.length === 0)
-                            return;
-                        await db
-                            .insert(schema.taskAcceptanceCriteriaHistory)
-                            .values(rows.map((r) => ({
-                            acId: r.acId,
-                            previousText: r.previousText,
-                            reason: r.reason,
-                        })))
-                            .run();
-                    },
-                    // ---- AC bindings (T10509 — AC-coverage gate) ----
-                    async getAcBindings(acIds) {
-                        if (acIds.length === 0)
-                            return [];
-                        const out = await db
-                            .select({
-                            id: schema.evidenceAcBindings.id,
-                            evidenceAtomId: schema.evidenceAcBindings.evidenceAtomId,
-                            acId: schema.evidenceAcBindings.acId,
-                            bindingType: schema.evidenceAcBindings.bindingType,
-                            createdAt: schema.evidenceAcBindings.createdAt,
-                        })
-                            .from(schema.evidenceAcBindings)
-                            .where(inArray(schema.evidenceAcBindings.acId, acIds))
-                            .all();
-                        return out.map((r) => ({
-                            id: r.id,
-                            evidenceAtomId: r.evidenceAtomId,
-                            acId: r.acId,
-                            bindingType: r.bindingType,
-                            createdAt: r.createdAt,
-                        }));
-                    },
-                    // ---- AC bindings — writer (T10511, Validator SDK tools) ----
-                    async insertAcBindings(rows) {
-                        if (rows.length === 0)
-                            return;
-                        // Idempotent insert — UNIQUE (evidence_atom_id, ac_id, binding_type)
-                        // index collapses re-inserts of the same triple via DO NOTHING.
-                        await db
-                            .insert(schema.evidenceAcBindings)
-                            .values(rows.map((r) => ({
-                            id: r.id,
-                            evidenceAtomId: r.evidenceAtomId,
-                            acId: r.acId,
-                            bindingType: r.bindingType,
-                        })))
-                            .onConflictDoNothing({
-                            target: [
-                                schema.evidenceAcBindings.evidenceAtomId,
-                                schema.evidenceAcBindings.acId,
-                                schema.evidenceAcBindings.bindingType,
-                            ],
-                        })
-                            .run();
-                    },
+                if (context && !context.active)
+                    return accessor.transaction(fn);
+                const execute = async () => {
+                    if (!context && nativeDb.isTransaction) {
+                        throw new Error('Cannot join a transaction without an active task-accessor owner');
+                    }
+                    const inherited = taskTransactionContext.getStore();
+                    const scope = new TaskTransactionScope(nativeDb, inherited?.active ? inherited : undefined);
+                    return taskTransactionContext.run(scope, async () => {
+                        const isOuter = !nativeDb.isTransaction;
+                        const spName = isOuter ? null : `_cleo_tx_${(_txSavepointCounter++).toString(36)}`;
+                        if (isOuter) {
+                            nativeDb.prepare('BEGIN IMMEDIATE').run();
+                        }
+                        else {
+                            nativeDb.prepare(`SAVEPOINT ${spName}`).run();
+                        }
+                        try {
+                            const tx = {
+                                async upsertSingleTask(task) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        const row = taskToRow(task);
+                                        await upsertTask(db, row);
+                                        await updateDependencies(db, task.id, task.depends ?? []);
+                                    });
+                                },
+                                async archiveSingleTask(taskId, fields) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await db
+                                            .update(schema.tasks)
+                                            .set({
+                                            status: 'archived',
+                                            archivedAt: fields.archivedAt ?? new Date().toISOString(),
+                                            archiveReason: fields.archiveReason ?? ARCHIVE_REASON_TOMBSTONE,
+                                            cycleTimeDays: fields.cycleTimeDays ?? null,
+                                            updatedAt: new Date().toISOString(),
+                                        })
+                                            .where(eq(schema.tasks.id, taskId))
+                                            .run();
+                                    });
+                                },
+                                async removeSingleTask(taskId) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await db
+                                            .delete(schema.taskDependencies)
+                                            .where(eq(schema.taskDependencies.taskId, taskId))
+                                            .run();
+                                        await db
+                                            .delete(schema.taskDependencies)
+                                            .where(eq(schema.taskDependencies.dependsOn, taskId))
+                                            .run();
+                                        await db.delete(schema.tasks).where(eq(schema.tasks.id, taskId)).run();
+                                    });
+                                },
+                                async setMetaValue(key, value) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await writeMetaValue(cwd, key, value);
+                                    });
+                                },
+                                async updateTaskFields(taskId, flds) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        // Delegate to the outer accessor's implementation
+                                        await accessor.updateTaskFields(taskId, flds);
+                                    });
+                                },
+                                async getChildren(parentId) {
+                                    scope.assertActive();
+                                    const rows = await db
+                                        .select()
+                                        .from(schema.tasks)
+                                        .where(and(eq(schema.tasks.parentId, parentId), ne(schema.tasks.status, 'archived')))
+                                        .orderBy(sql `${schema.tasks.position} ASC, ${schema.tasks.createdAt} ASC`)
+                                        .all();
+                                    return rows.map(rowToTask);
+                                },
+                                async appendLog(entry) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await accessor.appendLog(entry);
+                                    });
+                                },
+                                // T9514: persist relates mutations inside the transaction
+                                async addRelation(taskId, relatedTo, relationType, reason) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await accessor.addRelation(taskId, relatedTo, relationType, reason);
+                                    });
+                                },
+                                async removeRelation(taskId, relatedTo, relationType) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await accessor.removeRelation(taskId, relatedTo, relationType);
+                                    });
+                                },
+                                async clearRelations(taskId) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await db
+                                            .delete(schema.taskRelations)
+                                            .where(eq(schema.taskRelations.taskId, taskId))
+                                            .run();
+                                    });
+                                },
+                                // ---- AC rows (T10508) ----
+                                async insertAcRows(rows) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        if (rows.length === 0)
+                                            return;
+                                        await db
+                                            .insert(schema.taskAcceptanceCriteria)
+                                            .values(rows.map((r) => ({
+                                            id: r.id,
+                                            taskId: r.taskId,
+                                            ordinal: r.ordinal,
+                                            kind: r.kind ?? 'text',
+                                            sourceKey: r.sourceKey ?? `text:${r.ordinal}`,
+                                            targetTaskId: r.targetTaskId ?? null,
+                                            projection: r.projection ?? 'legacy',
+                                            text: r.text,
+                                            contentHash: r.contentHash ?? null,
+                                        })))
+                                            .run();
+                                    });
+                                },
+                                async getAcRows(taskId) {
+                                    scope.assertActive();
+                                    const out = await db
+                                        .select({
+                                        id: schema.taskAcceptanceCriteria.id,
+                                        taskId: schema.taskAcceptanceCriteria.taskId,
+                                        ordinal: schema.taskAcceptanceCriteria.ordinal,
+                                        kind: schema.taskAcceptanceCriteria.kind,
+                                        sourceKey: schema.taskAcceptanceCriteria.sourceKey,
+                                        targetTaskId: schema.taskAcceptanceCriteria.targetTaskId,
+                                        projection: schema.taskAcceptanceCriteria.projection,
+                                        text: schema.taskAcceptanceCriteria.text,
+                                        createdAt: schema.taskAcceptanceCriteria.createdAt,
+                                        updatedAt: schema.taskAcceptanceCriteria.updatedAt,
+                                        contentHash: schema.taskAcceptanceCriteria.contentHash,
+                                    })
+                                        .from(schema.taskAcceptanceCriteria)
+                                        .where(eq(schema.taskAcceptanceCriteria.taskId, taskId))
+                                        .orderBy(schema.taskAcceptanceCriteria.ordinal)
+                                        .all();
+                                    return out.map((r) => ({
+                                        id: r.id,
+                                        taskId: r.taskId,
+                                        ordinal: r.ordinal,
+                                        kind: r.kind,
+                                        sourceKey: r.sourceKey ?? `text:${r.ordinal}`,
+                                        targetTaskId: r.targetTaskId ?? null,
+                                        projection: r.projection,
+                                        text: r.text,
+                                        createdAt: r.createdAt,
+                                        updatedAt: r.updatedAt ?? null,
+                                        contentHash: r.contentHash ?? null,
+                                    }));
+                                },
+                                async deleteAcRowsForTask(taskId) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        await db
+                                            .delete(schema.taskAcceptanceCriteria)
+                                            .where(eq(schema.taskAcceptanceCriteria.taskId, taskId))
+                                            .run();
+                                    });
+                                },
+                                async appendAcHistory(rows) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        if (rows.length === 0)
+                                            return;
+                                        await db
+                                            .insert(schema.taskAcceptanceCriteriaHistory)
+                                            .values(rows.map((r) => ({
+                                            acId: r.acId,
+                                            previousText: r.previousText,
+                                            reason: r.reason,
+                                        })))
+                                            .run();
+                                    });
+                                },
+                                // ---- AC bindings (T10509 — AC-coverage gate) ----
+                                async getAcBindings(acIds) {
+                                    scope.assertActive();
+                                    if (acIds.length === 0)
+                                        return [];
+                                    const out = await db
+                                        .select({
+                                        id: schema.evidenceAcBindings.id,
+                                        evidenceAtomId: schema.evidenceAcBindings.evidenceAtomId,
+                                        acId: schema.evidenceAcBindings.acId,
+                                        bindingType: schema.evidenceAcBindings.bindingType,
+                                        createdAt: schema.evidenceAcBindings.createdAt,
+                                    })
+                                        .from(schema.evidenceAcBindings)
+                                        .where(inArray(schema.evidenceAcBindings.acId, acIds))
+                                        .all();
+                                    return out.map((r) => ({
+                                        id: r.id,
+                                        evidenceAtomId: r.evidenceAtomId,
+                                        acId: r.acId,
+                                        bindingType: r.bindingType,
+                                        createdAt: r.createdAt,
+                                    }));
+                                },
+                                // ---- AC bindings — writer (T10511, Validator SDK tools) ----
+                                async insertAcBindings(rows) {
+                                    scope.assertActive();
+                                    return accessor.transaction(async () => {
+                                        scope.assertActive();
+                                        if (rows.length === 0)
+                                            return;
+                                        // Idempotent insert — UNIQUE (evidence_atom_id, ac_id, binding_type)
+                                        // index collapses re-inserts of the same triple via DO NOTHING.
+                                        await db
+                                            .insert(schema.evidenceAcBindings)
+                                            .values(rows.map((r) => ({
+                                            id: r.id,
+                                            evidenceAtomId: r.evidenceAtomId,
+                                            acId: r.acId,
+                                            bindingType: r.bindingType,
+                                        })))
+                                            .onConflictDoNothing({
+                                            target: [
+                                                schema.evidenceAcBindings.evidenceAtomId,
+                                                schema.evidenceAcBindings.acId,
+                                                schema.evidenceAcBindings.bindingType,
+                                            ],
+                                        })
+                                            .run();
+                                    });
+                                },
+                            };
+                            const result = await fn(bindTaskAccessorScope(tx, accessorScope));
+                            await scope.pending;
+                            if (isOuter) {
+                                nativeDb.prepare('COMMIT').run();
+                            }
+                            else {
+                                nativeDb.prepare(`RELEASE SAVEPOINT ${spName}`).run();
+                            }
+                            return result;
+                        }
+                        catch (err) {
+                            await scope.pending;
+                            try {
+                                if (isOuter) {
+                                    nativeDb.prepare('ROLLBACK').run();
+                                }
+                                else {
+                                    nativeDb.prepare(`ROLLBACK TO SAVEPOINT ${spName}`).run();
+                                    nativeDb.prepare(`RELEASE SAVEPOINT ${spName}`).run();
+                                }
+                            }
+                            catch {
+                                /* ignore secondary rollback errors */
+                            }
+                            throw err;
+                        }
+                        finally {
+                            scope.active = false;
+                        }
+                    });
                 };
-                const result = await fn(tx);
-                _txDepth--;
-                if (isOuter) {
-                    nativeDb.prepare('COMMIT').run();
-                }
-                else {
-                    nativeDb.prepare(`RELEASE SAVEPOINT ${spName}`).run();
-                }
-                return result;
+                const commit = () => withBackgroundOpCommitBoundary(nativeDb, execute, worktreeScope.getStore()?.execution, (work) => scheduleTaskBackground(nativeDb, work));
+                return await (context ? commit() : withWriteRetry(commit));
             }
-            catch (err) {
-                _txDepth--;
-                try {
-                    if (isOuter) {
-                        nativeDb.prepare('ROLLBACK').run();
-                    }
-                    else {
-                        nativeDb.prepare(`ROLLBACK TO SAVEPOINT ${spName}`).run();
-                        nativeDb.prepare(`RELEASE SAVEPOINT ${spName}`).run();
-                    }
-                }
-                catch {
-                    /* ignore secondary rollback errors */
-                }
-                throw err;
+            finally {
+                released.resolve();
+                if (!context && taskTransactionQueue.get(nativeDb) === tail)
+                    taskTransactionQueue.delete(nativeDb);
             }
         },
         // ---- close ----
@@ -1128,7 +1286,7 @@ export async function createSqliteDataAccessor(cwd) {
             return getMetaValue(cwd, key);
         },
         async setMetaValue(key, value) {
-            return setMetaValue(cwd, key, value);
+            return accessor.transaction((tx) => tx.setMetaValue(key, value));
         },
         async getSchemaVersion() {
             const meta = await getMetaValue(cwd, 'file_meta');
@@ -1146,44 +1304,48 @@ export async function createSqliteDataAccessor(cwd) {
         },
         // ---- Agent task claiming ----
         async claimTask(taskId, agentId) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb) {
-                throw new Error('Native database not initialized');
-            }
-            // Verify the task exists first
-            const existsRow = nativeDb
-                .prepare('SELECT assignee FROM tasks_tasks WHERE id = ?')
-                .get(taskId);
-            if (!existsRow) {
-                throw new Error(`Task not found: ${taskId}`);
-            }
-            // Atomic claim: only succeeds if assignee IS NULL or already claimed by this agent.
-            // This prevents race conditions between concurrent agents.
-            const result = nativeDb
-                .prepare('UPDATE tasks_tasks SET assignee = ?, updated_at = ? WHERE id = ? AND (assignee IS NULL OR assignee = ?)')
-                .run(agentId, new Date().toISOString(), taskId, agentId);
-            if (result.changes === 0) {
-                // Row was not updated — task is claimed by a different agent
-                const currentRow = nativeDb
+            return accessor.transaction(async () => {
+                const nativeDb = await requireNativeDb();
+                if (!nativeDb) {
+                    throw new Error('Native database not initialized');
+                }
+                // Verify the task exists first
+                const existsRow = nativeDb
                     .prepare('SELECT assignee FROM tasks_tasks WHERE id = ?')
                     .get(taskId);
-                throw new Error(`Task ${taskId} is already claimed by agent: ${currentRow?.assignee ?? 'unknown'}`);
-            }
+                if (!existsRow) {
+                    throw new Error(`Task not found: ${taskId}`);
+                }
+                // Atomic claim: only succeeds if assignee IS NULL or already claimed by this agent.
+                // This prevents race conditions between concurrent agents.
+                const result = nativeDb
+                    .prepare('UPDATE tasks_tasks SET assignee = ?, updated_at = ? WHERE id = ? AND (assignee IS NULL OR assignee = ?)')
+                    .run(agentId, new Date().toISOString(), taskId, agentId);
+                if (result.changes === 0) {
+                    // Row was not updated — task is claimed by a different agent
+                    const currentRow = nativeDb
+                        .prepare('SELECT assignee FROM tasks_tasks WHERE id = ?')
+                        .get(taskId);
+                    throw new Error(`Task ${taskId} is already claimed by agent: ${currentRow?.assignee ?? 'unknown'}`);
+                }
+            });
         },
         async unclaimTask(taskId) {
-            const nativeDb = getNativeTasksDb();
-            if (!nativeDb) {
-                throw new Error('Native database not initialized');
-            }
-            // Verify the task exists
-            const existsRow = nativeDb.prepare('SELECT id FROM tasks_tasks WHERE id = ?').get(taskId);
-            if (!existsRow) {
-                throw new Error(`Task not found: ${taskId}`);
-            }
-            // Clear the assignee — no-op if already null
-            nativeDb
-                .prepare('UPDATE tasks_tasks SET assignee = NULL, updated_at = ? WHERE id = ?')
-                .run(new Date().toISOString(), taskId);
+            return accessor.transaction(async () => {
+                const nativeDb = await requireNativeDb();
+                if (!nativeDb) {
+                    throw new Error('Native database not initialized');
+                }
+                // Verify the task exists
+                const existsRow = nativeDb.prepare('SELECT id FROM tasks_tasks WHERE id = ?').get(taskId);
+                if (!existsRow) {
+                    throw new Error(`Task not found: ${taskId}`);
+                }
+                // Clear the assignee — no-op if already null
+                nativeDb
+                    .prepare('UPDATE tasks_tasks SET assignee = NULL, updated_at = ? WHERE id = ?')
+                    .run(new Date().toISOString(), taskId);
+            });
         },
     };
     return accessor;