steroids-api 0.2.7

package/dist/routes/tasks.js

@@ -0,0 +1,1145 @@
+/**
+ * Tasks API routes
+ * Exposes task details and logs for individual tasks
+ */
+import { Router } from 'express';
+import Database from 'better-sqlite3';
+import { createReadStream, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { Tail } from 'tail';
+import { openSqliteForRead } from '../utils/sqlite.js';
+const router = Router();
+const MAX_SSE_CONNECTIONS = Math.max(1, parseInt(process.env.MAX_SSE_CONNECTIONS || '100', 10) || 100);
+let activeSseConnections = 0;
+/**
+ * Get GitHub URL from git remote
+ * @param projectPath - Path to project root
+ * @returns GitHub base URL (e.g., https://github.com/owner/repo) or null
+ */
+function getGitHubUrl(projectPath) {
+    try {
+        const remoteUrl = execSync('git remote get-url origin', {
+            cwd: projectPath,
+            encoding: 'utf-8',
+        }).trim();
+        // Convert SSH or HTTPS URL to web URL
+        // SSH: git@github.com:owner/repo.git
+        // HTTPS: https://github.com/owner/repo.git
+        let webUrl = null;
+        if (remoteUrl.startsWith('git@github.com:')) {
+            // SSH format
+            const path = remoteUrl.replace('git@github.com:', '').replace(/\.git$/, '');
+            webUrl = `https://github.com/${path}`;
+        }
+        else if (remoteUrl.includes('github.com')) {
+            // HTTPS format
+            webUrl = remoteUrl.replace(/\.git$/, '');
+        }
+        return webUrl;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Open project database
+ * @param projectPath - Path to project root
+ * @returns Database connection or null if not found
+ */
+function openProjectDatabase(projectPath) {
+    const dbPath = join(projectPath, '.steroids', 'steroids.db');
+    if (!existsSync(dbPath)) {
+        return null;
+    }
+    try {
+        return openSqliteForRead(dbPath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate duration for each status from audit trail
+ * @param auditTrail - Array of audit entries sorted by created_at
+ * @returns Audit entries with duration_seconds added
+ */
+function calculateDurations(auditTrail) {
+    // Sort by created_at ascending for duration calculation
+    const sorted = [...auditTrail].sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+    return sorted.map((entry, index) => {
+        // Duration is time until next status change
+        if (index < sorted.length - 1) {
+            const startTime = new Date(entry.created_at).getTime();
+            const endTime = new Date(sorted[index + 1].created_at).getTime();
+            const durationSeconds = Math.round((endTime - startTime) / 1000);
+            return { ...entry, duration_seconds: durationSeconds };
+        }
+        // Current/last status - duration from entry until now
+        const startTime = new Date(entry.created_at).getTime();
+        const now = Date.now();
+        const durationSeconds = Math.round((now - startTime) / 1000);
+        return { ...entry, duration_seconds: durationSeconds };
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function writeSSE(res, payload) {
+    if (res.writableEnded)
+        return;
+    const chunk = `data: ${JSON.stringify(payload)}\n\n`;
+    const ok = res.write(chunk);
+    if (ok)
+        return;
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const cleanup = () => {
+            res.off('drain', onDrain);
+            res.off('error', onError);
+        };
+        res.on('drain', onDrain);
+        res.on('error', onError);
+    });
+}
+async function writeSSEComment(res, comment) {
+    if (res.writableEnded)
+        return;
+    const chunk = `: ${comment}\n\n`;
+    const ok = res.write(chunk);
+    if (ok)
+        return;
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const cleanup = () => {
+            res.off('drain', onDrain);
+            res.off('error', onError);
+        };
+        res.on('drain', onDrain);
+        res.on('error', onError);
+    });
+}
+async function waitForFile(filePath, opts) {
+    const deadline = Date.now() + opts.timeoutMs;
+    while (Date.now() < deadline) {
+        if (opts.isAborted())
+            return false;
+        if (existsSync(filePath))
+            return true;
+        await sleep(opts.pollMs);
+    }
+    return existsSync(filePath);
+}
+async function streamJsonlFileToSSE(res, filePath, opts) {
+    const rs = createReadStream(filePath, { encoding: 'utf8' });
+    let buffer = '';
+    for await (const chunk of rs) {
+        if (opts.isAborted())
+            return;
+        buffer += chunk;
+        let nl = buffer.indexOf('\n');
+        while (nl >= 0) {
+            const line = buffer.slice(0, nl);
+            buffer = buffer.slice(nl + 1);
+            nl = buffer.indexOf('\n');
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                await writeSSE(res, entry);
+            }
+            catch {
+                // ignore malformed JSONL lines
+            }
+        }
+    }
+    const tailLine = buffer.trim();
+    if (tailLine && !opts.isAborted()) {
+        try {
+            const entry = JSON.parse(tailLine);
+            await writeSSE(res, entry);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+async function readSampledJsonlEntries(filePath, opts) {
+    const rs = createReadStream(filePath, { encoding: 'utf8' });
+    let buffer = '';
+    let index = 0;
+    const out = [];
+    const keep = (entry, i) => {
+        if (opts.shouldKeep)
+            return opts.shouldKeep(entry, i);
+        // Keep all tools, and sample the rest.
+        return entry?.type === 'tool' || i % opts.keepEveryN === 0;
+    };
+    for await (const chunk of rs) {
+        buffer += chunk;
+        let nl = buffer.indexOf('\n');
+        while (nl >= 0) {
+            const line = buffer.slice(0, nl);
+            buffer = buffer.slice(nl + 1);
+            nl = buffer.indexOf('\n');
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                if (keep(entry, index))
+                    out.push(entry);
+            }
+            catch {
+                // ignore malformed JSONL lines
+            }
+            finally {
+                index++;
+            }
+        }
+    }
+    const tailLine = buffer.trim();
+    if (tailLine) {
+        try {
+            const entry = JSON.parse(tailLine);
+            if (keep(entry, index))
+                out.push(entry);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return out;
+}
+/**
+ * GET /api/tasks/:taskId
+ * Get detailed information about a task including audit history
+ * Query params:
+ *   - project: string (required) - project path
+ */
+router.get('/tasks/:taskId', (req, res) => {
+    try {
+        const { taskId } = req.params;
+        const projectPath = req.query.project;
+        if (!projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required query parameter: project',
+            });
+            return;
+        }
+        const db = openProjectDatabase(projectPath);
+        if (!db) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        try {
+            // Get task details with section name
+            const task = db
+                .prepare(`SELECT
+            t.id, t.title, t.status, t.section_id,
+            s.name as section_name,
+            t.source_file, t.rejection_count,
+            t.created_at, t.updated_at
+          FROM tasks t
+          LEFT JOIN sections s ON t.section_id = s.id
+          WHERE t.id = ?`)
+                .get(taskId);
+            if (!task) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Task not found',
+                    task_id: taskId,
+                });
+                return;
+            }
+            // Get audit trail
+            const auditTrail = db
+                .prepare(`SELECT id, task_id, from_status, to_status, actor, actor_type, model, notes, error_code, commit_sha, created_at
+          FROM audit
+          WHERE task_id = ?
+          ORDER BY created_at ASC`)
+                .all(taskId);
+            // Get disputes for task
+            const disputes = db
+                .prepare(`SELECT * FROM disputes
+          WHERE task_id = ?
+          ORDER BY created_at DESC`)
+                .all(taskId);
+            // Get LLM invocations (exclude prompt/response to keep payload light)
+            const invocations = db
+                .prepare(`SELECT id, task_id, role, provider, model, exit_code, duration_ms, success, timed_out, rejection_number, created_at
+          FROM task_invocations
+          WHERE task_id = ?
+          ORDER BY created_at ASC`)
+                .all(taskId);
+            // Calculate durations for each status
+            const auditWithDurations = calculateDurations(auditTrail);
+            // Calculate total time in each status
+            let inProgressSeconds = 0;
+            let reviewSeconds = 0;
+            for (const entry of auditWithDurations) {
+                if (entry.to_status === 'in_progress' && entry.duration_seconds) {
+                    inProgressSeconds += entry.duration_seconds;
+                }
+                else if (entry.to_status === 'review' && entry.duration_seconds) {
+                    reviewSeconds += entry.duration_seconds;
+                }
+            }
+            // Total time is just the sum of active work time (coding + review)
+            const totalSeconds = inProgressSeconds + reviewSeconds;
+            // Get GitHub URL for commit links
+            const githubUrl = getGitHubUrl(projectPath);
+            const response = {
+                ...task,
+                duration: {
+                    total_seconds: totalSeconds,
+                    in_progress_seconds: inProgressSeconds,
+                    review_seconds: reviewSeconds,
+                },
+                audit_trail: auditWithDurations.reverse(), // Most recent first for display
+                invocations, // Oldest first (chronological)
+                disputes,
+                github_url: githubUrl,
+            };
+            res.json({
+                success: true,
+                task: response,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error getting task details:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to get task details',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * GET /api/tasks/:taskId/stream
+ * Stream invocation activity (JSONL) for the currently-running invocation using SSE.
+ * Query params:
+ *   - project: string (required) - project path
+ */
+router.get('/tasks/:taskId/stream', async (req, res) => {
+    const { taskId } = req.params;
+    const projectPath = req.query.project;
+    if (!projectPath) {
+        res.status(400).json({
+            success: false,
+            error: 'Missing required query parameter: project',
+        });
+        return;
+    }
+    if (activeSseConnections >= MAX_SSE_CONNECTIONS) {
+        res.status(429).json({
+            success: false,
+            error: 'Too many active streams',
+            max: MAX_SSE_CONNECTIONS,
+        });
+        return;
+    }
+    activeSseConnections++;
+    let closed = false;
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        activeSseConnections = Math.max(0, activeSseConnections - 1);
+        try {
+            res.end();
+        }
+        catch {
+            // ignore
+        }
+    };
+    req.on('close', close);
+    // SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+    const db = openProjectDatabase(projectPath);
+    if (!db) {
+        await writeSSE(res, { type: 'error', error: 'Project database not found', project: projectPath });
+        close();
+        return;
+    }
+    let invocation;
+    try {
+        invocation = db
+            .prepare(`SELECT id, status
+         FROM task_invocations
+         WHERE task_id = ? AND status = 'running'
+         ORDER BY started_at_ms DESC
+         LIMIT 1`)
+            .get(taskId);
+    }
+    catch (error) {
+        await writeSSE(res, {
+            type: 'error',
+            error: 'Failed to query running invocation (is the database migrated?)',
+            message: error instanceof Error ? error.message : String(error),
+        });
+        close();
+        return;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!invocation) {
+        await writeSSE(res, { type: 'no_active_invocation', taskId });
+        close();
+        return;
+    }
+    const logFile = join(projectPath, '.steroids', 'invocations', `${invocation.id}.log`);
+    const isAborted = () => closed || res.writableEnded;
+    // If the invocation just started, the log file may not exist yet.
+    if (!existsSync(logFile)) {
+        await writeSSE(res, { type: 'waiting_for_log', taskId, invocationId: invocation.id });
+        const ok = await waitForFile(logFile, { timeoutMs: 5000, pollMs: 100, isAborted });
+        if (!ok) {
+            await writeSSE(res, { type: 'log_not_found', taskId, invocationId: invocation.id });
+            close();
+            return;
+        }
+    }
+    try {
+        // 1) Send existing log entries first
+        await streamJsonlFileToSSE(res, logFile, { isAborted });
+        if (isAborted())
+            return;
+        // 2) Tail for new entries
+        const tail = new Tail(logFile, { follow: true, useWatchFile: true });
+        let writeChain = Promise.resolve();
+        const heartbeat = setInterval(() => {
+            // Keep proxies from timing out the connection.
+            writeChain = writeChain.then(() => writeSSEComment(res, 'heartbeat')).catch(() => { });
+        }, 30000);
+        const cleanup = () => {
+            clearInterval(heartbeat);
+            try {
+                tail.unwatch();
+            }
+            catch {
+                // ignore
+            }
+            close();
+        };
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            try {
+                tail.unwatch();
+            }
+            catch { }
+        });
+        tail.on('line', (line) => {
+            if (isAborted())
+                return;
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            writeChain = writeChain
+                .then(async () => {
+                try {
+                    const entry = JSON.parse(trimmed);
+                    await writeSSE(res, entry);
+                    if (entry?.type === 'complete' || entry?.type === 'error') {
+                        cleanup();
+                    }
+                }
+                catch {
+                    // ignore malformed JSONL lines
+                }
+            })
+                .catch(() => { });
+        });
+        tail.on('error', (err) => {
+            void writeChain
+                .then(() => writeSSE(res, {
+                type: 'error',
+                error: 'Tail error',
+                message: err instanceof Error ? err.message : String(err),
+            }))
+                .finally(cleanup);
+        });
+    }
+    catch (error) {
+        await writeSSE(res, {
+            type: 'error',
+            error: 'Failed to stream invocation log',
+            message: error instanceof Error ? error.message : String(error),
+        });
+        close();
+    }
+});
+/**
+ * GET /api/tasks/:taskId/timeline
+ * Parse invocation JSONL activity logs on demand and return a sampled timeline.
+ * Query params:
+ *   - project: string (required) - project path
+ */
+router.get('/tasks/:taskId/timeline', async (req, res) => {
+    const { taskId } = req.params;
+    const projectPath = req.query.project;
+    if (!projectPath) {
+        res.status(400).json({
+            success: false,
+            error: 'Missing required query parameter: project',
+        });
+        return;
+    }
+    const db = openProjectDatabase(projectPath);
+    if (!db) {
+        res.status(404).json({
+            success: false,
+            error: 'Project database not found',
+            project: projectPath,
+        });
+        return;
+    }
+    let invocations = [];
+    try {
+        invocations = db
+            .prepare(`SELECT id, role, provider, model, started_at_ms, completed_at_ms, status
+         FROM task_invocations
+         WHERE task_id = ?
+         ORDER BY started_at_ms ASC`)
+            .all(taskId);
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Failed to query invocations (is the database migrated?)',
+            message: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { }
+    }
+    const timeline = [];
+    for (const inv of invocations) {
+        // Invocation start event (from DB lifecycle timestamps).
+        timeline.push({
+            ts: inv.started_at_ms,
+            type: 'invocation.started',
+            invocationId: inv.id,
+            role: inv.role,
+            provider: inv.provider,
+            model: inv.model,
+        });
+        const logFile = join(projectPath, '.steroids', 'invocations', `${inv.id}.log`);
+        if (existsSync(logFile)) {
+            try {
+                const sampled = await readSampledJsonlEntries(logFile, { keepEveryN: 10 });
+                // Exclude output events from timeline - they're only shown in the live stream
+                for (const e of sampled) {
+                    if (e.type !== 'output')
+                        timeline.push({ ...e, invocationId: inv.id });
+                }
+            }
+            catch {
+                // ignore per spec: timeline is best-effort
+            }
+        }
+        // Invocation completion event, when available.
+        if (inv.completed_at_ms) {
+            timeline.push({
+                ts: inv.completed_at_ms,
+                type: 'invocation.completed',
+                invocationId: inv.id,
+                success: inv.status === 'completed',
+                duration: inv.completed_at_ms - inv.started_at_ms,
+            });
+        }
+    }
+    res.json({ success: true, timeline });
+});
+/**
+ * GET /api/tasks/:taskId/logs
+ * Get execution logs/audit trail for a task
+ * Query params:
+ *   - project: string (required) - project path
+ *   - limit: number (optional) - max entries to return (default: 50)
+ *   - offset: number (optional) - offset for pagination (default: 0)
+ */
+router.get('/tasks/:taskId/logs', (req, res) => {
+    try {
+        const { taskId } = req.params;
+        const projectPath = req.query.project;
+        const limitParam = req.query.limit;
+        const offsetParam = req.query.offset;
+        if (!projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required query parameter: project',
+            });
+            return;
+        }
+        // Parse limit and offset
+        let limit = 50;
+        let offset = 0;
+        if (limitParam !== undefined) {
+            const parsed = parseInt(limitParam, 10);
+            if (!isNaN(parsed) && parsed > 0) {
+                limit = Math.min(parsed, 500); // Cap at 500
+            }
+        }
+        if (offsetParam !== undefined) {
+            const parsed = parseInt(offsetParam, 10);
+            if (!isNaN(parsed) && parsed >= 0) {
+                offset = parsed;
+            }
+        }
+        const db = openProjectDatabase(projectPath);
+        if (!db) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        try {
+            // Check task exists
+            const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(taskId);
+            if (!task) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Task not found',
+                    task_id: taskId,
+                });
+                return;
+            }
+            // Get total count
+            const countResult = db
+                .prepare('SELECT COUNT(*) as count FROM audit WHERE task_id = ?')
+                .get(taskId);
+            // Get audit entries with pagination
+            const logs = db
+                .prepare(`SELECT id, task_id, from_status, to_status, actor, actor_type, model, notes, commit_sha, created_at
+          FROM audit
+          WHERE task_id = ?
+          ORDER BY created_at DESC
+          LIMIT ? OFFSET ?`)
+                .all(taskId, limit, offset);
+            res.json({
+                success: true,
+                task_id: taskId,
+                task_title: task.title,
+                task_status: task.status,
+                logs,
+                pagination: {
+                    total: countResult.count,
+                    limit,
+                    offset,
+                    has_more: offset + logs.length < countResult.count,
+                },
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error getting task logs:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to get task logs',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * GET /api/projects/:projectPath/sections
+ * List all sections for a project with task counts by status
+ */
+router.get('/projects/:projectPath(*)/sections', (req, res) => {
+    try {
+        const projectPath = decodeURIComponent(req.params.projectPath);
+        const db = openProjectDatabase(projectPath);
+        if (!db) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        try {
+            // Check which columns exist (handles older DBs missing priority/branch/pr fields)
+            const sectionCols = (() => {
+                try {
+                    const cols = db.prepare("PRAGMA table_info(sections)").all();
+                    return new Set(cols.map(c => c.name));
+                }
+                catch {
+                    return new Set();
+                }
+            })();
+            const hasPriority = sectionCols.has('priority');
+            const hasBranch = sectionCols.has('branch');
+            const hasPrFields = sectionCols.has('pr_number') && sectionCols.has('auto_pr');
+            const prioritySelect = hasPriority ? 's.priority,' : '50 as priority,';
+            const branchSelect = hasBranch ? 's.branch,' : 'NULL as branch,';
+            const prSelect = hasPrFields ? 's.auto_pr, s.pr_number,' : '0 as auto_pr, NULL as pr_number,';
+            const orderBy = hasPriority ? 'ORDER BY s.priority DESC, s.name ASC' : 'ORDER BY s.name ASC';
+            // Get sections with task counts by status
+            const sections = db
+                .prepare(`SELECT
+            s.id,
+            s.name,
+            ${prioritySelect}
+            ${branchSelect}
+            ${prSelect}
+            s.created_at,
+            COUNT(t.id) as total_tasks,
+            SUM(CASE WHEN t.status = 'pending' THEN 1 ELSE 0 END) as pending,
+            SUM(CASE WHEN t.status = 'in_progress' THEN 1 ELSE 0 END) as in_progress,
+            SUM(CASE WHEN t.status = 'review' THEN 1 ELSE 0 END) as review,
+            SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) as completed,
+            SUM(CASE WHEN t.status = 'failed' THEN 1 ELSE 0 END) as failed,
+            SUM(CASE WHEN t.status = 'skipped' THEN 1 ELSE 0 END) as skipped
+          FROM sections s
+          LEFT JOIN tasks t ON t.section_id = s.id
+          GROUP BY s.id
+          ${orderBy}`)
+                .all();
+            // Derive PR URL from git remote + pr_number (GitHub-only)
+            const githubBaseUrl = getGitHubUrl(projectPath);
+            // Fetch all section dependencies in one query, keyed by section_id
+            // Wrapped in try/catch for older DBs that pre-date migration 004
+            const dependsBySection = new Map();
+            try {
+                const deps = db.prepare(`
+          SELECT sd.section_id, s.name as depends_on_name
+          FROM section_dependencies sd
+          JOIN sections s ON sd.depends_on_section_id = s.id
+          ORDER BY s.name ASC
+        `).all();
+                for (const row of deps) {
+                    const existing = dependsBySection.get(row.section_id);
+                    if (existing) {
+                        existing.push(row.depends_on_name);
+                    }
+                    else {
+                        dependsBySection.set(row.section_id, [row.depends_on_name]);
+                    }
+                }
+            }
+            catch {
+                // section_dependencies table absent — leave map empty
+            }
+            // Also get tasks without a section (null section_id)
+            const unassigned = db
+                .prepare(`SELECT
+            COUNT(*) as total_tasks,
+            SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+            SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) as in_progress,
+            SUM(CASE WHEN status = 'review' THEN 1 ELSE 0 END) as review,
+            SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+            SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+            SUM(CASE WHEN status = 'skipped' THEN 1 ELSE 0 END) as skipped
+          FROM tasks
+          WHERE section_id IS NULL`)
+                .get();
+            res.json({
+                success: true,
+                project: projectPath,
+                sections: sections.map(s => ({
+                    ...s,
+                    auto_pr: s.auto_pr !== 0,
+                    pr_url: s.pr_number && githubBaseUrl ? `${githubBaseUrl}/pull/${s.pr_number}` : null,
+                    depends_on: dependsBySection.get(s.id) ?? [],
+                })),
+                unassigned: unassigned.total_tasks > 0 ? unassigned : null,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error listing project sections:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to list project sections',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * GET /api/projects/:projectPath/tasks
+ * List all tasks for a project
+ * Query params:
+ *   - status: string (optional) - filter by status
+ *   - section: string (optional) - filter by section id
+ *   - issue: string (optional) - filter by issue bucket (failed_retries, stale)
+ *   - hours: number (optional) - filter to tasks created within last N hours
+ *   - limit: number (optional) - max entries (default: 100)
+ */
+router.get('/projects/:projectPath(*)/tasks', (req, res) => {
+    try {
+        // projectPath comes URL-encoded, decode it
+        const projectPath = decodeURIComponent(req.params.projectPath);
+        const statusFilter = req.query.status;
+        const sectionFilter = req.query.section;
+        const issueFilter = req.query.issue;
+        const hoursParam = req.query.hours;
+        const limitParam = req.query.limit;
+        const normalizedIssueFilter = issueFilter === 'failed_retries' || issueFilter === 'stale'
+            ? issueFilter
+            : undefined;
+        if (issueFilter && !normalizedIssueFilter) {
+            res.status(400).json({
+                success: false,
+                error: 'Invalid issue parameter - supported values: failed_retries, stale',
+            });
+            return;
+        }
+        let limit = 100;
+        if (limitParam !== undefined) {
+            const parsed = parseInt(limitParam, 10);
+            if (!isNaN(parsed) && parsed > 0) {
+                limit = Math.min(parsed, 500);
+            }
+        }
+        let hoursFilter;
+        if (hoursParam !== undefined) {
+            const parsed = parseInt(hoursParam, 10);
+            if (isNaN(parsed) || parsed <= 0) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Invalid hours parameter - must be a positive integer',
+                });
+                return;
+            }
+            hoursFilter = parsed;
+        }
+        const db = openProjectDatabase(projectPath);
+        if (!db) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        try {
+            let staleIssueSupported = false;
+            if (normalizedIssueFilter === 'stale') {
+                try {
+                    const row = db
+                        .prepare(`SELECT 1 as exists_flag FROM sqlite_master WHERE type = 'table' AND name = 'incidents' LIMIT 1`)
+                        .get();
+                    staleIssueSupported = Boolean(row?.exists_flag);
+                }
+                catch {
+                    staleIssueSupported = false;
+                }
+            }
+            let query = `
+        SELECT
+          t.id, t.title, t.status, t.section_id,
+          s.name as section_name,
+          t.source_file, t.rejection_count, t.failure_count,
+          t.created_at, t.updated_at
+        FROM tasks t
+        LEFT JOIN sections s ON t.section_id = s.id
+        WHERE 1=1
+      `;
+            const params = [];
+            if (statusFilter) {
+                query += ' AND t.status = ?';
+                params.push(statusFilter);
+            }
+            if (sectionFilter) {
+                query += ' AND t.section_id = ?';
+                params.push(sectionFilter);
+            }
+            if (hoursFilter) {
+                query += ` AND julianday(t.created_at) >= julianday('now', ? || ' hours')`;
+                params.push(`-${hoursFilter}`);
+            }
+            if (normalizedIssueFilter === 'failed_retries') {
+                query += ` AND COALESCE(t.failure_count, 0) > 0`;
+            }
+            if (normalizedIssueFilter === 'stale') {
+                if (!staleIssueSupported) {
+                    query += ' AND 1=0';
+                }
+                else {
+                    query += `
+            AND EXISTS (
+              SELECT 1
+              FROM incidents i
+              WHERE i.task_id = t.id
+                AND i.resolved_at IS NULL
+                AND i.failure_mode IN ('orphaned_task', 'hanging_invocation')
+            )
+          `;
+                }
+            }
+            query += ' ORDER BY t.created_at DESC LIMIT ?';
+            params.push(limit);
+            const tasks = db.prepare(query).all(...params);
+            // Get task counts by status
+            let countsQuery = `
+        SELECT status, COUNT(*) as count
+        FROM tasks
+        WHERE 1=1
+      `;
+            const countParams = [];
+            if (hoursFilter) {
+                countsQuery += ` AND julianday(created_at) >= julianday('now', ? || ' hours')`;
+                countParams.push(`-${hoursFilter}`);
+            }
+            if (normalizedIssueFilter === 'failed_retries') {
+                countsQuery += ` AND COALESCE(failure_count, 0) > 0`;
+            }
+            if (normalizedIssueFilter === 'stale') {
+                if (!staleIssueSupported) {
+                    countsQuery += ' AND 1=0';
+                }
+                else {
+                    countsQuery += `
+            AND EXISTS (
+              SELECT 1
+              FROM incidents i
+              WHERE i.task_id = tasks.id
+                AND i.resolved_at IS NULL
+                AND i.failure_mode IN ('orphaned_task', 'hanging_invocation')
+            )
+          `;
+                }
+            }
+            countsQuery += ' GROUP BY status';
+            const statusCounts = db
+                .prepare(countsQuery)
+                .all(...countParams);
+            const counts = statusCounts.reduce((acc, { status, count }) => {
+                acc[status] = count;
+                return acc;
+            }, {});
+            // Pending tasks are always shown regardless of time range — a task created
+            // two weeks ago that is still pending is just as relevant as one from today.
+            if (hoursFilter) {
+                const pendingRow = db
+                    .prepare(`SELECT COUNT(*) as count FROM tasks WHERE status = 'pending'`)
+                    .get();
+                counts['pending'] = pendingRow.count;
+            }
+            res.json({
+                success: true,
+                project: projectPath,
+                tasks,
+                count: tasks.length,
+                status_counts: counts,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error listing project tasks:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to list project tasks',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * GET /api/tasks/:taskId/invocations/:invocationId
+ * Get full details for a specific invocation including prompt and response
+ * Query params:
+ *   - project: string (required) - project path
+ */
+router.get('/tasks/:taskId/invocations/:invocationId', (req, res) => {
+    try {
+        const { taskId, invocationId } = req.params;
+        const projectPath = req.query.project;
+        if (!projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required query parameter: project',
+            });
+            return;
+        }
+        const db = openProjectDatabase(projectPath);
+        if (!db) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        try {
+            // Get full invocation details including prompt and response
+            const invocation = db
+                .prepare(`SELECT id, task_id, role, provider, model, prompt, response, error, exit_code, duration_ms, success, timed_out, rejection_number, created_at
+          FROM task_invocations
+          WHERE id = ? AND task_id = ?`)
+                .get(invocationId, taskId);
+            if (!invocation) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Invocation not found',
+                    invocation_id: invocationId,
+                    task_id: taskId,
+                });
+                return;
+            }
+            res.json({
+                success: true,
+                invocation,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error getting invocation details:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to get invocation details',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * POST /api/tasks/:taskId/restart
+ * Restart a failed/disputed task by resetting rejection count and setting status to pending
+ * Body: { project: string, notes?: string }
+ * Notes are stored in the audit entry as human guidance for the coder
+ */
+router.post('/tasks/:taskId/restart', (req, res) => {
+    try {
+        const { taskId } = req.params;
+        const projectPath = req.body.project;
+        const notes = req.body.notes;
+        if (!projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required body parameter: project',
+            });
+            return;
+        }
+        const dbPath = join(projectPath, '.steroids', 'steroids.db');
+        if (!existsSync(dbPath)) {
+            res.status(404).json({
+                success: false,
+                error: 'Project database not found',
+                project: projectPath,
+            });
+            return;
+        }
+        let db;
+        try {
+            db = new Database(dbPath); // Writable mode
+        }
+        catch {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to open project database',
+            });
+            return;
+        }
+        try {
+            // Check task exists
+            const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(taskId);
+            if (!task) {
+                res.status(404).json({
+                    success: false,
+                    error: 'Task not found',
+                    task_id: taskId,
+                });
+                return;
+            }
+            // Block restart for tasks already in progress
+            if (task.status === 'in_progress' || task.status === 'review') {
+                res.status(400).json({
+                    success: false,
+                    error: `Cannot restart task in ${task.status} status. Task is currently being worked on.`,
+                });
+                return;
+            }
+            // Resolve any open disputes for this task
+            const openDisputes = db
+                .prepare(`SELECT id FROM disputes WHERE task_id = ? AND status = 'open'`)
+                .all(taskId);
+            for (const dispute of openDisputes) {
+                db.prepare(`UPDATE disputes
+           SET status = 'resolved', resolution = 'custom', resolution_notes = ?,
+               resolved_by = 'human:webui', resolved_at = datetime('now')
+           WHERE id = ?`).run(notes || 'Resolved via WebUI restart', dispute.id);
+            }
+            // Reset task: set status to pending and rejection_count to 0
+            db.prepare(`UPDATE tasks
+         SET status = 'pending', rejection_count = 0, updated_at = datetime('now')
+         WHERE id = ?`).run(taskId);
+            // Add audit entry with human guidance notes
+            const auditNotes = notes
+                ? `Task restarted via WebUI. Human guidance: ${notes}`
+                : 'Task restarted via WebUI';
+            db.prepare(`INSERT INTO audit (task_id, from_status, to_status, actor, actor_type, notes, created_at)
+         VALUES (?, ?, 'pending', 'human:webui', 'human', ?, datetime('now'))`).run(taskId, task.status, auditNotes);
+            res.json({
+                success: true,
+                message: 'Task restarted successfully',
+                task_id: taskId,
+                disputes_resolved: openDisputes.length,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        console.error('Error restarting task:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to restart task',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+export default router;
+//# sourceMappingURL=tasks.js.map