@joshuafolkken/kit 1.1035.0 → 1.1050.0

package/scripts/lane/lane-cli.ts

@@ -2,6 +2,8 @@
 import { fileURLToPath } from 'node:url'
 import { epic_busy } from '#scripts/epic/epic-busy'
 import { git_gh_command } from '#scripts/git/git-gh-command'
+import type { OpenIssueData } from '#scripts/git/schemas'
+import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
 import { error_text } from '#scripts/lib/error-message'
 import { run_carry } from '#scripts/run/run-carry'
 import { lane_await } from './lane-await'
@@ -150,10 +152,10 @@ function report_sweep(outcome: SweepOutcome): number {
 
 // `none` on standard output for the empty case as well, so `lane:list` keeps the contract the rest
 // of the commands follow — the prose belongs on standard error with every other explanation.
-function report_lanes(lanes: ReadonlyArray<LaneInfo>): number {
+function report_lanes(lanes: ReadonlyArray<LaneInfo>, cite: IssueCiter): number {
 	if (lanes.length === 0) console.error(lane_report.NO_LANES)
 
-	console.info(lanes.length === 0 ? NONE_TOKEN : lane_report.describe_lanes(lanes))
+	console.info(lanes.length === 0 ? NONE_TOKEN : lane_report.describe_lanes(lanes, cite))
 
 	return SUCCESS_EXIT_CODE
 }
@@ -192,23 +194,39 @@ const OCCUPANCY_UNREADABLE =
 // The `in-progress` issues this repository shows running, read the way `epic:next` reads lane
 // occupancy — never rebuilt (joshuafolkken/kit#2235). A read that could not see the whole listing is
 // `undefined`, so the difference is skipped rather than computed against a set known to be partial.
-async function to_holder_numbers(repo: string): Promise<ReadonlyArray<number> | undefined> {
+async function to_holders(repo: string): Promise<ReadonlyArray<OpenIssueData> | undefined> {
 	const read = await epic_busy.read_repository(repo)
 	if (read.kind === 'idle') return []
 
-	return read.kind === 'busy' ? read.issues.map((issue) => issue.number) : undefined
+	return read.kind === 'busy' ? read.issues : undefined
 }
 
-async function read_in_progress(): Promise<ReadonlyArray<number> | undefined> {
+// The repository and its running issues, read once: the listing cites each lane from the titles here
+// (joshuafolkken/kit#2943) and the occupancy check compares against the same set.
+interface InProgress {
+	repo: string | undefined
+	holders: ReadonlyArray<OpenIssueData> | undefined
+}
+
+async function read_in_progress(): Promise<InProgress> {
 	try {
 		const repo = await git_gh_command.repo_get_name_with_owner()
 
-		return repo === undefined ? undefined : await to_holder_numbers(repo)
+		return { repo, holders: repo === undefined ? undefined : await to_holders(repo) }
 	} catch {
-		return undefined
+		return { repo: undefined, holders: undefined }
 	}
 }
 
+function citer_of(in_progress: InProgress): IssueCiter {
+	const holders = in_progress.holders ?? []
+
+	return issue_cite.citer(
+		in_progress.repo,
+		new Map(holders.map((issue) => [String(issue.number), issue.title])),
+	)
+}
+
 // A stranded lane's work tree is gone, so it holds no issue: it counts as no lane rather than a live
 // one, which is what turns its surviving `in-progress` label into a `stopped` anomaly.
 function live_lane_issues(lanes: ReadonlyArray<LaneInfo>): Array<number> {
@@ -217,16 +235,15 @@ function live_lane_issues(lanes: ReadonlyArray<LaneInfo>): Array<number> {
 
 // The lane/label difference, printed to standard error beside the listing. Wrapped so a GitHub read
 // that fails skips only this section — `lane:list`'s job is to list the lanes it already read.
-async function report_occupancy(lanes: ReadonlyArray<LaneInfo>): Promise<void> {
-	const in_progress = await read_in_progress()
-
-	if (in_progress === undefined) {
+function report_occupancy(lanes: ReadonlyArray<LaneInfo>, in_progress: InProgress): void {
+	if (in_progress.holders === undefined) {
 		console.error(OCCUPANCY_UNREADABLE)
 
 		return
 	}
 
-	const report = lane_occupancy.classify(in_progress, {
+	const holders = in_progress.holders.map((issue) => issue.number)
+	const report = lane_occupancy.classify(holders, {
 		kind: 'lanes',
 		issues: live_lane_issues(lanes),
 	})
@@ -239,9 +256,10 @@ async function list_command(rest: ReadonlyArray<string>): Promise<number> {
 	if (rest.length > 0) return report_usage()
 
 	const lanes = await lane_registry.list_lanes()
-	const code = report_lanes(lanes)
+	const in_progress = await read_in_progress()
+	const code = report_lanes(lanes, citer_of(in_progress))
 
-	await report_occupancy(lanes)
+	report_occupancy(lanes, in_progress)
 
 	return code
 }

package/scripts/lane/lane-report.ts

@@ -1,4 +1,5 @@
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
+import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
 import { run_liveness } from '#scripts/run/run-liveness'
 import type { LaneInfo } from './lane-registry'
 
@@ -48,9 +49,14 @@ function event_column(lane: LaneInfo): string {
 	return state ?? 'agent -'
 }
 
-function describe_lane(lane: LaneInfo): string {
+// The plain `#N`, for a caller that could not read the repository the issue would link into.
+const PLAIN_CITE: IssueCiter = issue_cite.citer(undefined, new Map())
+
+// The issue leads as a citation (joshuafolkken/kit#2943): a lane status report copies this row, and a
+// bare `#N` copied into it is what the Stop guard sends back.
+function describe_lane(lane: LaneInfo, cite: IssueCiter = PLAIN_CITE): string {
 	return [
-		`#${lane.issue}`,
+		cite(lane.issue),
 		`seat ${value_or_unknown(lane.seat)}`,
 		`dev ${value_or_unknown(lane.development_port)}`,
 		`preview ${value_or_unknown(lane.preview_port)}`,
@@ -63,10 +69,10 @@ function describe_lane(lane: LaneInfo): string {
 	].join(COLUMN_SEPARATOR)
 }
 
-function describe_lanes(lanes: ReadonlyArray<LaneInfo>): string {
+function describe_lanes(lanes: ReadonlyArray<LaneInfo>, cite: IssueCiter = PLAIN_CITE): string {
 	if (lanes.length === 0) return NO_LANES
 
-	return lanes.map((lane) => describe_lane(lane)).join('\n')
+	return lanes.map((lane) => describe_lane(lane, cite)).join('\n')
 }
 
 function describe_ports(lane: LaneInfo): string {

package/scripts/propagate/propagate-plan.ts

@@ -0,0 +1,185 @@
+import { adopt_toolkits } from '#scripts/adopt/adopt-toolkits'
+import { propagate_run, type RunStep, type StepResult } from './propagate-run'
+import { propagate_steps, type Release, type ReleasePlan } from './propagate-steps'
+import { propagate_targets, type Manifest, type PropagateTarget } from './propagate-targets'
+
+// What one `josh propagate` run carries, decided from the repository it runs in (joshuafolkken/kit#2879).
+//
+// The supplier is kit or any toolkit built on it — app-kit, game-kit — and a toolkit's propagation
+// carries the base packages under it too, at the versions that toolkit itself has installed and was
+// verified with rather than at the base's newest. Each consumer is delivered by the topmost toolkit
+// it installs: a lower supplier skips it, because syncing only the base would write the overlay's
+// paths back to the base's originals (`docs/sync.md` → base first, overlay after), and would hand the
+// consumer a base the toolkit above it never verified. Discovery, ordering and the CLI name are
+// `josh adopt`'s own reads (`scripts/adopt/adopt-toolkits.ts`), not a second copy of them.
+
+const REFUSAL_PREFIX = 'Refusing to propagate:'
+const SUPPLIER_REFUSAL = [
+	`${REFUSAL_PREFIX} this is not a ${adopt_toolkits.TOOLKIT_SCOPE} toolkit's own repository.`,
+	'Propagation carries a published release outward, so it runs from the toolkit that published it',
+	'— kit, or a toolkit built on it that ships a CLI. Run it from that checkout instead.',
+].join('\n')
+const UNRESOLVED_CAUSE =
+	'declared here but not installed with a runnable CLI, so the consumers would receive this toolkit without it. Run `pnpm install`.'
+const MISPLACED_CAUSE =
+	'declared under `dependencies`, which leaves it out of the plan. Move it to `devDependencies`.'
+const ARROW = ' → '
+const LIST_SEPARATOR = ', '
+
+interface Supplier {
+	package_name: string
+	bin_name: string
+}
+
+interface SupplierResolution {
+	supplier?: Supplier
+	refusal?: string
+}
+
+interface BaseResolution {
+	bases?: Array<Release>
+	cause?: string
+}
+
+interface PlanResolution {
+	plan?: ReleasePlan
+	refusal?: string
+}
+
+// A toolkit is a scoped package that ships a CLI — the same reading `josh adopt` applies to an
+// installed one, applied here to the repository's own manifest.
+function toolkit_name(manifest: Manifest): string | undefined {
+	const { name } = manifest
+
+	return name !== undefined && adopt_toolkits.is_toolkit_package(name) ? name : undefined
+}
+
+function supplier_of(manifest: Manifest | undefined): Supplier | undefined {
+	const package_name = manifest === undefined ? undefined : toolkit_name(manifest)
+	if (manifest === undefined || package_name === undefined) return undefined
+	const bin_name = adopt_toolkits.bin_name_of(package_name, manifest)
+
+	return bin_name === undefined ? undefined : { package_name, bin_name }
+}
+
+function resolve_supplier(project_root: string): SupplierResolution {
+	const supplier = supplier_of(propagate_targets.read_manifest(project_root))
+
+	return supplier === undefined ? { refusal: SUPPLIER_REFUSAL } : { supplier }
+}
+
+// A base toolkit pinned to the version installed in the supplier's own checkout — the one the
+// supplier's verification gate ran against.
+function pin_installed(project_root: string, release: Release): Release | undefined {
+	const version = propagate_targets.installed_version(project_root, release.package_name)
+
+	return version === undefined ? undefined : { ...release, version }
+}
+
+// Why a declared base toolkit would fall out of the plan, naming it — either way `josh adopt` refuses
+// one for (joshuafolkken/kit#1540). A base left out is not merely left behind: every consumer that
+// installs it would then read it as a toolkit above this one and be skipped.
+function incomplete_cause(project_root: string): string | undefined {
+	const misplaced = adopt_toolkits.misplaced_toolkits(project_root)
+	if (misplaced.length > 0) return `${misplaced.join(LIST_SEPARATOR)} — ${MISPLACED_CAUSE}`
+	const unresolved = adopt_toolkits.unresolved_toolkits(project_root)
+
+	return unresolved.length === 0
+		? undefined
+		: `${unresolved.join(LIST_SEPARATOR)} — ${UNRESOLVED_CAUSE}`
+}
+
+// The supplier's base toolkits, base first, or the names that cannot be carried.
+function base_releases(project_root: string, supplier: Supplier): BaseResolution {
+	const cause = incomplete_cause(project_root)
+	if (cause !== undefined) return { cause }
+
+	const bases = adopt_toolkits
+		.discover_toolkits(project_root)
+		.filter((release) => release.package_name !== supplier.package_name)
+		.map((release) => pin_installed(project_root, release))
+
+	return bases.every((release) => release !== undefined) ? { bases } : { cause: UNRESOLVED_CAUSE }
+}
+
+// The releases one run carries: the base toolkits first, then the supplier at its own version, so the
+// sync runs base first and the supplier's overlay is written last.
+function build_plan(project_root: string, version: string): PlanResolution {
+	const { supplier, refusal } = resolve_supplier(project_root)
+	if (supplier === undefined) return { refusal: refusal ?? SUPPLIER_REFUSAL }
+	const { bases, cause } = base_releases(project_root, supplier)
+	if (bases === undefined) return { refusal: `${REFUSAL_PREFIX} ${cause ?? UNRESOLVED_CAUSE}` }
+	const releases = [...bases, { ...supplier, version }]
+
+	return { plan: { releases, origin: propagate_steps.PROPAGATE_ORIGIN } }
+}
+
+// The package the run publishes and waits for — by construction the plan's last release.
+function supplier_name(plan: ReleasePlan): string {
+	return plan.releases.at(-1)?.package_name ?? ''
+}
+
+// A declared scoped package counts as a toolkit unless it is demonstrably a library: installed, and
+// shipping no CLI. One that is not installed yet cannot be told apart, and treating it as a toolkit
+// errs toward leaving the consumer to the propagation above rather than reverting its overlay.
+function may_be_toolkit(repository_path: string, package_name: string): boolean {
+	if (adopt_toolkits.read_bin_name(repository_path, package_name) !== undefined) return true
+
+	return adopt_toolkits.is_unreachable_toolkit(repository_path, package_name)
+}
+
+function carriers_of(target: PropagateTarget, plan: ReleasePlan): Array<string> {
+	const carried = new Set(plan.releases.map((release) => release.package_name))
+
+	return adopt_toolkits
+		.all_declared_toolkits(target.path)
+		.filter((name) => !carried.has(name) && may_be_toolkit(target.path, name))
+}
+
+// A consumer that installs a toolkit this run does not carry is left to that toolkit's propagation.
+// Only a candidate that would otherwise be processed or reported current is re-classified.
+function mark_carried(target: PropagateTarget, plan: ReleasePlan): PropagateTarget {
+	if (target.state !== 'ready' && target.state !== 'up_to_date') return target
+	const carriers = carriers_of(target, plan)
+
+	return carriers.length === 0 ? target : { ...target, state: 'carried_above', carriers }
+}
+
+// What the dry run prints for the two steps that repeat per release: the versions each package is
+// pinned to, and the sync order.
+function plan_details(plan: ReleasePlan): Readonly<Record<string, string>> {
+	return {
+		[propagate_run.STEP_UPGRADE]: plan.releases
+			.map((release) => `${release.package_name}@${release.version}`)
+			.join(LIST_SEPARATOR),
+		[propagate_run.STEP_SYNC]: propagate_steps
+			.sync_commands(plan)
+			.map(({ command }) => command.join(' '))
+			.join(ARROW),
+	}
+}
+
+// The dry-run runner: it reports what each step would do and touches nothing.
+function create_step_describer(plan: ReleasePlan): RunStep {
+	const details = plan_details(plan)
+
+	return (target: PropagateTarget, step: string): StepResult => {
+		const detail = details[step]
+		const suffix = detail === undefined ? '' : `: ${detail}`
+
+		console.info(`  ${target.repo}: would run ${step}${suffix}`)
+
+		return { step, is_ok: true }
+	}
+}
+
+const propagate_plan = {
+	resolve_supplier,
+	build_plan,
+	supplier_name,
+	mark_carried,
+	create_step_describer,
+}
+
+export type { Supplier }
+export { propagate_plan }

package/scripts/propagate/propagate-run.ts

@@ -65,13 +65,17 @@ const SKIP_REASONS: Readonly<Record<string, string>> = {
 	missing_checkout: 'no local checkout at the mapped path — reported, not cloned',
 	unreadable: 'package.json could not be read',
 	not_selected: 'not the repository --target named',
+	carried_above: 'delivered by the propagation of a toolkit above this one',
 }
 
 // The reason text for a candidate that is not going to be processed. A missing local checkout is
 // reported rather than cloned: propagation writes to a working tree, and creating one nobody asked
 // for is not a step this command may take on its own.
 function skip_reason(target: PropagateTarget): string {
-	return SKIP_REASONS[target.state] ?? 'not eligible'
+	const reason = SKIP_REASONS[target.state] ?? 'not eligible'
+	if (target.carriers === undefined) return reason
+
+	return `${reason}: ${target.carriers.join(', ')}`
 }
 
 const LEFTOVER_NOTE = 'upgrade/sync changes left uncommitted'

package/scripts/propagate/propagate-steps.ts

@@ -88,13 +88,28 @@ function release_names(releases: ReadonlyArray<Release>): string {
 	return `${names.slice(0, -1).join(NAME_SEPARATOR)}${LAST_SEPARATOR}${last}`
 }
 
+// Each release with its own version, for a plan whose releases disagree on one — a toolkit's
+// propagation carries the base packages at the versions that toolkit was verified with
+// (joshuafolkken/kit#2879), so one shared "to <version>" would name a version most of them are not.
+function versioned_names(releases: ReadonlyArray<Release>): string {
+	const named = releases.map((release) => ({
+		...release,
+		package_name: `${release.package_name} to ${release.version}`,
+	}))
+
+	return `Upgrade ${release_names(named)}`
+}
+
 // One release reproduces `issue_title` exactly, which is what keeps a `propagate` run's issue title
 // unchanged by the generalization.
 function plan_title(releases: ReadonlyArray<Release>): string {
 	const [first] = releases
 	if (first === undefined) return EMPTY_PLAN_TITLE
+	const is_one_version = releases.every((release) => release.version === first.version)
 
-	return issue_title(release_names(releases), first.version)
+	return is_one_version
+		? issue_title(release_names(releases), first.version)
+		: versioned_names(releases)
 }
 
 function plan_body(plan: ReleasePlan): string {

package/scripts/propagate/propagate-targets.ts

@@ -20,9 +20,17 @@ const MANIFEST_NAME = 'package.json'
 const NODE_MODULES = 'node_modules'
 
 // Why a candidate is not going to be processed, or that it is. `not_selected` is the one state set
-// after classification: a candidate `--target` left out (joshuafolkken/kit#2755).
+// after classification: a candidate `--target` left out (joshuafolkken/kit#2755). `carried_above` is
+// the other: a consumer that installs a toolkit above the supplier, which that toolkit's own
+// propagation delivers instead (joshuafolkken/kit#2879).
 type TargetState =
-	'ready' | 'up_to_date' | 'not_downstream' | 'missing_checkout' | 'unreadable' | 'not_selected'
+	| 'ready'
+	| 'up_to_date'
+	| 'not_downstream'
+	| 'missing_checkout'
+	| 'unreadable'
+	| 'not_selected'
+	| 'carried_above'
 
 interface PropagateTarget {
 	repo: string
@@ -31,6 +39,9 @@ interface PropagateTarget {
 	// The range the consumer currently declares, when it declares one at all. Reported so a skip can
 	// say what it skipped rather than only that it did.
 	declared_range?: string
+	// The toolkits above the supplier this consumer installs, when it is `carried_above` — named in
+	// the skip so the report says which propagation will deliver it.
+	carriers?: ReadonlyArray<string>
 }
 
 // Only the fields propagation reads. `passthrough` is deliberate — a consumer manifest carries far

package/scripts/propagate/propagate.ts

@@ -4,15 +4,14 @@ import { repo_discovery } from '#scripts/discovery/repo-discovery'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { status_icons } from '#scripts/lib/status-icons'
-import { self_sync_guard } from '#scripts/self-sync-guard/self-sync-guard-logic'
-import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { derive_versions_endpoint } from '#scripts/version/version-command-config'
 import { version_targets } from '#scripts/version/version-targets'
 import { propagate_git } from './propagate-git'
+import { propagate_plan } from './propagate-plan'
 import { propagate_publish } from './propagate-publish'
 import { propagate_run } from './propagate-run'
 import { propagate_select, type TargetSelection } from './propagate-select'
-import { propagate_steps } from './propagate-steps'
+import { propagate_steps, type ReleasePlan } from './propagate-steps'
 import { propagate_targets, type PropagateTarget } from './propagate-targets'
 
 // `josh propagate` — carry the release this repository just published into every consumer checked
@@ -78,7 +77,8 @@ function parse_options(argv: ReadonlyArray<string>): RunOptions {
 	return usage === undefined ? options : { ...options, usage }
 }
 
-// Propagation runs from the supplier's own repository, and only there.
+// Propagation runs from the supplier's own repository, and only there — kit's, or a toolkit's built
+// on it (joshuafolkken/kit#2879).
 //
 // This is also what decides who propagates when several sessions are running: in the
 // per-repository concurrency model there is one session per checkout, so the session standing in
@@ -86,13 +86,7 @@ function parse_options(argv: ReadonlyArray<string>): RunOptions {
 // convention enforced at the boundary, not a lock — two checkouts of the supplier would both pass,
 // which is why each consumer is additionally refused unless its working tree is clean.
 function refuse_outside_source_repository(project_root: string): string | undefined {
-	if (self_sync_guard.read_package_name(project_root) === KIT_PACKAGE_NAME) return undefined
-
-	return [
-		`Refusing to propagate: this is not ${KIT_PACKAGE_NAME}'s own repository.`,
-		'Propagation carries a published release outward, so it runs from the package that published it.',
-		`Run it from the ${KIT_PACKAGE_NAME} checkout instead.`,
-	].join('\n')
+	return propagate_plan.resolve_supplier(project_root).refusal
 }
 
 // The version to carry: this repository's own declared version, which is what the merge published.
@@ -144,10 +138,14 @@ function resolve_run_version(project_root: string, is_dry_run = false): RunVersi
 	return resolve_supplier_version(project_root, is_dry_run)
 }
 
-async function await_publish(target_version: string, is_skipped: boolean): Promise<boolean> {
+async function await_publish(
+	package_name: string,
+	target_version: string,
+	is_skipped: boolean,
+): Promise<boolean> {
 	if (is_skipped) return true
-	console.info(`Waiting for ${KIT_PACKAGE_NAME}@${target_version} to appear in the registry…`)
-	const endpoint = derive_versions_endpoint(KIT_PACKAGE_NAME)
+	console.info(`Waiting for ${package_name}@${target_version} to appear in the registry…`)
+	const endpoint = derive_versions_endpoint(package_name)
 	const result = await propagate_publish.wait_for_publish(endpoint, target_version)
 
 	if (result.state === 'published') {
@@ -179,49 +177,65 @@ function announce_run_version(resolved: RunVersion): string | undefined {
 
 interface RunPlan {
 	version: string
+	releases: ReleasePlan
 	targets: ReadonlyArray<PropagateTarget>
 }
 
 // The consumers this run will consider, narrowed by `--target`. Resolved before the publish wait so
-// a mistyped name fails at once instead of after minutes of polling the registry.
-function resolve_run_targets(version: string, target: string | undefined): TargetSelection {
+// a mistyped name fails at once instead of after minutes of polling the registry. A consumer that
+// installs a toolkit above the supplier is left to that toolkit's propagation (joshuafolkken/kit#2879).
+function resolve_run_targets(
+	releases: ReleasePlan,
+	version: string,
+	target: string | undefined,
+): TargetSelection {
 	const map = repo_discovery.discover_repositories(PROJECT_ROOT)
-	const targets = propagate_targets.resolve_targets(map, KIT_PACKAGE_NAME, version)
+	const supplier = propagate_plan.supplier_name(releases)
+	const targets = propagate_targets
+		.resolve_targets(map, supplier, version)
+		.map((candidate) => propagate_plan.mark_carried(candidate, releases))
 
 	return propagate_select.select_target(targets, target)
 }
 
-// The version and the consumers, or nothing once whatever stopped the run has been printed.
+// Print why the run stopped before any consumer was touched.
+function refuse_run(refusal: string): void {
+	console.error(refusal)
+	console.error(UNTOUCHED_NOTE)
+}
+
+interface PlanOutcome {
+	plan?: RunPlan
+	refusal?: string
+}
+
+// The releases and the consumers for a version already accepted, or the reason there are none.
+function plan_consumers(version: string, options: RunOptions): PlanOutcome {
+	const { plan: releases, refusal } = propagate_plan.build_plan(PROJECT_ROOT, version)
+	if (releases === undefined) return { refusal: refusal ?? UNTOUCHED_NOTE }
+	const selection = resolve_run_targets(releases, version, options.target)
+	if (selection.refusal !== undefined) return { refusal: selection.refusal }
+
+	return { plan: { version, releases, targets: selection.targets } }
+}
+
+// The version, the releases and the consumers, or nothing once whatever stopped the run has been
+// printed.
 function plan_run(options: RunOptions): RunPlan | undefined {
 	const version = announce_run_version(resolve_run_version(PROJECT_ROOT, options.is_dry_run))
 	if (version === undefined) return undefined
-	const selection = resolve_run_targets(version, options.target)
+	const { plan, refusal } = plan_consumers(version, options)
+	if (refusal !== undefined) refuse_run(refusal)
 
-	if (selection.refusal !== undefined) {
-		console.error(selection.refusal)
-		console.error(UNTOUCHED_NOTE)
-
-		return undefined
-	}
-
-	return { version, targets: selection.targets }
+	return plan
 }
 
 // Everything after the publish wait: run each consumer, print one report.
 function propagate_to_consumers(plan: RunPlan, is_dry_run: boolean): number {
-	const { version, targets } = plan
+	const { releases, targets } = plan
 	const step = is_dry_run
-		? propagate_steps.describe_step
-		: propagate_steps.create_step_runner({
-				releases: [
-					{
-						package_name: KIT_PACKAGE_NAME,
-						version,
-						bin_name: propagate_steps.JOSH_BIN,
-					},
-				],
-				origin: propagate_steps.PROPAGATE_ORIGIN,
-			})
+		? propagate_plan.create_step_describer(releases)
+		: propagate_steps.create_step_runner(releases)
 	const results = propagate_run.run_targets(
 		targets,
 		step,
@@ -236,8 +250,12 @@ function propagate_to_consumers(plan: RunPlan, is_dry_run: boolean): number {
 
 // A dry run never waits: the whole reason to ask for one is to see the target list, and a wait that
 // times out would end the run before the list was ever printed.
-async function resolve_publish(version: string, options: RunOptions): Promise<boolean> {
-	return await await_publish(version, options.is_dry_run || options.is_publish_wait_skipped)
+async function resolve_publish(plan: RunPlan, options: RunOptions): Promise<boolean> {
+	return await await_publish(
+		propagate_plan.supplier_name(plan.releases),
+		plan.version,
+		options.is_dry_run || options.is_publish_wait_skipped,
+	)
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
@@ -251,7 +269,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 
 	const plan = plan_run(options)
 	if (plan === undefined) return FAILURE_EXIT_CODE
-	if (!(await resolve_publish(plan.version, options))) return FAILURE_EXIT_CODE
+	if (!(await resolve_publish(plan, options))) return FAILURE_EXIT_CODE
 
 	return propagate_to_consumers(plan, options.is_dry_run)
 }

package/scripts/registry-migration/migrate-logic.ts

@@ -219,6 +219,7 @@ function plan(project_npmrc: string, user_npmrc: string, lockfile: string): Migr
 const migrate_logic = {
 	plan,
 	github_tarballs,
+	is_github_tarball,
 	rewrite_kit_lockfile,
 	registry_of,
 	scoped_packages,

package/scripts/release/github-release.ts

@@ -4,7 +4,7 @@ import { z } from 'zod'
 
 const API_URL = 'https://api.github.com/repos/joshuafolkken/kit/releases'
 const WORKFLOW_RUNS_URL =
-	'https://api.github.com/repos/joshuafolkken/kit/actions/workflows/publish.yml/runs?event=repository_dispatch&per_page=100'
+	'https://api.github.com/repos/joshuafolkken/kit/actions/workflows/publish.yml/runs?per_page=100'
 const WORKFLOW_JOBS_URL = 'https://api.github.com/repos/joshuafolkken/kit/actions/runs'
 const TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[.-][0-9A-Za-z.-]+)?$/u
 const REQUEST_TIMEOUT_MS = 30_000

package/scripts/review/review-attest.ts

@@ -1,4 +1,5 @@
 import { randomBytes } from 'node:crypto'
+import { lstatSync } from 'node:fs'
 import { git_command } from '#scripts/git/git-command'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { stamp_file } from '#scripts/josh/stamp-file'
@@ -240,6 +241,47 @@ function check(now: number = Date.now(), root?: string): AttestVerdict {
 	return verdict
 }
 
+function is_written_since(source: string, taken_at: string): boolean {
+	try {
+		const stats = lstatSync(source)
+
+		return stats.isFile() && stats.mtimeMs >= Date.parse(taken_at)
+	} catch {
+		return false
+	}
+}
+
+// **Whether the last briefed review of this branch finished** (joshuafolkken/kit#2945). A ship resumed
+// after a stop re-issues round 1, and without this answer it briefed the whole change again — the
+// files the finished review had just read, re-read at full cost. It is asked before `record_target`
+// mints the next nonce, since that call drops the record it reads. The branch must match: the pointer
+// is keyed on the root, and a lane root outlives the branch a previous run reviewed there.
+//
+// **An attestation alone is not a finished review.** The reviewer may attest and then die before it
+// reports — a timeout, a usage limit — and narrowing on that would call files nobody read "already
+// read". So the findings file, written only once the review has its verdict, must postdate the brief
+// this pointer names; one left from an earlier review is older than that brief and does not count.
+function is_reviewed_on(checkout: ReviewCheckout, findings_path: string, root?: string): boolean {
+	const pointer = read_pointer(root)
+
+	if (pointer === undefined) return false
+
+	const verdict = verdict_for(pointer.nonce)
+
+	if (verdict.status !== 'ok' || verdict.expected?.branch !== checkout.branch) return false
+
+	return is_written_since(findings_path, pointer.taken_at)
+}
+
+// Whether a record written at `written_at` belongs to the brief the pointer names rather than an earlier
+// one (joshuafolkken/kit#2945): that brief writes it right after minting the pointer. ISO timestamps
+// order as strings.
+function is_briefed_since(written_at: string, root?: string): boolean {
+	const pointer = read_pointer(root)
+
+	return pointer !== undefined && written_at >= pointer.taken_at
+}
+
 // The pointer is keyed on the repository root rather than on `process.cwd()`, which is what
 // `PROJECT_ROOT` is. `josh review:brief` records against the root it just asked git for, so the check
 // has to ask the same question: run the two from different directories — one from `scripts/`, one
@@ -303,6 +345,8 @@ const review_attest = {
 	clear_here,
 	EXPECT_PREFIX,
 	expect_path,
+	is_briefed_since,
+	is_reviewed_on,
 	MISMATCH_VERDICT,
 	MISSING_REASON,
 	POINTER_PREFIX,