querysub 0.500.0 → 0.501.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.500.0",
+  "version": "0.501.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "mc": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts --cwd D:/repos/qs-cyoa/",
     "mcp2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts",
     "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/",
-    "autofixer": "yarn typenode ./src/diagnostics/logs/errorTickets/autoFixerEntry.ts",
+    "autofix": "yarn typenode ./src/diagnostics/logs/errorTickets/autoFixerEntry.ts",
     "ssh-a-claude": "ssh root@a.querysubtest.com"
   },
   "bin": {
@@ -49,7 +49,7 @@
     "audit-imports": "./bin/audit-imports.js",
     "audit-disk-values": "./bin/audit-disk-values.js",
     "mcp-indexed-logs": "./bin/mcp-indexed-logs.js",
-    "autofixer": "./bin/autofixer.js"
+    "autofix": "./bin/autofix.js"
   },
   "dependencies": {
     "@types/fs-ext": "^2.0.3",

package/src/5-diagnostics/Table.tsx

@@ -216,7 +216,7 @@ function renderTrimmed(config: {
 
     return {
         outerAttributes: {
-            class: css.opacity(0.5, "hover").button,
+            class: css.opacity(0.5, "hover"),
             onClick: () => {
                 let close = showModal({
                     content: <FullscreenModal onCancel={() => {

package/src/diagnostics/logs/errorNotifications2/ErrorNotificationPage.tsx

@@ -18,19 +18,45 @@ import { startTimeParam, endTimeParam } from "../TimeRangeSelector";
 import { timeInHour } from "socket-function/src/misc";
 import { ATag, URLOverride } from "../../../library-components/ATag";
 import { Button } from "../../../library-components/Button";
-import { createTicketForError, ticketIdURL } from "../errorTickets/TicketPage";
+import { createTicketForError, findTicketForPattern, goToTicket } from "../errorTickets/TicketPage";
 
 function openTicket(datum: LogDatum, pattern: string | undefined) {
+    // datum may be synchronized state (props/manager state), which cannot be read inside the async callback — snapshot it while we're still in the synchronized event context.
+    let datumSnapshot: LogDatum = JSON.parse(JSON.stringify(datum));
     Querysub.onCommitFinished(async () => {
-        let id = await createTicketForError(datum, pattern);
+        let id = await createTicketForError(datumSnapshot, pattern);
         Querysub.commit(() => {
-            showingManagementURL.value = true;
-            managementPageURL.value = "TicketPage";
-            ticketIdURL.value = id;
+            goToTicket(id);
         });
     });
 }
 
+// Renders "Ticket" (create + navigate) or, when a ticket already exists for this suppression pattern, "Go to Ticket" — duplicate tickets for the same pattern are pointless.
+function TicketButton(props: {
+    getDatum: () => LogDatum;
+    pattern: string | undefined;
+    stopClickPropagation?: boolean;
+}) {
+    let existingTicket = findTicketForPattern(props.pattern);
+    return <Button
+        hue={210}
+        onClick={(e) => {
+            if (props.stopClickPropagation) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+            if (existingTicket) {
+                goToTicket(existingTicket.id);
+            } else {
+                openTicket(props.getDatum(), props.pattern);
+            }
+        }}
+    >
+        {existingTicket && `Go to Ticket (${existingTicket.state})` || "Ticket"}
+    </Button>;
+}
+qreact.inline(TicketButton);
+
 let getMatcher = cacheLimited(100, (pattern: string) =>
     createMatchesPattern(Buffer.from(pattern), false)
 );
@@ -166,18 +192,11 @@ export class LogDatumRenderer extends qreact.Component<{
                     >
                         Not a Bug
                     </Button>
-                    <Button
-                        hue={210}
-                        onClick={(e) => {
-                            if (this.props.inlineMode) {
-                                e.preventDefault();
-                                e.stopPropagation();
-                            }
-                            openTicket(datum, timedOutMatches[0].pattern);
-                        }}
-                    >
-                        Ticket
-                    </Button>
+                    <TicketButton
+                        getDatum={() => datum}
+                        pattern={timedOutMatches[0].pattern}
+                        stopClickPropagation={this.props.inlineMode}
+                    />
                 </div>
             )}
 
@@ -436,19 +455,21 @@ class SuppressionItem extends qreact.Component<{
                 >
                     Not a Bug
                 </Button>
-                <Button
-                    hue={210}
-                    onClick={() => {
-                        let datum = this.props.matchData?.examples[0] || {
+                <TicketButton
+                    getDatum={() => {
+                        let example = this.props.matchData?.examples[0];
+                        if (example) return example;
+                        // No example recorded for this suppression — find any live error matching the pattern, so the ticket stores a real, full log entry instead of a synthetic stub.
+                        let matcher = getMatcher(suppression.pattern);
+                        let fallback = this.manager.state.unmatchedErrors.find(e => matcher(Buffer.from(JSON.stringify(e))));
+                        return fallback || {
                             time: Date.now(),
                             __LOG_TYPE: "error",
                             param0: suppression.pattern,
                         };
-                        openTicket(datum, suppression.pattern);
                     }}
-                >
-                    Ticket
-                </Button>
+                    pattern={suppression.pattern}
+                />
                 <Button
                     hue={30}
                     onClick={() => {

package/src/diagnostics/logs/errorNotifications2/ErrorWarning.tsx

@@ -1,34 +1,74 @@
+import preact from "preact";
 import { qreact } from "../../../4-dom/qreact";
-import { t } from "../../../2-proxy/schema2";
 import { css } from "typesafecss";
+import { SocketFunction } from "socket-function/SocketFunction";
 import { ATag } from "../../../library-components/ATag";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { LogDatumRenderer } from "./ErrorNotificationPage";
 import { getErrorNotificationsManager } from "./errorWatcher";
+import { TicketsController } from "../errorTickets/tickets";
+import { STATE_HUES, ticketFilterURL } from "../errorTickets/TicketPage";
+import { isTicketFinished, TicketState, TICKET_STATES } from "../errorTickets/ticketTypes";
 
 export class ErrorWarning extends qreact.Component {
     manager = getErrorNotificationsManager();
 
-    render() {
-        if (this.manager.state.isLoading) {
-            return undefined;
+    renderTicketCounts() {
+        let tickets = TicketsController(SocketFunction.browserNodeId()).getTickets();
+        if (!tickets) return undefined;
+        let unfinished = tickets.filter(x => !isTicketFinished(x.state));
+        if (unfinished.length === 0) return undefined;
+
+        let counts = new Map<TicketState, number>();
+        for (let ticket of unfinished) {
+            counts.set(ticket.state, (counts.get(ticket.state) ?? 0) + 1);
         }
 
-        if (this.manager.state.unmatchedErrors.length === 0) {
-            return undefined;
+        return <div className={css.hbox(4).flexShrink0}>
+            {TICKET_STATES.filter(state => counts.has(state)).map(state => {
+                let hue = STATE_HUES[state];
+                return <ATag
+                    key={state}
+                    className={
+                        css.pad2(6, 2).hsl(hue, 60, 85).bord2(hue, 60, 60)
+                            .colorhsl(hue, 80, 25).fontSize(12).boldStyle.whiteSpace("nowrap")
+                            .textDecoration("none")
+                    }
+                    values={[
+                        showingManagementURL.getOverride(true),
+                        managementPageURL.getOverride("TicketPage"),
+                        ticketFilterURL.getOverride("unfinished"),
+                    ]}
+                >
+                    {counts.get(state)} {state}
+                </ATag>;
+            })}
+        </div>;
+    }
+
+    render() {
+        let ticketCounts = this.renderTicketCounts();
+
+        let errorWarning: preact.ComponentChild = undefined;
+        if (!this.manager.state.isLoading && this.manager.state.unmatchedErrors.length > 0) {
+            let firstError = this.manager.state.unmatchedErrors[0];
+            errorWarning = <div className={css.hbox(4).alignItems("start").hsl(0, 0, 90).bord2(0, 0, 85).pad2(4, 2).hslcolor(0, 0, 0)}>
+                <ATag className={css.paddingTop(5).flexShrink0} values={[
+                    showingManagementURL.getOverride(true),
+                    managementPageURL.getOverride("ErrorNotificationPage"),
+                ]}>
+                    Suppress
+                </ATag>
+                <div className={css.paddingTop(5)}>|</div>
+                <LogDatumRenderer datum={firstError} inlineMode />
+            </div>;
         }
 
-        let firstError = this.manager.state.unmatchedErrors[0];
-
-        return <div className={css.hbox(4).alignItems("start").hsl(0, 0, 90).bord2(0, 0, 85).pad2(4, 2).hslcolor(0, 0, 0)}>
-            <ATag className={css.paddingTop(5).flexShrink0} values={[
-                showingManagementURL.getOverride(true),
-                managementPageURL.getOverride("ErrorNotificationPage"),
-            ]}>
-                Suppress
-            </ATag>
-            <div className={css.paddingTop(5)}>|</div>
-            <LogDatumRenderer datum={firstError} inlineMode />
+        if (!ticketCounts && !errorWarning) return undefined;
+
+        return <div className={css.hbox(8).alignItems("start")}>
+            {ticketCounts}
+            {errorWarning}
         </div>;
     }
 }

package/src/diagnostics/logs/errorTickets/TicketPage.tsx

@@ -10,18 +10,24 @@ import { URLParam } from "../../../library-components/URLParam";
 import { ATag } from "../../../library-components/ATag";
 import { Button } from "../../../library-components/Button";
 import { LogDatum } from "../diskLogger";
-import { TicketsController } from "./tickets";
-import { Ticket, TicketComment, TicketPatchFile, TicketState, TICKET_STATES } from "./ticketTypes";
+import { managementPageURL, showingManagementURL } from "../../managementPages";
+import { TicketsController, watchTickets } from "./tickets";
+import { isTicketFinished, Ticket, TicketComment, TicketPatchFile, TicketState, TICKET_STATES } from "./ticketTypes";
 
 export const ticketIdURL = new URLParam("ticketid", "");
+// "unfinished" hides tickets in a final state (fixed / not-a-bug).
+export const ticketFilterURL = new URLParam("ticketfilter", "");
 
 const TITLE_MAX_LENGTH = 200;
+const COMMENT_TEXTAREA_MIN_HEIGHT = 250;
+const COMMENT_TEXTAREA_COLLAPSED_HEIGHT = 40;
 
-const STATE_HUES: Record<TicketState, number> = {
+export const STATE_HUES: Record<TicketState, number> = {
     "investigation": 45,
     "code-change": 210,
     "fixed": 120,
     "not-a-bug": 280,
+    "confused": 330,
     "timed-out": 0,
 };
 
@@ -35,6 +41,28 @@ function resetTicketData() {
     controller.getTicket.resetAll();
 }
 
+// Must be called in a synchronized context (e.g. an event callback or Querysub.commit).
+export function goToTicket(ticketId: string) {
+    showingManagementURL.value = true;
+    managementPageURL.value = "TicketPage";
+    ticketIdURL.value = ticketId;
+}
+
+// Reactive: returns undefined while the ticket list is still loading. When several tickets share the pattern, returns the most recently updated one.
+export function findTicketForPattern(pattern: string | undefined): Ticket | undefined {
+    if (!pattern) return undefined;
+    let tickets = getController().getTickets();
+    if (!tickets) return undefined;
+    let best: Ticket | undefined = undefined;
+    for (let ticket of tickets) {
+        if (ticket.suppressionPattern !== pattern) continue;
+        if (!best || ticket.lastUpdatedTime > best.lastUpdatedTime) {
+            best = ticket;
+        }
+    }
+    return best;
+}
+
 export async function createTicketForError(datum: LogDatum, suppressionPattern?: string): Promise<string> {
     let now = Date.now();
     let title = (datum.param0 && String(datum.param0) || "(no message)").slice(0, TITLE_MAX_LENGTH);
@@ -78,23 +106,22 @@ class HighlightedCode extends qreact.Component<{
     });
 
     componentDidMount() {
+        // Props are synchronized state, so read them here and not after an await.
+        let code = this.props.code;
+        let file = this.props.file;
         void (async () => {
-            try {
-                await ensureHljsLoaded();
-                let hljs = (window as any).hljs;
-                let extension = this.props.file?.split(".").pop() || "";
-                let html: string;
-                if (extension && hljs.getLanguage(extension)) {
-                    html = hljs.highlight(this.props.code, { language: extension }).value;
-                } else {
-                    html = hljs.highlightAuto(this.props.code).value;
-                }
-                Querysub.commit(() => {
-                    this.state.html = html;
-                });
-            } catch (e) {
-                console.error(`Failed to highlight code:`, (e as Error).stack ?? e);
+            await ensureHljsLoaded();
+            let hljs = (window as any).hljs;
+            let extension = file?.split(".").pop() || "";
+            let html: string;
+            if (extension && hljs.getLanguage(extension)) {
+                html = hljs.highlight(code, { language: extension }).value;
+            } else {
+                html = hljs.highlightAuto(code).value;
             }
+            Querysub.commit(() => {
+                this.state.html = html;
+            });
         })();
     }
 
@@ -130,6 +157,23 @@ function StateBadge(props: { state: TicketState }) {
 qreact.inline(StateBadge);
 
 export class TicketPage extends qreact.Component {
+    unwatch: (() => void) | undefined = undefined;
+
+    componentDidMount() {
+        void watchTickets(() => {
+            // refresh (not reset) so the current data stays on screen while the refetch happens.
+            let controller = getController();
+            controller.getTickets.refreshAll();
+            controller.getTicket.refreshAll();
+        }).then(unwatch => {
+            this.unwatch = unwatch;
+        });
+    }
+
+    componentWillUnmount() {
+        this.unwatch?.();
+    }
+
     render() {
         if (ticketIdURL.value) {
             return <TicketDetail ticketId={ticketIdURL.value} />;
@@ -148,12 +192,16 @@ class TicketList extends qreact.Component {
             </div>;
         }
 
-        let sorted = [...tickets];
+        let showUnfinishedOnly = ticketFilterURL.value === "unfinished";
+        let sorted = showUnfinishedOnly && tickets.filter(x => !isTicketFinished(x.state)) || [...tickets];
         sort(sorted, x => -x.lastUpdatedTime);
 
-        return <div className={css.vbox(16).pad2(16).fillWidth}>
+        return <div className={css.vbox(16).pad2(16).fillBoth.minHeight(0)}>
             <div className={css.hbox(16)}>
-                <h2>Tickets ({sorted.length})</h2>
+                <h2>Tickets ({sorted.length}{showUnfinishedOnly && " unfinished" || ""})</h2>
+                <ATag values={[ticketFilterURL.getOverride(showUnfinishedOnly && "" || "unfinished")]}>
+                    {showUnfinishedOnly && "Show All" || "Show Unfinished Only"}
+                </ATag>
                 <Button
                     hue={200}
                     onClick={() => {
@@ -163,13 +211,18 @@ class TicketList extends qreact.Component {
                     Refresh
                 </Button>
             </div>
+            <div className={css.hbox(8).alignItems("center")}>
+                <span>Run</span>
+                <code className={css.pad2(8, 4).hsl(220, 15, 15).colorhsl(120, 60, 70).fontSize(13).borderRadius(3)}>yarn autofix</code>
+                <span>to automatically investigate and fix open tickets.</span>
+            </div>
             {sorted.length === 0 && <div>No tickets. Create one from the Error Notifications page with the "Ticket" button.</div>}
-            <div className={css.vbox(8)}>
+            <div className={css.vbox(8).fillWidth.flexGrow(1).minHeight(0).overflowAuto}>
                 {sorted.map(ticket => (
                     <ATag
                         key={ticket.id}
                         values={[ticketIdURL.getOverride(ticket.id)]}
-                        className={css.hbox(16).pad2(12).bord2(200, 30, 70).hsl(0, 0, 96).alignItems("center").textDecoration("none")}
+                        className={css.hbox(16).pad2(12).bord2(200, 30, 70).hsl(0, 0, 96).alignItems("center").textDecoration("none").fillWidth}
                     >
                         <StateBadge state={ticket.state} />
                         <span className={css.ellipsis.flexFillWidth.colorhsl(0, 0, 10).boldStyle}>{ticket.title}</span>
@@ -206,8 +259,7 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
 
         let sortedComments = [...ticket.comments];
         sort(sortedComments, x => x.time);
-
-        return <div className={css.vbox(16).pad2(16).fillWidth.maxWidth("100%")}>
+        return <div className={css.vbox(16).pad2(16).fillBoth.maxWidth("100%").minHeight(0)}>
             <div className={css.hbox(16).alignItems("center")}>
                 <ATag values={[ticketIdURL.getOverride("")]}>← All Tickets</ATag>
                 <StateBadge state={ticket.state} />
@@ -222,8 +274,9 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                         hue={STATE_HUES[state]}
                         disabled={state === ticket!.state}
                         onClick={() => {
+                            let ticketId = this.props.ticketId;
                             Querysub.onCommitFinished(async () => {
-                                await getController().setTicketState.promise(this.props.ticketId, state);
+                                await getController().setTicketState.promise(ticketId, state);
                                 resetTicketData();
                             });
                         }}
@@ -235,8 +288,9 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                     hue={0}
                     onClick={() => {
                         if (!confirm(`Delete this ticket "${ticket!.title}"?`)) return;
+                        let ticketId = this.props.ticketId;
                         Querysub.onCommitFinished(async () => {
-                            await getController().deleteTicket.promise(this.props.ticketId);
+                            await getController().deleteTicket.promise(ticketId);
                             resetTicketData();
                             Querysub.commit(() => {
                                 ticketIdURL.value = "";
@@ -248,7 +302,7 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                 </Button>
             </div>
 
-            <div className={css.vbox(8).pad2(12).bord2(0, 50, 70).hsl(0, 30, 96)}>
+            <div className={css.vbox(8).pad2(12).bord2(0, 50, 70).hsl(0, 30, 96).fillWidth}>
                 <div
                     className={css.hbox(8).button}
                     onClick={() => {
@@ -266,7 +320,7 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                     </div>
                 )}
                 {this.state.showingErrorInfo && (
-                    <div className={css.vbox(4).pad2(8).hsl(0, 0, 98).bord2(0, 0, 85)}>
+                    <div className={css.vbox(4).pad2(8).hsl(0, 0, 98).bord2(0, 0, 85).fillWidth}>
                         {Object.entries(ticket.errorDatum).map(([key, value]) => (
                             <div key={key} className={css.hbox(8)}>
                                 <strong className={css.minWidth(120)}>{key}:</strong>
@@ -277,17 +331,17 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                 )}
             </div>
 
-            <div className={css.vbox(12)}>
+            <div className={css.vbox(12).fillWidth.flexGrow(1).minHeight(0).overflowAuto}>
                 <h3>Comments ({sortedComments.length})</h3>
                 {sortedComments.map(comment => (
                     <TicketCommentItem key={comment.id} ticketId={this.props.ticketId} comment={comment} />
                 ))}
             </div>
 
-            <div className={css.vbox(8).pad2(12).bord2(120, 50, 60).hsl(120, 50, 96)}>
+            <div className={css.vbox(8).pad2(12).bord2(120, 50, 60).hsl(120, 50, 96).fillWidth}>
                 <strong>Add Comment</strong>
                 <textarea
-                    className={css.minHeight(80).fillWidth.pad2(8)}
+                    className={css.minHeight(COMMENT_TEXTAREA_COLLAPSED_HEIGHT).minHeight(COMMENT_TEXTAREA_MIN_HEIGHT, "focus").fillWidth.pad2(8).fontSize(14).resize("vertical")}
                     value={this.state.newCommentText}
                     onInput={e => {
                         this.state.newCommentText = (e.target as HTMLTextAreaElement).value;
@@ -299,6 +353,7 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                         onClick={() => {
                             let text = this.state.newCommentText.trim();
                             if (!text) return;
+                            let ticketId = this.props.ticketId;
                             Querysub.onCommitFinished(async () => {
                                 let comment: TicketComment = {
                                     id: nextId(),
@@ -307,7 +362,7 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
                                     kind: "text",
                                     text,
                                 };
-                                await getController().addComment.promise(this.props.ticketId, comment);
+                                await getController().addComment.promise(ticketId, comment);
                                 resetTicketData();
                                 Querysub.commit(() => {
                                     this.state.newCommentText = "";
@@ -323,6 +378,45 @@ class TicketDetail extends qreact.Component<{ ticketId: string }> {
     }
 }
 
+// Pulls the interesting parts out of a searchLogs tool-call comment so they can be shown inline. startTime/endTime may be epoch ms or strings — either way the Date constructor parses them.
+function parseSearchLogsInfo(comment: TicketComment): {
+    rangeText: string;
+    resultsText: string;
+    machine: string;
+    query: string;
+} | undefined {
+    if (comment.kind !== "tool-call" || comment.toolName !== "searchLogs") return undefined;
+    try {
+        let input = JSON.parse(comment.toolInput || "{}") as Record<string, unknown>;
+
+        function formatBound(value: unknown): string {
+            let time = new Date(value as string | number).getTime();
+            if (Number.isFinite(time)) return formatDateTime(time);
+            return String(value);
+        }
+        let rangeText = `${formatBound(input.startTime)} → ${formatBound(input.endTime)}`;
+
+        let resultsText = "error";
+        try {
+            let output = JSON.parse(comment.toolOutput || "") as { results?: unknown[]; limitHit?: boolean };
+            if (Array.isArray(output.results)) {
+                resultsText = `${output.results.length}${output.limitHit && "+" || ""} results`;
+            }
+        } catch {
+            // Output was an error message, not JSON.
+        }
+
+        return {
+            rangeText,
+            resultsText,
+            machine: String(input.machine ?? ""),
+            query: String(input.query ?? ""),
+        };
+    } catch {
+        return undefined;
+    }
+}
+
 class TicketCommentItem extends qreact.Component<{
     ticketId: string;
     comment: TicketComment;
@@ -340,8 +434,9 @@ class TicketCommentItem extends qreact.Component<{
         if (comment.kind === "tool-call") {
             hue = 0;
         }
+        let searchInfo = parseSearchLogsInfo(comment);
 
-        return <div className={css.vbox(8).pad2(12).bord2(hue, 30, 70).hsl(hue, 20, 97)}>
+        return <div className={css.vbox(8).pad2(12).bord2(hue, 30, 70).hsl(hue, 20, 97).fillWidth}>
             <div className={css.hbox(12).alignItems("center")}>
                 <strong>{comment.author}</strong>
                 <span className={css.colorhsl(0, 0, 40).fontSize(12)}>{formatDateTime(comment.time)}</span>
@@ -369,18 +464,28 @@ class TicketCommentItem extends qreact.Component<{
                     flavor="small"
                     onClick={() => {
                         if (!confirm(`Delete this comment?`)) return;
+                        let ticketId = this.props.ticketId;
+                        let commentId = comment.id;
                         Querysub.onCommitFinished(async () => {
-                            await getController().deleteComment.promise(this.props.ticketId, comment.id);
+                            await getController().deleteComment.promise(ticketId, commentId);
                             resetTicketData();
                         });
                     }}
                 >
                     Delete
                 </Button>
+                {searchInfo && (
+                    <>
+                        <span className={css.fontSize(12).whiteSpace("nowrap")}>{searchInfo.rangeText}</span>
+                        <span className={css.fontSize(12).whiteSpace("nowrap").boldStyle}>{searchInfo.resultsText}</span>
+                        <span className={css.fontSize(12).whiteSpace("nowrap").colorhsl(0, 0, 40)}>{searchInfo.machine}</span>
+                        <span className={css.fontSize(12).ellipsis.colorhsl(210, 60, 35)}>{searchInfo.query}</span>
+                    </>
+                )}
             </div>
 
             {comment.kind === "tool-call" && (
-                <div className={css.vbox(8)}>
+                <div className={css.vbox(8).fillWidth}>
                     <div
                         className={css.hbox(8).button}
                         onClick={() => {
@@ -395,7 +500,7 @@ class TicketCommentItem extends qreact.Component<{
                         <span className={css.ellipsis.colorhsl(0, 0, 40).fontSize(12)}>{comment.toolInput}</span>
                     </div>
                     {this.state.expandedTool && (
-                        <div className={css.vbox(8)}>
+                        <div className={css.vbox(8).fillWidth}>
                             <strong>Input</strong>
                             <pre className={css.pad2(8).hsl(0, 0, 92).whiteSpace("pre-wrap").overflowWrap("break-word").margin(0).fontSize(12).maxHeight(200).overflowAuto}>{comment.toolInput}</pre>
                             <strong>Output</strong>
@@ -410,9 +515,9 @@ class TicketCommentItem extends qreact.Component<{
             )}
 
             {this.state.editing && (
-                <div className={css.vbox(8)}>
+                <div className={css.vbox(8).fillWidth}>
                     <textarea
-                        className={css.minHeight(80).fillWidth.pad2(8)}
+                        className={css.minHeight(COMMENT_TEXTAREA_MIN_HEIGHT).fillWidth.pad2(8).fontSize(14).resize("vertical")}
                         value={this.state.editText}
                         onInput={e => {
                             this.state.editText = (e.target as HTMLTextAreaElement).value;
@@ -423,8 +528,10 @@ class TicketCommentItem extends qreact.Component<{
                             hue={120}
                             onClick={() => {
                                 let text = this.state.editText.trim();
+                                let ticketId = this.props.ticketId;
+                                let commentId = comment.id;
                                 Querysub.onCommitFinished(async () => {
-                                    await getController().updateCommentText.promise(this.props.ticketId, comment.id, text);
+                                    await getController().updateCommentText.promise(ticketId, commentId, text);
                                     resetTicketData();
                                     Querysub.commit(() => {
                                         this.state.editing = false;
@@ -446,7 +553,7 @@ class TicketCommentItem extends qreact.Component<{
             )}
 
             {comment.kind === "patch" && comment.patchFiles && (
-                <div className={css.vbox(12)}>
+                <div className={css.vbox(12).fillWidth}>
                     {comment.patchFiles.map((patchFile, idx) => (
                         <PatchFileView key={idx} patchFile={patchFile} />
                     ))}
@@ -456,12 +563,10 @@ class TicketCommentItem extends qreact.Component<{
                                 <Button
                                     hue={120}
                                     onClick={() => {
+                                        let ticketId = this.props.ticketId;
+                                        let commentId = comment.id;
                                         Querysub.onCommitFinished(async () => {
-                                            try {
-                                                await getController().applyPatch.promise(this.props.ticketId, comment.id);
-                                            } catch (e) {
-                                                alert(`Failed to apply patch: ${(e as Error).message}`);
-                                            }
+                                            await getController().applyPatch.promise(ticketId, commentId);
                                             resetTicketData();
                                         });
                                     }}
@@ -471,8 +576,10 @@ class TicketCommentItem extends qreact.Component<{
                                 <Button
                                     hue={0}
                                     onClick={() => {
+                                        let ticketId = this.props.ticketId;
+                                        let commentId = comment.id;
                                         Querysub.onCommitFinished(async () => {
-                                            await getController().setPatchStatus.promise(this.props.ticketId, comment.id, "rejected");
+                                            await getController().setPatchStatus.promise(ticketId, commentId, "rejected");
                                             resetTicketData();
                                         });
                                     }}
@@ -501,10 +608,10 @@ class TicketCommentItem extends qreact.Component<{
 class PatchFileView extends qreact.Component<{ patchFile: TicketPatchFile }> {
     render() {
         let patchFile = this.props.patchFile;
-        return <div className={css.vbox(4)}>
+        return <div className={css.vbox(4).fillWidth}>
             <strong className={css.fontSize(13)}>{patchFile.file}</strong>
             {patchFile.oldText && (
-                <div className={css.vbox(2)}>
+                <div className={css.vbox(2).fillWidth}>
                     <span className={css.colorhsl(0, 70, 40).fontSize(12).boldStyle}>- Old</span>
                     <HighlightedCode code={patchFile.oldText} file={patchFile.file} />
                 </div>

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

@@ -5,9 +5,11 @@ 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 { formatNumber, formatTime } from "socket-function/src/formatting/format";
+import { blue, green } from "socket-function/src/formatting/logColors";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { isPublic } from "../../../config";
+import { decodeNodeId } from "sliftutils/misc/https/certs";
+import { getDomain, isPublic } from "../../../config";
 import { timeoutToUndefinedSilent } from "../../../errors";
 import { getAllNodeIds } from "../../../-f-node-discovery/NodeDiscovery";
 import { getControllerNodeId, NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
@@ -16,7 +18,7 @@ import { AutoFixerControllerBase, setAutoFixerHandlers } from "./autoFixerContro
 import { TicketServiceBase } from "./tickets";
 import { Ticket, TicketComment, TicketPatchFile, TicketState } from "./ticketTypes";
 
-const INVESTIGATION_TIMEOUT = timeInMinute * 20;
+const INVESTIGATION_TIMEOUT = timeInMinute * 60;
 // "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).
@@ -24,6 +26,7 @@ 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 STATUS_LOG_INTERVAL = timeInMinute;
 const TOOL_SERVER_PORT = 4517;
 const MAX_TOOL_OUTPUT_STORED = 20_000;
 const MAX_PRIOR_COMMENTS_PROMPT_CHARS = 30_000;
@@ -53,6 +56,44 @@ async function ticketService() {
 
 // The ticket the current claude run is bound to. Runs are serialized, so a module-level value is safe.
 let currentTicketId: string | undefined = undefined;
+let currentTicketTitle: string | undefined = undefined;
+let currentTicketStartTime = 0;
+
+// inputTokens is uncached input only — cache reads/writes are tracked separately, otherwise cache reads massively inflate the input number.
+type TokenUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+};
+function emptyTokens(): TokenUsage {
+    return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+}
+function addTokens(into: TokenUsage, from: TokenUsage) {
+    into.inputTokens += from.inputTokens;
+    into.outputTokens += from.outputTokens;
+    into.cacheReadTokens += from.cacheReadTokens;
+    into.cacheWriteTokens += from.cacheWriteTokens;
+}
+let runTokens = emptyTokens();
+let totalTokens = emptyTokens();
+
+function formatTokens(tokens: TokenUsage) {
+    return `${formatNumber(tokens.inputTokens)} in / ${formatNumber(tokens.outputTokens)} out (cache: ${formatNumber(tokens.cacheReadTokens)} read, ${formatNumber(tokens.cacheWriteTokens)} write)`;
+}
+
+function logStatus() {
+    let parts: string[] = [];
+    parts.push(`${knownOpenTicketIds.size} open ticket(s) to fix`);
+    if (currentTicketId) {
+        parts.push(`working on "${currentTicketTitle}" (${currentTicketId}) for ${formatTime(Date.now() - currentTicketStartTime)}`);
+        parts.push(`run tokens: ${formatTokens(runTokens)}`);
+    } else {
+        parts.push(`idle`);
+    }
+    parts.push(`total tokens: ${formatTokens(totalTokens)}`);
+    console.log(`AutoFixer status: ${parts.join(" | ")}`);
+}
 // 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.
@@ -188,7 +229,7 @@ Query syntax (case-insensitive substring match by default):
             type: "object",
             properties: {
                 query: { type: "string" },
-                machine: { type: "string", description: "machineId, or \"local\" for the machine running this server" },
+                machine: { type: "string", description: "machineId (get one from listNodes, or from the error's __machineId field), or \"local\" for the machine running this server. A nodeId is also accepted and converted to its machineId." },
                 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"] },
@@ -201,7 +242,7 @@ Query syntax (case-insensitive substring match by default):
     },
     {
         name: "listNodes",
-        description: `List every node in the Querysub cluster, with each node's process entry point. Returns an array of { nodeId, entryPoint }.`,
+        description: `List every node in the Querysub cluster, with each node's process entry point. Returns an array of { nodeId, machineId, entryPoint }. Use the machineId (NOT the nodeId) as the \`machine\` parameter of searchLogs.`,
         inputSchema: { type: "object", properties: {} },
     },
     {
@@ -240,11 +281,11 @@ Query syntax (case-insensitive substring match by default):
     },
     {
         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.`,
+        description: `Set the state of the ticket you are investigating. Use "code-change" once you have proposed patches, "not-a-bug" if the error should simply be ignored, or "confused" if you genuinely cannot figure out what is going on.`,
         inputSchema: {
             type: "object",
             properties: {
-                state: { type: "string", enum: ["code-change", "not-a-bug"] },
+                state: { type: "string", enum: ["code-change", "not-a-bug", "confused"] },
             },
             required: ["state"],
         },
@@ -274,11 +315,23 @@ async function getNodeInfos() {
     return Promise.all(
         nodes.map(async nodeId => {
             let metadata = await timeoutToUndefinedSilent(NODE_INFO_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
-            return { nodeId, entryPoint: metadata?.entryPoint };
+            return {
+                nodeId,
+                machineId: decodeNodeId(nodeId, getDomain(), "allowMissingThreadId")?.machineId,
+                entryPoint: metadata?.entryPoint,
+            };
         }),
     );
 }
 
+// The search only matches files by machineId — a nodeId (or anything else) silently matches nothing, so convert nodeIds for the AI.
+function normalizeMachineParam(machine: string): string {
+    if (machine === "local") return machine;
+    let decoded = decodeNodeId(machine, getDomain(), "allowMissingThreadId");
+    if (decoded?.machineId) return decoded.machineId;
+    return machine;
+}
+
 let mcpLogs = new MCPIndexedLogs();
 
 async function callTool(toolName: string, args: Record<string, unknown>): Promise<unknown> {
@@ -321,13 +374,15 @@ async function callTool(toolName: string, args: Record<string, unknown>): Promis
     let errorText: string | undefined = undefined;
     try {
         if (toolName === "searchLogs") {
-            result = await mcpLogs.search(args as Parameters<MCPIndexedLogs["search"]>[0]);
+            let searchArgs = { ...args } as Parameters<MCPIndexedLogs["search"]>[0];
+            searchArgs.machine = normalizeMachineParam(String(searchArgs.machine ?? ""));
+            result = await mcpLogs.search(searchArgs);
         } 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"`);
+            if (state !== "code-change" && state !== "not-a-bug" && state !== "confused") {
+                throw new Error(`setTicketState only allows "code-change", "not-a-bug", or "confused"`);
             }
             let service = await ticketService();
             await service.setTicketState(ticketId, state);
@@ -465,7 +520,7 @@ function buildPrompt(ticket: Ticket): string {
 
     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.
+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.
 
 Work in two phases:
 
@@ -477,9 +532,9 @@ PHASE 2 — FIX. Only after you have added your diagnosis comment, decide on the
   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.
+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. Relative file paths are resolved against the application repository (${process.cwd()}); for files in the querysub repository use absolute paths. 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.
+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. If you are confused and just cannot figure out what is going on — the logs and code don't add up, and you can't even propose useful additional logging — add a comment explaining what you tried and what confused you, then call mcp__autofixer__setTicketState with "confused". Do NOT edit files directly — only propose changes through mcp__autofixer__addPatch.
 
 ==== TICKET ====
 Title: ${ticket.title}
@@ -489,10 +544,76 @@ ${ticket.suppressionPattern && `Matched suppression pattern: ${ticket.suppressio
 ${JSON.stringify(ticket.errorDatum, undefined, 2)}
 
 ==== COMMENTS SO FAR (chronological) ====
+This is the ticket's full history: your own comments, patches, and tool calls from prior runs, plus comments from the human user. Comments authored by "user" are from the human — read them carefully and treat them as direct instructions and corrections. They take precedence over the generic instructions above and over your own prior conclusions.
+
 ${priorCommentsText || "(none)"}
 `;
 }
 
+const CLAUDE_LOG_PREVIEW_CHARS = 300;
+
+// This file lives at <querysub>/src/diagnostics/logs/errorTickets, so the framework repo root is four levels up — correct whether querysub is a sibling repo or inside node_modules.
+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;
+
+type ClaudeUsage = {
+    input_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    output_tokens?: number;
+};
+
+function usageToTokens(usage: ClaudeUsage): TokenUsage {
+    return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+        cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+    };
+}
+
+// Parses one stream-json line from claude. Returns true when the line was understood (so the raw JSON isn't echoed).
+function handleClaudeStreamLine(line: string): boolean {
+    let event: any;
+    try {
+        event = JSON.parse(line);
+    } catch {
+        return false;
+    }
+    if (!event || typeof event.type !== "string") return false;
+
+    if (event.type === "assistant") {
+        let usage = event.message?.usage as ClaudeUsage | undefined;
+        if (usage) {
+            addTokens(runTokens, usageToTokens(usage));
+        }
+        for (let block of event.message?.content ?? []) {
+            if (block.type === "text" && block.text) {
+                console.log(`[claude] ${String(block.text).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
+            } else if (block.type === "tool_use") {
+                console.log(`[claude] tool_use: ${blue(String(block.name))} ${JSON.stringify(block.input ?? {}).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
+            }
+        }
+        return true;
+    }
+    if (event.type === "result") {
+        // The result's usage is the authoritative total for the run, replacing our per-message accumulation.
+        if (event.usage) {
+            runTokens = usageToTokens(event.usage as ClaudeUsage);
+        }
+        console.log(`[claude] result (${event.subtype ?? "?"}): tokens ${formatTokens(runTokens)}${event.total_cost_usd !== undefined && `, cost $${event.total_cost_usd}` || ""}`);
+        claudeTurnEndedHandler?.();
+        return true;
+    }
+    if (event.type === "system" || event.type === "user") {
+        // Init/config noise and tool results (which we already record in the ticket).
+        return true;
+    }
+    return false;
+}
+
 function quoteArgForShell(arg: string): string {
     if (!/[\s"^&|<>()%!;'$`\\]/.test(arg)) return arg;
     return `"${arg.replace(/"/g, "\\\"")}"`;
@@ -507,7 +628,7 @@ function killChildTree(child: ChildProcess) {
     }
 }
 
-async function runClaude(prompt: string): Promise<{ timedOut: boolean; exitCode: number | undefined }> {
+async function runClaude(prompt: string, 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: {
@@ -520,6 +641,10 @@ async function runClaude(prompt: string): Promise<{ timedOut: boolean; exitCode:
 
     let args = [
         "-p",
+        // stream-json output (which requires --verbose in -p mode) gives us per-message token usage for status logging. stream-json input keeps stdin open so we can inject new user comments as user messages between turns.
+        "--output-format", "stream-json",
+        "--input-format", "stream-json",
+        "--verbose",
         "--mcp-config", mcpConfigPath,
         "--strict-mcp-config",
         "--allowedTools", CLAUDE_ALLOWED_TOOLS.join(","),
@@ -534,26 +659,63 @@ async function runClaude(prompt: string): Promise<{ timedOut: boolean; exitCode:
         child = spawn("claude", args, { stdio: ["pipe", "pipe", "pipe"] });
     }
 
-    child.stdin!.write(prompt);
-    child.stdin!.end();
+    function writeUserMessage(text: string) {
+        if (child.exitCode !== null || child.killed) return;
+        try {
+            child.stdin!.write(JSON.stringify({
+                type: "user",
+                message: { role: "user", content: [{ type: "text", text }] },
+            }) + "\n");
+        } catch (e) {
+            console.error(`Failed to write user message to claude:`, (e as Error).stack ?? e);
+        }
+    }
+    writeUserMessage(prompt);
+
+    // 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 () => {
+            let newComments: string[] = [];
+            try {
+                newComments = await takeNewUserComments();
+            } catch (e) {
+                console.error(`Failed to check for new user comments:`, (e as Error).stack ?? e);
+            }
+            if (newComments.length > 0) {
+                console.log(green(`Forwarding ${newComments.length} new user comment(s) to the running investigation`));
+                writeUserMessage(`The user added the following comment(s) to the ticket while you were working. Take them into account and continue (re-run phases as needed, and remember to set the ticket state when you are done):\n\n${newComments.join("\n\n---\n\n")}`);
+                return;
+            }
+            try {
+                child.stdin!.end();
+            } catch {
+                // Process already exited.
+            }
+        })();
+    };
 
-    function forwardLines(stream: NodeJS.ReadableStream, prefix: string) {
+    function forwardLines(stream: NodeJS.ReadableStream, prefix: string, onLine?: (line: string) => boolean) {
         let pending = "";
+        function emit(line: string) {
+            if (!line.trim()) return;
+            if (onLine && onLine(line)) return;
+            console.log(`${prefix} ${line}`);
+        }
         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}`);
+                emit(line);
             }
         });
         stream.on("end", () => {
             if (pending) {
-                console.log(`${prefix} ${pending}`);
+                emit(pending);
             }
         });
     }
-    forwardLines(child.stdout!, "[claude]");
+    forwardLines(child.stdout!, "[claude]", line => handleClaudeStreamLine(line));
     forwardLines(child.stderr!, "[claude:err]");
 
     let timedOut = false;
@@ -570,15 +732,19 @@ async function runClaude(prompt: string): Promise<{ timedOut: boolean; exitCode:
         });
         child.on("exit", code => resolve(code ?? undefined));
     });
+    claudeTurnEndedHandler = undefined;
     clearTimeout(timeout);
     return { timedOut, exitCode };
 }
 
 async function runInvestigation(ticket: Ticket): Promise<void> {
-    console.log(`AutoFixer starting investigation of ticket ${ticket.id}: ${ticket.title}`);
+    console.log(green(`AutoFixer starting investigation of ticket ${ticket.id}: ${ticket.title}`));
     let service = await ticketService();
 
     currentTicketId = ticket.id;
+    currentTicketTitle = ticket.title;
+    currentTicketStartTime = Date.now();
+    runTokens = emptyTokens();
     stateChangedDuringRun = false;
     patchAddedDuringRun = false;
     try {
@@ -587,7 +753,23 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
             text: `Starting automated investigation (timeout ${formatTime(INVESTIGATION_TIMEOUT)}).`,
         });
 
-        let { timedOut, exitCode } = await runClaude(buildPrompt(ticket));
+        // 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.
+        let seenCommentIds = new Set(ticket.comments.map(c => c.id));
+        async function takeNewUserComments(): Promise<string[]> {
+            let updated = await service.getTicket(ticket.id);
+            if (!updated) return [];
+            let newComments = updated.comments.filter(c =>
+                c.kind === "text"
+                && c.author !== AUTOFIXER_AUTHOR
+                && !seenCommentIds.has(c.id)
+            );
+            for (let comment of updated.comments) {
+                seenCommentIds.add(comment.id);
+            }
+            return newComments.map(c => c.text);
+        }
+
+        let { timedOut, exitCode } = await runClaude(buildPrompt(ticket), takeNewUserComments);
 
         if (timedOut) {
             await addTicketComment(ticket.id, {
@@ -612,12 +794,14 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
         } 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.`,
+                text: `Automated investigation ended (claude exit code ${exitCode}) without a diagnosis, patches, or a state change. Marking the ticket confused so it is not retried automatically — set it back to investigation to retry.`,
             });
-            await service.setTicketState(ticket.id, "timed-out");
+            await service.setTicketState(ticket.id, "confused");
         }
     } finally {
+        addTokens(totalTokens, runTokens);
         currentTicketId = undefined;
+        currentTicketTitle = undefined;
     }
 }
 
@@ -629,6 +813,7 @@ export async function runAutoFixer(): Promise<void> {
     void runInfinitePollCallAtStart(REGISTER_POLL_INTERVAL, registerWithTicketService);
     void runInfinitePollCallAtStart(ALL_TICKETS_POLL_INTERVAL, pollAllTickets);
     void runInfinitePollCallAtStart(OPEN_TICKET_POLL_INTERVAL, pollOpenTickets);
+    void runInfinitePollCallAtStart(STATUS_LOG_INTERVAL, logStatus);
 
     console.log(`AutoFixer running. Watching for tickets in the investigation state (cwd: ${process.cwd()}).`);
 }

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

@@ -1,7 +1,12 @@
 import { LogDatum } from "../diskLogger";
 
-export type TicketState = "investigation" | "code-change" | "fixed" | "not-a-bug" | "timed-out";
-export const TICKET_STATES: TicketState[] = ["investigation", "code-change", "fixed", "not-a-bug", "timed-out"];
+export type TicketState = "investigation" | "code-change" | "fixed" | "not-a-bug" | "confused" | "timed-out";
+export const TICKET_STATES: TicketState[] = ["investigation", "code-change", "fixed", "not-a-bug", "confused", "timed-out"];
+
+export const TICKET_FINAL_STATES: TicketState[] = ["fixed", "not-a-bug"];
+export function isTicketFinished(state: TicketState): boolean {
+    return TICKET_FINAL_STATES.includes(state);
+}
 
 export type TicketPatchStatus = "pending" | "applied" | "rejected";
 

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

@@ -137,7 +137,7 @@ class TicketService {
         }
         if (!applied) {
             if (TicketService.autoFixerNodes.size === 0) {
-                throw new Error(`No autofixer is connected, so the patch cannot be applied. Run \`yarn autofixer\` in the repository the patch targets.`);
+                throw new Error(`No autofixer is connected, so the patch cannot be applied. Run \`yarn autofix\` in the repository the patch targets.`);
             }
             throw new Error(`Failed to apply patch on all connected autofixer nodes:\n${errors.join("\n")}`);
         }
@@ -150,6 +150,12 @@ class TicketService {
         TicketService.autoFixerNodes.add(caller.nodeId);
     }
 
+    private static watchersSERVICE = new Set<string>();
+    public async watchTicketsSERVICE(): Promise<void> {
+        let caller = SocketFunction.getCaller();
+        TicketService.watchersSERVICE.add(caller.nodeId);
+    }
+
     public static triggerTicketsChanged = batchFunction({ delay: 100 }, (ticketIds: string[]) => {
         let uniqueIds = Array.from(new Set(ticketIds));
         for (let nodeId of TicketService.autoFixerNodes) {
@@ -161,6 +167,15 @@ class TicketService {
                 }
             })();
         }
+        for (let nodeId of TicketService.watchersSERVICE) {
+            void (async () => {
+                try {
+                    await TicketDataBase.nodes[nodeId].receiveTicketsChangedHTTP(uniqueIds);
+                } catch {
+                    TicketService.watchersSERVICE.delete(nodeId);
+                }
+            })();
+        }
     });
 }
 
@@ -179,6 +194,7 @@ export const TicketServiceBase = SocketFunction.register(
         setPatchStatus: {},
         applyPatch: {},
         registerAutoFixerSERVICE: {},
+        watchTicketsSERVICE: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],
@@ -240,6 +256,53 @@ class TicketData {
     public async applyPatch(id: string, commentId: string): Promise<void> {
         await TicketServiceBase.nodes[await getTicketServiceNode()].applyPatch(id, commentId);
     }
+
+    // Live updates: browser → this HTTP node → ticket service node, with change notifications flowing back down the same two hops.
+    private static browserCallbacks = new Set<(ticketIds: string[]) => void>();
+    public static async watchTickets(callback: (ticketIds: string[]) => void) {
+        TicketData.browserCallbacks.add(callback);
+        await TicketData.ensureWatchingBrowser();
+        return () => {
+            TicketData.browserCallbacks.delete(callback);
+        };
+    }
+
+    private static ensureWatchingBrowser = lazy(async () => {
+        await TicketDataBase.nodes[SocketFunction.getBrowserNodeId()].watchTicketsHTTP();
+    });
+
+    public async receiveTicketsChangedBrowser(ticketIds: string[]) {
+        for (let callback of TicketData.browserCallbacks) {
+            callback(ticketIds);
+        }
+    }
+
+    private watchersHTTP = new Set<string>();
+    public async watchTicketsHTTP() {
+        let caller = SocketFunction.getCaller();
+        this.watchersHTTP.add(caller.nodeId);
+        await TicketData.ensureWatchingService();
+    }
+
+    private static ensureWatchingService = lazy(async () => {
+        let controllerNodeId = await getTicketServiceNode();
+        SocketFunction.onNextDisconnect(controllerNodeId, () => {
+            TicketData.ensureWatchingService.reset();
+        }, "iKnowThatServerNodeIdsMayReconnect_andIHandleReconnections");
+        await TicketServiceBase.nodes[controllerNodeId].watchTicketsSERVICE();
+    });
+
+    public async receiveTicketsChangedHTTP(ticketIds: string[]) {
+        for (let nodeId of this.watchersHTTP) {
+            void (async () => {
+                try {
+                    await TicketDataBase.nodes[nodeId].receiveTicketsChangedBrowser(ticketIds);
+                } catch {
+                    this.watchersHTTP.delete(nodeId);
+                }
+            })();
+        }
+    }
 }
 
 export const TicketDataBase = SocketFunction.register(
@@ -256,9 +319,16 @@ export const TicketDataBase = SocketFunction.register(
         deleteComment: {},
         setPatchStatus: {},
         applyPatch: {},
+        watchTicketsHTTP: {},
+        receiveTicketsChangedHTTP: {},
+        receiveTicketsChangedBrowser: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],
     })
 );
 export const TicketsController = getSyncedController(TicketDataBase);
+
+export function watchTickets(callback: (ticketIds: string[]) => void) {
+    return TicketData.watchTickets(callback);
+}