@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/run/ship/run-ship-review.ts

@@ -23,12 +23,18 @@ const LINE_SEPARATOR = /\r?\n/u
 const HIGH = 'high'
 const MEDIUM = 'medium'
 const FIXED_PREFIX = 'fixed '
+const KIND_FIELDS = 2
 // What a finding line carries after its spec: one sentence saying what is wrong, so a stopped ship's
 // log tells the resumed lane child the defect rather than only its location.
 const DESCRIPTION_SEPARATOR = ' — '
 // Where the spec ends on read: a reviewer that types the dash as `-`, `--` or `–` still ends it there,
 // so its sentence never lands in the ledger's file field.
 const DESCRIPTION_BOUNDARY = / [—–-]{1,2} /u
+// Where a description's first sentence ends, and the cap that keeps a run-on one a line. Japanese
+// sets no space after `。`, so it ends a sentence on its own.
+const SENTENCE_END = /(?<=[.!?])\s|(?<=。)/u
+const SENTENCE_LIMIT = 200
+const ELLIPSIS = '…'
 
 const VERDICT = {
 	CLEAN: 'clean',
@@ -57,6 +63,15 @@ interface Finding {
 	spec: string
 	is_fixed: boolean
 	line: string
+	description: string
+}
+
+// One finding that decided a stopped review, as the durable stop log keeps it: its kind, the
+// `<file>[:<line>]` it cites and the first sentence of what it said (joshuafolkken/kit#4519).
+interface StopFinding {
+	kind: string
+	location: string
+	sentence: string
 }
 
 const MISSING_NOTE = 'the reviewer wrote no findings file — the review did not complete'
@@ -120,17 +135,30 @@ function verification_prompt(brief_path: string, findings_path: string, issue: s
 	].join(' ')
 }
 
