@joshuafolkken/kit 1.1166.0 → 1.1229.0

package/scripts/run/{run-wake-cli.ts → wake/run-wake-cli.ts}

@@ -4,15 +4,17 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { poll } from '#scripts/lib/poll'
 import { telegram_notify } from '#scripts/notify/telegram-notify'
-import { run_carry, type CarryRead } from './run-carry'
-import { run_event_stream } from './run-event-stream'
-import { run_headless } from './run-headless'
+import { run_carry, type CarryRead } from '#scripts/run/carry/run-carry'
+import { run_event_stream } from '#scripts/run/event/run-event-stream'
+import { run_headless } from '#scripts/run/run-headless'
 import { run_wake, type RunWake, type WakeStopReason, type WakeTidyResult } from './run-wake'
 import { run_wake_describe, type WakeContext } from './run-wake-describe'
 import { run_wake_driver } from './run-wake-driver'
 import { run_wake_handoff } from './run-wake-handoff'
 import { run_wake_loop, type LoopPorts, type LoopStop } from './run-wake-loop'
+import { run_wake_restart, type RestartPorts } from './run-wake-restart'
 import { run_wake_session, type LaunchResult } from './run-wake-session'
 
 // `josh run:wake --start | --list | --stop | --loop` — the supervisor that continues a cut
@@ -209,10 +211,16 @@ function log_hint(context: WakeContext): string {
 	return `The output of every session this supervisor started is in ${context.log_target}.`
 }
 
+// The log hint goes ahead of the note: the Telegram length limit cuts the tail, and a long failure note
+// (stdout tail plus stderr tail) would otherwise take the one line that says where to look next.
+function warning_body(stop: LoopStop, body: string, context: WakeContext): string {
+	return [body, log_hint(context), stop.note].filter(Boolean).join('\n')
+}
+
 async function warn_of_stop(stop: LoopStop, body: string, context: WakeContext): Promise<void> {
 	await telegram_notify.warn({
 		issue_title: WARNING_TITLE,
-		body: [body, stop.note, log_hint(context)].filter(Boolean).join('\n'),
+		body: warning_body(stop, body, context),
 		recovery: WARNING_RECOVERY,
 	})
 }
@@ -303,6 +311,22 @@ function tidy_up(target: string): void {
 	if (run_wake.tidy_own_wake(target) === SUPERSEDED_RESULT) note_to_stderr(SUPERSEDED_NOTE)
 }
 
