@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/scripts/agent/answer-verdict.ts

@@ -0,0 +1,122 @@
+import type { IssueSource } from '#scripts/issue/issue-sources'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// **Whether an Issue already answers a question, as one contract every caller shares** — the park that
+// refuses an answered question and the package scout that reuses existing code read the same verdict.
+// An answered verdict stands only on quotes found verbatim in a fetched trusted source; anything else
+// is a failure with its cause, never read as "answered" or "unanswered". The caller does its own
+// writes: this module validates and returns.
+
+const NON_BLANK = /\S/u
+const TEXT_SCHEMA = z.string().regex(NON_BLANK)
+const QUOTE_SCHEMA = z.strictObject({ source: TEXT_SCHEMA, text: TEXT_SCHEMA })
+const ANSWERED_SCHEMA = z.strictObject({
+	verdict: z.literal('answered'),
+	decision: TEXT_SCHEMA,
+	decision_kind: z.enum(['choice', 'reuse']),
+	quotes: z.array(QUOTE_SCHEMA).min(1),
+})
+const UNANSWERED_SCHEMA = z.strictObject({ verdict: z.literal('unanswered'), reason: TEXT_SCHEMA })
+const VERDICT_SCHEMA = z.discriminatedUnion('verdict', [ANSWERED_SCHEMA, UNANSWERED_SCHEMA])
+const RETRY =
+	'Re-run the same command: the judgment is launched again on the Issue as it reads now.'
+
+type Answered = z.infer<typeof ANSWERED_SCHEMA>
+type ParsedVerdict = z.infer<typeof VERDICT_SCHEMA>
+type DecisionKind = Answered['decision_kind']
+
+interface Evidence {
+	source: IssueSource
+	quote: string
+}
+
+interface VerdictFailure {
+	kind: 'failed'
+	cause: string
+	retry: string
+}
+
+type AnswerVerdict =
+	| VerdictFailure
+	| { kind: 'answered'; decision: string; decision_kind: DecisionKind; evidence: Array<Evidence> }
+	| { kind: 'unanswered'; reason: string }
+
+function failed(cause: string, retry: string = RETRY): VerdictFailure {
+	return { kind: 'failed', cause, retry }
+}
+
+// A model may wrap its object in a fence or a sentence; the object is what lies between the braces.
+function json_text(raw: string): string | undefined {
+	const start = raw.indexOf('{')
+	const end = raw.lastIndexOf('}')
+
+	return start === -1 || end < start ? undefined : raw.slice(start, end + 1)
+}
+
+function issues_of(error: z.ZodError): string {
+	return error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; ')
+}
+
+function parsed_of(raw: string): ParsedVerdict | VerdictFailure {
+	const text = json_text(raw)
+	const value = text === undefined ? undefined : json_value.parse_or_undefined(text)
+
+	if (value === undefined) return failed('the judgment printed no JSON object')
+
+	const result = VERDICT_SCHEMA.safeParse(value)
+
+	return result.success
+		? result.data
+		: failed(`the judgment is off the contract — ${issues_of(result.error)}`)
+}
+
+// An untrusted text never reaches `sources`, so a quote naming one fails as a source never fetched.
+function evidence_of(
+	quote: Answered['quotes'][number],
+	sources: ReadonlyArray<IssueSource>,
+): Evidence | VerdictFailure {
+	const source = sources.find((candidate) => candidate.id === quote.source)
+
+	if (source === undefined) {
+		return failed(`a quote cites ${quote.source}, which is not a fetched trusted source`)
+	}
+
+	if (!source.text.includes(quote.text)) {
+		return failed(`a quote is not in ${quote.source} verbatim: ${quote.text}`)
+	}
+
+	return { source, quote: quote.text }
+}
+
+function answered(parsed: Answered, sources: ReadonlyArray<IssueSource>): AnswerVerdict {
+	const evidence: Array<Evidence> = []
+
+	for (const quote of parsed.quotes) {
+		const found = evidence_of(quote, sources)
+
+		if ('kind' in found) return found
+		evidence.push(found)
+	}
+
+	return {
+		kind: 'answered',
+		decision: parsed.decision,
+		decision_kind: parsed.decision_kind,
+		evidence,
+	}
+}
+
+function validate(raw: string, sources: ReadonlyArray<IssueSource>): AnswerVerdict {
+	const parsed = parsed_of(raw)
+
+	if (!('verdict' in parsed)) return parsed
+	if (parsed.verdict === 'unanswered') return { kind: 'unanswered', reason: parsed.reason }
+
+	return answered(parsed, sources)
+}
+
+const answer_verdict = { RETRY, failed, validate }
+
+export type { AnswerVerdict, DecisionKind, Evidence, VerdictFailure }
+export { answer_verdict }

