@joshuafolkken/kit 1.953.0 → 1.957.0

package/README.md

@@ -26,6 +26,8 @@ pnpm josh format
 pnpm josh gate
 ```
 
+`josh init` is the entry without GitHub. To start a new project on the GitHub Issue workflow (`kickoff`), run `pnpm exec josh start` instead of `josh init` — it also creates the Git repository, the GitHub repository and the labels ([init.md → `josh init` or `josh start`](./docs/init.md#josh-init-or-josh-start)).
+
 It needs [Node.js](https://nodejs.org/) 22.19.0 or later with [pnpm](https://pnpm.io/), even for a `static` project; [getting-started.md](./docs/getting-started.md) installs both. The global `josh` command ([cli.md](./docs/cli.md)) and the [gh CLI](https://cli.github.com/) for `josh version` and the GitHub Issue workflow are optional.
 
 ## Documentation

package/dist/hooks/batch-guard.js

@@ -9,10 +9,10 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-V7RH56HU.js";
-import "./chunk-OM5VDM6F.js";
-import "./chunk-O3PEDF3M.js";
-import "./chunk-EYFJ74MJ.js";
+} from "./chunk-244WYOEO.js";
+import "./chunk-XSL4SRMA.js";
+import "./chunk-LDQDZYHX.js";
+import "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/{chunk-V7RH56HU.js → chunk-244WYOEO.js}

@@ -1,10 +1,10 @@
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-OM5VDM6F.js";
+} from "./chunk-XSL4SRMA.js";
 import {
   hook_decision
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 
 // scripts/hooks/batch-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-IA7WC4NS.js → chunk-3ON7HOYB.js}

@@ -5,7 +5,7 @@ import {
 import {
   ESLINT_EDIT_CACHE_FLAGS,
   time_density_hook
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 
 // scripts/hooks/format-edited-file.ts
 import { existsSync as existsSync2 } from "node:fs";

package/dist/hooks/{chunk-EYFJ74MJ.js → chunk-BELI5XSS.js}

@@ -1016,9 +1016,13 @@ var PROJECT_COMMANDS = {
   },
   start: {
     script: "scripts/init/start.ts",
-    description: "Initialize a project for the GitHub Issue workflow",
+    description: "Create a new project for the GitHub Issue workflow, from git init to labels",
     category: "Project",
-    reference: [PROFILE_ARGUMENTS, "developer", ["files", "git", "network"]]
+    reference: [
+      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public]`,
+      "developer",
+      ["files", "git", "network", "processes"]
+    ]
   },
   init: {
     script: "scripts/init/init.ts",

package/dist/hooks/{chunk-IBFC25IX.js → chunk-GNOITLRR.js}

@@ -1,16 +1,16 @@
 import {
   investigation_reads
-} from "./chunk-M4U4YNRE.js";
+} from "./chunk-HJXQZ7V4.js";
 import {
   lane_guard_policy
-} from "./chunk-OM5VDM6F.js";
+} from "./chunk-XSL4SRMA.js";
 import {
   hook_decision
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   json_value,
   time_spans
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 
 // scripts/delegation/duplicate-read-guard.ts
 import { statSync } from "node:fs";

package/dist/hooks/{chunk-M4U4YNRE.js → chunk-HJXQZ7V4.js}

@@ -1,16 +1,16 @@
 import {
   time_batch_guard
-} from "./chunk-OM5VDM6F.js";
+} from "./chunk-XSL4SRMA.js";
 import {
   hook_decision
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   cost_blocks,
   cost_transcript,
   time_bundle_call,
   time_shell,
   time_spans
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 
 // scripts/delegation/investigation-reads.ts
 import path from "node:path";

package/dist/hooks/{chunk-452OKRQX.js → chunk-IJPBTDTB.js}

@@ -1,7 +1,7 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_blocks,
@@ -12,7 +12,7 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
@@ -1625,6 +1625,7 @@ var lane_background = {
 };
 
 // scripts/git/issue-labels.ts
+var EPIC_LABEL = "epic";
 var BUG_LABEL = "bug";
 var ENHANCEMENT_LABEL = "enhancement";
 var BREAKING_CHANGE_LABEL = "breaking-change";
@@ -1632,6 +1633,66 @@ var IN_PROGRESS_LABEL = "in-progress";
 var NEEDS_DECISION_LABEL = "needs-decision";
 var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
 var ALREADY_DONE_LABEL = "already-done";
+var INTERRUPT_ROUTE_LABEL = "route:interrupt";
+var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
+var SPLIT_ROUTE_LABEL = "route:split";
+var TIER_A_ROUTE_LABEL = "route:tier-a";
+var FILING_ROUTE_LABELS = [
+  {
+    name: INTERRUPT_ROUTE_LABEL,
+    // Not `5319e7`, which is the `epic` label's purple: in a listing an interrupt would render as
+    // an epic, and the two are read at a glance rather than by name.
+    color: "1d76db",
+    // Keyed to the tests rather than to severity. "A serious defect" is the self-assessment
+    // `wip-cap.md` bans as a criterion, and this string is what a person reads in `gh label list`.
+    description: "Filed past the WIP cap \u2014 meets one of the three interrupt tests (wip-cap.md)"
+  },
+  {
+    name: REVIEW_CAP_ROUTE_LABEL,
+    color: "eab308",
+    description: "Filed by the review round cap's carry-forward (prompts/review.md \u2192 Review round cap)"
+  },
+  {
+    name: SPLIT_ROUTE_LABEL,
+    color: "0e8a16",
+    description: "A child issue created by a split (split-assessment.md)"
+  },
+  {
+    name: TIER_A_ROUTE_LABEL,
+    color: "d93f0b",
+    description: "Filed Tier A during implementation \u2014 an upstream defect or a prerequisite"
+  }
+];
+var DEPTH_0_LABEL = "depth:0";
+var DEPTH_1_LABEL = "depth:1";
+var DEPTH_2_LABEL = "depth:2";
+var DEPTH_LABELS = [
+  {
+    name: DEPTH_0_LABEL,
+    color: "0e8a16",
+    description: "Depth 0 \u2014 what a consumer of this package touches (SKILL.md \xA72i)"
+  },
+  {
+    name: DEPTH_1_LABEL,
+    color: "fbc02d",
+    description: "Depth 1 \u2014 the run orchestration that executes an Issue (SKILL.md \xA72i)"
+  },
+  {
+    name: DEPTH_2_LABEL,
+    color: "c5def5",
+    description: "Depth 2 \u2014 what measures a run (SKILL.md \xA72i)"
+  }
+];
+var WORKFLOW_LABELS = [
+  {
+    name: EPIC_LABEL,
+    color: "5319e7",
+    description: "Tracks a batch of child issues from one split"
+  },
+  { name: IN_PROGRESS_LABEL, color: "0075ca", description: "Work is actively in progress" },
+  ...FILING_ROUTE_LABELS,
+  ...DEPTH_LABELS
+];
 function has_any_label(labels, wanted) {
   return (labels ?? []).some((label) => wanted.has(label.name.toLowerCase()));
 }

package/dist/hooks/{chunk-NKVLBB65.js → chunk-KOCK5FXQ.js}

@@ -1,12 +1,12 @@
 import {
   investigation_reads
-} from "./chunk-M4U4YNRE.js";
+} from "./chunk-HJXQZ7V4.js";
 import {
   lane_guard_policy
-} from "./chunk-OM5VDM6F.js";
+} from "./chunk-XSL4SRMA.js";
 import {
   hook_decision
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 
 // scripts/delegation/investigation-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-O3PEDF3M.js → chunk-LDQDZYHX.js}

@@ -3,7 +3,7 @@ import {
   stamp_file,
   time_density_hook,
   time_hook_transcript
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 import {
   josh_environment_file
 } from "./chunk-WPALEIRX.js";

package/dist/hooks/{chunk-Z5TVZ4AP.js → chunk-M6K7EQDO.js}

@@ -35,31 +35,31 @@ import {
   run_watcher_guard,
   shell_segments,
   tail_commands
-} from "./chunk-452OKRQX.js";
+} from "./chunk-IJPBTDTB.js";
 import {
   find_local_bin_upwards
 } from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-V7RH56HU.js";
+} from "./chunk-244WYOEO.js";
 import {
   investigation_refusal
-} from "./chunk-NKVLBB65.js";
+} from "./chunk-KOCK5FXQ.js";
 import {
   duplicate_read_outcome
-} from "./chunk-IBFC25IX.js";
+} from "./chunk-GNOITLRR.js";
 import {
   investigation_reads
-} from "./chunk-M4U4YNRE.js";
+} from "./chunk-HJXQZ7V4.js";
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-OM5VDM6F.js";
+} from "./chunk-XSL4SRMA.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -71,7 +71,7 @@ import {
   stamp_file,
   time_density_hook,
   time_shell
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 
 // scripts/hooks/pretool-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-OM5VDM6F.js → chunk-XSL4SRMA.js}

