@joshuafolkken/kit 1.1383.0 → 1.1435.0

package/scripts/lane/lane-spent.ts

@@ -0,0 +1,195 @@
+import { backlog_drive_restore } from '#scripts/backlog/backlog-drive-restore'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { git_command } from '#scripts/git/git-command'
+import { issue_state } from '#scripts/issue/issue-state'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { run_hold } from '#scripts/run/hold/run-hold'
+import {
+	PROCESS_ALIVE,
+	PROCESS_NONE,
+	PROCESS_UNKNOWN,
+	type ProcessTrace,
+} from '#scripts/run/run-liveness'
+import { lane_await } from './lane-await'
+import { lane_registry, type LaneInfo } from './lane-registry'
+
+// Whether a lane is in use, and whether it is spent — the one reading `lane:prune` discards a lane
+// on and `josh backlogrun` keeps a watching run on.
+//
+// **In use means a child is working in it, or nobody could tell.** A lane a past run left behind has
+// no process, and counting it as open kept a watching run from being replaced for as long as the lane
+// sat there. An unanswered probe is in use: both callers act on "nobody is here", and the lane a
+// wrong answer costs is one with a child mid-change.
+//
+// **Spent is all five: no child, the issue closed, not in flight, a clean tree, no commit off every
+// remote.** `lane:close` forces the removal, so each condition names something a close cannot give
+// back — and a condition that could not be read keeps the lane, with the reason said.
+//
+// **A lane the running `backlogrun` still has in flight is its `run:merge`'s.** A child that merged
+// while no driver watched leaves a lane that reads spent on every other count; closed here, the run
+// would have no `merge` event, no ledger line and no merged count for it (`run-tidy-lanes.ts`).
+
+const STATE_FIELD = 'state'
+const CLOSED_STATE = 'CLOSED'
+
+interface SpentProbes {
+	process_trace: (issue: string) => ProcessTrace
+	issue_state: (issue: string) => Promise<string | undefined>
+	// The issues the running `backlogrun` launched and has not settled.
+	in_flight: () => Promise<ReadonlySet<string>>
+	is_tree_dirty: (directory: string) => Promise<boolean>
+	unpushed_commits: (branch: string) => Promise<number | undefined>
+}
+
+interface KeptLane {
+	issue: string
+	reason: string
+}
+
+// The lanes that are in use, apart: a probe that did not answer is not a child seen working.
+interface LaneUse {
+	working: Array<string>
+	unread: Array<string>
+}
+
+// One probe answer per lane: a second sample can disagree with the first, and a lane bucketed on
+// two answers can land in neither list.
+type TracedLane = readonly [issue: string, trace: ProcessTrace]
+
+interface SpentSort {
+	spent: Array<LaneInfo>
+	kept: Array<KeptLane>
+}
+
+type Check = (lane: LaneInfo, probes: SpentProbes) => Promise<string | undefined>
+
+async function read_issue_state(issue: string): Promise<string | undefined> {
+	const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELD)
+
+	return json === undefined ? undefined : issue_state.parse_issue_state(json)?.state
+}
+
+async function read_unpushed_commits(branch: string): Promise<number | undefined> {
+	try {
+		return await git_command.commit_count_unpushed(branch)
+	} catch {
+		return undefined
+	}
+}
+
+async function read_in_flight(): Promise<ReadonlySet<string>> {
+	return backlog_drive_restore.active_issues(await run_event_stream_emit.current_events())
+}
+
+const LIVE_PROBES: SpentProbes = {
+	process_trace: lane_await.process_trace_default,
+	issue_state: read_issue_state,
+	in_flight: read_in_flight,
+	is_tree_dirty: run_hold.is_tree_dirty,
+	unpushed_commits: read_unpushed_commits,
+}
+
+// A stranded lane has no work tree for a child to be in, so it is never in use.
+function trace_of(lane: LaneInfo, probes: SpentProbes): ProcessTrace {
+	return lane.is_stranded ? PROCESS_NONE : probes.process_trace(lane.issue)
+}
+
+async function child_reason(lane: LaneInfo, probes: SpentProbes): Promise<string | undefined> {
+	const trace = probes.process_trace(lane.issue)
+
+	if (trace === PROCESS_NONE) return undefined
+
+	return trace === PROCESS_ALIVE
+		? 'a child is still working in it'
+		: 'whether a child is working in it could not be read'
+}
+
+async function issue_reason(lane: LaneInfo, probes: SpentProbes): Promise<string | undefined> {
+	const state = await probes.issue_state(lane.issue)
+
+	if (state === CLOSED_STATE) return undefined
+
+	return state === undefined ? 'its issue could not be read' : 'its issue is still open'
+}
+
+async function run_reason(lane: LaneInfo, probes: SpentProbes): Promise<string | undefined> {
+	const in_flight = await probes.in_flight()
+
+	return in_flight.has(lane.issue)
+		? 'the running backlogrun has not collected it yet (`pnpm josh run:merge` does)'
+		: undefined
+}
+
+// `is_tree_dirty` answers dirty for a status it could not read, which is the side that keeps the lane.
+async function tree_reason(lane: LaneInfo, probes: SpentProbes): Promise<string | undefined> {
+	return (await probes.is_tree_dirty(lane.directory)) ? 'it has uncommitted changes' : undefined
+}
+
+async function commit_reason(lane: LaneInfo, probes: SpentProbes): Promise<string | undefined> {
+	const count = await probes.unpushed_commits(lane.branch)
+
+	if (count === 0) return undefined
+
+	return count === undefined
+		? 'its commits could not be counted'
+		: `it has ${String(count)} commit(s) that are on no remote`
+}
+
+// In the order a person acts on them: a running child outranks everything, and an open issue is why
+// the lane exists at all.
+const CHECKS: ReadonlyArray<Check> = [
+	child_reason,
+	issue_reason,
+	run_reason,
+	tree_reason,
+	commit_reason,
+]
+
+// Why the lane is kept, or `undefined` for a spent one.
+async function kept_reason(
+	lane: LaneInfo,
+	probes: SpentProbes = LIVE_PROBES,
+): Promise<string | undefined> {
+	const reasons = await Promise.all(CHECKS.map(async (check) => await check(lane, probes)))
+
+	return reasons.find((reason) => reason !== undefined)
+}
+
+// Every live lane as spent or kept. A stranded lane is neither: `lane:prune` closes it already.
+async function sort_lanes(
+	lanes: ReadonlyArray<LaneInfo>,
+	probes: SpentProbes = LIVE_PROBES,
+): Promise<SpentSort> {
+	const live = lanes.filter((lane) => !lane.is_stranded)
+	const reasons = await Promise.all(live.map(async (lane) => await kept_reason(lane, probes)))
+	const sorted: SpentSort = { spent: [], kept: [] }
+
+	for (const [index, lane] of live.entries()) {
+		const reason = reasons[index]
+
+		if (reason === undefined) sorted.spent.push(lane)
+		else sorted.kept.push({ issue: lane.issue, reason })
+	}
+
+	return sorted
+}
+
+function issues_traced(traced: ReadonlyArray<TracedLane>, trace: ProcessTrace): Array<string> {
+	return traced.filter(([, answer]) => answer === trace).map(([issue]) => issue)
+}
+
+/** The lanes in use — what a run being replaced must not be stopped over. */
+async function lanes_in_use(probes: SpentProbes = LIVE_PROBES): Promise<LaneUse> {
+	const lanes = await lane_registry.list_lanes()
+	const traced = lanes.map((lane): TracedLane => [lane.issue, trace_of(lane, probes)])
+
+	return {
+		working: issues_traced(traced, PROCESS_ALIVE),
+		unread: issues_traced(traced, PROCESS_UNKNOWN),
+	}
+}
+
+const lane_spent = { kept_reason, lanes_in_use, sort_lanes }
+
+export type { KeptLane, LaneUse, SpentProbes, SpentSort }
+export { lane_spent }

