@vintasoftware/pr-review-canvas 0.1.0 → 0.3.0

package/src/acpx/acpx.ts

@@ -231,7 +231,11 @@ export function createAgentRunner(opts: CreateAgentRunnerOptions = {}): AgentRun
         // The cancel call gets its own timeout, and SIGKILL when it elapses: a cancel that hangs
         // must neither hold the kill back nor stay behind as a process of its own.
         agentArgs =>
-          execQuiet(bin, agentArgs, { cwd: options.cwd, timeoutSec: CANCEL_TIMEOUT_SEC, killSignal: 'SIGKILL' }),
+          execQuiet(bin, agentArgs, {
+            cwd: options.cwd,
+            timeoutSec: CANCEL_TIMEOUT_SEC,
+            killSignal: 'SIGKILL',
+          }),
         slackMs,
         cancelGraceMs
       )
@@ -268,7 +272,12 @@ export function createAgentRunner(opts: CreateAgentRunnerOptions = {}): AgentRun
         }
       }
       if (!ended) {
-        return { ok: false, text: '', code: 'AGENT_INCOMPLETE', message: 'the agent stopped before finishing' }
+        return {
+          ok: false,
+          text: '',
+          code: 'AGENT_INCOMPLETE',
+          message: 'the agent stopped before finishing',
+        }
       }
       return text === ''
         ? { ok: false, text: '', code: 'AGENT_INCOMPLETE', message: 'the agent replied nothing' }
@@ -516,11 +525,19 @@ function startRun(
     const exit = code ?? 1
     const mapped = exitCodeToAgentCode(exit)
     if (mapped !== null) {
-      finish({ type: 'error', code: mapped, message: stderr.trim() === '' ? exitCodeMessage(exit) : stderr.trim() })
+      finish({
+        type: 'error',
+        code: mapped,
+        message: stderr.trim() === '' ? exitCodeMessage(exit) : stderr.trim(),
+      })
       return
     }
     // acpx 0.13.2 exits 0 when its own --timeout elapses, without a terminal event.
-    finish({ type: 'error', code: 'AGENT_INCOMPLETE', message: 'the agent stopped before finishing its answer' })
+    finish({
+      type: 'error',
+      code: 'AGENT_INCOMPLETE',
+      message: 'the agent stopped before finishing its answer',
+    })
   })
 
   child.stdin?.on('error', () => undefined)

package/src/acpx/events.ts