@@ -1,13 +1,13 @@
 import {
   lane_child_marker
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   time_bundle_call,
   time_format,
   time_round_trips,
   time_spans,
   time_transcript_line
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 
 // scripts/lane/lane-guard-policy.ts
 var DEFAULT_MODE = "refuse";

package/dist/hooks/codex-hook-adapter.js

@@ -1,25 +1,25 @@
 #!/usr/bin/env tsx
 import {
   pretool_guard
-} from "./chunk-Z5TVZ4AP.js";
-import "./chunk-452OKRQX.js";
+} from "./chunk-M6K7EQDO.js";
+import "./chunk-IJPBTDTB.js";
 import {
   build_envelope,
   compose_context,
   format_edited_payload
-} from "./chunk-IA7WC4NS.js";
+} from "./chunk-3ON7HOYB.js";
 import "./chunk-3V37IID6.js";
-import "./chunk-V7RH56HU.js";
-import "./chunk-NKVLBB65.js";
-import "./chunk-IBFC25IX.js";
-import "./chunk-M4U4YNRE.js";
-import "./chunk-OM5VDM6F.js";
+import "./chunk-244WYOEO.js";
+import "./chunk-KOCK5FXQ.js";
+import "./chunk-GNOITLRR.js";
+import "./chunk-HJXQZ7V4.js";
+import "./chunk-XSL4SRMA.js";
 import {
   hook_decision
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   time_density_hook
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 

package/dist/hooks/duplicate-read-guard.js

@@ -9,11 +9,11 @@ import {
   is_enabled,
   notice_refusal_path,
   refusal_path
-} from "./chunk-IBFC25IX.js";
-import "./chunk-M4U4YNRE.js";
-import "./chunk-OM5VDM6F.js";
-import "./chunk-O3PEDF3M.js";
-import "./chunk-EYFJ74MJ.js";
+} from "./chunk-GNOITLRR.js";
+import "./chunk-HJXQZ7V4.js";
+import "./chunk-XSL4SRMA.js";
+import "./chunk-LDQDZYHX.js";
+import "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/format-edited.js

@@ -15,9 +15,9 @@ import {
   relative_to_root,
   resolve_invocations,
   select_invocation
-} from "./chunk-IA7WC4NS.js";
+} from "./chunk-3ON7HOYB.js";
 import "./chunk-3V37IID6.js";
-import "./chunk-EYFJ74MJ.js";
+import "./chunk-BELI5XSS.js";
 import "./chunk-RKUAD3I6.js";
 export {
   ESLINT_DAEMON,

package/dist/hooks/investigation-guard.js

@@ -10,11 +10,11 @@ import {
   is_enabled,
   load_environment_file,
   refusal_path
-} from "./chunk-NKVLBB65.js";
-import "./chunk-M4U4YNRE.js";
-import "./chunk-OM5VDM6F.js";
-import "./chunk-O3PEDF3M.js";
-import "./chunk-EYFJ74MJ.js";
+} from "./chunk-KOCK5FXQ.js";
+import "./chunk-HJXQZ7V4.js";
+import "./chunk-XSL4SRMA.js";
+import "./chunk-LDQDZYHX.js";
+import "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/pretool-guard.js