package/scripts/lane/lane-stage-stats.ts

@@ -112,11 +112,15 @@ function stage_row(stage: string, measured: Measured): string {
 	])
 }
 
+function measured_of(entries: ReadonlyArray<LedgerEntry>): Measured {
+	const stages = entries.filter(is_stage)
+
+	return { implement: implement_durations(entries.filter(is_dispatch), stages), stages }
+}
+
 // The period's table: `entries` is the whole ledger, filtered here to `window`.
 function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
-	const period = lane_stats.in_window(entries, window)
-	const stages = period.filter(is_stage)
-	const measured = { implement: implement_durations(period.filter(is_dispatch), stages), stages }
+	const measured = measured_of(lane_stats.in_window(entries, window))
 
 	return [
 		lane_stats.to_row(COLUMNS),
@@ -125,10 +129,30 @@ function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string
 	].join('\n')
 }
 
+// Each stage's median over every entry given, a stage nothing recorded left out rather than read as
+// `0` — how long a stage usually takes, which `run:board` measures a running child's phase against.
+function medians(entries: ReadonlyArray<LedgerEntry>): ReadonlyMap<string, number> {
+	const measured = measured_of(entries)
+
+	return new Map(
+		STAGES.flatMap((stage) => {
+			const median = lane_stats.median(durations_of(stage, measured))
+
+			return median === undefined ? [] : [[stage, median] as const]
+		}),
+	)
+}
+
 const lane_stage_stats = {
 	IMPLEMENT,
 	NOT_MEASURED,
 	STAGES,
+	cell,
+	is_dispatch,
+	is_number,
+	is_stage,
+	medians,
+	started_ms,
 	table,
 }
 

