@erclx/canon 5.77.0 → 5.79.0

package/src/pr/local.ts

@@ -45,6 +45,11 @@ async function firstFailingPath(
   return undefined
 }
 
+/** Whether `cwd` is `folder` or inside it, compared on whole path segments. */
+function isUnder(cwd: string, folder: string): boolean {
+  return cwd === folder || cwd.startsWith(`${folder}/`)
+}
+
 /**
  * Finds the server this worktree is running: the lowest port whose listening
  * process runs inside the worktree, answers an HTTP probe, and passes every
@@ -53,11 +58,14 @@ async function firstFailingPath(
  * lower one is the page by convention. Health is read on the page's own port,
  * since that is the address a reviewer drives, and a page whose backend fails
  * refuses as `unhealthy` naming the lowest page port's first failing path.
+ * A port whose listener runs under a `pageOnly` folder, matched on whole
+ * segments, is found on the page probe alone.
  */
 export async function findLocalServer(
   worktreeRoot: string,
   runner: LocalRunner,
   healthPaths: readonly string[] = [],
+  pageOnly: readonly string[] = [],
 ): Promise<LocalResult> {
   const listeners = await runner.listListeners()
   if (listeners === undefined) {
@@ -65,17 +73,22 @@ export async function findLocalServer(
   }
 
   const cwdByPid = new Map<number, string | undefined>()
-  const ports = new Set<number>()
+  const ports = new Map<number, boolean>()
+  const folders = pageOnly.map((folder) => `${worktreeRoot}/${folder}`)
   for (const { pid, port } of listeners) {
     if (!cwdByPid.has(pid)) cwdByPid.set(pid, await runner.cwdOf(pid))
     const cwd = cwdByPid.get(pid)
-    if (cwd !== undefined && belongsTo(cwd, worktreeRoot)) ports.add(port)
+    if (cwd === undefined || !belongsTo(cwd, worktreeRoot)) continue
+    const skipsHealth = folders.some((folder) => isUnder(cwd, folder))
+    ports.set(port, (ports.get(port) ?? false) || skipsHealth)
   }
 
   let unhealthy: (HealthFailure & { readonly port: number }) | undefined
-  for (const port of [...ports].sort((a, b) => a - b)) {
+  for (const [port, skipsHealth] of [...ports].sort(([a], [b]) => a - b)) {
     if (!(await runner.probe(port))) continue
-    const failure = await firstFailingPath(port, healthPaths, runner)
+    const failure = skipsHealth
+      ? undefined
+      : await firstFailingPath(port, healthPaths, runner)
     if (failure === undefined) {
       return { kind: 'found', port, url: `http://localhost:${port}` }
     }

package/src/pr/paths.ts

@@ -77,7 +77,7 @@ const HEADING = /^(#{1,6})\s+(.+?)\s*$/
  * A `file.ts:42` or `file.ts:42-58` suffix, which is a reader's click target
  * rather than part of the name.
  */
-const LINE_SUFFIX = /:\d+(?:-\d+)?$/
+export const LINE_SUFFIX = /:\d+(?:-\d+)?$/
 
 /**
  * A span that carries a line suffix and nothing else, such as `:642` beside
@@ -214,6 +214,21 @@ function disclaimsChange(bullet: string): boolean {
  * reports rather than reading as an empty section.
  */
 export function readSection(body: string, title: string): string | undefined {
+  return readSectionAt(body, title)?.text
+}
+
+/**
+ * The section's text and the character offset it starts at, counted in the body
+ * with its line endings normalized to `\n`.
+ *
+ * The offset is what lets a caller rewrite the section in place. Searching the
+ * body for the text instead finds the first copy, so an identical block above
+ * the heading would take the edit.
+ */
+export function readSectionAt(
+  body: string,
+  title: string,
+): { readonly text: string; readonly offset: number } | undefined {
   const lines = body.replace(/\r\n/g, '\n').split('\n')
   const wanted = title.toLowerCase()
 
@@ -246,7 +261,10 @@ export function readSection(body: string, title: string): string | undefined {
     out.push(line)
   }
 
-  return out.join('\n')
+  const offset = lines
+    .slice(0, start)
+    .reduce((sum, line) => sum + line.length + 1, 0)
+  return { text: out.join('\n'), offset }
 }
 
 /**

package/src/pr/rest.ts

@@ -39,6 +39,7 @@ export interface RestReview {
   readonly body?: string | null
   readonly commit_id?: string | null
   readonly submitted_at?: string | null
+  readonly state?: string | null
 }
 
 /** One row of `repos/{owner}/{repo}/issues/<n>/comments`. */
@@ -117,6 +118,7 @@ export function reviewRowOf(review: RestReview): ReviewRow {
         ? null
         : { oid: review.commit_id },
     submittedAt: review.submitted_at ?? null,
+    ...(typeof review.state === 'string' && { state: review.state }),
   }
 }
 

package/src/pr/review-scope.ts

@@ -47,6 +47,8 @@ export interface ReviewRow {
   readonly body?: string
   readonly commit?: { readonly oid?: string } | null
   readonly submittedAt?: string | null
+  /** GitHub's review state, `DISMISSED` once the operator withdrew the pass. */
+  readonly state?: string | null
 }
 
 /**
@@ -238,6 +240,32 @@ export function resolveUiScope(listing: ReviewListing): UiScope {
   }
 }
 
+/**
+ * The newest code pass and the newest UI pass, each only when its own marker
+ * closes it, skipping any pass the operator dismissed. A body with no pass
+ * heading never stands, and neither does an older pass a newer one replaced,
+ * so a pass speaks only for the head it read.
+ */
+export function standingPasses(reviews: readonly ReviewRow[]): ReviewRow[] {
+  let code: ReviewRow | undefined
+  let ui: ReviewRow | undefined
+  for (const row of reviews) {
+    if (row.state === 'DISMISSED') continue
+    const body = row.body ?? ''
+    if (headingOf(body) !== undefined) code = row
+    else if (resolveUiScope({ reviews: [row] }).state !== 'none') ui = row
+  }
+
+  const passes: ReviewRow[] = []
+  if (code !== undefined && markerOf(code.body ?? '') !== undefined) {
+    passes.push(code)
+  }
+  if (ui !== undefined && UI_MARKER.test(lastLine(ui.body ?? '') ?? '')) {
+    passes.push(ui)
+  }
+  return passes
+}
+
 /**
  * Whether a covered commit names the head. A marker may carry a short sha, so
  * coverage is a prefix match on the head.

package/src/pr/review-state.ts

@@ -94,7 +94,7 @@ function familyOf(gate: GateResult, commit: string | undefined, tip: string) {
  */
 async function readAt(
   api: ReviewStateApi,
-  hasChecklist: boolean,
+  hasDrivableBox: boolean,
   painted: PaintedPatterns,
 ): Promise<ReviewStateRead> {
   const [tip, reviews] = await Promise.all([api.readTip(), api.readReviews()])
@@ -105,7 +105,7 @@ async function readAt(
   const listing: { reviews: readonly ReviewRow[] } = { reviews }
   const scope = resolveReviewScope(listing)
   const uiScope = resolveUiScope(listing)
-  const ui = await uiGate(api, painted, reviews, tip, hasChecklist)
+  const ui = await uiGate(api, painted, reviews, tip, hasDrivableBox)
   if (ui.reason === 'gh-failed') return { kind: 'refused', reason: 'gh-failed' }
 
   return {
@@ -117,7 +117,7 @@ async function readAt(
       ui: {
         ...uiScope,
         ...familyOf(ui, uiScope.commit, tip),
-        isBound: hasChecklist,
+        isBound: hasDrivableBox || uiScope.state === 'open',
         ...(ui.carriedFrom !== undefined && { carriedFrom: ui.carriedFrom }),
         ...(ui.paintedPaths !== undefined && { paintedPaths: ui.paintedPaths }),
         ...(ui.drivenPaths !== undefined && { drivenPaths: ui.drivenPaths }),
@@ -132,7 +132,7 @@ export async function readReviewState(
 ): Promise<ReviewStateRead> {
   const evidence = await api.readEvidence()
   if (evidence === undefined) return { kind: 'refused', reason: 'gh-failed' }
-  return readAt(api, evidence.hasChecklist, painted)
+  return readAt(api, evidence.hasDrivableBox, painted)
 }
 
 /**
@@ -158,7 +158,7 @@ export async function waitForReviews(
   }
 
   for (;;) {
-    const read = await readAt(api, evidence.hasChecklist, painted)
+    const read = await readAt(api, evidence.hasDrivableBox, painted)
     if (read.kind === 'refused') {
       return { ...read, waitedSeconds: waited() }
     }

package/src/pr/waiver.ts

@@ -0,0 +1,45 @@
+import type { ReviewRow } from '@/pr/review-scope'
+
+/** A painted path a review accepted as owing no capture, and why. */
+export interface Waiver {
+  readonly path: string
+  readonly reason: string
+}
+
+/**
+ * The line `review-pr` writes in a pass body to waive one path. The path is
+ * kept exactly as spelled, so a waiver matches an uncaptured path only when
+ * both spell it alike.
+ */
+const WAIVER_LINE = /^- \*\*Waived capture:\*\* `([^`]+)`:\s*(\S.*)$/
+
+const FENCE = /^\s*(```|~~~)/
+
+/**
+ * Every waiver in the review bodies, in order. A line inside a fenced block is
+ * a quoted sample rather than a waiver, so it never counts.
+ *
+ * Review bodies alone are read, never the pull request body or an issue
+ * comment, since every session posts as one account and a review is the one
+ * surface a worker never writes.
+ */
+export function readWaivers(reviews: readonly ReviewRow[]): Waiver[] {
+  const waivers: Waiver[] = []
+  for (const review of reviews) {
+    let fence: string | undefined
+    for (const line of (review.body ?? '').split('\n')) {
+      const opener = FENCE.exec(line)?.[1]
+      if (opener !== undefined) {
+        if (fence === undefined) fence = opener
+        else if (opener === fence) fence = undefined
+        continue
+      }
+      if (fence !== undefined) continue
+      const match = WAIVER_LINE.exec(line.trimEnd())
+      if (match?.[1] !== undefined && match[2] !== undefined) {
+        waivers.push({ path: match[1], reason: match[2] })
+      }
+    }
+  }
+  return waivers
+}

package/src/sessions/stop.ts

@@ -0,0 +1,145 @@
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs'
+import type { ResolvedSession } from '@/sessions/resolve'
+import { locateTranscript, projectsDir } from '@/sessions/transcript'
+
+export interface StopReading {
+  /**
+   * `usage-limit` means the last assistant entry is a limit stop, passing over
+   * a `<synthetic>` entry with no error, such as the one a client restart
+   * writes. `unknown` means the read failed or found a limit-worded entry of
+   * another shape, so the row may be stopped and nothing here can say.
+   */
+  readonly stopped: 'usage-limit' | 'unknown' | null
+  readonly stopResets: string | null
+}
+
+const NOT_STOPPED: StopReading = { stopped: null, stopResets: null }
+const UNREADABLE: StopReading = { stopped: 'unknown', stopResets: null }
+
+/**
+ * The largest measured distance from a final stop to the end of its file is
+ * under 4 KiB, while a live transcript reaches hundreds of megabytes, so the
+ * read stays positional and never loads the file.
+ */
+const WINDOW_BYTES = 1024 * 1024
+
+function readTail(path: string): {
+  readonly text: string
+  readonly cut: boolean
+} {
+  const fd = openSync(path, 'r')
+  try {
+    const { size } = fstatSync(fd)
+    const length = Math.min(size, WINDOW_BYTES)
+    const start = size - length
+    const buffer = Buffer.alloc(length)
+    let filled = 0
+    while (filled < length) {
+      const read = readSync(fd, buffer, filled, length - filled, start + filled)
+      if (read === 0) break
+      filled += read
+    }
+    return {
+      text: buffer.subarray(0, filled).toString('utf8'),
+      cut: start > 0,
+    }
+  } finally {
+    closeSync(fd)
+  }
+}
+
+function parseEntry(line: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(line)
+    return typeof parsed === 'object' && parsed !== null
+      ? (parsed as Record<string, unknown>)
+      : null
+  } catch {
+    return null
+  }
+}
+
+function entryText(message: Record<string, unknown>): string {
+  if (!Array.isArray(message.content)) return ''
+  return message.content
+    .map((block: { text?: unknown } | null) =>
+      typeof block?.text === 'string' ? block.text : '',
+    )
+    .join('\n')
+}
+
+/**
+ * Walks back to the entry that decides the row. No published contract describes
+ * the stop entry, so this rests on a measured shape: `error: "rate_limit"`, a
+ * `<synthetic>` model, `isApiErrorMessage`, and text naming the limit and its
+ * reset.
+ *
+ * A generated entry with limit wording and any other shape reads `unknown`,
+ * since a release renaming the field or the type still parses cleanly and would
+ * otherwise read as a session that never stopped. A `<synthetic>` entry with no
+ * error and no limit wording is passed over, since a client restart writes one
+ * reading `No response requested.` with no model turn behind it.
+ */
+function readEntries(text: string, cut: boolean): StopReading {
+  const lines = text.split('\n')
+  // The first line of a cut window usually starts mid-entry, and one that
+  // happens to parse cannot be told apart from it.
+  const first = cut ? 1 : 0
+
+  for (let index = lines.length - 1; index >= first; index -= 1) {
+    const entry = parseEntry(lines[index] ?? '')
+    if (entry === null || entry.isSidechain === true) continue
+
+    const message =
+      typeof entry.message === 'object' && entry.message !== null
+        ? (entry.message as Record<string, unknown>)
+        : {}
+    const synthetic = message.model === '<synthetic>'
+    const generated = synthetic || entry.isApiErrorMessage === true
+    const entryWords = generated ? entryText(message) : ''
+    const worded = /hit your .* limit/.test(entryWords)
+
+    if (entry.type !== 'assistant') {
+      if (worded) return UNREADABLE
+      continue
+    }
+
+    if (entry.error === 'rate_limit') {
+      return {
+        stopped: 'usage-limit',
+        stopResets: /resets (.+)/.exec(entryText(message))?.[1]?.trim() ?? null,
+      }
+    }
+    if (worded) return UNREADABLE
+    if (synthetic && entry.error === undefined) continue
+
+    return NOT_STOPPED
+  }
+
+  return cut ? UNREADABLE : NOT_STOPPED
+}
+
+/**
+ * Reads whether a usage limit stopped one roster row, from the tail of its
+ * transcript. A `busy` row reads nothing, since a turn is running and a resume
+ * may be in flight.
+ */
+export function readStop(
+  row: Pick<ResolvedSession, 'status' | 'sessionId'>,
+  dir: string = projectsDir(),
+): StopReading {
+  if (row.status === 'busy') return NOT_STOPPED
+  if (row.sessionId === null) return UNREADABLE
+
+  const located = locateTranscript(row.sessionId, dir)
+  if (located === null) return UNREADABLE
+
+  let tail: ReturnType<typeof readTail>
+  try {
+    tail = readTail(located.transcript)
+  } catch {
+    return UNREADABLE
+  }
+
+  return readEntries(tail.text, tail.cut)
+}

package/src/sessions/transfer/bundle.ts

@@ -21,7 +21,7 @@ import {
   readSideFolder,
   readTranscript,
   transcriptFacts,
-} from '@/sessions/transfer/transcript'
+} from '@/sessions/transcript'
 
 /** Bumped when a field changes meaning, so an older import refuses a newer bundle. */
 export const BUNDLE_FORMAT = 1