@@ -3,16 +3,16 @@ import {
   pretool_guard,
   pretool_outcome,
   pretool_outcome_async
-} from "./chunk-Z5TVZ4AP.js";
-import "./chunk-452OKRQX.js";
+} from "./chunk-M6K7EQDO.js";
+import "./chunk-IJPBTDTB.js";
 import "./chunk-3V37IID6.js";
-import "./chunk-V7RH56HU.js";
-import "./chunk-NKVLBB65.js";
-import "./chunk-IBFC25IX.js";
-import "./chunk-M4U4YNRE.js";
-import "./chunk-OM5VDM6F.js";
-import "./chunk-O3PEDF3M.js";
-import "./chunk-EYFJ74MJ.js";
+import "./chunk-244WYOEO.js";
+import "./chunk-KOCK5FXQ.js";
+import "./chunk-GNOITLRR.js";
+import "./chunk-HJXQZ7V4.js";
+import "./chunk-XSL4SRMA.js";
+import "./chunk-LDQDZYHX.js";
+import "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/stop-guard.js

@@ -16,20 +16,20 @@ import {
   run_hold,
   run_invocation,
   run_watcher_guard
-} from "./chunk-452OKRQX.js";
+} from "./chunk-IJPBTDTB.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
 import {
   hook_decision,
   lane_child_marker
-} from "./chunk-O3PEDF3M.js";
+} from "./chunk-LDQDZYHX.js";
 import {
   PROJECT_ROOT,
   stamp_file,
   time_density_hook,
   time_hook_transcript
-} from "./chunk-EYFJ74MJ.js";
+} from "./chunk-BELI5XSS.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 

package/dist/josh.js