package/scripts/agent/claude-agent-argv.ts

@@ -36,8 +36,8 @@ const SESSION_ID_FLAG = '--session-id'
 // **A launched child carries only the tools a lane has ever used**. Every
 // tool definition and every user-side claude.ai connector rides on each request's cached preamble, and
 // across the lanes measured none of Artifact, Workflow or a connector was ever called, while
-// AskUserQuestion has nobody to answer it in an unattended lane. Narrowing them cut the preamble by
-// about 16,000 tokens per request. **No web tool is launched**: no role runs with a person at the keyboard, and a
+// AskUserQuestion has nobody to answer it in an unattended lane, so narrowing them shrinks every
+// request's preamble. **No web tool is launched**: no role runs with a person at the keyboard, and a
 // fetched page enters the context with no trust label, past the Issue trust filter (#4664). This list
 // is the one place the set is kept.
 const LAUNCHED_TOOLS: ReadonlyArray<string> = [
@@ -55,8 +55,14 @@ const LAUNCHED_TOOLS: ReadonlyArray<string> = [
 ]
 // **A reviewer is the review, not a launcher of one** (joshuafolkken/kit#4715): with `Skill` it ran
 // `/code-review`, which forked a second agent that read the same diff and brief again. Without the two
-// tools that open a nested agent, the review stays in the one session.
-const NESTING_TOOLS: ReadonlySet<string> = new Set(['Agent', 'Skill'])
+// tools that open a nested agent, the review stays in the one session. **A worker has no `Skill` call
+// path** (#7104): it reads its procedures with `josh doc:read` and starts reviews through `Agent`, so
+// dropping `Skill` takes the skill listing off every request's preamble. The scheduler keeps both.
+const DROPPED_TOOLS: Readonly<Record<AgentRole, ReadonlySet<string>>> = {
+	scheduler: new Set(),
+	worker: new Set(['Skill']),
+	reviewer: new Set(['Agent', 'Skill']),
+}
 const TOOLS_FLAG = '--tools'
 // **Only the project's own MCP servers load** — the user's connectors are what the strict flag drops.
 // A project with no `.mcp.json` gets the strict flag alone, which loads no server at all: that is
@@ -82,9 +88,9 @@ function session_id_flags(session_id: string | undefined): ReadonlyArray<string>
 }
 
 function launched_tools(role: AgentRole): ReadonlyArray<string> {
-	if (role !== agent_role_profile.REVIEWER) return LAUNCHED_TOOLS
+	const dropped = DROPPED_TOOLS[role]
 
-	return LAUNCHED_TOOLS.filter((tool) => !NESTING_TOOLS.has(tool))
+	return LAUNCHED_TOOLS.filter((tool) => !dropped.has(tool))
 }
 
 // The config is named by absolute path, resolved against the directory the child is launched in, so

package/scripts/agent/codex-agent-argv.ts

@@ -1,9 +1,6 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync } from 'node:fs'
 import path from 'node:path'
