querysub 0.680.0 → 0.682.0

package/src/diagnostics/logs/errorTickets/autoFixer.ts

@@ -3,6 +3,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { spawn, ChildProcess } from "child_process";
+import { lazy } from "socket-function/src/caching";
 import { nextId, timeInHour, timeInMinute } from "socket-function/src/misc";
 import { runInfinitePollCallAtStart, runInSerial } from "socket-function/src/batching";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
@@ -16,7 +17,7 @@ import { getControllerNodeId, NodeCapabilitiesController } from "../../../-g-cor
 import { MCPIndexedLogs } from "../IndexedLogs/MCPIndexedLogs";
 import { AutoFixerControllerBase, setAutoFixerHandlers } from "./autoFixerController";
 import { TicketServiceBase } from "./tickets";
-import { Ticket, TicketComment, TicketPatchFile, TicketState } from "./ticketTypes";
+import { AutoFixerRunStatus, Ticket, TicketComment, TicketPatchFile, TicketState } from "./ticketTypes";
 
 const INVESTIGATION_TIMEOUT = timeInMinute * 60;
 // "Files modified" check on tickets we already know are open.
@@ -59,6 +60,13 @@ let currentTicketId: string | undefined = undefined;
 let currentTicketTitle: string | undefined = undefined;
 let currentTicketStartTime = 0;
 
