querysub 0.497.0 → 0.499.0

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

@@ -0,0 +1,634 @@
+import * as http from "http";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { spawn, ChildProcess } from "child_process";
+import { nextId, timeInHour, timeInMinute } from "socket-function/src/misc";
+import { runInfinitePollCallAtStart, runInSerial } from "socket-function/src/batching";
+import { formatTime } from "socket-function/src/formatting/format";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { isPublic } from "../../../config";
+import { timeoutToUndefinedSilent } from "../../../errors";
+import { getAllNodeIds } from "../../../-f-node-discovery/NodeDiscovery";
+import { getControllerNodeId, NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
+import { MCPIndexedLogs } from "../IndexedLogs/MCPIndexedLogs";
+import { AutoFixerControllerBase, setAutoFixerHandlers } from "./autoFixerController";
+import { TicketServiceBase } from "./tickets";
+import { Ticket, TicketComment, TicketPatchFile, TicketState } from "./ticketTypes";
+
+const INVESTIGATION_TIMEOUT = timeInMinute * 20;
+// "Files modified" check on tickets we already know are open.
+const OPEN_TICKET_POLL_INTERVAL = timeInMinute * 30;
+// Full listing, to discover tickets we've never seen (in case a change notification was missed).
+const ALL_TICKETS_POLL_INTERVAL = timeInHour;
+// Re-registering is cheap and the service loses its watcher set when it restarts.
+const REGISTER_POLL_INTERVAL = timeInMinute * 5;
+const NODE_INFO_TIMEOUT_MS = 5000;
+const TOOL_SERVER_PORT = 4517;
+const MAX_TOOL_OUTPUT_STORED = 20_000;
+const MAX_PRIOR_COMMENTS_PROMPT_CHARS = 30_000;
+const AUTOFIXER_AUTHOR = "autofixer";
+
+const PROTOCOL_VERSION = "2025-03-26";
+const SERVER_INFO = { name: "querysub-autofixer", version: "0.1.0" };
+
+const CLAUDE_ALLOWED_TOOLS = [
+    "Read",
+    "Glob",
+    "Grep",
+    "mcp__autofixer__searchLogs",
+    "mcp__autofixer__listNodes",
+    "mcp__autofixer__addComment",
+    "mcp__autofixer__addPatch",
+    "mcp__autofixer__setTicketState",
+];
+
+async function ticketService() {
+    let controllerNodeId = await getControllerNodeId(TicketServiceBase, !isPublic());
+    if (!controllerNodeId) {
+        throw new Error(`Could not find node exposing controller TicketServiceBase. Is \`yarn error-watch\` running?`);
+    }
+    return TicketServiceBase.nodes[controllerNodeId];
+}
+
+// The ticket the current claude run is bound to. Runs are serialized, so a module-level value is safe.
+let currentTicketId: string | undefined = undefined;
+// Set when the AI calls setTicketState during a run, so we know not to auto-transition afterwards.
+let stateChangedDuringRun = false;
+// Set when the AI adds a patch during a run.
+let patchAddedDuringRun = false;
+
+let knownOpenTicketIds = new Set<string>();
+
+const processTicket = runInSerial(async (ticketId: string): Promise<void> => {
+    try {
+        let service = await ticketService();
+        let ticket = await service.getTicket(ticketId);
+        if (!ticket) {
+            knownOpenTicketIds.delete(ticketId);
+            return;
+        }
+        if (ticket.state !== "investigation") {
+            knownOpenTicketIds.delete(ticketId);
+            return;
+        }
+        knownOpenTicketIds.add(ticketId);
+        await runInvestigation(ticket);
+    } catch (e) {
+        console.error(`AutoFixer failed to process ticket ${ticketId}:`, (e as Error).stack ?? e);
+    }
+});
+
+function queueTicket(ticketId: string) {
+    void processTicket(ticketId);
+}
+
+async function pollOpenTickets() {
+    for (let ticketId of Array.from(knownOpenTicketIds)) {
+        queueTicket(ticketId);
+    }
+}
+
+async function pollAllTickets() {
+    try {
+        let service = await ticketService();
+        let tickets = await service.getTickets();
+        for (let ticket of tickets) {
+            if (ticket.state === "investigation") {
+                knownOpenTicketIds.add(ticket.id);
+                queueTicket(ticket.id);
+            }
+        }
+    } catch (e) {
+        console.error(`AutoFixer failed to poll tickets:`, (e as Error).stack ?? e);
+    }
+}
+
+function onTicketsChanged(ticketIds: string[]) {
+    console.log(`AutoFixer received ticket change notification: ${ticketIds.join(", ")}`);
+    for (let ticketId of ticketIds) {
+        queueTicket(ticketId);
+    }
+}
+
+async function registerWithTicketService() {
+    try {
+        let service = await ticketService();
+        await service.registerAutoFixerSERVICE();
+    } catch (e) {
+        console.error(`AutoFixer failed to register with ticket service (will retry):`, (e as Error).stack ?? e);
+    }
+}
+
+async function applyPatch(ticketId: string, commentId: 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}`);
+    }
+
+    // Validate everything before writing anything, so a patch is all-or-nothing.
+    let writes: { fullPath: string; newContents: string }[] = [];
+    for (let patchFile of comment.patchFiles) {
+        let fullPath = path.resolve(process.cwd(), patchFile.file);
+        if (!patchFile.oldText) {
+            if (fs.existsSync(fullPath) && fs.readFileSync(fullPath, "utf8").trim()) {
+                throw new Error(`Patch wants to create ${patchFile.file}, but it already exists and is not empty`);
+            }
+            writes.push({ fullPath, newContents: patchFile.newText });
+            continue;
+        }
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Patch targets ${patchFile.file}, which does not exist (cwd is ${process.cwd()})`);
+        }
+        let contents = fs.readFileSync(fullPath, "utf8");
+        let index = contents.indexOf(patchFile.oldText);
+        if (index === -1) {
+            throw new Error(`Patch oldText not found in ${patchFile.file}. The file may have changed since the patch was created.`);
+        }
+        let newContents = contents.slice(0, index) + patchFile.newText + contents.slice(index + patchFile.oldText.length);
+        writes.push({ fullPath, newContents });
+    }
+    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}`);
+    }
+}
+
+async function addTicketComment(ticketId: string, comment: Omit<TicketComment, "id" | "time" | "author">) {
+    let service = await ticketService();
+    await service.addComment(ticketId, {
+        id: nextId(),
+        time: Date.now(),
+        author: AUTOFIXER_AUTHOR,
+        ...comment,
+    });
+}
+
+// ==================== MCP tool server (what the claude process talks to) ====================
+
+const TOOL_DEFS = [
+    {
+        name: "searchLogs",
+        description: `Search the indexed production logs (across log/info/warn/error) on one machine for rows matching a query, projected to the requested columns.
+
+Returns { allColumns, results, files: { <loggerName>: {total, scanned} } }. If a \`limitHit\` field is present, results were truncated by the limit.
+
+Query syntax (case-insensitive substring match by default):
+  | — OR. \`cat|dog\` matches if either substring is present.
+  & — AND. \`error&timeout\` matches if both are present (in any order, anywhere).
+  * — ordered wildcard. \`cat*ate\` matches "cat ate my bird" but NOT "cate".
+  No negation is supported.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                machine: { type: "string", description: "machineId, or \"local\" for the machine running this server" },
+                startTime: { type: ["number", "string"], description: "epoch ms or any string Date can parse (no-tz strings are local time)" },
+                endTime: { type: ["number", "string"], description: "epoch ms or any string Date can parse; must be at least 1 minute in the past" },
+                direction: { type: "string", enum: ["fromStart", "fromEnd"] },
+                columns: { type: "array", items: { type: "string" }, description: "Which fields to project onto each row. Use [] to get just metadata." },
+                limit: { type: "number", default: 100 },
+                logTypes: { type: "string", description: "Optional pipe-separated list restricting which log streams to scan. Allowed values: log, info, warn, error." },
+            },
+            required: ["query", "machine", "startTime", "endTime", "direction", "columns"],
+        },
+    },
+    {
+        name: "listNodes",
+        description: `List every node in the Querysub cluster, with each node's process entry point. Returns an array of { nodeId, entryPoint }.`,
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "addComment",
+        description: `Add a text comment to the ticket you are investigating. Use this to record your diagnosis before proposing any fixes.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "addPatch",
+        description: `Propose a code patch on the ticket. The patch is NOT applied automatically — a human reviews it and applies or rejects it. Each file entry replaces the first exact occurrence of oldText with newText. oldText must be copied exactly from the current file contents and should be unique within the file. An empty oldText creates a new file with newText as its contents.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "Explanation of what the patch does and why" },
+                files: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            file: { type: "string", description: "Path relative to the repository root" },
+                            oldText: { type: "string" },
+                            newText: { type: "string" },
+                        },
+                        required: ["file", "oldText", "newText"],
+                    },
+                },
+            },
+            required: ["text", "files"],
+        },
+    },
+    {
+        name: "setTicketState",
+        description: `Set the state of the ticket you are investigating. Use "code-change" once you have proposed patches, or "not-a-bug" if the error should simply be ignored.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                state: { type: "string", enum: ["code-change", "not-a-bug"] },
+            },
+            required: ["state"],
+        },
+    },
+];
+
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id?: number | string | null;
+    method: string;
+    params?: unknown;
+};
+
+type JsonRpcResponse = {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: { code: number; message: string; data?: unknown };
+};
+
+function errorResponse(id: number | string | null, code: number, message: string): JsonRpcResponse {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+async function getNodeInfos() {
+    let nodes = await getAllNodeIds();
+    return Promise.all(
+        nodes.map(async nodeId => {
+            let metadata = await timeoutToUndefinedSilent(NODE_INFO_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint };
+        }),
+    );
+}
+
+let mcpLogs = new MCPIndexedLogs();
+
+async function callTool(toolName: string, args: Record<string, unknown>): Promise<unknown> {
+    let ticketId = currentTicketId;
+    if (!ticketId) {
+        throw new Error(`No ticket is currently being investigated`);
+    }
+
+    if (toolName === "addComment") {
+        let text = String(args.text ?? "").trim();
+        if (!text) {
+            throw new Error(`addComment requires non-empty text`);
+        }
+        await addTicketComment(ticketId, { kind: "text", text });
+        return { ok: true };
+    }
+    if (toolName === "addPatch") {
+        let text = String(args.text ?? "").trim();
+        let files = args.files as TicketPatchFile[] | undefined;
+        if (!files || !Array.isArray(files) || files.length === 0) {
+            throw new Error(`addPatch requires at least one file entry`);
+        }
+        for (let file of files) {
+            if (!file.file || typeof file.newText !== "string" || typeof file.oldText !== "string") {
+                throw new Error(`Each patch file entry requires file, oldText, and newText`);
+            }
+        }
+        await addTicketComment(ticketId, {
+            kind: "patch",
+            text,
+            patchFiles: files,
+            patchStatus: "pending",
+        });
+        patchAddedDuringRun = true;
+        return { ok: true };
+    }
+    // Remaining tools don't create a visible comment of their own, so record the call and its output chronologically in the ticket.
+    let startTime = Date.now();
+    let result: unknown;
+    let errorText: string | undefined = undefined;
+    try {
+        if (toolName === "searchLogs") {
+            result = await mcpLogs.search(args as Parameters<MCPIndexedLogs["search"]>[0]);
+        } else if (toolName === "listNodes") {
+            result = await getNodeInfos();
+        } else if (toolName === "setTicketState") {
+            let state = String(args.state ?? "") as TicketState;
+            if (state !== "code-change" && state !== "not-a-bug") {
+                throw new Error(`setTicketState only allows "code-change" or "not-a-bug"`);
+            }
+            let service = await ticketService();
+            await service.setTicketState(ticketId, state);
+            stateChangedDuringRun = true;
+            result = { ok: true };
+        } else {
+            throw new Error(`Unknown tool ${toolName}`);
+        }
+    } catch (e) {
+        errorText = (e as Error).stack ?? String(e);
+    }
+    let outputText = errorText !== undefined && `ERROR: ${errorText}` || JSON.stringify(result);
+    if (outputText.length > MAX_TOOL_OUTPUT_STORED) {
+        outputText = outputText.slice(0, MAX_TOOL_OUTPUT_STORED) + `... (truncated, ${outputText.length} chars total)`;
+    }
+    try {
+        await addTicketComment(ticketId, {
+            kind: "tool-call",
+            text: "",
+            toolName,
+            toolInput: JSON.stringify(args),
+            toolOutput: outputText,
+            toolDurationMs: Date.now() - startTime,
+        });
+    } catch (e) {
+        console.error(`Failed to record tool call in ticket ${ticketId}:`, (e as Error).stack ?? e);
+    }
+    if (errorText !== undefined) {
+        throw new Error(errorText);
+    }
+    return result;
+}
+
+async function dispatch(method: string, params: unknown): Promise<unknown> {
+    if (method === "initialize") {
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: SERVER_INFO,
+        };
+    }
+    if (method === "tools/list") {
+        return { tools: TOOL_DEFS };
+    }
+    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) }],
+        };
+    }
+    if (method === "ping") {
+        return {};
+    }
+    if (method.startsWith("notifications/")) {
+        return {};
+    }
+    throw new Error(`Unknown method ${method}`);
+}
+
+async function handleJsonRpc(body: string): Promise<JsonRpcResponse | undefined> {
+    let req: JsonRpcRequest;
+    try {
+        req = JSON.parse(body);
+    } catch (e) {
+        return errorResponse(null, -32700, `Parse error: ${(e as Error).message}`);
+    }
+    if (req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+        return errorResponse(req.id ?? null, -32600, `Invalid request`);
+    }
+    let isNotification = req.id === undefined;
+    try {
+        let result = await dispatch(req.method, req.params);
+        if (isNotification) return undefined;
+        return { jsonrpc: "2.0", id: req.id ?? null, result };
+    } catch (e) {
+        console.error(`AutoFixer tool server error in ${req.method}:`, (e as Error).stack ?? e);
+        if (isNotification) return undefined;
+        return errorResponse(req.id ?? null, -32000, (e as Error).message ?? String(e));
+    }
+}
+
+async function startToolServer(): Promise<void> {
+    let server = http.createServer((req, res) => {
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            res.end();
+            return;
+        }
+        let chunks: Buffer[] = [];
+        req.on("data", c => chunks.push(c));
+        req.on("end", async () => {
+            let body = Buffer.concat(chunks).toString("utf8");
+            let response = await handleJsonRpc(body);
+            if (response === undefined) {
+                res.statusCode = 204;
+                res.end();
+                return;
+            }
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify(response));
+        });
+        req.on("error", e => {
+            console.error(`AutoFixer tool server request error:`, (e as Error).stack ?? e);
+            res.statusCode = 500;
+            res.end();
+        });
+    });
+    await new Promise<void>((resolve, reject) => {
+        server.once("error", reject);
+        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}`);
+}
+
+// ==================== Investigation runs ====================
+
+function buildPrompt(ticket: Ticket): string {
+    let priorComments: string[] = [];
+    for (let comment of ticket.comments) {
+        let time = new Date(comment.time).toISOString();
+        if (comment.kind === "text") {
+            priorComments.push(`[${time}] ${comment.author}: ${comment.text}`);
+        } else if (comment.kind === "patch") {
+            let fileList = (comment.patchFiles ?? []).map(f => f.file).join(", ");
+            priorComments.push(`[${time}] ${comment.author} proposed a patch (status: ${comment.patchStatus}) touching ${fileList}: ${comment.text}`);
+        } else if (comment.kind === "tool-call") {
+            priorComments.push(`[${time}] tool ${comment.toolName}(${comment.toolInput ?? ""}) => ${(comment.toolOutput ?? "").slice(0, 500)}`);
+        }
+    }
+    let priorCommentsText = priorComments.join("\n");
+    if (priorCommentsText.length > MAX_PRIOR_COMMENTS_PROMPT_CHARS) {
+        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.
+
+The repository is at ${process.cwd()}. Use Read/Glob/Grep to read the code, and the mcp__autofixer__searchLogs / mcp__autofixer__listNodes tools to search the production logs.
+
+Work in two phases:
+
+PHASE 1 — INVESTIGATION. Figure out what is wrong. Do log searches and read the code. Do NOT think about the fix yet — focus only on identifying the problem. Conclude this phase by calling mcp__autofixer__addComment with your diagnosis. The diagnosis must be one of:
+  - "This code is broken here, and this is why it is broken" (name the file and the mechanism), or
+  - "This error is not important and we should ignore it, and this is why" (e.g. a remote TCP client disconnecting is not an error — remote clients are supposed to disappear).
+
+PHASE 2 — FIX. Only after you have added your diagnosis comment, decide on the fix and propose it with mcp__autofixer__addPatch. The kinds of fixes are:
+  1. Downgrading logging: when the "error" is not actually an error, patch the logging call site to downgrade it from an error to a warning or a plain log, so it stops being reported.
+  2. Actually fixing the broken code.
+  3. Gathering more information: if you could NOT determine the root cause from the available logs, propose patches that ADD logging statements to the relevant code paths so the next investigation has the information it needs.
+Each patch file entry is { file, oldText, newText }: oldText must be copied exactly from the current file contents and should be unique within the file; it is replaced with newText. An empty oldText creates a new file. Keep patches minimal and follow the style of the surrounding code.
+
+When you are done, call mcp__autofixer__setTicketState with "code-change" if you proposed patches, or "not-a-bug" if the error should simply be ignored without any code change. Do NOT edit files directly — only propose changes through mcp__autofixer__addPatch.
+
+==== TICKET ====
+Title: ${ticket.title}
+Created: ${new Date(ticket.createdTime).toISOString()}
+${ticket.suppressionPattern && `Matched suppression pattern: ${ticket.suppressionPattern}\n` || ""}
+==== ERROR LOG ENTRY (full JSON) ====
+${JSON.stringify(ticket.errorDatum, undefined, 2)}
+
+==== COMMENTS SO FAR (chronological) ====
+${priorCommentsText || "(none)"}
+`;
+}
+
+function quoteArgForShell(arg: string): string {
+    if (!/[\s"^&|<>()%!;'$`\\]/.test(arg)) return arg;
+    return `"${arg.replace(/"/g, "\\\"")}"`;
+}
+
+function killChildTree(child: ChildProcess) {
+    if (!child.pid) return;
+    if (process.platform === "win32") {
+        spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"]);
+    } else {
+        child.kill("SIGKILL");
+    }
+}
+
+async function runClaude(prompt: string): Promise<{ timedOut: boolean; exitCode: number | undefined }> {
+    let mcpConfigPath = path.join(os.tmpdir(), `autofixer-mcp-${process.pid}.json`);
+    fs.writeFileSync(mcpConfigPath, JSON.stringify({
+        mcpServers: {
+            autofixer: {
+                type: "http",
+                url: `http://127.0.0.1:${TOOL_SERVER_PORT}/`,
+            },
+        },
+    }));
+
+    let args = [
+        "-p",
+        "--mcp-config", mcpConfigPath,
+        "--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"] });
+    }
+
+    child.stdin!.write(prompt);
+    child.stdin!.end();
+
+    function forwardLines(stream: NodeJS.ReadableStream, prefix: string) {
+        let pending = "";
+        stream.on("data", (chunk: Buffer) => {
+            pending += chunk.toString("utf8");
+            let lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            for (let line of lines) {
+                console.log(`${prefix} ${line}`);
+            }
+        });
+        stream.on("end", () => {
+            if (pending) {
+                console.log(`${prefix} ${pending}`);
+            }
+        });
+    }
+    forwardLines(child.stdout!, "[claude]");
+    forwardLines(child.stderr!, "[claude:err]");
+
+    let timedOut = false;
+    let timeout = setTimeout(() => {
+        timedOut = true;
+        console.error(`Claude investigation exceeded ${formatTime(INVESTIGATION_TIMEOUT)}, killing it`);
+        killChildTree(child);
+    }, INVESTIGATION_TIMEOUT);
+
+    let exitCode = await new Promise<number | undefined>(resolve => {
+        child.on("error", e => {
+            console.error(`Failed to spawn claude:`, (e as Error).stack ?? e);
+            resolve(undefined);
+        });
+        child.on("exit", code => resolve(code ?? undefined));
+    });
+    clearTimeout(timeout);
+    return { timedOut, exitCode };
+}
+
+async function runInvestigation(ticket: Ticket): Promise<void> {
+    console.log(`AutoFixer starting investigation of ticket ${ticket.id}: ${ticket.title}`);
+    let service = await ticketService();
+
+    currentTicketId = ticket.id;
+    stateChangedDuringRun = false;
+    patchAddedDuringRun = false;
+    try {
+        await addTicketComment(ticket.id, {
+            kind: "text",
+            text: `Starting automated investigation (timeout ${formatTime(INVESTIGATION_TIMEOUT)}).`,
+        });
+
+        let { timedOut, exitCode } = await runClaude(buildPrompt(ticket));
+
+        if (timedOut) {
+            await addTicketComment(ticket.id, {
+                kind: "text",
+                text: `Automated investigation timed out after ${formatTime(INVESTIGATION_TIMEOUT)} and was stopped.`,
+            });
+            await service.setTicketState(ticket.id, "timed-out");
+            return;
+        }
+
+        let updated = await service.getTicket(ticket.id);
+        if (!updated || updated.state !== "investigation" || stateChangedDuringRun) {
+            console.log(`AutoFixer finished investigation of ticket ${ticket.id} (state: ${updated?.state})`);
+            return;
+        }
+        if (patchAddedDuringRun) {
+            await addTicketComment(ticket.id, {
+                kind: "text",
+                text: `Automated investigation proposed patches but did not set the ticket state; moving the ticket to code-change.`,
+            });
+            await service.setTicketState(ticket.id, "code-change");
+        } else {
+            await addTicketComment(ticket.id, {
+                kind: "text",
+                text: `Automated investigation ended (claude exit code ${exitCode}) without a diagnosis, patches, or a state change. Marking the ticket timed-out so it is not retried automatically — set it back to investigation to retry.`,
+            });
+            await service.setTicketState(ticket.id, "timed-out");
+        }
+    } finally {
+        currentTicketId = undefined;
+    }
+}
+
+export async function runAutoFixer(): Promise<void> {
+    setAutoFixerHandlers({ onTicketsChanged, applyPatch });
+    SocketFunction.expose(AutoFixerControllerBase);
+    await startToolServer();
+
+    void runInfinitePollCallAtStart(REGISTER_POLL_INTERVAL, registerWithTicketService);
+    void runInfinitePollCallAtStart(ALL_TICKETS_POLL_INTERVAL, pollAllTickets);
+    void runInfinitePollCallAtStart(OPEN_TICKET_POLL_INTERVAL, pollOpenTickets);
+
+    console.log(`AutoFixer running. Watching for tickets in the investigation state (cwd: ${process.cwd()}).`);
+}

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

@@ -0,0 +1,41 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+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>;
+};
+
+let handlers: AutoFixerHandlers | undefined = undefined;
+export function setAutoFixerHandlers(newHandlers: AutoFixerHandlers) {
+    handlers = newHandlers;
+}
+
+class AutoFixerController {
+    public async onTicketsChanged(ticketIds: string[]) {
+        handlers?.onTicketsChanged(ticketIds);
+    }
+
+    public async applyPatch(ticketId: string, commentId: string) {
+        if (!handlers) {
+            throw new Error(`AutoFixer is not running on this node, so patches cannot be applied here`);
+        }
+        await handlers.applyPatch(ticketId, commentId);
+    }
+}
+
+export const AutoFixerControllerBase = SocketFunction.register(
+    "AutoFixerController-019c9cae-8333-7708-a4e7-500f5fc23182",
+    new AutoFixerController(),
+    () => ({
+        onTicketsChanged: {},
+        applyPatch: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);