@@ -64,7 +64,11 @@ function contentText(value: unknown): string {
  */
 export function mapAcpxMessage(message: unknown): AgentEvent | null {
   if (!isRecord(message)) {
-    return { type: 'error', code: 'AGENT_PROTOCOL_INVALID', message: 'the agent wrote a line that is not a message' }
+    return {
+      type: 'error',
+      code: 'AGENT_PROTOCOL_INVALID',
+      message: 'the agent wrote a line that is not a message',
+    }
   }
   const error = read(message, 'error')
   if (isRecord(error)) {

package/src/acpx/ndjson.ts

@@ -50,7 +50,9 @@ export function createNdjsonSplitter(lineMax: number = NDJSON_LINE_MAX): NdjsonS
         const raw = buffer.slice(0, at)
         buffer = buffer.slice(at + 1)
         if (raw.length > lineMax) {
-          throw new NdjsonError(`the agent wrote a line of ${raw.length} characters, over the ${lineMax} limit`)
+          throw new NdjsonError(
+            `the agent wrote a line of ${raw.length} characters, over the ${lineMax} limit`
+          )
         }
         out.push(...take(raw))
         at = buffer.indexOf('\n')

package/src/acpx/preflight.ts

@@ -16,7 +16,11 @@ export interface PreflightProbe {
  * Is acpx on PATH? The answer barely changes while the server runs, so it is asked once and
  * reused; the page shows a banner and hides the chat when it says no.
  */
-export function createPreflightProbe(runner: AgentRunner, now: () => Date, ttlMs = PREFLIGHT_TTL_MS): PreflightProbe {
+export function createPreflightProbe(
+  runner: AgentRunner,
+  now: () => Date,
+  ttlMs = PREFLIGHT_TTL_MS
+): PreflightProbe {
   let cached: { at: number; value: AcpxPreflight } | null = null
   let inFlight: Promise<AcpxPreflight> | null = null
   return {

package/src/canvas/export.ts

@@ -37,7 +37,12 @@ export async function buildCanvasZipFor(
   const number = prNumber ?? stored.prNumber
   const manifest: CanvasManifest = number === undefined ? stored : { ...stored, prNumber: number }
   const zip: CanvasZip = {
-    name: buildCanvasZipName({ repo: manifest.repo, headSha, prNumber: number }),
+    name: buildCanvasZipName({
+      repo: manifest.repo,
+      headSha,
+      prNumber: number,
+      generatedAt: manifest.generatedAt,
+    }),
     bytes: buildCanvasZip(manifest, artifact),
     headSha,
   }
@@ -64,7 +69,11 @@ async function isDirectory(target: string): Promise<boolean> {
 }
 
 /** `--out` names a file when it ends in `.zip` or is not an existing directory. */
-export async function resolveOutPath(out: string | undefined, defaultDir: string, name: string): Promise<string> {
+export async function resolveOutPath(
+  out: string | undefined,
+  defaultDir: string,
+  name: string
+): Promise<string> {
   if (out === undefined) {
     return path.join(defaultDir, name)
   }

package/src/canvas/name.ts

@@ -4,11 +4,9 @@ import type { Repo } from '../contract/review-artifact.js'
 
 export interface ParsedCanvasName {
   prNumber?: number
-  sha7: string
+  shaPrefix: string
 }
 
-export const CANVAS_NAME_PREFIX = 'pr-review-canvas'
-
 /** Owner and repo names may hold characters a file name should not; runs of them become one dash. */
 function slugPart(value: string): string {
   return value
@@ -24,32 +22,34 @@ export function repoSlug(repo: Repo): string {
 export interface BuildNameOptions {
   repo: Repo
   headSha: string
+  generatedAt: string
   prNumber?: number | undefined
 }
 
-/** `pr-review-canvas-<owner>-<repo>-pr<n>-<sha7>.zip`, without `-pr<n>` before the PR exists. */
+/** PR or ref, UTC generation time to seconds, commit prefix, repository, and canvas marker. */
 export function buildCanvasZipName(opts: BuildNameOptions): string {
-  const pr = opts.prNumber === undefined ? '' : `-pr${opts.prNumber}`
-  return `${CANVAS_NAME_PREFIX}-${repoSlug(opts.repo)}${pr}-${opts.headSha.slice(0, 7)}.zip`
+  const target = opts.prNumber === undefined ? 'ref' : `pr-${opts.prNumber}`
+  const timestamp = new Date(opts.generatedAt).toISOString().slice(0, 19).replace(/[-:]/g, '') + 'Z'
+  return `${target}-${timestamp}-${opts.headSha.slice(0, 8)}-${repoSlug(opts.repo)}-canvas.zip`
 }
 
-const TAIL_RE = /^(?:pr(\d+)-)?([0-9a-f]{7})\.zip$/
+const NAME_RE = /^(?:pr-([1-9]\d*)|ref)-\d{8}t\d{6}z-([0-9a-f]{8})$/
 
 /**
  * Reads a file name as a canvas zip for `repo`. A name for another repository, or one that does
  * not follow the grammar, returns null: discovery uses this to skip attachments that are not ours.
  */
 export function parseCanvasZipName(filename: string, repo: Repo): ParsedCanvasName | null {
-  const prefix = `${CANVAS_NAME_PREFIX}-${repoSlug(repo)}-`
+  const suffix = `-${repoSlug(repo)}-canvas.zip`
   const lower = filename.toLowerCase()
-  if (!lower.startsWith(prefix)) {
+  if (!lower.endsWith(suffix)) {
     return null
   }
-  const m = TAIL_RE.exec(lower.slice(prefix.length))
-  const sha7 = m?.[2]
-  if (sha7 === undefined) {
+  const m = NAME_RE.exec(lower.slice(0, -suffix.length))
+  const shaPrefix = m?.[2]
+  if (shaPrefix === undefined) {
     return null
   }
   const pr = m?.[1]
-  return pr === undefined ? { sha7 } : { prNumber: Number(pr), sha7 }
+  return pr === undefined ? { shaPrefix } : { prNumber: Number(pr), shaPrefix }
 }

package/src/canvas/zip.ts

@@ -66,7 +66,10 @@ function decode(entry: Uint8Array | undefined, name: string, issues: string[]):
  */
 export function readCanvasZip(bytes: Uint8Array): CanvasZipContents {
   if (bytes.length > CANVAS_ZIP_MAX_BYTES) {
-    throw new CanvasZipError('CANVAS_TOO_LARGE', `the canvas zip is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`)
+    throw new CanvasZipError(
+      'CANVAS_TOO_LARGE',
+      `the canvas zip is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`
+    )
   }
   if (!hasZipMagic(bytes)) {
     throw new CanvasZipError('CANVAS_INVALID', 'this file is not a zip', [

package/src/chat/chat-manager.ts

@@ -10,7 +10,13 @@ import type { SettingsStore } from '../store/settings-store.js'
 import type { StateStore } from '../store/state-store.js'
 import { type ContextSources, renderChatContext } from './context.js'
 import { renderSeed, type SeedPaths } from './seed.js'
-import { NEW_THREAD_TITLE, nextThreadIndex, type TranscriptStore, threadName, threadTitle } from './threads.js'
+import {
+  NEW_THREAD_TITLE,
+  nextThreadIndex,
+  type TranscriptStore,
+  threadName,
+  threadTitle,
+} from './threads.js'
 
 export class ChatBusyError extends Error {
   constructor() {
@@ -188,7 +194,11 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
     }
   }
 
-  async function* runTurn(target: ChatTarget, input: ChatSendInput, slot: RunningTurn): AsyncIterable<ChatEvent> {
+  async function* runTurn(
+    target: ChatTarget,
+    input: ChatSendInput,
+    slot: RunningTurn
+  ): AsyncIterable<ChatEvent> {
     const settings = await effectiveSettings()
     const thread = await resolveThread(target.prNumber, settings.agent, input.thread)
     const seeded = thread.seededHeadSha !== target.headSha
@@ -350,7 +360,10 @@ export function createChatManager(deps: ChatManagerDeps): ChatManager {
       if (thread === undefined) {
         return null
       }
-      await deps.state.update(prNumber, current => ({ ...current, chat: { ...current.chat, activeThread: name } }))
+      await deps.state.update(prNumber, current => ({
+        ...current,
+        chat: { ...current.chat, activeThread: name },
+      }))
       return thread
     },
     send,

package/src/chat/context.ts

@@ -106,7 +106,10 @@ export async function renderChatContext(context: ChatContext, sources: ContextSo
  * An attention point: what it says, plus the lines it sits on. The agent needs the text to know
  * what the reader is reacting to; the lines alone leave it guessing. One context, one heading.
  */
-async function renderPoint(context: Extract<ChatContext, { kind: 'point' }>, sources: ContextSources): Promise<string> {
+async function renderPoint(
+  context: Extract<ChatContext, { kind: 'point' }>,
+  sources: ContextSources
+): Promise<string> {
   const point = sources.artifact.points.find(p => p.fingerprint === context.fingerprint)
   if (point === undefined) {
     throw new ChatContextError('this canvas has no such attention point')
@@ -140,7 +143,10 @@ async function renderLines(
 }
 
 /** The quoted lines and the hunk around them, with no heading of their own. */
-async function linesBody(context: Extract<ChatContext, { kind: 'lines' }>, sources: ContextSources): Promise<string> {
+async function linesBody(
+  context: Extract<ChatContext, { kind: 'lines' }>,
+  sources: ContextSources
+): Promise<string> {
   if (context.end < context.start) {
     throw new ChatContextError('the last line of a selection comes after the first')
   }
@@ -155,6 +161,7 @@ async function linesBody(context: Extract<ChatContext, { kind: 'lines' }>, sourc
     lines === null || lines.length === 0
       ? '_these lines are not available locally_'
       : fence(lines.map((text, i) => `${context.start + i}: ${text}`).join('\n'))
-  const hunkBlock = hunk === undefined ? '' : `\n\nThe hunk around them is \`${hunk.id}\` (\`${hunk.header}\`).`
+  const hunkBlock =
+    hunk === undefined ? '' : `\n\nThe hunk around them is \`${hunk.id}\` (\`${hunk.header}\`).`
   return `${numbered}${hunkBlock}`
 }

package/src/chat/seed.ts

@@ -42,7 +42,9 @@ export function pointsMarkdown(artifact: ReviewArtifact): string {
   if (artifact.points.length === 0) {
     return '_none_'
   }
-  return artifact.points.map(p => `- ${p.level} · ${p.kind} · ${p.title} (\`${p.path}:${p.line}\`)`).join('\n')
+  return artifact.points
+    .map(p => `- ${p.level} · ${p.kind} · ${p.title} (\`${p.path}:${p.line}\`)`)
+    .join('\n')
 }
 
 export function testsMarkdown(artifact: ReviewArtifact): string {

package/src/cli.ts

@@ -1,4 +1,3 @@
-import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { parseArgs } from 'node:util'
 import { createAgentRunner } from './acpx/acpx.js'
@@ -21,12 +20,22 @@ import { type ReviewArtifact, ReviewArtifactSchema } from './contract/review-art
 import { createGit } from './git/git.js'
 import { createGitHubClient } from './github/gh.js'
 import { loadProjectConfig } from './project-config.js'
+import { checkSkill } from './review/doctor.js'
 import { type AppContext, createAppContext, readPackageVersion } from './server/context.js'
 import { startServer } from './server/node-server.js'
 import { readJson } from './store/atomic-json.js'
 import { ensureDataDir } from './store/data-dir.js'
 
-const SUBCOMMANDS = ['serve', 'prepare', 'validate', 'publish', 'export', 'import', 'install-skill', 'doctor'] as const
+const SUBCOMMANDS = [
+  'serve',
+  'prepare',
+  'validate',
+  'publish',
+  'export',
+  'import',
+  'install-skill',
+  'doctor',
+] as const
 
 const USAGE = `usage: pr-review <command> [flags]
 
@@ -78,7 +87,8 @@ async function buildContext(
   )
   const projectConfig = await loadProjectConfig(config.repoRoot)
   await ensureDataDir(config.dataDir)
-  const fixtureArtifact = config.fixtureCanvasPath === null ? null : await loadFixture(config.fixtureCanvasPath)
+  const fixtureArtifact =
+    config.fixtureCanvasPath === null ? null : await loadFixture(config.fixtureCanvasPath)
   return createAppContext({ config, projectConfig, fixtureArtifact })
 }
 
@@ -109,6 +119,8 @@ async function serve(argv: string[]): Promise<number> {
     agent: values.agent,
     model: values.model,
   })
+  const skill = await checkSkill(ctx.config.repoRoot)
+  if (!skill.ok) io.stderr(`pr-review doctor: ${skill.detail}. ${skill.hint ?? ''}`)
   startServer(ctx, line => process.stderr.write(`${line}\n`))
   return EXIT.ok
 }
@@ -125,15 +137,6 @@ async function doctorCommand(argv: string[]): Promise<number> {
       version: readPackageVersion(),
       acpxVersion: () => createAgentRunner().acpxVersion(),
       dataDirOverride: dataDir ?? readEnv(process.env, 'PR_REVIEW_DATA_DIR'),
-      exists: async file => {
-        try {
-          // A read, so a dangling symlink and a directory both answer no.
-          await readFile(file)
-          return true
-        } catch {
-          return false
-        }
-      },
     },
     rest,
     io
@@ -144,7 +147,7 @@ async function installSkillCommand(argv: string[]): Promise<number> {
   const { repo, rest } = splitCommonFlags(argv)
   const cwd = process.cwd()
   const repoRoot = await resolveRepoRoot(createGit(repo === undefined ? cwd : path.resolve(cwd, repo)))
-  return runInstallSkill({ repoRoot, cwd, platform: process.platform }, rest, io)
+  return runInstallSkill({ repoRoot, cwd }, rest, io)
 }
 
 export async function main(argv: string[]): Promise<number> {

package/src/commands.ts

@@ -63,7 +63,12 @@ export function printErrorEnvelope(io: CliIo, code: ErrorCode, message: string,
 }
 
 function isParseArgsError(err: unknown): err is Error {
-  return err instanceof Error && 'code' in err && typeof err.code === 'string' && err.code.startsWith('ERR_PARSE_ARGS')
+  return (
+    err instanceof Error &&
+    'code' in err &&
+    typeof err.code === 'string' &&
+    err.code.startsWith('ERR_PARSE_ARGS')
+  )
 }
 
 /** Prints the envelope for any failure and picks the exit code. */
@@ -156,7 +161,12 @@ export function parsePrepareTarget(values: { pr?: string; base?: string; head?:
 export async function runPrepare(ctx: AppContext, argv: string[], io: CliIo): Promise<number> {
   const { values } = parseArgs({
     args: argv,
-    options: { pr: { type: 'string' }, base: { type: 'string' }, head: { type: 'string' }, force: { type: 'boolean' } },
+    options: {
+      pr: { type: 'string' },
+      base: { type: 'string' },
+      head: { type: 'string' },
+      force: { type: 'boolean' },
+    },
     strict: true,
   })
   const target = parsePrepareTarget(values)
@@ -194,7 +204,9 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
   })
   const file = positionals[0]
   if (file === undefined || positionals.length > 1) {
-    throw new UsageError('validate takes one file: pr-review validate <model.json|review.json> --canvas <dir>')
+    throw new UsageError(
+      'validate takes one file: pr-review validate <model.json|review.json> --canvas <dir>'
+    )
   }
   if (values.canvas === undefined) {
     throw new UsageError('validate needs --canvas <dir> (the directory prepare printed)')
@@ -202,7 +214,11 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
   const context = await readContext(path.resolve(values.canvas))
   const text = await readText(path.resolve(file))
   if (text === null) {
-    throw new PublishError('NOT_FOUND', `${file} does not exist`, 'pass the model.json or review.json to check')
+    throw new PublishError(
+      'NOT_FOUND',
+      `${file} does not exist`,
+      'pass the model.json or review.json to check'
+    )
   }
   const fixed = values.fix === true ? await fixTitles(path.resolve(file), text, context) : { text, trims: [] }
   const report = await validateFile(ctx, parseModelText(fixed.text, path.basename(file)), context)
@@ -214,7 +230,9 @@ export async function runValidate(ctx: AppContext, argv: string[], io: CliIo): P
     if (trim.outcome === 'fixed') {
       io.stdout(`fixed ${trim.where}: "${trim.from}" -> "${trim.to}"`)
     } else {
-      io.stdout(`unfixable ${trim.where}: ${trim.length} visible chars, cap ${trim.cap}, ${trim.reason}; rewrite by hand`)
+      io.stdout(
+        `unfixable ${trim.where}: ${trim.length} visible chars, cap ${trim.cap}, ${trim.reason}; rewrite by hand`
+      )
     }
   }
   if (report.ok) {
@@ -277,7 +295,9 @@ export async function runPublish(ctx: AppContext, argv: string[], io: CliIo): Pr
   })
   const canvasDir = positionals[0]
   if (canvasDir === undefined || positionals.length > 1) {
-    throw new UsageError('publish takes one directory: pr-review publish <canvasDir> --agent <id> --harness <id>')
+    throw new UsageError(
+      'publish takes one directory: pr-review publish <canvasDir> --agent <id> --harness <id>'
+    )
   }
   if (values.agent === undefined || values.agent === '') {
     throw new UsageError('publish needs --agent <id>')
@@ -306,20 +326,22 @@ export async function runDoctor(deps: DoctorDeps, argv: string[], io: CliIo): Pr
 export interface InstallSkillEnv {
   repoRoot: string
   cwd: string
-  platform: NodeJS.Platform
 }
 
 /** `install-skill [--claude-dir <dir>] [--codex-dir <dir>] [--force]`, both dirs under the repo root by default. */
 export async function runInstallSkill(env: InstallSkillEnv, argv: string[], io: CliIo): Promise<number> {
   const { values } = parseArgs({
     args: argv,
-    options: { 'claude-dir': { type: 'string' }, 'codex-dir': { type: 'string' }, force: { type: 'boolean' } },
+    options: {
+      'claude-dir': { type: 'string' },
+      'codex-dir': { type: 'string' },
+      force: { type: 'boolean' },
+    },
     strict: true,
   })
   const resolve = (flag: string | undefined, fallback: string): string =>
     flag === undefined ? path.join(env.repoRoot, fallback) : path.resolve(env.cwd, flag)
   const result = await installSkill({
-    platform: env.platform,
     force: values.force === true,
     targets: [
       { kind: 'claude', dir: resolve(values['claude-dir'], CLAUDE_SKILLS_DIR) },
@@ -359,7 +381,11 @@ export async function runExport(ctx: AppContext, argv: string[], io: CliIo): Pro
     strict: true,
   })
   const target = await resolveHead(ctx, values)
-  const result = await exportCanvas(ctx, { headSha: target.headSha, prNumber: target.prNumber, out: values.out })
+  const result = await exportCanvas(ctx, {
+    headSha: target.headSha,
+    prNumber: target.prNumber,
+    out: values.out,
+  })
   printJson(io, result)
   io.stderr(`drag ${result.path} into the pull request description or a comment`)
   return EXIT.ok
@@ -377,7 +403,11 @@ async function readZipFile(zipPath: string, shown: string): Promise<Uint8Array>
   } catch {
     throw new PublishError('NOT_FOUND', `${shown} does not exist`, 'pass the canvas zip to import')
   }
-  const tooLarge = new AppError('CANVAS_TOO_LARGE', `${shown} is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`, 413)
+  const tooLarge = new AppError(
+    'CANVAS_TOO_LARGE',
+    `${shown} is larger than ${CANVAS_ZIP_MAX_BYTES} bytes`,
+    413
+  )
   try {
     // One byte past the cap is read, so a file of exactly the cap still fits and anything longer
     // is refused without the rest of it ever being in memory.

package/src/config.ts

@@ -47,7 +47,11 @@ export async function resolveRepoRoot(git: Git): Promise<string> {
     return await git.topLevel()
   } catch (err) {
     if (err instanceof GitError) {
-      throw new ConfigError('NOT_A_REPO', 'not inside a git repository', 'run from a clone or pass --repo <dir>')
+      throw new ConfigError(
+        'NOT_A_REPO',
+        'not inside a git repository',
+        'run from a clone or pass --repo <dir>'
+      )
     }
     throw err
   }
@@ -72,7 +76,11 @@ export function parseGithubRemote(url: string): Repo | null {
 export async function resolveGithubRepo(git: Git): Promise<Repo> {
   const url = await git.remoteUrl('origin')
   if (url === null) {
-    throw new ConfigError('NO_ORIGIN', 'the repository has no "origin" remote', 'add one that points at GitHub')
+    throw new ConfigError(
+      'NO_ORIGIN',
+      'the repository has no "origin" remote',
+      'add one that points at GitHub'
+    )
   }
   const repo = parseGithubRemote(url)
   if (repo === null) {
@@ -90,7 +98,11 @@ export function parseChatOverrides(flags: ServeFlags): SettingsOverrides {
   const overrides: SettingsOverrides = {}
   if (flags.agent !== undefined) {
     if (!isChatAgent(flags.agent)) {
-      throw new ConfigError('BAD_REQUEST', `unknown chat agent: ${flags.agent}`, 'use --agent claude or --agent codex')
+      throw new ConfigError(
+        'BAD_REQUEST',
+        `unknown chat agent: ${flags.agent}`,
+        'use --agent claude or --agent codex'
+      )
     }
     overrides.agent = flags.agent
   }

package/src/contract/comments.ts

@@ -79,7 +79,9 @@ export const PostCommentInputSchema = z.discriminatedUnion('kind', [
 export type PostCommentInput = z.infer<typeof PostCommentInputSchema>
 
 /** The posted comment: a review comment for inline and reply, an issue comment for PR-level. */
-export type PostCommentResult = { kind: 'review'; comment: ReviewComment } | { kind: 'issue'; comment: IssueComment }
+export type PostCommentResult =
+  | { kind: 'review'; comment: ReviewComment }
+  | { kind: 'issue'; comment: IssueComment }
 
 // The proposed-comment block a chat answer can carry. The parser lives in
 // static/js/proposed-comment.js so the browser loads the same code without a bundler.

package/src/contract/generation-context.ts

@@ -57,7 +57,9 @@ export const GenerationContextSchema = z.object({
   }),
   /** The globs that make a file a test here. Defaulted, so a context written before this
    * field existed still reads. */
-  tests: z.object({ patterns: z.array(z.string().min(1)) }).default(() => ({ patterns: [...DEFAULT_TEST_PATTERNS] })),
+  tests: z
+    .object({ patterns: z.array(z.string().min(1)) })
+    .default(() => ({ patterns: [...DEFAULT_TEST_PATTERNS] })),
   /** At most `generation.smallPrHunks` hunks: one layer unless concerns differ, fewer annotations. */
   smallPr: z.boolean(),
   /** More than 400 files or 50 000 changed lines: the prompt inlines nothing and tightens the caps. */

package/src/contract/review-artifact.ts

@@ -48,7 +48,9 @@ function mapCaps(fn: (key: keyof TextCaps) => number): TextCaps {
 }
 
 /** The project config may raise or lower a cap; the result is what the validator and the prompt use. */
-export function effectiveCaps(overrides: { [K in keyof TextCaps]?: number | undefined } | undefined): TextCaps {
+export function effectiveCaps(
+  overrides: { [K in keyof TextCaps]?: number | undefined } | undefined
+): TextCaps {
   return mapCaps(key => overrides?.[key] ?? TEXT_CAPS[key])
 }
 
@@ -162,13 +164,17 @@ function text(caps: Caps, key: keyof TextCaps): z.ZodString {
 
 function textOrEmpty(caps: Caps, key: keyof TextCaps): z.ZodString {
   const visibleCap = caps[key] / HARD_CAP_FACTOR
-  const diagrams = key === 'summary' || key === 'rationale'
-    ? ' Mermaid fences count toward the separate diagram cap, not this prose cap.'
-    : ''
-  return z.string().max(caps[key]).meta({
-    description: `At most ${visibleCap} visible characters. Link targets, backticks, and code-fence lines do not count. maxLength is only the raw Markdown ceiling.${diagrams}`,
-    'x-visibleMaxLength': visibleCap,
-  })
+  const diagrams =
+    key === 'summary' || key === 'rationale'
+      ? ' Mermaid fences count toward the separate diagram cap, not this prose cap.'
+      : ''
+  return z
+    .string()
+    .max(caps[key])
+    .meta({
+      description: `At most ${visibleCap} visible characters. Link targets, backticks, and code-fence lines do not count. maxLength is only the raw Markdown ceiling.${diagrams}`,
+      'x-visibleMaxLength': visibleCap,
+    })
 }
 
 export function testEntrySchema(caps: Caps) {

package/src/contract/state.ts

@@ -25,7 +25,9 @@ export const PrStateSchema = z.object({
    */
   reviewedHeadSha: z.string().optional(),
   hiddenThreads: z.record(z.string(), z.object({ at: z.string() })),
-  posted: z.array(z.object({ commentId: z.number().int(), pointFingerprint: z.string().optional(), at: z.string() })),
+  posted: z.array(
+    z.object({ commentId: z.number().int(), pointFingerprint: z.string().optional(), at: z.string() })
+  ),
   dismissed: z.record(z.string(), z.object({ at: z.string(), reason: z.string().optional() })),
   chat: z.object({ threads: z.array(ChatThreadSchema), activeThread: z.string().optional() }),
   updatedAt: z.string(),

package/src/git/diff-collector.ts

@@ -79,7 +79,8 @@ export function parseBlock(lines: string[]): Omit<CollectedFile, 'key'> | null {
     return null
   }
 
-  const isBinary = header.some(l => l.startsWith('Binary files ')) || header.some(l => l === 'GIT binary patch')
+  const isBinary =
+    header.some(l => l.startsWith('Binary files ')) || header.some(l => l === 'GIT binary patch')
   let status: FileStatus
   if (renameFrom !== null) {
     status = 'renamed'

package/src/git/git.ts

@@ -62,10 +62,15 @@ interface ExecResult {
 /** Runs git with an argument array; never a shell. */
 export function execGit(cwd: string, args: string[]): Promise<ExecResult> {
   return new Promise(resolve => {
-    execFile('git', args, { cwd, encoding: 'buffer', maxBuffer: 256 * 1024 * 1024 }, (error, stdout, stderr) => {
-      const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0
-      resolve({ stdout, stderr: stderr.toString('utf8'), code })
-    })
+    execFile(
+      'git',
+      args,
+      { cwd, encoding: 'buffer', maxBuffer: 256 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0
+        resolve({ stdout, stderr: stderr.toString('utf8'), code })
+      }
+    )
   })
 }
 

package/src/github/attachments.ts

@@ -94,9 +94,9 @@ export function rankCandidates(
   candidates: AttachmentCandidate[],
   target: { headSha: string; prNumber: number }
 ): AttachmentCandidate[] {
-  const sha7 = target.headSha.slice(0, 7)
+  const shaPrefix = target.headSha.slice(0, 8)
   const score = (c: AttachmentCandidate): number =>
-    (c.parsed.sha7 === sha7 ? 2 : 0) + (c.parsed.prNumber === target.prNumber ? 1 : 0)
+    (c.parsed.shaPrefix === shaPrefix ? 2 : 0) + (c.parsed.prNumber === target.prNumber ? 1 : 0)
   return [...candidates].sort(
     (a, b) => score(b) - score(a) || b.postedAt.localeCompare(a.postedAt) || b.order - a.order
   )
@@ -261,7 +261,7 @@ async function tryCandidate(
   const shared = {
     url: candidate.url,
     name: candidate.name,
-    matchesHead: candidate.parsed.sha7 === pr.headSha.slice(0, 7),
+    matchesHead: candidate.parsed.shaPrefix === pr.headSha.slice(0, 8),
   }
   const download = await downloadAttachment(ctx, candidate.url)
   if (!download.ok) {

package/src/github/capabilities.ts

@@ -10,7 +10,11 @@ const RepoBodySchema = z.object({
 })
 
 /** What a page assumes before the probe answers: posting is tried and GitHub decides. */
-export const UNKNOWN_CAPABILITIES: Capabilities = { canComment: 'unknown', tokenKind: 'unprobed', login: null }
+export const UNKNOWN_CAPABILITIES: Capabilities = {
+  canComment: 'unknown',
+  tokenKind: 'unprobed',
+  login: null,
+}
 
 export const SCOPE_HINT = 'gh auth refresh -h github.com -s repo'