package/scripts/lane/lane-stop-stats.ts

@@ -0,0 +1,96 @@
+import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
+import { lane_ledger, type LedgerEntry, type StopEntry } from './lane-ledger'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// How long a lane stood stopped: the ledger's `stop` entries of one period reduced to one row per stop
+// reason — median, maximum, how many stops were resumed and how many never were — printed by
+// `josh lane:stats` under the per-stage table, so the stop reason worth removing next is a number.
+//
+// **The wait is derived, not recorded**: from a stop to the start of the same issue's next ship stage,
+// the way `implement` is. A stop that no ship stage followed — the lane parked, or left stopped — is
+// counted under `not resumed` and kept out of the median and the maximum, whose time has no end.
+//
+// **A re-dispatch of the issue ends the search**: the new child's ship is a fresh lane's work, not the
+// resumption of a stop that may be days old.
+
+const COLUMNS = ['stop', 'median (min)', 'max (min)', 'runs', 'not resumed'] as const
+const { STAGE } = run_ship_stage
+const { is_dispatch, is_number, is_stage } = lane_stage_stats
+const REASONS = [
+	STAGE.PREFLIGHT,
+	STAGE.REVIEW,
+	STAGE.SYNC,
+	run_ship_stage.CONFLICT,
+	STAGE.GATE,
+	STAGE.COMMIT,
+	STAGE.ROUND_TWO,
+	STAGE.FOLLOWUP,
+	STAGE.REPORT,
+] as const
+
+interface StopWait {
+	reason: string
+	wait_ms: number | undefined
+}
+
+function is_stop(entry: LedgerEntry): entry is StopEntry {
+	return entry.kind === lane_ledger.KIND.STOP
+}
+
+function redispatch_ms(stop: StopEntry, entries: ReadonlyArray<LedgerEntry>): number {
+	const from_ms = Date.parse(stop.at)
+	const later = entries
+		.filter((entry) => is_dispatch(entry))
+		.filter((entry) => entry.issue === stop.issue)
+		.map((entry) => Date.parse(entry.at))
+		.filter((at) => at > from_ms)
+
+	return later.length === 0 ? Infinity : Math.min(...later)
+}
+
+function wait_ms(stop: StopEntry, entries: ReadonlyArray<LedgerEntry>): number | undefined {
+	const from_ms = Date.parse(stop.at)
+	const until_ms = redispatch_ms(stop, entries)
+	const starts = entries
+		.filter((entry) => is_stage(entry))
+		.filter((stage) => stage.issue === stop.issue)
+		.map((stage) => lane_stage_stats.started_ms(stage))
+		.filter((start) => start >= from_ms && start < until_ms)
+
+	return starts.length === 0 ? undefined : Math.min(...starts) - from_ms
+}
+
+function waits_of(entries: ReadonlyArray<LedgerEntry>): Array<StopWait> {
+	return entries
+		.filter(is_stop)
+		.map((stop) => ({ reason: stop.reason, wait_ms: wait_ms(stop, entries) }))
+}
+
+function reason_row(reason: string, waits: ReadonlyArray<StopWait>): string {
+	const of_reason = waits.filter((wait) => wait.reason === reason)
+	const resumed = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value))
+
+	return lane_stats.to_row([
+		reason,
+		lane_stage_stats.cell(lane_stats.median(resumed)),
+		lane_stage_stats.cell(lane_stats.peak(resumed)),
+		String(resumed.length),
+		String(of_reason.length - resumed.length),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const waits = waits_of(lane_stats.in_window(entries, window))
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...REASONS.map((reason) => reason_row(reason, waits)),
+	].join('\n')
+}
+
+const lane_stop_stats = { REASONS, table }
+
+export { lane_stop_stats }