+// Model selected per ticket (from the ticket page dropdown); absent means claude's default.
+let ticketModelOverrides = new Map<string, string>();
+let currentRunRequestedModel: string | undefined = undefined;
+// From claude's stream-json init event, which names the session's actual model.
+let currentRunResolvedModel: string | undefined = undefined;
+let defaultClaudeModel: string | undefined = undefined;
+
 // inputTokens is uncached input only — cache reads/writes are tracked separately, otherwise cache reads massively inflate the input number.
 type TokenUsage = {
     inputTokens: number;
@@ -101,7 +109,20 @@ let patchAddedDuringRun = false;
 
 let knownOpenTicketIds = new Set<string>();
 
+// Tickets queued behind the current run (runs are serialized), for status reporting.
+let pendingTicketIds = new Set<string>();
+// Manually triggered runs skip the "must be in investigation state" check — the user explicitly asked for a run.
+let manualRunTicketIds = new Set<string>();
+// A stop lets the in-flight step finish, then ends the run (or skips the run entirely if it hasn't started yet).
+let stopRequestedTicketIds = new Set<string>();
+
 const processTicket = runInSerial(async (ticketId: string): Promise<void> => {
+    pendingTicketIds.delete(ticketId);
+    let manual = manualRunTicketIds.delete(ticketId);
+    if (stopRequestedTicketIds.delete(ticketId)) {
+        console.log(`AutoFixer skipping queued investigation of ticket ${ticketId} because a stop was requested before it started`);
+        return;
+    }
     try {
         let service = await ticketService();
         let ticket = await service.getTicket(ticketId);
@@ -111,9 +132,12 @@ const processTicket = runInSerial(async (ticketId: string): Promise<void> => {
         }
         if (ticket.state !== "investigation") {
             knownOpenTicketIds.delete(ticketId);
-            return;
+            if (!manual) {
+                return;
+            }
+        } else {
+            knownOpenTicketIds.add(ticketId);
         }
-        knownOpenTicketIds.add(ticketId);
         await runInvestigation(ticket);
     } catch (e) {
         console.error(`AutoFixer failed to process ticket ${ticketId}:`, (e as Error).stack ?? e);
@@ -121,9 +145,59 @@ const processTicket = runInSerial(async (ticketId: string): Promise<void> => {
 });
 
 function queueTicket(ticketId: string) {
+    pendingTicketIds.add(ticketId);
     void processTicket(ticketId);
 }
 
+export function getAutoFixerRunStatus(): AutoFixerRunStatus {
+    return {
+        runningTicketId: currentTicketId,
+        runningTicketTitle: currentTicketTitle,
+        runStartTime: currentTicketId && currentTicketStartTime || undefined,
+        runningModel: currentTicketId && (currentRunResolvedModel ?? currentRunRequestedModel) || undefined,
+        defaultModel: defaultClaudeModel,
+        stopRequested: currentTicketId && stopRequestedTicketIds.has(currentTicketId) || undefined,
+        queuedTicketIds: Array.from(pendingTicketIds).filter(id => id !== currentTicketId),
+    };
+}
+
+export async function startTicketInvestigation(ticketId: string, model?: string): Promise<void> {
+    // The model becomes a command-line argument, so restrict it even though the dropdown only sends known values.
+    if (model && !/^[a-zA-Z0-9._-]+$/.test(model)) {
+        throw new Error(`Invalid model name: ${model}`);
+    }
+    await ensureAutoFixerBase();
+    await registerWithTicketService();
+    let service = await ticketService();
+    let ticket = await service.getTicket(ticketId);
+    if (!ticket) {
+        throw new Error(`Ticket ${ticketId} not found`);
+    }
+    if (currentTicketId === ticketId) {
+        throw new Error(`An AI investigation is already running for this ticket`);
+    }
+    if (pendingTicketIds.has(ticketId)) {
+        throw new Error(`An AI investigation is already queued for this ticket`);
+    }
+    console.log(green(`Manual AI investigation triggered for ticket ${ticketId} (model: ${model ?? "default"}): ${ticket.title}`));
+    stopRequestedTicketIds.delete(ticketId);
+    if (model) {
+        ticketModelOverrides.set(ticketId, model);
+    } else {
+        ticketModelOverrides.delete(ticketId);
+    }
+    manualRunTicketIds.add(ticketId);
+    queueTicket(ticketId);
+}
+
+export function requestStopTicketInvestigation(ticketId: string): void {
+    if (currentTicketId !== ticketId && !pendingTicketIds.has(ticketId)) {
+        return;
+    }
+    console.log(green(`Stop requested for AI investigation of ticket ${ticketId} (current: ${currentTicketId ?? "none"})`));
+    stopRequestedTicketIds.add(ticketId);
+}
+
 async function pollOpenTickets() {
     for (let ticketId of Array.from(knownOpenTicketIds)) {
         queueTicket(ticketId);
@@ -145,7 +219,11 @@ async function pollAllTickets() {
     }
 }
 
+// Only the dedicated autofixer process (yarn autofix) auto-processes every investigation ticket. Nodes that merely host manual runs ignore change notifications.
+let autoProcessingEnabled = false;
+
 function onTicketsChanged(ticketIds: string[]) {
+    if (!autoProcessingEnabled) return;
     console.log(`AutoFixer received ticket change notification: ${ticketIds.join(", ")}`);
     for (let ticketId of ticketIds) {
         queueTicket(ticketId);
@@ -161,65 +239,83 @@ async function registerWithTicketService() {
     }
 }
 
-// Relative paths may belong to either the application repo or the querysub repo (a sibling / dependency) — file paths are unique across the two, so whichever one actually has the file wins.
-function resolvePatchFilePath(file: string): { fullPath: string | undefined; candidates: string[] } {
-    let candidates = Array.from(new Set([
-        path.resolve(process.cwd(), file),
-        path.resolve(QUERYSUB_ROOT, file),
-    ]));
-    for (let candidate of candidates) {
-        if (fs.existsSync(candidate)) {
-            return { fullPath: candidate, candidates };
+// Resolves and validates every file entry without writing anything, accumulating the resulting file contents into `overlay` (fullPath -> contents). Reads go through the overlay first so several patches touching the same file compose in order. Throws with a detailed message when the patch cannot apply cleanly — also used at addPatch time so the AI is told about mistakes immediately.
+function preparePatchWrites(patchFiles: TicketPatchFile[], overlay: Map<string, string>): void {
+    // Relative paths may belong to either the application repo or the querysub repo (a sibling / dependency) — file paths are unique across the two, so whichever one actually has the file wins.
+    function readCurrent(candidates: string[]): { fullPath: string; contents: string } | undefined {
+        for (let candidate of candidates) {
+            let pending = overlay.get(candidate);
+            if (pending !== undefined) {
+                return { fullPath: candidate, contents: pending };
+            }
         }
+        for (let candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return { fullPath: candidate, contents: fs.readFileSync(candidate, "utf8") };
+            }
+        }
+        return undefined;
     }
-    return { fullPath: undefined, candidates };
-}
-
-// Resolves and validates every file entry without writing anything (so a patch is all-or-nothing), returning the writes to perform. Throws with a detailed message when the patch cannot apply cleanly — also used at addPatch time so the AI is told about mistakes immediately.
-function preparePatchWrites(patchFiles: TicketPatchFile[]): { fullPath: string; newContents: string }[] {
-    let writes: { fullPath: string; newContents: string }[] = [];
     for (let patchFile of patchFiles) {
-        let { fullPath, candidates } = resolvePatchFilePath(patchFile.file);
+        let candidates = Array.from(new Set([
+            path.resolve(process.cwd(), patchFile.file),
+            path.resolve(QUERYSUB_ROOT, patchFile.file),
+        ]));
+        let current = readCurrent(candidates);
         if (!patchFile.oldText) {
-            if (fullPath && fs.readFileSync(fullPath, "utf8").trim()) {
-                throw new Error(`Patch wants to create ${patchFile.file}, but it already exists at ${fullPath} and is not empty`);
+            if (current && current.contents.trim() && current.contents !== patchFile.newText) {
+                throw new Error(`Patch wants to create ${patchFile.file}, but it already exists at ${current.fullPath} and is not empty`);
             }
-            writes.push({ fullPath: fullPath ?? candidates[0], newContents: patchFile.newText });
+            overlay.set(current?.fullPath ?? candidates[0], patchFile.newText);
             continue;
         }
-        if (!fullPath) {
+        if (!current) {
             throw new Error(`Patch targets ${patchFile.file}, which does not exist. Tried: ${candidates.join(", ")}`);
         }
-        let contents = fs.readFileSync(fullPath, "utf8");
+        let { fullPath, contents } = current;
         let index = contents.indexOf(patchFile.oldText);
         if (index === -1) {
+            // Re-applying is allowed, so an entry whose replacement is already present is a no-op instead of an error.
+            if (contents.includes(patchFile.newText)) continue;
             throw new Error(`Patch oldText not found in ${fullPath}. oldText must be copied EXACTLY from the current file contents (check whitespace/indentation).`);
         }
         if (contents.indexOf(patchFile.oldText, index + 1) !== -1) {
             throw new Error(`Patch oldText appears more than once in ${fullPath}, so the replacement is ambiguous. Include more surrounding context to make it unique.`);
         }
-        let newContents = contents.slice(0, index) + patchFile.newText + contents.slice(index + patchFile.oldText.length);
-        writes.push({ fullPath, newContents });
+        overlay.set(fullPath, contents.slice(0, index) + patchFile.newText + contents.slice(index + patchFile.oldText.length));
     }
-    return writes;
 }
 
-async function applyPatch(ticketId: string, commentId: string): Promise<void> {
+// Applies a batch of patch comments as one operation: validate ALL of them first (nothing is written if any fails), then persist the applied statuses, and only then write the files. The file writes go last because they can hot-reload this very process (and the page the user is on) — everything else must already be durable by then.
+export async function applyPatches(ticketId: string, commentIds: string[]): Promise<void> {
     let service = await ticketService();
     let ticket = await service.getTicket(ticketId);
     if (!ticket) {
         throw new Error(`Ticket ${ticketId} not found`);
     }
-    let comment = ticket.comments.find(c => c.id === commentId);
-    if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
-        throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
+    let comments = commentIds.map(commentId => {
+        let comment = ticket!.comments.find(c => c.id === commentId);
+        if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
+            throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
+        }
+        return comment;
+    });
+
+    let overlay = new Map<string, string>();
+    for (let comment of comments) {
+        try {
+            preparePatchWrites(comment.patchFiles!, overlay);
+        } catch (e) {
+            throw new Error(`Patch ${comment.id} failed validation — NO patches were applied. ${(e as Error).message}`);
+        }
     }
 
-    let writes = preparePatchWrites(comment.patchFiles);
-    for (let write of writes) {
-        fs.mkdirSync(path.dirname(write.fullPath), { recursive: true });
-        fs.writeFileSync(write.fullPath, write.newContents);
-        console.log(`AutoFixer applied patch to ${write.fullPath}`);
+    await service.setPatchStatuses(ticketId, commentIds, "applied");
+
+    for (let [fullPath, contents] of overlay) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, contents);
+        console.log(`AutoFixer applied patch to ${fullPath}`);
     }
 }
 
@@ -382,7 +478,7 @@ async function callTool(toolName: string, args: Record<string, unknown>): Promis
             }
         }
         try {
-            preparePatchWrites(files);
+            preparePatchWrites(files, new Map());
         } catch (e) {
             throw new Error(`Patch validation failed — the patch was NOT added. Fix the problem and call addPatch again. ${(e as Error).message}`);
         }
@@ -456,10 +552,14 @@ async function dispatch(method: string, params: unknown): Promise<unknown> {
     }
     if (method === "tools/call") {
         let p = (params ?? {}) as { name?: string; arguments?: Record<string, unknown> };
-        let result = await callTool(p.name ?? "", p.arguments ?? {});
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-        };
+        try {
+            let result = await callTool(p.name ?? "", p.arguments ?? {});
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+            };
+        } finally {
+            checkStopAfterStep(`tool ${p.name}`);
+        }
     }
     if (method === "ping") {
         return {};
@@ -519,7 +619,7 @@ async function startToolServer(): Promise<void> {
         });
     });
     await new Promise<void>((resolve, reject) => {
-        server.once("error", reject);
+        server.once("error", e => reject(new Error(`AutoFixer tool server could not listen on port ${TOOL_SERVER_PORT} (is another autofixer already running on this machine?): ${e.stack ?? e}`)));
         server.listen(TOOL_SERVER_PORT, "127.0.0.1", () => resolve());
     });
     console.log(`AutoFixer tool server listening on http://127.0.0.1:${TOOL_SERVER_PORT}`);
@@ -527,6 +627,17 @@ async function startToolServer(): Promise<void> {
 
 // ==================== Investigation runs ====================
 
+// Read fresh per run so edits to the overview apply without restarting the autofixer.
+function getQuerysubOverview(): string {
+    let overviewPath = path.join(QUERYSUB_ROOT, "overview.md");
+    try {
+        return fs.readFileSync(overviewPath, "utf8");
+    } catch (e) {
+        console.error(`AutoFixer could not read ${overviewPath}:`, (e as Error).stack ?? e);
+        return "";
+    }
+}
+
 function buildPrompt(ticket: Ticket): string {
     let priorComments: string[] = [];
     for (let comment of ticket.comments) {
@@ -545,7 +656,8 @@ function buildPrompt(ticket: Ticket): string {
         priorCommentsText = `(older comments omitted)\n` + priorCommentsText.slice(-MAX_PRIOR_COMMENTS_PROMPT_CHARS);
     }
 
-    return `You are an automated bug investigator ("autofixer") working on a ticket created from a production error.
+    let overview = getQuerysubOverview();
+    return `${overview && `==== QUERYSUB OVERVIEW (how the framework works) ====\n${overview.trim()}\n\n` || ""}You are an automated bug investigator ("autofixer") working on a ticket created from a production error.
 
 The application repository is at ${process.cwd()}, and it is built on the querysub framework, whose repository is at ${QUERYSUB_ROOT}. Your job is to fix bugs in BOTH repositories — the bug may be in the application or in querysub itself, so read and patch whichever one the problem actually lives in. Use Read/Glob/Grep to read the code, and the mcp__autofixer__searchLogs / mcp__autofixer__listNodes tools to search the production logs.
 
@@ -585,6 +697,21 @@ const QUERYSUB_ROOT = path.resolve(__dirname, "../../../..");
 // Set for the duration of a claude run; called whenever a turn finishes (a stream-json "result" event), so the run loop can decide to forward new user comments or end the session.
 let claudeTurnEndedHandler: (() => void) | undefined = undefined;
 
+// Set for the duration of a claude run so a stop request can kill it between steps.
+let currentClaudeChild: ChildProcess | undefined = undefined;
+let currentRunStopped = false;
+
+// Called at step boundaries (a tool call finished, an assistant message arrived). Killing here means the in-flight step completed, but the AI never gets to loop again.
+function checkStopAfterStep(context: string) {
+    if (currentRunStopped) return;
+    if (!currentTicketId || !stopRequestedTicketIds.has(currentTicketId)) return;
+    currentRunStopped = true;
+    console.log(green(`Stop requested for ticket ${currentTicketId}; ending the investigation after ${context}`));
+    if (currentClaudeChild) {
+        killChildTree(currentClaudeChild);
+    }
+}
+
 // Built-in tools (Read/Glob/Grep) don't go through our MCP server, so we record them from the stream instead: tool_use blocks are stashed here until their tool_result arrives in a "user" event. Our own mcp__autofixer__ tools are excluded — callTool already records those.
 let pendingStreamToolCalls = new Map<string, { name: string; input: string; startTime: number }>();
 
@@ -645,6 +772,7 @@ function handleClaudeStreamLine(line: string): boolean {
                 }
             }
         }
+        checkStopAfterStep(`an assistant message`);
         return true;
     }
     if (event.type === "result") {
@@ -683,10 +811,18 @@ function handleClaudeStreamLine(line: string): boolean {
                 console.error(`Failed to record tool call in ticket ${ticketId}:`, (e as Error).stack ?? e);
             });
         }
+        checkStopAfterStep(`a tool result`);
         return true;
     }
     if (event.type === "system") {
-        // Init/config noise.
+        if (event.subtype === "init" && typeof event.model === "string") {
+            currentRunResolvedModel = event.model;
+            // A run without --model reveals what the default resolves to, saving a probe.
+            if (!currentRunRequestedModel && !defaultClaudeModel) {
+                defaultClaudeModel = event.model;
+            }
+            console.log(`[claude] session model: ${event.model}`);
+        }
         return true;
     }
     return false;
@@ -697,6 +833,15 @@ function quoteArgForShell(arg: string): string {
     return `"${arg.replace(/"/g, "\\\"")}"`;
 }
 
+function spawnClaudeProcess(args: string[]): ChildProcess {
+    if (process.platform === "win32") {
+        // claude is a .cmd shim on Windows, which spawn can only run through a shell. The shell does no escaping, so we quote the command line ourselves.
+        let commandLine = ["claude", ...args].map(quoteArgForShell).join(" ");
+        return spawn(commandLine, { shell: true, stdio: ["pipe", "pipe", "pipe"] });
+    }
+    return spawn("claude", args, { stdio: ["pipe", "pipe", "pipe"] });
+}
+
 function killChildTree(child: ChildProcess) {
     if (!child.pid) return;
     if (process.platform === "win32") {
@@ -706,7 +851,77 @@ function killChildTree(child: ChildProcess) {
     }
 }
 
-async function runClaude(prompt: string, takeNewUserComments: () => Promise<string[]>): Promise<{ timedOut: boolean; exitCode: number | undefined }> {
+const DEFAULT_MODEL_PROBE_TIMEOUT = timeInMinute;
+
+let defaultModelProbe: Promise<void> | undefined = undefined;
+
+// Kicked off from status queries so the ticket page can show what "default" resolves to. The outcome (success or failure) is cached for the process lifetime — the default doesn't change while we run, and retrying a missing claude install on every 5s status poll would spawn endlessly.
+export function ensureDefaultModelProbed(): void {
+    if (defaultClaudeModel || defaultModelProbe) return;
+    defaultModelProbe = (async () => {
+        try {
+            defaultClaudeModel = await probeDefaultClaudeModel();
+            console.log(green(`AutoFixer resolved the default claude model: ${defaultClaudeModel}`));
+        } catch (e) {
+            console.error(`AutoFixer failed to resolve the default claude model (will not retry):`, (e as Error).stack ?? e);
+        }
+    })();
+}
+
+// The stream-json init event names the session's model and arrives before the first API response, so killing the process the moment it appears makes this a near-free query for what --model defaults to.
+async function probeDefaultClaudeModel(): Promise<string> {
+    let child = spawnClaudeProcess([
+        "-p",
+        "--output-format", "stream-json",
+        "--input-format", "stream-json",
+        "--verbose",
+        "--strict-mcp-config",
+    ]);
+    return await new Promise<string>((resolve, reject) => {
+        let settled = false;
+        function finish(err: Error | undefined, model?: string) {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            killChildTree(child);
+            if (err) {
+                reject(err);
+            } else {
+                resolve(model!);
+            }
+        }
+        let timeout = setTimeout(() => finish(new Error(`Timed out waiting for the claude init event`)), DEFAULT_MODEL_PROBE_TIMEOUT);
+        let pending = "";
+        child.stdout!.on("data", (chunk: Buffer) => {
+            pending += chunk.toString("utf8");
+            let lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            for (let line of lines) {
+                let event: any;
+                try {
+                    event = JSON.parse(line);
+                } catch {
+                    continue;
+                }
+                if (event?.type === "system" && event.subtype === "init" && typeof event.model === "string") {
+                    finish(undefined, event.model);
+                }
+            }
+        });
+        child.on("error", e => finish(e as Error));
+        child.on("exit", code => finish(new Error(`claude exited (code ${code}) before emitting its init event`)));
+        try {
+            child.stdin!.write(JSON.stringify({
+                type: "user",
+                message: { role: "user", content: [{ type: "text", text: "Reply with OK." }] },
+            }) + "\n");
+        } catch (e) {
+            finish(e as Error);
+        }
+    });
+}
+
+async function runClaude(prompt: string, model: string | undefined, takeNewUserComments: () => Promise<string[]>): Promise<{ timedOut: boolean; exitCode: number | undefined }> {
     let mcpConfigPath = path.join(os.tmpdir(), `autofixer-mcp-${process.pid}.json`);
     fs.writeFileSync(mcpConfigPath, JSON.stringify({
         mcpServers: {
@@ -727,16 +942,13 @@ async function runClaude(prompt: string, takeNewUserComments: () => Promise<stri
         "--strict-mcp-config",
         "--allowedTools", CLAUDE_ALLOWED_TOOLS.join(","),
     ];
-
-    let child: ChildProcess;
-    if (process.platform === "win32") {
-        // claude is a .cmd shim on Windows, which spawn can only run through a shell. The shell does no escaping, so we quote the command line ourselves.
-        let commandLine = ["claude", ...args].map(quoteArgForShell).join(" ");
-        child = spawn(commandLine, { shell: true, stdio: ["pipe", "pipe", "pipe"] });
-    } else {
-        child = spawn("claude", args, { stdio: ["pipe", "pipe", "pipe"] });
+    if (model) {
+        args.push("--model", model);
     }
 
+    let child = spawnClaudeProcess(args);
+    currentClaudeChild = child;
+
     function writeUserMessage(text: string) {
         if (child.exitCode !== null || child.killed) return;
         try {
@@ -753,6 +965,16 @@ async function runClaude(prompt: string, takeNewUserComments: () => Promise<stri
     // After each turn: forward any user comments added to the ticket during the turn as a new user message, otherwise end the session.
     claudeTurnEndedHandler = () => {
         void (async () => {
+            if (currentTicketId && stopRequestedTicketIds.has(currentTicketId)) {
+                currentRunStopped = true;
+                console.log(green(`Stop requested for ticket ${currentTicketId}; ending the claude session at turn end`));
+                try {
+                    child.stdin!.end();
+                } catch {
+                    // Process already exited.
+                }
+                return;
+            }
             let newComments: string[] = [];
             try {
                 newComments = await takeNewUserComments();
@@ -812,6 +1034,7 @@ async function runClaude(prompt: string, takeNewUserComments: () => Promise<stri
         child.on("exit", code => resolve(code ?? undefined));
     });
     claudeTurnEndedHandler = undefined;
+    currentClaudeChild = undefined;
     clearTimeout(timeout);
     return { timedOut, exitCode };
 }
@@ -820,17 +1043,21 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
     console.log(green(`AutoFixer starting investigation of ticket ${ticket.id}: ${ticket.title}`));
     let service = await ticketService();
 
+    let model = ticketModelOverrides.get(ticket.id);
     currentTicketId = ticket.id;
     currentTicketTitle = ticket.title;
     currentTicketStartTime = Date.now();
+    currentRunRequestedModel = model;
+    currentRunResolvedModel = undefined;
     runTokens = emptyTokens();
     pendingStreamToolCalls.clear();
     stateChangedDuringRun = false;
     patchAddedDuringRun = false;
+    currentRunStopped = false;
     try {
         await addTicketComment(ticket.id, {
             kind: "text",
-            text: `Starting automated investigation (timeout ${formatTime(INVESTIGATION_TIMEOUT)}).`,
+            text: `Starting automated investigation (model: ${model ?? defaultClaudeModel ?? "default"}, timeout ${formatTime(INVESTIGATION_TIMEOUT)}).`,
         });
 
         // Any text comment that appears on the ticket during the run and wasn't written by us is a user comment — forwarded into the claude session between turns.
@@ -849,7 +1076,16 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
             return newComments.map(c => c.text);
         }
 
-        let { timedOut, exitCode } = await runClaude(buildPrompt(ticket), takeNewUserComments);
+        let { timedOut, exitCode } = await runClaude(buildPrompt(ticket), model, takeNewUserComments);
+
+        if (currentRunStopped) {
+            console.log(green(`AutoFixer investigation of ticket ${ticket.id} was stopped by the user`));
+            await addTicketComment(ticket.id, {
+                kind: "text",
+                text: `Automated investigation stopped by the user (the in-flight step was allowed to finish). The ticket state was left unchanged.`,
+            });
+            return;
+        }
 
         if (timedOut) {
             await addTicketComment(ticket.id, {
@@ -880,15 +1116,25 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
         }
     } finally {
         addTokens(totalTokens, runTokens);
+        stopRequestedTicketIds.delete(ticket.id);
+        ticketModelOverrides.delete(ticket.id);
+        currentRunRequestedModel = undefined;
+        currentRunResolvedModel = undefined;
         currentTicketId = undefined;
         currentTicketTitle = undefined;
     }
 }
 
-export async function runAutoFixer(): Promise<void> {
-    setAutoFixerHandlers({ onTicketsChanged, applyPatch });
+// Shared by the dedicated autofixer process and by nodes that only run manual investigations (triggered from the ticket page).
+const ensureAutoFixerBase = lazy(async () => {
+    setAutoFixerHandlers({ onTicketsChanged, applyPatches });
     SocketFunction.expose(AutoFixerControllerBase);
     await startToolServer();
+});
+
+export async function runAutoFixer(): Promise<void> {
+    autoProcessingEnabled = true;
+    await ensureAutoFixerBase();
 
     void runInfinitePollCallAtStart(REGISTER_POLL_INTERVAL, registerWithTicketService);
     void runInfinitePollCallAtStart(ALL_TICKETS_POLL_INTERVAL, pollAllTickets);

package/src/diagnostics/logs/errorTickets/autoFixerController.ts

@@ -4,7 +4,7 @@ import { assertIsManagementUser } from "../../managementPages";
 // The AutoFixerController is registered in every process (so ticket code can reference it), but only does anything in the autofixer process, which installs handlers via setAutoFixerHandlers and exposes the controller.
 export type AutoFixerHandlers = {
     onTicketsChanged(ticketIds: string[]): void;
-    applyPatch(ticketId: string, commentId: string): Promise<void>;
+    applyPatches(ticketId: string, commentIds: string[]): Promise<void>;
 };
 
 let handlers: AutoFixerHandlers | undefined = undefined;
@@ -17,11 +17,11 @@ class AutoFixerController {
         handlers?.onTicketsChanged(ticketIds);
     }
 
-    public async applyPatch(ticketId: string, commentId: string) {
+    public async applyPatches(ticketId: string, commentIds: string[]) {
         if (!handlers) {
             throw new Error(`AutoFixer is not running on this node, so patches cannot be applied here`);
         }
-        await handlers.applyPatch(ticketId, commentId);
+        await handlers.applyPatches(ticketId, commentIds);
     }
 }
 
@@ -30,7 +30,7 @@ export const AutoFixerControllerBase = SocketFunction.register(
     new AutoFixerController(),
     () => ({
         onTicketsChanged: {},
-        applyPatch: {},
+        applyPatches: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],

package/src/diagnostics/logs/errorTickets/ticketTypes.ts

@@ -36,6 +36,23 @@ export type TicketComment = {
     toolDurationMs?: number;
 };
 
+// Model aliases accepted by the claude CLI's --model flag. Aliases (not full model IDs) so they keep resolving to the latest model of each tier as the CLI updates.
+export const AUTOFIXER_MODEL_OPTIONS = ["opus", "sonnet", "haiku"];
+
+// Status of the autofixer machinery on a single node (the node that answered the status query).
+export type AutoFixerRunStatus = {
+    runningTicketId?: string;
+    runningTicketTitle?: string;
+    runStartTime?: number;
+    // The actual model of the current run (from claude's init event), falling back to the requested model until the run reports it.
+    runningModel?: string;
+    // What claude resolves when no --model is passed. Undefined until the probe (or a default-model run) has resolved it.
+    defaultModel?: string;
+    // A stop was requested for the running ticket — the current step finishes and then the run ends.
+    stopRequested?: boolean;
+    queuedTicketIds: string[];
+};
+
 export type Ticket = {
     id: string;
     title: string;