+function restart_ports(context: WakeContext, ports: LoopPorts, interval_ms: number): RestartPorts {
+	return {
+		pass: async () => await run_wake_loop.run_loop(context.wake_target, ports, interval_ms),
+		is_resumable: () => run_carry.read_carry(context.carry_target).kind === 'carried',
+		pause: async () => {
+			await poll.sleep(interval_ms)
+		},
+		note: note_to_stderr,
+	}
+}
+
+// A failed pass is restarted while the carry record is still resumable (`run-wake-restart.ts`), so
+// only a failure past the restart bound reaches `finish` and its warning (joshuafolkken/kit#3332).
+// **The record is claimed once and held across every restart**, so a `--stop` landing in the pause
+// between two passes still finds it, signals this process, and the next pass reads the removal as the
+// person's stop rather than claiming a fresh record and resuming.
 async function loop(context: WakeContext, interval_ms: number): Promise<number> {
 	const read = run_carry.read_carry(context.carry_target)
 
@@ -315,11 +339,8 @@ async function loop(context: WakeContext, interval_ms: number): Promise<number>
 
 	if (claimed === undefined) return report(RUNNING_VERDICT)
 
-	const stop = await run_wake_loop.run_loop(
-		context.wake_target,
-		ports_for(context, claimed.profile ?? profile),
-		interval_ms,
-	)
+	const ports = ports_for(context, claimed.profile ?? profile)
+	const stop = await run_wake_restart.supervise(restart_ports(context, ports, interval_ms))
 
 	tidy_up(context.wake_target)
 
@@ -408,6 +429,7 @@ const run_wake_cli = {
 	USAGE,
 	run,
 	stop_body,
+	warning_body,
 }
 
 if (process.argv[1] === SCRIPT_PATH) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/run/{run-wake-describe.ts → wake/run-wake-describe.ts}

@@ -1,9 +1,9 @@
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { gh_spawn } from '#scripts/gh/gh-spawn'
 import { issue_citation } from '#scripts/rules/issue-citation'
-import { run_carry, type CarryRead } from './run-carry'
-import { run_event_stream } from './run-event-stream'
-import { run_liveness } from './run-liveness'
+import { run_carry, type CarryRead } from '#scripts/run/carry/run-carry'
+import { run_event_stream } from '#scripts/run/event/run-event-stream'
+import { run_liveness } from '#scripts/run/run-liveness'
 import { run_wake, type RunWake } from './run-wake'
 
 // The `--list` presentation of a wake record (joshuafolkken/kit#2407 split it out of `run-wake-cli.ts`,

package/scripts/run/{run-wake-driver.ts → wake/run-wake-driver.ts}

@@ -1,6 +1,6 @@
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
-import { run_carry, type CarryRead } from './run-carry'
-import { run_invocation } from './run-invocation'
+import { run_carry, type CarryRead } from '#scripts/run/carry/run-carry'
+import { run_invocation } from '#scripts/run/run-invocation'
 import type { DriveResult } from './run-wake-loop'
 
 const SUCCESS = 0
@@ -8,6 +8,8 @@ const FIRST_LINE = 0
 const RESUME_PREFIX = 'resume: '
 const DETAILS_TAIL_LENGTH = 2048
 const TRUNCATION_MARK = '... '
+// The prefix `backlog-drive-cli.ts` gives the exception it catches.
+const ERROR_PREFIX = 'error '
 
 function driver_args(invocation: string): ReadonlyArray<string> | undefined {
 	const rebuilt = run_invocation.rebuild(invocation)
@@ -40,6 +42,11 @@ function details_tail(details: string): string {
 // **The hand-off names its next move, so the woken session never searches the procedure for it**
 // (joshuafolkken/kit#3156). Whatever the branch, the session acts on it and hands the loop back to the
 // supervisor with a cut; only a person's stop ends the run instead.
+//
+// **The claim comes first** (joshuafolkken/kit#3238). The supervisor hands the record off before the
+// wake, so until the session adopts it with `--resume` every count it writes — `--merged`, `--done`,
+// the closing `--cut` — is refused as advancing a handed-off budget, and the supervisor, seeing no
+// claim, ends the run as a failed wake.
 const HAND_BACK = 'then hand the loop back with pnpm josh run:carry --cut --owner "$PPID"'
 const NEXT_BY_VERDICT: ReadonlyArray<readonly [string, string]> = [
 	[
@@ -48,28 +55,38 @@ const NEXT_BY_VERDICT: ReadonlyArray<readonly [string, string]> = [
 	],
 	[
 		'merge human-review',
-		'the child stopped before its commit for a person; stop the run (needs-human-review.md)',
+		'stop the run, because the child stopped before its commit for a person (needs-human-review.md)',
 	],
 	['epic #', `follow backlogrun-steps.md → "Named issues run first, in order", ${HAND_BACK}`],
 ]
 const NEXT_DEFAULT = `act on the result by backlogrun-steps.md → "The loop", ${HAND_BACK}`
 
-function next_move(verdict: string): string {
+function next_move(verdict: string, invocation: string): string {
 	const found = NEXT_BY_VERDICT.find(([prefix]) => verdict.startsWith(prefix))
 
-	return `\nNext: ${found?.[1] ?? NEXT_DEFAULT}`
+	return `\nNext: first claim the carry record with ${run_carry.claim_command(invocation)}, then ${found?.[1] ?? NEXT_DEFAULT}`
 }
 
-function handoff_material(verdict: string, resume: string, details: string): string {
+function handoff_material(
+	verdict: string,
+	resume: string,
+	invocation: string,
+	details: string,
+): string {
 	const context = details === '' ? '' : `\nDetails: ${details_tail(details)}`
 	const epic = verdict.startsWith('epic #')
 		? '\nThe named item is an epic. Follow backlogrun-steps.md named epic procedure; do not launch the epic root as a fullrun child. After all children merge or park, record the root with pnpm josh run:carry --done <epic-number> --owner "$PPID" before continuing to the next named item.'
 		: ''
 
-	return `Driver result: ${verdict}\n${resume}${epic}${next_move(verdict)}${context}`
+	return `Driver result: ${verdict}\n${resume}${epic}${next_move(verdict, invocation)}${context}`
 }
 
-function driver_result(out: string, read: CarryRead, details = ''): DriveResult {
+function driver_result(
+	out: string,
+	read: CarryRead,
+	invocation: string,
+	details = '',
+): DriveResult {
 	const lines = out.split('\n')
 	const verdict = lines[FIRST_LINE]
 
@@ -80,13 +97,32 @@ function driver_result(out: string, read: CarryRead, details = ''): DriveResult
 		return { kind: 'failed', note: `backlog:drive returned an incomplete result: ${out}` }
 	}
 
-	return { kind: 'judgment', material: handoff_material(verdict, resume, details) }
+	return { kind: 'judgment', material: handoff_material(verdict, resume, invocation, details) }
 }
 
-function read_result(result: JoshResult, target: string): DriveResult {
-	if (result.code !== SUCCESS) return { kind: 'failed', note: result.err ?? result.out }
+// **The cause is the driver's stdout `error …` line, so it leads the note** (joshuafolkken/kit#3242).
+// `backlog:drive` prints an exception only to stdout, and its stderr is never empty — every command it
+// ran is there — so reading `err ?? out` dropped the one line that said why. The stderr follows as its
+// tail, for the same reason `details_tail` cuts a judgment's details.
+function cause_of(out: string): string {
+	const errors = out.split('\n').filter((line) => line.startsWith(ERROR_PREFIX))
 
-	return driver_result(result.out, run_carry.read_carry(target), result.err)
+	return errors.length > 0 ? errors.join('\n') : details_tail(out)
+}
+
+function failure_note(result: JoshResult): string {
+	return [cause_of(result.out), details_tail(result.err ?? '')].filter(Boolean).join('\n')
+}
+
+function read_result(
+	result: JoshResult | undefined,
+	target: string,
+	invocation: string,
+): DriveResult {
+	if (result === undefined) return { kind: 'released' }
+	if (result.code !== SUCCESS) return { kind: 'failed', note: failure_note(result) }
+
+	return driver_result(result.out, run_carry.read_carry(target), invocation, result.err)
 }
 
 function claim_record(target: string, invocation: string): boolean {
@@ -97,7 +133,51 @@ function claim_record(target: string, invocation: string): boolean {
 	return run_carry.adopt_carry(target, current.carry, run_carry.owner_of(process.pid)) !== undefined
 }
 
-async function drive(target: string): Promise<DriveResult> {
+// **A verdict with nothing to judge is re-driven here, never handed to a session** (joshuafolkken/kit#3245).
+// A woken session met with `window`, `merge busy` or `merge retry` only cut and handed the loop back, and
+// the supervisor then ran the very same driver again — a model round trip, at a cache write each, that
+// decided nothing. The record is already this process's, so the rerun needs no fresh claim; the limit
+// keeps a driver that never settles from holding the supervisor past its own checks.
+const RERUN_VERDICTS: ReadonlyArray<string> = ['window', 'merge busy', 'merge retry']
+const RERUN_LIMIT = 10
+const RERUN_PAUSE_MS = 60_000
+
+type Pause = (ms: number) => Promise<void>
+
+async function pause(ms: number): Promise<void> {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms)
+	})
+}
+
+function is_mechanical(result: JoshResult): boolean {
+	const verdict = result.out.split('\n', 1)[FIRST_LINE] ?? ''
+
+	return (
+		result.code === SUCCESS &&
+		RERUN_VERDICTS.some((entry) => verdict === entry || verdict.startsWith(`${entry} `))
+	)
+}
+
+// A record that expired or was removed during the pause answers `undefined`: its stale verdict must not
+// reach a session, so the supervisor's own next pass re-reads the record and ends the run as `expired`
+// or `stopped`; a rerun would only fail on it and report the run as `failed`.
+async function run_driver(
+	target: string,
+	args: ReadonlyArray<string>,
+	wait: Pause,
+	remaining: number,
+): Promise<JoshResult | undefined> {
+	const result = await josh_command.josh_run(args, true)
+	if (remaining === 0 || !is_mechanical(result)) return result
+
+	await wait(RERUN_PAUSE_MS)
+	if (run_carry.read_carry(target).kind !== 'carried') return undefined
+
+	return await run_driver(target, args, wait, remaining - 1)
+}
+
+async function drive(target: string, wait: Pause = pause): Promise<DriveResult> {
 	const read = run_carry.read_carry(target)
 	if (read.kind !== 'carried') return { kind: 'failed', note: 'The carry record changed.' }
 
@@ -108,9 +188,11 @@ async function drive(target: string): Promise<DriveResult> {
 		return { kind: 'failed', note: 'The driver could not claim the carry record.' }
 	}
 
-	const result = await josh_command.josh_run(args, true)
-
-	return read_result(result, target)
+	return read_result(
+		await run_driver(target, args, wait, RERUN_LIMIT),
+		target,
+		read.carry.invocation,
+	)
 }
 
-export const run_wake_driver = { drive, driver_args, driver_result }
+export const run_wake_driver = { RERUN_LIMIT, drive, driver_args, driver_result }

package/scripts/run/{run-wake-handoff.ts → wake/run-wake-handoff.ts}

@@ -1,5 +1,5 @@
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { run_carry } from './run-carry'
+import { run_carry } from '#scripts/run/carry/run-carry'
 
 // The supervisor's recovery hand-off (joshuafolkken/kit#2437). A session that claimed the carry record
 // and then died without `run:carry --cut` leaves it `carried`, owned by a gone process, with no

package/scripts/run/{run-wake-loop.ts → wake/run-wake-loop.ts}

@@ -1,4 +1,4 @@
-import type { CarryRead } from './run-carry'
+import type { CarryRead } from '#scripts/run/carry/run-carry'
 import {
 	run_wake,
 	type RunWake,
@@ -56,8 +56,13 @@ interface LoopPorts {
 	now: () => Date
 }
 
+// `released`: the carry record ended while the driver paused, so there is nothing to hand on and the
+// next pass decides from the record how the run ends.
 type DriveResult =
-	{ kind: 'finished' } | { kind: 'judgment'; material: string } | { kind: 'failed'; note: string }
+	| { kind: 'finished' }
+	| { kind: 'released' }
+	| { kind: 'judgment'; material: string }
+	| { kind: 'failed'; note: string }
 
 interface LoopStop {
 	reason: WakeStopReason
@@ -89,6 +94,7 @@ async function wake_step(wake: RunWake, ports: LoopPorts): Promise<StepOutcome>
 	const driven = await ports.drive()
 	if (driven.kind === 'finished') return stopped('ended')
 	if (driven.kind === 'failed') return stopped(FAILED_REASON, driven.note)
+	if (driven.kind === 'released') return { kind: 'continue', wake }
 
 	const session_id = ports.new_session_id()
 

package/scripts/run/wake/run-wake-restart.ts

@@ -0,0 +1,58 @@
+import { run_wake_loop, type LoopStop } from './run-wake-loop'
+
+// **A supervisor that fails while the run is still resumable restarts itself** (joshuafolkken/kit#3332).
+// A `backlog:drive` that exited on a transient `main:sync` failure ended the supervisor as `failed`,
+// and the run then sat for forty minutes with a valid carry record, waiting for one `run:wake --start`
+// that only a person was left to type — joshuafolkken/kit#3297's "resume it yourself" rule binds an AI
+// session, and once the supervisor is gone there is none to read it.
+//
+// **Bounded, and only the bound reaches a person.** A failure that is not transient fails again on
+// every pass, so the restarts stop at `RESTART_LIMIT` and the last failure is handed back for the
+// ordinary warning, its note saying how many restarts went before it.
+
+const RESTART_LIMIT = 3
+
+interface RestartPorts {
+	// One run of the loop over the record the caller claimed once and holds across every restart, so a
+	// `--stop` landing in the pause is read by the next pass as the person's stop.
+	pass: () => Promise<LoopStop>
+	// Whether the carry record can still be continued — `carried`, neither `expired` nor gone.
+	is_resumable: () => boolean
+	pause: () => Promise<void>
+	note: (text: string) => void
+}
+
+function is_restartable(stop: LoopStop, restarts: number, ports: RestartPorts): boolean {
+	return (
+		stop.reason === run_wake_loop.FAILED_REASON && restarts < RESTART_LIMIT && ports.is_resumable()
+	)
+}
+
+function restart_note(stop: LoopStop, restarts: number): string {
+	return `the supervisor failed (${stop.note ?? 'no note'}); restarting it, ${String(restarts + 1)} of ${String(RESTART_LIMIT)}`
+}
+
+function with_restart_count(stop: LoopStop, restarts: number): LoopStop {
+	if (restarts === 0 || stop.reason !== run_wake_loop.FAILED_REASON) return stop
+
+	return {
+		...stop,
+		note: [stop.note, `after ${String(restarts)} automatic restarts`].filter(Boolean).join('\n'),
+	}
+}
+
+async function supervise(ports: RestartPorts, restarts = 0): Promise<LoopStop> {
+	const stop = await ports.pass()
+
+	if (!is_restartable(stop, restarts, ports)) return with_restart_count(stop, restarts)
+
+	ports.note(restart_note(stop, restarts))
+	await ports.pause()
+
+	return await supervise(ports, restarts + 1)
+}
+
+const run_wake_restart = { RESTART_LIMIT, supervise }
+
+export { run_wake_restart }
+export type { RestartPorts }

package/scripts/run/{run-wake-session.ts → wake/run-wake-session.ts}

@@ -1,8 +1,8 @@
 import { agent_argv, type AgentArgvResult } from '#scripts/agent/agent-argv'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 import { claude_agent_argv } from '#scripts/agent/claude-agent-argv'
-import { detached_launch, type LaunchArgv } from './detached-launch'
-import { run_invocation } from './run-invocation'
+import { detached_launch, type LaunchArgv } from '#scripts/run/detached-launch'
+import { run_invocation } from '#scripts/run/run-invocation'
 
 // How the supervisor starts things: the next agent session, and — at `--start` — its own detached
 // self. Both go through one `launch`, because the two differ only in what is being run
@@ -159,5 +159,5 @@ const run_wake_session = {
 	wake_argv,
 }
 
-export type { LaunchRequest, LaunchResult } from './detached-launch'
+export type { LaunchRequest, LaunchResult } from '#scripts/run/detached-launch'
 export { run_wake_session }

package/scripts/run/{run-wake.ts → wake/run-wake.ts}

@@ -3,8 +3,8 @@ import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import { process_identity } from '#scripts/josh/process-identity'
 import { process_owner_schema } from '#scripts/josh/process-owner'
 import { stamp_file } from '#scripts/josh/stamp-file'
+import type { CarryRead } from '#scripts/run/carry/run-carry'
 import { z } from 'zod'
-import type { CarryRead } from './run-carry'
 
 // joshuafolkken/kit#1719. joshuafolkken/kit#1714 made a `backlogrun`'s budget survive the session cut
 // and left out the one thing that starts the next session, so the record was carried and the

package/scripts/safe-chain/preinstall-command.ts

@@ -1,38 +1,37 @@
-// `setup-ci` only writes shims and adds them to PATH on a CI runner, so a local `pnpm install` is
-// scanned only when the developer has enabled safe-chain's own shell integration. That integration
-// runs pnpm behind safe-chain's registry proxy and hands `GLOBAL_AGENT_HTTP_PROXY` to it, which a bare
-// pnpm never sets — the one signal a lifecycle script can read (joshuafolkken/kit#2707).
-const SETUP_CI_CMD = 'pnpm dlx @aikidosec/safe-chain setup-ci'
-const LEGACY_PREINSTALL_RE = /^pnpm dlx @aikidosec\/safe-chain(?:@\S+)? setup-ci$/u
+// The `preinstall` kit writes fetches nothing: it only checks that safe-chain is scanning the install
+// and warns when it is not (joshuafolkken/kit#3269). It used to run `pnpm dlx @aikidosec/safe-chain
+// setup-ci`, which downloaded an unverified package on every install and — `setup-ci` acting only on
+// a CI runner, where kit installs with `--ignore-scripts` — protected nothing. safe-chain's shell
+// integration runs pnpm behind its registry proxy and hands `GLOBAL_AGENT_HTTP_PROXY` to it, which a
+// bare pnpm never sets — the one signal a lifecycle script can read (joshuafolkken/kit#2707).
+const INSTALL_GUIDE_ANCHOR = 'installing-safe-chain'
+const INSTALL_GUIDE_URL = `https://github.com/joshuafolkken/kit/blob/main/SECURITY.md#${INSTALL_GUIDE_ANCHOR}`
+// `.pnpmfile.mjs` recognizes the command by the package name, so the hint names it.
 const INTEGRATION_HINT =
-	'Warning: safe-chain is not scanning this install because its shell integration is not active.' +
-	' Install safe-chain (https://github.com/AikidoSec/safe-chain#installation) or run: safe-chain setup' +
+	'Warning: safe-chain (@aikidosec/safe-chain) is not scanning this install because its shell' +
+	` integration is not active. Install it with the hash-verified steps at ${INSTALL_GUIDE_URL}` +
 	' - then restart your terminal.'
 // `preinstall` runs before any dependency is installed, kit included, so the check is plain Node with
 // no imports. It never fails the install and stays silent on CI, where the runner is set up instead.
 // The source avoids double quotes, `$` and backticks so the shell passes it to Node verbatim.
 const LOCAL_INTEGRATION_CHECK_SOURCE = `if(!process.env.CI&&!process.env.GLOBAL_AGENT_HTTP_PROXY)console.warn('${INTEGRATION_HINT}')`
-const LOCAL_INTEGRATION_CHECK_CMD = `node -e "${LOCAL_INTEGRATION_CHECK_SOURCE}"`
+const SAFE_CHAIN_CMD = `node -e "${LOCAL_INTEGRATION_CHECK_SOURCE}"`
+// Every `preinstall` an earlier kit wrote: `setup-ci` alone, pinned or not, or followed by the
+// `node -e` check of any earlier wording.
+const LEGACY_PREINSTALL_RE =
+	/^pnpm dlx @aikidosec\/safe-chain(?:@\S+)? setup-ci(?: && node -e "[^"]*")?$/u
 
-function with_local_check(setup_command: string): string {
-	return `${setup_command} && ${LOCAL_INTEGRATION_CHECK_CMD}`
-}
-
-// Upgrade a `preinstall` kit wrote before the check existed, pinned version included; any other
-// value is the consumer's own and is left exactly as it is.
+// Replace a `preinstall` kit wrote earlier; any other value is the consumer's own and is left exactly
+// as it is.
 function migrate_preinstall(value: string): string {
-	if (!LEGACY_PREINSTALL_RE.test(value)) return value
-
-	return with_local_check(value)
+	return LEGACY_PREINSTALL_RE.test(value) ? SAFE_CHAIN_CMD : value
 }
 
-const SAFE_CHAIN_CMD = with_local_check(SETUP_CI_CMD)
-
 const safe_chain_preinstall = {
 	SAFE_CHAIN_CMD,
-	LOCAL_INTEGRATION_CHECK_CMD,
 	LOCAL_INTEGRATION_CHECK_SOURCE,
 	INTEGRATION_HINT,
+	INSTALL_GUIDE_ANCHOR,
 	migrate_preinstall,
 }
 

package/scripts/safe-chain/project-config.ts

@@ -8,7 +8,6 @@ import { z } from 'zod'
 
 const WORKSPACE_FILE = 'pnpm-workspace.yaml'
 const PROJECT_CONFIG_FILE = '.aikido'
-const NPMRC_FILE = '.npmrc'
 const EXCLUSIONS_FIELD = 'minimumPackageAgeExclusions'
 const AGE_FIELD = 'minimumPackageAgeHours'
 const MINUTES_PER_HOUR = 60
@@ -78,18 +77,22 @@ function replace_safe_chain_block(existing: string, safe_chain: Record<string, u
 }
 
 // Safe Chain enforces its own minimum package age (48 hours by default), so CI refused lockfiles pnpm
-// had resolved under `.npmrc`'s shorter window (kit #2743). `.npmrc` is the source: its minutes are
-// floored to whole hours so Safe Chain is never stricter than pnpm, and an undeclared window writes
-// nothing; an explicit `0` opt-out is written as 0 so an earlier synchronized age cannot outlive it.
-function package_age_hours(npmrc: string): number | undefined {
-	const minutes = release_age.parse_declared_minimum_release_age(npmrc)
+// had resolved under pnpm's shorter window (kit #2743). The workspace's `minimumReleaseAge` is the
+// source: its minutes are floored to whole hours so Safe Chain is never stricter than pnpm, and an
+// undeclared window writes nothing; an explicit `0` opt-out is written as 0 so an earlier
+// synchronized age cannot outlive it.
+function package_age_hours(workspace: string): number | undefined {
+	const minutes = release_age.parse_declared_minimum_release_age(workspace)
 	if (minutes === undefined) return undefined
 
 	return Math.floor(minutes / MINUTES_PER_HOUR)
 }
 
-function merge_age(safe_chain: Record<string, unknown>, npmrc: string): Record<string, unknown> {
-	const hours = package_age_hours(npmrc)
+function merge_age(
+	safe_chain: Record<string, unknown>,
+	workspace: string,
+): Record<string, unknown> {
+	const hours = package_age_hours(workspace)
 	if (hours === undefined) return safe_chain
 
 	return { ...safe_chain, [AGE_FIELD]: hours }
@@ -107,22 +110,24 @@ function merge_exclusions(
 function has_nothing_to_write(
 	existing: string,
 	exclusions: ReadonlyArray<string>,
-	npmrc: string,
+	workspace: string,
 ): boolean {
-	return existing.length === 0 && exclusions.length === 0 && package_age_hours(npmrc) === undefined
+	return (
+		existing.length === 0 && exclusions.length === 0 && package_age_hours(workspace) === undefined
+	)
 }
 
 function read_exclusions(workspace: string): ReadonlyArray<string> {
 	return workspace_schema.parse(yaml_document.parse_yaml(workspace)).minimumReleaseAgeExclude ?? []
 }
 
-function merge_project_config(existing: string, workspace: string, npmrc = ''): string {
+function merge_project_config(existing: string, workspace: string): string {
 	const exclusions = read_exclusions(workspace)
 	const aikido = yaml_document.parse_yaml(existing)
 	const safe_chain = read_mapping(aikido['safe-chain'], 'safe-chain')
-	const merged = merge_age(merge_exclusions(safe_chain, exclusions), npmrc)
+	const merged = merge_age(merge_exclusions(safe_chain, exclusions), workspace)
 	if (JSON.stringify(merged) === JSON.stringify(safe_chain)) return existing
-	if (has_nothing_to_write(existing, exclusions, npmrc)) return existing
+	if (has_nothing_to_write(existing, exclusions, workspace)) return existing
 
 	return replace_safe_chain_block(existing, merged)
 }
@@ -133,8 +138,7 @@ function sync_project_config(root: string): boolean {
 	const config_path = path.join(root, PROJECT_CONFIG_FILE)
 	const existing = file_reader.read_file_or_empty(config_path)
 	const workspace = readFileSync(workspace_path, 'utf8')
-	const npmrc = file_reader.read_file_or_empty(path.join(root, NPMRC_FILE))
-	const merged = merge_project_config(existing, workspace, npmrc)
+	const merged = merge_project_config(existing, workspace)
 	if (merged === existing) return false
 	writeFileSync(config_path, merged)
 

package/scripts/sync/sync-ai-files.ts

@@ -71,7 +71,7 @@ function sync_workspace_yaml(
 	destination_path: string,
 	is_force = false,
 ): boolean {
-	const template = readFileSync(template_path, 'utf8')
+	const template = init_ai_copy.read_workspace_template(template_path, destination_path)
 	const existing = is_force ? '' : file_reader.read_file_or_empty(destination_path)
 	const merged = init_logic.merge_workspace_yaml(existing, template)
 

package/scripts/sync/sync-configs.ts

@@ -29,7 +29,8 @@ function sync_with_merge(
 	console.info(`  ✔ synced    ${destination_name}`)
 }
 
-// Append-only, and deliberately so: a `_authToken` line in the consumer's file is left alone.
+// Removes only the exact settings lines earlier kit releases wrote, which pnpm 12 ignores in
+// `.npmrc` (joshuafolkken/kit#3267); every other line, a `_authToken` line included, is left alone.
 // Sync used to remove the env-var form, which broke every project that had opted its project
 // .npmrc in via `npmrcAuthFile` — there the line is the live credential, and the opt-in itself
 // can live in a deploy platform's dashboard where sync cannot see it (joshuafolkken/kit#759).

package/scripts/sync/sync.ts

@@ -192,12 +192,23 @@ function sync_prepare_lefthook_warning(destination_path: string): void {
 	)
 }
 
+// The `preinstall` earlier kits wrote fetched safe-chain on every install (joshuafolkken/kit#3269);
+// `josh init` replaces it, and this covers everyone already initialized.
+function sync_safe_chain_preinstall(destination_path: string): void {
+	sync_package_json_with(
+		destination_path,
+		(existing) => init_logic.upgrade_safe_chain_preinstall(existing),
+		'  ✔ synced    preinstall safe-chain check',
+	)
+}
+
 // Every migration an already-initialized consumer needs applied to its own manifest, run as one
 // group so the next one is added here rather than at the call site.
 function sync_package_json_migrations(destination_path: string): void {
 	sync_package_manager_version(destination_path)
 	sync_secretlint_development_deps(destination_path)
 	sync_prepare_lefthook_warning(destination_path)
+	sync_safe_chain_preinstall(destination_path)
 }
 
 // Two distributed artifacts each depend on a repository setting kit cannot write, and both reports
@@ -230,8 +241,8 @@ function sync_project_artifacts(is_force: boolean): void {
 
 	sync_sonar_with_template(name_with_owner, is_force)
 	sync_config_files()
-	// After `sync_config_files`, which may add the `.npmrc` window `.aikido`'s age is derived from
-	// (joshuafolkken/kit#2743).
+	// After `sync_ai_copy_all`, which may add the `pnpm-workspace.yaml` window `.aikido`'s age is
+	// derived from (joshuafolkken/kit#2743, #3267).
 	project_config.sync_project_config(PROJECT_ROOT)
 	sync_package_json_migrations(path.join(PROJECT_ROOT, PACKAGE_JSON))
 	report_repository_settings(name_with_owner)
@@ -277,6 +288,8 @@ const sync = {
 	sync_package_manager_version,
 	sync_secretlint_development_deps,
 	sync_prepare_lefthook_warning,
+	sync_safe_chain_preinstall,
+	sync_package_json_migrations,
 	migrate_prettierrc: did_migrate_prettierrc,
 }