@@ -1173,9 +1173,13 @@ var PROJECT_COMMANDS = {
   },
   start: {
     script: "scripts/init/start.ts",
-    description: "Initialize a project for the GitHub Issue workflow",
+    description: "Create a new project for the GitHub Issue workflow, from git init to labels",
     category: "Project",
-    reference: [PROFILE_ARGUMENTS, "developer", ["files", "git", "network"]]
+    reference: [
+      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public]`,
+      "developer",
+      ["files", "git", "network", "processes"]
+    ]
   },
   init: {
     script: "scripts/init/init.ts",

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.953.0",
+  "version": "1.957.0",
   "name": "@joshuafolkken/kit",
   "description": "Development toolkit for AI-assisted projects: formatting, AI assistant rules and a Git/GitHub Issue workflow for any repository, plus lint, type check, tests and hooks for Node projects",
   "keywords": [

package/scripts/backlog/backlog-drive-cli.ts

@@ -3,6 +3,7 @@ import { setTimeout as sleep } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
+import { hook_decision } from '#scripts/josh/hook-decision'
 import { josh_command } from '#scripts/josh/josh-run'
 import { lane_await, type AwaitState } from '#scripts/lane/lane-await'
 import { lane_launch_cli } from '#scripts/lane/lane-launch-cli'
@@ -24,6 +25,7 @@ import { backlog_drive_named_offer } from './backlog-drive-named-offer'
 import { backlog_drive_offer_argv } from './backlog-drive-offer-argv'
 import { backlog_drive_owner } from './backlog-drive-owner'
 import { backlog_drive_restore } from './backlog-drive-restore'
+import { backlog_drive_retrospective } from './backlog-drive-retrospective'
 import { backlog_offer_cli } from './backlog-offer-cli'
 
 // `josh backlog:drive` — the backlogrun parent's loop as one resident wait (joshuafolkken/kit#2499).
@@ -193,7 +195,7 @@ async function read_offer(
 
 	return offer === undefined
 		? undefined
-		: { ...offer, is_retrospective_done: carry.retrospective === true }
+		: { ...offer, is_retrospective_owed: backlog_drive_retrospective.is_owed(carry) }
 }
 
 // A non-zero `run:merge` prints its token first only for a hand-off (`busy`, `stop`, `retry`); any
@@ -357,6 +359,8 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {
+	// Load `.env` on the real command path only, so `JOSH_RETROSPECTIVE` set there reaches the offer read.
+	hook_decision.load_environment_file()
 	process.exitCode = await run(argv)
 }
 

package/scripts/backlog/backlog-drive-retrospective.ts

@@ -0,0 +1,20 @@
+import { doctor_consumer } from '#scripts/doctor/doctor-consumer'
+import { find_package_directory } from '#scripts/josh/josh-logic'
+import type { RunCarry } from '#scripts/run/run-carry'
+import { run_retrospective } from '#scripts/run/run-retrospective'
+
+// Whether a drain owes the retrospective, read through the owed rule `run:step` reads, so a drain it
+// owes nothing at keeps the idle watch rather than waking a session with nothing to run
+// (joshuafolkken/kit#2750). The drive is the parent's loop, never a lane child's.
+function is_owed(carry: RunCarry): boolean {
+	const root = find_package_directory(process.cwd())
+
+	return run_retrospective.is_owed({
+		is_retrospective_enabled: run_retrospective.is_enabled(),
+		is_lane_child: false,
+		is_retrospective_done: carry.retrospective === true,
+		is_consumer: doctor_consumer.is_kit_consumer(root),
+	})
+}
+
+export const backlog_drive_retrospective = { is_owed }

package/scripts/backlog/backlog-drive.ts

@@ -45,7 +45,9 @@ interface OfferRead {
 	retries: number
 	answer?: string | undefined
 	reason?: string | undefined
-	is_retrospective_done?: boolean
+	// Whether a drain here owes the retrospective: the opt-in switch is on and it has not run yet. Absent
+	// reads as not owed, so a drain with the switch off keeps the idle watch (joshuafolkken/kit#2750).
+	is_retrospective_owed?: boolean
 	is_finish?: boolean | undefined
 }
 
@@ -106,7 +108,9 @@ function ended(reason: string, state: DriveState, token?: string, issue?: string
 
 function is_drain(read: OfferRead, state: DriveState): boolean {
 	return (
-		read.verdict === WATCH_VERDICT && state.in_flight.length === 0 && !read.is_retrospective_done
+		read.verdict === WATCH_VERDICT &&
+		state.in_flight.length === 0 &&
+		read.is_retrospective_owed === true
 	)
 }
 
@@ -115,7 +119,7 @@ function needs_retrospective(read: OfferRead, state: DriveState): boolean {
 		read.verdict === STOP_VERDICT &&
 		read.answer === 'exhausted' &&
 		state.in_flight.length === 0 &&
-		!read.is_retrospective_done
+		read.is_retrospective_owed === true
 	)
 }
 

package/scripts/git/issue-labels.ts

@@ -177,6 +177,24 @@ const DEPTH_LABELS: ReadonlyArray<{
 	},
 ]
 
+// What `josh start` provisions on a new repository so the first `kickoff` finds every label a run
+// applies with its intended color (joshuafolkken/kit#2197). The `epic` and `in-progress` metadata is
+// the one the workflow documents create them with; the labels only a person applies are left out.
+const WORKFLOW_LABELS: ReadonlyArray<{
+	name: string
+	color: string
+	description: string
+}> = [
+	{
+		name: EPIC_LABEL,
+		color: '5319e7',
+		description: 'Tracks a batch of child issues from one split',
+	},
+	{ name: IN_PROGRESS_LABEL, color: '0075ca', description: 'Work is actively in progress' },
+	...FILING_ROUTE_LABELS,
+	...DEPTH_LABELS,
+]
+
 // The shape `gh issue list --json labels` returns; narrowed here so the predicate below takes any
 // listing row without importing a schema.
 interface LabelReference {
@@ -285,4 +303,5 @@ export {
 	REVIEW_ROUND2_SKIPPED_LABEL,
 	SPLIT_ROUTE_LABEL,
 	TIER_A_ROUTE_LABEL,
+	WORKFLOW_LABELS,
 }

package/scripts/init/project-profile.ts

@@ -29,12 +29,16 @@ function parse_profile(value: unknown): ProjectProfile | undefined {
 	return undefined
 }
 
-function requested_profile(args: ReadonlyArray<string>): ProjectProfile | undefined {
-	if (args.length === 0) return undefined
+function is_profile_pair(args: ReadonlyArray<string>): boolean {
+	return args.length === PROFILE_ARG_LENGTH && args[0] === '--profile'
+}
 
-	if (args.length !== PROFILE_ARG_LENGTH || args[0] !== '--profile') {
-		throw new Error('Usage: josh init [--profile static|node]')
-	}
+function requested_profile(
+	args: ReadonlyArray<string>,
+	usage = 'josh init [--profile static|node]',
+): ProjectProfile | undefined {
+	if (args.length === 0) return undefined
+	if (!is_profile_pair(args)) throw new Error(`Usage: ${usage}`)
 
 	const profile = parse_profile(args[1])
 	if (profile !== undefined) return profile

package/scripts/init/start-plan.ts

@@ -0,0 +1,145 @@
+import type { ProjectProfile } from './project-profile'
+
+type Visibility = 'private' | 'public'
+
+interface StartOptions {
+	profile: ProjectProfile | undefined
+	is_yes: boolean
+	is_github: boolean
+	visibility: Visibility
+}
+
+type StartStep = 'git_init' | 'initialize' | 'commit' | 'repository' | 'labels'
+
+interface GitState {
+	has_git: boolean
+	has_github: boolean
+	has_origin: boolean
+	branch: string | undefined
+	has_commits: boolean
+}
+
+interface StepPlan {
+	steps: ReadonlyArray<StartStep>
+	refusal: string | undefined
+}
+
+type Interaction = 'interactive' | 'unattended'
+type Consent = 'granted' | 'ask'
+
+interface Verdict<T> {
+	value: T | undefined
+	refusal: string | undefined
+}
+
+const DEFAULT_BRANCH = 'main'
+const FULL_STEPS: ReadonlyArray<StartStep> = [
+	'git_init',
+	'initialize',
+	'commit',
+	'repository',
+	'labels',
+]
+
+const STEP_LABELS: Readonly<Record<StartStep, string>> = {
+	git_init: 'Create a Git repository on main',
+	initialize: 'Initialize kit (the same setup as josh init)',
+	commit: 'Commit every file as the initial commit',
+	repository: 'Create the GitHub repository and push main',
+	labels: 'Add the workflow labels the repository is missing',
+}
+
+function refused(refusal: string): StepPlan {
+	return { steps: [], refusal }
+}
+
+// A repository that already has a history keeps it: nothing is committed on the user's behalf, and
+// only `main` is pushed, because the Issue workflow branches from and merges into it.
+function existing_git_steps(state: GitState): StepPlan {
+	if (!state.has_commits) return { steps: FULL_STEPS.slice(1), refusal: undefined }
+
+	if (state.branch !== DEFAULT_BRANCH) {
+		return refused(
+			`josh start pushes ${DEFAULT_BRANCH}, but this repository is on ${state.branch ?? 'a detached HEAD'}. Switch to ${DEFAULT_BRANCH}, or run josh init to set up without GitHub.`,
+		)
+	}
+
+	return { steps: ['initialize', 'repository', 'labels'], refusal: undefined }
+}
+
+// An existing GitHub origin is never replaced or pushed to: only the additive steps run. Any other
+// origin is refused here, before the first write — `gh repo create --remote origin` cannot add a
+// remote that already exists, so the run would otherwise fail after initializing the directory.
+function plan_steps(state: GitState): StepPlan {
+	if (state.has_github) return { steps: ['initialize', 'labels'], refusal: undefined }
+
+	if (state.has_origin) {
+		return refused(
+			'josh start creates the GitHub repository as origin, but this repository already has an origin that is not on GitHub. Remove or rename it, or run josh init to set up without GitHub.',
+		)
+	}
+
+	if (state.has_git) return existing_git_steps(state)
+
+	return { steps: FULL_STEPS, refusal: undefined }
+}
+
+function interaction_of(options: StartOptions, is_tty: boolean): Verdict<Interaction> {
+	if (options.is_yes) return { value: 'unattended', refusal: undefined }
+	if (is_tty) return { value: 'interactive', refusal: undefined }
+
+	return {
+		value: undefined,
+		refusal:
+			'josh start needs a terminal to confirm its choices. Pass --yes to accept the detected profile, and --github to create the GitHub repository.',
+	}
+}
+
+// `--yes` accepts the detected defaults, never the creation of a public-facing resource: an
+// unattended run creates and pushes a repository only when `--github` asks for it by name.
+function github_consent(
+	steps: ReadonlyArray<StartStep>,
+	options: StartOptions,
+	interaction: Interaction,
+): Verdict<Consent> {
+	if (!steps.includes('repository') || options.is_github) {
+		return { value: 'granted', refusal: undefined }
+	}
+
+	if (interaction === 'interactive') return { value: 'ask', refusal: undefined }
+
+	return {
+		value: undefined,
+		refusal:
+			'josh start --yes does not create a GitHub repository or push. Add --github to create one, or run josh init to set up without GitHub.',
+	}
+}
+
+// What a failed run prints, so the user can tell how far it got before deciding how to resume.
+function progress_report(
+	failed: StartStep,
+	completed: ReadonlyArray<StartStep>,
+	cause: string,
+): string {
+	const done =
+		completed.length === 0 ? 'nothing' : completed.map((step) => STEP_LABELS[step]).join('; ')
+
+	return `josh start stopped at: ${STEP_LABELS[failed]}\nCompleted: ${done}\nCause: ${cause}`
+}
+
+function plan_summary(steps: ReadonlyArray<StartStep>): string {
+	const lines = steps.map((step, index) => `  ${String(index + 1)}. ${STEP_LABELS[step]}`)
+
+	return ['josh start will:', ...lines].join('\n')
+}
+
+const start_plan = {
+	plan_steps,
+	interaction_of,
+	github_consent,
+	progress_report,
+	plan_summary,
+	STEP_LABELS,
+}
+export { start_plan }
+export type { Consent, GitState, Interaction, StartOptions, StartStep, StepPlan, Visibility }

package/scripts/init/start-prompt.ts

@@ -0,0 +1,55 @@
+import path from 'node:path'
+import { stdin as input, stdout as output } from 'node:process'
+import { createInterface, type Interface } from 'node:readline/promises'
+import { ask_yes_no_simple } from '#scripts/git/git-prompt'
+import { project_profile, type ProjectProfile, type ProjectShape } from './project-profile'
+import type { Consent, StartOptions } from './start-plan'
+
+interface Choices {
+	options: StartOptions
+	shape: ProjectShape
+	consent: Consent
+	root: string
+}
+
+const DECLINED =
+	'Stopped before creating the GitHub repository. Nothing was changed. Run josh init to set up without GitHub.'
+
+// The detected profile is the default, so pressing Enter accepts it; the reason is shown because an
+// ambiguous project is exactly the case this question exists for.
+async function ask_profile(prompt: Interface, shape: ProjectShape): Promise<ProjectProfile> {
+	const question = `Profile — static or node [${shape.profile}, ${shape.reason}]: `
+	const raw_answer = await prompt.question(question)
+	const answer = raw_answer.trim()
+	if (answer.length === 0) return shape.profile
+
+	return project_profile.requested_profile(['--profile', answer]) ?? shape.profile
+}
+
+async function ask_repository(prompt: Interface, choices: Choices): Promise<void> {
+	const name = path.basename(choices.root)
+	const question = `Create a ${choices.options.visibility} GitHub repository "${name}" and push main? (y/n): `
+
+	if (!(await ask_yes_no_simple(prompt, question))) throw new Error(DECLINED)
+}
+
+async function ask_choices(prompt: Interface, choices: Choices): Promise<ProjectProfile> {
+	const profile = choices.options.profile ?? (await ask_profile(prompt, choices.shape))
+	if (choices.consent === 'ask') await ask_repository(prompt, choices)
+
+	return profile
+}
+
+async function confirm_choices(choices: Choices): Promise<ProjectProfile> {
+	const prompt = createInterface({ input, output })
+
+	try {
+		return await ask_choices(prompt, choices)
+	} finally {
+		prompt.close()
+	}
+}
+
+const start_prompt = { confirm_choices }
+export { start_prompt }
+export type { Choices }

package/scripts/init/start-steps.ts

@@ -0,0 +1,167 @@
+import path from 'node:path'
+import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { WORKFLOW_LABELS } from '#scripts/git/issue-labels'
+import { self_sync_guard } from '#scripts/self-sync-guard/self-sync-guard-logic'
+import { execaSync } from 'execa'
+import { main as init_main } from './init'
+import { PACKAGE_DIR } from './init-paths'
+import type { ProjectProfile, ProjectShape } from './project-profile'
+import { start_plan, type GitState, type StartStep, type Visibility } from './start-plan'
+
+interface StepContext {
+	root: string
+	profile: ProjectProfile
+	visibility: Visibility
+}
+
+type WorkflowLabel = (typeof WORKFLOW_LABELS)[number]
+
+const DEFAULT_BRANCH = 'main'
+const LABELS_ENDPOINT = 'repos/{owner}/{repo}/labels'
+const GH_INSTALL_HINT =
+	'GitHub CLI (gh) is not installed. Install it from https://cli.github.com/, run gh auth login, then run josh start again. Nothing was changed.'
+const GH_AUTH_HINT =
+	'GitHub CLI is not signed in. Run gh auth login, then run josh start again. Nothing was changed.'
+
+function succeeds(command: string, args: ReadonlyArray<string>, root: string): boolean {
+	return execaSync(command, args, { cwd: root, reject: false }).exitCode === 0
+}
+
+function read_output(
+	command: string,
+	args: ReadonlyArray<string>,
+	root: string,
+): string | undefined {
+	const result = execaSync(command, args, { cwd: root, reject: false })
+
+	return result.exitCode === 0 ? result.stdout.trim() : undefined
+}
+
+// Every step spawned here dials GitHub directly, past a scanner's loopback proxy, the same as every
+// other `gh` spawn under scripts/ (joshuafolkken/kit#2436); a local `git` step is unaffected by it.
+function run(command: string, args: ReadonlyArray<string>, root: string): void {
+	execaSync(command, args, { ...git_gh_exec.direct_environment(), cwd: root, stdio: 'inherit' })
+}
+
+function read_git_state(root: string, shape: ProjectShape): GitState {
+	const { has_git, has_github } = shape
+
+	if (!has_git) {
+		return { has_git, has_github, has_origin: false, branch: undefined, has_commits: false }
+	}
+
+	const has_origin = succeeds('git', ['remote', 'get-url', 'origin'], root)
+	const branch = read_output('git', ['symbolic-ref', '--short', 'HEAD'], root)
+	const has_commits = succeeds('git', ['rev-parse', '--verify', '--quiet', 'HEAD'], root)
+
+	return { has_git, has_github, has_origin, branch, has_commits }
+}
+
+// Every step talks to GitHub, so the CLI is checked before the first write rather than at the step
+// that needs it — a missing `gh` then leaves the directory exactly as it was.
+function github_cli_refusal(root: string): string | undefined {
+	if (!succeeds('gh', ['--version'], root)) return GH_INSTALL_HINT
+	if (!succeeds('gh', ['auth', 'status'], root)) return GH_AUTH_HINT
+
+	return undefined
+}
+
+// `josh init` refuses to run inside the kit source repository by printing and setting the exit code
+// rather than throwing, so its step would pass and the later steps would commit and publish the
+// source repository. The same check is raised before the first write instead.
+function self_run_refusal(root: string): string | undefined {
+	return self_sync_guard.self_sync_refusal(PACKAGE_DIR, root)
+}
+
+function create_git_repository(context: StepContext): void {
+	run('git', ['init', `--initial-branch=${DEFAULT_BRANCH}`], context.root)
+}
+
+// The same setup `josh init` runs, called rather than copied, with the profile the user confirmed.
+function initialize(context: StepContext): void {
+	init_main(['--profile', context.profile])
+}
+
+function commit_all(context: StepContext): void {
+	run('git', ['add', '--all'], context.root)
+	// The first commit of a new repository has no branch to come from, so the hook that keeps commits
+	// off main — installed by the initialize step in a node project — would refuse the only commit
+	// that has to land there.
+	run('git', ['commit', '--no-verify', '--message', 'Initial commit'], context.root)
+	// A repository created by an older `git init` may name its unborn branch `master`.
+	run('git', ['branch', '--move', '--force', DEFAULT_BRANCH], context.root)
+}
+
+function create_github_repository(context: StepContext): void {
+	const name = path.basename(context.root)
+	const visibility = `--${context.visibility}`
+	const source = ['--source', '.', '--remote', 'origin', '--push']
+
+	run('gh', ['repo', 'create', name, visibility, ...source], context.root)
+}
+
+// Labels already present are left as they are — only the missing ones are created, so a repository
+// that recolored a label keeps its choice. GitHub compares label names case-insensitively.
+function missing_workflow_labels(existing: ReadonlyArray<string>): ReadonlyArray<WorkflowLabel> {
+	const names = new Set(existing.map((name) => name.toLowerCase()))
+
+	return WORKFLOW_LABELS.filter((label) => !names.has(label.name))
+}
+
+function create_label(label: WorkflowLabel, root: string): void {
+	const fields = [`name=${label.name}`, `color=${label.color}`, `description=${label.description}`]
+
+	run('gh', ['api', LABELS_ENDPOINT, ...fields.flatMap((field) => ['-f', field]), '--silent'], root)
+	console.info(`  ✔ label ${label.name}`)
+}
+
+function add_missing_labels(context: StepContext): void {
+	const listing = execaSync('gh', ['api', '--paginate', LABELS_ENDPOINT, '--jq', '.[].name'], {
+		...git_gh_exec.direct_environment(),
+		cwd: context.root,
+	})
+	const existing = listing.stdout.split('\n').filter((name) => name.length > 0)
+
+	for (const label of missing_workflow_labels(existing)) create_label(label, context.root)
+}
+
+const STEP_ACTIONS: Readonly<Record<StartStep, (context: StepContext) => void>> = {
+	git_init: create_git_repository,
+	initialize,
+	commit: commit_all,
+	repository: create_github_repository,
+	labels: add_missing_labels,
+}
+
+function run_step(
+	step: StartStep,
+	context: StepContext,
+	completed: ReadonlyArray<StartStep>,
+): void {
+	try {
+		STEP_ACTIONS[step](context)
+	} catch (error) {
+		const cause = error instanceof Error ? error.message : String(error)
+
+		throw new Error(start_plan.progress_report(step, completed, cause), { cause: error })
+	}
+}
+
+function run_steps(steps: ReadonlyArray<StartStep>, context: StepContext): void {
+	for (const [index, step] of steps.entries()) {
+		const position = `${String(index + 1)}/${String(steps.length)}`
+
+		console.info(`\n[${position}] ${start_plan.STEP_LABELS[step]}`)
+		run_step(step, context, steps.slice(0, index))
+	}
+}
+
+const start_steps = {
+	read_git_state,
+	github_cli_refusal,
+	self_run_refusal,
+	missing_workflow_labels,
+	run_steps,
+}
+export { start_steps }
+export type { StepContext }

package/scripts/init/start.ts

@@ -1,30 +1,106 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { main as init_main } from './init'
-import { project_profile, type ProjectShape } from './project-profile'
+import { project_profile, type ProjectProfile } from './project-profile'
+import {
+	start_plan,
+	type Consent,
+	type Interaction,
+	type StartOptions,
+	type StartStep,
+} from './start-plan'
+import { start_prompt, type Choices } from './start-prompt'
+import { start_steps } from './start-steps'
 
 const ARGUMENT_START_INDEX = 2
+const READY_MESSAGE = 'GitHub workflow ready. Use kickoff new in your assistant to plan an Issue.'
+const START_USAGE = 'josh start [--profile static|node] [--yes] [--github] [--public]'
+const YES_FLAG = '--yes'
+const GITHUB_FLAG = '--github'
+const PUBLIC_FLAG = '--public'
+const SWITCHES: ReadonlySet<string> = new Set([YES_FLAG, GITHUB_FLAG, PUBLIC_FLAG])
 
-function prerequisite(shape: ProjectShape): string | undefined {
-	if (!shape.has_git) return 'josh start requires Git. Run git init, or use josh init without Git.'
-	if (!shape.has_github) return 'josh start requires a GitHub origin. Add one, or use josh init.'
+interface Prepared {
+	steps: ReadonlyArray<StartStep>
+	interaction: Interaction
+	choices: Choices
+}
+
+// The switches are peeled off first, so what remains is exactly the `--profile` pair `josh init`
+// accepts — one parser for the profile in both commands.
+function parse_start_options(args: ReadonlyArray<string>): StartOptions {
+	const profile_args = args.filter((argument) => !SWITCHES.has(argument))
+
+	return {
+		profile: project_profile.requested_profile(profile_args, START_USAGE),
+		is_yes: args.includes(YES_FLAG),
+		is_github: args.includes(GITHUB_FLAG),
+		visibility: args.includes(PUBLIC_FLAG) ? 'public' : 'private',
+	}
+}
+
+function settle<T>(verdict: { value: T | undefined; refusal: string | undefined }): T {
+	if (verdict.value === undefined) throw new Error(verdict.refusal)
 
-	return undefined
+	return verdict.value
 }
 
-function main(args: ReadonlyArray<string> = []): void {
-	// --profile uses the same override as josh init.
-	const requested = project_profile.requested_profile(args)
-	const shape = project_profile.inspect_project(process.cwd(), requested)
-	const message = prerequisite(shape)
-	if (message !== undefined) throw new Error(message)
-	init_main(args)
-	console.info('GitHub workflow ready. Use kickoff in your assistant to plan an Issue.')
+function stop_on(refusal: string | undefined): void {
+	if (refusal !== undefined) throw new Error(refusal)
+}
+
+// An unattended run already holds every answer: `--profile` or the detected one, and a consent that
+// `github_consent` only grants when `--github` was given.
+async function resolve_profile(
+	choices: Choices,
+	interaction: Interaction,
+): Promise<ProjectProfile> {
+	if (interaction === 'unattended') return choices.options.profile ?? choices.shape.profile
+
+	return await start_prompt.confirm_choices(choices)
+}
+
+// Every refusal is raised here, before the first write, so a run that stops here changed nothing.
+function prepare(args: ReadonlyArray<string>, is_tty: boolean, root: string): Prepared {
+	stop_on(start_steps.self_run_refusal(root))
+	const options = parse_start_options(args)
+	const interaction = settle(start_plan.interaction_of(options, is_tty))
+	const shape = project_profile.inspect_project(root, options.profile)
+	const plan = start_plan.plan_steps(start_steps.read_git_state(root, shape))
+
+	stop_on(plan.refusal)
+	const consent: Consent = settle(start_plan.github_consent(plan.steps, options, interaction))
+
+	stop_on(start_steps.github_cli_refusal(root))
+
+	return { steps: plan.steps, interaction, choices: { options, shape, consent, root } }
+}
+
+async function main(args: ReadonlyArray<string>, is_tty: boolean): Promise<void> {
+	const { steps, interaction, choices } = prepare(args, is_tty, process.cwd())
+
+	console.info(start_plan.plan_summary(steps))
+	const profile = await resolve_profile(choices, interaction)
+	const { root, options } = choices
+
+	start_steps.run_steps(steps, { root, profile, visibility: options.visibility })
+	console.info(`\n${READY_MESSAGE}`)
+}
+
+async function run(args: ReadonlyArray<string>, is_tty: boolean): Promise<number> {
+	try {
+		await main(args, is_tty)
+
+		return 0
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error))
+
+		return 1
+	}
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	main(process.argv.slice(ARGUMENT_START_INDEX))
+	process.exitCode = await run(process.argv.slice(ARGUMENT_START_INDEX), process.stdin.isTTY)
 }
 
-const start = { prerequisite }
+const start = { run, parse_start_options }
 export { start }

package/scripts/josh/__snapshots__/josh-command-map.test.ts.snap

@@ -1103,12 +1103,13 @@ exports[`COMMAND_MAP — reference metadata > keeps every canonical command and
       ],
     ],
     "start": [
-      "[--profile static|node]",
+      "[--profile static|node] [--yes] [--github] [--public]",
       "developer",
       [
         "files",
         "git",
         "network",
+        "processes",
       ],
     ],
     "stash:pop": [

package/scripts/josh/josh-commands-project.ts

@@ -14,9 +14,13 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 	},
 	start: {
 		script: 'scripts/init/start.ts',
-		description: 'Initialize a project for the GitHub Issue workflow',
+		description: 'Create a new project for the GitHub Issue workflow, from git init to labels',
 		category: 'Project',
-		reference: [PROFILE_ARGUMENTS, 'developer', ['files', 'git', 'network']],
+		reference: [
+			`${PROFILE_ARGUMENTS} [--yes] [--github] [--public]`,
+			'developer',
+			['files', 'git', 'network', 'processes'],
+		],
 	},
 	init: {
 		script: 'scripts/init/init.ts',

package/scripts/run/run-retrospective.ts

@@ -0,0 +1,34 @@
+import { hook_decision } from '#scripts/josh/hook-decision'
+
+// Whether a run owes its end-of-run retrospective, single-sourced so `run:step` and `backlog:drive`
+// never disagree on it (joshuafolkken/kit#2750): a drive that read "owed" where `run:step` read "not
+// owed" handed back at every drain to a session that had nothing to run.
+
+// The opt-in switch that gates the retrospective (joshuafolkken/kit#2370). It defaults off, so an unset
+// variable owes no retrospective.
+const RETROSPECTIVE_ENV_KEY = 'JOSH_RETROSPECTIVE'
+
+interface RetrospectiveFacts {
+	is_retrospective_enabled: boolean
+	is_lane_child: boolean
+	is_retrospective_done: boolean
+	is_consumer: boolean
+}
+
+function is_enabled(): boolean {
+	return hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY)
+}
+
+// False when the switch is off, for a dispatched lane child (the batch runs one at its own end, never a
+// child's), once it has run this invocation, and in a consumer checkout, where the kit-only command is
+// refused. The switch is read first, so a run that has not opted in never consults the other three.
+function is_owed(facts: RetrospectiveFacts): boolean {
+	if (!facts.is_retrospective_enabled) return false
+
+	return !facts.is_lane_child && !facts.is_retrospective_done && !facts.is_consumer
+}
+
+const run_retrospective = { RETROSPECTIVE_ENV_KEY, is_enabled, is_owed }
+
+export type { RetrospectiveFacts }
+export { run_retrospective }