-import { git_common_directory } from '#scripts/git/git-common-directory'
-import { durable_state } from '#scripts/josh/durable-state'
-import { OBSERVATION_LEDGER_DIRECTORY } from '#scripts/observations/observation-ledger'
-import { agent_role_profile, type AgentProfile } from './agent-role-profile'
+import { agent_profile_schema, type AgentProfile } from './agent-profile-schema'
+import { agent_session_role } from './agent-session-role'
 
 const AGENT_COMMAND = 'codex'
 const AGENT_FLAGS: ReadonlyArray<string> = ['exec']
@@ -12,36 +9,14 @@ const CONFIG_FLAG = '-c'
 const JSON_FLAG = '--json'
 const SQLITE_CACHE_PATH = ['node_modules', '.cache', 'josh', 'openai']
 const EPHEMERAL_FLAG = '--ephemeral'
-const GIT_DIRECTORY = '.git'
-const LEDGER_DIRECTORY = path.dirname(OBSERVATION_LEDGER_DIRECTORY)
-const WORKTREE_REGISTRY = 'worktrees'
-const READ = 'read'
-const WRITE = 'write'
-
-// The sandbox is a Codex permission profile, not `--sandbox workspace-write` with `--add-dir` roots
-// (joshuafolkken/kit#4653). It reads the whole disk and writes the work tree, the temp directories, the
-// network and the common git directory — whose root a ref deletion needs: `git branch -d` and
-// `git stash drop` rewrite `packed-refs` through `packed-refs.lock` there.
-const PERMISSION_PROFILE = 'josh_lane'
-const PROFILE_CONFIG = `default_permissions="${PERMISSION_PROFILE}"`
-const NETWORK_CONFIG = `permissions.${PERMISSION_PROFILE}.network.enabled=true`
-const FILESYSTEM_KEY = `permissions.${PERMISSION_PROFILE}.filesystem`
-const BASE_GRANTS: ReadonlyArray<Grant> = [
-	[':root', READ],
-	[':workspace_roots', WRITE],
-	[':slash_tmp', WRITE],
-	[':tmpdir', WRITE],
+// Trusted local batches keep action authorization in the workflow and hooks (joshuafolkken/kit#5438).
+// This policy cannot remove an OS sandbox inherited from the process that launches the batch.
+const PERMISSION_ARGUMENTS: ReadonlyArray<string> = [
+	CONFIG_FLAG,
+	'default_permissions=":danger-full-access"',
+	CONFIG_FLAG,
+	'approval_policy="never"',
 ]
-// What git runs or follows to another directory stays read-only, so the sandbox cannot plant code that
-// runs outside it the next time anything runs git: `hooks/` and `config`, and the `commondir` and
-// `config.worktree` that would point a git directory at a planted one. An exact read-only path also
-// refuses creating, renaming and deleting it (measured on codex-cli 0.156.1).
-const PINNED_WORKTREE_ENTRIES: ReadonlyArray<string> = ['commondir', 'config.worktree']
-const PINNED_ENTRIES: ReadonlyArray<string> = ['hooks', 'config', ...PINNED_WORKTREE_ENTRIES]
-// Each registered work tree's git directory is pinned the same way; one registered after launch — a
-// later lane, or the detached tree `josh test:red` and `josh metrics` add (`base-tree.ts`) — is not.
-
-type Grant = readonly [string, string]
 
 interface CodexArgv {
 	command: string
@@ -53,119 +28,16 @@ function effort_config(profile: AgentProfile): string {
 	return `model_reasoning_effort="${profile.effort}"`
 }
 
+function role_config(profile: AgentProfile): string {
+	return `shell_environment_policy.set.${agent_session_role.KEY}=${JSON.stringify(profile.role)}`
+}
+
 function sqlite_config(cwd: string): string {
 	return `sqlite_home=${JSON.stringify(path.resolve(cwd, ...SQLITE_CACHE_PATH))}`
 }
 
 function persistence_arguments(profile: AgentProfile): ReadonlyArray<string> {
-	return profile.role === agent_role_profile.WORKER ? [] : [EPHEMERAL_FLAG]
-}
-
-// A granted directory is created up front — it would otherwise be created in a directory the sandbox
-// cannot write — and refused when it is not a real directory, so a symlink cannot widen the grant.
-function ensure_writable_directory(directory: string, mode?: number): void {
-	const current = lstatSync(directory, { throwIfNoEntry: false })
-
-	if (current === undefined) mkdirSync(directory, { recursive: true, mode })
-	else if (!current.isDirectory() || current.isSymbolicLink()) {
-		throw new Error(`Writable root must be a real directory: ${directory}`)
-	}
-}
-
-function pinned(directory: string, entries: ReadonlyArray<string>): ReadonlyArray<Grant> {
-	return entries.map((entry) => [path.join(directory, entry), READ])
-}
-
-function registered_worktrees(common_directory: string): ReadonlyArray<string> {
-	const registry = path.join(common_directory, WORKTREE_REGISTRY)
-	if (!existsSync(registry)) return []
-
-	return readdirSync(registry, { withFileTypes: true })
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => path.join(registry, entry.name))
-}
-
-// Real paths, since the sandbox matches resolved paths: a `.git` reached through a symlink is granted
-// where it lives, and an entry of it that is a symlink is not followed out of it.
-function git_grants(common_directory: string | undefined): ReadonlyArray<Grant> {
-	if (common_directory === undefined) return []
-
-	const root = realpathSync(common_directory)
-
-	return [
-		[root, WRITE],
-		...pinned(root, PINNED_ENTRIES),
-		...registered_worktrees(root).flatMap((worktree) => pinned(worktree, PINNED_WORKTREE_ENTRIES)),
-	]
-}
-
-// Only the ledger's parent directory is writable outside a lane, never the primary checkout root.
-function ledger_grants(
-	common_directory: string | undefined,
-	profile: AgentProfile,
-): ReadonlyArray<Grant> {
-	if (
-		common_directory === undefined ||
-		profile.role !== agent_role_profile.WORKER ||
-		path.basename(common_directory) !== GIT_DIRECTORY
-	) {
-		return []
-	}
-
-	const ledger = path.join(path.dirname(common_directory), LEDGER_DIRECTORY)
-
-	ensure_writable_directory(ledger)
-
-	return [[realpathSync(ledger), WRITE]]
-}
-
-// An inline TOML table; a JSON string is a valid TOML basic string.
-function filesystem_config(grants: ReadonlyArray<Grant>): string {
-	const pairs = grants.map(
-		([target, access]) => `${JSON.stringify(target)}=${JSON.stringify(access)}`,
-	)
-
-	return `${FILESYSTEM_KEY}={${pairs.join(',')}}`
-}
-
-// A `backlogrun` parent runs in the primary checkout, where no common git directory grant is given,
-// so the run-state directory its lanes write through that grant is granted on its own — without it the
-// parent's records would fall back to the temp root, apart from its lanes'.
-function state_grants(cwd: string): ReadonlyArray<Grant> {
-	const repository = git_common_directory.repository(cwd)
-	if (repository === undefined) return []
-
-	const state = durable_state.root_for(repository)
-
-	ensure_writable_directory(state, durable_state.STATE_DIRECTORY_MODE)
-
-	return [[realpathSync(state), WRITE]]
-}
-
-function lane_grants(cwd: string | undefined, profile: AgentProfile): ReadonlyArray<Grant> {
-	if (cwd === undefined) return []
-
-	const common_directory = git_common_directory.resolve(cwd)
-
-	if (common_directory === undefined) return state_grants(cwd)
-
-	return [...git_grants(common_directory), ...ledger_grants(common_directory, profile)]
-}
-
-function permission_arguments(
-	cwd: string | undefined,
-	profile: AgentProfile,
-): ReadonlyArray<string> {
-	const grants = [...BASE_GRANTS, ...lane_grants(cwd, profile)]
-
-	return [
-		CONFIG_FLAG,
-		PROFILE_CONFIG,
-		CONFIG_FLAG,
-		filesystem_config(grants),
-		CONFIG_FLAG,
-		NETWORK_CONFIG,
-	]
+	return profile.role === agent_profile_schema.WORKER ? [] : [EPHEMERAL_FLAG]
 }
 
 function lane_arguments(cwd: string | undefined, profile: AgentProfile): ReadonlyArray<string> {
@@ -183,7 +55,9 @@ function build(invocation: string, profile: AgentProfile, cwd?: string): CodexAr
 			profile.model,
 			CONFIG_FLAG,
 			effort_config(profile),
-			...permission_arguments(cwd, profile),
+			CONFIG_FLAG,
+			role_config(profile),
+			...PERMISSION_ARGUMENTS,
 			...lane_arguments(cwd, profile),
 			JSON_FLAG,
 			invocation,

package/scripts/agent/codex-home-source.ts

@@ -1,7 +1,7 @@
 import os from 'node:os'
 import path from 'node:path'
 
-// Resolve the default Codex home in a read-only module, separate from reviewer state setup.
+// Resolve the default Codex home in a read-only module.
 function default_home(): string {
 	return path.join(os.homedir(), '.codex')
 }

package/scripts/agent/codex-hooks.ts

@@ -7,7 +7,8 @@ import { hook_launch } from '#scripts/init/hook-launch'
 //
 // 1. The pretool and posttool handlers run through the Codex input adapter, which translates the
 //    `apply_patch` payload into the Edit/Write shape the Claude-side guards read.
-// 2. The PreToolUse and PostToolUse matchers also select `apply_patch`, Codex's edit tool.
+// 2. The PreToolUse and PostToolUse matchers also select `apply_patch`, Codex's edit tool, and
+//    `exec_command`, its shell, whose writes the posttool revert reads (`bash-revert.ts`).
 // 3. UserPromptSubmit carries no matcher — Codex documents that the event ignores it.
 
 interface HookHandler {
@@ -27,13 +28,22 @@ interface HookConfig {
 	hooks: HookEvents
 }
 
-const CODEX_EDIT_TOOL = 'apply_patch'
+const CODEX_EDIT_TOOL = 'apply_patch|functions.apply_patch'
+const CODEX_SHELL_TOOLS = 'exec_command|functions.exec_command|exec|functions.exec'
 const TOOL_EVENTS: ReadonlySet<string> = new Set(['PreToolUse', 'PostToolUse'])
 const UNMATCHED_EVENTS: ReadonlySet<string> = new Set(['UserPromptSubmit'])
 const JSON_INDENT = '\t'
+const CLAUDE_SETTINGS_FILE = '.claude/settings.json'
+const CODEX_HOOKS_FILE = '.codex/hooks.json'
+
+// Each committed artifact a build regenerates, keyed to the file it is generated from (repo-relative):
+// `lane:plan` does not count one planned beside its source (`lane-plan-size.ts`).
+const GENERATED_SOURCES: ReadonlyMap<string, string> = new Map([
+	[CODEX_HOOKS_FILE, CLAUDE_SETTINGS_FILE],
+])
 
 function adapter_command(mode: string): string {
-	return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`)
+	return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`, hook_launch.CODEX_ROOT)
 }
 
 // Each Claude-side guard command the adapter stands in for, keyed by that command verbatim.
@@ -43,12 +53,18 @@ const ADAPTED_COMMANDS: ReadonlyMap<string, string> = new Map([
 ])
 
 function codex_handler(handler: HookHandler): HookHandler {
-	return { ...handler, command: ADAPTED_COMMANDS.get(handler.command) ?? handler.command }
+	const command =
+		ADAPTED_COMMANDS.get(handler.command) ?? hook_launch.codex_command(handler.command)
+
+	return { ...handler, command }
 }
 
 function codex_matcher(event: string, matcher: string | undefined): string | undefined {
 	if (UNMATCHED_EVENTS.has(event)) return undefined
-	if (matcher !== undefined && TOOL_EVENTS.has(event)) return `${matcher}|${CODEX_EDIT_TOOL}`
+
+	if (matcher !== undefined && TOOL_EVENTS.has(event)) {
+		return `${matcher}|${CODEX_EDIT_TOOL}|${CODEX_SHELL_TOOLS}`
+	}
 
 	return matcher
 }
@@ -77,7 +93,14 @@ function codex_hooks_text(claude_settings_text: string): string {
 	return `${JSON.stringify(codex_hook_config(claude), undefined, JSON_INDENT)}\n`
 }
 
-const codex_hooks = { adapter_command, codex_hook_config, codex_hooks_text }
+const codex_hooks = {
+	adapter_command,
+	codex_hook_config,
+	codex_hooks_text,
+	CLAUDE_SETTINGS_FILE,
+	CODEX_HOOKS_FILE,
+	GENERATED_SOURCES,
+}
 
 export { codex_hooks }
 export type { HookConfig }

package/scripts/agent/judgment-agent-argv.ts

@@ -0,0 +1,49 @@
+import type { AgentArgv, AgentArgvResult } from './agent-argv'
+import { agent_diagnostics } from './agent-diagnostics'
+import type { AgentProfile } from './agent-role-profile'
+import { claude_agent_argv } from './claude-agent-argv'
+
+// **A judgment child reads and answers; it can do nothing else.** `--tools=` launches no built-in
+// tool — one element, because `detached_launch` refuses an empty argv element (`--tools ''`),
+// `--strict-mcp-config` with no `--mcp-config` loads no MCP server, `--restricted` ignores the
+// user, project and local settings files (their hooks and permissions included) and refuses
+// `bypassPermissions`, and `--disable-slash-commands` drops every skill and command. No permission
+// mode and no lane instruction set ride along, so nothing the worker launch grants carries over.
+const JUDGMENT_FLAGS: ReadonlyArray<string> = [
+	'-p',
+	'--verbose',
+	'--output-format',
+	'stream-json',
+	'--tools=',
+	'--strict-mcp-config',
+	'--restricted',
+	'--disable-slash-commands',
+]
+const MODEL_FLAG = '--model'
+const EFFORT_FLAG = '--effort'
+const SUPPORTED_PROVIDER = 'anthropic'
+// **A provider that cannot launch with no tool is refused, never swapped.** The Codex CLI has no
+// argument that stops every tool, and its read-only sandbox still runs shell commands.
+const UNSUPPORTED_NOTE =
+	'judgment launch refused: the openai provider (Codex CLI) has no argument that disables every tool, and a read-only sandbox still runs commands. Retry with JOSH_AGENT_PROVIDER=anthropic.'
+
+function build(invocation: string, profile: AgentProfile): AgentArgv {
+	return {
+		command: claude_agent_argv.AGENT_COMMAND,
+		args: [...JUDGMENT_FLAGS, MODEL_FLAG, profile.model, EFFORT_FLAG, profile.effort, invocation],
+		ends_with_prompt: true,
+	}
+}
+
+function resolve(invocation: string, profile: AgentProfile): AgentArgvResult {
+	if (profile.provider !== SUPPORTED_PROVIDER) return { kind: 'rejected', note: UNSUPPORTED_NOTE }
+
+	const diagnostic = agent_diagnostics.check(profile)
+	if (diagnostic.kind === 'rejected') return diagnostic
+
+	return { kind: 'argv', argv: build(invocation, profile), profile }
+}
+
+const judgment_agent_argv = { UNSUPPORTED_NOTE, build, resolve }
+
+export { judgment_agent_argv }

package/scripts/agent/lane-instructions.ts

@@ -17,6 +17,8 @@ interface LaneSet {
 // names the rules a lane does need by `CLAUDE.md` heading or bold label, and each `include` line is
 // expanded from the launch checkout's own `CLAUDE.md` here, so the rule text keeps one source (#3929).
 const LANE_DOCUMENT = 'prompts/collaboration-workflow/lane-instructions.md'
+const WORKFLOW_ENTRY = 'fullrun-lane.md'
+const WORKFLOW_GUIDE = `A headless fullrun lane child runs pnpm josh doc:read ${WORKFLOW_ENTRY} instead of workflow-commands/SKILL.md, fullrun.md or entry-sequence.md. A resumed child follows its resume prompt first. Review sessions do not start a fullrun.`
 const RULES_FILE = 'CLAUDE.md'
 // `AGENTS.md` only points at `CLAUDE.md`, and Claude Code loads it once `CLAUDE.md` is excluded.
 const POINTER_FILE = 'AGENTS.md'
@@ -42,7 +44,7 @@ function compose(lane_markdown: string, rules: string): string | undefined {
 
 	if (expanded.includes(undefined)) return undefined
 
-	return expanded.join('\n')
+	return [WORKFLOW_GUIDE, ...expanded].join('\n')
 }
 
 // **Where the rules are: the checkout's `CLAUDE.md`, else the package copy it imports.** kit and a
@@ -133,6 +135,7 @@ function resident_line(cwd: string = process.cwd()): string {
 }
 
 const lane_instructions = {
+	WORKFLOW_ENTRY,
 	PROMPT_FILE_FLAG,
 	SETTINGS_FLAG,
 	compose,

package/scripts/auto-ok/auto-ok-author.ts

@@ -1,14 +1,25 @@
 import { epic_graph, type EpicChild } from '#scripts/epic/epic-graph'
-import { gh_author_association } from '#scripts/gh/gh-author-association'
+import {
+	gh_author_association,
+	type Author,
+	type AuthorFields,
+} from '#scripts/gh/gh-author-association'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
 
 // Whether an unattended run may act on an opted-in issue's body. The run takes that body as its
 // specification, and on a public repository anyone can file an issue — the `auto-ok` a person applied
 // says nothing about a body its author rewrote after the label. So only an issue whose author has
 // write access is runnable, and a lookup that failed is not trust; the rest wait on a person.
+//
+// The asks are shared across processes (joshuafolkken/kit#6613): every backlog scan reads the same
+// authors, and a write role read in the last hour stands for the next scan.
+
+function shared_author_of(row: AuthorFields): Author {
+	return { ...gh_author_association.author_of(row), is_shared: true }
+}
 
 async function with_trust(issue: OpenIssueData): Promise<OpenIssueData> {
-	const author = gh_author_association.author_of(issue)
+	const author = shared_author_of(issue)
 
 	return { ...issue, author_trusted: await gh_author_association.is_trusted(author) }
 }
@@ -27,7 +38,7 @@ function is_author_trusted(issue: OpenIssueData): boolean {
 // The write-access lookup asks *this* repository's collaborators, which says nothing about access to
 // another one — so a child elsewhere is asked with no login, which `trust_of` answers for `OWNER` alone.
 async function is_child_trusted(child: EpicChild, repo: string): Promise<boolean> {
-	const author = gh_author_association.author_of(child)
+	const author = shared_author_of(child)
 
 	return await gh_author_association.is_trusted(
 		child.repo === repo ? author : { ...author, login: undefined },

package/scripts/auto-ok/auto-ok-cli.ts

@@ -146,9 +146,10 @@ function parse_options(argv: ReadonlyArray<string>, usage: string = USAGE): Next
 // empty listing: reading a failed read as "none" ends the run reporting a confident absence built on
 // a response nobody parsed. They stay apart from each other because the zod
 // rejection `parse_json_array_or_undefined` deliberately rethrows means the listing's *fields*
-// changed, not that the caller's authentication lapsed.
+// changed, not that the caller's authentication lapsed. `is_unchanged` is whether the listing answered
+// 304 throughout (`IssueListOutcome`), recorded by `backlog:next` (joshuafolkken/kit#7306).
 type OptedInRead =
-	| { kind: 'read'; issues: Array<OpenIssueData>; cutoff: ScanCutoff }
+	| { kind: 'read'; issues: Array<OpenIssueData>; cutoff: ScanCutoff; is_unchanged?: boolean }
 	| { kind: 'unreadable' }
 	| { kind: 'unexpected_shape' }
 	| { kind: 'blockers_unreadable' }
@@ -205,7 +206,7 @@ async function classify_failed_read(): Promise<OptedInRead> {
 }
 
 async function fetch_opted_in(): Promise<OptedInRead> {
-	const { json, is_capped } = await git_gh_command.issue_list_by_label_summary(
+	const { json, is_capped, is_unchanged } = await git_gh_command.issue_list_by_label_summary(
 		AUTO_OK_LABEL,
 		LISTING_LIMIT,
 	)
@@ -218,7 +219,7 @@ async function fetch_opted_in(): Promise<OptedInRead> {
 
 	await issue_sample_prime.prime(issues.map((issue) => issue.body))
 
-	return { ...read, issues }
+	return { ...read, issues, is_unchanged: is_unchanged === true }
 }
 
 // Whether every issue this one declares as a blocker has closed. `blockedBy` is the same native
@@ -336,12 +337,16 @@ async function fetch_tracking(count: number): Promise<TrackingRead> {
 // `tracked` is the narrowed set `epic_index.withheld_children` builds, not
 // every tracked child; this function only applies it.
 // What the issue itself must hold: an author with write access (`auto-ok-author.ts`), every blocker
-// closed, and its declared start date reached.
-function is_ready(issue: OpenIssueData, now: number): boolean {
+// closed and its declared start date reached. Its size is the lane's to settle (joshuafolkken/kit#7074).
+interface RunnableOptions {
+	now?: number
+}
+
+function is_ready(issue: OpenIssueData, options: RunnableOptions): boolean {
 	return (
 		auto_ok_author.is_author_trusted(issue) &&
 		is_unblocked(issue) &&
-		issue_not_before.is_due(issue.body, now)
+		issue_not_before.is_due(issue.body, options.now ?? Date.now())
 	)
 }
 
@@ -349,19 +354,22 @@ function is_runnable(
 	issue: OpenIssueData,
 	tracked: ReadonlyMap<number, number>,
 	exclude: ReadonlyArray<number>,
-	now: number = Date.now(),
+	options: RunnableOptions = {},
 ): boolean {
 	if (tracked.has(issue.number)) return false
 
-	return !exclude.includes(issue.number) && is_ready(issue, now)
+	return !exclude.includes(issue.number) && is_ready(issue, options)
 }
 
 function pick_next(
 	issues: ReadonlyArray<OpenIssueData>,
 	tracked: ReadonlyMap<number, number> = new Map(),
 	exclude: ReadonlyArray<number> = [],
+	options: RunnableOptions = {},
 ): OpenIssueData | undefined {
-	return git_next_issues.order(issues).find((issue) => is_runnable(issue, tracked, exclude))
+	return git_next_issues
+		.order(issues)
+		.find((issue) => is_runnable(issue, tracked, exclude, options))
 }
 
 // Why there is nothing to run. "No open issue carries the label" and "every opted-in issue is
@@ -398,7 +406,7 @@ function warn_gaps(context: PickupContext, has_answer: boolean): void {
 
 // Grouped rather than passed one by one: the pickup now answers from two listings, and the
 // parameter limit is four.
-interface PickupContext {
+interface PickupContext extends RunnableOptions {
 	issues: ReadonlyArray<OpenIssueData>
 	cutoff: ScanCutoff
 	tracked: ReadonlyMap<number, number>
@@ -408,7 +416,7 @@ interface PickupContext {
 
 function report(context: PickupContext): number {
 	const { issues } = context
-	const next = pick_next(issues, context.tracked, context.exclude)
+	const next = pick_next(issues, context.tracked, context.exclude, context)
 
 	warn_gaps(context, next !== undefined)