@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/delegation/investigation-reads.ts

@@ -2,16 +2,19 @@ import path from 'node:path'
 import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
 import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
 import { capped_print_part } from '#scripts/document/capped-print-part'
+import { changed_paths_sync } from '#scripts/git/changed-paths-sync'
 import { hook_decision, type GuardRun } from '#scripts/josh/hook-decision'
 import { time_batch_guard, type GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { time_bundle_call } from '#scripts/time-runtime/time-bundle-call'
+import { time_search_call } from '#scripts/time-runtime/time-search-call'
 import { time_shell } from '#scripts/time-runtime/time-shell'
 import { time_spans, type Span } from '#scripts/time-runtime/time-spans'
 import { delegation_policy } from './delegation-policy'
 
 // How many files a run has read and not edited since its last delegated unit, counted off the
 // transcript rather than left to the agent's memory, so the threshold fires again on a second
-// accumulation. A delegation clears the set; a read adds to it; an edit exempts its file.
+// accumulation. A delegation clears the set; a read adds to it; an edit exempts its file, as does
+// the branch's own change since its merge base, which an earlier session of the run wrote.
 
 const READ_TOOLS: ReadonlySet<string> = new Set(['Read'])
 // Both spellings of the subagent tool are in use: `Task` (published) and `Agent` (this harness).
@@ -32,17 +35,10 @@ const CONTENT_READ_LABELS: ReadonlySet<string> = new Set(
 	CONTENT_READ_COMMANDS.map((command) => time_shell.bash_label(command)),
 )
 
-// A search carries no file text but costs a turn, so searches count in turns: parallel ones count once.
-const SEARCH_COMMANDS: ReadonlyArray<string> = ['fd', 'find', 'grep', 'rg']
-const SEARCH_LABELS: ReadonlySet<string> = new Set(
-	SEARCH_COMMANDS.map((command) => time_shell.bash_label(command)),
-)
-
-// `.claude/agents/investigator.md`; a consumer receives it through the plugin as `kit:investigator`.
-const INVESTIGATOR_AGENT = 'investigator'
+const { INVESTIGATOR_AGENT } = delegation_policy
 
 // The deny reason is the only text that reaches the model, so it names the count, command and return shape.
-const REASON = `⛔ investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit. Run \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text. Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``
+const REASON = `⛔ investigation: ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``
 
 interface ReadTally {
 	// The files read and not since edited, resolved.
@@ -56,12 +52,13 @@ interface ReadTally {
 	// The search-side `pending` / `pending_since`, reset by a delegation or a successful write.
 	searches: number
 	searches_since: number
-	// Files successfully edited in the window; a read of one stays in the main line, so it never counts.
+	// Files successfully edited in the window or changed on the branch; a read of one stays in the main
+	// line, so it never counts.
 	edited: ReadonlySet<string>
 }
 
 // The run's own instructions are not the Issue's subject and cannot be delegated, so they never count.
-// Matched relative to the repository root, so `scripts/eval/prompts/x.ts` stays subject code.
+// Matched relative to the repository root, so `tools/eval/prompts/x.ts` stays subject code.
 const INSTRUCTION_PATHS: ReadonlyArray<string> = ['prompts', '.claude/skills']
 const INSTRUCTION_FILES: ReadonlySet<string> = new Set(['CLAUDE.md', 'AGENTS.md', 'GEMINI.md'])
 const REPOSITORY_ROOT = process.cwd()
@@ -188,10 +185,6 @@ interface Accumulation {
 	searches: Map<string, number>
 }
 
-function is_read_only_search(span: Span): boolean {
-	return SEARCH_LABELS.has(span.label) && span.is_bundleable && !span.may_write
-}
-
 // A span with no message id is a turn of its own, as in every other turn counter.
 function search_turn_key(searches: ReadonlyMap<string, number>, span: Span): string {
 	if (span.message_id !== time_spans.NO_MESSAGE_ID) return span.message_id
@@ -210,19 +203,27 @@ function apply_search(searches: Map<string, number>, span: Span): void {
 
 	const turn = search_turn_key(searches, span)
 
-	if (is_read_only_search(span) && !searches.has(turn)) searches.set(turn, span.ended_ms)
+	// A search carries no file text but costs a turn, so searches count in turns: parallel ones count once.
+	if (time_search_call.is_read_only_search(span) && !searches.has(turn)) {
+		searches.set(turn, span.ended_ms)
+	}
+}
+
+// A refused dispatch (`investigator-foreground`, `agent-model`) ran no unit, so it resets nothing.
+function is_delegation(span: Span): boolean {
+	return DELEGATION_TOOLS.has(span.label) && !is_failed_outcome(span)
 }
 
 function apply_span(accumulation: Accumulation, span: Span, edited: ReadonlySet<string>): void {
-	if (DELEGATION_TOOLS.has(span.label)) {
+	if (is_failed_outcome(span)) return
+
+	if (is_delegation(span)) {
 		accumulation.pending.clear()
 		accumulation.searches.clear()
 
 		return
 	}
 
-	if (is_failed_outcome(span)) return
-
 	apply_search(accumulation.searches, span)
 
 	if (!is_content_read(span.label)) return
@@ -233,7 +234,7 @@ function apply_span(accumulation: Accumulation, span: Span, edited: ReadonlySet<
 }
 
 function last_delegation_ms(spans: ReadonlyArray<Span>): number {
-	return delegation_instant(spans.findLast((span) => DELEGATION_TOOLS.has(span.label)))
+	return delegation_instant(spans.findLast((span) => is_delegation(span)))
 }
 
 // The window is the tail the hook read; the set clears at every delegation, so the tail suffices.
@@ -241,9 +242,15 @@ function pending_after(pending: ReadonlyMap<string, number>, since_ms: number):
 	return [...pending.values()].filter((at_ms) => at_ms > since_ms).length
 }
 
-function tally_of(text: string, since_ms: number = hook_decision.NEVER_MS): ReadTally {
+// `branch_files` (repository-relative) are the branch's own change since its merge base: an earlier
+// session of this run wrote them, and a resumed session's transcript holds none of those writes.
+function tally_of(
+	text: string,
+	since_ms: number = hook_decision.NEVER_MS,
+	branch_files: ReadonlyArray<string> = [],
+): ReadTally {
 	const { spans, started_ms } = time_spans.parse_timeline(text)
-	const edited = edited_files(spans)
+	const edited = new Set([...edited_files(spans), ...subject_targets(branch_files)])
 	const accumulation: Accumulation = { pending: new Map(), searches: new Map() }
 
 	for (const span of spans) apply_span(accumulation, span, edited)
@@ -314,7 +321,9 @@ function is_read_only_command(call: GuardedCall, labels: ReadonlySet<string>): b
 
 // A search is refusable without a subject target: a bare-directory sweep is what this count is for.
 function is_search_call(call: GuardedCall): boolean {
-	return is_read_only_command(call, SEARCH_LABELS)
+	return time_search_call.is_read_only_search(
+		time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID),
+	)
 }
 
 // This guard counts reading, so a `Bash` line that also writes is never refused, and neither is a call
@@ -336,6 +345,20 @@ function is_growing_past_threshold(tally: ReadTally, call: GuardedCall): boolean
 	return projected_count(tally.pending, call, tally.edited) > tally.pending.length
 }
 
+function is_blocking(tally: ReadTally, call: GuardedCall, refused_at_ms: number): boolean {
+	return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms)
+}
+
+// The branch diff is a git read, so it is asked only of a call the transcript alone would refuse; more
+// edited files can only lower the counts, so a call that passes without it passes with it.
+function is_blocking_past_branch(text: string, call: GuardedCall, refused_at_ms: number): boolean {
+	if (!is_blocking(tally_of(text, refused_at_ms), call, refused_at_ms)) return false
+
+	const branch_files = changed_paths_sync.read_changed_paths()
+
+	return is_blocking(tally_of(text, refused_at_ms, branch_files), call, refused_at_ms)
+}
+
 function should_block(
 	text: string,
 	call: GuardedCall,
@@ -345,9 +368,7 @@ function should_block(
 	// A delegated unit is never refused: the remedy — send the reading to a unit — does not exist inside one.
 	if (!is_refusable_call(call) || is_unit_run(run)) return false
 
-	const tally = tally_of(text, refused_at_ms)
-
-	return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms)
+	return is_blocking_past_branch(text, call, refused_at_ms)
 }
 
 const investigation_reads = {

package/scripts/dependabot/dependabot-cooldown.ts

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { file_content } from '#scripts/sync/file-content'
+import {
+	DEFAULT_RELEASE_AGE_MINUTES,
+	release_window,
+	type ReleaseWindow,
+} from '#scripts/version/release-window'
+
+// Dependabot's `cooldown` is the workspace's `minimumReleaseAge` restated in days, so a freshly
+// published action or package waits out the same window pnpm and Safe Chain enforce (kit #4023).
+// The edit is line-based and touches only each entry's `cooldown` block: a consumer's own keys and
+// the file's comments survive, which a YAML round trip would discard.
+const DEPENDABOT_FILE = path.join('.github', 'dependabot.yml')
+const MINUTES_PER_DAY = 1440
+// Dependabot accepts `default-days` from 1 to 90.
+const MIN_DAYS = 1
+const MAX_DAYS = 90
+// pnpm's exclusions name npm packages, so only the npm entry receives them.
+const NPM_ECOSYSTEM = 'npm'
+const UPDATES_PATTERN = /^updates:\s*(?:#.*)?$/u
+const ECOSYSTEM_PATTERN = /^\s*(?:-\s+)?package-ecosystem:\s*['"]?([\w-]+)/u
+const TOP_LEVEL_KEY_PATTERN = /^[^\s#-]/u
+const COOLDOWN_KEY = 'cooldown:'
+
+interface UpdateEntry {
+	start: number
+	end: number
+	key_indent: string
+}
+
+function cooldown_days(minutes: number | undefined): number {
+	const days = Math.ceil((minutes ?? DEFAULT_RELEASE_AGE_MINUTES) / MINUTES_PER_DAY)
+
+	return Math.min(MAX_DAYS, Math.max(MIN_DAYS, days))
+}
+
+function quote(value: string): string {
+	return `'${value.replaceAll("'", "''")}'`
+}
+
+function cooldown_lines(ecosystem: string, window: ReleaseWindow, indent: string): Array<string> {
+	const lines = ['cooldown:', `  default-days: ${String(cooldown_days(window.minutes))}`]
+
+	if (ecosystem === NPM_ECOSYSTEM && window.exclusions.length > 0) {
+		lines.push('  exclude:', ...window.exclusions.map((name) => `    - ${quote(name)}`))
+	}
+
+	return lines.map((line) => `${indent}${line}`)
+}
+
+function indent_width(line: string): number {
+	return line.length - line.trimStart().length
+}
+
+function is_blank(line: string | undefined): boolean {
+	return line?.trim() === ''
+}
+
+function trim_trailing_blanks(lines: ReadonlyArray<string>): Array<string> {
+	const trimmed = [...lines]
+	while (trimmed.length > 1 && is_blank(trimmed.at(-1))) trimmed.pop()
+
+	return trimmed
+}
+
+function is_comment(line: string | undefined): boolean {
+	return line?.trimStart().startsWith('#') === true
+}
+
+// A blank line, or a comment left of `width`: it may sit inside a block or head the next one.
+function is_detached(line: string | undefined, width: number): boolean {
+	return is_blank(line) || (is_comment(line) && indent_width(line ?? '') < width)
+}
+
+// The first key line at or after `from` that sits left of `width`, or `limit`.
+function block_stop(
+	lines: ReadonlyArray<string>,
+	from: number,
+	width: number,
+	limit: number,
+): number {
+	const relative = lines
+		.slice(from, limit)
+		.findIndex((line) => !is_blank(line) && !is_comment(line) && indent_width(line) < width)
+
+	return relative === -1 ? limit : from + relative
+}
+
+// The block runs to the next key line left of `width`. A comment left of `width` in the middle stays
+// inside, while the run of such comments right before that key belongs to what follows.
+function block_end(
+	lines: ReadonlyArray<string>,
+	from: number,
+	width: number,
+	limit: number,
+): number {
+	const stop = block_stop(lines, from, width, limit)
+	let end = stop
+
+	for (let index = stop - 1; index >= from && is_detached(lines[index], width); index -= 1) {
+		if (!is_blank(lines[index])) end = index
+	}
+
+	return end
+}
+
+// The next top-level key. A list written flush with `updates:` and a comment at column 0 both still
+// belong to it, so neither ends the list.
+function updates_end(lines: ReadonlyArray<string>, updates: number): number {
+	const relative = lines.slice(updates + 1).findIndex((line) => TOP_LEVEL_KEY_PATTERN.test(line))
+
+	return relative === -1 ? lines.length : updates + 1 + relative
+}
+
+function find_entries(lines: ReadonlyArray<string>, updates: number): Array<UpdateEntry> {
+	const limit = updates_end(lines, updates)
+	const starts = lines
+		.map((line, index) => ({ index, item: /^(\s*-\s+)\S/u.exec(line)?.[1] }))
+		.filter(({ index, item }) => index > updates && index < limit && item !== undefined)
+	const item_width = Math.min(...starts.map(({ item }) => item?.indexOf('-') ?? 0))
+
+	return starts
+		.filter(({ item }) => item?.indexOf('-') === item_width)
+		.map(({ index, item = '' }) => ({
+			start: index,
+			end: block_end(lines, index + 1, item.length, limit),
+			key_indent: ' '.repeat(item.length),
+		}))
+}
+
+// The entry's own `cooldown:` key, either on a key line or on the item line itself (`- cooldown:`).
+function is_cooldown_key(line: string, index: number, key_indent: string): boolean {
+	const is_key_line = index === 0 || line.startsWith(key_indent)
+
+	return is_key_line && line.slice(key_indent.length).startsWith(COOLDOWN_KEY)
+}
+
+// An entry that opened with `- cooldown:` hands its item marker to the next key once the block goes.
+function promote_first_key(rest: ReadonlyArray<string>, marker: string): Array<string> {
+	const first = rest.findIndex((line) => !is_blank(line) && !line.trimStart().startsWith('#'))
+
+	return rest.map((line, index) =>
+		index === first ? `${marker}${line.slice(marker.length)}` : line,
+	)
+}
+
+function without_cooldown(entry: ReadonlyArray<string>, key_indent: string): Array<string> {
+	const start = entry.findIndex((line, index) => is_cooldown_key(line, index, key_indent))
+	if (start === -1) return [...entry]
+	const rest = entry.slice(block_end(entry, start + 1, key_indent.length + 1, entry.length))
+	if (start > 0) return [...entry.slice(0, start), ...rest]
+
+	return promote_first_key(rest, (entry.at(0) ?? '').slice(0, key_indent.length))
+}
+
+function rewrite_entry(
+	entry: ReadonlyArray<string>,
+	key_indent: string,
+	window: ReleaseWindow,
+): Array<string> {
+	const ecosystem = entry.map((line) => ECOSYSTEM_PATTERN.exec(line)?.[1]).find(Boolean)
+	if (ecosystem === undefined) return [...entry]
+	const body = trim_trailing_blanks(without_cooldown(entry, key_indent))
+	const trailing = entry.slice(trim_trailing_blanks(entry).length)
+
+	return [...body, ...cooldown_lines(ecosystem, window, key_indent), ...trailing]
+}
+
+function merge_cooldown(existing: string, window: ReleaseWindow): string {
+	const lines = existing.split('\n')
+	const updates = lines.findIndex((line) => UPDATES_PATTERN.test(line))
+	if (updates === -1) return existing
+
+	for (const { start, end, key_indent } of find_entries(lines, updates).toReversed()) {
+		lines.splice(start, end - start, ...rewrite_entry(lines.slice(start, end), key_indent, window))
+	}
+
+	return lines.join('\n')
+}
+
+function sync_dependabot_cooldown(root: string): boolean {
+	const config_path = path.join(root, DEPENDABOT_FILE)
+	if (!existsSync(config_path)) return false
+	const existing = readFileSync(config_path, 'utf8')
+	const merged = merge_cooldown(existing, release_window.read_release_window(root))
+	if (merged === existing) return false
+	file_content.write_contained(config_path, merged)
+
+	return true
+}
+
+const dependabot_cooldown = { cooldown_days, merge_cooldown, sync_dependabot_cooldown }
+
+export { dependabot_cooldown }

package/scripts/discovery/repo-discovery.ts

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { stamped_memo } from '#scripts/lib/stamped-memo'
 import { repo_map_logic, type DiscoveredRepo, type RepoMap } from './repo-map-logic'
 import { repo_origin } from './repo-origin'
 
@@ -59,18 +60,35 @@ function resolve_git_directory(repository_path: string): string | undefined {
 	}
 }
 
-// The work tree's git config text, or nothing when it is unreadable or not a work tree.
-function read_config(repository_path: string): string | undefined {
-	const git_directory = resolve_git_directory(repository_path)
-	if (git_directory === undefined) return undefined
-
+function read_text(file: string): string | undefined {
 	try {
-		return readFileSync(path.join(git_directory, GIT_CONFIG), 'utf8')
+		return readFileSync(file, 'utf8')
 	} catch {
 		return undefined
 	}
 }
 
+// Each work tree's git directory and each config's text, read again only once the `.git` entry or the
+// config itself has changed: `run:board` cites issues through the origin on every redraw
+// (joshuafolkken/kit#4263).
+const git_directories = stamped_memo.create<string | undefined>()
+const configs = stamped_memo.create<string | undefined>()
+
+// The work tree's git config text, or nothing when it is unreadable or not a work tree.
+function read_config(repository_path: string): string | undefined {
+	const git_entry = path.join(repository_path, GIT_DIRECTORY)
+	const git_directory = git_directories.of(
+		repository_path,
+		stamped_memo.file_stamp(git_entry),
+		() => resolve_git_directory(repository_path),
+	)
+	if (git_directory === undefined) return undefined
+
+	const config = path.join(git_directory, GIT_CONFIG)
+
+	return configs.of(config, stamped_memo.file_stamp(config), () => read_text(config))
+}
+
 // The `origin` URL a work tree declares, or nothing when it has no `origin`, no readable config, or
 // is not a work tree at all. Every failure reads as "no remote" so one unreadable sibling cannot
 // fail a command whose contract is to report what it could find.

package/scripts/discovery/repo-party.ts

@@ -1,5 +1,6 @@
 import { repo_discovery } from './repo-discovery'
-import { repo_origin } from './repo-origin'
+import { repo_origin, type RepoIdentity } from './repo-origin'
+import { session_owner_pin } from './session-owner-pin'
 
 // **First-party vs third-party, computed rather than judged**. `CLAUDE.md`
 // and `upstream-interrupt.md` both declared the test mechanical — owner equality between the target
@@ -32,45 +33,100 @@ function classify(session_owner: string | undefined, target: string | undefined)
 // The owner half of a `owner/repo` argument, parsed through the remote-URL reader so a `.git` suffix
 // and a malformed form (one segment, three segments) are handled by the one place that already knows
 // them rather than by a second split here.
+function parse_owner_repo(owner_repo: string): RepoIdentity | undefined {
+	return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)
+}
+
 function target_owner(owner_repo: string): string | undefined {
-	return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner
+	return parse_owner_repo(owner_repo)?.owner
 }
 
-// The owner of the repository the session runs in, read locally from its `origin` — no network call
-// and no authenticated CLI, so the guard that consults it stays synchronous.
+// The owner of the repository the session runs in: the one pinned at session start, else read
+// locally from its `origin` — no network call and no authenticated CLI, so the guard that consults it
+// stays synchronous. The pin is what keeps a mid-session remote rewrite from changing the answer
+// (`session-owner-pin.ts`).
 function current_owner(repository_path: string = process.cwd()): string | undefined {
-	return repo_discovery.resolve_current_owner(repository_path)
+	return (
+		session_owner_pin.pinned(repository_path) ??
+		repo_discovery.resolve_current_owner(repository_path)
+	)
+}
+
+// The repository a `[HOST/]OWNER/REPO` selector names — `GH_REPO`, or `gh`'s `-R` / `--repo` value —
+// read from its last two segments so an optional host prefix is skipped.
+function selector_repository(selector: string): RepoIdentity | undefined {
+	return parse_owner_repo(selector.split('/').slice(-GH_REPO_PATH_SEGMENTS).join('/'))
 }
 
-// The owner `GH_REPO` names, read from its last two segments so an optional host prefix is skipped.
-function gh_repo_owners(gh_repo: string): Array<string | undefined> {
-	return [target_owner(gh_repo.split('/').slice(-GH_REPO_PATH_SEGMENTS).join('/'))]
+function selector_owner(selector: string): string | undefined {
+	return selector_repository(selector)?.owner
 }
 
-// The owner of every remote the work tree declares. A remote whose owner cannot be read stays in the
-// set as `undefined` rather than being dropped: an SSH host alias (`git@github-work:o/r.git`) is one
-// `gh` translates to github.com and may pick, so dropping it would hide the owner `gh` writes to.
-function remote_owners(repository_path: string): Array<string | undefined> {
+// Every remote the work tree declares. A remote that cannot be read stays in the set as `undefined`
+// rather than being dropped: an SSH host alias (`git@github-work:o/r.git`) is one `gh` translates to
+// github.com and may pick, so dropping it would hide the repository `gh` writes to.
+function remote_repositories(repository_path: string): Array<RepoIdentity | undefined> {
 	return repo_discovery
 		.read_remote_urls(repository_path)
-		.map((url) => repo_origin.parse_origin_url(url)?.owner)
+		.map((url) => repo_origin.parse_origin_url(url))
 }
 
-// Every owner `gh` could expand the `{owner}` placeholder to. `GH_REPO`
+// Every repository `gh` could expand the `{owner}/{repo}` placeholders to. `GH_REPO`
 // (`[HOST/]OWNER/REPO`) overrides the remotes outright; otherwise `gh` picks its base repository among
 // the GitHub remotes — `upstream` ahead of `origin`, or a `gh repo set-default` choice — so in a fork
-// checkout it can expand to the upstream owner. Answering the whole candidate set rather than
+// checkout it can expand to the upstream repository. Answering the whole candidate set rather than
 // re-implementing that pick keeps the caller safe whichever remote `gh` chooses. An `undefined` entry
-// is a candidate whose owner could not be read, which the caller must not assume is first-party.
+// is a candidate that could not be read, which the caller must not assume is first-party.
+function placeholder_repositories(
+	repository_path: string,
+	environment: NodeJS.ProcessEnv,
+): Array<RepoIdentity | undefined> {
+	const gh_repo = environment[GH_REPO_ENV_KEY]
+
+	return gh_repo === undefined || gh_repo === ''
+		? remote_repositories(repository_path)
+		: [selector_repository(gh_repo)]
+}
+
 function placeholder_owners(
 	repository_path: string = process.cwd(),
 	environment: NodeJS.ProcessEnv = process.env,
 ): Array<string | undefined> {
-	const gh_repo = environment[GH_REPO_ENV_KEY]
+	return placeholder_repositories(repository_path, environment).map((identity) => identity?.owner)
+}
 
-	return gh_repo === undefined || gh_repo === ''
-		? remote_owners(repository_path)
-		: gh_repo_owners(gh_repo)
+// Two spellings of one repository, compared case-insensitively as GitHub resolves them.
+function is_same_repository(left: RepoIdentity | undefined, right: RepoIdentity): boolean {
+	if (left === undefined || classify(left.owner, right.owner) !== FIRST_PARTY) return false
+
+	return left.repo.toLowerCase() === right.repo.toLowerCase()
+}
+
+// The one repository every candidate names, or nothing when there is none, one is unreadable, or two
+// differ — a fork checkout whose `upstream` `gh` may pick ahead of `origin`.
+function sole_repository(
+	candidates: ReadonlyArray<RepoIdentity | undefined>,
+): RepoIdentity | undefined {
+	const [first, ...rest] = candidates
+	if (first === undefined) return undefined
+
+	return rest.every((candidate) => is_same_repository(candidate, first)) ? first : undefined
+}
+
+// The checkout's own repository: the one `{owner}/{repo}` expands to — where `josh issue:comment`
+// posts. Nothing unless that is one repository whichever candidate `gh` picks, so a spelled-out
+// repository is never read as the one `issue:comment` reaches when it might not be
+// (joshuafolkken/kit#4737).
+function current_repository(
+	repository_path: string = process.cwd(),
+	environment: NodeJS.ProcessEnv = process.env,
+): RepoIdentity | undefined {
+	return sole_repository(placeholder_repositories(repository_path, environment))
+}
+
+// Whether `target` is the checkout's own repository `current_repository` answered.
+function is_own_repository(target: RepoIdentity, own: RepoIdentity | undefined): boolean {
+	return is_same_repository(own, target)
 }
 
 const repo_party = {
@@ -79,7 +135,11 @@ const repo_party = {
 	UNKNOWN,
 	classify,
 	current_owner,
+	current_repository,
+	is_own_repository,
 	placeholder_owners,
+	selector_owner,
+	sole_repository,
 	target_owner,
 }
 

package/scripts/discovery/session-owner-pin.ts

@@ -0,0 +1,51 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { repo_discovery } from './repo-discovery'
+
+// **The session's owner, fixed when the session starts** (joshuafolkken/kit#4659). The first-party
+// test compares a target's owner with the session's, and the session's was read from `origin` on
+// every call — so `git remote set-url origin https://github.com/<other>/x` mid-session made another
+// owner first-party. The session-start hook records the owner once; `repo_party.current_owner`
+// answers the record ahead of the live remote. Only the session's owner is pinned: the `{owner}`
+// placeholder candidates and a selector-less `gh` write still resolve against the live remotes.
+//
+// **Written by the process the session start already runs** (`audit-provision --session-start`), so
+// pinning adds no spawn to the launch, and read as one local file by the hooks that already run — no
+// network call. A checkout with no record (a session the hook did not start) falls back to `origin`.
+//
+// **Per checkout, replaced at every session start.** The record is the stamp `stamp-file.ts` keeps in
+// the temp directory, keyed on the account and the checkout path; a checkout whose origin owner
+// cannot be read at start leaves no record rather than a stale one. A command run outside a session
+// reads the last session's record for that path, which the next session start replaces.
+
+const PIN_PREFIX = 'josh-session-owner-'
+const PIN_SUFFIX = '.txt'
+
+function pin_path(repository_path: string): string {
+	return stamp_file.stamp_path(PIN_PREFIX, repository_path, PIN_SUFFIX)
+}
+
+// Records the checkout's `origin` owner for the session about to run. Never throws: this runs at
+// session start beside the scanner provisioning, and an unwritable temp directory only costs the pin.
+function pin(repository_path: string = process.cwd()): string | undefined {
+	const owner = repo_discovery.resolve_current_owner(repository_path)
+
+	try {
+		if (owner === undefined) stamp_file.remove_stamp(pin_path(repository_path))
+		else stamp_file.write_text_stamp(pin_path(repository_path), owner)
+	} catch {
+		return undefined
+	}
+
+	return owner
+}
+
+// The owner recorded at session start, or `undefined` when the checkout holds no readable record.
+function pinned(repository_path: string = process.cwd()): string | undefined {
+	const text = stamp_file.read_stamp_text(pin_path(repository_path))?.trim()
+
+	return text === '' ? undefined : text
+}
+
+const session_owner_pin = { pin, pin_path, pinned }
+
+export { session_owner_pin }

package/scripts/doctor/doctor-consumer.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 import { json_value } from '#scripts/lib/json-value'
+import { package_manifest } from '#scripts/lib/package-manifest'
 import { file_reader } from '#scripts/lib/read-file'
 import { PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
@@ -37,11 +38,7 @@ const STATE_MISSING = 'missing'
 type ClaudeMdState = typeof STATE_OK | typeof STATE_TARGET_MISSING | typeof STATE_MISSING
 
 function parse_manifest(root: string): ManifestShape | undefined {
-	const content = file_reader.read_if_readable(path.join(root, 'package.json'))
-	if (content === undefined) return undefined
-	const parsed = manifest_schema.safeParse(json_value.parse_or_undefined(content))
-
-	return parsed.success ? parsed.data : undefined
+	return package_manifest.read_manifest_if_valid(root, manifest_schema)
 }
 
 function lists_kit_dependency(manifest: ManifestShape | undefined): boolean {

package/scripts/document/capped-print.ts

@@ -68,6 +68,6 @@ function capped_print(text: string, label: string, root: string = process.cwd())
 	console.info(listing(text, budget, write_parts(label, text, budget)))
 }
 
-const capped_output = { HEADROOM_CHARS, capped_print }
+const capped_output = { HEADROOM_CHARS, capped_print, output_budget }
 
 export { capped_output }