@joshuafolkken/kit 1.1373.0 → 1.1383.0

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

@@ -13,10 +13,12 @@ import { run_carry, type RunCarry } from '#scripts/run/carry/run-carry'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_merge_cli, type MergeResult } from '#scripts/run/merge/run-merge-cli'
 import { z } from 'zod'
+import { backlog_budget } from './backlog-budget'
 import {
 	backlog_drive,
 	type DriveEnd,
 	type DriveState,
+	type LoopConfig,
 	type LoopPorts,
 	type OfferRead,
 } from './backlog-drive'
@@ -46,7 +48,6 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const should_forward_stderr = true
 const POLL_MS = 5000
-const OFFER_MS = 60_000
 const FIRST_LINE = 0
 
 // The `--json` object `backlog:offer` prints, keyed under its `JSON_KEY`.
@@ -71,7 +72,7 @@ async function read_record(): Promise<RunCarry | undefined> {
 
 	const read = run_carry.read_carry(run_carry.carry_path(target))
 
-	return read.kind === 'carried' || read.kind === 'expired' ? read.carry : undefined
+	return read.kind === 'carried' ? read.carry : undefined
 }
 
 async function read_offer(
@@ -204,6 +205,11 @@ async function seeded_lanes(context: DriveContext): Promise<ReadonlyArray<string
 	return backlog_drive_restore.restore(lanes, events, carry.merged_issues ?? [])
 }
 