-// The spec is what `review:record` reads; the description after it travels only in the stage output.
-function spec_of(unmarked: string): string {
-	const end = unmarked.search(DESCRIPTION_BOUNDARY)
+// The spec is what `review:record` reads; the description after it travels in the stage output and,
+// for a finding that stopped the ship, its first sentence in the durable stop log.
+function split_description(unmarked: string): { spec: string; description: string } {
+	const boundary = DESCRIPTION_BOUNDARY.exec(unmarked)
+
+	if (boundary === null) return { spec: unmarked.trim(), description: '' }
 
-	return (end === -1 ? unmarked : unmarked.slice(0, end)).trim()
+	const rest = unmarked.slice(boundary.index + boundary[0].length)
+
+	return { spec: unmarked.slice(0, boundary.index).trim(), description: rest.trim() }
 }
 
 function finding_of(line: string): Finding {
 	const is_fixed = line.startsWith(FIXED_PREFIX)
 
-	return { spec: spec_of(is_fixed ? line.slice(FIXED_PREFIX.length) : line), is_fixed, line }
+	return { ...split_description(is_fixed ? line.slice(FIXED_PREFIX.length) : line), is_fixed, line }
+}
+
+function first_sentence(description: string): string {
+	const [sentence = ''] = description.split(SENTENCE_END, 1)
+
+	if (sentence.length <= SENTENCE_LIMIT) return sentence
+
+	return `${sentence.slice(0, SENTENCE_LIMIT - ELLIPSIS.length)}${ELLIPSIS}`
 }
 
 function spec_findings(text: string): ReadonlyArray<Finding> {
@@ -153,6 +181,43 @@ function is_blocking(finding: Finding): boolean {
 	return severity === HIGH || (severity === MEDIUM && !finding.is_fixed)
 }
 
+function kind_of(finding: Finding): string {
+	return finding.spec.split(':', KIND_FIELDS).join(':')
+}
+
+function kinds_of(findings: ReadonlyArray<Finding>): ReadonlyArray<string> {
+	return [...new Set(findings.map((finding) => kind_of(finding)))]
+}
+
+function stop_finding_of(finding: Finding): StopFinding {
+	const location = review_record_cli.parse_finding(finding.spec)?.file ?? ''
+
+	return { kind: kind_of(finding), location, sentence: first_sentence(finding.description) }
+}
+
+// `bug-risks:medium` — each kind of finding that decided a stopped stage, once per kind (the stop
+// counts once under each in `lane:stats`), so the lane ledger records which kinds of finding stop a
+// lane rather than only that one did (joshuafolkken/kit#4426). The blocking findings decide it where
+// there are any; otherwise the stop was decided by the fixes — round-1 fixes red on the scoped pair, or
+// a round 2 that edited the tree — so the fixed findings do. A line outside the grammar is the stage's
+// own prose and never counts.
+function deciding_findings(text: string): ReadonlyArray<Finding> {
+	const findings = spec_findings(text).filter((finding) => is_recordable(finding))
+	const blocking = findings.filter((finding) => is_blocking(finding))
+
+	return blocking.length > 0 ? blocking : findings.filter((finding) => finding.is_fixed)
+}
+
+function blocking_kinds(text: string): ReadonlyArray<string> {
+	return kinds_of(deciding_findings(text))
+}
+
+// The same findings `blocking_kinds` counts, each one whole — every finding, not once per kind — so a
+// stop can be classified by what was found where, not only by its kind (joshuafolkken/kit#4519).
+function blocking_details(text: string): ReadonlyArray<StopFinding> {
+	return deciding_findings(text).map((finding) => stop_finding_of(finding))
+}
+
 function scored_kind(findings: ReadonlyArray<Finding>): ScoredVerdict['kind'] {
 	if (findings.some((finding) => is_blocking(finding))) return VERDICT.BLOCKING
 
@@ -216,6 +281,8 @@ const run_ship_review = {
 	FIXED_PREFIX,
 	UNVERIFIED_OUTCOME,
 	VERDICT,
+	blocking_details,
+	blocking_kinds,
 	has_fixes,
 	is_clean_round_one,
 	read_verdict,
@@ -225,5 +292,5 @@ const run_ship_review = {
 	verification_prompt,
 }
 
-export type { ReviewVerdict, RoundOutcome, ScoredVerdict }
+export type { ReviewVerdict, RoundOutcome, ScoredVerdict, StopFinding }
 export { run_ship_review }

package/scripts/run/ship/run-ship-reviewer.ts

@@ -0,0 +1,207 @@
+import { agent_argv, type AgentArgv } from '#scripts/agent/agent-argv'
+import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
+import { api_auth } from '#scripts/agent/api-auth'
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { lane_session_broker } from '#scripts/lane/lane-session-broker'
+import { detached_launch } from '#scripts/run/detached-launch'
+import { run_ship_review } from './run-ship-review'
+import type { Phase } from './run-ship-scoped'
+import { run_ship_stop_cause, type Cause } from './run-ship-stop-cause'
+import type { StepResult } from './run-ship-sync'
+
+// The reviewer half of `josh ship --review` (`run-ship-review-steps.ts`): a brief-minting command, a
+// reviewer session handed what it printed, and the attestation that the session read this checkout.
+// Every review round the ship runs — round 1, the interaction review, round 2 — launches through here.
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const should_forward_stderr = true
+const ATTEST_CHECK = ['review:attest', '--check']
+const KEPT_REVIEW_NOTE =
+	'the reviewer wrote its findings before it failed — its review is kept; attest and record judge it.'
+type Round = '1' | '2'
+
+const ROUND_ONE: Round = '1'
+const ROUND_TWO: Round = '2'
+type PromptOf = (brief_path: string, findings_path: string, issue: string) => string
+
+const { CAUSE } = run_ship_stop_cause
+
+// **Every stop is tagged with the step's own cause**, so a round that stopped on a red join, a reviewer
+// that did not finish or a refused attestation is not booked as a finding (joshuafolkken/kit#4431).
+function failure(out: string, cause: Cause): StepResult {
+	return { code: FAILURE_EXIT_CODE, out, cause }
+}
+
+function tagged(cause: Cause, result: JoshResult): StepResult {
+	return result.code === SUCCESS_EXIT_CODE ? result : { ...result, cause }
+}
+
+function tagged_phase(cause: Cause, phase: Phase): Phase {
+	return async () => tagged(cause, await phase())
+}
+
+function paths(): { brief: string; findings: string; log: string } {
+	return lane_session_broker.review_paths(PROJECT_ROOT)
+}
+
+async function josh(argv: ReadonlyArray<string>): Promise<JoshResult> {
+	return await josh_command.josh_run(argv, should_forward_stderr)
+}
+
+function note(text: string): void {
+	process.stderr.write(`${text}\n`)
+}
+
+// A reviewer that could not authenticate is named as such (`api-auth.ts`), so the stop is not booked as
+// a review finding (joshuafolkken/kit#4216).
+function exited_note(log_path: string): string {
+	const exited = `reviewer failed — log: ${log_path}`
+
+	if (!api_auth.is_auth_failed_transcript(stamp_file.read_stamp_text(log_path))) return exited
+
+	return `${api_auth.AUTH_FAILURE_NOTE}: ${exited}`
+}
+
+function current_verdict(): ReturnType<typeof run_ship_review.read_verdict> {
+	return run_ship_review.read_verdict(stamp_file.read_stamp_text(paths().findings))
+}
+
+// **A session that ran and then failed keeps the review it wrote** (joshuafolkken/kit#4562). The
+// findings file is removed before the launch and written as the reviewer's last step, so a readable one
+// is this session's finished review — a late auth failure or a lost broker reply then costs nothing,
+// where a relaunch would review the whole change again. The attest and record phases still judge it.
+function ended_session(failed_note: string): JoshResult {
+	if (current_verdict().kind === run_ship_review.VERDICT.INVALID) {
+		return failure(failed_note, CAUSE.INFRA)
+	}
+
+	note(`${failed_note}\n${KEPT_REVIEW_NOTE}`)
+
+	return { code: SUCCESS_EXIT_CODE, out: '' }
+}
+
+// Under the round's reviewer profile — the same model and effort (`JOSH_REVIEWER_*` included) the
+// chain's subagent is given — and waited on, so the join below runs only once the review has finished.
+// Each call is its own process, so round 2 is a fresh session by construction.
+async function run_direct_session(
+	argv: AgentArgv,
+	profile: AgentProfile,
+	log_path: string,
+	round: Round,
+): Promise<JoshResult> {
+	const request = { argv, cwd: PROJECT_ROOT, log_path, profile }
+
+	note(agent_role_profile.describe_review(Number(round), profile))
+	const result = await detached_launch.launch_attached(request, note)
+
+	if (result.kind === 'failed') {
+		return failure(`reviewer could not start: ${result.note}`, CAUSE.INFRA)
+	}
+
+	if (result.exit_code !== SUCCESS_EXIT_CODE) return ended_session(exited_note(log_path))
+
+	return { code: SUCCESS_EXIT_CODE, out: '' }
+}
+
+// A lane child's reviewer is started by the lane's broker: an OpenAI lane's always, since a nested Codex
+// cannot write outside its sandbox, and a Claude lane's whenever the `run:wake` supervisor serves it, since this
+// ship was started from the child's Bash tool and so never received a token-only credential
+// (joshuafolkken/kit#3817). A Claude lane nobody serves starts the reviewer itself, as before.
+function is_brokered(profile: AgentProfile, issue: string): boolean {
+	if (!lane_child_marker.is_child_of(PROJECT_ROOT)) return false
+
+	return profile.provider === 'openai' || lane_session_broker.is_serving(PROJECT_ROOT, issue)
+}
+
+async function run_session(
+	prompt: string,
+	log_path: string,
+	issue: string,
+	round: Round,
+): Promise<JoshResult> {
+	const built = agent_argv.review_in(prompt, Number(round), PROJECT_ROOT)
+
+	if (built.kind === 'rejected') {
+		return failure(`reviewer profile rejected: ${built.note}`, CAUSE.INFRA)
+	}
+
+	if (!is_brokered(built.profile, issue)) {
+		return await run_direct_session(built.argv, built.profile, log_path, round)
+	}
+
+	const answer = await lane_session_broker.request(PROJECT_ROOT, issue, { kind: 'review', round })
+
+	return answer.is_success
+		? { code: SUCCESS_EXIT_CODE, out: '' }
+		: ended_session(`isolated reviewer failed: ${answer.reason}`)
+}
+
+// The brief goes to a file and the previous round's findings are removed, so a reviewer that writes
+// nothing reads as unfinished rather than as the last round's verdict.
+async function launch_reviewer(
+	brief: string,
+	prompt_of: PromptOf,
+	issue: string,
+	round: Round,
+): Promise<JoshResult> {
+	const target = paths()
+
+	stamp_file.write_text_stamp(target.brief, brief)
+	stamp_file.remove_stamp(target.findings)
+
+	return await run_session(
+		prompt_of(target.brief, target.findings, issue),
+		target.log,
+		issue,
+		round,
+	)
+}
+
+// A refused attestation — the issue changed after the brief, an update left unread, no attestation —
+// is no finding: the round read what it was briefed on.
+async function attest_phase(): Promise<StepResult> {
+	return tagged(CAUSE.ATTEST, await josh(ATTEST_CHECK))
+}
+
+// A brief-minting command, then a reviewer handed what it printed.
+function reviewed(
+	open: ReadonlyArray<string>,
+	prompt_of: PromptOf,
+	issue: string,
+	round: Round,
+): ReadonlyArray<Phase> {
+	const opened = { brief: '' }
+
+	return [
+		async () => {
+			const result = await josh(open)
+
+			opened.brief = result.out
+
+			return tagged(CAUSE.CHECK, result)
+		},
+		async () => await launch_reviewer(opened.brief, prompt_of, issue, round),
+	]
+}
+
+const run_ship_reviewer = {
+	attest_phase,
+	current_verdict,
+	failure,
+	josh,
+	note,
+	paths,
+	reviewed,
+	ROUND_ONE,
+	ROUND_TWO,
+	SUCCESS_EXIT_CODE,
+	tagged,
+	tagged_phase,
+}
+
+export type { Round }
+export { run_ship_reviewer }

package/scripts/run/ship/run-ship-stage.ts

@@ -44,6 +44,9 @@ interface ShipState {
 	is_committed: boolean
 	is_pushed: boolean
 	is_merged: boolean
+	// The issue changed after the recorded review's brief (`issue-watch-gate.ts`), so the review re-runs
+	// even on a committed tree (joshuafolkken/kit#4221).
+	is_review_stale?: boolean
 }
 
 const RECORD_PREFIX = 'josh-ship-stages-'
@@ -56,15 +59,24 @@ const STARTED_INDEX = 3
 const WORD_COUNT = STARTED_INDEX + 1
 
 // `started` lists the stages the current attempt started, kept across a supervisor that ended without a
-// stop so its successor's lines still carry them.
+// stop so its successor's lines still carry them. `is_merge_waiting` is set only while `josh followup`
+// itself runs, `is_place_waiting` only while a followup stop waits for a lane place
+// (`run-ship-place.ts`) (joshuafolkken/kit#4466).
 const record_schema = z.object({
 	done: z.array(z.string()),
 	started: z.array(z.string()).default([]),
+	is_merge_waiting: z.boolean().default(false),
+	is_place_waiting: z.boolean().default(false),
 })
 
 type ShipRecord = z.infer<typeof record_schema>
 
-const EMPTY_RECORD: ShipRecord = { done: [], started: [] }
+const EMPTY_RECORD: ShipRecord = {
+	done: [],
+	started: [],
+	is_merge_waiting: false,
+	is_place_waiting: false,
+}
 
 // Keyed on the repository and the issue: every lane of one repository shares the common git directory,
 // and two issues shipping from two lanes keep two records.
@@ -109,7 +121,36 @@ function mark_started(target: string, stage: Stage): void {
 // A `ship-stop` ends the attempt on the board (`run-board-phase.ts`), so the next attempt lists afresh
 // while the completed stages stay recorded.
 function end_attempt(target: string): void {
-	stamp_file.replace_stamp(target, { ...read_record(target), started: [] })
+	stamp_file.replace_stamp(target, { ...read_record(target), started: [], is_merge_waiting: false })
+}
+
+// Whether the ship waits on CI, CodeRabbit and the merge alone: its lane then holds no place under the
+// lane limit (`backlog-occupied.ts`). Cleared before any gate the followup stage runs, at a stop, and
+// when a successor supervisor opens the record, so a dead supervisor's flag frees nothing.
+function read_merge_waiting(target: string): boolean {
+	return read_record(target).is_merge_waiting
+}
+
+function mark_merge_waiting(target: string, is_merge_waiting: boolean): void {
+	stamp_file.replace_stamp(target, { ...read_record(target), is_merge_waiting })
+}
+
+// Whether a followup stop waits for a place before it relaunches its child (`run-ship-place.ts`).
+function read_place_waiting(target: string): boolean {
+	return read_record(target).is_place_waiting
+}
+
+function mark_place_waiting(target: string, is_place_waiting: boolean): void {
+	stamp_file.replace_stamp(target, { ...read_record(target), is_place_waiting })
+}
+
+// A supervisor that died mid-wait left its wait marked; its successor waits on nothing yet.
+function clear_waits(target: string): void {
+	stamp_file.replace_stamp(target, {
+		...read_record(target),
+		is_merge_waiting: false,
+		is_place_waiting: false,
+	})
 }
 
 // Removed once the report stage completes, so a later ship of the same issue starts from the preflight.
@@ -129,8 +170,9 @@ const DONE_BY: Record<Stage, (done: ReadonlySet<string>, state: ShipState) => bo
 	[STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
 	// The `--review` round precedes the commit, so a commit is its output as it
 	// is the gate's. A record alone is not honored: before a commit the tree may have been edited since
-	// the recorded round, and only a commit pins the tree that round read.
-	[STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed,
+	// the recorded round, and only a commit pins the tree that round read — unless the issue changed since.
+	[STAGE.REVIEW]: (_done, state) =>
+		state.is_merged || (state.is_committed && state.is_review_stale !== true),
 	[STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
 	// The merge of the default branch before the commit: once committed, a
 	// conflicting pull request is the followup's to merge again.
@@ -173,9 +215,11 @@ function commit_flags(state: ShipState): ReadonlyArray<string> {
 // **The newest line carries the attempt's history**: a fourth word lists every
 // stage the attempt has started, so the one line per issue a stream full of positions keeps still
 // draws the whole track. A line with no started stage keeps the three-word form.
+// The stage is a word rather than a `Stage`: the pre-detach checks, which are not one, are written in
+// the same form (`run-ship-pre-detach-timed.ts`).
 function event_text(
 	issue: string,
-	stage: Stage,
+	stage: string,
 	phase: Phase,
 	started: ReadonlyArray<string> = [],
 ): string {
@@ -205,13 +249,18 @@ const run_ship_stage = {
 	PHASE,
 	STAGE,
 	clear,
+	clear_waits,
 	commit_flags,
 	end_attempt,
 	event_text,
 	is_done,
 	mark_done,
+	mark_merge_waiting,
+	mark_place_waiting,
 	mark_started,
 	read_done,
+	read_merge_waiting,
+	read_place_waiting,
 	read_started,
 	record_path,
 	started_of,

package/scripts/run/ship/run-ship-steps.ts

@@ -1,15 +1,18 @@
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { run_ship } from './run-ship'
+import { run_ship_body_draft } from './run-ship-body-draft'
 import { run_ship_preflight } from './run-ship-preflight'
+import { run_ship_probe } from './run-ship-probe'
 import { run_ship_review_steps } from './run-ship-review-steps'
 import { run_ship_scoped } from './run-ship-scoped'
 import { run_ship_stage, type ShipState, type Stage } from './run-ship-stage'
-import { run_ship_sync, type StepResult } from './run-ship-sync'
+import { run_ship_sync, type StepResult, type WaitMark } from './run-ship-sync'
 
 // The stages `josh ship` runs, in the order a change ships, kept apart from the chaining
 // CLI so the order is read in one place.
 
 const should_forward_stderr = true
+const SUCCESS_EXIT_CODE = 0
 
 interface ShipArguments {
 	title: string
@@ -54,19 +57,22 @@ async function gate_stage(): Promise<StepResult> {
 	return { ...result, is_skipped }
 }
 
+// The default branch is merged before the gate, so the pull request opens on a branch that is current;
+// a clean merge goes on without waking anyone. A merge after the gate would move the merge base the
+// gate's record pins, so the pre-push hook could not reuse that record. **With `--review` it runs before
+// round 1 too**: the gate round 1 launches then reads the base the commit carries, so a clean round
+// leaves the gate stage a reuse rather than a whole second gate over a moved base (joshuafolkken/kit#4442).
+const SYNC_STEP: Step = {
+	stage: STAGE.SYNC,
+	header: run_ship.SYNC_HEADER,
+	run: async (args) => await run_ship_sync.sync_stage(args.number),
+}
+
 // The gate before the commit, the commit/push/PR before the merge. The gate meets the scoped pair
 // first: a round-1 reviewer may have edited the tree since the preflight, and `josh gate` refuses a tree
 // with no green record. The commit step carries the `--skip-*` flags a resumed ship needs, so an
 // existing commit or push is never made twice.
 const COMMIT_STEPS: ReadonlyArray<Step> = [
-	// The default branch is merged again before the commit, so the pull request opens on a branch that
-	// is current; a clean merge goes on without waking anyone. It runs before the gate: a merge after it
-	// would move the merge base the gate's record pins, so the pre-push hook could not reuse that record.
-	{
-		stage: STAGE.SYNC,
-		header: run_ship.SYNC_HEADER,
-		run: async (args) => await run_ship_sync.sync_stage(args.number),
-	},
 	{
 		stage: STAGE.GATE,
 		header: run_ship.GATE_HEADER,
@@ -80,12 +86,36 @@ const COMMIT_STEPS: ReadonlyArray<Step> = [
 	},
 ]
 
+// The followup's merge wait on the stage record, written best-effort as the stages are
+// (`run-ship-cli.ts`): a lost mark only keeps the lane counted (joshuafolkken/kit#4466).
+function wait_mark(target: string | undefined): WaitMark {
+	return function mark(is_merge_waiting: boolean): void {
+		if (target === undefined) return
+
+		try {
+			run_ship_stage.mark_merge_waiting(target, is_merge_waiting)
+		} catch {
+			// Best-effort: an unmarked wait holds the lane's place, the safe direction.
+		}
+	}
+}
+
+// The merge, then the ship body draft goes with it (`run-ship-body-draft.ts`).
+async function followup_stage(args: ShipArguments): Promise<StepResult> {
+	const mark = wait_mark(await run_ship_probe.record_target(args.number))
+	const result = await run_ship_sync.followup_stage(args.title, args.notify, mark)
+
+	if (result.code === SUCCESS_EXIT_CODE) await run_ship_body_draft.remove(args.number)
+
+	return result
+}
+
 // The merge before the report bookkeeping.
 const MERGE_STEPS: ReadonlyArray<Step> = [
 	{
 		stage: STAGE.FOLLOWUP,
 		header: run_ship.FOLLOWUP_HEADER,
-		run: async (args) => await run_ship_sync.followup_stage(args.title, args.notify),
+		run: async (args) => await followup_stage(args),
 	},
 	{
 		stage: STAGE.REPORT,
@@ -95,14 +125,15 @@ const MERGE_STEPS: ReadonlyArray<Step> = [
 ]
 
 // `--review` puts the supervised round-1 review in front of the gate: it launches the gate itself, so
-// the gate stage that follows reuses that tree's green record unless the sync stage between them
-// merged the default branch and changed the tree. It also puts the round-2 pass between the commit
+// the gate stage that follows reuses that tree's green record unless the round changed the tree. It
+// also puts the round-2 pass between the commit
 // and the followup, so the PR opens between the rounds and round 2 runs beside CI — a no-op when
 // round 1 left no fix delta.
 const REVIEW_STEP: Step = {
 	stage: STAGE.REVIEW,
 	header: run_ship.REVIEW_HEADER,
-	run: async (args) => await run_ship_review_steps.review_stage(args.number),
+	run: async (args, state) =>
+		await run_ship_review_steps.review_stage(args.number, state.is_review_stale === true),
 }
 const ROUND_TWO_STEP: Step = {
 	stage: STAGE.ROUND_TWO,
@@ -111,9 +142,9 @@ const ROUND_TWO_STEP: Step = {
 }
 
 function steps(args: ShipArguments): ReadonlyArray<Step> {
-	if (!args.is_review) return [PREFLIGHT_STEP, ...COMMIT_STEPS, ...MERGE_STEPS]
+	if (!args.is_review) return [PREFLIGHT_STEP, SYNC_STEP, ...COMMIT_STEPS, ...MERGE_STEPS]
 
-	return [PREFLIGHT_STEP, REVIEW_STEP, ...COMMIT_STEPS, ROUND_TWO_STEP, ...MERGE_STEPS]
+	return [PREFLIGHT_STEP, SYNC_STEP, REVIEW_STEP, ...COMMIT_STEPS, ROUND_TWO_STEP, ...MERGE_STEPS]
 }
 
 const run_ship_steps = { PREFLIGHT_STEP, steps }