agent-tasks 1.7.1 → 1.9.1

package/dist/domain/tasks.js

@@ -5,7 +5,8 @@
 // All mutations emit events. All inputs are validated.
 // =============================================================================
 import { NotFoundError, ConflictError, ValidationError } from '../types.js';
-import { MAX_TITLE_LENGTH, MAX_DESCRIPTION_LENGTH, MAX_RESULT_LENGTH, MAX_ARTIFACT_CONTENT_LENGTH, MAX_ARTIFACT_NAME_LENGTH, MAX_PROJECT_NAME_LENGTH, MAX_TAG_LENGTH, MAX_TAGS_COUNT, MAX_STAGE_NAME_LENGTH, MAX_STAGES_COUNT, MAX_LIST_LIMIT, rejectNullBytes, rejectControlChars, } from './validate.js';
+import { MAX_STAGE_NAME_LENGTH, MAX_STAGES_COUNT, MAX_LIST_LIMIT, rejectNullBytes, rejectControlChars, } from './validate.js';
+import { validateTitle, validateDescription, validateResult, validateProjectName, validateAssignee, validateTags, validateArtifactName, validateArtifactContent, } from './task-validator.js';
 export const DEFAULT_STAGES = [
     'backlog',
     'spec',
@@ -26,34 +27,69 @@ const VALID_STATUSES = [
 export class TaskService {
     db;
     events;
+    configCache = new Map();
+    static CONFIG_CACHE_TTL = 30_000;
     constructor(db, events) {
         this.db = db;
         this.events = events;
     }
-    // ---- Pipeline Config ----
-    getPipelineStages(project) {
-        if (project) {
-            const config = this.db.queryOne('SELECT * FROM pipeline_config WHERE project = ?', [project]);
-            if (config) {
+    // ---- Pipeline Config (cached) ----
+    getCachedConfig(project) {
+        const entry = this.configCache.get(project);
+        if (entry && Date.now() - entry.at < TaskService.CONFIG_CACHE_TTL) {
+            return { stages: entry.stages, gate: entry.gate };
+        }
+        return null;
+    }
+    invalidateConfigCache(project) {
+        this.configCache.delete(project);
+    }
+    loadAndCacheConfig(project) {
+        const config = this.db.queryOne('SELECT * FROM pipeline_config WHERE project = ?', [project]);
+        let stages = [...DEFAULT_STAGES];
+        let gate = null;
+        if (config) {
+            try {
+                stages = JSON.parse(config.stages);
+            }
+            catch {
+                // fall back to defaults
+            }
+            if (config.gate_config) {
                 try {
-                    return JSON.parse(config.stages);
+                    gate = JSON.parse(config.gate_config);
                 }
                 catch {
-                    /* fall through */
+                    // fall back to null
                 }
             }
         }
-        return [...DEFAULT_STAGES];
+        this.configCache.set(project, { stages, gate, at: Date.now() });
+        return { stages, gate };
+    }
+    getPipelineStages(project) {
+        if (!project)
+            return [...DEFAULT_STAGES];
+        const cached = this.getCachedConfig(project);
+        if (cached)
+            return cached.stages;
+        return this.loadAndCacheConfig(project).stages;
     }
     getAllGateConfigs() {
         const configs = this.db.queryAll('SELECT * FROM pipeline_config WHERE gate_config IS NOT NULL');
         const result = {};
         for (const c of configs) {
             try {
-                result[c.project] = JSON.parse(c.gate_config);
+                const gate = JSON.parse(c.gate_config);
+                result[c.project] = gate;
+                const cached = this.configCache.get(c.project);
+                if (cached) {
+                    cached.gate = gate;
+                    cached.at = Date.now();
+                }
             }
             catch {
-                /* skip invalid */
+                // skip corrupt entries
             }
         }
         return result;
@@ -61,27 +97,23 @@ export class TaskService {
     getGateConfig(project) {
         if (!project)
             return null;
-        const config = this.db.queryOne('SELECT * FROM pipeline_config WHERE project = ?', [project]);
-        if (!config?.gate_config)
-            return null;
-        try {
-            return JSON.parse(config.gate_config);
-        }
-        catch {
-            return null;
-        }
+        const cached = this.getCachedConfig(project);
+        if (cached)
+            return cached.gate;
+        return this.loadAndCacheConfig(project).gate;
     }
     setGateConfig(project, gateConfig) {
-        this.validateProjectName(project);
+        validateProjectName(project);
         const json = JSON.stringify(gateConfig);
         this.db.run(`INSERT INTO pipeline_config (project, stages, gate_config, updated_at) VALUES (?, ?, ?, datetime('now'))
        ON CONFLICT(project) DO UPDATE SET gate_config = ?, updated_at = datetime('now')`, [project, JSON.stringify(this.getPipelineStages(project)), json, json]);
+        this.invalidateConfigCache(project);
         return this.db.queryOne('SELECT * FROM pipeline_config WHERE project = ?', [
             project,
         ]);
     }
     setPipelineConfig(project, stages) {
-        this.validateProjectName(project);
+        validateProjectName(project);
         if (!stages.length)
             throw new ValidationError('Stages array cannot be empty.');
         if (stages.length > MAX_STAGES_COUNT) {
@@ -101,6 +133,7 @@ export class TaskService {
         const json = JSON.stringify(stages);
         this.db.run(`INSERT INTO pipeline_config (project, stages, updated_at) VALUES (?, ?, datetime('now'))
        ON CONFLICT(project) DO UPDATE SET stages = ?, updated_at = datetime('now')`, [project, json, json]);
+        this.invalidateConfigCache(project);
         this.events.emit('pipeline:configured', { project, stages });
         return this.db.queryOne('SELECT * FROM pipeline_config WHERE project = ?', [
             project,
@@ -108,15 +141,15 @@ export class TaskService {
     }
     // ---- CRUD ----
     create(input, createdBy) {
-        this.validateTitle(input.title);
+        validateTitle(input.title);
         if (input.description !== undefined)
-            this.validateDescription(input.description);
+            validateDescription(input.description);
         if (input.project !== undefined)
-            this.validateProjectName(input.project);
+            validateProjectName(input.project);
         if (input.tags !== undefined)
-            this.validateTags(input.tags);
+            validateTags(input.tags);
         if (input.assign_to !== undefined)
-            this.validateAssignee(input.assign_to);
+            validateAssignee(input.assign_to);
         if (input.parent_id !== undefined)
             this.requireTask(input.parent_id);
         const stages = this.getPipelineStages(input.project);
@@ -143,15 +176,15 @@ export class TaskService {
     update(taskId, updates) {
         const task = this.requireTask(taskId);
         if (updates.title !== undefined)
-            this.validateTitle(updates.title);
+            validateTitle(updates.title);
         if (updates.description !== undefined)
-            this.validateDescription(updates.description);
+            validateDescription(updates.description);
         if (updates.project !== undefined)
-            this.validateProjectName(updates.project);
+            validateProjectName(updates.project);
         if (updates.tags !== undefined)
-            this.validateTags(updates.tags);
+            validateTags(updates.tags);
         if (updates.assigned_to !== undefined && updates.assigned_to !== '') {
-            this.validateAssignee(updates.assigned_to);
+            validateAssignee(updates.assigned_to);
         }
         const sets = [];
         const params = [];
@@ -261,7 +294,7 @@ export class TaskService {
     }
     // ---- Claiming ----
     claim(taskId, claimerName) {
-        this.validateAssignee(claimerName);
+        validateAssignee(claimerName);
         return this.db.transaction(() => {
             const task = this.requireTask(taskId);
             if (task.status !== 'pending') {
@@ -278,9 +311,38 @@ export class TaskService {
             return claimed;
         });
     }
+    // ---- Learnings ----
+    learn(taskId, content, category = 'technique', createdBy = 'system') {
+        const validCategories = ['technique', 'pitfall', 'decision', 'pattern'];
+        if (!validCategories.includes(category)) {
+            throw new ValidationError(`Invalid learning category: ${category}. Valid: ${validCategories.join(', ')}`);
+        }
+        validateArtifactContent(content);
+        const task = this.requireTask(taskId);
+        const prefixedContent = `[${category}] ${content}`;
+        return this.addArtifact(taskId, 'learning', prefixedContent, createdBy, task.stage);
+    }
+    propagateLearnings(task) {
+        if (!task.parent_id)
+            return;
+        const learnings = this.db.queryAll(`SELECT * FROM task_artifacts WHERE task_id = ? AND name = 'learning' ORDER BY created_at ASC`, [task.id]);
+        if (learnings.length === 0)
+            return;
+        for (const learning of learnings) {
+            const parentContent = `Learning from subtask #${task.id}: ${learning.content}`;
+            this.addArtifact(task.parent_id, 'learning', parentContent, 'system');
+        }
+        const siblings = this.db.queryAll(`SELECT * FROM tasks WHERE parent_id = ? AND id != ? AND status = 'in_progress'`, [task.parent_id, task.id]);
+        for (const sibling of siblings) {
+            for (const learning of learnings) {
+                const siblingContent = `Learning from sibling #${task.id}: ${learning.content}`;
+                this.addArtifact(sibling.id, 'learning', siblingContent, 'system');
+            }
+        }
+    }
     // ---- Completion / Failure / Cancellation ----
     complete(taskId, result) {
-        this.validateResult(result);
+        validateResult(result);
         return this.db.transaction(() => {
             const task = this.requireTask(taskId);
             if (task.status !== 'in_progress') {
@@ -289,13 +351,14 @@ export class TaskService {
             const stages = this.getPipelineStages(task.project ?? undefined);
             const doneStage = stages.filter((s) => s !== 'cancelled').pop() ?? 'done';
             this.db.run(`UPDATE tasks SET status = 'completed', stage = ?, result = ?, updated_at = datetime('now') WHERE id = ?`, [doneStage, result, taskId]);
+            this.propagateLearnings(task);
             const completed = this.getById(taskId);
             this.events.emit('task:completed', { task: completed });
             return completed;
         });
     }
     fail(taskId, result) {
-        this.validateResult(result);
+        validateResult(result);
         return this.db.transaction(() => {
             const task = this.requireTask(taskId);
             if (task.status !== 'in_progress') {
@@ -308,7 +371,7 @@ export class TaskService {
         });
     }
     cancel(taskId, reason) {
-        this.validateResult(reason);
+        validateResult(reason);
         return this.db.transaction(() => {
             const task = this.requireTask(taskId);
             if (task.status === 'completed' || task.status === 'cancelled') {
@@ -382,7 +445,7 @@ export class TaskService {
             const newStatus = syncStatusForStage(toStage, stages);
             this.db.run(`UPDATE tasks SET stage = ?, status = ?, updated_at = datetime('now') WHERE id = ?`, [toStage, newStatus, taskId]);
             if (reason) {
-                this.validateResult(reason);
+                validateResult(reason);
                 this.db.run(`INSERT INTO task_artifacts (task_id, stage, name, content, created_by) VALUES (?, ?, ?, ?, ?)`, [
                     taskId,
                     task.stage,
@@ -402,7 +465,7 @@ export class TaskService {
         });
     }
     // ---- Next Task ----
-    next(project, stage) {
+    next(project, stage, agent) {
         let sql = `SELECT t.* FROM tasks t WHERE t.status IN ('pending', 'in_progress') AND t.assigned_to IS NULL`;
         const params = [];
         if (project) {
@@ -418,8 +481,104 @@ export class TaskService {
       JOIN tasks dep ON dep.id = d.depends_on
       WHERE d.task_id = t.id AND d.relationship = 'blocks' AND dep.status NOT IN ('completed', 'cancelled', 'failed')
     )`;
-        sql += ' ORDER BY t.priority DESC, t.created_at ASC LIMIT 1';
-        return this.db.queryOne(sql, params);
+        sql += ' ORDER BY t.priority DESC, t.created_at ASC LIMIT 50';
+        const candidates = this.db.queryAll(sql, params);
+        if (candidates.length === 0)
+            return null;
+        if (!agent || candidates.length === 1) {
+            return { task: candidates[0], affinity_score: 0, affinity_reasons: [] };
+        }
+        const topPriority = candidates[0].priority;
+        const topCandidates = candidates.filter((t) => t.priority === topPriority);
+        if (topCandidates.length <= 1) {
+            return { task: candidates[0], affinity_score: 0, affinity_reasons: [] };
+        }
+        const scored = this.computeAffinityBatch(topCandidates, agent);
+        let bestTask = topCandidates[0];
+        let bestScore = 0;
+        let bestReasons = [];
+        for (const { task: t, score, reasons } of scored) {
+            if (score > bestScore) {
+                bestScore = score;
+                bestReasons = reasons;
+                bestTask = t;
+            }
+        }
+        return { task: bestTask, affinity_score: bestScore, affinity_reasons: bestReasons };
+    }
+    computeAffinityBatch(tasks, agent) {
+        const parentIds = [...new Set(tasks.map((t) => t.parent_id).filter((id) => id !== null))];
+        const parentMap = new Map();
+        if (parentIds.length > 0) {
+            const placeholders = parentIds.map(() => '?').join(',');
+            const parents = this.db.queryAll(`SELECT * FROM tasks WHERE id IN (${placeholders})`, parentIds);
+            for (const p of parents)
+                parentMap.set(p.id, p);
+        }
+        const taskIds = tasks.map((t) => t.id);
+        const depsMap = new Map();
+        if (taskIds.length > 0) {
+            const placeholders = taskIds.map(() => '?').join(',');
+            const allDeps = this.db.queryAll(`SELECT * FROM task_dependencies WHERE task_id IN (${placeholders}) AND relationship = 'blocks'`, taskIds);
+            for (const d of allDeps) {
+                let arr = depsMap.get(d.task_id);
+                if (!arr) {
+                    arr = [];
+                    depsMap.set(d.task_id, arr);
+                }
+                arr.push(d);
+            }
+        }
+        const depTargetIds = new Set();
+        for (const deps of depsMap.values()) {
+            for (const d of deps)
+                depTargetIds.add(d.depends_on);
+        }
+        const depTaskMap = new Map();
+        if (depTargetIds.size > 0) {
+            const placeholders = [...depTargetIds].map(() => '?').join(',');
+            const depTasks = this.db.queryAll(`SELECT * FROM tasks WHERE id IN (${placeholders})`, [
+                ...depTargetIds,
+            ]);
+            for (const t of depTasks)
+                depTaskMap.set(t.id, t);
+        }
+        const projects = [...new Set(tasks.map((t) => t.project).filter((p) => p !== null))];
+        const projectCounts = new Map();
+        if (projects.length > 0) {
+            const placeholders = projects.map(() => '?').join(',');
+            const rows = this.db.queryAll(`SELECT project, COUNT(*) as cnt FROM tasks WHERE project IN (${placeholders}) AND assigned_to = ? AND status IN ('completed', 'in_progress') GROUP BY project`, [...projects, agent]);
+            for (const r of rows)
+                projectCounts.set(r.project, r.cnt);
+        }
+        return tasks.map((task) => {
+            let score = 0;
+            const reasons = [];
+            if (task.parent_id) {
+                const parent = parentMap.get(task.parent_id);
+                if (parent?.assigned_to === agent) {
+                    score += 3;
+                    reasons.push('worked on parent task');
+                }
+            }
+            const deps = depsMap.get(task.id) ?? [];
+            for (const dep of deps) {
+                const depTask = depTaskMap.get(dep.depends_on);
+                if (depTask?.assigned_to === agent) {
+                    score += 2;
+                    reasons.push('worked on dependency #' + dep.depends_on);
+                    break;
+                }
+            }
+            if (task.project) {
+                const cnt = projectCounts.get(task.project) ?? 0;
+                if (cnt > 0) {
+                    score += 1;
+                    reasons.push('worked on project ' + task.project);
+                }
+            }
+            return { task, score, reasons };
+        });
     }
     // ---- Dependencies ----
     addDependency(taskId, dependsOn, relationship = 'blocks') {
@@ -460,11 +619,17 @@ export class TaskService {
     getAllDependencies() {
         return this.db.queryAll('SELECT * FROM task_dependencies');
     }
+    getDependenciesForTasks(taskIds) {
+        if (taskIds.length === 0)
+            return [];
+        const placeholders = taskIds.map(() => '?').join(',');
+        return this.db.queryAll(`SELECT * FROM task_dependencies WHERE task_id IN (${placeholders}) OR depends_on IN (${placeholders})`, [...taskIds, ...taskIds]);
+    }
     // ---- Artifacts ----
     addArtifact(taskId, name, content, createdBy, stage) {
         const task = this.requireTask(taskId);
-        this.validateArtifactName(name);
-        this.validateArtifactContent(content);
+        validateArtifactName(name);
+        validateArtifactContent(content);
         const effectiveStage = stage && stage !== '_current_' ? stage : task.stage;
         const existing = this.db.queryOne('SELECT * FROM task_artifacts WHERE task_id = ? AND stage = ? AND name = ? ORDER BY version DESC LIMIT 1', [taskId, effectiveStage, name]);
         const version = existing ? existing.version + 1 : 1;
@@ -490,6 +655,16 @@ export class TaskService {
             counts[r.task_id] = r.cnt;
         return counts;
     }
+    getArtifactCountsForTasks(taskIds) {
+        if (taskIds.length === 0)
+            return {};
+        const placeholders = taskIds.map(() => '?').join(',');
+        const rows = this.db.queryAll(`SELECT task_id, COUNT(*) as cnt FROM task_artifacts WHERE task_id IN (${placeholders}) GROUP BY task_id`, taskIds);
+        const counts = {};
+        for (const r of rows)
+            counts[r.task_id] = r.cnt;
+        return counts;
+    }
     // ---- Subtasks ----
     getSubtasks(taskId) {
         this.requireTask(taskId);
@@ -506,6 +681,21 @@ export class TaskService {
         }
         return { total, done };
     }
+    getSubtaskProgressForTasks(taskIds) {
+        if (taskIds.length === 0)
+            return {};
+        const placeholders = taskIds.map(() => '?').join(',');
+        const rows = this.db.queryAll(`SELECT parent_id, status, COUNT(*) as cnt FROM tasks WHERE parent_id IN (${placeholders}) GROUP BY parent_id, status`, taskIds);
+        const progress = {};
+        for (const r of rows) {
+            if (!progress[r.parent_id])
+                progress[r.parent_id] = { total: 0, done: 0 };
+            progress[r.parent_id].total += r.cnt;
+            if (r.status === 'completed')
+                progress[r.parent_id].done += r.cnt;
+        }
+        return progress;
+    }
     getAllSubtaskProgress() {
         const rows = this.db.queryAll(`SELECT parent_id, status, COUNT(*) as cnt FROM tasks WHERE parent_id IS NOT NULL GROUP BY parent_id, status`);
         const progress = {};
@@ -586,72 +776,13 @@ export class TaskService {
             const assignmentConfig = JSON.parse(config.assignment_config);
             return assignmentConfig[stage]?.auto_assign ?? null;
         }
-        catch {
+        catch (err) {
+            process.stderr.write('[agent-tasks] getAutoAssignee JSON parse: ' +
+                (err instanceof Error ? err.message : String(err)) +
+                '\n');
             return null;
         }
     }
-    validateTitle(title) {
-        rejectNullBytes(title, 'title');
-        rejectControlChars(title, 'title');
-        const trimmed = title.trim();
-        if (!trimmed)
-            throw new ValidationError('Title must not be empty.');
-        if (trimmed.length > MAX_TITLE_LENGTH) {
-            throw new ValidationError(`Title too long (max ${MAX_TITLE_LENGTH} chars).`);
-        }
-    }
-    validateDescription(desc) {
-        rejectNullBytes(desc, 'description');
-        if (desc.length > MAX_DESCRIPTION_LENGTH) {
-            throw new ValidationError(`Description too long (max ${MAX_DESCRIPTION_LENGTH} chars).`);
-        }
-    }
-    validateResult(result) {
-        rejectNullBytes(result, 'result');
-        if (result.length > MAX_RESULT_LENGTH) {
-            throw new ValidationError(`Result too long (max ${MAX_RESULT_LENGTH} chars).`);
-        }
-    }
-    validateProjectName(project) {
-        rejectNullBytes(project, 'project');
-        rejectControlChars(project, 'project');
-        if (project.length > MAX_PROJECT_NAME_LENGTH) {
-            throw new ValidationError(`Project name too long (max ${MAX_PROJECT_NAME_LENGTH} chars).`);
-        }
-    }
-    validateAssignee(name) {
-        rejectNullBytes(name, 'assign_to');
-        rejectControlChars(name, 'assign_to');
-        if (!name.trim())
-            throw new ValidationError('Assignee name must not be empty.');
-    }
-    validateTags(tags) {
-        if (tags.length > MAX_TAGS_COUNT) {
-            throw new ValidationError(`Too many tags (max ${MAX_TAGS_COUNT}).`);
-        }
-        for (const tag of tags) {
-            rejectNullBytes(tag, 'tag');
-            rejectControlChars(tag, 'tag');
-            if (tag.length > MAX_TAG_LENGTH) {
-                throw new ValidationError(`Tag too long: "${tag}" (max ${MAX_TAG_LENGTH} chars).`);
-            }
-        }
-    }
-    validateArtifactName(name) {
-        rejectNullBytes(name, 'artifact name');
-        rejectControlChars(name, 'artifact name');
-        if (!name.trim())
-            throw new ValidationError('Artifact name must not be empty.');
-        if (name.length > MAX_ARTIFACT_NAME_LENGTH) {
-            throw new ValidationError(`Artifact name too long (max ${MAX_ARTIFACT_NAME_LENGTH} chars).`);
-        }
-    }
-    validateArtifactContent(content) {
-        rejectNullBytes(content, 'artifact content');
-        if (content.length > MAX_ARTIFACT_CONTENT_LENGTH) {
-            throw new ValidationError(`Artifact content too long (max ${MAX_ARTIFACT_CONTENT_LENGTH} chars).`);
-        }
-    }
     checkStageGate(task, inlineComment) {
         const gate = this.getGateConfig(task.project ?? undefined);
         if (!gate)
@@ -678,8 +809,8 @@ export class TaskService {
             return;
         if (stageGate.require_comment) {
             if (!inlineComment) {
-                const cnt = this.db.queryOne(`SELECT COUNT(*) as cnt FROM task_comments WHERE task_id = ?`, [task.id]);
-                if (!cnt || cnt.cnt === 0) {
+                const commentCount = this.db.queryOne(`SELECT COUNT(*) as cnt FROM task_comments WHERE task_id = ?`, [task.id]);
+                if (!commentCount || commentCount.cnt === 0) {
                     throw new ValidationError(`Stage gate [${task.stage}]: comment required before advancing. Use task_comment or pass comment param to task_advance.`);
                 }
             }
@@ -693,15 +824,15 @@ export class TaskService {
             }
         }
         if (stageGate.require_min_artifacts !== undefined && stageGate.require_min_artifacts > 0) {
-            const cnt2 = this.db.queryOne(`SELECT COUNT(*) as cnt FROM task_artifacts WHERE task_id = ? AND stage = ?`, [task.id, task.stage]);
-            if (!cnt2 || cnt2.cnt < stageGate.require_min_artifacts) {
-                throw new ValidationError(`Stage gate [${task.stage}]: at least ${stageGate.require_min_artifacts} artifact(s) required (found ${cnt2?.cnt ?? 0}). Use task_add_artifact.`);
+            const artifactCount = this.db.queryOne(`SELECT COUNT(*) as cnt FROM task_artifacts WHERE task_id = ? AND stage = ?`, [task.id, task.stage]);
+            if (!artifactCount || artifactCount.cnt < stageGate.require_min_artifacts) {
+                throw new ValidationError(`Stage gate [${task.stage}]: at least ${stageGate.require_min_artifacts} artifact(s) required (found ${artifactCount?.cnt ?? 0}). Use task_add_artifact.`);
             }
         }
         if (stageGate.require_approval) {
             const approved = this.db.queryOne(`SELECT COUNT(*) as cnt FROM task_approvals WHERE task_id = ? AND stage = ? AND status = 'approved'`, [task.id, task.stage]);
             if (!approved || approved.cnt === 0) {
-                throw new ValidationError(`Stage gate [${task.stage}]: approval required before advancing. Use task_request_approval + task_approve.`);
+                throw new ValidationError(`Stage gate [${task.stage}]: approval required before advancing. Use task_approval(action: "request") + task_approval(action: "approve").`);
             }
         }
     }