package/scripts/run/run-step-cli.ts

@@ -9,6 +9,7 @@ import { run_carry, type CarryRead } from './run-carry'
 import { run_event_scope } from './run-event-scope'
 import { run_event_stream } from './run-event-stream'
 import { run_prep_cli } from './run-prep-cli'
+import { run_retrospective } from './run-retrospective'
 import { run_step, type StepInput } from './run-step'
 
 // `josh run:step <N>` — print the run's next single action, computed from the event stream, the carry
@@ -22,10 +23,6 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const USAGE = 'Usage: josh run:step <issue-number>'
-// The opt-in switch that gates the end-of-run retrospective (joshuafolkken/kit#2370). Read here rather
-// than in `run-step.ts` so the position logic stays a pure function of its input; it defaults off, so an
-// unset variable prints no retrospective step.
-const RETROSPECTIVE_ENV_KEY = 'JOSH_RETROSPECTIVE'
 
 interface RunReads {
 	carry_kind: CarryRead['kind']
@@ -83,7 +80,8 @@ async function gather(issue_number: string): Promise<StepInput> {
 		is_at_cut_cap: run_reads.is_at_cut_cap,
 		is_lane_child: lane_child_marker.is_child_of(process.cwd()),
 		is_consumer: doctor_consumer.is_kit_consumer(find_package_directory(process.cwd())),
-		is_retrospective_enabled: hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY),
+		// Read here rather than in `run-step.ts` so the position logic stays a pure function of its input.
+		is_retrospective_enabled: run_retrospective.is_enabled(),
 		has_changes: parts.has_changes,
 		has_completion_callback: agent_role_profile.has_completion_callback(),
 	}