package/scripts/lane/openai-lane-supervisor.ts

@@ -9,10 +9,10 @@ import { lane_child_invocation } from './lane-child-invocation'
 import { lane_child_marker } from './lane-child-marker'
 import { lane_dispatch_log } from './lane-dispatch-log'
 import type { LaneInfo } from './lane-registry'
+import { lane_session_broker } from './lane-session-broker'
 import { openai_lane_ship } from './openai-lane-ship'
 import { openai_lane_supervisor_decision } from './openai-lane-supervisor-decision'
 import { openai_lane_supervisor_owner, type SupervisorOwner } from './openai-lane-supervisor-owner'
-import { openai_review_broker } from './openai-review-broker'
 
 const { claim, read_state, release, update } = openai_lane_supervisor_owner
 const CHILD_POLL_MS = 250
@@ -178,7 +178,7 @@ async function supervise(lane: LaneInfo, profile: AgentProfile, nonce: string):
 	try {
 		if (!(await openai_lane_supervisor_decision.is_approved(lane.directory, nonce))) return 0
 
-		return await openai_review_broker.with_server(
+		return await lane_session_broker.with_server(
 			lane,
 			async () => await run_claimed(lane, profile, owner),
 		)

package/scripts/lane/process-tools.ts

@@ -0,0 +1,31 @@
+import path from 'node:path'
+
+// One definition of "the process tools a lane reads are not installed".
+//
+// **`ps` and `pgrep` are a prerequisite, not an optional probe.** The owner check walks the caller's
+// ancestry with `ps`, and lane liveness and reaping match children with `pgrep`. A machine without
+// them (a slim Debian image ships no `procps`) used to read every probe as "nothing there": the
+// ancestry stopped at the caller, `run:step` answered `unknown`, and the parent stopped before its
+// first lane with no word of why. A missing tool is refused by name instead.
+
+// What Node reports when the executable to spawn does not exist.
+const NOT_FOUND_CODE = 'ENOENT'
+const PACKAGE_HINT =
+	'install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)'
+
+function is_not_found(error: unknown): boolean {
+	return error instanceof Error && 'code' in error && error.code === NOT_FOUND_CODE
+}
+
+function missing_notice(command: string): string {
+	return `\`${path.basename(command)}\` is not installed — kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`
+}
+
+/** Throw a named refusal when `error` says `command` could not be spawned because it does not exist. */
+function throw_if_missing(command: string, error: unknown): void {
+	if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error })
+}
+
+const process_tools = { missing_notice, throw_if_missing }
+
+export { process_tools }

package/scripts/lib/buffered-process.ts

@@ -1,4 +1,6 @@
+import { existsSync } from 'node:fs'
 import { execa } from 'execa'
+import { pnpm_reach } from './pnpm-reach'
 import { SUITE_TIMEOUT_MS } from './timeouts'
 
 // One definition of "run a check, keep its output, never throw".
@@ -9,7 +11,7 @@ import { SUITE_TIMEOUT_MS } from './timeouts'
 // (so one failing check does not abort its siblings), and a bound on how long a child may hang.
 // They had the same code twice, which is how a fix to one of them missed the other.
 
-const PNPM = 'pnpm'
+const { PNPM } = pnpm_reach
 const FORCE_COLOR = '1'
 const FAIL_EXIT_CODE = 1
 
@@ -35,6 +37,38 @@ interface BufferedProcessOptions {
 	timeout_ms?: number
 }
 
