@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/scripts/adopt/adopt-toolkits.ts

@@ -5,8 +5,7 @@ import { propagate_targets, type Manifest } from '#scripts/propagate/propagate-t
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { z } from 'zod'
 
-// Which `@joshuafolkken/*` toolkits `josh adopt` can upgrade in the repository it is run from
-// (joshuafolkken/kit#1085).
+// Which `@joshuafolkken/*` toolkits `josh adopt` can upgrade in the repository it is run from.
 //
 // Discovery is a filesystem fact rather than a roster written here: a hardcoded list would go stale
 // the day a fourth toolkit is published, and a project that depends on only one of them would be
@@ -112,7 +111,7 @@ function resolve_toolkit(project_root: string, package_name: string): Release |
 // package turns out to be. A package that is installed perfectly well and simply ships **no** CLI is
 // a scoped *library* rather than a toolkit: nothing about it is broken, so it is not this, and it is
 // not misplaced either. The `@joshuafolkken/` prefix alone cannot tell the two apart, which is why
-// the question is asked of the installed `bin` field (joshuafolkken/kit#1540 review round 1).
+// the question is asked of the installed `bin` field.
 function is_unreachable_toolkit(project_root: string, package_name: string): boolean {
 	const installed = read_installed_manifest(project_root, package_name)
 	if (installed === undefined) return true
@@ -153,8 +152,8 @@ function all_declared_toolkits(project_root: string): ReadonlyArray<string> {
 }
 
 // The other half of the same read: which declared packages the run cannot reach at all. Dropping
-// them silently is what let a partial install sync kit alone and revert the overlay tier
-// (joshuafolkken/kit#1540), so the caller refuses on this list rather than discovering it as a
+// them silently is what let a partial install sync kit alone and revert the overlay tier,
+// so the caller refuses on this list rather than discovering it as a
 // shorter plan. A scoped library that ships no CLI appears in neither list, because nothing about it
 // is broken.
 function unresolved_toolkits(project_root: string): ReadonlyArray<string> {

package/scripts/adopt/adopt.ts

@@ -9,8 +9,7 @@ import { adopt_logic } from './adopt-logic'
 import { adopt_toolkits } from './adopt-toolkits'
 
 // `josh adopt` — upgrade every `@joshuafolkken/*` toolkit installed in this repository to latest,
-// sync each one's managed files, run the verification gate, and open the issue and pull request
-// (joshuafolkken/kit#1085).
+// sync each one's managed files, run the verification gate, and open the issue and pull request.
 //
 // It is `josh propagate` seen from the other end: propagation stands in the supplier and pushes one
 // released version out to every consumer, adoption stands in the consumer and pulls whatever is
@@ -67,7 +66,7 @@ function run_sequence(target: PropagateTarget, plan: ReleasePlan | undefined): n
 }
 
 // A declared toolkit that cannot be carried stops the run, whichever of the two ways it fell out —
-// placed under `dependencies`, or declared with no runnable CLI here (joshuafolkken/kit#1540). The
+// placed under `dependencies`, or declared with no runnable CLI here. The
 // refusal names each one and its cause, so the exclusion is still reported as it was before; what
 // changed is that it no longer leaves the run to sync kit alone and revert the overlay tier.
 //

package/scripts/agent/agent-argv.ts

@@ -16,8 +16,8 @@ interface AgentArgv {
 type AgentArgvResult =
 	{ kind: 'argv'; argv: AgentArgv; profile: AgentProfile } | { kind: 'rejected'; note: string }
 
-// **`session_id` forces the fresh session's id, and only the Claude path can honour it**
-// (joshuafolkken/kit#2407). Codex has no such flag, and the run-state report reads Claude transcripts
+// **`session_id` forces the fresh session's id, and only the Claude path can honour it**.
+// Codex has no such flag, and the run-state report reads Claude transcripts
 // alone, so an OpenAI scheduler simply builds as before; whiff attribution is a Claude-transcript
 // property, so nothing is lost by the omission.
 function build(
@@ -31,7 +31,7 @@ function build(
 		: claude_agent_argv.build(invocation, profile, session_id, cwd)
 }
 
-// The resume counterpart of `build` (joshuafolkken/kit#2317). Only the Claude path resumes by session
+// The resume counterpart of `build`. Only the Claude path resumes by session
 // id; an OpenAI lane carries no such id at the outage re-dispatch, so it falls back to a fresh build —
 // which is never reached in practice, because `lane-resume.ts` only plans a resume for an Anthropic
 // provider. The fallback keeps this total rather than throwing on a provider it was not handed.
@@ -47,7 +47,7 @@ function build_resume(
 }
 
 // **`session_id` threads to the Claude build, so a wake launched in a lane's work tree still forces
-// its transcript id** (joshuafolkken/kit#2407). It is optional, so every other caller of the
+// its transcript id**. It is optional, so every other caller of the
 // cwd-scoped build is unchanged.
 function with_profile_in(
 	invocation: string,
@@ -62,7 +62,7 @@ function with_profile_in(
 }
 
 // A resume build under the same profile diagnostics as `with_profile_in`, so a lane re-dispatch that
-// resumes a session runs the identical readiness check a fresh one does (joshuafolkken/kit#2317).
+// resumes a session runs the identical readiness check a fresh one does.
 function with_resume_in(
 	invocation: string,
 	profile: AgentProfile,
@@ -92,8 +92,8 @@ function resolve(
 	return resolved.kind === 'rejected' ? resolved : with_profile(invocation, resolved.profile)
 }
 
-// **A cut relaunch's profile, resolved for the phase the resumed child is entering**
-// (joshuafolkken/kit#2382). A stored lane profile keeps its model and takes only the phase's effort; a
+// **A cut relaunch's profile, resolved for the phase the resumed child is entering**.
+// A stored lane profile keeps its model and takes only the phase's effort; a
 // lane without one resolves the worker for the phase. An env override wins over the phase in either path.
 function resume_argv(
 	invocation: string,

package/scripts/agent/agent-diagnostics.ts

@@ -30,7 +30,7 @@ const PROVIDER_CLI_TABLE: Readonly<Record<AgentProvider, ProviderCli>> = {
 	openai: { command: 'codex', name: 'Codex CLI', update: 'npm install -g @openai/codex@latest' },
 }
 
-// **The oldest CLI that can run each pinned model** (joshuafolkken/kit#2415). An older CLI either
+// **The oldest CLI that can run each pinned model**. An older CLI either
 // rejects the id after the lane has started or quietly runs something else, so the launch is refused
 // here instead. A model with no entry — a lane's recorded pre-migration model, or a person's override —
 // is not version-checked, so an existing lane resumes on the CLI it already ran on.
@@ -106,7 +106,7 @@ function check_auth(cli: ProviderCli, ports: DiagnosticPorts): DiagnosticResult
 }
 
 // The model is checked as it was resolved: a refusal names the update and stops, and nothing here
-// retries or swaps in another model (joshuafolkken/kit#2415).
+// retries or swaps in another model.
 function check(profile: AgentProfile, ports: DiagnosticPorts = default_ports): DiagnosticResult {
 	const cli = PROVIDER_CLI_TABLE[profile.provider]
 	const version = check_version(profile.model, cli, ports)

package/scripts/agent/agent-exit-record.ts

@@ -2,7 +2,7 @@ import { json_value } from '#scripts/lib/json-value'
 import { claude_result_event, type ClaudeResultEvent } from './claude-result-event'
 
 // The exit record of a dispatched lane child — the terminal `result` event a `claude -p` session
-// writes as the last line of its transcript (joshuafolkken/kit#2139). `run:ending` classifies how a
+// writes as the last line of its transcript. `run:ending` classifies how a
 // child ended from it, so this reads the *record*, not the liveness state `agent-event.ts` folds a
 // transcript into: `subtype`, `num_turns` and `permission_denials` are dropped by that fold, and they
 // are exactly what a park comment has to name.

package/scripts/agent/agent-headless.ts

@@ -1,5 +1,5 @@
 // The mark every agent session kit launches itself carries — a lane child, a ship reviewer, a woken
-// `run:wake` session (joshuafolkken/kit#3245).
+// `run:wake` session.
 //
 // **Those sessions run under `claude -p`, and nobody reads their replies.** Their output goes to a
 // stream-json log, and the only reader of the final text is the exit record's failure reason. So the

package/scripts/agent/agent-launch-environment.ts

@@ -4,6 +4,7 @@ import { gh_cli_token } from '#scripts/gh/gh-cli-token'
 import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
 import { agent_headless } from './agent-headless'
 import { agent_role_profile, type AgentProfile } from './agent-role-profile'
+import { agent_session_role } from './agent-session-role'
 import { codex_home_source } from './codex-home-source'
 
 const OPENAI_PROVIDER = 'openai'
@@ -60,7 +61,11 @@ function build(
 ): LaunchEnvironment {
 	if (profile === undefined) return environment
 
-	const marked = { ...agent_headless.environment(), ...environment }
+	const marked = {
+		...agent_headless.environment(),
+		...agent_session_role.env_for(profile.role),
+		...environment,
+	}
 	if (profile.provider !== OPENAI_PROVIDER) return marked
 
 	const base = { ...openai_environment(), ...marked }

package/scripts/agent/agent-role-profile.ts

@@ -10,7 +10,7 @@ const MAX_VALUE_LENGTH = 4096
 const ROLE_SCHEMA = z.enum(['scheduler', 'worker', 'reviewer'])
 const PROVIDER_SCHEMA = z.enum(['anthropic', 'openai'])
 const EFFORT_SCHEMA = z.enum(['low', 'medium', 'high', 'xhigh', 'max'])
-// The run phases effort may vary by (joshuafolkken/kit#2382). They are the cut boundaries a lane child
+// The run phases effort may vary by. They are the cut boundaries a lane child
 // resumes across — `run-cut.ts` imports these names for its own cut record, so the phase a run passes
 // and the phase this table is keyed on cannot drift. A phase-less call resolves the role default, which
 // is what keeps every existing caller unchanged.
@@ -31,7 +31,7 @@ type AgentEnvironment = Readonly<Record<string, string | undefined>>
 type ProfileResult = { kind: 'profile'; profile: AgentProfile } | { kind: 'rejected'; note: string }
 type Rejected = Extract<ProfileResult, { kind: 'rejected' }>
 type EffortResult = Rejected | { kind: 'effort'; effort: AgentEffort }
-type ProviderResult = Rejected | { kind: 'provider'; provider: AgentProvider }
+type ProviderResult = Rejected | { kind: 'provider'; provider: AgentProvider; is_default?: true }
 
 const SCHEDULER: AgentRole = 'scheduler'
 const WORKER: AgentRole = 'worker'
@@ -40,7 +40,7 @@ const IMPLEMENTATION_PHASE: AgentPhase = 'implementation'
 const PRE_GATE_PHASE: AgentPhase = 'pre-gate'
 const ANTHROPIC_PROVIDER: AgentProvider = 'anthropic'
 const OPENAI_PROVIDER: AgentProvider = 'openai'
-// **Pinned model ids, never a floating alias** (joshuafolkken/kit#2415). An alias such as `opus` moves
+// **Pinned model ids, never a floating alias**. An alias such as `opus` moves
 // whenever the CLI moves it, so a run log could not say which model produced it and a model migration
 // could not be measured apart from everything else. A new lane records the id it resolved; a lane
 // created before a migration keeps the model it recorded (`with_phase_effort` leaves it untouched).
@@ -72,7 +72,7 @@ const OPENAI_PROFILES: Readonly<Record<AgentRole, AgentProfile>> = {
 
 const PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES }
 
-// **Effort as a function of the run phase, not the role alone** (joshuafolkken/kit#2382). For the first
+// **Effort as a function of the run phase, not the role alone**. For the first
 // merge only the mechanical ship/bookkeeping region is lowered: the pre-gate resume drives the gate,
 // commit, PR and merge, applying fixes the gate has already named — work delegation.md calls the opposite
 // of judgement. The design-judgment implementation phases keep the role default, as does any role/phase
@@ -162,24 +162,32 @@ function has_session(environment: AgentEnvironment, keys: ReadonlyArray<string>)
 	return keys.some((key) => trimmed(environment[key]) !== undefined)
 }
 
-function session_rejection(is_conflicting: boolean): Rejected {
-	const note = is_conflicting
-		? 'both Codex and Claude Code sessions were detected'
-		: 'no Codex or Claude Code session was detected'
-
-	return { kind: 'rejected', note }
+const CONFLICTING_SESSIONS: Rejected = {
+	kind: 'rejected',
+	note: 'both Codex and Claude Code sessions were detected',
 }
 
-// The provider a detached launcher hands a process that is not itself an agent session
-// (joshuafolkken/kit#2456). `detached_launch` strips the parent-session keys — the very keys the
+// The provider a detached launcher hands a process that is not itself an agent session.
+// `detached_launch` strips the parent-session keys — the very keys the
 // detection below reads — so a `josh ship --detach --review` supervisor could never resolve its reviewer.
 // **It is a fallback, read only when no session is detected**: the mark is inherited by everything the
 // supervisor starts, and a real session's own keys must keep deciding for that session.
 const HANDED_PROVIDER_KEY = 'JOSH_AGENT_PROVIDER'
 
+// **Nothing named a provider, so Claude Code is the default** — a person typing `josh lane:launch` in a
+// plain terminal has no session and no mark. Only silence defaults: two detected sessions and a mark
+// naming no allowed provider still refuse. `is_default` lets a launch say so, and lets `josh cost` keep
+// reading "no session of its own" rather than pricing another session's transcript.
+const DEFAULT_PROVIDER: ProviderResult = {
+	kind: 'provider',
+	provider: ANTHROPIC_PROVIDER,
+	is_default: true,
+}
+const DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`
+
 function handed_provider(environment: AgentEnvironment): ProviderResult {
 	const value = trimmed(environment[HANDED_PROVIDER_KEY])
-	if (value === undefined) return session_rejection(false)
+	if (value === undefined) return DEFAULT_PROVIDER
 	const parsed = PROVIDER_SCHEMA.safeParse(value)
 
 	return parsed.success
@@ -192,7 +200,7 @@ function detected_provider(environment: AgentEnvironment): ProviderResult | unde
 	const has_codex = has_session(environment, [CODEX_SESSION_KEY])
 	const has_claude = has_session(environment, agent_session_environment.PARENT_SESSION_KEYS)
 
-	if (has_codex === has_claude) return has_codex ? session_rejection(true) : undefined
+	if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : undefined
 
 	return { kind: 'provider', provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER }
 }
@@ -201,18 +209,34 @@ function resolve_provider(environment: AgentEnvironment = process.env): Provider
 	return detected_provider(environment) ?? handed_provider(environment)
 }
 
-// Whether this session is woken when a background command it started completes
-// (joshuafolkken/kit#2653). Claude Code re-invokes the session at the completion; a Codex session is not
+// The sentence a launch appends when it ran on the default, so falling back is never silent; empty when
+// a session or a mark decided.
+function default_notice(environment: AgentEnvironment = process.env): string {
+	const selected = resolve_provider(environment)
+
+	return selected.kind === 'provider' && selected.is_default === true ? DEFAULT_NOTICE : ''
+}
+
+// The same sentence on stderr, for a launcher whose own line is a verdict or a brief another process
+// reads: `run:wake --start`, `review:brief` and `ship --detach` default exactly as a dispatch does.
+function warn_of_default(environment: AgentEnvironment = process.env): void {
+	const notice = default_notice(environment).trim()
+
+	if (notice !== '') console.error(notice)
+}
+
+// Whether this session is woken when a background command it started completes.
+// Claude Code re-invokes the session at the completion; a Codex session is not
 // re-invoked, so a parent there can only wait by polling, each poll a model call over its whole context.
-// Only a resolved Codex session answers no — an unresolved one keeps the behavior it had before.
+// Only a resolved Codex session answers no — a defaulted or conflicting one keeps the callback.
 function has_completion_callback(environment: AgentEnvironment = process.env): boolean {
 	const selected = resolve_provider(environment)
 
 	return selected.kind !== 'provider' || selected.provider !== OPENAI_PROVIDER
 }
 
-// The mark a detached launch sets on its child: the provider this session resolved, or nothing when it
-// resolved none — the child then fails the same way this session would have.
+// The mark a detached launch sets on its child: the provider this session resolved, the default
+// included, or nothing when it was refused — the child then fails the same way this session would have.
 function handoff_environment(
 	environment: AgentEnvironment = process.env,
 ): Readonly<Record<string, string>> {
@@ -230,7 +254,7 @@ function validate(profile: AgentProfile, model_key: string): ProfileResult {
 }
 
 // The effort a phase resolves to before any env override: the phase's own value where the table names
-// one, otherwise the fallback (joshuafolkken/kit#2382). A phase-less or unrecognized call returns the
+// one, otherwise the fallback. A phase-less or unrecognized call returns the
 // fallback unchanged, which is what keeps every existing caller reading the current default.
 function phase_effort(
 	role: AgentRole,
@@ -244,7 +268,7 @@ function phase_effort(
 }
 
 // The effort a stored profile takes in a phase: an env override wins, then the phase value, then the
-// profile's own effort (joshuafolkken/kit#2382). A cut relaunch that keeps a lane's stored model resolves
+// profile's own effort. A cut relaunch that keeps a lane's stored model resolves
 // the effort through this so a person's `JOSH_WORKER_EFFORT` is never overwritten by the phase value.
 function overridden_effort(
 	profile: AgentProfile,
@@ -257,7 +281,7 @@ function overridden_effort(
 }
 
 // A stored profile with its effort resolved for the phase the run is entering, its model and provider
-// left as they were (joshuafolkken/kit#2382).
+// left as they were.
 function with_phase_effort(
 	profile: AgentProfile,
 	phase: string,
@@ -301,6 +325,7 @@ function parse(value: unknown): AgentProfile | undefined {
 }
 
 const agent_role_profile = {
+	CODEX_SESSION_KEY,
 	DEFAULT_PROFILES,
 	HANDED_PROVIDER_KEY,
 	IMPLEMENTATION_PHASE,
@@ -311,6 +336,7 @@ const agent_role_profile = {
 	REVIEWER,
 	SCHEDULER,
 	WORKER,
+	default_notice,
 	describe,
 	handoff_environment,
 	has_completion_callback,
@@ -318,6 +344,7 @@ const agent_role_profile = {
 	parse,
 	resolve,
 	resolve_provider,
+	warn_of_default,
 	with_phase_effort,
 }
 

package/scripts/agent/agent-session-role.ts

@@ -0,0 +1,32 @@
+import { agent_role_profile, type AgentRole } from './agent-role-profile'
+
+// The role an agent session kit launched was launched in — the fact that tells a ship reviewer apart
+// from the implementing child whose checkout it reads.
+//
+// **A reviewer inherits everything else its launcher carries.** The ship supervisor is started by a
+// lane child, so the reviewer it launches in the same checkout carries that child's `JOSH_LANE_CHILD`
+// mark and its run hold, and nothing in the environment said "this session reviews, it does not
+// implement". The context cuts read it as the implementing child, refused its findings `Write`, and the
+// cut it then took relaunched a second child beside the supervisor's own repair
+// (joshuafolkken/kit#3623). A reviewer is a one-shot session its supervisor is waiting on, so there is
+// no process to hand its work to.
+//
+// **It is set at the one place agent sessions are launched, and on every one of them.** Like
+// `agent_headless`, it is composed in `agent_launch_environment.build`; because every profiled launch
+// writes its own role, a value inherited from a launcher is always overwritten and a reviewer's mark
+// cannot leak into a worker it did not start.
+const KEY = 'JOSH_AGENT_ROLE'
+
+type EnvironmentSource = Readonly<Record<string, string | undefined>>
+
+function environment_for(role: AgentRole): Record<string, string> {
+	return { [KEY]: role }
+}
+
+function is_reviewer(source: EnvironmentSource = process.env): boolean {
+	return source[KEY] === agent_role_profile.REVIEWER
+}
+
+const agent_session_role = { KEY, env_for: environment_for, is_reviewer }
+
+export { agent_session_role }

package/scripts/agent/api-outage.ts

@@ -1,7 +1,7 @@
 import type { ClaudeResultEvent } from './claude-result-event'
 
 // Whether a dispatched lane child's exit record is an API-connection outage rather than a child that
-// stopped mid-implementation on its own (joshuafolkken/kit#2240). Measured twice: on 2026-09-15 four
+// stopped mid-implementation on its own. Measured twice: on 2026-09-15 four
 // children ended `The socket connection was closed unexpectedly`, and on 2026-09-21 a child spent all
 // ten connection retries on `Unable to connect to API (ConnectionRefused)`. The parent read both as
 // ordinary failures — `in-progress` stripped, `needs-decision` applied, counted against the

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

@@ -11,16 +11,16 @@ const AGENT_COMMAND = 'claude'
 const AGENT_FLAGS: ReadonlyArray<string> = ['-p', '--verbose', '--output-format', 'stream-json']
 const MODEL_FLAG = '--model'
 const EFFORT_FLAG = '--effort'
-// Resumes a stored session by id (joshuafolkken/kit#2317). An `outage` re-dispatch passes the
+// Resumes a stored session by id. An `outage` re-dispatch passes the
 // disconnected child's `session_id` so the relaunched process continues that conversation — its
 // accumulated context intact — rather than reading everything from scratch.
 const RESUME_FLAG = '--resume'
-// Forces a fresh session's id rather than resuming one (joshuafolkken/kit#2407). The wake supervisor
+// Forces a fresh session's id rather than resuming one. The wake supervisor
 // generates the id, so it knows without asking the child which transcript that session will write —
 // `<session-id>.jsonl` — and can later attribute a whiff to a session it actually started rather than
 // to any transcript that happened to move while it was alive.
 const SESSION_ID_FLAG = '--session-id'
-// **A launched child carries only the tools a lane has ever used** (joshuafolkken/kit#2435). Every
+// **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
@@ -97,7 +97,7 @@ function build(
 }
 
 // The resume counterpart: the same vector with `--resume <session_id>` ahead of the model flags, so the
-// relaunched child continues the stored session rather than opening a new one (joshuafolkken/kit#2317).
+// relaunched child continues the stored session rather than opening a new one.
 function build_resume(
 	invocation: string,
 	profile: AgentProfile,

package/scripts/agent/claude-result-event.ts

@@ -19,21 +19,21 @@ const USAGE_SCHEMA = z.looseObject({
 
 interface ClaudeResultEvent {
 	is_error: boolean
-	// The exit-record fields a supervisor classifies a dispatched lane child's ending from
-	// (joshuafolkken/kit#2139). `subtype` and `num_turns` describe how the turn ended, and
+	// The exit-record fields a supervisor classifies a dispatched lane child's ending from.
+	// `subtype` and `num_turns` describe how the turn ended, and
 	// `permission_denials` is the count of tool calls the harness refused — the direct cause of a child
 	// that stopped mid-implementation without parking, so a classifier can name it in the park comment.
 	subtype: string | undefined
 	num_turns: number | undefined
 	permission_denials: number
-	// The refused interactive ask lifted out of `permission_denials` (joshuafolkken/kit#2201). Where a
+	// The refused interactive ask lifted out of `permission_denials`. Where a
 	// child reached for `AskUserQuestion` and was refused, its question and options are stranded in the
 	// exit record; `run:ending` puts them into the park comment so a person can answer, instead of the
 	// parent opening the JSONL by hand. Undefined when no denial was an interactive ask.
 	refused_ask: string | undefined
 	reason: string | undefined
 	// The Claude Code session identifier the `-p --output-format stream-json` run wrote on its result
-	// event (joshuafolkken/kit#2317). An `outage` re-dispatch reads it to resume the disconnected child's
+	// event. An `outage` re-dispatch reads it to resume the disconnected child's
 	// stored session — recovering its accumulated context — rather than starting a fresh `fullrun`.
 	// Undefined when the event carried none, which sends the re-dispatch down the fresh fallback.
 	session_id: string | undefined

package/scripts/agent/codex-hooks.ts

@@ -1,7 +1,7 @@
 import { hook_launch } from '#scripts/init/hook-launch'
 
-// `.codex/hooks.json` is derived from `.claude/settings.json`, never written by hand
-// (joshuafolkken/kit#2997). The hand copy carried every hook command twice, so a change to one side
+// `.codex/hooks.json` is derived from `.claude/settings.json`, never written by hand.
+// The hand copy carried every hook command twice, so a change to one side
 // left the other silently stale. Codex differs from Claude Code in three places only, and each is a
 // rule applied here rather than a line maintained in the copy:
 //

package/scripts/agent/interactive-ask.ts

@@ -1,13 +1,10 @@
 import { z } from 'zod'
 
-// The tools a session uses to ask a person, and how to lift a refused ask out of an exit record
-// (joshuafolkken/kit#2201).
+// The tools a session uses to ask a person, and how to lift a refused ask out of an exit record.
 //
 // **A dispatched lane child cannot ask a person.** It is a headless `claude -p` process, so an
-// interactive ask is refused — and with nowhere to route it the turn ends with nothing on the Issue,
-// the gap joshuafolkken/kit#2034 measured. Two consumers share the one notion of "an interactive ask":
-// the
-// `PreToolUse` rule that refuses it in a lane child (`scripts/rules/lane-interactive-ask.ts`), and
+// interactive ask is refused — and with nowhere to route it the turn ends with nothing on the Issue.
+// Two consumers share the one notion of "an interactive ask": the `PreToolUse` rule that refuses it in a lane child (`scripts/rules/lane-interactive-ask.ts`), and
 // `run:ending`, which reads the refused ask back out of the child's exit record so the parent can put
 // the question and its options into the park comment. Both read `INTERACTIVE_TOOLS`, so the set lives
 // here rather than in either.