package/scripts/run/run-step.ts

@@ -2,6 +2,7 @@ import { git_stash } from '#scripts/git/git-stash'
 import { latest_scope_cli } from '#scripts/version/latest-scope-cli'
 import type { CarryRead } from './run-carry'
 import { run_event_stream } from './run-event-stream'
+import { run_retrospective } from './run-retrospective'
 
 // `josh run:step <N>` — the run's next single action, computed from three mechanical inputs and nothing
 // else (joshuafolkken/kit#2248). It is the child of epic #2166 that lifts the fold from an *event* to a
@@ -174,23 +175,10 @@ const EVENT_ACTIONS: Record<string, (issue_number: string) => StepAction> = {
 // (joshuafolkken/kit#2297).
 const PARENT_ONLY_EVENTS: ReadonlySet<string> = new Set([KIND.MERGE, KIND.OUTAGE])
 
-// Whether a run at a winding-down position still owes its end-of-run retrospective
-// (joshuafolkken/kit#2328) — false when the switch is off (the opt-in default, joshuafolkken/kit#2370),
-// for a dispatched lane child, where the batch runs one at its own end and never a child's (the
-// `release:scope` precedent), for a run whose retrospective has already run this invocation, and in a
-// consumer checkout, where the kit-only command is refused. The switch is read first, so a run that has
-// not opted in never consults the other three. The two positions that consult it are the drain and the
-// stop; both read exactly this, so the exclusion set is single-sourced.
-function is_retrospective_owed(input: StepInput): boolean {
-	if (!input.is_retrospective_enabled) return false
-
-	return !input.is_lane_child && !input.is_retrospective_done && !input.is_consumer
-}
-
 // A stopped run's last owed step is the end-of-run retrospective. When it is not owed the position stops
 // with no command to run, which is what the position meant before the retrospective existed.
 function stop_action(input: StepInput): StepAction {
-	return is_retrospective_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP)
+	return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP)
 }
 
 // The drain fires the retrospective *before* the idle watch, not after it (joshuafolkken/kit#2335): the
@@ -199,7 +187,7 @@ function stop_action(input: StepInput): StepAction {
 // run proceeds to that watch, which is a `WAIT` rather than a `STOP`: the backlog is empty but the run is
 // not ending, and the real `STOP` follows when the watch expires with the retrospective already done.
 function drain_action(input: StepInput): StepAction {
-	return is_retrospective_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT)
+	return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT)
 }
 
 // The hand-off a `backlogrun` parent without a completion callback takes right after dispatching