+// What execa reports about a child that produced no exit code. Declared here because execa's own
+// result type does not carry `code` or `shortMessage` on the non-rejecting path, though both are
+// there at runtime whenever the child did not exit by itself.
+interface UnfinishedChild {
+	exitCode?: number | undefined
+	code?: string | undefined
+	shortMessage?: string | undefined
+}
+
+// A missing working directory is reported with the same code as a missing executable, so the code
+// alone would blame pnpm for a lane directory that was removed.
+function is_pnpm_missing(result: UnfinishedChild, cwd: string | undefined): boolean {
+	return pnpm_reach.is_not_found(result) && existsSync(cwd ?? process.cwd())
+}
+
+// Why a child has no exit code: it could not be started, it ran past its bound, or a signal ended
+// it. The child cannot say so itself — in the first case there is no child — and without this a
+// check that never ran reads as a check that failed with nothing to report.
+function unfinished_reason(result: UnfinishedChild, cwd: string | undefined): Array<string> {
+	if (result.exitCode !== undefined) return []
+	const reason = [result.shortMessage ?? '']
+	if (is_pnpm_missing(result, cwd)) reason.push(pnpm_reach.NOT_ON_PATH_NOTICE)
+
+	return reason
+}
+
+// The reason follows whatever the child wrote before it stopped: a timed-out suite's last lines
+// are the evidence, and the reason is what explains them.
+function collect_output(all: string, reason: ReadonlyArray<string>): string {
+	return [all, ...reason].filter((part) => part !== '').join('\n')
+}
+
 async function run_buffered_process(
 	command_args: ReadonlyArray<string>,
 	options: BufferedProcessOptions = {},
@@ -58,7 +92,7 @@ async function run_buffered_process(
 	})
 
 	return {
-		output: result.all,
+		output: collect_output(result.all, unfinished_reason(result, options.cwd)),
 		exit_code: result.exitCode,
 		elapsed_ms: performance.now() - started_at,
 	}

package/scripts/lib/pnpm-reach.ts

@@ -0,0 +1,27 @@
+// One definition of "pnpm is not reachable from this process", for every caller that starts pnpm.
+//
+// `josh` runs its checks as `pnpm josh <check>` children, so a `pnpm` missing from the PATH this
+// process sees fails every one of them before it starts. Nothing in the child's output can say so —
+// there is no child — and the two places that can tell the user (the spawn itself and `josh doctor`)
+// have to say the same thing.
+
+const PNPM = 'pnpm'
+// What Node reports when the executable to spawn is not on PATH.
+const NOT_FOUND_CODE = 'ENOENT'
+const PREREQUISITES_URL =
+	'https://github.com/joshuafolkken/kit/blob/main/docs/setup/prerequisites.md#2-install-pnpm-and-nodejs'
+const NOT_ON_PATH_NOTICE = [
+	'pnpm was not found on the PATH this process sees, so the command could not start.',
+	'A shell opened by an editor, an agent or a service can have a different PATH from your terminal.',
+	`Install pnpm or add its directory to that PATH: ${PREREQUISITES_URL}`,
+].join('\n')
+
+// Narrowed to the one field it reads: execa's declared result type does not carry `code` on the
+// non-rejecting path, though the value is there at runtime whenever the spawn itself failed.
+function is_not_found(result: { code?: string | undefined }): boolean {
+	return result.code === NOT_FOUND_CODE
+}
+
+const pnpm_reach = { PNPM, NOT_ON_PATH_NOTICE, is_not_found }
+
+export { pnpm_reach }

package/scripts/lib/status-icons.ts

@@ -15,10 +15,14 @@
 // `✔ verification gate passed` line to tell a green gate from the third-party warning bodies it
 // forwards, so the pass icon is under the same rule as the failure icon: declared
 // once, imported by the printer and the reader alike.
+//
+// **The warning icon is read as well.** It opens the gate's `not verified` verdict — a gate that ran no
+// check — which `josh-verdict.ts` reads back, so it is declared here for the reason the other two are.
 
 const FAIL_ICON = '✗'
 const PASS_ICON = '✔'
+const WARN_ICON = '⚠'
 
-const status_icons = { FAIL_ICON, PASS_ICON }
+const status_icons = { FAIL_ICON, PASS_ICON, WARN_ICON }
 
 export { status_icons }

package/scripts/lint/lint-parallel.ts

@@ -8,6 +8,7 @@ import {
 	FAIL_EXIT_CODE,
 	type BufferedProcessResult,
 } from '#scripts/lib/buffered-process'
+import { SKIP_MARKER } from '#scripts/test/skip-marker'
 import { cross_file_recheck, type CrossFileRecheckOptions } from './cross-file-recheck'
 
 const PRETTIER_ARGS = ['exec', 'prettier', '--check', '.'] as const
@@ -67,6 +68,22 @@ async function run_checked_eslint(
 	return await run_eslint(eslint)
 }
 
