hzl-core 2.3.0 → 2.4.0

package/dist/services/task-service.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { EventType, TaskStatus, } from '../events/types.js';
 import { withWriteTransaction } from '../db/transaction.js';
 import { generateId } from '../utils/id.js';
@@ -11,11 +13,6 @@ export class TaskNotClaimableError extends Error {
         super(`Task ${taskId} is not claimable: ${reason}`);
     }
 }
-export class DependenciesNotDoneError extends Error {
-    constructor(taskId, pendingDeps) {
-        super(`Task ${taskId} has dependencies not done: ${pendingDeps.join(', ')}`);
-    }
-}
 export class AmbiguousPrefixError extends Error {
     matches;
     constructor(prefix, matches) {
@@ -55,18 +52,26 @@ function validateProgress(progress) {
         throw new InvalidProgressError();
     }
 }
+function arraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
 export class TaskService {
     db;
     eventStore;
     projectionEngine;
     projectService;
     eventsDb;
-    getIncompleteDepsStmt;
+    static PRUNE_JOURNAL_FILENAME = 'prune-journal.json';
+    static ATTACHED_EVENTS_SCHEMA = 'events_src';
     getSubtasksStmt;
     getTaskByIdStmt;
     resolveTaskIdStmt;
     hookOutboxAvailable = null;
     onDoneHook;
+    pruneJournalPath;
     constructor(db, // cache database
     eventStore, projectionEngine, projectService, eventsDb, // events database for pruning
     options) {
@@ -76,13 +81,7 @@ export class TaskService {
         this.projectService = projectService;
         this.eventsDb = eventsDb;
         this.onDoneHook = options?.onDone;
-        this.getIncompleteDepsStmt = db.prepare(`
-      SELECT td.depends_on_id
-      FROM task_dependencies td
-      LEFT JOIN tasks_current tc ON tc.task_id = td.depends_on_id
-      WHERE td.task_id = ?
-        AND (tc.status IS NULL OR tc.status != 'done')
-    `);
+        this.pruneJournalPath = this.resolvePruneJournalPath(options?.pruneJournalPath);
         this.getSubtasksStmt = db.prepare(`
       SELECT task_id, title, project, status, parent_id, description,
              links, tags, priority, due_at, metadata,
@@ -103,6 +102,7 @@ export class TaskService {
         this.resolveTaskIdStmt = db.prepare(`
       SELECT task_id, title FROM tasks_current WHERE task_id LIKE ? || '%' ESCAPE '\\'
     `);
+        this.recoverPruneJournalIfNeeded();
     }
     emitComment(taskId, text, ctx) {
         // Validate comment text - same validation as addComment
@@ -316,15 +316,11 @@ export class TaskService {
             const task = this.getTaskById(taskId);
             if (!task)
                 throw new TaskNotFoundError(taskId);
-            if (task.status !== TaskStatus.Ready) {
-                throw new TaskNotClaimableError(taskId, `status is ${task.status}, must be ready`);
-            }
-            const incompleteDeps = this.getIncompleteDepsStmt.all(taskId);
-            if (incompleteDeps.length > 0) {
-                throw new DependenciesNotDoneError(taskId, incompleteDeps.map(d => d.depends_on_id));
+            if (task.status === TaskStatus.Done || task.status === TaskStatus.Archived) {
+                throw new TaskNotClaimableError(taskId, `status is ${task.status}, must not be done or archived`);
             }
             const eventData = {
-                from: TaskStatus.Ready,
+                from: task.status,
                 to: TaskStatus.InProgress,
             };
             if (opts?.lease_until)
@@ -345,6 +341,13 @@ export class TaskService {
             const task = this.getTaskById(taskId);
             if (!task)
                 throw new TaskNotFoundError(taskId);
+            // No-op on self-transition
+            if (task.status === toStatus) {
+                return task;
+            }
+            if (task.status === TaskStatus.Archived) {
+                throw new InvalidStatusTransitionError(`Cannot change status: task is archived`);
+            }
             const event = this.eventStore.append({
                 task_id: taskId,
                 type: EventType.StatusChanged,
@@ -850,7 +853,7 @@ export class TaskService {
      * Used by the web dashboard.
      */
     listTasks(opts = {}) {
-        const { sinceDays = 3, project, dueMonth } = opts;
+        const { sinceDays = 3, project, dueMonth, tag } = opts;
         const conditions = ["status != 'archived'"];
         const params = [];
         if (dueMonth) {
@@ -883,10 +886,14 @@ export class TaskService {
             conditions.push('project = ?');
             params.push(project);
         }
+        if (tag) {
+            conditions.push('EXISTS (SELECT 1 FROM task_tags WHERE task_id = tasks_current.task_id AND tag = ?)');
+            params.push(tag);
+        }
         const sql = `
       SELECT task_id, title, project, status, priority,
              agent, progress, lease_until, updated_at,
-             parent_id, due_at
+             parent_id, due_at, tags
       FROM tasks_current
       WHERE ${conditions.join(' AND ')}
       ORDER BY priority DESC, updated_at DESC
@@ -905,8 +912,22 @@ export class TaskService {
             parent_id: row.parent_id,
             progress: row.progress,
             due_at: row.due_at,
+            tags: JSON.parse(row.tags),
         }));
     }
+    /**
+     * Get distinct tags with their task counts, excluding archived tasks.
+     */
+    getTagCounts() {
+        return this.db.prepare(`
+      SELECT tt.tag, COUNT(*) as count
+      FROM task_tags tt
+      JOIN tasks_current tc ON tt.task_id = tc.task_id
+      WHERE tc.status != 'archived'
+      GROUP BY tt.tag
+      ORDER BY tt.tag
+    `).all();
+    }
     /**
      * Get a map of task_id -> array of blocking task ids.
      * A task is blocked if it's in 'ready' status but has incomplete dependencies.
@@ -1110,6 +1131,42 @@ export class TaskService {
             return this.getTaskById(taskId);
         });
     }
+    updateTask(taskId, updates, ctx) {
+        return withWriteTransaction(this.db, () => {
+            const task = this.getTaskById(taskId);
+            if (!task)
+                throw new TaskNotFoundError(taskId);
+            const emitFieldUpdate = (field, oldValue, newValue) => {
+                const event = this.eventStore.append({
+                    task_id: taskId,
+                    type: EventType.TaskUpdated,
+                    data: { field, old_value: oldValue, new_value: newValue },
+                    author: ctx?.author,
+                    agent_id: ctx?.agent_id,
+                    session_id: ctx?.session_id,
+                    correlation_id: ctx?.correlation_id,
+                    causation_id: ctx?.causation_id,
+                });
+                this.projectionEngine.applyEvent(event);
+            };
+            if (updates.title !== undefined && updates.title !== task.title) {
+                emitFieldUpdate('title', task.title, updates.title);
+            }
+            if (updates.description !== undefined && updates.description !== task.description) {
+                emitFieldUpdate('description', task.description, updates.description);
+            }
+            if (updates.priority !== undefined && updates.priority !== task.priority) {
+                emitFieldUpdate('priority', task.priority, updates.priority);
+            }
+            if (updates.tags !== undefined && !arraysEqual(updates.tags, task.tags)) {
+                emitFieldUpdate('tags', task.tags, updates.tags);
+            }
+            if (updates.links !== undefined && !arraysEqual(updates.links, task.links)) {
+                emitFieldUpdate('links', task.links, updates.links);
+            }
+            return this.getTaskById(taskId);
+        });
+    }
     orphanSubtasks(parentTaskId, opts) {
         const subtasks = this.getSubtasks(parentTaskId);
         for (const subtask of subtasks) {
@@ -1287,36 +1344,85 @@ export class TaskService {
      * Recomputes eligibility inside the prune transaction to avoid TOCTOU.
      */
     pruneEligible(opts) {
+        // Single DB mode (combined events+cache database) retains existing behavior.
+        if (!this.eventsDb || this.eventsDb === this.db) {
+            return withWriteTransaction(this.db, () => this.pruneEligibleWithinTransaction(opts, this.db, 'main'));
+        }
+        const eventsDbPath = this.getDatabasePath(this.eventsDb);
+        if (!eventsDbPath) {
+            return this.pruneEligibleWithJournalFallback(opts);
+        }
+        this.db.prepare(`ATTACH DATABASE ? AS ${TaskService.ATTACHED_EVENTS_SCHEMA}`).run(eventsDbPath);
+        try {
+            return withWriteTransaction(this.db, () => this.pruneEligibleWithinTransaction(opts, this.db, TaskService.ATTACHED_EVENTS_SCHEMA));
+        }
+        finally {
+            this.db.exec(`DETACH DATABASE ${TaskService.ATTACHED_EVENTS_SCHEMA}`);
+        }
+    }
+    pruneEligibleWithinTransaction(opts, txDb, eventsSchema) {
+        // Recompute inside transaction to avoid TOCTOU races.
+        const eligibleTasks = this.previewPrunableTasks(opts);
+        if (eligibleTasks.length === 0) {
+            return {
+                pruned: [],
+                count: 0,
+                eventsDeleted: 0,
+            };
+        }
+        const taskIds = eligibleTasks.map(t => t.task_id);
+        // Delete events first (source of truth), then projections.
+        const eventsDeleted = this.deleteTasksFromEvents(txDb, taskIds, eventsSchema);
+        this.deleteTasksFromProjections(txDb, taskIds);
+        return {
+            pruned: eligibleTasks,
+            count: eligibleTasks.length,
+            eventsDeleted,
+        };
+    }
+    pruneEligibleWithJournalFallback(opts) {
         if (!this.eventsDb) {
             throw new Error('TaskService: eventsDb not provided, cannot prune tasks');
         }
-        return withWriteTransaction(this.eventsDb, () => {
-            // First, get eligible tasks (recompute to avoid TOCTOU race)
-            const eligibleTasks = this.previewPrunableTasks(opts);
-            if (eligibleTasks.length === 0) {
-                return {
-                    pruned: [],
-                    count: 0,
-                    eventsDeleted: 0,
-                };
-            }
-            const taskIds = eligibleTasks.map(t => t.task_id);
-            // Delete events first (source of truth) - requires trigger bypass
-            // This ordering is intentional: if projection deletion fails after events
-            // are deleted, the projections can be rebuilt from remaining events.
-            // The reverse (projections deleted, events remaining) would leave orphan
-            // events that recreate projections on rebuild.
-            const eventsDeleted = this.deleteTasksFromEvents(taskIds);
-            // Delete from projections (cache.db) - derived state, recoverable
-            this.deleteTasksFromProjections(taskIds);
+        if (!this.pruneJournalPath) {
+            throw new Error('TaskService: prune journal path unavailable for cross-db fallback');
+        }
+        const eligibleTasks = this.previewPrunableTasks(opts);
+        if (eligibleTasks.length === 0) {
             return {
-                pruned: eligibleTasks,
-                count: eligibleTasks.length,
-                eventsDeleted,
+                pruned: [],
+                count: 0,
+                eventsDeleted: 0,
             };
-        });
+        }
+        const taskIds = eligibleTasks.map(t => t.task_id);
+        this.writePruneJournal(taskIds);
+        let eventsDeleted = 0;
+        try {
+            eventsDeleted = withWriteTransaction(this.eventsDb, () => this.deleteTasksFromEvents(this.eventsDb, taskIds, 'main'));
+        }
+        catch (err) {
+            // Events prune did not complete; do not keep stale recovery journal.
+            this.deletePruneJournal();
+            throw err;
+        }
+        try {
+            withWriteTransaction(this.db, () => {
+                this.deleteTasksFromProjections(this.db, taskIds);
+            });
+            this.deletePruneJournal();
+        }
+        catch (err) {
+            // Keep journal for constructor-time recovery on next startup.
+            throw err;
+        }
+        return {
+            pruned: eligibleTasks,
+            count: eligibleTasks.length,
+            eventsDeleted,
+        };
     }
-    deleteTasksFromProjections(taskIds) {
+    deleteTasksFromProjections(db, taskIds) {
         // Delete from all projection tables in order
         const tables = [
             'task_comments',
@@ -1327,9 +1433,10 @@ export class TaskService {
             'tasks_current',
         ];
         // Create temp table once to avoid SQLite parameter limits
-        this.db.exec('CREATE TEMP TABLE IF NOT EXISTS prune_targets (task_id TEXT PRIMARY KEY)');
-        this.db.exec('DELETE FROM prune_targets'); // Clear any previous data
-        const insert = this.db.prepare('INSERT INTO prune_targets (task_id) VALUES (?)');
+        const tempTable = 'prune_targets_projection';
+        db.exec(`CREATE TEMP TABLE IF NOT EXISTS ${tempTable} (task_id TEXT PRIMARY KEY)`);
+        db.exec(`DELETE FROM ${tempTable}`); // Clear any previous data
+        const insert = db.prepare(`INSERT INTO ${tempTable} (task_id) VALUES (?)`);
         for (const id of taskIds) {
             insert.run(id);
         }
@@ -1337,62 +1444,158 @@ export class TaskService {
         for (const table of tables) {
             if (table === 'task_dependencies') {
                 // Delete both directions
-                this.db.exec('DELETE FROM task_dependencies WHERE task_id IN (SELECT task_id FROM prune_targets) OR depends_on_id IN (SELECT task_id FROM prune_targets)');
+                db.exec(`DELETE FROM task_dependencies WHERE task_id IN (SELECT task_id FROM ${tempTable}) OR depends_on_id IN (SELECT task_id FROM ${tempTable})`);
             }
             else if (table === 'task_search') {
                 // FTS table uses different syntax
-                this.db.exec('DELETE FROM task_search WHERE task_id IN (SELECT task_id FROM prune_targets)');
+                db.exec(`DELETE FROM task_search WHERE task_id IN (SELECT task_id FROM ${tempTable})`);
             }
             else {
-                this.db.exec(`DELETE FROM ${table} WHERE task_id IN (SELECT task_id FROM prune_targets)`);
+                db.exec(`DELETE FROM ${table} WHERE task_id IN (SELECT task_id FROM ${tempTable})`);
             }
         }
-        this.db.exec('DROP TABLE prune_targets');
+        db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
     }
-    deleteTasksFromEvents(taskIds) {
-        const eventsDb = this.eventsDb; // Non-null assertion safe: checked in pruneEligible
+    deleteTasksFromEvents(db, taskIds, eventsSchema) {
+        const triggerPrefix = eventsSchema === 'main' ? '' : `${eventsSchema}.`;
+        const eventsTable = eventsSchema === 'main' ? 'events' : `${eventsSchema}.events`;
+        const tempTable = 'prune_targets_events';
         // Disable triggers
-        eventsDb.exec('DROP TRIGGER IF EXISTS events_no_delete');
-        eventsDb.exec('DROP TRIGGER IF EXISTS events_no_update');
+        db.exec(`DROP TRIGGER IF EXISTS ${triggerPrefix}events_no_delete`);
+        db.exec(`DROP TRIGGER IF EXISTS ${triggerPrefix}events_no_update`);
         try {
             // Create temp table to avoid SQLite parameter limits on large prune sets
-            eventsDb.exec('CREATE TEMP TABLE prune_targets (task_id TEXT PRIMARY KEY)');
-            const insert = eventsDb.prepare('INSERT INTO prune_targets (task_id) VALUES (?)');
+            db.exec(`CREATE TEMP TABLE IF NOT EXISTS ${tempTable} (task_id TEXT PRIMARY KEY)`);
+            db.exec(`DELETE FROM ${tempTable}`);
+            const insert = db.prepare(`INSERT INTO ${tempTable} (task_id) VALUES (?)`);
             for (const id of taskIds) {
                 insert.run(id);
             }
-            const result = eventsDb
-                .prepare('DELETE FROM events WHERE task_id IN (SELECT task_id FROM prune_targets)')
+            const result = db
+                .prepare(`DELETE FROM ${eventsTable} WHERE task_id IN (SELECT task_id FROM ${tempTable})`)
                 .run();
-            eventsDb.exec('DROP TABLE prune_targets');
             // Re-enable triggers
-            this.recreateEventTriggers();
+            this.recreateEventTriggers(db, eventsSchema);
+            db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
             return result.changes;
         }
         catch (err) {
             // Re-enable triggers even on error
-            this.recreateEventTriggers();
+            this.recreateEventTriggers(db, eventsSchema);
+            db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
             throw err;
         }
     }
-    recreateEventTriggers() {
-        const eventsDb = this.eventsDb; // Non-null assertion safe: checked in pruneEligible
+    recreateEventTriggers(db, eventsSchema) {
+        // In SQLite, `CREATE TRIGGER schema.name BEFORE UPDATE ON table` resolves
+        // `table` within the schema specified by the trigger name prefix.
+        // So `events_src.events_no_update BEFORE UPDATE ON events` correctly targets
+        // the `events` table inside the attached `events_src` database.
+        // Note: the table name in the ON clause MUST be unqualified — SQLite does not
+        // allow schema-qualified table names there (it would be a syntax error).
+        const triggerPrefix = eventsSchema === 'main' ? '' : `${eventsSchema}.`;
         const EVENTS_TRIGGERS_SQL = `
       -- Append-only enforcement: prevent UPDATE on events
-      CREATE TRIGGER IF NOT EXISTS events_no_update
+      CREATE TRIGGER IF NOT EXISTS ${triggerPrefix}events_no_update
       BEFORE UPDATE ON events
       BEGIN
           SELECT RAISE(ABORT, 'Events table is append-only: cannot UPDATE');
       END;
 
       -- Append-only enforcement: prevent DELETE on events
-      CREATE TRIGGER IF NOT EXISTS events_no_delete
+      CREATE TRIGGER IF NOT EXISTS ${triggerPrefix}events_no_delete
       BEFORE DELETE ON events
       BEGIN
           SELECT RAISE(ABORT, 'Events table is append-only: cannot DELETE');
       END;
     `;
-        eventsDb.exec(EVENTS_TRIGGERS_SQL);
+        db.exec(EVENTS_TRIGGERS_SQL);
+    }
+    getDatabasePath(db) {
+        const rows = db.prepare('PRAGMA database_list').all();
+        const mainRow = rows.find(row => row.name === 'main');
+        const filePath = mainRow?.file;
+        if (!filePath || filePath === ':memory:') {
+            return null;
+        }
+        return filePath;
+    }
+    resolvePruneJournalPath(explicitPath) {
+        if (explicitPath) {
+            return explicitPath;
+        }
+        const cachePath = this.getDatabasePath(this.db);
+        if (cachePath) {
+            return path.join(path.dirname(cachePath), TaskService.PRUNE_JOURNAL_FILENAME);
+        }
+        if (this.eventsDb) {
+            const eventsPath = this.getDatabasePath(this.eventsDb);
+            if (eventsPath) {
+                return path.join(path.dirname(eventsPath), TaskService.PRUNE_JOURNAL_FILENAME);
+            }
+        }
+        return null;
+    }
+    writePruneJournal(taskIds) {
+        if (!this.pruneJournalPath) {
+            throw new Error('TaskService: prune journal path unavailable');
+        }
+        fs.mkdirSync(path.dirname(this.pruneJournalPath), { recursive: true });
+        fs.writeFileSync(this.pruneJournalPath, JSON.stringify({
+            taskIds,
+            createdAt: new Date().toISOString(),
+        }, null, 2), 'utf8');
+    }
+    deletePruneJournal() {
+        if (!this.pruneJournalPath) {
+            return;
+        }
+        if (fs.existsSync(this.pruneJournalPath)) {
+            fs.unlinkSync(this.pruneJournalPath);
+        }
+    }
+    readPruneJournalTaskIds() {
+        if (!this.pruneJournalPath || !fs.existsSync(this.pruneJournalPath)) {
+            return null;
+        }
+        const raw = fs.readFileSync(this.pruneJournalPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.taskIds)) {
+            throw new Error('Invalid prune journal payload');
+        }
+        const taskIds = parsed.taskIds.filter((value) => typeof value === 'string');
+        if (taskIds.length === 0) {
+            throw new Error('Invalid prune journal payload');
+        }
+        return taskIds;
+    }
+    recoverPruneJournalIfNeeded() {
+        if (!this.pruneJournalPath) {
+            return;
+        }
+        let taskIds = null;
+        try {
+            taskIds = this.readPruneJournalTaskIds();
+        }
+        catch {
+            // Invalid journal payload should not block startup.
+            this.deletePruneJournal();
+            return;
+        }
+        if (!taskIds || taskIds.length === 0) {
+            this.deletePruneJournal();
+            return;
+        }
+        try {
+            const recoveryTaskIds = taskIds;
+            withWriteTransaction(this.db, () => {
+                this.deleteTasksFromProjections(this.db, recoveryTaskIds);
+            });
+            this.deletePruneJournal();
+        }
+        catch {
+            // Keep the journal for next startup retry.
+        }
     }
     rowToTask(row) {
         return {