+// The interval between two asks is `backlog:budget`'s own, so the driver keeps the one its reason prints.
+function loop_config(window_ms: number | undefined): LoopConfig {
+	return { poll_ms: POLL_MS, offer_ms: backlog_budget.OFFER_INTERVAL_MS, window_ms }
+}
+
 async function drive(context: DriveContext): Promise<number> {
 	const seeded = await seeded_lanes(context)
 
@@ -212,7 +218,7 @@ async function drive(context: DriveContext): Promise<number> {
 	const initial =
 		context.stopped === undefined ? fresh : backlog_drive.merge_stopped(context.stopped, fresh)
 	const last = { state: { ...initial, exclude: [...context.exclude] } }
-	const config = { poll_ms: POLL_MS, offer_ms: OFFER_MS, window_ms: context.window_ms }
+	const config = loop_config(context.window_ms)
 	const end = await backlog_drive.run_loop(last.state, config, ports_of(context, seeded, last))
 
 	console.info(end_line(end))
@@ -258,6 +264,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 const backlog_drive_cli = {
 	end_line,
 	finish: backlog_drive_finish.finish,
+	loop_config,
 	merge,
 	merge_token,
 	offer_argv: backlog_drive_offer_argv.offer_argv,

package/scripts/backlog/backlog-drive.ts

@@ -140,9 +140,12 @@ function ended(reason: string, state: DriveState, token?: string, issue?: string
 	}
 }
 
+// Only an empty backlog drains: `backlog:offer` marks the drain on `exhausted` alone, so a watch over a
+// parked or unreadable backlog has no retrospective for `run:step` to fire and stays the driver's.
 function is_drain(read: OfferRead, state: DriveState): boolean {
 	return (
 		read.verdict === WATCH_VERDICT &&
+		read.answer === 'exhausted' &&
 		state.in_flight.length === 0 &&
 		read.is_retrospective_owed === true
 	)
@@ -352,8 +355,8 @@ async function run_pass(
 
 interface LoopConfig {
 	poll_ms: number
-	// The floor between two `backlog:offer` asks while nothing was collected — the same one-minute
-	// cadence the wake supervisor polls the backlog on, so an idle stretch is not a network hammer.
+	// The floor between two `backlog:offer` asks while nothing was collected, running or idle alike —
+	// `backlog_budget.OFFER_INTERVAL_MS`, the interval the wake supervisor polls on too.
 	offer_ms: number
 	// How long one invocation may wait before returning `window`, or `undefined` for no bound. A headless
 	// parent's foreground call is capped by its shell's timeout, so it passes one under that cap.

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

@@ -125,27 +125,19 @@ const budget_read_schema = z.object({
 	[BUDGET_JSON_KEY]: z.string(),
 	reason: z.string(),
 	is_finish: z.boolean(),
-	idle: z.string().optional(),
 })
 
 interface BudgetRead {
 	verdict: string
 	reason: string
 	is_finish: boolean
-	// The idle watch's window, as `backlog_idle.text_of` wrote it, when the budget opened one.
-	idle?: string | undefined
 }
 
 function budget_of(out: string): BudgetRead | undefined {
 	const read = json_value.parse_with(out, budget_read_schema)
 	if (read === undefined) return undefined
 
-	return {
-		verdict: read[BUDGET_JSON_KEY],
-		reason: read.reason,
-		is_finish: read.is_finish,
-		idle: read.idle,
-	}
+	return { verdict: read[BUDGET_JSON_KEY], reason: read.reason, is_finish: read.is_finish }
 }
 
 function to_tokens(out: string): ReadonlyArray<string> {
@@ -225,12 +217,6 @@ async function decide(values: ParsedValues, counts: OfferCounts): Promise<number
 
 	await mark_drain(decision.verdict, offer.answer, counts.running)
 
-	// The idle window with the ask that read it, once per watching poll, so `run:board` counts the next
-	// check from the poll that ran rather than guessing one.
-	if (decision.idle !== undefined) {
-		await run_event_stream_emit.emit_changed(run_event_stream.EVENT_KIND.IDLE, decision.idle)
-	}
-
 	return emit(decision, offer, values.json === true)
 }
 

package/scripts/cost-runtime/context-cut-payback.ts

@@ -26,11 +26,16 @@ const POST_CUT_CONTEXT = 60_000
 const EXPECTED_REMAINING_REQUESTS = 10
 
 // The price of a dropped token relative to a rewritten one, from `cost-pricing.ts`. A cache read bills
-// `CACHE_READ_MULTIPLIER` of base input and a 5-minute cache write `CACHE_WRITE_5M_MULTIPLIER`, so a
-// preamble rewrite costs this many per-request cache reads. The base input rate is common to both and
-// cancels, which is why only the ratio appears.
+// `DEFAULT_CACHE_READ_MULTIPLIER` of base input and a 5-minute cache write `CACHE_WRITE_5M_MULTIPLIER`,
+// so a preamble rewrite costs this many per-request cache reads. The base input rate is common to both
+// and cancels, which is why only the ratio appears.
+//
+// **The standard cache-read rate, deliberately, not the running model's.** Opus 5.5 reads cache at
+// 0.05x and Fable 5.1 at 0.025x, which would move the threshold from 135,000 to 210,000 and 360,000 —
+// outside the 100k–200k band the cut was validated in. That changes when a cut fires, a decision that
+// needs a lane measurement of its own rather than arriving as a side effect of a corrected price list.
 function write_over_read(): number {
-	return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.CACHE_READ_MULTIPLIER
+	return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.DEFAULT_CACHE_READ_MULTIPLIER
 }
 
 // The current per-request context at which a cut breaks even over exactly `remaining` requests. The

package/scripts/cost-runtime/cost-pricing.ts

@@ -1,68 +1,114 @@
 import { cost_usage, type UsageTotals } from './cost-usage'
 
-// The current Claude price list, and the three multipliers that make a token's price depend on how
-// it was sent.
+// The current Claude price list, and the multipliers that make a token's price depend on how it was
+// sent.
 //
-// A run's cost is not "tokens x one rate". A cache read costs a tenth of base input, a 5-minute
-// cache write 1.25x, a 1-hour cache write 2x, and output 5x. On a measured request with
-// `cache_read_input_tokens` 97,190 against `input_tokens` 2, an estimate that ignored the
-// multipliers would be wrong by more than an order of magnitude in either direction depending on
+// A run's cost is not "tokens x one rate". A cache read costs a fraction of base input that depends
+// on the model, a 5-minute cache write 1.25x, a 1-hour cache write 2x, and output 5x. On a measured
+// request with `cache_read_input_tokens` 97,190 against `input_tokens` 2, an estimate that ignored
+// the multipliers would be wrong by more than an order of magnitude in either direction depending on
 // which single rate it picked.
 
 const CACHE_WRITE_5M_MULTIPLIER = 1.25
 const CACHE_WRITE_1H_MULTIPLIER = 2
-const CACHE_READ_MULTIPLIER = 0.1
+// The standard cache-read rate, a tenth of base input — what a model bills unless its row says
+// otherwise. Named the default because it is not every model's rate: pricing a model reads the row's
+// multiplier through `estimate_cost`, never this constant.
+const DEFAULT_CACHE_READ_MULTIPLIER = 0.1
+// The discounted cache-read rates of the 5.5 generation (platform.claude.com "Model pricing", read
+// 2026-10-12): Opus 5.5 and Sonnet 5.5 bill a cache read at 0.05x base input, Fable 5.1 and Mythos
+// 5.1 at 0.025x.
+const HALVED_CACHE_READ_MULTIPLIER = 0.05
+const QUARTERED_CACHE_READ_MULTIPLIER = 0.025
 const TOKENS_PER_MILLION = 1_000_000
 
 interface ModelPrice {
 	// USD per million tokens.
 	input: number
 	output: number
+	// The cache-read rate as a multiple of `input`. Absent on a model billed at the standard
+	// `DEFAULT_CACHE_READ_MULTIPLIER`, so a row states a multiplier only where it differs.
+	cache_read_multiplier?: number
 }
 
+// A model priced by prompt length carries a second row under its id plus this suffix — the rates a
+// request over `LONG_PROMPT_THRESHOLD` pays. The suffixed name is not an id the API reports; it is
+// what `cost_by_model` bills such a request under, so the higher-priced requests show as their own
+// row and resolve to their own price like any other.
+const LONG_PROMPT_SUFFIX = ':long-prompt'
+const LONG_PROMPT_THRESHOLD = 100_000
+
 // Base input/output rates per million tokens. Cache rates are derived from `input` by the
 // multipliers above rather than listed, because they are defined as multiples of it — writing them
 // out would let the two drift.
 /* eslint-disable @typescript-eslint/naming-convention */
 const MODEL_PRICES: Record<string, ModelPrice> = {
+	'claude-fable-5-1': {
+		input: 10,
+		output: 50,
+		cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER,
+	},
+	'claude-mythos-5-1': {
+		input: 10,
+		output: 50,
+		cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER,
+	},
 	'claude-fable-5': { input: 10, output: 50 },
 	'claude-mythos-5': { input: 10, output: 50 },
+	'claude-opus-5-5': { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
 	'claude-opus-5': { input: 5, output: 25 },
 	'claude-opus-4-8': { input: 5, output: 25 },
 	'claude-opus-4-7': { input: 5, output: 25 },
 	'claude-opus-4-6': { input: 5, output: 25 },
+	'claude-sonnet-5-5': {
+		input: 2,
+		output: 10,
+		cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER,
+	},
 	'claude-sonnet-5': { input: 2, output: 10 },
 	'claude-sonnet-4-6': { input: 3, output: 15 },
+	'claude-haiku-5-5': { input: 0.1, output: 0.5 },
+	[`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
 	'claude-haiku-4-5': { input: 1, output: 5 },
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
 const CONTEXT_MARKER = '['
+// A deployment's date suffix — `claude-haiku-4-5-20251001`. Eight digits and nothing else, so a
+// version segment (the last `-5` of `claude-opus-5-5`) is never read as one.
+const DATE_SUFFIX = /-\d{8}$/u
 
 // Claude Code appends a context-window marker to the model id it records — `claude-opus-5[1m]` —
 // and a deployment may carry a date suffix. Both name the same priced model, so the id is reduced
-// to its longest prefix that the table knows rather than reported as unknown.
+// to the table's id by removing exactly those two decorations.
+//
+// **Nothing else is removed.** The reduction was once "the longest prefix the table knows", which
+// priced `claude-opus-5-5` at `claude-opus-5`'s rates and `claude-fable-5-1` at `claude-fable-5`'s —
+// another model's price list, reported with no warning. A version the table does not carry is
+// unpriced, which `total_cost` names, rather than billed as the closest id it resembles.
 //
 // The `[1m]` marker is the 1M-context beta, and stripping it to the base rate is confirmed correct,
-// not an approximation. The published price list — platform.claude.com
-// "Long context pricing", read 2026-09 — states that Claude 4.6 and later models "include the full
-// 1M token context window at standard pricing (a 900k-token request is billed at the same per-token
-// rate as a 9k-token request)". Every id in `MODEL_PRICES` is 4.6-or-later, so no request has an
-// input-size surcharge band to account for, whatever its size. (Fast mode is a separate premium, but
-// it is signalled by `speed: "fast"` rather than by the context marker, so it is not this marker's
-// concern.) Were a future model to reintroduce a >200K band, the marker could no longer be stripped
-// blindly and this function would branch on the input size instead.
-function resolve_price(model: string): ModelPrice | undefined {
+// not an approximation. The published price list — platform.claude.com "Long context pricing", read
+// 2026-10-12 — states that Claude 4.6 and later models other than Haiku 5.5 "include the full 1M
+// token context window at standard pricing (a 900k-token request is billed at the same per-token
+// rate as a 9k-token request)". The one model with an input-size band is priced from the request's
+// own size by `billed_model`, not from the marker. (Fast mode is a separate premium, but it is
+// signalled by `speed: "fast"` rather than by the context marker, so it is not this marker's
+// concern.)
+function known_id(model: string): string | undefined {
 	const base = model.split(CONTEXT_MARKER)[0] ?? model
-	const direct = MODEL_PRICES[base]
 
-	if (direct !== undefined) return direct
+	return [base, base.replace(DATE_SUFFIX, '')].find((id) => Object.hasOwn(MODEL_PRICES, id))
+}
+
+function resolve_price(model: string): ModelPrice | undefined {
+	const id = known_id(model)
 
-	const [matched] = Object.keys(MODEL_PRICES)
-		.filter((id) => base.startsWith(id))
-		.toSorted((left, right) => right.length - left.length)
+	return id === undefined ? undefined : MODEL_PRICES[id]
+}
 
-	return matched === undefined ? undefined : MODEL_PRICES[matched]
+function cache_read_multiplier(price: ModelPrice): number {
+	return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER
 }
 
 function estimate_cost(totals: UsageTotals, price: ModelPrice): number {
@@ -70,16 +116,16 @@ function estimate_cost(totals: UsageTotals, price: ModelPrice): number {
 		totals.input_tokens +
 		totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER +
 		totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER +
-		totals.cache_read_tokens * CACHE_READ_MULTIPLIER
+		totals.cache_read_tokens * cache_read_multiplier(price)
 
 	return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION
 }
 
 // The five dollar terms `estimate_cost` sums, kept apart so a report can say what a run's dollars
-// were spent on rather than only their total. Each is priced by the same
-// multipliers `estimate_cost` uses — the exported constants above — so the five always sum to
-// `estimate_cost(totals, price)`. It is a decomposition of the same arithmetic, not a second price
-// list, which is why the weights live in the constants both read rather than in either function.
+// were spent on rather than only their total. Each is priced by the same multipliers `estimate_cost`
+// uses — the write constants above and the price's own cache-read multiplier — so the five always
+// sum to `estimate_cost(totals, price)`. It is a decomposition of the same arithmetic, not a second
+// price list, which is why the weights live where both read them rather than in either function.
 interface CostComposition {
 	input_usd: number
 	cache_write_5m_usd: number
@@ -103,7 +149,7 @@ function estimate_composition(totals: UsageTotals, price: ModelPrice): CostCompo
 			totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
 			price.input,
 		),
-		cache_read_usd: priced(totals.cache_read_tokens * CACHE_READ_MULTIPLIER, price.input),
+		cache_read_usd: priced(totals.cache_read_tokens * cache_read_multiplier(price), price.input),
 		output_usd: priced(totals.output_tokens, price.output),
 	}
 }
@@ -129,15 +175,29 @@ interface ModelUsage {
 	totals: UsageTotals
 }
 
+// The id a request is billed under: its own, unless the model is priced by prompt length and this
+// request is over the threshold, in which case the model's long-prompt row. The prompt length is
+// everything the request sent — cache reads and writes included — and each request is priced on its
+// own (platform.claude.com "Long context pricing", read 2026-10-12), which is why this reads one
+// request's totals and cannot be asked of a sum.
+function billed_model(usage: ModelUsage): string {
+	const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`
+	const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD
+
+	return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model
+}
+
 // Per-model, because a session routinely mixes tiers — a subagent on Haiku inside an Opus run — and
-// one blended rate would be wrong for both.
+// one blended rate would be wrong for both. Grouped by `billed_model`, so each record is one request:
+// a model priced by prompt length is split into the rows its requests were billed at.
 function cost_by_model(records: ReadonlyArray<ModelUsage>): Array<ModelCost> {
 	const grouped = new Map<string, UsageTotals>()
 
 	for (const record of records) {
-		const running = grouped.get(record.model) ?? cost_usage.EMPTY_TOTALS
+		const model = billed_model(record)
+		const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS
 
-		grouped.set(record.model, cost_usage.add_totals(running, record.totals))
+		grouped.set(model, cost_usage.add_totals(running, record.totals))
 	}
 
 	return [...grouped].map(([model, totals]) => to_model_cost(model, totals))
@@ -162,7 +222,8 @@ function cost_of(records: ReadonlyArray<ModelUsage>): number {
 const cost_pricing = {
 	CACHE_WRITE_5M_MULTIPLIER,
 	CACHE_WRITE_1H_MULTIPLIER,
-	CACHE_READ_MULTIPLIER,
+	DEFAULT_CACHE_READ_MULTIPLIER,
+	LONG_PROMPT_THRESHOLD,
 	resolve_price,
 	estimate_cost,
 	estimate_composition,

package/scripts/document/document-byte-budget.ts

@@ -76,7 +76,7 @@ const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
 	{ path: 'docs/josh-commands-automation.md', bytes: 53_248 },
 	{ path: 'docs/josh-commands-run.md', bytes: 65_536 },
 	{ path: 'docs/josh-commands-backlog.md', bytes: 57_344 },
-	{ path: 'docs/josh-commands.md', bytes: 45_056 },
+	{ path: 'docs/josh-commands.md', bytes: 49_152 },
 	{ path: 'docs/labels-and-run-states.md', bytes: 8192 },
 	{ path: 'prompts/coding-standards.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow.md', bytes: 8192 },

package/scripts/document/read-set-pricing.ts

@@ -9,11 +9,12 @@
 // was worth moving off the entry read.
 //
 // **The rate is not defined here.** The per-million-token input rate and the cache-read multiplier
-// come from `cost-pricing.ts` — the same constants `josh cost` and `josh time` price a run with — so
+// come from `cost-pricing.ts` — the same price table `josh cost` and `josh time` price a run with — so
 // there is no second price list to drift. This file is the model (a token rides every request as a
 // cache read) and the one assumption the model needs (how many requests a run makes); the arithmetic
 // is `cost_pricing.estimate_cost`'s.
 
+import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { cost_pricing } from '#scripts/cost-runtime/cost-pricing'
 import { cost_usage } from '#scripts/cost-runtime/cost-usage'
 
@@ -23,10 +24,10 @@ import { cost_usage } from '#scripts/cost-runtime/cost-usage'
 // much per entry-read token, so the figure is "per run of this size", never an absolute.
 const ASSUMED_REQUESTS = 118
 
-// The model these runs execute on. Its base input rate and the cache-read multiplier are read from
-// the price table rather than written here, so the dollar figure tracks any price change with no edit
-// to this file.
-const REFERENCE_MODEL = 'claude-opus-4-8'
+// The model these runs execute on — the worker's default, read from the profile that launches a lane
+// rather than written here, so a model migration moves the dollar figure with no edit to this file.
+// Its base input rate and cache-read multiplier come from the price table in the same way.
+const REFERENCE_MODEL = agent_role_profile.DEFAULT_PROFILES.worker.model
 
 // A token read at the entry is written to cache once and then read back on every request. Modelled as
 // a pure cache read across the run — the one-time write is under 1% of the total and folding it in
@@ -45,6 +46,7 @@ function dollars_per_run(tokens: number): number {
 
 const read_set_pricing = {
 	ASSUMED_REQUESTS,
+	REFERENCE_MODEL,
 	dollars_per_run,
 }
 

package/scripts/epic/epic-candidate-confirm.ts

@@ -111,7 +111,7 @@ function is_still_runnable(
 // A read that failed withholds the candidate rather than confirming it. "Could not tell" is not
 // "nothing blocks it", and this is the one direction the guard may not fail in, because that answer
 // *starts* work — the same reason `epic-busy.ts` answers `wait` for a listing it could not read. The
-// caller then offers the next candidate or waits, and the whole-run timeout bounds the wait.
+// caller then offers the next candidate or waits, and the idle wait bounds the wait.
 async function read_or_withhold(
 	candidate: EpicChild,
 	read_blockers: BlockersReader,

package/scripts/epic/epic-cross-repo.ts

@@ -80,7 +80,7 @@ const NOT_FOUND_STATUS = 404
 //
 // **`absent` is not `unreadable`.** A repository with no
 // manifest, or one whose manifest says `private`, publishes nothing — so a closed blocker there has
-// no release anyone could wait for, and waiting means waiting until the run's own eight-hour timeout
+// no release anyone could wait for, and waiting means waiting until the run's idle wait runs out
 // with nothing an operator can edit to clear it. A read that merely failed says none of that.
 //
 // **It is read from the repository rather than from the registry, and that is the whole design.** The
@@ -123,7 +123,7 @@ type WorkspaceCheck = 'workspace' | 'single' | 'unreadable'
 //
 // **The file's existence proves nothing.** `josh sync` distributes it to every consumer regardless of
 // layout — it carries `allowBuilds`, `overrides` and the like — so probing for its presence would read
-// every private first-party repository as a workspace and wait the eight-hour timeout on each. What
+// every private first-party repository as a workspace and wait the whole idle wait on each. What
 // makes a repository a workspace is a non-empty `packages`
 // key, so that is what is read.
 function declares_packages(yaml: string): boolean {
@@ -271,7 +271,7 @@ function read_default_branch_version(repo: string): string | undefined {
 // would start a dependent before its blocker's release existed. What is asked is only whether the
 // repository *is* a workspace — the members are not enumerated and nothing looks for which of them
 // publishes, so a workspace whose members are all private waits when it need not. That is the safe
-// direction: waiting ends at the run's own timeout, resolving early does not end at all.
+// direction: waiting ends when the run's idle wait runs out, resolving early does not end at all.
 function publishes_nothing(repo: string): boolean {
 	const answer = read_manifest(repo)
 
@@ -285,7 +285,7 @@ function publishes_nothing(repo: string): boolean {
 //
 // **"Ships nothing" is asked first, and it is a different question.** Waiting is right only where
 // something could still arrive; a closed blocker in a repository that publishes no package has no
-// release for `is_published` to ever find, so it would wait until the run's own eight-hour timeout
+// release for `is_published` to ever find, so it would wait until the run's idle wait runs out
 // with nothing an operator could edit to clear it. It is answered from that repository's own manifest and never from
 // the registry, for the reason `ManifestAnswer` records: a registry 404 also means "this token may
 // not see it", and resolving on one would start a consumer child before its blocker's release

package/scripts/epic/epic-next.ts

@@ -194,7 +194,7 @@ function refuse(reason: string): number {
 
 // The verdict as it applies to *this* repository. `run` never reaches a caller here: it means some
 // other repository has work, which for this session is something to wait on rather than a state its
-// loop has a branch for. The whole-run timeout is what bounds that wait.
+// loop has a branch for. The idle wait is what bounds that wait.
 function repo_verdict(verdict: LaneOffer['verdict']): LaneOffer['verdict'] {
 	return verdict === 'run' ? 'wait' : verdict
 }

package/scripts/git/git-spawn-sync.ts

@@ -2,6 +2,7 @@ import { read_spawn_stderr, read_spawn_stdout } from '#scripts/lib/spawn-exit'
 import { GIT_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { execaSync } from 'execa'
 import { git_utilities } from './constants'
+import { git_location_environment } from './git-location-environment'
 
 // The one place a synchronous git command is spawned from — the sync
 // counterpart of `git-spawn.ts`. Every caller here wants an answer rather than an exception, so a
@@ -51,8 +52,15 @@ function read(args: ReadonlyArray<string>, options: GitSyncOptions = {}): string
 }
 
 // The configured `origin` URL, or undefined when the repository has none.
+//
+// **The git location variables are cleared, so `cwd` is the repository that answers.** A hook exports
+// `GIT_DIR`, which beats `cwd` outright — a caller reached from inside `pre-push` would otherwise be
+// told the `origin` of the repository being pushed rather than of the directory it named.
 function origin_url(cwd: string): string | undefined {
-	return read(['config', '--get', 'remote.origin.url'], { cwd })
+	return read(['config', '--get', 'remote.origin.url'], {
+		cwd,
+		env: git_location_environment.location_free_environment(),
+	})
 }
 
 // The absolute repository (or worktree) root, asked under the C locale so a caller can tell "not a

package/scripts/hooks/stop-guard.ts

@@ -126,20 +126,22 @@ async function outcome_of(raw_payload: string): Promise<StopOutcome> {
 
 // A live carry record is in place — `carried` alone reads as a run. Both report checks below are about
 // a carried run: the strand judge reads this very record and returns on anything but `carried`, and a
-// stall needs a backlog driver, which begins one before its plan. A spent (`expired`) or `unreadable`
-// record a crashed run left behind is no run either, so it does not re-arm the stall's backlog probe
-// on every stop.
+// stall needs a backlog driver, which begins one before its plan. An `unreadable`
+// record a crashed run left behind is no run either.
+// The answer is whether that run's owner is still live, and `undefined` where there is no run at all.
 // A failed git read — outside a repository, `git rev-parse` exits non-zero — reads as no run, since this
 // gate sits ahead of the checks' own swallowing and must not throw into the stop decision either.
-async function has_run_record(): Promise<boolean> {
+async function carried_owner_live(): Promise<boolean | undefined> {
 	try {
 		const directory = await run_carry.repository_directory()
 
-		if (directory === undefined) return false
+		if (directory === undefined) return undefined
 
-		return run_carry.read_carry(run_carry.carry_path(directory)).kind === 'carried'
+		const read = run_carry.read_carry(run_carry.carry_path(directory))
+
+		return read.kind === 'carried' ? run_carry.is_owner_live(read.carry) : undefined
 	} catch {
-		return false
+		return undefined
 	}
 }
 
@@ -149,10 +151,19 @@ async function has_run_record(): Promise<boolean> {
 // — the budget handed off, the owner dead, no supervisor watching. Both only report and swallow their
 // own failures, so neither can change the stop decision. An ordinary stop with no run record skips
 // both, so it pays one directory read rather than their reads and a stale stream's backlog probe.
+//
+// **A stall is a live driver not dispatching, so a record whose owner is gone is not asked.** A record
+// stands until a person carries or discards it, so a crashed run's would otherwise re-arm the stall's
+// `git worktree list` and network backlog probe on every stop in the repository, for a run nobody
+// drives. A gone driver is the strand check's question — handed off or not (`run-stranded.ts` →
+// `had_driver`) — and that one reads local files only.
 async function run_report_checks(): Promise<void> {
-	if (!(await has_run_record())) return
+	const is_owner_live = await carried_owner_live()
+
+	if (is_owner_live === undefined) return
+
+	if (is_owner_live) await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
 
-	await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
 	await run_stranded_detect.run_stranded_check()
 }
 

package/scripts/init/init-ai-copy.ts

@@ -16,6 +16,7 @@ import { init_logic } from './init-logic'
 import { package_path, PROJECT_ROOT } from './init-paths'
 import { init_sonar } from './init-sonar'
 import type { ProjectShape } from './project-profile'
+import { security_policy } from './security-policy'
 
 const WORKSPACE_YAML = 'pnpm-workspace.yaml'
 const CLAUDE_MD_FILENAME = 'CLAUDE.md'
@@ -23,7 +24,7 @@ const BASIC_CLAUDE_IMPORT = '@node_modules/@joshuafolkken/kit/dist/CLAUDE.basic.
 const PRETTIER_IGNORE = '.prettierignore'
 const GIT_ATTRIBUTES = '.gitattributes'
 const CODE_OF_CONDUCT = 'CODE_OF_CONDUCT.md'
-const SECURITY_MD = 'SECURITY.md'
+const { SECURITY_MD } = security_policy
 const BASIC_AI_FILES = [
 	'AGENTS.md',
 	'GEMINI.md',
@@ -38,6 +39,10 @@ const BASIC_SOURCES: Readonly<Record<string, string>> = {
 	[PRETTIER_IGNORE]: 'templates/prettierignore.basic',
 	[WORKSPACE_YAML]: 'templates/pnpm-workspace.basic.yaml',
 }
+// Written from a template of the consumer's own on every profile, not from kit's same-named file.
+const CONSUMER_SOURCES: Readonly<Record<string, string>> = {
+	[SECURITY_MD]: security_policy.SECURITY_TEMPLATE,
+}
 const GITHUB_FILES = new Set([CODE_OF_CONDUCT, SECURITY_MD])
 const BASIC_POINTER_MAPPING = { src: 'templates/cursorrules.basic', dest: '.cursorrules' }
 const PULL_REQUEST_TEMPLATE = '.github/pull_request_template.md'
@@ -143,14 +148,16 @@ function did_skip_workspace_yaml_copy(source_path: string, destination_path: str
 }
 
 // The package file an AI file is copied from: a basic project gets its own template for a few of
-// them, every other file is copied from the path it is written to.
+// them, a few are a consumer template on every profile, and every other file is copied from the
+// path it is written to.
 function ai_file_source(filename: string, shape?: ProjectShape): string {
 	const basic_source = shape?.profile === 'basic' ? BASIC_SOURCES[filename] : undefined
 
-	return basic_source ?? filename
+	return basic_source ?? CONSUMER_SOURCES[filename] ?? filename
 }
 
 function did_skip_ai_file_copy(filename: string, shape?: ProjectShape): boolean {
+	if (security_policy.did_skip_unresolved(filename, PROJECT_ROOT)) return false
 	const source_path = package_path(ai_file_source(filename, shape))
 	const destination_path = path.join(PROJECT_ROOT, filename)
 

package/scripts/init/init-copy-content.ts

@@ -5,6 +5,7 @@ import { claude_kit_only_settings } from './claude-kit-only-settings'
 import { claude_plugin_config } from './claude-plugin-config'
 import { hook_command_rewrite } from './hook-command-rewrite'
 import { init_logic } from './init-logic'
+import { security_policy } from './security-policy'
 
 /**
  * The single transform applied to every file kit copies verbatim into a consumer
@@ -29,6 +30,10 @@ import { init_logic } from './init-logic'
  * Keeping both on this one function is the same guarantee as the workflow passes — a copy path that
  * skipped the plugin block would ship a settings file that never enables the plugin, and one that
  * skipped the rewrite would leave every consumer hook slower than it has to be.
+ *
+ * The consumer's `SECURITY.md` gets one further pass: the repository it lands in is filled into the
+ * template, so its advisory and release links name that repository and not kit (see
+ * security-policy.ts).
  */
 function transform_copied_content(destination_path: string, content: string): string {
 	const with_paths = init_logic.transform_distributed_paths(content)
@@ -47,10 +52,12 @@ function transform_copied_content(destination_path: string, content: string): st
 		with_kit_only_stripped,
 	)
 
-	return hook_command_rewrite.apply_hook_command_rewrite_for_destination(
+	const with_hooks = hook_command_rewrite.apply_hook_command_rewrite_for_destination(
 		destination_path,
 		with_plugin,
 	)
+
+	return security_policy.apply_repository_for_destination(destination_path, with_hooks)
 }
 
 export { transform_copied_content }