@longshot/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1250 @@
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { readFile as fsReadFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { marked } from "marked";
+import * as store from "./store.js";
+import * as git from "./git.js";
+import { spawnAgent, chatWithClaude } from "./agent.js";
+import { enqueue, getQueueState, pendingDiffs, persistPendingDiffs, reloadPendingDiffs, startQueueProcessor, findConflictItem, resolveConflictRestart, resolveConflictAgent, resolveConflictManual, resolveConflictDone } from "./queue.js";
+import { chatPage } from "./views/chat.js";
+import { specPage } from "./views/spec.js";
+import { diffPage } from "./views/diff.js";
+import { historyPage } from "./views/history.js";
+import { tasksListPage, taskDetailPage } from "./views/tasks.js";
+import { runPage } from "./views/run.js";
+import { agentProgressPage } from "./views/agent-progress.js";
+import { verifyPage, verifyLogPage } from "./views/verify.js";
+import { servicesPage, serviceLogsPage } from "./views/services.js";
+import { branchesPage } from "./views/branches.js";
+import * as services from "./services.js";
+import * as projects from "./projects.js";
+const app = new Hono();
+const PORT = parseInt(process.env.PORT || "3333", 10);
+const runningVerifications = [];
+// --- Static files ---
+app.use("/style.css", serveStatic({ root: "./public" }));
+// --- Project API routes (multi-project mode) ---
+app.get("/api/projects", (c) => {
+    if (!projects.isMultiProject())
+        return c.json({ multiProject: false, projects: [] });
+    return c.json({
+        multiProject: true,
+        projects: projects.readProjects(),
+        current: projects.getCurrentProjectName(),
+    });
+});
+app.get("/api/projects/current", (c) => {
+    return c.json({
+        multiProject: projects.isMultiProject(),
+        current: projects.getCurrentProjectName(),
+    });
+});
+app.post("/api/projects/current", async (c) => {
+    if (!projects.isMultiProject())
+        return c.json({ error: "Not in multi-project mode" }, 400);
+    const body = await c.req.json();
+    if (!body.name)
+        return c.json({ error: "No project name" }, 400);
+    const ok = projects.switchProject(body.name);
+    if (!ok)
+        return c.json({ error: "Project not found" }, 404);
+    // Reload pending diffs for the new project
+    reloadPendingDiffs();
+    return c.json({ ok: true, current: body.name });
+});
+app.post("/api/projects", async (c) => {
+    if (!projects.isMultiProject())
+        return c.json({ error: "Not in multi-project mode" }, 400);
+    const body = await c.req.json();
+    if (!body.name?.trim())
+        return c.json({ error: "No project name" }, 400);
+    const result = projects.createProject(body.name.trim());
+    if (!result.ok)
+        return c.json({ error: result.error }, 400);
+    // Switch to the new project
+    projects.switchProject(body.name.trim());
+    reloadPendingDiffs();
+    return c.json({ ok: true }, 201);
+});
+app.post("/api/projects/adopt", async (c) => {
+    if (!projects.isMultiProject())
+        return c.json({ error: "Not in multi-project mode" }, 400);
+    const body = await c.req.json();
+    if (!body.name?.trim())
+        return c.json({ error: "No project name" }, 400);
+    const result = projects.adoptProject(body.name.trim());
+    if (!result.ok) {
+        const status = result.error?.includes("not found") ? 404 : 400;
+        return c.json({ error: result.error }, status);
+    }
+    reloadPendingDiffs();
+    return c.json({ ok: true });
+});
+app.get("/api/projects/available", (c) => {
+    if (!projects.isMultiProject())
+        return c.json({ available: [] });
+    return c.json({ available: projects.listAvailableSubdirs() });
+});
+// --- Routes ---
+app.get("/", (c) => c.redirect("/chat"));
+// Agent status (for polling)
+app.get("/api/agent-status", (c) => {
+    const qs = getQueueState();
+    return c.json({ running: qs.agentRunning, runId: qs.currentRunId });
+});
+// Chat — Q&A with Claude + notepad
+app.get("/chat", async (c) => {
+    const allMessages = await store.readConversation();
+    const messages = allMessages.slice(-50); // Show last 50 in UI
+    const pending = [];
+    for (const [diffId, diff] of pendingDiffs) {
+        pending.push({ diffId, summary: diff.task });
+    }
+    const qs = getQueueState();
+    const queue = await store.readQueue();
+    const queueCounts = store.getQueueCounts(queue);
+    const svcList = await services.getServicesWithStatus();
+    const chatServices = svcList.map((s) => ({ id: s.id, name: s.name, status: s.status }));
+    const historyEntries = await store.readHistory();
+    const recentHistory = historyEntries.slice(-10).reverse();
+    return c.html(chatPage(messages, pending, qs.agentRunning, qs.currentRunId, chatPending, queueCounts.pending, chatServices, recentHistory));
+});
+app.post("/chat", async (c) => {
+    const body = await c.req.json();
+    const message = body.message?.trim();
+    if (!message) {
+        return c.json({ error: "No message" }, 400);
+    }
+    let messages = await store.readConversation();
+    messages.push({
+        role: "user",
+        content: message,
+        timestamp: new Date().toISOString(),
+    });
+    messages = await store.archiveConversationIfNeeded(messages);
+    await store.saveConversation(messages);
+    return c.json({ ok: true });
+});
+// Chat with Claude (read-only, no tools)
+let chatPending = false;
+const taskChatPending = new Map();
+app.post("/api/chat/send", async (c) => {
+    const body = await c.req.json();
+    const message = body.message?.trim();
+    if (!message)
+        return c.json({ error: "No message" }, 400);
+    if (chatPending)
+        return c.json({ error: "Chat already pending" }, 409);
+    // Save user message
+    let messages = await store.readConversation();
+    messages.push({
+        role: "user",
+        content: message,
+        timestamp: new Date().toISOString(),
+    });
+    messages = await store.archiveConversationIfNeeded(messages);
+    await store.saveConversation(messages);
+    // Spawn read-only Claude in background
+    chatPending = true;
+    (async () => {
+        try {
+            const response = await chatWithClaude(messages, projects.getProjectRoot());
+            let updated = await store.readConversation();
+            updated.push({
+                role: "assistant",
+                content: response,
+                timestamp: new Date().toISOString(),
+            });
+            updated = await store.archiveConversationIfNeeded(updated);
+            await store.saveConversation(updated);
+        }
+        catch (err) {
+            console.error("Chat error:", err);
+            let updated = await store.readConversation();
+            updated.push({
+                role: "assistant",
+                content: "Sorry, something went wrong getting a response.",
+                timestamp: new Date().toISOString(),
+            });
+            await store.saveConversation(updated);
+        }
+        finally {
+            chatPending = false;
+        }
+    })();
+    return c.json({ ok: true });
+});
+// Add service via Claude chat
+let addServicePending = false;
+app.post("/api/chat/add-service", async (c) => {
+    const body = await c.req.json();
+    const message = body.message?.trim();
+    if (!message)
+        return c.json({ error: "No message" }, 400);
+    if (addServicePending || chatPending)
+        return c.json({ error: "Chat already pending" }, 409);
+    // Save user message
+    let messages = await store.readConversation();
+    messages.push({
+        role: "user",
+        content: message,
+        timestamp: new Date().toISOString(),
+    });
+    messages = await store.archiveConversationIfNeeded(messages);
+    await store.saveConversation(messages);
+    // Spawn read-only Claude with service-extraction system prompt
+    addServicePending = true;
+    chatPending = true;
+    (async () => {
+        try {
+            const systemPrompt = `You are a helpful assistant. The user wants to add a background service (a long-running shell command like a dev server, watcher, etc.).
+
+Extract a service definition from their message and respond with:
+1. A brief confirmation message
+2. A JSON block with the service definition
+
+The JSON block MUST be wrapped in a code fence like this:
+\`\`\`json
+{ "name": "Service Name", "command": "the shell command", "cwd": "/optional/working/directory" }
+\`\`\`
+
+Rules:
+- "name" should be a short, descriptive name (e.g. "Vite Dev Server", "TypeScript Watcher")
+- "command" is the shell command to run
+- "cwd" is optional — only include it if the user specifies a working directory
+- If you cannot determine a reasonable service definition from the message, respond normally without any JSON block`;
+            const response = await chatWithClaude(messages, projects.getProjectRoot(), { systemPrompt });
+            // Try to extract JSON service definition from the response
+            const jsonMatch = response.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
+            let service = null;
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[1]);
+                    if (parsed.name && parsed.command) {
+                        const created = await store.createService(parsed.name.trim(), parsed.command.trim(), parsed.cwd?.trim() || undefined);
+                        service = created;
+                    }
+                }
+                catch {
+                    // JSON parse failed — treat as normal chat response
+                }
+            }
+            // Save Claude's response to conversation
+            let updated = await store.readConversation();
+            updated.push({
+                role: "assistant",
+                content: response,
+                timestamp: new Date().toISOString(),
+            });
+            updated = await store.archiveConversationIfNeeded(updated);
+            await store.saveConversation(updated);
+        }
+        catch (err) {
+            console.error("Add service chat error:", err);
+            let updated = await store.readConversation();
+            updated.push({
+                role: "assistant",
+                content: "Sorry, something went wrong getting a response.",
+                timestamp: new Date().toISOString(),
+            });
+            await store.saveConversation(updated);
+        }
+        finally {
+            addServicePending = false;
+            chatPending = false;
+        }
+    })();
+    return c.json({ ok: true });
+});
+app.get("/api/chat/status", (c) => {
+    return c.json({ pending: chatPending });
+});
+app.get("/api/chat/messages", async (c) => {
+    const after = parseInt(c.req.query("after") || "0", 10);
+    const allMessages = await store.readConversation();
+    // Filter out agent messages (those with runId) — display-only
+    const filtered = allMessages.filter((m) => !m.runId);
+    return c.json({
+        messages: filtered.slice(after).map((m) => ({
+            ...m,
+            html: marked.parse(m.content, { async: false }),
+        })),
+        total: filtered.length,
+        pending: chatPending,
+    });
+});
+app.post("/chat/reset", async (c) => {
+    await store.clearConversation();
+    return c.redirect("/chat");
+});
+// --- Task chat helpers ---
+async function buildTaskChatPrompt(taskId, task, diffContent) {
+    const spec = await store.readSpec();
+    const diffSection = diffContent
+        ? `\nCurrent diff (changes made so far):\n\`\`\`diff\n${diffContent.slice(0, 10000)}\n\`\`\`\n`
+        : "";
+    return `You are a helpful assistant for a software project. You can read files and search the codebase to answer questions accurately, but do not modify anything. You have access to Read, Glob, Grep, and LS tools for discovery.
+
+Project spec:
+${spec}
+
+Task #${taskId}: ${task.meta.title}
+Task spec:
+${task.spec}
+${diffSection}`;
+}
+// --- Task chat routes ---
+app.get("/api/tasks/:id/chat", async (c) => {
+    const id = c.req.param("id");
+    const taskIdStr = String(id);
+    const after = parseInt(c.req.query("after") || "0", 10);
+    const messages = await store.readTaskConversation(taskIdStr);
+    const pending = taskChatPending.get(id) || false;
+    return c.json({
+        messages: messages.slice(after).map((m) => ({
+            ...m,
+            html: marked.parse(m.content, { async: false }),
+        })),
+        total: messages.length,
+        pending,
+    });
+});
+app.post("/api/tasks/:id/chat", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    const message = body.message?.trim();
+    if (!message)
+        return c.json({ error: "No message" }, 400);
+    if (taskChatPending.get(id))
+        return c.json({ error: "Chat already pending" }, 409);
+    const task = await store.getTask(id);
+    if (!task)
+        return c.json({ error: "Task not found" }, 404);
+    // Save user message to task conversation
+    let messages = await store.readTaskConversation(id);
+    messages.push({
+        role: "user",
+        content: message,
+        timestamp: new Date().toISOString(),
+    });
+    messages = await store.archiveTaskConversationIfNeeded(id, messages);
+    await store.saveTaskConversation(id, messages);
+    // Spawn read-only Claude in background with task context
+    taskChatPending.set(id, true);
+    (async () => {
+        try {
+            const systemPrompt = await buildTaskChatPrompt(id, task);
+            const taskConv = await store.readTaskConversation(id);
+            const response = await chatWithClaude(taskConv, projects.getProjectRoot(), { systemPrompt });
+            let updated = await store.readTaskConversation(id);
+            updated.push({
+                role: "assistant",
+                content: response,
+                timestamp: new Date().toISOString(),
+            });
+            updated = await store.archiveTaskConversationIfNeeded(id, updated);
+            await store.saveTaskConversation(id, updated);
+        }
+        catch (err) {
+            console.error("Task chat error:", err);
+            let updated = await store.readTaskConversation(id);
+            updated.push({
+                role: "assistant",
+                content: "Sorry, something went wrong getting a response.",
+                timestamp: new Date().toISOString(),
+            });
+            await store.saveTaskConversation(id, updated);
+        }
+        finally {
+            taskChatPending.set(id, false);
+        }
+    })();
+    return c.json({ ok: true });
+});
+// --- Agent lifecycle routes ---
+app.post("/agent/draft-task", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const userMessage = body.message?.trim();
+    if (!userMessage) {
+        return c.json({ error: "No message" }, 400);
+    }
+    const item = await enqueue("draft-task", { message: userMessage });
+    return c.json({ ok: true, id: item.id, taskId: item.params.taskId });
+});
+app.post("/agent/refine-task/:id", async (c) => {
+    const id = c.req.param("id");
+    const task = await store.getTask(id);
+    if (!task)
+        return c.json({ error: "Task not found" }, 404);
+    const body = await c.req.json().catch(() => ({}));
+    const userMessage = body.message?.trim() || "Refine this task spec based on recent chat feedback.";
+    const item = await enqueue("refine-task", { taskId: id, message: userMessage });
+    return c.json({ ok: true, id: item.id });
+});
+// Agent progress page
+app.get("/agent/:runId", async (c) => {
+    const runId = c.req.param("runId");
+    const events = await store.readRunLog(runId);
+    const qs = getQueueState();
+    const isRunning = qs.agentRunning && qs.currentRunId === runId;
+    return c.html(agentProgressPage(runId, events, isRunning));
+});
+// Agent events polling endpoint
+app.get("/api/agent/:runId/events", async (c) => {
+    const runId = c.req.param("runId");
+    const after = parseInt(c.req.query("after") || "0", 10);
+    const events = await store.readRunLog(runId);
+    const newEvents = events.slice(after);
+    const qs = getQueueState();
+    const isRunning = qs.agentRunning && qs.currentRunId === runId;
+    // Check if there's a diff_ready or auto_committed event
+    let diffId = null;
+    let autoCommitted = false;
+    for (const ev of events) {
+        if (ev.type === "diff_ready") {
+            diffId = ev.diffId;
+        }
+        if (ev.type === "auto_committed") {
+            autoCommitted = true;
+        }
+    }
+    // Check if agent is done (has a done event or diff_ready or agent_done_no_changes or auto_committed or agent_done_no_commit)
+    const isDone = events.some((e) => e.type === "done" || e.type === "diff_ready" || e.type === "agent_done_no_changes" || e.type === "auto_committed" || e.type === "agent_done_no_commit");
+    return c.json({
+        events: newEvents,
+        total: events.length,
+        done: isDone && !isRunning,
+        running: isRunning,
+        diffId,
+        autoCommitted,
+    });
+});
+// Tasks API (for polling)
+app.get("/api/tasks", async (c) => {
+    const tasks = await store.listTasks();
+    reloadPendingDiffs();
+    const taskDiffs = {};
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.taskId) {
+            taskDiffs[diff.taskId] = diffId;
+        }
+    }
+    const qs = getQueueState();
+    const queue = await store.readQueue();
+    let agentTaskId = null;
+    if (qs.agentRunning && qs.currentRunId) {
+        const running = queue.find((item) => item.status === "running");
+        if (running?.params.taskId)
+            agentTaskId = running.params.taskId;
+    }
+    // Collect task IDs with pending/running queue items
+    const pendingQueueTaskIds = queue
+        .filter((item) => (item.status === "pending" || item.status === "running") && item.params.taskId)
+        .map((item) => item.params.taskId);
+    return c.json({
+        tasks,
+        taskDiffs,
+        agentRunning: qs.agentRunning,
+        currentRunId: qs.currentRunId,
+        agentTaskId,
+        pendingQueueTaskIds,
+    });
+});
+app.get("/api/tasks/:id/status", async (c) => {
+    const id = c.req.param("id");
+    const task = await store.getTask(id);
+    if (!task)
+        return c.json({ error: "Task not found" }, 404);
+    const qs = getQueueState();
+    const queue = await store.readQueue();
+    let agentTaskId = null;
+    if (qs.agentRunning && qs.currentRunId) {
+        const running = queue.find((item) => item.status === "running");
+        if (running?.params.taskId)
+            agentTaskId = running.params.taskId;
+    }
+    reloadPendingDiffs();
+    let pendingDiffId = null;
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.taskId === id) {
+            pendingDiffId = diffId;
+            break;
+        }
+    }
+    const hasPendingQueueItem = queue.some((item) => (item.status === "pending" || item.status === "running") && item.params.taskId === id);
+    // Find conflict error if in conflict status
+    let conflictError = null;
+    if (task.meta.status === "conflict") {
+        const conflictItem = findConflictItem(queue, id);
+        if (conflictItem) {
+            conflictError = conflictItem.error || "Merge conflict occurred";
+        }
+    }
+    const specHtml = task.spec
+        ? marked.parse(task.spec, { async: false })
+        : '<p class="empty-state">No task spec written yet.</p>';
+    return c.json({
+        status: task.meta.status,
+        title: task.meta.title,
+        agentRunning: qs.agentRunning,
+        currentRunId: qs.currentRunId,
+        agentTaskId,
+        pendingDiffId,
+        chatPending: taskChatPending.get(id) || false,
+        hasSpec: store.hasRealSpec(task.spec),
+        hasPendingQueueItem,
+        conflictError,
+        specHtml,
+    });
+});
+// Tasks
+app.get("/tasks", async (c) => {
+    const tasks = await store.listTasks();
+    // Build pending diffs map: taskId -> diffId
+    reloadPendingDiffs();
+    const taskDiffs = new Map();
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.taskId) {
+            taskDiffs.set(diff.taskId, diffId);
+        }
+    }
+    // Determine which task has a running agent and which have pending queue items
+    const qs = getQueueState();
+    const queue = await store.readQueue();
+    let agentTaskId = null;
+    if (qs.agentRunning && qs.currentRunId) {
+        const running = queue.find((item) => item.status === "running");
+        if (running?.params.taskId)
+            agentTaskId = running.params.taskId;
+    }
+    const pendingQueueTaskIds = new Set(queue
+        .filter((item) => (item.status === "pending" || item.status === "running") && item.params.taskId)
+        .map((item) => item.params.taskId));
+    return c.html(tasksListPage(tasks, taskDiffs, qs.agentRunning, qs.currentRunId, agentTaskId, pendingQueueTaskIds));
+});
+app.get("/tasks/:id", async (c) => {
+    const id = c.req.param("id");
+    const task = await store.getTask(id);
+    if (!task)
+        return c.html("<p>Task not found.</p>", 404);
+    const taskMessages = (task.meta.status === "drafting" || task.meta.status === "refining")
+        ? await store.readTaskConversation(id)
+        : [];
+    const taskChatIsPending = taskChatPending.get(id) || false;
+    const report = task.meta.status === "complete"
+        ? await store.getTaskReport(id)
+        : null;
+    const qs = getQueueState();
+    const queue = await store.readQueue();
+    let detailAgentTaskId = null;
+    if (qs.agentRunning && qs.currentRunId) {
+        const running = queue.find((item) => item.status === "running");
+        if (running?.params.taskId)
+            detailAgentTaskId = running.params.taskId;
+    }
+    // Look up pending diff for this task
+    reloadPendingDiffs();
+    let pendingDiffId;
+    for (const [diffId, diff] of pendingDiffs) {
+        if (diff.taskId === id) {
+            pendingDiffId = diffId;
+            break;
+        }
+    }
+    const hasPendingQueueItem = queue.some((item) => (item.status === "pending" || item.status === "running") && item.params.taskId === id);
+    // Find conflict error if in conflict status
+    let conflictError;
+    if (task.meta.status === "conflict") {
+        const conflictItem = findConflictItem(queue, task.meta.id);
+        if (conflictItem) {
+            conflictError = conflictItem.error || "Merge conflict occurred";
+        }
+    }
+    return c.html(taskDetailPage(task.meta, task.spec, qs.agentRunning, qs.currentRunId, taskMessages, taskChatIsPending, report, detailAgentTaskId, pendingDiffId, hasPendingQueueItem, conflictError));
+});
+app.post("/tasks/:id/status", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    if (body.status === "rejected") {
+        // Cancel task: clean up pending queue items and pending diffs
+        const queue = await store.readQueue();
+        for (const item of queue) {
+            if (item.params.taskId === id && item.status === "pending") {
+                await store.removeQueueItem(item.id);
+            }
+        }
+        // Clean up any pending diff for this task
+        reloadPendingDiffs();
+        for (const [diffId, diff] of pendingDiffs) {
+            if (diff.taskId === id) {
+                if (diff.stashRef) {
+                    await git.stashDrop(projects.getProjectRoot(), diff.stashRef);
+                }
+                pendingDiffs.delete(diffId);
+                persistPendingDiffs(pendingDiffs);
+                break;
+            }
+        }
+        await store.updateTaskStatus(id, "rejected");
+        await store.appendHistory({
+            timestamp: new Date().toISOString(),
+            type: "rejection",
+            summary: `Cancelled task #${id}`,
+        });
+        return c.json({ ok: true });
+    }
+    if (body.status === "in_progress") {
+        const item = await enqueue("start-work", { taskId: id });
+        return c.json({ ok: true, id: item.id });
+    }
+    // When marking ready, commit spec + conversation
+    if (body.status === "ready") {
+        const task = await store.getTask(id);
+        if (task) {
+            if (!store.hasRealSpec(task.spec)) {
+                return c.json({ error: "Cannot mark ready — task spec is still a placeholder. Wait for the drafting agent to finish or refine the spec first." }, 400);
+            }
+            await store.updateTaskStatus(id, "ready");
+            try {
+                const specPath = store.getTaskSpecPath(id, task.meta.slug);
+                const convPath = store.getTaskConversationPath(id, task.meta.slug);
+                await git.ensureRepo(projects.getProjectRoot());
+                // Stage specific files and commit
+                const { execFile } = await import("node:child_process");
+                const { promisify } = await import("node:util");
+                const execAsync = promisify(execFile);
+                await execAsync("git", ["add", specPath, convPath], { cwd: projects.getProjectRoot() });
+                try {
+                    await execAsync("git", ["commit", "-m", `task #${id}: Mark ready — ${task.meta.title}`], { cwd: projects.getProjectRoot() });
+                }
+                catch {
+                    // Nothing to commit (no changes to spec/conversation)
+                }
+            }
+            catch (err) {
+                console.error("Mark ready commit error:", err);
+            }
+            return c.json({ ok: true });
+        }
+    }
+    await store.updateTaskStatus(id, body.status);
+    return c.json({ ok: true });
+});
+// Spec
+app.get("/spec", async (c) => {
+    const spec = await store.readSpec();
+    return c.html(specPage(spec));
+});
+app.get("/api/spec", async (c) => {
+    const spec = await store.readSpec();
+    return c.text(spec);
+});
+// Diff review
+app.get("/diff/:id", async (c) => {
+    const id = c.req.param("id");
+    reloadPendingDiffs();
+    const pending = pendingDiffs.get(id);
+    if (!pending) {
+        return c.html("<p>Diff not found or already reviewed.</p>", 404);
+    }
+    const chatMessages = pending.taskId
+        ? await store.readTaskConversation(pending.taskId)
+        : [];
+    const chatPending = pending.taskId
+        ? taskChatPending.get(pending.taskId) || false
+        : false;
+    // Extract acceptance criteria from task spec if available
+    let acceptanceCriteria;
+    if (pending.taskId) {
+        const taskSpec = await store.readTaskSpec(pending.taskId);
+        if (taskSpec) {
+            const match = taskSpec.match(/\n## Acceptance criteria\s*\n([\s\S]*?)(?=\n## |\n---|\s*$)/i);
+            if (match) {
+                acceptanceCriteria = match[1].trim();
+            }
+        }
+    }
+    return c.html(diffPage(id, pending.diffContent, pending.task, pending.taskId, chatMessages, chatPending, acceptanceCriteria, pending.agentSummary, pending.checks));
+});
+app.post("/diff/:id/approve", async (c) => {
+    const id = c.req.param("id");
+    reloadPendingDiffs();
+    const pending = pendingDiffs.get(id);
+    if (!pending) {
+        return c.json({ ok: false, error: "Diff not found" }, 404);
+    }
+    // Apply stash + commit immediately (no queue)
+    try {
+        if (pending.stashRef) {
+            await git.stashApply(pending.cwd, pending.stashRef);
+        }
+        const commitHash = await git.commit(pending.cwd, `checkpoint: ${pending.task}`);
+        if (pending.stashRef) {
+            await git.stashDrop(pending.cwd, pending.stashRef);
+        }
+        await store.appendHistory({
+            timestamp: new Date().toISOString(),
+            type: "checkpoint",
+            summary: pending.task,
+            details: `commit: ${commitHash}, from: ${pending.snapshotHash}`,
+        });
+        pendingDiffs.delete(id);
+        persistPendingDiffs(pendingDiffs);
+    }
+    catch (err) {
+        return c.json({ ok: false, error: err.message }, 500);
+    }
+    // If this was a task diff, enqueue spec-update agent
+    if (pending.taskId && !pending.specUpdate) {
+        const item = await enqueue("spec-update", { taskId: pending.taskId });
+        return c.json({ ok: true, id: item.id, specUpdate: true });
+    }
+    return c.json({ ok: true, specUpdate: false });
+});
+app.post("/diff/:id/reject", async (c) => {
+    const id = c.req.param("id");
+    reloadPendingDiffs();
+    const pending = pendingDiffs.get(id);
+    if (!pending) {
+        return c.json({ ok: false, error: "Diff not found" }, 404);
+    }
+    if (pending.stashRef) {
+        await git.stashDrop(pending.cwd, pending.stashRef);
+    }
+    await store.appendHistory({
+        timestamp: new Date().toISOString(),
+        type: "rejection",
+        summary: `Rejected: ${pending.task}`,
+        details: `Snapshot: ${pending.snapshotHash}`,
+    });
+    pendingDiffs.delete(id);
+    persistPendingDiffs(pendingDiffs);
+    return c.json({ ok: true });
+});
+// Fix task (targeted fix during diff review)
+app.post("/api/tasks/:id/fix", async (c) => {
+    const taskId = c.req.param("id");
+    const body = await c.req.json();
+    const message = body.message?.trim();
+    if (!message)
+        return c.json({ error: "No message" }, 400);
+    const task = await store.getTask(taskId);
+    if (!task)
+        return c.json({ error: "Task not found" }, 404);
+    const item = await enqueue("fix-task", { taskId, message, diffId: body.diffId });
+    return c.json({ ok: true, id: item.id });
+});
+// --- Conflict resolution ---
+app.post("/api/tasks/:id/conflict/restart", async (c) => {
+    const taskId = c.req.param("id");
+    const ok = await resolveConflictRestart(taskId);
+    if (!ok)
+        return c.json({ error: "No conflict found for this task" }, 404);
+    return c.json({ ok: true });
+});
+app.post("/api/tasks/:id/conflict/agent-resolve", async (c) => {
+    const taskId = c.req.param("id");
+    const item = await resolveConflictAgent(taskId);
+    if (!item)
+        return c.json({ error: "No conflict found for this task" }, 404);
+    return c.json({ ok: true, id: item.id });
+});
+app.post("/api/tasks/:id/conflict/manual", async (c) => {
+    const taskId = c.req.param("id");
+    const result = await resolveConflictManual(taskId);
+    if (!result)
+        return c.json({ error: "No conflict found for this task" }, 404);
+    return c.json({ ok: true, conflicts: result.conflicts });
+});
+app.post("/api/tasks/:id/conflict/done", async (c) => {
+    const taskId = c.req.param("id");
+    const diffId = await resolveConflictDone(taskId);
+    if (!diffId)
+        return c.json({ error: "No changes to review" }, 400);
+    return c.json({ ok: true, diffId });
+});
+// --- Services ---
+app.get("/services", async (c) => {
+    const svcList = await services.getServicesWithStatus();
+    return c.html(servicesPage(svcList));
+});
+app.get("/services/:id/logs", async (c) => {
+    const id = c.req.param("id");
+    const service = await store.getService(id);
+    if (!service)
+        return c.html("<p>Service not found.</p>", 404);
+    const status = services.getServiceStatus(id);
+    const logs = await services.getServiceLogs(id);
+    return c.html(serviceLogsPage({ ...service, ...status }, logs));
+});
+app.get("/api/services", async (c) => {
+    const svcList = await services.getServicesWithStatus();
+    return c.json(svcList);
+});
+app.post("/api/services", async (c) => {
+    const body = await c.req.json();
+    if (!body.name?.trim() || !body.command?.trim()) {
+        return c.json({ error: "Name and command required" }, 400);
+    }
+    const service = await store.createService(body.name.trim(), body.command.trim(), body.cwd?.trim() || undefined);
+    return c.json(service, 201);
+});
+app.put("/api/services/:id", async (c) => {
+    const id = c.req.param("id");
+    const status = services.getServiceStatus(id);
+    if (status.status === "running") {
+        return c.json({ error: "Cannot edit a running service" }, 400);
+    }
+    const body = await c.req.json();
+    const updated = await store.updateService(id, {
+        name: body.name?.trim(),
+        command: body.command?.trim(),
+        cwd: body.cwd?.trim(),
+    });
+    if (!updated)
+        return c.json({ error: "Service not found" }, 404);
+    return c.json({ ok: true });
+});
+app.delete("/api/services/:id", async (c) => {
+    const id = c.req.param("id");
+    const status = services.getServiceStatus(id);
+    if (status.status === "running") {
+        return c.json({ error: "Cannot delete a running service" }, 400);
+    }
+    const deleted = await store.deleteService(id);
+    if (!deleted)
+        return c.json({ error: "Service not found" }, 404);
+    return c.json({ ok: true });
+});
+app.post("/api/services/:id/start", async (c) => {
+    const id = c.req.param("id");
+    const result = await services.startService(id);
+    if (!result.ok)
+        return c.json({ error: result.error }, 400);
+    return c.json({ ok: true });
+});
+app.post("/api/services/:id/stop", async (c) => {
+    const id = c.req.param("id");
+    const result = await services.stopService(id);
+    if (!result.ok)
+        return c.json({ error: result.error }, 400);
+    return c.json({ ok: true });
+});
+app.post("/api/services/:id/restart", async (c) => {
+    const id = c.req.param("id");
+    const result = await services.restartService(id);
+    if (!result.ok)
+        return c.json({ error: result.error }, 400);
+    return c.json({ ok: true });
+});
+app.get("/api/services/:id/logs", async (c) => {
+    const id = c.req.param("id");
+    const tailLines = parseInt(c.req.query("lines") || "200", 10);
+    const logs = await services.getServiceLogs(id, tailLines);
+    return c.json({ logs });
+});
+app.post("/api/services/:id/logs/clear", async (c) => {
+    const id = c.req.param("id");
+    await services.clearServiceLogs(id);
+    return c.json({ ok: true });
+});
+// --- Git sync routes ---
+app.get("/api/git/status", async (c) => {
+    const cwd = projects.getProjectRoot();
+    const status = await git.getRemoteStatus(cwd);
+    const outgoing = status.ahead > 0 ? await git.getOutgoingCommits(cwd) : [];
+    return c.json({ ...status, outgoing });
+});
+app.post("/api/git/push", async (c) => {
+    const result = await git.push(projects.getProjectRoot());
+    return c.json(result);
+});
+app.post("/api/git/pull", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const result = body.rebase
+        ? await git.pullRebase(projects.getProjectRoot())
+        : await git.pull(projects.getProjectRoot());
+    return c.json(result);
+});
+// --- Branch management routes ---
+app.get("/branches", async (c) => {
+    const cwd = projects.getProjectRoot();
+    const { local, current } = await git.listBranches(cwd);
+    const branchState = await store.readBranches();
+    // Check for pending diffs
+    reloadPendingDiffs();
+    const hasPendingDiffs = pendingDiffs.size > 0;
+    const branches = local.map((name) => ({
+        name,
+        isCurrent: name === current,
+        info: branchState.branches.find((b) => b.name === name),
+    }));
+    return c.html(branchesPage(branches, current, hasPendingDiffs));
+});
+app.get("/api/branches", async (c) => {
+    const cwd = projects.getProjectRoot();
+    const { local, current } = await git.listBranches(cwd);
+    const branchState = await store.readBranches();
+    return c.json({ branches: local, current, state: branchState });
+});
+app.post("/api/branches", async (c) => {
+    const body = await c.req.json();
+    const name = body.name?.trim();
+    if (!name)
+        return c.json({ error: "No branch name" }, 400);
+    // Validate branch name (basic)
+    if (/[\s~^:?*\[\\]/.test(name)) {
+        return c.json({ error: "Invalid branch name" }, 400);
+    }
+    const cwd = projects.getProjectRoot();
+    try {
+        const currentBranch = await git.getCurrentBranch(cwd);
+        await git.createBranch(cwd, name);
+        // Track in branch state
+        const state = await store.readBranches();
+        state.active = name;
+        state.branches.push({
+            name,
+            createdFrom: currentBranch,
+            createdAt: new Date().toISOString(),
+            taskIds: [],
+        });
+        await store.saveBranches(state);
+        return c.json({ ok: true, branch: name });
+    }
+    catch (err) {
+        return c.json({ error: err.stderr || err.message }, 400);
+    }
+});
+app.post("/api/branches/switch", async (c) => {
+    const body = await c.req.json();
+    const name = body.name?.trim();
+    if (!name)
+        return c.json({ error: "No branch name" }, 400);
+    // Block if pending diffs exist
+    reloadPendingDiffs();
+    if (pendingDiffs.size > 0) {
+        return c.json({ error: "Cannot switch branches while diffs are pending review. Approve or reject them first." }, 400);
+    }
+    const cwd = projects.getProjectRoot();
+    try {
+        await git.switchBranch(cwd, name);
+        // Update branch state
+        const state = await store.readBranches();
+        const isDefault = name === "master" || name === "main";
+        state.active = isDefault ? null : name;
+        await store.saveBranches(state);
+        return c.json({ ok: true, branch: name });
+    }
+    catch (err) {
+        return c.json({ error: err.stderr || err.message }, 400);
+    }
+});
+app.post("/api/branches/:name/push", async (c) => {
+    const name = c.req.param("name");
+    const cwd = projects.getProjectRoot();
+    const result = await git.pushBranch(cwd, name);
+    return c.json(result);
+});
+app.post("/api/branches/:name/merge", async (c) => {
+    const name = c.req.param("name");
+    const cwd = projects.getProjectRoot();
+    const branchState = await store.readBranches();
+    const branchInfo = branchState.branches.find((b) => b.name === name);
+    const target = branchInfo?.createdFrom || "master";
+    const result = await git.mergeBranch(cwd, name, target);
+    if (result.success) {
+        // Update branch state — switch active to target
+        const isDefault = target === "master" || target === "main";
+        branchState.active = isDefault ? null : target;
+        await store.saveBranches(branchState);
+    }
+    return c.json(result);
+});
+app.delete("/api/branches/:name", async (c) => {
+    const name = c.req.param("name");
+    const cwd = projects.getProjectRoot();
+    // Don't delete current branch
+    const current = await git.getCurrentBranch(cwd);
+    if (current === name) {
+        return c.json({ error: "Cannot delete the current branch" }, 400);
+    }
+    const result = await git.deleteBranch(cwd, name);
+    if (result.success) {
+        // Remove from branch state
+        const state = await store.readBranches();
+        state.branches = state.branches.filter((b) => b.name !== name);
+        if (state.active === name)
+            state.active = null;
+        await store.saveBranches(state);
+    }
+    return c.json(result);
+});
+// Queue management
+app.get("/api/queue", async (c) => {
+    const queue = await store.readQueue();
+    return c.json(queue);
+});
+app.post("/api/queue/:id/remove", async (c) => {
+    const id = c.req.param("id");
+    const removed = await store.removeQueueItem(id);
+    return c.json({ ok: removed });
+});
+// History
+app.get("/history", async (c) => {
+    const entries = await store.readHistory();
+    return c.html(historyPage(entries));
+});
+// History API (for polling)
+app.get("/api/history", async (c) => {
+    const entries = await store.readHistory();
+    return c.json({ entries, total: entries.length });
+});
+// Run logs
+app.get("/run/:id", async (c) => {
+    const id = c.req.param("id");
+    const events = await store.readRunLog(id);
+    if (events.length === 0) {
+        return c.html("<p>Run not found.</p>", 404);
+    }
+    return c.html(runPage(id, events));
+});
+// --- Verification routes ---
+// Verify page
+app.get("/task/:id/verify", async (c) => {
+    const taskId = c.req.param("id");
+    const diffId = c.req.query("diffId") || "";
+    const pending = diffId ? pendingDiffs.get(diffId) : null;
+    const taskSummary = pending?.task || `Task #${taskId}`;
+    const results = await store.listVerifyResults(taskId);
+    return c.html(verifyPage(taskId, diffId, taskSummary, results, runningVerifications));
+});
+// Spawn verification agent
+app.post("/task/:id/verify", async (c) => {
+    const taskId = c.req.param("id");
+    const body = await c.req.json();
+    const prompt = body.prompt?.trim();
+    const diffId = body.diffId;
+    if (!prompt)
+        return c.json({ error: "No prompt" }, 400);
+    const task = await store.getTask(taskId);
+    if (!task)
+        return c.json({ error: "Task not found" }, 404);
+    const pending = diffId ? pendingDiffs.get(diffId) : null;
+    const diffContent = pending?.diffContent || "";
+    const runNumber = await store.nextVerifyRunNumber(taskId);
+    const verifyDirPath = await store.ensureVerifyDir(taskId);
+    const padded = String(runNumber).padStart(3, "0");
+    // Load MCP config for verification agents
+    const mcpConfig = await store.readMcpConfig();
+    // Build available tools section based on MCP config
+    const mcpToolsSection = mcpConfig?.mcpServers
+        ? `\n## Available Tools
+You have access to MCP servers for enhanced verification:
+${Object.keys(mcpConfig.mcpServers).includes("playwright") ? `- **Playwright** — browser automation: navigate to URLs, take screenshots, click elements, fill forms
+  - The app runs on http://localhost:${PORT}
+  - Use these tools to visually verify UI changes` : ""}
+${Object.keys(mcpConfig.mcpServers)
+            .filter((k) => k !== "playwright")
+            .map((k) => `- **${k}** MCP server`)
+            .join("\n")}
+`
+        : "";
+    // Build verification agent prompt
+    const verifyPrompt = `You are a verification agent. Your job is to verify that changes work correctly.
+
+## Task
+${task.spec}
+
+## Git Diff Being Reviewed
+\`\`\`diff
+${diffContent.slice(0, 10000)}
+\`\`\`
+
+## Your Verification Task
+${prompt}
+${mcpToolsSection}
+## Instructions
+1. Perform the verification described above
+2. Save any output artifacts (screenshots, test output, etc.) to: ${verifyDirPath}/
+   - Name files with prefix: run-${padded}-
+   - Example: run-${padded}-screenshot.png
+3. When done, write a JSON result file to: ${verifyDirPath}/run-${padded}-result.json
+   With this format:
+   \`\`\`json
+   {
+     "runNumber": ${runNumber},
+     "status": "pass" or "fail" or "error",
+     "summary": "Brief description of what you found",
+     "prompt": ${JSON.stringify(prompt)},
+     "artifacts": ["list of artifact filenames you saved"],
+     "startedAt": "${new Date().toISOString()}",
+     "completedAt": "<ISO timestamp when done>"
+   }
+   \`\`\`
+4. Do NOT modify any source code — you are only verifying
+5. You may run processes, tests, use puppeteer, curl, etc.`;
+    // Save initial result as running
+    const initialResult = {
+        runNumber,
+        status: "running",
+        summary: "",
+        prompt,
+        artifacts: [],
+        startedAt: new Date().toISOString(),
+    };
+    await store.saveVerifyResult(taskId, initialResult);
+    await store.appendVerifyEvent(taskId, runNumber, {
+        ts: new Date().toISOString(),
+        type: "user_message",
+        content: prompt,
+    });
+    const tracking = {
+        runNumber,
+        taskId,
+        done: false,
+        lastEvent: "Starting...",
+    };
+    runningVerifications.push(tracking);
+    // Spawn agent (fire and forget)
+    (async () => {
+        try {
+            const agent = spawnAgent(verifyPrompt, projects.getProjectRoot(), 10 * 60 * 1000, mcpConfig ?? undefined);
+            for await (const event of agent.events) {
+                await store.appendVerifyEvent(taskId, runNumber, {
+                    ts: new Date().toISOString(),
+                    ...event,
+                });
+                if (event.type === "tool_use") {
+                    tracking.lastEvent = `Running: ${event.name}`;
+                }
+                else if (event.type === "text") {
+                    tracking.lastEvent = event.content.slice(0, 80);
+                }
+            }
+            // Check if agent wrote a result file
+            const agentResult = await store.readVerifyResult(taskId, runNumber);
+            if (!agentResult || agentResult.status === "running") {
+                await store.saveVerifyResult(taskId, {
+                    ...initialResult,
+                    status: "error",
+                    summary: "Agent finished without writing a result",
+                    completedAt: new Date().toISOString(),
+                });
+            }
+        }
+        catch (err) {
+            console.error(`Verification agent error:`, err);
+            await store.appendVerifyEvent(taskId, runNumber, {
+                ts: new Date().toISOString(),
+                type: "error",
+                message: err.message,
+            });
+            await store.saveVerifyResult(taskId, {
+                ...initialResult,
+                status: "error",
+                summary: err.message,
+                completedAt: new Date().toISOString(),
+            });
+        }
+        finally {
+            tracking.done = true;
+            const idx = runningVerifications.indexOf(tracking);
+            if (idx >= 0)
+                runningVerifications.splice(idx, 1);
+        }
+    })();
+    return c.json({ ok: true, runNumber });
+});
+// Verification run status (for polling)
+app.get("/task/:id/verify/:runNum/status", async (c) => {
+    const taskId = c.req.param("id");
+    const runNum = parseInt(c.req.param("runNum"), 10);
+    const tracking = runningVerifications.find((v) => v.taskId === taskId && v.runNumber === runNum);
+    if (tracking) {
+        return c.json({ done: false, lastEvent: tracking.lastEvent });
+    }
+    const result = await store.readVerifyResult(taskId, runNum);
+    return c.json({
+        done: true,
+        status: result?.status || "unknown",
+        lastEvent: result?.summary || "Complete",
+    });
+});
+// Verification results list
+app.get("/task/:id/verify/results", async (c) => {
+    const taskId = c.req.param("id");
+    const results = await store.listVerifyResults(taskId);
+    return c.json(results);
+});
+// Verification run log page
+app.get("/task/:id/verify/:runNum/log", async (c) => {
+    const taskId = c.req.param("id");
+    const runNum = parseInt(c.req.param("runNum"), 10);
+    const diffId = c.req.query("diffId") || "";
+    const events = await store.readVerifyLog(taskId, runNum);
+    return c.html(verifyLogPage(taskId, runNum, events, diffId));
+});
+// Serve verification artifacts
+app.get("/task/:id/verify/artifact/:runNum/:filename", async (c) => {
+    const taskId = c.req.param("id");
+    const filename = c.req.param("filename");
+    const verifyDirPath = await store.ensureVerifyDir(taskId);
+    const filePath = join(verifyDirPath, filename);
+    if (!existsSync(filePath)) {
+        return c.text("Not found", 404);
+    }
+    const content = await fsReadFile(filePath);
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    const mimeTypes = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        webp: "image/webp",
+        json: "application/json",
+        txt: "text/plain",
+        log: "text/plain",
+    };
+    const contentType = mimeTypes[ext] || "application/octet-stream";
+    return new Response(content, {
+        headers: { "Content-Type": contentType },
+    });
+});
+// Export app for testing
+export { app };
+export async function startServer() {
+    // Detect multi-project mode
+    projects.detectMode();
+    // Startup cleanup and queue processor
+    try {
+        const deleted = await store.cleanOldRuns();
+        if (deleted > 0)
+            console.log(`Cleaned ${deleted} old run files`);
+        await store.truncateHistoryIfNeeded();
+        await startQueueProcessor();
+    }
+    catch (err) {
+        console.error("Startup cleanup error:", err);
+    }
+    // Start
+    serve({ fetch: app.fetch, port: PORT, hostname: "0.0.0.0" }, (info) => {
+        console.log(`longshot running on http://0.0.0.0:${info.port}`);
+        if (projects.isMultiProject()) {
+            console.log(`Multi-project mode — root: ${projects.getRootDir()}`);
+            const current = projects.getCurrentProjectName();
+            if (current)
+                console.log(`Active project: ${current}`);
+        }
+        else {
+            console.log(`Project root: ${projects.getProjectRoot()}`);
+        }
+    });
+}
+// Only start server when not imported as a module for testing
+if (!process.env.TESTING) {
+    startServer();
+}