@cleocode/core 2026.9.8 → 2026.9.9

package/dist/store/data-safety-central.js

@@ -17,12 +17,18 @@
  */
 import { eq } from 'drizzle-orm';
 import { getLogger } from '../logger.js';
+import { captureProjectScope, getProjectRoot, worktreeScope } from '../project-scope.js';
 import { checkSequence, repairSequence } from '../sequence/index.js';
 import { gitCheckpoint } from './git-checkpoint.js';
 import { getDb } from './sqlite.js';
 import { vacuumIntoBackup } from './sqlite-backup.js';
 import * as schema from './tasks-schema.js';
 const log = getLogger('data-safety');
+/** Bind explicit ownership before the first asynchronous safety or callback step. */
+function inSafetyScope(cwd, operation) {
+    const scope = captureProjectScope(cwd ?? getProjectRoot(), worktreeScope.getStore());
+    return worktreeScope.run(scope, () => operation(scope.worktreeRoot));
+}
 /** Safety violation error */
 export class DataSafetyError extends Error {
     code;
@@ -127,21 +133,25 @@ async function verifyArchiveFile(data, accessor, options) {
  * Safe wrapper for DataAccessor.saveSessions()
  */
 export async function safeSaveSessions(accessor, data, cwd, options) {
-    const opts = { ...DEFAULT_SAFETY, ...options };
-    await accessor.saveSessions(data);
-    stats.writes++;
-    await verifySessions(data, accessor, opts);
-    await checkpoint(`saved Sessions (${data.length} sessions)`, cwd, opts);
+    return inSafetyScope(cwd, async (cwd) => {
+        const opts = { ...DEFAULT_SAFETY, ...options };
+        await accessor.saveSessions(data);
+        stats.writes++;
+        await verifySessions(data, accessor, opts);
+        await checkpoint(`saved Sessions (${data.length} sessions)`, cwd, opts);
+    });
 }
 /**
  * Safe wrapper for DataAccessor.saveArchive()
  */
 export async function safeSaveArchive(accessor, data, cwd, options) {
-    const opts = { ...DEFAULT_SAFETY, ...options };
-    await accessor.saveArchive(data);
-    stats.writes++;
-    await verifyArchiveFile(data, accessor, opts);
-    await checkpoint(`saved Archive (${data.archivedTasks.length} tasks)`, cwd, opts);
+    return inSafetyScope(cwd, async (cwd) => {
+        const opts = { ...DEFAULT_SAFETY, ...options };
+        await accessor.saveArchive(data);
+        stats.writes++;
+        await verifyArchiveFile(data, accessor, opts);
+        await checkpoint(`saved Archive (${data.archivedTasks.length} tasks)`, cwd, opts);
+    });
 }
 /**
  * Safe wrapper for single-task write operations (T5034).
@@ -155,14 +165,16 @@ export async function safeSaveArchive(accessor, data, cwd, options) {
  * itself is a targeted SQL operation that either succeeds or throws.
  */
 export async function safeSingleTaskWrite(_accessor, taskId, writeFn, cwd, options) {
-    const opts = { ...DEFAULT_SAFETY, ...options };
-    // 1. Validate sequence
-    await ensureSequenceValid(cwd, opts);
-    // 2. Perform targeted write
-    await writeFn();
-    stats.writes++;
-    // 3. Checkpoint (lightweight — no full-file verify)
-    await checkpoint(`single-task ${taskId}`, cwd, opts);
+    return inSafetyScope(cwd, async (cwd) => {
+        const opts = { ...DEFAULT_SAFETY, ...options };
+        // 1. Validate sequence
+        await ensureSequenceValid(cwd, opts);
+        // 2. Perform targeted write
+        await writeFn();
+        stats.writes++;
+        // 3. Checkpoint (lightweight — no full-file verify)
+        await checkpoint(`single-task ${taskId}`, cwd, opts);
+    });
 }
 /**
  * Safe wrapper for DataAccessor.appendLog()
@@ -171,77 +183,83 @@ export async function safeSingleTaskWrite(_accessor, taskId, writeFn, cwd, optio
  * but we still checkpoint to ensure data is committed.
  */
 export async function safeAppendLog(accessor, entry, cwd, options) {
-    const opts = { ...DEFAULT_SAFETY, ...options, verify: false }; // Logs don't need verification
-    await accessor.appendLog(entry);
-    stats.writes++;
-    await checkpoint('log entry', cwd, opts);
+    return inSafetyScope(cwd, async (cwd) => {
+        const opts = { ...DEFAULT_SAFETY, ...options, verify: false }; // Logs don't need verification
+        await accessor.appendLog(entry);
+        stats.writes++;
+        await checkpoint('log entry', cwd, opts);
+    });
 }
 /**
  * Run comprehensive data integrity check.
  * Validates all data files and sequence consistency.
  */
 export async function runDataIntegrityCheck(accessor, cwd) {
-    const errors = [];
-    const warnings = [];
-    // 1. Check sequence
-    try {
-        const seqCheck = await checkSequence(cwd);
-        if (!seqCheck.valid) {
-            errors.push(`Sequence invalid: counter=${seqCheck.counter}, maxId=T${seqCheck.maxIdInData}`);
-            // Try to repair
-            const repair = await repairSequence(cwd);
-            if (repair.repaired) {
-                warnings.push(`Auto-repaired sequence: ${repair.oldCounter} -> ${repair.newCounter}`);
+    return inSafetyScope(cwd, async (cwd) => {
+        const errors = [];
+        const warnings = [];
+        // 1. Check sequence
+        try {
+            const seqCheck = await checkSequence(cwd);
+            if (!seqCheck.valid) {
+                errors.push(`Sequence invalid: counter=${seqCheck.counter}, maxId=T${seqCheck.maxIdInData}`);
+                // Try to repair
+                const repair = await repairSequence(cwd);
+                if (repair.repaired) {
+                    warnings.push(`Auto-repaired sequence: ${repair.oldCounter} -> ${repair.newCounter}`);
+                }
+                else {
+                    errors.push('Sequence auto-repair failed');
+                }
             }
-            else {
-                errors.push('Sequence auto-repair failed');
+        }
+        catch (err) {
+            errors.push(`Sequence check failed: ${String(err)}`);
+        }
+        // 2. Verify task data can be queried
+        try {
+            const count = await accessor.countTasks();
+            if (count < 0) {
+                errors.push('Task count returned negative value');
             }
         }
-    }
-    catch (err) {
-        errors.push(`Sequence check failed: ${String(err)}`);
-    }
-    // 2. Verify task data can be queried
-    try {
-        const count = await accessor.countTasks();
-        if (count < 0) {
-            errors.push('Task count returned negative value');
+        catch (err) {
+            errors.push(`Task data query failed: ${String(err)}`);
         }
-    }
-    catch (err) {
-        errors.push(`Task data query failed: ${String(err)}`);
-    }
-    try {
-        const sessions = await accessor.loadSessions();
-        if (!Array.isArray(sessions)) {
-            errors.push('Sessions data is not an array');
+        try {
+            const sessions = await accessor.loadSessions();
+            if (!Array.isArray(sessions)) {
+                errors.push('Sessions data is not an array');
+            }
         }
-    }
-    catch (err) {
-        errors.push(`Sessions load failed: ${String(err)}`);
-    }
-    // 3. Check for checkpoint recency
-    if (stats.lastCheckpoint) {
-        const minutesSinceCheckpoint = (Date.now() - stats.lastCheckpoint.getTime()) / 60000;
-        if (minutesSinceCheckpoint > 60) {
-            warnings.push(`Last checkpoint was ${Math.round(minutesSinceCheckpoint)} minutes ago`);
+        catch (err) {
+            errors.push(`Sessions load failed: ${String(err)}`);
         }
-    }
-    return {
-        passed: errors.length === 0,
-        errors,
-        warnings,
-        stats: getSafetyStats(),
-    };
+        // 3. Check for checkpoint recency
+        if (stats.lastCheckpoint) {
+            const minutesSinceCheckpoint = (Date.now() - stats.lastCheckpoint.getTime()) / 60000;
+            if (minutesSinceCheckpoint > 60) {
+                warnings.push(`Last checkpoint was ${Math.round(minutesSinceCheckpoint)} minutes ago`);
+            }
+        }
+        return {
+            passed: errors.length === 0,
+            errors,
+            warnings,
+            stats: getSafetyStats(),
+        };
+    });
 }
 /**
  * Force immediate checkpoint.
  * Use before destructive operations.
  */
 export async function forceSafetyCheckpoint(context, cwd) {
-    log.info({ context }, 'Forcing checkpoint');
-    await gitCheckpoint('manual', context, cwd);
-    vacuumIntoBackup({ cwd, force: true }).catch(() => { }); // non-fatal SQLite snapshot
+    return inSafetyScope(cwd, async (cwd) => {
+        log.info({ context }, 'Forcing checkpoint');
+        await gitCheckpoint('manual', context, cwd);
+        vacuumIntoBackup({ cwd, force: true }).catch(() => { }); // non-fatal SQLite snapshot
+    });
 }
 /**
  * Disable all safety for current process.
@@ -292,202 +310,222 @@ export class SafetyError extends Error {
  * @throws SafetyError if task exists and strict mode is enabled
  */
 export async function checkTaskExists(taskId, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    if (!cfg.detectCollisions)
-        return false;
-    const db = await getDb(cwd);
-    const existing = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
-    const exists = existing.length > 0;
-    if (exists && cfg.strictMode) {
-        throw new SafetyError(`Task ID collision detected: ${taskId} already exists`, 'COLLISION_DETECTED', { taskId, existingTask: existing[0] });
-    }
-    return exists;
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        if (!cfg.detectCollisions)
+            return false;
+        const db = await getDb(cwd);
+        const existing = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
+        const exists = existing.length > 0;
+        if (exists && cfg.strictMode) {
+            throw new SafetyError(`Task ID collision detected: ${taskId} already exists`, 'COLLISION_DETECTED', { taskId, existingTask: existing[0] });
+        }
+        return exists;
+    });
 }
 /**
  * Verify a task was actually written to the database.
  * @throws SafetyError if verification fails
  */
 export async function verifyTaskWrite(taskId, expectedData, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    if (!cfg.verifyWrites)
-        return true;
-    const db = await getDb(cwd);
-    const rows = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
-    if (rows.length === 0) {
-        if (cfg.strictMode) {
-            throw new SafetyError(`Write verification failed: Task ${taskId} not found after write`, 'WRITE_VERIFICATION_FAILED', { taskId });
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        if (!cfg.verifyWrites)
+            return true;
+        const db = await getDb(cwd);
+        const rows = await db.select().from(schema.tasks).where(eq(schema.tasks.id, taskId)).all();
+        if (rows.length === 0) {
+            if (cfg.strictMode) {
+                throw new SafetyError(`Write verification failed: Task ${taskId} not found after write`, 'WRITE_VERIFICATION_FAILED', { taskId });
+            }
+            return false;
         }
-        return false;
-    }
-    // Verify expected data if provided
-    if (expectedData) {
-        const row = rows[0];
-        for (const [key, value] of Object.entries(expectedData)) {
-            if (value !== undefined && row[key] !== value) {
-                if (cfg.strictMode) {
-                    throw new SafetyError(`Write verification failed: Task ${taskId} field ${key} mismatch`, 'WRITE_VERIFICATION_MISMATCH', { taskId, field: key, expected: value, actual: row[key] });
+        // Verify expected data if provided
+        if (expectedData) {
+            const row = rows[0];
+            for (const [key, value] of Object.entries(expectedData)) {
+                if (value !== undefined && row[key] !== value) {
+                    if (cfg.strictMode) {
+                        throw new SafetyError(`Write verification failed: Task ${taskId} field ${key} mismatch`, 'WRITE_VERIFICATION_MISMATCH', { taskId, field: key, expected: value, actual: row[key] });
+                    }
+                    return false;
                 }
-                return false;
             }
         }
-    }
-    return true;
+        return true;
+    });
 }
 /**
  * Validate and repair sequence if necessary.
  * @returns true if sequence was valid or successfully repaired
  */
 export async function validateAndRepairSequence(cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    if (!cfg.validateSequence)
-        return { valid: true, repaired: false };
-    try {
-        const check = await checkSequence(cwd);
-        if (check.valid) {
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        if (!cfg.validateSequence)
+            return { valid: true, repaired: false };
+        try {
+            const check = await checkSequence(cwd);
+            if (check.valid) {
+                return { valid: true, repaired: false };
+            }
+            // Sequence is behind, repair it
+            const repair = await repairSequence(cwd);
+            if (repair.repaired) {
+                log.warn({ oldCounter: repair.oldCounter, newCounter: repair.newCounter }, 'Sequence repaired');
+                return {
+                    valid: true,
+                    repaired: true,
+                    oldCounter: repair.oldCounter,
+                    newCounter: repair.newCounter,
+                };
+            }
+            // repairSequence returning repaired:false means "already valid, nothing to do"
             return { valid: true, repaired: false };
         }
-        // Sequence is behind, repair it
-        const repair = await repairSequence(cwd);
-        if (repair.repaired) {
-            log.warn({ oldCounter: repair.oldCounter, newCounter: repair.newCounter }, 'Sequence repaired');
-            return {
-                valid: true,
-                repaired: true,
-                oldCounter: repair.oldCounter,
-                newCounter: repair.newCounter,
-            };
-        }
-        // repairSequence returning repaired:false means "already valid, nothing to do"
-        return { valid: true, repaired: false };
-    }
-    catch (err) {
-        if (cfg.strictMode) {
-            throw new SafetyError(`Sequence validation failed: ${String(err)}`, 'SEQUENCE_VALIDATION_FAILED', { error: String(err) });
+        catch (err) {
+            if (cfg.strictMode) {
+                throw new SafetyError(`Sequence validation failed: ${String(err)}`, 'SEQUENCE_VALIDATION_FAILED', { error: String(err) });
+            }
+            return { valid: false, repaired: false };
         }
-        return { valid: false, repaired: false };
-    }
+    });
 }
 /**
  * Trigger auto-checkpoint after a successful task write.
  */
 export async function triggerCheckpoint(context, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    if (!cfg.autoCheckpoint)
-        return;
-    try {
-        await gitCheckpoint('auto', context, cwd);
-    }
-    catch (err) {
-        // Checkpoint failures are non-fatal but should be logged
-        log.warn({ err }, 'Checkpoint failed (non-fatal)');
-    }
-    vacuumIntoBackup({ cwd }).catch(() => { }); // non-fatal SQLite snapshot
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        if (!cfg.autoCheckpoint)
+            return;
+        try {
+            await gitCheckpoint('auto', context, cwd);
+        }
+        catch (err) {
+            // Checkpoint failures are non-fatal but should be logged
+            log.warn({ err }, 'Checkpoint failed (non-fatal)');
+        }
+        vacuumIntoBackup({ cwd }).catch(() => { }); // non-fatal SQLite snapshot
+    });
 }
 /**
  * Safely create a task with all safety mechanisms.
  * Wraps the actual createTask operation.
  */
 export async function safeCreateTask(createFn, task, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    // 1. Validate sequence before creation
-    if (cfg.validateSequence) {
-        await validateAndRepairSequence(cwd, config);
-    }
-    // 2. Check for collisions
-    if (cfg.detectCollisions) {
-        await checkTaskExists(task.id, cwd, config);
-    }
-    // 3. Perform the actual creation
-    const result = await createFn();
-    // 4. Trigger checkpoint
-    if (cfg.autoCheckpoint) {
-        await triggerCheckpoint(`created ${task.id}`, cwd, config);
-    }
-    return result;
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        // 1. Validate sequence before creation
+        if (cfg.validateSequence) {
+            await validateAndRepairSequence(cwd, config);
+        }
+        // 2. Check for collisions
+        if (cfg.detectCollisions) {
+            await checkTaskExists(task.id, cwd, config);
+        }
+        // 3. Perform the actual creation
+        const result = await createFn();
+        // 4. Trigger checkpoint
+        if (cfg.autoCheckpoint) {
+            await triggerCheckpoint(`created ${task.id}`, cwd, config);
+        }
+        return result;
+    });
 }
 /**
  * Safely update a task with all safety mechanisms.
  */
 export async function safeUpdateTask(updateFn, taskId, _updates, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    // 1. Perform the actual update
-    const result = await updateFn();
-    if (!result)
-        return null;
-    // 2. Trigger checkpoint
-    if (cfg.autoCheckpoint) {
-        await triggerCheckpoint(`updated ${taskId}`, cwd, config);
-    }
-    return result;
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        // 1. Perform the actual update
+        const result = await updateFn();
+        if (!result)
+            return null;
+        // 2. Trigger checkpoint
+        if (cfg.autoCheckpoint) {
+            await triggerCheckpoint(`updated ${taskId}`, cwd, config);
+        }
+        return result;
+    });
 }
 /**
  * Safely delete a task with all safety mechanisms.
  */
 export async function safeDeleteTask(deleteFn, taskId, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    // 1. Perform the actual deletion
-    const result = await deleteFn();
-    if (!result)
-        return false;
-    // 2. Trigger checkpoint
-    if (cfg.autoCheckpoint) {
-        await triggerCheckpoint(`deleted ${taskId}`, cwd, config);
-    }
-    return result;
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        // 1. Perform the actual deletion
+        const result = await deleteFn();
+        if (!result)
+            return false;
+        // 2. Trigger checkpoint
+        if (cfg.autoCheckpoint) {
+            await triggerCheckpoint(`deleted ${taskId}`, cwd, config);
+        }
+        return result;
+    });
 }
 /**
  * Verify a session write landed in the database.
  * @throws SafetyError if verification fails in strict mode
  */
 export async function verifySessionWrite(sessionId, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    if (!cfg.verifyWrites)
-        return true;
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.sessions)
-        .where(eq(schema.sessions.id, sessionId))
-        .all();
-    if (rows.length === 0) {
-        if (cfg.strictMode) {
-            throw new SafetyError(`Write verification failed: Session ${sessionId} not found after write`, 'SESSION_WRITE_VERIFICATION_FAILED', { sessionId });
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        if (!cfg.verifyWrites)
+            return true;
+        const db = await getDb(cwd);
+        const rows = await db
+            .select()
+            .from(schema.sessions)
+            .where(eq(schema.sessions.id, sessionId))
+            .all();
+        if (rows.length === 0) {
+            if (cfg.strictMode) {
+                throw new SafetyError(`Write verification failed: Session ${sessionId} not found after write`, 'SESSION_WRITE_VERIFICATION_FAILED', { sessionId });
+            }
+            return false;
         }
-        return false;
-    }
-    return true;
+        return true;
+    });
 }
 /**
  * Safely create a session with all safety mechanisms.
  */
 export async function safeCreateSession(createFn, session, cwd, config = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    // 1. Perform the actual creation
-    const result = await createFn();
-    // 2. Verify the write
-    if (cfg.verifyWrites) {
-        await verifySessionWrite(session.id, cwd, config);
-    }
-    // 3. Trigger checkpoint
-    if (cfg.autoCheckpoint) {
-        await triggerCheckpoint(`session ${session.id} started`, cwd, config);
-    }
-    return result;
+    return inSafetyScope(cwd, async (cwd) => {
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        // 1. Perform the actual creation
+        const result = await createFn();
+        // 2. Verify the write
+        if (cfg.verifyWrites) {
+            await verifySessionWrite(session.id, cwd, config);
+        }
+        // 3. Trigger checkpoint
+        if (cfg.autoCheckpoint) {
+            await triggerCheckpoint(`session ${session.id} started`, cwd, config);
+        }
+        return result;
+    });
 }
 /**
  * Force a checkpoint before destructive operations.
  * Use this before migrations, bulk updates, etc.
  */
 export async function forceCheckpointBeforeOperation(operation, cwd) {
-    log.info({ operation }, 'Forcing checkpoint before operation');
-    try {
-        await gitCheckpoint('manual', `pre-${operation}`, cwd);
-    }
-    catch (err) {
-        log.error({ err }, 'Failed to create pre-operation checkpoint');
-        // Don't throw - checkpoint failures shouldn't block operations
-    }
-    vacuumIntoBackup({ cwd, force: true }).catch(() => { }); // non-fatal SQLite snapshot
+    return inSafetyScope(cwd, async (cwd) => {
+        log.info({ operation }, 'Forcing checkpoint before operation');
+        try {
+            await gitCheckpoint('manual', `pre-${operation}`, cwd);
+        }
+        catch (err) {
+            log.error({ err }, 'Failed to create pre-operation checkpoint');
+            // Don't throw - checkpoint failures shouldn't block operations
+        }
+        vacuumIntoBackup({ cwd, force: true }).catch(() => { }); // non-fatal SQLite snapshot
+    });
 }
 /**
  * Run a sequence-focused integrity check keyed only by working directory.
@@ -497,30 +535,32 @@ export async function forceCheckpointBeforeOperation(operation, cwd) {
  * only. Retained for the lightweight `cwd`-only integrity probe.
  */
 export async function runSequenceIntegrityCheck(cwd) {
-    const issues = [];
-    const repairs = [];
-    // 1. Check sequence
-    try {
-        const seqCheck = await checkSequence(cwd);
-        if (!seqCheck.valid) {
-            issues.push(`Sequence invalid: counter ${seqCheck.counter} < max ID T${seqCheck.maxIdInData}`);
-            // Auto-repair
-            const repair = await repairSequence(cwd);
-            if (repair.repaired) {
-                repairs.push(`Sequence repaired: ${repair.oldCounter} -> ${repair.newCounter}`);
-            }
-            else {
-                issues.push('Sequence repair failed');
+    return inSafetyScope(cwd, async (cwd) => {
+        const issues = [];
+        const repairs = [];
+        // 1. Check sequence
+        try {
+            const seqCheck = await checkSequence(cwd);
+            if (!seqCheck.valid) {
+                issues.push(`Sequence invalid: counter ${seqCheck.counter} < max ID T${seqCheck.maxIdInData}`);
+                // Auto-repair
+                const repair = await repairSequence(cwd);
+                if (repair.repaired) {
+                    repairs.push(`Sequence repaired: ${repair.oldCounter} -> ${repair.newCounter}`);
+                }
+                else {
+                    issues.push('Sequence repair failed');
+                }
             }
         }
-    }
-    catch (err) {
-        issues.push(`Sequence check failed: ${String(err)}`);
-    }
-    return {
-        passed: issues.length === repairs.length,
-        issues,
-        repairs,
-    };
+        catch (err) {
+            issues.push(`Sequence check failed: ${String(err)}`);
+        }
+        return {
+            passed: issues.length === repairs.length,
+            issues,
+            repairs,
+        };
+    });
 }
 //# sourceMappingURL=data-safety-central.js.map