+function is_silent_pass(result: BufferedProcessResult): boolean {
+	return result.output === '' && !buffered_process.is_process_failed(result)
+}
+
+// Only beside a skipped sibling (`project_checks.ran_notice`): a `lint` that skipped nothing keeps the
+// output it always had.
+function with_ran_notice(
+	check: string,
+	result: BufferedProcessResult,
+	sibling: BufferedProcessResult,
+): BufferedProcessResult {
+	if (!sibling.output.includes(SKIP_MARKER) || !is_silent_pass(result)) return result
+
+	return { ...result, output: `${project_checks.ran_notice(check)}\n` }
+}
+
 function lint_exit_code(prettier: BufferedProcessResult, eslint: BufferedProcessResult): number {
 	return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint)
 		? FAIL_EXIT_CODE
@@ -94,8 +111,8 @@ async function run_lint_checks(
 		run_checked_eslint(directory, { args: eslint_args, recheck }),
 	])
 
-	write_output(prettier)
-	write_output(eslint)
+	write_output(with_ran_notice('prettier', prettier, eslint))
+	write_output(with_ran_notice('eslint', eslint, prettier))
 
 	return lint_exit_code(prettier, eslint)
 }

package/scripts/observations/observation-ledger-home.ts

@@ -119,6 +119,7 @@ async function append(target: string, lines: ReadonlyArray<string>): Promise<voi
 
 const observation_ledger_home = {
 	append,
+	file_path,
 	issue_path,
 	ledger_date,
 	ledger_root,

package/scripts/review/review-attest-cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 import { review_attest, type AttestVerdict } from './review-attest'
 import { review_checkout } from './review-checkout'
 
@@ -51,6 +52,22 @@ async function run_attest(nonce: string): Promise<number> {
 	return FAILURE_EXIT_CODE
 }
 
+// An attested review still describes the issue as it read it: a person's update it has not taken in,
+// or one taken in after the brief, makes its verdict stale (`issue-watch-gate.ts`).
+async function report_issue_watch(verdict: AttestVerdict): Promise<number> {
+	const refusal = await issue_watch_gate.review_refusal_here()
+
+	if (refusal !== undefined) {
+		console.error(refusal)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(attested_line(verdict))
+
+	return 0
+}
+
 // **`check_here`, not `check`** — the pointer is keyed on the repository root, and `check`'s default
 // is `PROJECT_ROOT`, which is `process.cwd()`. Run from a subdirectory, or from the session checkout
 // rather than the lane's, the two hash different keys: no pointer is found, the command prints "no
@@ -65,15 +82,13 @@ async function run_check(): Promise<number> {
 		return 0
 	}
 
-	if (verdict.status === 'ok') {
-		console.info(attested_line(verdict))
+	if (verdict.status !== 'ok') {
+		console.error(review_attest.refusal_message(verdict))
 
-		return 0
+		return FAILURE_EXIT_CODE
 	}
 
-	console.error(review_attest.refusal_message(verdict))
-
-	return FAILURE_EXIT_CODE
+	return await report_issue_watch(verdict)
 }
 
 // Anything unrecognized is a usage error rather than a default. A misspelled flag that fell through

package/scripts/review/review-brief-cli.ts

@@ -12,7 +12,7 @@ import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { find_package_directory } from '#scripts/josh/josh-logic'
 import { path_decision } from '#scripts/josh/path-decision'
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { openai_review_broker } from '#scripts/lane/openai-review-broker'
+import { lane_session_broker } from '#scripts/lane/lane-session-broker'
 import { run_ship_review } from '#scripts/run/ship/run-ship-review'
 import { review_attest } from './review-attest'
 import { review_brief } from './review-brief'
@@ -150,7 +150,7 @@ function record_round_one(
 // was written by the brief the pointer names: one left by an earlier brief is not the tree the
 // finished review read, so the resume reads the whole change instead.
 function attested_tree(checkout: ReviewCheckout): FileMapStamp | undefined {
-	const { findings } = openai_review_broker.review_paths(PROJECT_ROOT)
+	const { findings } = lane_session_broker.review_paths(PROJECT_ROOT)
 	const briefed = review_stamps.briefed_stamp.read()
 
 	if (briefed === undefined || !review_attest.is_briefed_since(briefed.taken_at, checkout.root)) {