@vintasoftware/pr-review-canvas 0.2.0 → 0.4.0

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

@@ -10,16 +10,23 @@ import { ChatSendSchema } from '../../contract/chat.js'
 import type { Pr, ReviewArtifact } from '../../contract/review-artifact.js'
 import type { SettingsResponse } from '../../contract/settings.js'
 import { isChatAgent, SettingsInputSchema } from '../../contract/settings.js'
+import { lookupCanvas } from '../../review/carry-over.js'
+import type { Derived } from '../../store/derived-store.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'
+import { isLocalKey, type ReviewKey } from '../../contract/review-key.js'
+import { parseTargetKey } 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> {
@@ -49,28 +56,72 @@ function settingsResponse(ctx: AppContext, settings: SettingsResponse['settings'
       maxRepairRounds: project.generation.maxRepairRounds,
       inlineDiffMaxLines: project.generation.inlineDiffMaxLines,
       smallPrHunks: project.generation.smallPrHunks,
+      keepForIdenticalDiff: project.canvas.keepForIdenticalDiff,
       layers: project.layers.length,
       highRisk: project.highRisk.length,
     },
   }
 }
 
-/** The canvas the chat talks about: the one written for the pull request's current head. */
-async function artifactForChat(ctx: AppContext, number: number, pr: Pr): Promise<ReviewArtifact> {
+/** What the chat talks about: the canvas on screen, and the diff that canvas is shown with. */
+interface ChatSubject {
+  artifact: ReviewArtifact
+  /** The head for a current canvas; the canvas's own commit for an outdated one, as the page shows it. */
+  headSha: string
+  files: Derived['files']
+  patches: Derived['patches']
+}
+
+/**
+ * The canvas the chat talks about. A current canvas is read with the head's diff. An outdated one
+ * is still a canvas: the page shows it with the diff of its own commit, so the chat quotes that.
+ */
+async function subjectForChat(ctx: AppContext, key: ReviewKey, pr: Pr): Promise<ChatSubject> {
   if (ctx.fixtureArtifact !== null) {
-    return { ...ctx.fixtureArtifact, pr }
+    return withDiff({ ...ctx.fixtureArtifact, pr }, pr.headSha, await ctx.derived.read(pr.headSha))
   }
-  const found = await ctx.canvases.findForPr(number, pr.headSha)
-  const artifact = found.status === 'ready' ? await ctx.canvases.readArtifact(found.headSha) : null
-  if (artifact === null) {
+  const found = isLocalKey(key)
+    ? await ctx.canvases.findForLocal(key, pr.headSha)
+    : await lookupCanvas(ctx, key, pr)
+  const artifact = found.status === 'missing' ? null : await ctx.canvases.readArtifact(found.headSha)
+  if (found.status === 'missing' || artifact === null) {
     throw new AppError(
       'CANVAS_NOT_FOUND',
-      'there is no canvas for this commit, so the chat has nothing to talk about',
+      'there is no canvas for this pull request, so the chat has nothing to talk about',
       404,
       'generate a canvas for the current head first'
     )
   }
-  return artifact
+  if (found.status === 'stale') {
+    // The diff is the canvas's own commit's, so the stored artifact, which names that commit,
+    // is already the one that describes it.
+    const manifest = await ctx.canvases.readManifest(found.headSha)
+    return withDiff(
+      artifact,
+      found.headSha,
+      await ctx.derived.readOrBuild(found.headSha, manifest?.mergeBaseSha)
+    )
+  }
+  // A carried-over canvas was generated for an earlier commit but is read with the head's diff,
+  // so the live pull request is stamped on it: the seed's header names the commit whose diff the
+  // agent is given, with that commit's file and line counts.
+  return withDiff({ ...artifact, pr }, pr.headSha, await ctx.derived.read(pr.headSha))
+}
+
+/**
+ * The subject with its diff, or the 404 that says the diff is not on this machine. The artifact
+ * passed in names `headSha` as its own commit, so the seed header and the diff agree.
+ */
+function withDiff(artifact: ReviewArtifact, headSha: string, derived: Derived | null): ChatSubject {
+  if (derived === null) {
+    throw new AppError(
+      'NOT_FOUND',
+      'the diff of this head is not available locally, so the chat cannot quote it',
+      404,
+      'fetch the PR head and reload'
+    )
+  }
+  return { artifact, headSha, files: derived.files, patches: derived.patches }
 }
 
 /** Every path this file serves, so the chat-disabled check covers all of them and nothing else. */
@@ -106,7 +157,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')
@@ -116,52 +169,47 @@ export function chatRoutes(ctx: AppContext, loader: PrLoader): Hono {
     return c.json(await ctx.agents.probe(id, { refresh: c.req.query('refresh') === '1' }))
   })
 
-  api.get('/prs/:n/chat/threads', async c => c.json(await ctx.chat.threads(parsePrNumber(c.req.param('n')))))
+  api.get('/prs/:n/chat/threads', async c => c.json(await ctx.chat.threads(parseTargetKey(c.req.param('n')))))
 
   api.post('/prs/:n/chat/threads', async c => {
-    const number = parsePrNumber(c.req.param('n'))
-    const thread = await ctx.chat.createThread(number)
-    return c.json({ thread, ...(await ctx.chat.threads(number)) }, 201)
+    const key = parseTargetKey(c.req.param('n'))
+    const thread = await ctx.chat.createThread(key)
+    return c.json({ thread, ...(await ctx.chat.threads(key)) }, 201)
   })
 
   api.get('/prs/:n/chat/threads/:name/history', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const key = parseTargetKey(c.req.param('n'))
     const name = c.req.param('name')
-    if (!isThreadNameFor(name, number)) {
-      throw new AppError('NOT_FOUND', `no chat thread named ${name} on this pull request`, 404)
+    if (!isThreadNameFor(name, key)) {
+      throw new AppError('NOT_FOUND', `no chat thread named ${name} on this review`, 404)
     }
-    const body: ChatHistoryResponse = { name, turns: await ctx.transcripts.read(number, name) }
+    const body: ChatHistoryResponse = { name, turns: await ctx.transcripts.read(key, name) }
     return c.json(body)
   })
 
   api.post('/prs/:n/chat/cancel', async c => {
-    const number = parsePrNumber(c.req.param('n'))
-    return c.json({ cancelled: await ctx.chat.cancel(number) })
+    const key = parseTargetKey(c.req.param('n'))
+    return c.json({ cancelled: await ctx.chat.cancel(key) })
   })
 
   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 pr = await loader.currentPr(number)
-    const artifact = await artifactForChat(ctx, number, pr)
-    const derived = await ctx.derived.read(pr.headSha)
-    if (derived === null) {
-      throw new AppError(
-        'NOT_FOUND',
-        'the diff of this head is not available locally, so the chat cannot quote it',
-        404,
-        'fetch the PR head and reload'
-      )
-    }
+    const key = parseTargetKey(c.req.param('n'))
+    const input = await readJsonBody(
+      c.req.raw,
+      ChatSendSchema,
+      '{ "message": "…", "context": { "kind": "pr" } }'
+    )
+    const pr = await loader.currentTarget(key)
+    const { artifact, headSha, files, patches } = await subjectForChat(ctx, key, pr)
     const events = ctx.chat.send(
       {
-        prNumber: number,
-        headSha: pr.headSha,
+        key,
+        headSha,
         artifact,
-        files: derived.files,
-        patches: derived.patches,
-        derivedDir: ctx.derived.derivedDir(pr.headSha),
-        readLines: (side, filePath, from, to) => ctx.derived.readLines(pr.headSha, side, filePath, from, to),
+        files,
+        patches,
+        derivedDir: ctx.derived.derivedDir(headSha),
+        readLines: (side, filePath, from, to) => ctx.derived.readLines(headSha, side, filePath, from, to),
       },
       { message: input.message, context: input.context, thread: input.thread }
     )
@@ -176,9 +224,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(key)
+        },
+        err => logRequestError(ctx.log, c.req, err)
+      ),
       { headers: SSE_HEADERS }
     )
   })
