@longshot/cli 0.0.1

package/dist/queue.js

@@ -0,0 +1,868 @@
+import * as store from "./store.js";
+import * as git from "./git.js";
+import { spawnAgent } from "./agent.js";
+import { getProjectRoot } from "./projects.js";
+import { writeFile, readFile as fsReadFile, unlink } from "node:fs/promises";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+async function readAgentStatus() {
+    const path = join(getProjectRoot(), ".longshot", "status.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const content = await fsReadFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function clearAgentStatus() {
+    const path = join(getProjectRoot(), ".longshot", "status.json");
+    if (existsSync(path)) {
+        await unlink(path);
+    }
+}
+// --- CLAUDE.md generation ---
+async function writeCLAUDEmd(spec, activeTask) {
+    const taskSection = activeTask
+        ? `
+## Active Task: #${activeTask.meta.id} — ${activeTask.meta.title}
+
+Status: ${activeTask.meta.status}
+
+Task spec:
+---
+${activeTask.spec}
+---
+
+When working on this task:
+- Follow the task spec above
+- When the task is complete, update .longshot/spec.md (the project spec) to reflect what was built
+- Update the task spec file at .longshot/tasks/${String(activeTask.meta.id).padStart(3, "0")}-${activeTask.meta.slug}.md if the approach changes
+`
+        : `
+## No active task
+
+The user is either discussing the project, writing the project spec, or creating a new task.
+- If they describe features or architecture: update .longshot/spec.md
+- If they want to start a specific piece of work: create a task spec in .longshot/tasks/ and add it to .longshot/tasks.json
+`;
+    const claudeMd = `# Project: longshot managed project
+
+## Project Spec (source of truth)
+
+${spec || "(No project spec yet — the user will describe what they want.)"}
+
+${taskSection}
+
+## File structure for project management
+
+- .longshot/spec.md — Top-level project spec. The "what this project IS" document.
+- .longshot/tasks.json — Task index: array of {id, slug, title, status, created, completed?, checkpoint?}
+- .longshot/tasks/NNN-slug.md — Individual task specs. Each task has its own spec with scope, approach, acceptance criteria.
+- .longshot/history.jsonl — Append-only action log.
+- .longshot/status.json — Write this after every action (see below).
+
+## Task workflow
+
+1. User describes work → you create a task spec file + add entry to tasks.json with status "drafting"
+2. User reviews/amends → you update the task spec. When agreed, status becomes "ready"
+3. User says go → status becomes "in_progress", you implement against the task spec
+4. User reviews diff → approve means checkpoint + project spec updated + task marked "complete"
+
+## Working style
+
+- You are being driven by a mobile web UI. The user types short messages from their phone.
+- Read the project spec and active task before doing anything.
+- Keep responses concise — the user is reading on a small screen.
+- When implementing: stay focused on the task spec. Don't scope-creep.
+- Be decisive. State what you did, don't ask rhetorical questions. Never say "Would you like me to...", "Should I...", or "Do you want...". Just do it. If something is ambiguous, pick the best option and state your choice.
+
+## IMPORTANT: Populate your task list immediately
+
+Before doing any file reads, searches, or writes, your VERY FIRST action must be to use the TodoWrite tool to create a task list for what you plan to do. This lets the user see your plan immediately in the agent progress view. Update the list as you work — mark items in_progress when you start them and completed when done.
+
+## After every action
+
+Always write .longshot/status.json when you're done:
+
+\`\`\`json
+{
+  "summary": "One-line description of what you did",
+  "specUpdated": true or false,
+  "taskId": null or task number,
+  "filesChanged": ["list", "of", "files", "you", "modified"],
+  "actions": ["Short description of each action taken"]
+}
+\`\`\`
+`;
+    await writeFile(join(getProjectRoot(), "CLAUDE.md"), claudeMd, "utf-8");
+}
+function getPendingDiffsPath() {
+    return join(getProjectRoot(), ".longshot", "pending-diffs.json");
+}
+function loadPendingDiffs() {
+    try {
+        const path = getPendingDiffsPath();
+        if (existsSync(path)) {
+            const data = JSON.parse(readFileSync(path, "utf-8"));
+            return new Map(Object.entries(data));
+        }
+    }
+    catch { }
+    return new Map();
+}
+function savePendingDiffs(diffs) {
+    const obj = Object.fromEntries(diffs);
+    writeFileSync(getPendingDiffsPath(), JSON.stringify(obj, null, 2), "utf-8");
+}
+// The shared pending diffs map — imported by index.ts
+export const pendingDiffs = loadPendingDiffs();
+export function reloadPendingDiffs() {
+    const fresh = loadPendingDiffs();
+    pendingDiffs.clear();
+    for (const [k, v] of fresh) {
+        pendingDiffs.set(k, v);
+    }
+}
+export { savePendingDiffs as persistPendingDiffs };
+// --- Extract checks from run events ---
+const TEST_COMMAND_PATTERNS = [
+    /\bnpm\s+test\b/,
+    /\bnpx\s+jest\b/,
+    /\bnpx\s+vitest\b/,
+    /\bpytest\b/,
+    /\bcargo\s+test\b/,
+    /\bgo\s+test\b/,
+    /\bmake\s+test\b/,
+    /\bnode\s+--test\b/,
+    /\bnpx\s+tsx\s+--test\b/,
+];
+async function extractChecksFromRun(runId) {
+    const events = await store.readRunLog(runId);
+    const checks = { testsRun: false };
+    // Track tool_use → tool_result pairs for test detection
+    const bashToolUses = new Map(); // id → command
+    let lastTodoItems;
+    for (const event of events) {
+        if (event.type === "tool_use" && event.name === "Bash" && event.input?.command) {
+            const cmd = event.input.command;
+            if (TEST_COMMAND_PATTERNS.some((p) => p.test(cmd))) {
+                bashToolUses.set(event.id, cmd);
+            }
+        }
+        if (event.type === "tool_result" && bashToolUses.has(event.id)) {
+            checks.testsRun = true;
+            const output = event.content || "";
+            // Truncate test output for storage
+            checks.testOutput = output.slice(0, 2000);
+            // Heuristic: check for common failure indicators
+            const hasFailure = /\bfail(ed|ure|ing)?\b/i.test(output) &&
+                !/\bfail(ed|ure|s)?\s*(0|:?\s*0)\b/i.test(output) &&
+                !/0\s+fail/i.test(output);
+            const hasPass = /\b(pass(ed)?|ok|success)\b/i.test(output) ||
+                /0\s+fail/i.test(output) ||
+                /\bfail(ed|ure|s)?\s*(0|:?\s*0)\b/i.test(output);
+            checks.testsPassed = hasPass && !hasFailure;
+        }
+        if (event.type === "tool_use" && event.name === "TodoWrite" && event.input?.todos) {
+            lastTodoItems = event.input.todos.map((t) => ({ content: t.content, status: t.status }));
+        }
+    }
+    if (lastTodoItems) {
+        checks.todoItems = lastTodoItems;
+    }
+    return checks;
+}
+// --- Queue state ---
+let processing = false;
+let currentRunId = null;
+let agentRunning = false;
+export function getQueueState() {
+    return { processing, currentRunId, agentRunning };
+}
+async function runAgent(prompt, label, activeTask, taskId, opts) {
+    const spec = await store.readSpec();
+    await writeCLAUDEmd(spec, activeTask);
+    await clearAgentStatus();
+    await git.ensureRepo(getProjectRoot());
+    const snapshotHash = await git.snapshot(getProjectRoot());
+    const runId = store.generateRunId();
+    await store.appendRunEvent(runId, {
+        ts: new Date().toISOString(),
+        type: "user_message",
+        content: prompt,
+    });
+    await store.appendHistory({
+        timestamp: new Date().toISOString(),
+        type: "agent_spawn",
+        summary: label,
+        details: `Run: ${runId}`,
+    });
+    agentRunning = true;
+    currentRunId = runId;
+    try {
+        const agent = spawnAgent(prompt, getProjectRoot());
+        let fullText = "";
+        for await (const event of agent.events) {
+            await store.appendRunEvent(runId, {
+                ts: new Date().toISOString(),
+                ...event,
+            });
+            if (event.type === "text") {
+                fullText += event.content;
+            }
+        }
+        // Save assistant response to conversation
+        if (fullText) {
+            const messages = await store.readConversation();
+            messages.push({
+                role: "assistant",
+                content: fullText,
+                timestamp: new Date().toISOString(),
+                runId,
+            });
+            await store.saveConversation(messages);
+        }
+        // Check for diff (excludes .longshot/)
+        const status = await readAgentStatus();
+        const diffContent = await git.diff(getProjectRoot(), snapshotHash);
+        const summary = status?.summary || label;
+        // For autoCommit runs (spec-update, draft, refine), also check for .longshot/ changes
+        // since diff() excludes them but they're the expected output
+        const hasSourceChanges = diffContent.trim().length > 0;
+        const hasAnyChanges = hasSourceChanges || (opts?.autoCommit && await git.hasUncommittedChanges(getProjectRoot()));
+        if (hasAnyChanges) {
+            if (opts?.skipDiff) {
+                // Keep file changes on disk but don't commit or create a pending diff
+                await store.appendRunEvent(runId, {
+                    ts: new Date().toISOString(),
+                    type: "agent_done_no_commit",
+                    summary,
+                });
+                await store.appendHistory({
+                    timestamp: new Date().toISOString(),
+                    type: "agent_complete",
+                    summary: `Agent completed (changes on disk): ${summary}`,
+                });
+            }
+            else if (opts?.autoCommit) {
+                const commitHash = await git.commit(getProjectRoot(), `checkpoint: ${summary}`);
+                await store.appendRunEvent(runId, {
+                    ts: new Date().toISOString(),
+                    type: "auto_committed",
+                    summary,
+                    commitHash,
+                });
+                await store.appendHistory({
+                    timestamp: new Date().toISOString(),
+                    type: "checkpoint",
+                    summary: `Auto-committed: ${summary}`,
+                    details: `commit: ${commitHash}, from: ${snapshotHash}`,
+                });
+                if (opts.onAutoCommit) {
+                    await opts.onAutoCommit(commitHash);
+                }
+            }
+            else {
+                // Create pending diff and stash source changes for isolation
+                const diffId = crypto.randomUUID();
+                const stashRef = await git.stashSave(getProjectRoot(), `pending-${diffId}`);
+                // Capture agent summary and checks at diff-creation time
+                const agentSummary = status
+                    ? {
+                        summary: status.summary || summary,
+                        filesChanged: status.filesChanged || [],
+                        actions: status.actions || [],
+                    }
+                    : undefined;
+                const checks = await extractChecksFromRun(runId);
+                pendingDiffs.set(diffId, {
+                    cwd: getProjectRoot(),
+                    snapshotHash,
+                    task: summary,
+                    taskId: taskId,
+                    diffContent,
+                    stashRef: stashRef || undefined,
+                    agentSummary,
+                    checks,
+                });
+                savePendingDiffs(pendingDiffs);
+                await store.appendRunEvent(runId, {
+                    ts: new Date().toISOString(),
+                    type: "diff_ready",
+                    diffId,
+                    summary,
+                });
+                await store.appendHistory({
+                    timestamp: new Date().toISOString(),
+                    type: "agent_complete",
+                    summary: `Agent completed: ${summary}`,
+                    details: `Diff: ${diffId}`,
+                });
+            }
+        }
+        else {
+            await store.appendRunEvent(runId, {
+                ts: new Date().toISOString(),
+                type: "agent_done_no_changes",
+                summary: summary,
+            });
+            await store.appendHistory({
+                timestamp: new Date().toISOString(),
+                type: "agent_complete",
+                summary: `Agent completed (no file changes): ${summary}`,
+            });
+        }
+        return { runId };
+    }
+    catch (err) {
+        console.error(`Agent error:`, err);
+        await store.appendRunEvent(runId, {
+            ts: new Date().toISOString(),
+            type: "error",
+            message: err.message,
+        });
+        return { runId, error: err.message };
+    }
+    finally {
+        agentRunning = false;
+        currentRunId = null;
+    }
+}
+// --- Process a single queue item ---
+async function processItem(item) {
+    await store.updateQueueItem(item.id, {
+        status: "running",
+        startedAt: new Date().toISOString(),
+    });
+    try {
+        let result;
+        switch (item.type) {
+            case "draft-task": {
+                const taskId = item.params.taskId;
+                const taskSlug = item.params.taskSlug;
+                const padId = taskId.padStart(3, "0");
+                const prompt = `${item.params.message}
+
+Create a task spec for the above request. A task entry already exists in tasks.json (id: ${taskId}, slug: "${taskSlug}"). Update the task spec file at .longshot/tasks/${padId}-${taskSlug}.md with the full spec. Update the title in tasks.json if needed. Do not create a new entry.
+
+Context available if needed:
+- .longshot/spec.md — project spec
+- .longshot/tasks.json — existing tasks
+- .longshot/conversation.json — chat history`;
+                const activeTask = taskId ? await store.getTask(taskId) : undefined;
+                result = await runAgent(prompt, `Draft task: ${item.params.message.slice(0, 80)}`, activeTask, taskId, { autoCommit: true });
+                break;
+            }
+            case "refine-task": {
+                const task = await store.getTask(item.params.taskId);
+                if (!task) {
+                    await store.updateQueueItem(item.id, {
+                        status: "failed",
+                        error: "Task not found",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+                // Save "Refining..." message to task conversation before agent starts
+                const refineMessage = item.params.message || "Refine this task spec based on recent chat feedback.";
+                let taskConvBefore = await store.readTaskConversation(item.params.taskId);
+                taskConvBefore.push({
+                    role: "assistant",
+                    content: `Refining the spec based on your feedback...`,
+                    timestamp: new Date().toISOString(),
+                });
+                taskConvBefore = await store.archiveTaskConversationIfNeeded(item.params.taskId, taskConvBefore);
+                await store.saveTaskConversation(item.params.taskId, taskConvBefore);
+                // Include task-local conversation context in the prompt
+                const taskConversation = await store.readTaskConversation(item.params.taskId);
+                const recentTaskChat = taskConversation.slice(-20);
+                const taskChatContext = recentTaskChat.length > 0
+                    ? `\nRecent task conversation:\n${recentTaskChat.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n\n")}\n`
+                    : "";
+                const prompt = `${refineMessage}
+${taskChatContext}
+Refine the task spec for task #${item.params.taskId}: ${task.meta.title}. Update the task spec file. Keep the task in "drafting" status.
+
+IMPORTANT: Be decisive. When the user gives feedback or direction, make decisions and state what you did. Do NOT ask rhetorical questions like "Would you like me to...", "Should I...", "Do you want me to...". The user is on mobile and wants you to act, not ask. If something is ambiguous, pick the most reasonable option, apply it, and state what you chose. The user can always refine further if they disagree.
+
+If the user is asking a direct question, answer it concisely. If they're giving feedback or direction, update the spec accordingly and summarise what changed.
+
+Context available if needed:
+- .longshot/spec.md — project spec
+- .longshot/tasks.json — existing tasks`;
+                result = await runAgent(prompt, `Refine task #${item.params.taskId}: ${task.meta.title}`, task, item.params.taskId, { skipDiff: true });
+                // Commit just the spec file so changes aren't orphaned on disk
+                if (!result.error) {
+                    const padId = String(item.params.taskId).padStart(3, "0");
+                    const specFile = `.longshot/tasks/${padId}-${task.meta.slug}.md`;
+                    await git.commitFiles(getProjectRoot(), `refine task #${item.params.taskId}: ${task.meta.title}`, [specFile]);
+                    // Save completion message to task conversation
+                    const status = await readAgentStatus();
+                    const summary = status?.summary || "Spec updated.";
+                    let taskConvAfter = await store.readTaskConversation(item.params.taskId);
+                    taskConvAfter.push({
+                        role: "assistant",
+                        content: summary,
+                        timestamp: new Date().toISOString(),
+                    });
+                    taskConvAfter = await store.archiveTaskConversationIfNeeded(item.params.taskId, taskConvAfter);
+                    await store.saveTaskConversation(item.params.taskId, taskConvAfter);
+                    await store.updateTaskStatus(item.params.taskId, "drafting");
+                }
+                break;
+            }
+            case "start-work": {
+                await store.updateTaskStatus(item.params.taskId, "in_progress");
+                const task = await store.getTask(item.params.taskId);
+                if (!task) {
+                    await store.updateQueueItem(item.id, {
+                        status: "failed",
+                        error: "Task not found",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+                const prompt = `Implement task #${item.params.taskId}: ${task.meta.title}\n\nTask spec:\n${task.spec}`;
+                result = await runAgent(prompt, `Task #${item.params.taskId}: ${task.meta.title}`, task, item.params.taskId);
+                break;
+            }
+            case "spec-update": {
+                const taskIdForUpdate = item.params.taskId;
+                const task = await store.getTask(taskIdForUpdate);
+                if (!task) {
+                    await store.updateQueueItem(item.id, {
+                        status: "failed",
+                        error: "Task not found",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+                const padId = String(task.meta.id).padStart(3, "0");
+                const taskDir = `.longshot/tasks/${padId}-${task.meta.slug}`;
+                const specPrompt = `Task #${taskIdForUpdate} "${task.meta.title}" has just been implemented and approved.
+
+Do TWO things:
+
+1. Update .longshot/spec.md to reflect what was built. Read the task spec and the current spec, then update the spec to accurately describe the project as it now exists.
+
+2. Generate a completion report and save it to ${taskDir}/report.md. The report should include:
+   - **Summary**: 1-2 sentence description of what was done
+   - **Changes**: list of files modified/added/deleted with brief descriptions
+   - **Diff from plan**: anything that diverged from the original task spec (scope changes, unexpected complications, things left out)
+   - **Commits**: the commit hash(es) associated with this task (check git log)
+
+Context:
+- .longshot/tasks/${padId}-${task.meta.slug}.md — the task spec
+- .longshot/spec.md — current project spec to update
+- Use git log and git diff to understand what changed`;
+                result = await runAgent(specPrompt, `Update spec for task #${taskIdForUpdate}`, task, taskIdForUpdate, {
+                    autoCommit: true,
+                    onAutoCommit: async (specCommitHash) => {
+                        await store.updateTaskStatus(taskIdForUpdate, "complete", specCommitHash);
+                        await store.appendHistory({
+                            timestamp: new Date().toISOString(),
+                            type: "task_complete",
+                            summary: `Task #${taskIdForUpdate} completed`,
+                            details: `commit: ${specCommitHash}`,
+                        });
+                    },
+                });
+                break;
+            }
+            case "fix-task": {
+                const task = await store.getTask(item.params.taskId);
+                if (!task) {
+                    await store.updateQueueItem(item.id, {
+                        status: "failed",
+                        error: "Task not found",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+                // Get the existing pending diff to include context
+                reloadPendingDiffs();
+                const existingDiff = item.params.diffId
+                    ? pendingDiffs.get(item.params.diffId)
+                    : null;
+                // Preserve the original snapshot hash (from before the task started)
+                const originalSnapshotHash = existingDiff?.snapshotHash;
+                // Apply existing stash so fix agent can see current changes
+                if (existingDiff?.stashRef) {
+                    await git.stashApply(getProjectRoot(), existingDiff.stashRef);
+                    await git.stashDrop(getProjectRoot(), existingDiff.stashRef);
+                }
+                // Include task-local conversation context in the prompt
+                const taskConversation = await store.readTaskConversation(item.params.taskId);
+                const recentTaskChat = taskConversation.slice(-20);
+                const taskChatContext = recentTaskChat.length > 0
+                    ? `\nRecent conversation about this task:\n${recentTaskChat.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n\n")}\n`
+                    : "";
+                const diffSection = existingDiff?.diffContent
+                    ? `\nCurrent diff (changes made so far):\n\`\`\`diff\n${existingDiff.diffContent.slice(0, 10000)}\n\`\`\`\n`
+                    : "";
+                const fixPrompt = `You are fixing a targeted issue in task #${item.params.taskId}: ${task.meta.title}
+
+Task spec:
+${task.spec}
+${diffSection}${taskChatContext}
+The user has requested the following fix:
+${item.params.message}
+
+If the user is asking a question about the diff, answer it in the conversation and make no code changes. If they're requesting a change, apply the fix. Stay focused — only change what's needed to address this specific request.`;
+                // Delete the old pending diff before running the fix agent
+                if (item.params.diffId && pendingDiffs.has(item.params.diffId)) {
+                    pendingDiffs.delete(item.params.diffId);
+                    savePendingDiffs(pendingDiffs);
+                }
+                // Set task back to in_progress for the agent run
+                await store.updateTaskStatus(item.params.taskId, "in_progress");
+                // Run fix agent in main tree (runAgent will stash changes after)
+                result = await runAgent(fixPrompt, `Fix task #${item.params.taskId}: ${item.params.message.slice(0, 60)}`, task, item.params.taskId);
+                // After agent completes, update the new pending diff to use the original
+                // snapshot hash so the diff shows cumulative changes from task start
+                if (originalSnapshotHash && !result.error) {
+                    reloadPendingDiffs();
+                    for (const [diffId, diff] of pendingDiffs) {
+                        if (diff.taskId === item.params.taskId && diff.snapshotHash !== originalSnapshotHash) {
+                            // Unstash, recalculate cumulative diff, re-stash
+                            if (diff.stashRef) {
+                                await git.stashApply(getProjectRoot(), diff.stashRef);
+                            }
+                            const cumulativeDiff = await git.diff(getProjectRoot(), originalSnapshotHash);
+                            if (cumulativeDiff.trim()) {
+                                diff.snapshotHash = originalSnapshotHash;
+                                diff.diffContent = cumulativeDiff;
+                            }
+                            if (diff.stashRef) {
+                                await git.stashDrop(getProjectRoot(), diff.stashRef);
+                                const newRef = await git.stashSave(getProjectRoot(), `pending-${diffId}`);
+                                diff.stashRef = newRef || undefined;
+                            }
+                            savePendingDiffs(pendingDiffs);
+                        }
+                    }
+                }
+                break;
+            }
+            case "verify": {
+                // Verification runs separately — they don't block the main queue
+                // For now, mark as done immediately and let the existing verify system handle it
+                result = { runId: `verify-${item.params.taskId}` };
+                break;
+            }
+            default:
+                result = { runId: "" };
+        }
+        const failed = !!result.error;
+        await store.updateQueueItem(item.id, {
+            status: failed ? "failed" : "done",
+            runId: result.runId,
+            error: result.error,
+            completedAt: new Date().toISOString(),
+        });
+        // Revert transitional task status on failure
+        if (failed) {
+            await revertTaskStatusOnFailure(item);
+        }
+    }
+    catch (err) {
+        console.error("Queue item processing error:", err);
+        const isConflict = err.message?.includes("conflict") ||
+            err.message?.includes("CONFLICT");
+        if (isConflict && item.params.taskId) {
+            // Preserve conflict context for resolution UI
+            await store.updateQueueItem(item.id, {
+                status: "conflict",
+                error: err.message,
+                completedAt: new Date().toISOString(),
+            });
+            // Set task to conflict status (don't revert to in_progress)
+            await store.updateTaskStatus(item.params.taskId, "conflict");
+        }
+        else {
+            await store.updateQueueItem(item.id, {
+                status: isConflict ? "conflict" : "failed",
+                error: err.message,
+                completedAt: new Date().toISOString(),
+            });
+            // Revert transitional task status on failure
+            await revertTaskStatusOnFailure(item);
+        }
+    }
+}
+async function revertTaskStatusOnFailure(item) {
+    const taskId = item.params.taskId;
+    if (!taskId)
+        return;
+    // Don't revert terminal statuses — a completed/rejected task should stay that way
+    const task = await store.getTask(taskId);
+    if (task && (task.meta.status === "complete" || task.meta.status === "rejected"))
+        return;
+    switch (item.type) {
+        case "start-work": {
+            // If there's a pending diff from a previous run, stay in_progress
+            reloadPendingDiffs();
+            const hasDiff = [...pendingDiffs.values()].some((d) => d.taskId === taskId);
+            await store.updateTaskStatus(taskId, hasDiff ? "in_progress" : "ready");
+            break;
+        }
+        case "refine-task":
+            await store.updateTaskStatus(taskId, "drafting");
+            break;
+        case "spec-update":
+            await store.updateTaskStatus(taskId, "in_progress");
+            break;
+        case "fix-task":
+            await store.updateTaskStatus(taskId, "in_progress");
+            break;
+    }
+}
+// --- Queue processor loop ---
+async function processNext() {
+    if (processing)
+        return;
+    processing = true;
+    try {
+        while (true) {
+            const queue = await store.readQueue();
+            const next = queue.find((q) => q.status === "pending");
+            if (!next)
+                break;
+            await processItem(next);
+        }
+    }
+    finally {
+        processing = false;
+    }
+}
+// Generate a slug from a message (first few words, kebab-case)
+function slugFromMessage(message) {
+    return message
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, "")
+        .trim()
+        .split(/\s+/)
+        .slice(0, 5)
+        .join("-")
+        .slice(0, 50)
+        .replace(/-$/, "") || "new-task";
+}
+// Generate a title from a message (first ~80 chars, sentence case)
+function titleFromMessage(message) {
+    const first = message.split("\n")[0].trim();
+    return first.length > 80 ? first.slice(0, 77) + "..." : first;
+}
+// Enqueue an item and kick off processing
+export async function enqueue(type, params) {
+    // Pre-create task entry for draft-task so it appears immediately
+    if (type === "draft-task" && params.message) {
+        const slug = slugFromMessage(params.message);
+        const title = titleFromMessage(params.message);
+        const task = await store.createTask(title, slug);
+        params.taskId = task.id;
+        params.taskSlug = task.slug;
+    }
+    const item = await store.addQueueItem({ type, params });
+    // Set transitional task status immediately on enqueue
+    if (type === "start-work" && params.taskId) {
+        await store.updateTaskStatus(params.taskId, "queued");
+    }
+    else if (type === "refine-task" && params.taskId) {
+        await store.updateTaskStatus(params.taskId, "refining");
+    }
+    else if (type === "spec-update" && params.taskId) {
+        await store.updateTaskStatus(params.taskId, "approved");
+    }
+    else if (type === "fix-task" && params.taskId) {
+        await store.updateTaskStatus(params.taskId, "fixing");
+    }
+    // Start processing if not already running
+    processNext().catch((err) => console.error("Queue processor error:", err));
+    return item;
+}
+// Start processing on boot (if there are pending items)
+export async function startQueueProcessor() {
+    // Clean up any items stuck in "running" state from a crash
+    const queue = await store.readQueue();
+    for (const item of queue) {
+        if (item.status === "running") {
+            await store.updateQueueItem(item.id, {
+                status: "failed",
+                error: "Server restarted while running",
+                completedAt: new Date().toISOString(),
+            });
+            // Revert transitional task status
+            await revertTaskStatusOnFailure(item);
+        }
+    }
+    await store.cleanOldQueueItems();
+    // Backward compat: drop any old pending diffs with worktreePath (pre-stash migration)
+    reloadPendingDiffs();
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.worktreePath) {
+            console.log(`Dropping legacy worktree-based pending diff: ${diffId}`);
+            pendingDiffs.delete(diffId);
+        }
+    }
+    savePendingDiffs(pendingDiffs);
+    // Process any pending items
+    processNext().catch((err) => console.error("Queue processor startup error:", err));
+}
+// Find the conflict queue item for a task
+export function findConflictItem(queue, taskId) {
+    return queue.find((q) => q.status === "conflict" && q.params.taskId === taskId);
+}
+// Resolve conflict: restart task (drop stash, delete pending diff, reset to ready)
+export async function resolveConflictRestart(taskId) {
+    const queue = await store.readQueue();
+    const conflictItem = findConflictItem(queue, taskId);
+    if (!conflictItem)
+        return false;
+    // Find and clean up the pending diff for this task
+    reloadPendingDiffs();
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.taskId === taskId) {
+            if (diff.stashRef) {
+                await git.stashDrop(getProjectRoot(), diff.stashRef);
+            }
+            pendingDiffs.delete(diffId);
+            savePendingDiffs(pendingDiffs);
+            break;
+        }
+    }
+    // Clean up conflict queue item
+    await store.updateQueueItem(conflictItem.id, {
+        status: "done",
+        completedAt: new Date().toISOString(),
+    });
+    // Reset task to ready
+    await store.updateTaskStatus(taskId, "ready");
+    return true;
+}
+// Resolve conflict: agent resolve (apply stash with conflicts, run fix agent)
+export async function resolveConflictAgent(taskId) {
+    const queue = await store.readQueue();
+    const conflictItem = findConflictItem(queue, taskId);
+    if (!conflictItem)
+        return null;
+    // Find the pending diff
+    reloadPendingDiffs();
+    let diffId;
+    let pending;
+    for (const [id, diff] of pendingDiffs) {
+        if (diff.taskId === taskId) {
+            diffId = id;
+            pending = diff;
+            break;
+        }
+    }
+    if (!pending || !diffId)
+        return null;
+    // Apply stash allowing conflicts
+    if (pending.stashRef) {
+        const { conflicts } = await git.stashApplyAllowConflicts(getProjectRoot(), pending.stashRef);
+        await git.stashDrop(getProjectRoot(), pending.stashRef);
+        // Remove the old pending diff
+        pendingDiffs.delete(diffId);
+        savePendingDiffs(pendingDiffs);
+        // Mark conflict queue item as done
+        await store.updateQueueItem(conflictItem.id, {
+            status: "done",
+            completedAt: new Date().toISOString(),
+        });
+        // Enqueue a fix-task to resolve the conflicts
+        const conflictFiles = conflicts.join(", ");
+        const item = await enqueue("fix-task", {
+            taskId,
+            message: `Resolve merge conflicts in the following files: ${conflictFiles}. Look for conflict markers (<<<<<<< / ======= / >>>>>>>) and resolve them by keeping the correct code. After resolving, ensure the code compiles and works correctly.`,
+        });
+        return item;
+    }
+    return null;
+}
+// Resolve conflict: manual (apply stash with conflicts, leave for user)
+export async function resolveConflictManual(taskId) {
+    const queue = await store.readQueue();
+    const conflictItem = findConflictItem(queue, taskId);
+    if (!conflictItem)
+        return null;
+    // Find the pending diff
+    reloadPendingDiffs();
+    let diffId;
+    let pending;
+    for (const [id, diff] of pendingDiffs) {
+        if (diff.taskId === taskId) {
+            diffId = id;
+            pending = diff;
+            break;
+        }
+    }
+    if (!pending || !diffId)
+        return null;
+    let conflicts = [];
+    if (pending.stashRef) {
+        const result = await git.stashApplyAllowConflicts(getProjectRoot(), pending.stashRef);
+        conflicts = result.conflicts;
+        await git.stashDrop(getProjectRoot(), pending.stashRef);
+    }
+    // Remove old pending diff
+    pendingDiffs.delete(diffId);
+    savePendingDiffs(pendingDiffs);
+    // Mark conflict queue item as done
+    await store.updateQueueItem(conflictItem.id, {
+        status: "done",
+        completedAt: new Date().toISOString(),
+    });
+    // Set task to in_progress (manual resolution in progress)
+    await store.updateTaskStatus(taskId, "in_progress");
+    return { conflicts };
+}
+// After manual conflict resolution, create a new pending diff
+export async function resolveConflictDone(taskId) {
+    const task = await store.getTask(taskId);
+    if (!task)
+        return null;
+    // Find the original snapshot hash from the queue item
+    const queue = await store.readQueue();
+    // Look for the most recent done conflict item for this task to get the snapshot
+    // We need the original snapshot — get it from the task's checkpoint or find it
+    // Take a diff from current state
+    await git.ensureRepo(getProjectRoot());
+    const currentHead = await git.snapshot(getProjectRoot());
+    const diffContent = await git.diff(getProjectRoot(), currentHead);
+    if (!diffContent.trim()) {
+        return null; // No changes to review
+    }
+    // Create a new pending diff
+    const newDiffId = crypto.randomUUID();
+    const stashRef = await git.stashSave(getProjectRoot(), `pending-${newDiffId}`);
+    pendingDiffs.set(newDiffId, {
+        cwd: getProjectRoot(),
+        snapshotHash: currentHead,
+        task: `Task #${taskId}: ${task.meta.title} (conflict resolved)`,
+        taskId,
+        diffContent,
+        stashRef: stashRef || undefined,
+    });
+    savePendingDiffs(pendingDiffs);
+    return newDiffId;
+}
+// Retry a failed/conflict item
+export async function retryQueueItem(id) {
+    const queue = await store.readQueue();
+    const item = queue.find((q) => q.id === id);
+    if (!item || (item.status !== "failed" && item.status !== "conflict"))
+        return false;
+    await store.updateQueueItem(id, {
+        status: "pending",
+        startedAt: undefined,
+        completedAt: undefined,
+        runId: undefined,
+        error: undefined,
+    });
+    processNext().catch((err) => console.error("Queue processor retry error:", err));
+    return true;
+}