refactor: codebase audit cleanup — dead code, dedup, module splits

Multi-agent audit + aggressive cleanup across server/web/coder/booterm,
delivered behind a DEFER discipline so none of the in-flight files were
touched. Removes dead code/deps/columns, dedups server + coder helpers,
and splits the oversized modules (tools.ts, opencode-server.ts,
sentinel-summaries, turn.ts, TerminalPane.tsx) behind stable contracts.
Adds 78 parity/unit tests (server 587, coder 323); fixes two latent bugs
(ChatPane queue keys, FileViewerOverlay blank-line parity).

Intended tag: v2.7.12-audit-cleanup.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/server/src/services/inference/error-handler.ts

@@ -10,7 +10,7 @@ import { maybeFlagForCompaction } from './payload.js';
 import { insertParts, partsFromAssistantMessage } from './parts.js';
 import type { PartInsert } from './parts.js';
 import { stripToolMarkup } from './tool-call-parser.js';
-import type { InferenceContext, StreamResult, TurnArgs } from './turn.js';
+import type { InferenceContext, StreamResult, TurnArgs } from './types.js';
 
 export async function handleAbortOrError(
   ctx: InferenceContext,
@@ -95,6 +95,90 @@ export async function handleAbortOrError(
   }
 }
 
+// P5: the success-finalize atom shared by the wrap-up summaries
+// (sentinel-summaries.ts) and the synthesis pass (synthesisPipeline.ts). Both
+// previously hand-rolled this exact ceremony — n_ctx lookup, the complete
+// UPDATE (content/status/tokens/ctx/ctx_max/finished_at; NO model column), and
+// the message_complete frame with the full token fields. Single-sourcing it
+// means a message_complete frame-contract change lands in one place instead of
+// silently skipping the summary/synthesis paths.
+//
+// `beforeComplete` runs AFTER the UPDATE and BEFORE the message_complete frame
+// — synthesis uses it to write its kind='synthesis' part in the original order
+// (UPDATE → insertParts → message_complete), preserving timing exactly.
+//
+// NOTE: finalizeCompletion does NOT use this — it additionally writes the
+// `model` column, the text/reasoning/html_artifact parts, the compaction flag,
+// and the session_updated bump, which this atom deliberately omits (the summary
+// and synthesis paths handle those — or not — themselves).
+export async function finalizeStreamedRow(
+  ctx: InferenceContext,
+  opts: {
+    sessionId: string;
+    chatId: string;
+    messageId: string;
+    model: string;
+    content: string;
+    completionTokens: number | null;
+    promptTokens: number | null;
+    startedAt: string | null;
+    beforeComplete?: () => Promise<void>;
+  },
+): Promise<void> {
+  // v1.11.3: see executeToolPhase for the rationale.
+  const mctx = await modelContext.getModelContext(opts.model);
+  const nCtx = mctx?.n_ctx ?? null;
+  const [updated] = await ctx.sql<
+    { tokens_used: number | null; ctx_used: number | null; ctx_max: number | null; finished_at: string | null }[]
+  >`
+    UPDATE messages
+    SET content = ${opts.content},
+        status = 'complete',
+        tokens_used = ${opts.completionTokens},
+        ctx_used = ${opts.promptTokens},
+        ctx_max = ${nCtx},
+        finished_at = clock_timestamp()
+    WHERE id = ${opts.messageId}
+    RETURNING tokens_used, ctx_used, ctx_max, finished_at
+  `;
+  if (opts.beforeComplete) await opts.beforeComplete();
+  ctx.publish(opts.sessionId, {
+    type: 'message_complete',
+    message_id: opts.messageId,
+    chat_id: opts.chatId,
+    tokens_used: updated?.tokens_used ?? null,
+    ctx_used: updated?.ctx_used ?? null,
+    ctx_max: updated?.ctx_max ?? null,
+    started_at: opts.startedAt,
+    finished_at: updated?.finished_at ?? null,
+    model: opts.model,
+  });
+}
+
+// P5: minimal empty-finalize for the mistake-escalate path. The escalate
+// branch in runAssistantTurn stops the turn cap-hit-style; the next assistant
+// row is still 'streaming', so it's finalized as an empty complete row (no
+// tokens, no parts, no session bump — the escalate branch handles the sentinel
+// + chat_status itself). Centralizing the status-column write + message_complete
+// frame here keeps it next to the other finalize paths so a status-column
+// change is found in one place.
+export async function finalizeEmpty(
+  ctx: InferenceContext,
+  args: TurnArgs,
+): Promise<void> {
+  const { sessionId, chatId, assistantMessageId } = args;
+  await ctx.sql`
+    UPDATE messages
+    SET content = '', status = 'complete', finished_at = clock_timestamp()
+    WHERE id = ${assistantMessageId}
+  `;
+  ctx.publish(sessionId, {
+    type: 'message_complete',
+    message_id: assistantMessageId,
+    chat_id: chatId,
+  });
+}
+
 export async function finalizeCompletion(
   ctx: InferenceContext,
   args: TurnArgs,