@@ -190,7 +243,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 +273,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

@@ -3,8 +3,8 @@ import { type Appearance, type AppearanceQuery, appearanceForRequest } from '../
 import type { AppContext } from '../context.js'
 import type { AppEnv } from '../env.js'
 import { AppError } from '../errors.js'
+import { LOCAL_KEYS, parseReviewKey } from '../../contract/review-key.js'
 import { homePage, reviewPage } from '../html.js'
-import { parsePrNumber } from './api.js'
 
 /** How the page is painted, rendered onto the tag so nothing flashes before the app module runs. */
 export async function appearanceFor(ctx: AppContext, query: AppearanceQuery): Promise<Appearance> {
@@ -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') }
 }
 
@@ -20,15 +22,20 @@ export function pageRoutes(ctx: AppContext): Hono<AppEnv> {
   const app = new Hono<AppEnv>()
 
   app.get('/', async c => {
-    const recentPrs = await ctx.prs.listRecent(10)
+    const [recentPrs, ...localPrs] = await Promise.all([
+      ctx.prs.listRecent(10),
+      ...LOCAL_KEYS.map(key => ctx.prs.readPr(key)),
+    ])
     return c.html(
       homePage(
         {
           recentPrs,
+          localReviews: LOCAL_KEYS.filter((_, i) => localPrs[i] !== null && localPrs[i] !== undefined),
           owner: ctx.config.repo.owner,
           repo: ctx.config.repo.name,
           version: ctx.version,
           port: ctx.config.port,
+          host: ctx.config.host,
         },
         c.get('cspNonce'),
         await appearanceFor(ctx, appearanceQuery(c))
@@ -45,15 +52,24 @@ export function pageRoutes(ctx: AppContext): Hono<AppEnv> {
 
   app.get('/review/:n', async c => {
     const raw = c.req.param('n')
-    let prNumber: number
-    try {
-      prNumber = parsePrNumber(raw)
-    } catch {
-      throw new AppError('BAD_REQUEST', `"${raw}" is not a pull request number`, 400, 'use /review/<number>')
+    const prNumber = parseReviewKey(raw)
+    if (prNumber === null) {
+      throw new AppError(
+        'BAD_REQUEST',
+        `"${raw}" is not a review target`,
+        400,
+        'use /review/<number>, /review/branch, or /review/uncommitted'
+      )
     }
     return c.html(
       reviewPage(
-        { prNumber, owner: ctx.config.repo.owner, repo: ctx.config.repo.name, version: ctx.version },
+        {
+          prNumber,
+          owner: ctx.config.repo.owner,
+          repo: ctx.config.repo.name,
+          version: ctx.version,
+          host: ctx.config.host,
+        },
         c.get('cspNonce'),
         await appearanceFor(ctx, appearanceQuery(c))
       )

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

@@ -4,14 +4,19 @@ import { z } from 'zod'
 import type { ReviewBodyResponse, StateResponse } from '../../contract/api.js'
 import { PostCommentInputSchema, type PostCommentResult } from '../../contract/comments.js'
 import type { Pr, ReviewArtifact } from '../../contract/review-artifact.js'
-import { checkInlineTarget, postComment } from '../../github/post-comment.js'
-import { PostReviewInputSchema, postReview } from '../../github/post-review.js'
-import { buildReviewBody, stateForHead, unreviewedLayers } from '../../github/review-body.js'
+import type { PrState } from '../../contract/state.js'
+import { checkInlineTarget } from '../../git/patch-lines.js'
+import { PostReviewInputSchema } from '../../contract/reviews.js'
+import { lookupCanvas } from '../../review/carry-over.js'
+import { buildReviewBody, stateForCanvas, unreviewedLayers } from '../../review/review-body.js'
+import { isLocalKey, keyLabel, type ReviewKey } from '../../contract/review-key.js'
+import { canvasBelongsTo } from '../../store/canvas-store.js'
 import { isReviewedId } from '../../store/state-store.js'
-import type { PrLoader } from '../bundle.js'
+import type { Derived } from '../../store/derived-store.js'
+import { LOCAL_CAPABILITIES, type PrLoader } from '../bundle.js'
 import type { AppContext } from '../context.js'
 import { AppError } from '../errors.js'
-import { parsePrNumber } from './api.js'
+import { parseTargetKey, requirePrNumber } from './api.js'
 
 const ReviewedBodySchema = z.object({
   reviewed: z.boolean(),
@@ -20,6 +25,14 @@ const ReviewedBodySchema = z.object({
     .string()
     .regex(/^[0-9a-f]{40}$/)
     .optional(),
+  /**
+   * The commit of the canvas on the page, which the marks are keyed to. The head when absent. Any
+   * other value must be a canvas indexed for this pull request.
+   */
+  canvasSha: z
+    .string()
+    .regex(/^[0-9a-f]{40}$/)
+    .optional(),
 })
 const DismissedBodySchema = z.object({ dismissed: z.boolean(), reason: z.string().max(500).optional() })
 const HiddenBodySchema = z.object({ hidden: z.boolean() })
@@ -54,12 +67,34 @@ async function readBody<T>(request: Request, schema: z.ZodType<T>, expected: str
   return parsed.data
 }
 
-/** The canvas the reviewer is signing off on: the one written for the pull request's head. */
-async function artifactForHead(ctx: AppContext, number: number, pr: Pr): Promise<ReviewArtifact> {
+/** Refuses a commit that is not an indexed canvas of this target. */
+async function requireCanvasOf(ctx: AppContext, key: ReviewKey, canvasSha: string): Promise<void> {
+  const entry = (await ctx.canvases.readIndex()).canvases[canvasSha]
+  // The same rule the lookups use, so a mark can only be keyed to a canvas this target shows.
+  if (entry === undefined || !canvasBelongsTo(entry, key)) {
+    throw new AppError(
+      'CANVAS_NOT_FOUND',
+      `${canvasSha.slice(0, 7)} is not a canvas of ${keyLabel(key)}`,
+      404,
+      'reload the page'
+    )
+  }
+}
+
+/**
+ * The canvas the reviewer is signing off on, with the marks made on it: the canvas written for the
+ * pull request's head, or for another commit with an identical diff.
+ */
+async function canvasForSignOff(
+  ctx: AppContext,
+  number: number,
+  pr: Pr
+): Promise<{ artifact: ReviewArtifact; state: PrState }> {
+  const stored = await ctx.state.read(number)
   if (ctx.fixtureArtifact !== null) {
-    return { ...ctx.fixtureArtifact, pr }
+    return { artifact: { ...ctx.fixtureArtifact, pr }, state: stateForCanvas(stored, pr.headSha) }
   }
-  const found = await ctx.canvases.findForPr(number, pr.headSha)
+  const found = await lookupCanvas(ctx, number, pr)
   if (found.status !== 'ready') {
     throw new AppError(
       'SIGNOFF_INCOMPLETE',
@@ -72,7 +107,7 @@ async function artifactForHead(ctx: AppContext, number: number, pr: Pr): Promise
   if (artifact === null) {
     throw new AppError('CANVAS_NOT_FOUND', `no canvas for pull request ${number}`, 404, 'generate one first')
   }
-  return artifact
+  return { artifact, state: stateForCanvas(stored, found.headSha) }
 }
 
 export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
@@ -84,42 +119,60 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
     if (caps.canComment === false) {
       throw new AppError(
         'COMMENT_FORBIDDEN',
-        caps.reason ?? 'this GitHub login cannot post on this repository',
+        caps.reason ?? `this ${ctx.config.host.label} login cannot post on this repository`,
         403,
         caps.hint
       )
     }
   }
 
-  const stateBody = (number: number, state: StateResponse['state']): StateResponse => ({ prNumber: number, state })
+  const stateBody = (key: ReviewKey, state: StateResponse['state']): StateResponse => ({
+    prNumber: key,
+    state,
+  })
 
   api.get('/prs/:n/state', async c => {
-    const number = parsePrNumber(c.req.param('n'))
-    return c.json(stateBody(number, await ctx.state.read(number)))
+    const key = parseTargetKey(c.req.param('n'))
+    return c.json(stateBody(key, await ctx.state.read(key)))
   })
 
   api.put('/prs/:n/reviewed/:id{.+}', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const key = parseTargetKey(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)
-    requireSameHead(body.headSha, pr.headSha)
-    return c.json(stateBody(number, await ctx.state.setReviewed(number, id, body.reviewed, pr.headSha)))
+    // A mark is made against the canvas on screen, which for a local review is the snapshot the
+    // page was drawn from, not whatever the working tree holds a keystroke later.
+    const pr = await loader.currentTarget(key)
+    if (!isLocalKey(key)) {
+      requireSameHead(body.headSha, pr.headSha)
+    }
+    // The page sends back the canvas commit the bundle keyed its marks to, so a toggle costs no
+    // git work; the index, not git, says the commit is a canvas of this target.
+    const canvasSha = body.canvasSha ?? pr.headSha
+    if (canvasSha !== pr.headSha) {
+      await requireCanvasOf(ctx, key, canvasSha)
+    }
+    return c.json(stateBody(key, await ctx.state.setReviewed(key, id, body.reviewed, canvasSha)))
   })
 
   api.put('/prs/:n/points/:fingerprint/dismissed', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const key = parseTargetKey(c.req.param('n'))
     const fingerprint = c.req.param('fingerprint')
     const body = await readBody(c.req.raw, DismissedBodySchema, '{ "dismissed": true, "reason": "…" }')
-    const next = await ctx.state.setDismissed(number, fingerprint, body.dismissed, body.reason)
-    return c.json(stateBody(number, next))
+    const next = await ctx.state.setDismissed(key, fingerprint, body.dismissed, body.reason)
+    return c.json(stateBody(key, next))
   })
 
   api.put('/prs/:n/threads/:rootCommentId/hidden', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const number = requirePrNumber(parseTargetKey(c.req.param('n')), 'hiding a comment thread')
     const rootId = z.coerce.number().int().positive().safeParse(c.req.param('rootCommentId'))
     if (!rootId.success) {
       throw new AppError('BAD_REQUEST', 'the thread id is the numeric id of its first comment', 400)
@@ -129,16 +182,20 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
   })
 
   api.get('/prs/:n/capabilities', async c => {
-    parsePrNumber(c.req.param('n'))
+    const key = parseTargetKey(c.req.param('n'))
+    if (isLocalKey(key)) {
+      return c.json(LOCAL_CAPABILITIES)
+    }
     return c.json(await ctx.capabilities.get({ refresh: c.req.query('refresh') === '1' }))
   })
 
   api.post('/prs/:n/comments', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const number = requirePrNumber(parseTargetKey(c.req.param('n')), 'posting a comment')
     const input = await readBody(c.req.raw, PostCommentInputSchema, 'an inline, reply, or issue comment')
     await requirePosting()
     const pr = await loader.currentPr(number)
     requireSameHead(input.headSha, pr.headSha)
+    let diff: Derived = { files: [], patches: {} }
     if (input.kind === 'inline') {
       const derived = await ctx.derived.read(pr.headSha)
       if (derived === null) {
@@ -153,8 +210,9 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
       if (problem !== null) {
         throw new AppError('COMMENT_LINE_NOT_IN_DIFF', problem, 422, 'comment on a line the diff shows')
       }
+      diff = derived
     }
-    const posted = await postComment(ctx.gh, ctx.config.repo, number, pr.headSha, input)
+    const posted = await ctx.config.host.postComment(ctx.gh, ctx.config.repo, number, pr.headSha, input, diff)
     await appendComment(ctx, number, posted)
     const entry =
       input.kind === 'inline' && input.pointFingerprint !== undefined
@@ -165,10 +223,9 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
   })
 
   api.get('/prs/:n/review/body', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const number = requirePrNumber(parseTargetKey(c.req.param('n')), 'the sign-off summary')
     const pr = await loader.currentPr(number)
-    const artifact = await artifactForHead(ctx, number, pr)
-    const state = stateForHead(await ctx.state.read(number), pr.headSha)
+    const { artifact, state } = await canvasForSignOff(ctx, number, pr)
     const comments = (await ctx.prs.readComments(number)) ?? (await loader.refreshComments(number)).comments
     const body: ReviewBodyResponse = {
       headSha: pr.headSha,
@@ -179,13 +236,12 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
   })
 
   api.post('/prs/:n/review', async c => {
-    const number = parsePrNumber(c.req.param('n'))
+    const number = requirePrNumber(parseTargetKey(c.req.param('n')), 'submitting a review')
     const input = await readBody(c.req.raw, PostReviewInputSchema, '{ "event": "APPROVE" }')
     await requirePosting()
     const pr = await loader.currentPr(number)
     requireSameHead(input.headSha, pr.headSha)
-    const artifact = await artifactForHead(ctx, number, pr)
-    const state = stateForHead(await ctx.state.read(number), pr.headSha)
+    const { artifact, state } = await canvasForSignOff(ctx, number, pr)
     if (input.event === 'APPROVE') {
       const missing = unreviewedLayers(artifact, state)
       if (missing.length > 0) {
@@ -199,7 +255,10 @@ export function reviewRoutes(ctx: AppContext, loader: PrLoader): Hono {
     }
     const comments = (await ctx.prs.readComments(number)) ?? (await loader.refreshComments(number)).comments
     const body = input.body ?? buildReviewBody({ artifact, state, comments, headSha: pr.headSha })
-    const review = await postReview(ctx.gh, ctx.config.repo, number, pr.headSha, { event: input.event, body })
+    const review = await ctx.config.host.postReview(ctx.gh, ctx.config.repo, number, pr.headSha, {
+      event: input.event,
+      body,
+    })
     return c.json({ review }, 201)
   })
 
@@ -223,7 +282,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 +304,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()