@vintasoftware/pr-review-canvas 0.1.0 → 0.3.0

package/src/review/trim-caps.ts

@@ -77,7 +77,10 @@ interface TitledOutput {
  * Titles only: a rationale or a body is prose a reader will read, and cutting it is the author's
  * call, not the tool's.
  */
-export function applyTitleTrims(output: unknown, caps: { layerTitle: number; pointTitle: number }): TitleTrim[] {
+export function applyTitleTrims(
+  output: unknown,
+  caps: { layerTitle: number; pointTitle: number }
+): TitleTrim[] {
   const trims: TitleTrim[] = []
   const trim = (where: string, holder: { title?: string }, cap: number): void => {
     if (typeof holder.title !== 'string') {
@@ -89,11 +92,12 @@ export function applyTitleTrims(output: unknown, caps: { layerTitle: number; poi
       holder.title = trimmed
     } else if (visibleLength(holder.title) > cap) {
       const match = EXPLAINER.exec(holder.title.trim().replace(/\s+/g, ' '))
-      const reason = match === null
-        ? 'no explainer separator (:, —, – or -) to drop'
-        : match.index === 0
-          ? 'dropping the explainer would leave an empty title'
-          : 'the title before the explainer still exceeds the cap'
+      const reason =
+        match === null
+          ? 'no explainer separator (:, —, – or -) to drop'
+          : match.index === 0
+            ? 'dropping the explainer would leave an empty title'
+            : 'the title before the explainer still exceeds the cap'
       trims.push({ outcome: 'unfixable', where, length: visibleLength(holder.title), cap, reason })
     }
   }

package/src/review/validate.ts

@@ -152,7 +152,11 @@ function checkLengths(output: ModelOutput, caps: TextCaps, report: Report): void
       f.folds?.forEach((fold, k) => {
         const where = `${at}.files.${j}.folds.${k}.title`
         if (fold.title.length > caps.pointTitle) {
-          report.add('TEXT_TOO_LONG', where, `${where}: ${fold.title.length} visible chars, cap ${caps.pointTitle}`)
+          report.add(
+            'TEXT_TOO_LONG',
+            where,
+            `${where}: ${fold.title.length} visible chars, cap ${caps.pointTitle}`
+          )
         }
       })
       f.annotations.forEach((a, k) => {
@@ -218,7 +222,11 @@ function checkHunks(output: ModelOutput, index: Index, report: Report): Map<stri
           continue
         }
         if (hit.file.path !== file.path) {
-          report.add('HUNK_UNKNOWN', where, `${layerLabel(layer)}: ${id} belongs to ${hit.file.path}, not ${file.path}`)
+          report.add(
+            'HUNK_UNKNOWN',
+            where,
+            `${layerLabel(layer)}: ${id} belongs to ${hit.file.path}, not ${file.path}`
+          )
           continue
         }
         const first = owner.get(id)
@@ -236,7 +244,11 @@ function checkHunks(output: ModelOutput, index: Index, report: Report): Map<stri
   }
   for (const { file, hunk } of index.byHunkId.values()) {
     if (!owner.has(hunk.id)) {
-      report.add('HUNK_UNASSIGNED', `hunk:${hunk.id}`, `${hunk.id} in ${file.path} (${hunk.header}) is in no layer`)
+      report.add(
+        'HUNK_UNASSIGNED',
+        `hunk:${hunk.id}`,
+        `${hunk.id} in ${file.path} (${hunk.header}) is in no layer`
+      )
     }
   }
   return owner
@@ -248,7 +260,11 @@ function checkLayers(output: ModelOutput, report: Report): void {
     const where = `layer:${layer.key}`
     const seen = keys.get(layer.key)
     if (seen !== undefined) {
-      report.add('LAYER_KEY_DUPLICATE', where, `layer ${i + 1}: key "${layer.key}" is also used by layer ${seen + 1}`)
+      report.add(
+        'LAYER_KEY_DUPLICATE',
+        where,
+        `layer ${i + 1}: key "${layer.key}" is also used by layer ${seen + 1}`
+      )
     } else {
       keys.set(layer.key, i)
     }
@@ -268,7 +284,11 @@ function checkLayers(output: ModelOutput, report: Report): void {
   }
   const last = output.layers[output.layers.length - 1]
   if (first !== undefined && first !== last) {
-    report.add('OTHER_NOT_LAST', `layer:${first.key}`, `layer ${first.key} (kind other) must be the last layer`)
+    report.add(
+      'OTHER_NOT_LAST',
+      `layer:${first.key}`,
+      `layer ${first.key} (kind other) must be the last layer`
+    )
   }
 }
 
@@ -308,7 +328,11 @@ function checkTests(
         continue
       }
       if (t.testPath === undefined) {
-        report.add('TEST_PATH_UNKNOWN', where, `${layerLabel(layer)}: "${t.behavior}" is covered but names no testPath`)
+        report.add(
+          'TEST_PATH_UNKNOWN',
+          where,
+          `${layerLabel(layer)}: "${t.behavior}" is covered but names no testPath`
+        )
       } else if (!(index.byPath.has(t.testPath) || headPaths.has(t.testPath))) {
         report.add('TEST_PATH_UNKNOWN', where, `${layerLabel(layer)}: ${t.testPath} is not in the PR head`)
       }
@@ -339,12 +363,20 @@ function checkRisk(output: ModelOutput, highRisk: readonly HighRiskRule[], repor
   }
   const where = `layer:${other.key}`
   for (const tag of other.risk ?? []) {
-    report.add('RISK_IN_OTHER', where, `other: carries the risk tag "${tag.label}"; move the hunks to a real layer`)
+    report.add(
+      'RISK_IN_OTHER',
+      where,
+      `other: carries the risk tag "${tag.label}"; move the hunks to a real layer`
+    )
   }
   for (const file of other.files) {
     const rule = highRisk.find(r => matchesGlob(r.pattern, file.path))
     if (rule !== undefined) {
-      report.add('RISK_IN_OTHER', where, `other: ${file.path} matches highRisk "${rule.pattern}" (${rule.label})`)
+      report.add(
+        'RISK_IN_OTHER',
+        where,
+        `other: ${file.path} matches highRisk "${rule.pattern}" (${rule.label})`
+      )
     }
   }
 }
@@ -368,9 +400,17 @@ function checkAnnotations(output: ModelOutput, index: Index, report: Report): vo
         const start = hunkAt(entry, a.side, a.startLine)
         const end = hunkAt(entry, a.side, a.endLine)
         if (start === null || end === null || start.id !== end.id) {
-          report.add('ANNOTATION_OUTSIDE_HUNK', where, `${label} is not inside one hunk of the diff (${hunkLineRanges(entry?.hunks ?? [], a.side)})`)
+          report.add(
+            'ANNOTATION_OUTSIDE_HUNK',
+            where,
+            `${label} is not inside one hunk of the diff (${hunkLineRanges(entry?.hunks ?? [], a.side)})`
+          )
         } else if (!file.hunks.includes(start.id)) {
-          report.add('ANNOTATION_OUTSIDE_HUNK', where, `${label} is in ${start.id}, which this layer does not list`)
+          report.add(
+            'ANNOTATION_OUTSIDE_HUNK',
+            where,
+            `${label} is in ${start.id}, which this layer does not list`
+          )
         }
       })
     }
@@ -378,7 +418,10 @@ function checkAnnotations(output: ModelOutput, index: Index, report: Report): vo
 }
 
 function checkPoints(output: ModelOutput, index: Index, limits: Limits, report: Report): void {
-  const missingTests = output.layers.reduce((n, l) => n + l.tests.filter(t => t.status === 'missing').length, 0)
+  const missingTests = output.layers.reduce(
+    (n, l) => n + l.tests.filter(t => t.status === 'missing').length,
+    0
+  )
   const total = output.points.length + missingTests
   if (total > limits.maxPoints) {
     report.add(
@@ -464,7 +507,12 @@ function checkLinks(output: ModelOutput, files: readonly FileEntry[], report: Re
  * The sidecar map of a layer's diagram: each key names a node of the mermaid source, each value
  * is a canvas link, and a diagram carries at most `maxDiagramLinks` of them.
  */
-function checkDiagramLinks(output: ModelOutput, files: readonly FileEntry[], limits: Limits, report: Report): void {
+function checkDiagramLinks(
+  output: ModelOutput,
+  files: readonly FileEntry[],
+  limits: Limits,
+  report: Report
+): void {
   const targets: LinkTargets = { layers: output.layers, files }
   for (const layer of output.layers) {
     if (layer.diagram === undefined) {
@@ -474,7 +522,11 @@ function checkDiagramLinks(output: ModelOutput, files: readonly FileEntry[], lim
     const label = `${layerLabel(layer)} diagram`
     const entries = Object.entries(layer.diagram.links)
     if (entries.length > limits.maxDiagramLinks) {
-      report.add('DIAGRAM_LIMIT', where, `${label}: ${entries.length} node links, at most ${limits.maxDiagramLinks}`)
+      report.add(
+        'DIAGRAM_LIMIT',
+        where,
+        `${label}: ${entries.length} node links, at most ${limits.maxDiagramLinks}`
+      )
     }
     const kind = diagramKind(layer.diagram.mermaid)
     const nodes = diagramNodeIds(layer.diagram.mermaid)

package/src/server/app.ts

@@ -1,7 +1,7 @@
 import { type Context, Hono } from 'hono'
 import type { AppContext } from './context.js'
 import type { AppEnv } from './env.js'
-import { AppError, toAppError } from './errors.js'
+import { AppError, logRequestError, toAppError } from './errors.js'
 import { errorPage } from './html.js'
 import { apiRoutes } from './routes/api.js'
 import { appearanceFor, appearanceQuery, pageRoutes } from './routes/pages.js'
@@ -29,14 +29,22 @@ export function createApp(ctx: AppContext): Hono<AppEnv> {
     const nonce = c.get('cspNonce') ?? createNonce()
     const res = wantsJson(c.req.path)
       ? c.json(envelope, err.status)
-      : await c.html(errorPage(envelope.error, nonce, await appearanceFor(ctx, appearanceQuery(c))), err.status)
+      : await c.html(
+          errorPage(envelope.error, nonce, await appearanceFor(ctx, appearanceQuery(c))),
+          err.status
+        )
     applyResponseHeaders(res, c.req.path, nonce)
     return res
   }
 
-  app.onError((err, c) => errorResponse(c, toAppError(err)))
+  app.onError((err, c) => {
+    logRequestError(ctx.log, c.req, err)
+    return errorResponse(c, toAppError(err))
+  })
 
-  app.notFound(c => errorResponse(c, new AppError('NOT_FOUND', `no route for ${c.req.method} ${c.req.path}`, 404)))
+  app.notFound(c =>
+    errorResponse(c, new AppError('NOT_FOUND', `no route for ${c.req.method} ${c.req.path}`, 404))
+  )
 
   app.route('/api', apiRoutes(ctx))
   app.route('/', staticRoutes(ctx))

package/src/server/bundle.ts

@@ -45,7 +45,11 @@ export async function runDiscovery(
     checkedAt: ctx.now().toISOString(),
     sharedCanvas: outcome.sharedCanvas,
   })
-  return { sharedCanvas: outcome.sharedCanvas, imported: outcome.imported !== null, warnings: outcome.warnings }
+  return {
+    sharedCanvas: outcome.sharedCanvas,
+    imported: outcome.imported !== null,
+    warnings: outcome.warnings,
+  }
 }
 
 /**
@@ -55,7 +59,9 @@ export async function runDiscovery(
 export function createPrLoader(ctx: AppContext) {
   const refreshed = new Set<number>()
 
-  async function refreshPr(number: number): Promise<{ pr: Pr; comments: CommentsPayload; warnings: string[] }> {
+  async function refreshPr(
+    number: number
+  ): Promise<{ pr: Pr; comments: CommentsPayload; warnings: string[] }> {
     const meta = await fetchPrMeta(ctx.gh, ctx.config.repo, number)
     const shas = await fetchPrRefs(ctx.git, meta)
     const pr = toPr(meta, ctx.config.repo, shas)
@@ -225,11 +231,18 @@ export async function resolveBundle(
   const shared = sharedCanvas === null ? {} : { sharedCanvas }
 
   if (found.status === 'missing') {
-    return { ...base, ...shared, status: 'missing', skillCommand: buildSkillCommand(number, { force: false }) }
+    return {
+      ...base,
+      ...shared,
+      status: 'missing',
+      skillCommand: buildSkillCommand(number, { force: false }),
+    }
   }
   const loaded = await loadCanvas(ctx, found)
   if (loaded === null) {
-    allWarnings.push(`the canvas for ${found.headSha.slice(0, 7)} does not match the current format; regenerate it`)
+    allWarnings.push(
+      `the canvas for ${found.headSha.slice(0, 7)} does not match the current format; regenerate it`
+    )
     return { ...base, ...shared, status: 'missing', skillCommand: buildSkillCommand(number, { force: true }) }
   }
   // A canvas exists for this PR, so regenerating always needs --force.

package/src/server/context.ts

@@ -36,6 +36,7 @@ export interface VendorRoots {
  * `createAppContext`; tests assemble their own with fakes and a temp data dir.
  */
 export interface AppContext {
+  log: (line: string) => void
   config: RuntimeConfig
   projectConfig: LoadedProjectConfig
   git: Git
@@ -72,7 +73,11 @@ export function resolveVendorRoots(): VendorRoots {
     diff: path.dirname(fileURLToPath(import.meta.resolve('diff'))),
     marked: fileURLToPath(import.meta.resolve('marked')),
     dompurify: fileURLToPath(import.meta.resolve('dompurify')),
-    hljs: path.join(path.dirname(require.resolve('@highlightjs/cdn-assets/package.json')), 'es', 'highlight.min.js'),
+    hljs: path.join(
+      path.dirname(require.resolve('@highlightjs/cdn-assets/package.json')),
+      'es',
+      'highlight.min.js'
+    ),
     mermaid: path.dirname(fileURLToPath(import.meta.resolve('mermaid'))),
   }
 }
@@ -158,13 +163,20 @@ export function createAppContext(opts: CreateAppContextOptions): AppContext {
   const stores = createStores(opts.config.dataDir, opts.config, git, now)
   return {
     config: opts.config,
+    log: line => process.stderr.write(`${line}\n`),
     projectConfig: opts.projectConfig,
     git,
     gh,
     capabilities: createCapabilityProbe(gh, opts.config.repo, now),
     fetch: opts.fetch ?? ((input, init) => globalThis.fetch(input, init)),
     ...stores,
-    ...createChatSet(opts.config, opts.runner ?? createAgentRunner(), stores, now, opts.projectConfig.config.prompts),
+    ...createChatSet(
+      opts.config,
+      opts.runner ?? createAgentRunner(),
+      stores,
+      now,
+      opts.projectConfig.config.prompts
+    ),
     now,
     version: readPackageVersion(),
     staticDir: STATIC_DIR,

package/src/server/errors.ts

@@ -1,3 +1,4 @@
+import { inspect } from 'node:util'
 import type { ContentfulStatusCode } from 'hono/utils/http-status'
 import { ConfigError } from '../config.js'
 import type { ErrorCode, ErrorEnvelope } from '../contract/api.js'
@@ -12,7 +13,13 @@ export class AppError extends Error {
   /** What a rejected file got wrong, one line each. Never the file's content. */
   readonly issues: string[] | undefined
 
-  constructor(code: ErrorCode, message: string, status: ContentfulStatusCode, hint?: string, issues?: string[]) {
+  constructor(
+    code: ErrorCode,
+    message: string,
+    status: ContentfulStatusCode,
+    hint?: string,
+    issues?: string[]
+  ) {
     super(message)
     this.name = 'AppError'
     this.code = code
@@ -39,7 +46,12 @@ export function toAppError(err: unknown): AppError {
     return err
   }
   if (err instanceof PrNotFoundError) {
-    return new AppError('PR_NOT_FOUND', err.message, 404, 'check the number and that origin is the right repository')
+    return new AppError(
+      'PR_NOT_FOUND',
+      err.message,
+      404,
+      'check the number and that origin is the right repository'
+    )
   }
   if (err instanceof GitHubApiError) {
     if (err.missingBinary) {
@@ -63,3 +75,15 @@ export function toAppError(err: unknown): AppError {
   }
   return new AppError('INTERNAL', err instanceof Error ? err.message : String(err), 500)
 }
+
+/** Keep the original error and its causes in the server log, before response mapping loses the stack. */
+export function logRequestError(
+  log: (line: string) => void,
+  request: { method: string; path: string },
+  err: unknown
+): void {
+  const mapped = toAppError(err)
+  if (mapped.status >= 500) {
+    log(`[serve] ${request.method} ${request.path} ${mapped.status} ${mapped.code}\n${inspect(err)}`)
+  }
+}

package/src/server/html.ts

@@ -96,7 +96,7 @@ export function homePage(
     app: false,
     body: html`<div class="page">
 <header class="hdr">
-<div class="hdr-bar"><div class="brand"><span class="box">PR review canvas</span><span class="mono muted">localhost:${String(data.port)}</span></div>
+<div class="hdr-bar"><div class="brand"><span class="brand-wordmark"><img class="brand-icon" src="/static/brand.svg" width="32" height="32" alt="">PR review canvas</span><span class="mono muted">localhost:${String(data.port)}</span></div>
 <div class="hdr-actions"><a class="cmd" href="/api/health">health</a></div></div>
 <div class="stripe" aria-hidden="true"></div>
 <div class="hdr-title"><div class="title"><h1>${data.owner}/${data.repo}</h1></div>
@@ -132,7 +132,7 @@ export function errorPage(error: ErrorEnvelope['error'], nonce: string, appearan
     appearance,
     app: false,
     body: html`<div class="page"><header class="hdr">
-<div class="hdr-bar"><div class="brand"><span class="box">PR review canvas</span></div><div class="hdr-actions"><a class="cmd" href="/">home</a></div></div>
+<div class="hdr-bar"><div class="brand"><span class="brand-wordmark"><img class="brand-icon" src="/static/brand.svg" width="32" height="32" alt="">PR review canvas</span></div><div class="hdr-actions"><a class="cmd" href="/">home</a></div></div>
 <div class="stripe" aria-hidden="true"></div></header>
 <main id="main" class="home"><section class="panel error-card"><div class="panel-h"><h2><span class="mono">${error.code}</span></h2></div>
 <div class="body"><p>${error.message}</p>${error.hint ? html`<p class="muted">${error.hint}</p>` : ''}</div></section></main></div>`,

package/src/server/node-server.ts

@@ -4,9 +4,11 @@ import type { AppContext } from './context.js'
 
 /** Binds 127.0.0.1 only. The Host allowlist in security.ts covers the rest. */
 export function startServer(ctx: AppContext, log: (line: string) => void): { close: () => void } {
-  const app = createApp(ctx)
+  const app = createApp({ ...ctx, log })
   const server = serve({ fetch: app.fetch, port: ctx.config.port, hostname: '127.0.0.1' }, info => {
-    log(`pr-review ${ctx.version} · http://localhost:${info.port}/ · ${ctx.config.repo.owner}/${ctx.config.repo.name}`)
+    log(
+      `pr-review ${ctx.version} · http://localhost:${info.port}/ · ${ctx.config.repo.owner}/${ctx.config.repo.name}`
+    )
     log(`data dir ${ctx.config.dataDir}`)
     if (ctx.fixtureArtifact !== null) {
       log(`fixture canvas ${ctx.config.fixtureCanvasPath ?? ''} (dev only): every PR reports ready`)

package/src/server/routes/api.ts

@@ -3,7 +3,12 @@ import { z } from 'zod'
 import { buildCanvasZipFor } from '../../canvas/export.js'
 import { importCanvas } from '../../canvas/import.js'
 import { CANVAS_ZIP_MAX_BYTES } from '../../canvas/zip.js'
-import type { ContextResponse, HealthResponse, PatchesResponse, SharedCanvasFetchResponse } from '../../contract/api.js'
+import type {
+  ContextResponse,
+  HealthResponse,
+  PatchesResponse,
+  SharedCanvasFetchResponse,
+} from '../../contract/api.js'
 import { AppearanceInputSchema, type AppearanceResponse } from '../../contract/settings.js'
 import { createPrLoader, resolveBundle, runDiscovery } from '../bundle.js'
 import { BodyTooLargeError, readCappedBody } from '../capped-body.js'
@@ -87,7 +92,10 @@ export function apiRoutes(ctx: AppContext): Hono {
 
   // How the page is painted. It lives in the same settings file the chat settings do, but on its
   // own route, because a repository with chat off still has a page to paint.
-  const appearanceOf = (settings: { skin: AppearanceResponse['skin']; theme: AppearanceResponse['theme'] }) => ({
+  const appearanceOf = (settings: {
+    skin: AppearanceResponse['skin']
+    theme: AppearanceResponse['theme']
+  }) => ({
     skin: settings.skin,
     theme: settings.theme,
   })
@@ -197,11 +205,23 @@ export function apiRoutes(ctx: AppContext): Hono {
       throw new AppError('BAD_REQUEST', `request between 1 and ${CONTEXT_MAX_LINES} lines`, 400)
     }
     const pr = await loader.currentPr(number)
-    const lines = await ctx.derived.readLines(pr.headSha, q.side === 'new' ? 'head' : 'base', q.path, q.from, q.to)
+    const lines = await ctx.derived.readLines(
+      pr.headSha,
+      q.side === 'new' ? 'head' : 'base',
+      q.path,
+      q.from,
+      q.to
+    )
     if (lines === null) {
       throw new AppError('NOT_FOUND', `${q.path} is not materialized for this head`, 404)
     }
-    const body: ContextResponse = { path: q.path, side: q.side, from: q.from, to: q.from + lines.length - 1, lines }
+    const body: ContextResponse = {
+      path: q.path,
+      side: q.side,
+      from: q.from,
+      to: q.from + lines.length - 1,
+      lines,
+    }
     return c.json(body)
   })
 
@@ -226,7 +246,11 @@ export function apiRoutes(ctx: AppContext): Hono {
       throw new AppError('BAD_REQUEST', 'send the zip as the multipart field `file`', 400)
     }
     if (file.size > CANVAS_ZIP_MAX_BYTES) {
-      throw new AppError('CANVAS_TOO_LARGE', `the canvas zip is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`, 413)
+      throw new AppError(
+        'CANVAS_TOO_LARGE',
+        `the canvas zip is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`,
+        413
+      )
     }
     const result = await importCanvas(ctx, {
       bytes: new Uint8Array(await file.arrayBuffer()),

package/src/server/routes/chat-routes.ts

@@ -12,14 +12,18 @@ import type { SettingsResponse } from '../../contract/settings.js'
 import { isChatAgent, SettingsInputSchema } from '../../contract/settings.js'
 import type { PrLoader } from '../bundle.js'
 import type { AppContext } from '../context.js'
-import { AppError } from '../errors.js'
+import { AppError, logRequestError } from '../errors.js'
 import { SSE_HEADERS, sseStream } from '../sse.js'
 import { parsePrNumber } from './api.js'
 
 async function readJsonBody<T>(
   request: Request,
   schema: {
-    safeParse: (raw: unknown) => { success: boolean; data?: T; error?: { issues: Array<{ message: string }> } }
+    safeParse: (raw: unknown) => {
+      success: boolean
+      data?: T
+      error?: { issues: Array<{ message: string }> }
+    }
   },
   expected: string
 ): Promise<T> {
@@ -106,7 +110,9 @@ export function chatRoutes(ctx: AppContext, loader: PrLoader): Hono {
     return c.json(settingsResponse(ctx, await ctx.settings.write(input)))
   })
 
-  api.get('/settings/agents', async c => c.json(await ctx.agents.list({ refresh: c.req.query('refresh') === '1' })))
+  api.get('/settings/agents', async c =>
+    c.json(await ctx.agents.list({ refresh: c.req.query('refresh') === '1' }))
+  )
 
   api.post('/settings/agents/:id/probe', async c => {
     const id = c.req.param('id')
@@ -141,7 +147,11 @@ export function chatRoutes(ctx: AppContext, loader: PrLoader): Hono {
 
   api.post('/prs/:n/chat', async c => {
     const number = parsePrNumber(c.req.param('n'))
-    const input = await readJsonBody(c.req.raw, ChatSendSchema, '{ "message": "…", "context": { "kind": "pr" } }')
+    const input = await readJsonBody(
+      c.req.raw,
+      ChatSendSchema,
+      '{ "message": "…", "context": { "kind": "pr" } }'
+    )
     const pr = await loader.currentPr(number)
     const artifact = await artifactForChat(ctx, number, pr)
     const derived = await ctx.derived.read(pr.headSha)
@@ -176,9 +186,14 @@ export function chatRoutes(ctx: AppContext, loader: PrLoader): Hono {
     }
     // A browser that goes away stops the agent; the turn is nobody's answer any more.
     return new Response(
-      sseStream(replayFrom(first, iterator), undefined, () => {
-        void ctx.chat.cancel(number)
-      }),
+      sseStream(
+        replayFrom(first, iterator),
+        undefined,
+        () => {
+          void ctx.chat.cancel(number)
+        },
+        err => logRequestError(ctx.log, c.req, err)
+      ),
       { headers: SSE_HEADERS }
     )
   })
@@ -190,7 +205,10 @@ export function chatRoutes(ctx: AppContext, loader: PrLoader): Hono {
  * The turn as a stream again, after its first event was read to see whether the route can answer
  * with a stream at all. A turn that ended on that first read is an empty stream.
  */
-export function replayFrom(first: IteratorResult<ChatEvent>, rest: AsyncIterator<ChatEvent>): AsyncIterable<ChatEvent> {
+export function replayFrom(
+  first: IteratorResult<ChatEvent>,
+  rest: AsyncIterator<ChatEvent>
+): AsyncIterable<ChatEvent> {
   let sent = first.done === true
   return {
     [Symbol.asyncIterator]: () => ({
@@ -217,5 +235,8 @@ export function toChatError(err: unknown): AppError {
   if (err instanceof ChatContextError) {
     return new AppError('BAD_REQUEST', err.message, 400)
   }
-  return err instanceof AppError ? err : new AppError('INTERNAL', err instanceof Error ? err.message : String(err), 500)
+  if (err instanceof AppError) return err
+  const error = new AppError('INTERNAL', err instanceof Error ? err.message : String(err), 500)
+  error.cause = err
+  return error
 }

package/src/server/routes/pages.ts

@@ -12,7 +12,9 @@ export async function appearanceFor(ctx: AppContext, query: AppearanceQuery): Pr
 }
 
 /** The `?skin` and `?theme` of one request, which pick an appearance for that load alone. */
-export function appearanceQuery(c: { req: { query: (name: string) => string | undefined } }): AppearanceQuery {
+export function appearanceQuery(c: {
+  req: { query: (name: string) => string | undefined }
+}): AppearanceQuery {
   return { skin: c.req.query('skin'), theme: c.req.query('theme') }
 }
 

package/src/server/routes/review-routes.ts

@@ -91,7 +91,10 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
     }
   }
 
-  const stateBody = (number: number, state: StateResponse['state']): StateResponse => ({ prNumber: number, state })
+  const stateBody = (number: number, state: StateResponse['state']): StateResponse => ({
+    prNumber: number,
+    state,
+  })
 
   api.get('/prs/:n/state', async c => {
     const number = parsePrNumber(c.req.param('n'))
@@ -102,7 +105,12 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
     const number = parsePrNumber(c.req.param('n'))
     const id = c.req.param('id')
     if (!isReviewedId(id)) {
-      throw new AppError('BAD_REQUEST', `not a reviewed id: ${id}`, 400, 'use layer:<id> or layer:<id>/file:<key>')
+      throw new AppError(
+        'BAD_REQUEST',
+        `not a reviewed id: ${id}`,
+        400,
+        'use layer:<id> or layer:<id>/file:<key>'
+      )
     }
     const body = await readBody(c.req.raw, ReviewedBodySchema, '{ "reviewed": true }')
     const pr = await loader.currentPr(number)
@@ -223,7 +231,11 @@ function appendComment(ctx: AppContext, number: number, posted: PostCommentResul
  * Keeps the cached comments in step with what was just posted, so a reload shows it once. With
  * nothing cached there is nothing to keep in step: the next read fetches the list from GitHub.
  */
-async function writeAppendedComment(ctx: AppContext, number: number, posted: PostCommentResult): Promise<void> {
+async function writeAppendedComment(
+  ctx: AppContext,
+  number: number,
+  posted: PostCommentResult
+): Promise<void> {
   const comments = await ctx.prs.readComments(number)
   if (comments === null) {
     return
@@ -241,5 +253,8 @@ async function writeAppendedComment(ctx: AppContext, number: number, posted: Pos
   if (comments.issueComments.some(c => c.id === posted.comment.id)) {
     return
   }
-  await ctx.prs.writeComments(number, { ...comments, issueComments: [...comments.issueComments, posted.comment] })
+  await ctx.prs.writeComments(number, {
+    ...comments,
+    issueComments: [...comments.issueComments, posted.comment],
+  })
 }

package/src/server/sse.ts

@@ -28,7 +28,8 @@ export function sseFrame(event: ChatEvent): string {
 export function sseStream(
   events: AsyncIterable<ChatEvent>,
   onClose?: () => void,
-  onCancel?: () => void
+  onCancel?: () => void,
+  onError?: (err: unknown) => void
 ): ReadableStream<Uint8Array> {
   const encoder = new TextEncoder()
   const iterator = events[Symbol.asyncIterator]()
@@ -38,6 +39,7 @@ export function sseStream(
       try {
         next = await iterator.next()
       } catch (err) {
+        onError?.(err)
         controller.enqueue(
           encoder.encode(
             sseFrame({

package/src/store/atomic-json.ts

@@ -37,7 +37,11 @@ export async function readJson<T>(file: string, schema: z.ZodType<T>): Promise<T
  * Like readJson, but a missing file, invalid JSON, or a shape the schema rejects all return
  * `fallback()`. Other read errors still throw.
  */
-export async function readJsonOrDefault<T, D>(file: string, schema: z.ZodType<T>, fallback: () => D): Promise<T | D> {
+export async function readJsonOrDefault<T, D>(
+  file: string,
+  schema: z.ZodType<T>,
+  fallback: () => D
+): Promise<T | D> {
   const text = await readText(file)
   if (text === null) {
     return fallback()