@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/scripts/lane/lane-child-marker.ts

@@ -1,15 +1,15 @@
-import { run_issue_number } from '#scripts/run/run-issue-number'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { lane_paths } from './lane-paths'
 
 // The mark a dispatched lane child carries, so the pre-gate cut and a resume are decided from the
-// environment rather than from the model's reading of the prompt (joshuafolkken/kit#1904).
+// environment rather than from the model's reading of the prompt.
 //
-// **A dispatched child used to be indistinguishable from a person's own session.** `lane:dispatch`
-// and the `run:cut` relaunch both start the child with `claude -p "fullrun #<N>"` and a copied
-// environment, and nothing in the argv, the environment or a file said "this session was launched, not
-// typed". So `pre-gate-cut.ts` left the human-or-child question to the model, which read its own prompt
-// and — across the six children joshuafolkken/kit#1850 measured — decided "person" every time and
-// declined the cut. This variable is that missing fact, made mechanical.
+// **Without this mark a dispatched child is indistinguishable from a person's own session.**
+// `lane:dispatch` and the `run:cut` relaunch both start the child with `claude -p "fullrun #<N>"` and
+// a copied environment, and nothing in the argv, the environment or a file says "this session was
+// launched, not typed". Left to the model, the human-or-child question is answered by reading its own
+// prompt, which decides "person" and declines the cut. This variable is that missing fact, made
+// mechanical.
 //
 // **Its value is the issue number, because a mark that only said "a child" could not be told from one
 // that leaked.** A person's shell, or a parent session that was itself a dispatched child, can carry
@@ -19,7 +19,7 @@ import { lane_paths } from './lane-paths'
 // `.claude/skills/workflow-commands/pre-gate-cut.md`.
 const KEY = 'JOSH_LANE_CHILD'
 
-// **A dispatched child also asks for the five-minute prompt-cache TTL** (joshuafolkken/kit#2944). A
+// **A dispatched child also asks for the five-minute prompt-cache TTL**. A
 // headless `claude -p` session on a subscription defaults to the one-hour TTL, whose writes bill at 2x
 // the input rate against 1.25x for five minutes. A replay of 1,953 lane transcripts (about 57,000
 // requests) found 0.3% of request gaps over five minutes, so the shorter TTL — re-writing the prefix on
@@ -34,7 +34,7 @@ type MarkerSource = Readonly<Record<string, string | undefined>>
 // issue number rather than from text read anywhere — the same discipline `lane-dispatch.ts` applies to
 // the invocation it builds — so a malformed number fails here rather than reaching a child.
 function environment_for(issue: string): Record<string, string> {
-	run_issue_number.require_issue_number(issue)
+	issue_number_shape.require_issue_number(issue)
 
 	return { [KEY]: issue, [CACHE_TTL_KEY]: CACHE_TTL }
 }
@@ -47,14 +47,14 @@ function marked_issue(source: MarkerSource = process.env): string | undefined {
 
 	if (value === undefined) return undefined
 
-	return run_issue_number.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
+	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
 }
 
 // True when this session is a dispatched lane child for the checkout it is running in: the mark is
 // present and names this lane's own issue, read from the checkout path. A numeric mark naming a
 // *different* issue leaked in from a parent session into a checkout it does not belong to, so it is
 // read as a person's run — the trust condition the header describes, applied the same way
-// `pre-gate-cut.ts` applies it to the resume decision (joshuafolkken/kit#1947).
+// `pre-gate-cut.ts` applies it to the resume decision.
 function is_child_of(directory: string, source: MarkerSource = process.env): boolean {
 	const marked = marked_issue(source)
 

package/scripts/lane/lane-cli.ts

@@ -4,6 +4,8 @@ import { epic_busy } from '#scripts/epic/epic-busy'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
 import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
 import { error_text } from '#scripts/lib/error-message'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_carry_reclaim } from '#scripts/run/carry/run-carry-reclaim'
@@ -18,8 +20,7 @@ import { lane_report } from './lane-report'
 import { lane_seed_policy } from './lane-seed'
 import { lane_stray } from './lane-stray'
 
-// `josh lane:open` / `lane:close` / `lane:list` / `lane:prune` — the lane's whole lifecycle
-// (joshuafolkken/kit#1490).
+// `josh lane:open` / `lane:close` / `lane:list` / `lane:prune` — the lane's whole lifecycle.
 //
 // **`lane:open` prints the lane's directory on standard output and nothing else**, so
 // `dir=$(pnpm josh lane:open 1490)` is what a caller needs and a refusal is an empty capture beside
@@ -33,7 +34,6 @@ const SINGLE_ARGUMENT = 1
 const ISSUE_AND_PATH_ARGUMENTS = 2
 const ALL_FLAG = '--all'
 const NONE_TOKEN = 'none'
-const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
 
 const USAGE = [
 	'Usage: josh lane:open <issue-number>',
@@ -54,8 +54,7 @@ function report_usage(): number {
 }
 
 // Read the carry record and refuse if this session has already handed off its budget via `--cut`.
-// A cut session must not open new lanes or dispatch new children — the successor owns the budget
-// (joshuafolkken/kit#2114).
+// A cut session must not open new lanes or dispatch new children — the successor owns the budget.
 async function guard_cut_session(): Promise<string | undefined> {
 	const directory = await run_carry.repository_directory()
 
@@ -73,7 +72,7 @@ async function guard_cut_session(): Promise<string | undefined> {
 function parse_lane_issue(value: string | undefined): string | undefined {
 	if (value === undefined) return undefined
 
-	return ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
+	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
 }
 
 function parse_issue(rest: ReadonlyArray<string>): string | undefined {
@@ -89,7 +88,7 @@ function refusal_message(outcome: Exclude<OpenOutcome, { kind: 'opened' }>): str
 		return `All ${String(lane_seed_policy.LAST_LANE_SEAT)} lane seats are taken. Run \`pnpm josh lane:list\` to see them and \`pnpm josh lane:close <issue-number>\` to free one.`
 	}
 
-	return `A lane for #${outcome.lane.issue} is already open at ${outcome.lane.directory}. Run \`pnpm josh lane:close ${outcome.lane.issue}\` before opening it again.`
+	return `A lane for ${session_cite.issue(outcome.lane.issue)} is already open at ${outcome.lane.directory}. Run \`pnpm josh lane:close ${outcome.lane.issue}\` before opening it again.`
 }
 
 function report_open(outcome: OpenOutcome): number {
@@ -119,7 +118,7 @@ function report_issues(issues: ReadonlyArray<string>): number {
 function report_close(outcome: CloseOutcome): number {
 	if (outcome.reaped.length > 0) {
 		console.error(
-			`Terminated the lane child for #${outcome.issue} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
+			`Terminated the lane child for ${session_cite.issue(outcome.issue)} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
 		)
 	}
 
@@ -128,7 +127,7 @@ function report_close(outcome: CloseOutcome): number {
 	}
 
 	console.error(
-		`Closing the lane for #${outcome.issue} left this behind: ${outcome.left_behind.join(', ')}. Remove it and run \`pnpm josh lane:close ${outcome.issue}\` again.`,
+		`Closing the lane for ${session_cite.issue(outcome.issue)} left this behind: ${outcome.left_behind.join(', ')}. Remove it and run \`pnpm josh lane:close ${outcome.issue}\` again.`,
 	)
 
 	return FAILURE_EXIT_CODE
@@ -141,7 +140,7 @@ function report_sweep(outcome: SweepOutcome): number {
 
 	if (outcome.failed.length === 0) return code
 
-	const named = outcome.failed.map((issue) => `#${issue}`).join(', ')
+	const named = outcome.failed.map((issue) => session_cite.issue(issue)).join(', ')
 
 	// `lane:list` reads git's work trees, and the usual survivor is a branch whose work tree is
 	// already gone — which that listing cannot show. Closing each one again is what names it.
@@ -194,7 +193,7 @@ const OCCUPANCY_UNREADABLE =
 	'Could not read the `in-progress` listing, so the lane/label difference was not checked — that is not "everything agrees"; check `gh auth status`.'
 
 // The `in-progress` issues this repository shows running, read the way `epic:next` reads lane
-// occupancy — never rebuilt (joshuafolkken/kit#2235). A read that could not see the whole listing is
+// occupancy — never rebuilt. A read that could not see the whole listing is
 // `undefined`, so the difference is skipped rather than computed against a set known to be partial.
 async function to_holders(repo: string): Promise<ReadonlyArray<OpenIssueData> | undefined> {
 	const read = await epic_busy.read_repository(repo)
@@ -204,7 +203,7 @@ async function to_holders(repo: string): Promise<ReadonlyArray<OpenIssueData> |
 }
 
 // The repository and its running issues, read once: the listing cites each lane from the titles here
-// (joshuafolkken/kit#2943) and the occupancy check compares against the same set.
+// and the occupancy check compares against the same set.
 interface InProgress {
 	repo: string | undefined
 	holders: ReadonlyArray<OpenIssueData> | undefined
@@ -273,7 +272,7 @@ async function prune_command(rest: ReadonlyArray<string>): Promise<number> {
 
 	// After the closes, so a lane whose close left its directory behind is swept in the same run. A
 	// kept stray is reported, never a failure: it waits on a person, and a non-zero exit would stop
-	// every `backlogrun` preparation until one came (joshuafolkken/kit#3370).
+	// every `backlogrun` preparation until one came.
 	await lane_stray.sweep_and_report()
 
 	return code

package/scripts/lane/lane-close.ts

@@ -6,7 +6,7 @@ import { lane_paths } from './lane-paths'
 import { lane_reap } from './lane-reap'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
-// Closing a lane: no work tree, no branch, no directory (joshuafolkken/kit#1490).
+// Closing a lane: no work tree, no branch, no directory.
 //
 // **A lane is closed after a park, a failure or an interruption as readily as after a success**, so
 // every step here is written to run over a subject that is already gone or that still holds
@@ -21,7 +21,7 @@ interface LaneTargets {
 
 // The lane an issue number names: its registration, when there is one, and the paths a close acts on.
 // Resolved once here so a caller that has to look inside the tree before closing it reads the same
-// directory the close removes (joshuafolkken/kit#2476).
+// directory the close removes.
 interface ResolvedLane {
 	existing: LaneInfo | undefined
 	targets: LaneTargets
@@ -107,8 +107,8 @@ function close_kind(did_exist: boolean, left_behind: ReadonlyArray<string>): Clo
 }
 
 // The main work tree's root, not this one's — the same reading `list_lanes` uses, so the fallback
-// directory an unregistered lane is closed by is the one `lane:open` would have created
-// (joshuafolkken/kit#1497). Derived here from the current work tree, a close run inside a lane
+// directory an unregistered lane is closed by is the one `lane:open` would have created.
+// Derived here from the current work tree, a close run inside a lane
 // reports `none` over a directory that is still on disk.
 async function lane_root_directory(): Promise<string> {
 	return lane_paths.lane_root(await lane_registry.main_repository_root())
@@ -130,8 +130,8 @@ async function close_lane(issue: string): Promise<CloseOutcome> {
 	const { existing, targets } = await resolve_lane(issue)
 	const did_exist = existing !== undefined || existsSync(targets.directory)
 	// Before the removal, not after: a child still running in the tree would keep writing into a
-	// directory being deleted, and a process outliving its lane is the half-discarded state
-	// joshuafolkken/kit#2421 found — the work tree gone, the child still answering `alive`.
+	// directory being deleted, and a process outliving its lane is a half-discarded state — the work
+	// tree gone, the child still answering `alive`.
 	const reaped = lane_reap.reap_child(issue)
 
 	await remove_lane(targets)

package/scripts/lane/lane-dispatch.ts

@@ -2,45 +2,44 @@ import { agent_argv, type AgentArgv, type AgentArgvResult } from '#scripts/agent
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import type { LabelWrite } from '#scripts/gh/git-gh-issue-write'
+import { issue_cite } from '#scripts/issue/issue-cite'
 import { IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
 import { telegram_notify } from '#scripts/notify/telegram-notify'
 import { detached_launch } from '#scripts/run/detached-launch'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_ending } from '#scripts/run/run-ending'
-import { run_issue_number } from '#scripts/run/run-issue-number'
+import { run_label } from '#scripts/run/run-label'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_child_marker } from './lane-child-marker'
 import { lane_dispatch_log } from './lane-dispatch-log'
+import { lane_ledger } from './lane-ledger'
 import { lane_output } from './lane-output'
 import { lane_registry, type LaneInfo } from './lane-registry'
 import { lane_resume, type ResumePlan } from './lane-resume'
 import { openai_lane_supervisor } from './openai-lane-supervisor'
 
-// `josh lane:dispatch <issue-number>` — start a lane's child as an operating-system process of its own
-// (joshuafolkken/kit#1749).
+// `josh lane:dispatch <issue-number>` — start a lane's child as an operating-system process of its own.
 //
-// **The premise the session cut rests on was not true, and this is what makes it true.** A delegated
-// child used to be an in-process subagent of the parent session, so cutting the parent killed every
-// child still implementing: `backlogrun-progress.md` → "The hand-off" says "nothing has to finish, because nothing
-// is being abandoned", and what actually happened was that the next session polled a file whose writer
-// was dead, waited out the silent-unit window, booked each lane `stopped`, and aborted the whole run on
-// the third one. Launched detached, the child survives the cut and the sentence holds as written.
+// **This is what makes the premise the session cut rests on true.** `backlogrun-progress.md` → "The
+// hand-off" says "nothing has to finish, because nothing is being abandoned"; an in-process child
+// would die with the parent it was cut from. Launched detached, the child survives the cut and the
+// sentence holds as written.
 //
 // **Nothing here is new machinery.** The lane is already a linked work tree with its own branch and
 // ports (`lane-open.ts`), the detached launcher is already `run:wake`'s (`detached-launch.ts`), and the
 // recorded output path is already how a session that never opened a lane polls it (`lane-output.ts`).
-// What was missing was the one command that puts the three together.
+// This is the one command that puts the three together.
 //
-// **The recording happens inside the dispatch, so "the lane records no path" stops being a state.**
-// `backlogrun.md`'s hand-off has an exception for a lane nobody could poll, and it exists because the
-// recording used to be a separate step a run could forget. A lane dispatched through here is recorded
-// by the same call that starts it.
+// **The recording happens inside the dispatch, so "the lane records no path" is not a state.** A
+// lane dispatched through here is recorded by the same call that starts it, so no run can forget it.
 
 // The invocation the child is given. Composed from this constant and a digits-only issue number, never
 // from text that was read from anywhere — the same discipline `run-wake-session.ts` applies to the
 // invocation it rebuilds out of the carry record.
-// The resume guide a relaunched child is pointed at (joshuafolkken/kit#2022). It carries the resume
+// The resume guide a relaunched child is pointed at. It carries the resume
 // procedure a `run:cut` successor follows, so naming it lets the child read one section rather than the
 // workflow-commands entry documents it would otherwise read to learn it is a resume at all.
 const NOTE_SEPARATOR = '; '
@@ -60,7 +59,7 @@ interface Dispatched {
 	log_path: string
 	pid: number
 	profile: AgentProfile
-	// The session id this dispatch resumed, or `undefined` when it started fresh (joshuafolkken/kit#2317).
+	// The session id this dispatch resumed, or `undefined` when it started fresh.
 	// `describe` reports which path was taken, so an `outage` re-dispatch says whether it recovered the
 	// disconnected child's context or fell back to a fresh run.
 	resumed_from: string | undefined
@@ -110,14 +109,13 @@ function child_invocation(issue: string): string {
 
 /**
  * The prompt a relaunched child is given after a `run:cut` — a resume-specific instruction followed by
- * the bare `child_invocation` (joshuafolkken/kit#2022). A relaunched child used to be given the plain
- * `fullrun #<N>`, so it read the workflow-commands entry documents (SKILL.md, fullrun.md, ~29k tokens)
- * every resume before it could learn it was a resume at all — the "do not re-read" exception lives
- * inside the very skill it had to open. This preamble tells it up front, so it goes straight to
- * `run:cut --resume` and the stage that answers.
+ * the bare `child_invocation`. Given the plain `fullrun #<N>`, a relaunched child would read the
+ * workflow-commands entry documents every resume before it could learn it was a resume at all — the
+ * "do not re-read" exception lives inside the very skill it would have to open. This preamble tells
+ * it up front, so it goes straight to `run:cut --resume` and the stage that answers.
  *
  * **It ends with `child_invocation` on purpose, not as decoration.** The parent's liveness poll is
- * `pgrep -laf "<child_invocation>$"` (built at dispatch — see `log_sentence`), so a relaunched process
+ * `lane_child_invocation.process_pattern` (read by `run:liveness` — see `log_sentence`), so a relaunched process
  * whose command line did not end with `fullrun #<N>` would be booked stopped while it ran. The trailing
  * invocation keeps that poll matching and is also the ordinary run a `fresh` verdict falls back to.
  */
@@ -171,7 +169,7 @@ function failed_start(
 
 // The `dispatched` outcome, built from the request the launch was composed from — one place so the
 // three launch paths cannot drift on which fields a dispatched child carries (the resume flag among
-// them, joshuafolkken/kit#2317). The request's `argv` rides along harmlessly, as it did before.
+// them). The request's `argv` rides along harmlessly.
 // **`kind` is written last on purpose**: the request was spread from a `Prepared`, so it still carries
 // `kind: 'prepared'` at runtime, and letting the spread win would mislabel the outcome.
 function dispatched_of(
@@ -190,7 +188,7 @@ function existing_dispatch(request: StartRequest): DispatchOutcome | undefined {
 	if (!openai_lane_supervisor.approve(request.lane.directory, active.nonce)) {
 		return failed_start(
 			request,
-			`the OpenAI supervisor for lane #${request.lane.issue} was cancelled`,
+			`the OpenAI supervisor for lane ${session_cite.issue(request.lane.issue)} was cancelled`,
 			[],
 		)
 	}
@@ -216,13 +214,17 @@ async function openai_dispatched_start(
 	if (owner?.issue !== lane.issue) {
 		if (nonce !== undefined) openai_lane_supervisor.cancel(lane.directory, nonce)
 
-		return failed_start(request, `the OpenAI supervisor did not claim lane #${lane.issue}`, notes)
+		return failed_start(
+			request,
+			`the OpenAI supervisor did not claim lane ${session_cite.issue(lane.issue)}`,
+			notes,
+		)
 	}
 
 	if (!openai_lane_supervisor.approve(lane.directory, owner.nonce)) {
 		return failed_start(
 			request,
-			`the OpenAI supervisor for lane #${lane.issue} was cancelled`,
+			`the OpenAI supervisor for lane ${session_cite.issue(lane.issue)} was cancelled`,
 			notes,
 		)
 	}
@@ -267,7 +269,7 @@ async function started(request: StartRequest): Promise<DispatchOutcome> {
 
 // Build the argv the plan calls for: a resume carries the stored session id, a fresh start does not.
 // Both run the same profile diagnostics under the already-resolved profile, so a resume is refused for
-// exactly the reasons a fresh dispatch is (joshuafolkken/kit#2317).
+// exactly the reasons a fresh dispatch is.
 function built_for(plan: ResumePlan, profile: AgentProfile, lane: LaneInfo): AgentArgvResult {
 	if (plan.kind === 'resume') {
 		return agent_argv.with_resume_in(plan.invocation, profile, plan.session_id, lane.directory)
@@ -276,7 +278,7 @@ function built_for(plan: ResumePlan, profile: AgentProfile, lane: LaneInfo): Age
 	return agent_argv.with_profile_in(plan.invocation, profile, lane.directory)
 }
 
-// **The re-dispatch decides resume-or-fresh from the lane's own exit record** (joshuafolkken/kit#2317).
+// **The re-dispatch decides resume-or-fresh from the lane's own exit record**.
 // The record is read from the log the previous dispatch of this lane wrote — a first dispatch finds
 // none and starts fresh, an `outage` ending with a session id resumes it. The provider is resolved
 // first because the resume mechanism is Claude Code's, and an OpenAI lane falls back to fresh.
@@ -304,30 +306,33 @@ function prepared(lane: LaneInfo): Prepared {
 // **The parent claims the marker before it starts the child**, so the window in which a running child
 // is uncounted closes at dispatch rather than tens of minutes later once the child's own `fullrun` gets
 // to its (idempotent) apply. `issue_add_label` creates the label if the repository lacks it — a
-// `POST /issues/{N}/labels` provisions a missing label with a generated color (measured on
-// joshuafolkken/kit#1026, `git-gh-issue-write.ts`) — so no separate `label_ensure` is needed here, and
+// `POST /issues/{N}/labels` provisions a missing label with a generated color
+// (`git-gh-issue-write.ts`) — so no separate `label_ensure` is needed here, and
 // its unapplied answer is a real refusal to launch rather than a note — confirmed by a read-back, so
-// a write that landed but answered with an error still launches (joshuafolkken/kit#3312).
+// a write that landed but answered with an error still launches.
 async function mark_in_progress(issue: string): Promise<LabelWrite> {
 	return await git_gh_command.issue_apply_label(issue, IN_PROGRESS_LABEL)
 }
 
-// The dispatch owns both halves of the marker: it applied it, so a launch that never started takes it
-// back off, leaving no `in-progress` on an issue nothing is running. A removal that itself fails is
-// swallowed — the failed launch is already warned about, and `lane:list` / `run:progress` surface a
-// stuck marker — so this never turns a launch failure into a thrown error.
-async function unmark_in_progress(issue: string): Promise<void> {
-	try {
-		await git_gh_command.issue_remove_label(issue, IN_PROGRESS_LABEL)
-	} catch {
-		/* the launch already failed and is warned about; a stuck marker is reported by lane:list */
-	}
-}
-
 // A started child is recorded on the run's stream, which is where the stall detector ages the last
-// dispatch from (joshuafolkken/kit#2464) — unrecorded, every stall read "hours since the last dispatch"
+// dispatch from — unrecorded, every stall read "hours since the last dispatch"
 // minutes after a launch. A failed start records nothing: no child is running. The marker is claimed
 // first, so a refused one starts nothing.
+//
+// The dispatch owns both halves of the marker: it applied it, so a launch that never started takes it
+// back off through `run_label.unmark`, leaving no `in-progress` on an issue nothing is running. That
+// removal warns and never throws, so it cannot turn a launch failure into a thrown error.
+//
+// The lane ledger takes the same instant: `lane:stats` times a lane's implementation from it, and the
+// stream is capped, so a period's earlier dispatches would be gone from there.
+async function record_started(issue: string): Promise<void> {
+	await run_event_stream_emit.emit(
+		run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+		`${issue_cite.plain(issue)} dispatched`,
+	)
+	await lane_ledger.record_dispatch(Number(issue))
+}
+
 async function finish_dispatch(issue: string, request: StartRequest): Promise<DispatchOutcome> {
 	const mark = await mark_in_progress(issue)
 
@@ -336,16 +341,14 @@ async function finish_dispatch(issue: string, request: StartRequest): Promise<Di
 
 	const is_failed = outcome.kind === 'failed'
 
-	await (is_failed
-		? unmark_in_progress(issue)
-		: run_event_stream_emit.emit(run_event_stream.EVENT_KIND.CHILD_LAUNCH, `#${issue} dispatched`))
+	await (is_failed ? run_label.unmark(issue) : record_started(issue))
 
 	return outcome
 }
 
 /** Start `fullrun #<N>` detached in the lane for `#<N>`, recording where it writes as it does so. */
 async function dispatch_child(issue: string): Promise<DispatchOutcome> {
-	run_issue_number.require_issue_number(issue)
+	issue_number_shape.require_issue_number(issue)
 
 	const lane = await lane_registry.find_open_lane(issue)
 
@@ -366,25 +369,11 @@ async function dispatch_child(issue: string): Promise<DispatchOutcome> {
 // The child is running — saying otherwise would send the caller to dispatch a second one into the same
 // lane — but its output is going nowhere, so a message naming the path would point at a file that will
 // never grow, and a poll of that file would book a working child as stopped.
-// The liveness pattern the parent polls with — the shared one, which also finds a detached ship
-// supervisor (joshuafolkken/kit#2428). `describe` never throws, so an issue that is not a number falls
-// back to the launched invocation rather than raising from the validator.
-function poll_pattern(outcome: Dispatched, issue: string): string {
-	if (!run_issue_number.ISSUE_NUMBER_PATTERN.test(issue)) return `${outcome.invocation}$`
-
-	return lane_child_invocation.process_pattern(issue)
-}
-
 function log_sentence(outcome: Dispatched, issue: string): string {
-	// **The pattern matches the child's own command line, not the lane it runs in**
-	// (joshuafolkken/kit#1948). The child is `claude … ${outcome.invocation}` and its argv carries no
-	// path, so `pgrep -laf <lane directory>` found nothing for a living child and a poll booked it
-	// stopped. The invocation is the last argument, so it sits at the end of the command line; the `$`
-	// anchor is what keeps `fullrun #12` from matching a running `fullrun #123`. `run:liveness` takes
-	// `--process` as what the caller *saw*, never as a property of the child's kind — told to pass
-	// `alive`, a parent that never ran `pgrep` would answer `alive` for a child that crashed an hour ago
-	// and poll it for ever.
-	const poll = `run \`pgrep -laf "${poll_pattern(outcome, issue)}"\` and pass what it found to \`pnpm josh run:liveness ${issue} --output ${outcome.log_path} --process alive\` — or \`--process none\` where it found nothing`
+	// **`run:liveness` reads the child's process for itself**, with the shared
+	// pattern that matches the child's own command line and a detached ship supervisor, so no parent
+	// passes `alive` by hand for a child that crashed an hour ago.
+	const poll = `run \`pnpm josh run:liveness ${issue} --output ${outcome.log_path}\` — it reads the child's process for itself`
 
 	if (outcome.notes.length > 0) {
 		return ` Its output is NOT being kept — ${outcome.notes.join(NOTE_SEPARATOR)} — so ${outcome.log_path} will not grow and the process trace is the only answer: ${poll}.`
@@ -394,7 +383,7 @@ function log_sentence(outcome: Dispatched, issue: string): string {
 }
 
 // Whether this dispatch resumed the disconnected child's session or started fresh — the report the
-// `outage` re-dispatch owes (joshuafolkken/kit#2317). A fresh start says so too, so the absence of a
+// `outage` re-dispatch owes. A fresh start says so too, so the absence of a
 // resume is never silent when an outage record was present.
 function resume_sentence(outcome: Dispatched): string {
 	if (outcome.resumed_from === undefined) {
@@ -408,20 +397,20 @@ function resume_sentence(outcome: Dispatched): string {
 // message the warning exists to carry — the pid among it, with the child already running.
 function describe(outcome: DispatchOutcome, issue: string): string {
 	if (outcome.kind === 'no-lane') {
-		return `No lane is open for #${issue}. Run \`pnpm josh lane:open ${issue}\` first, then dispatch into it.`
+		return `No lane is open for ${session_cite.issue(issue)}. Run \`pnpm josh lane:open ${issue}\` first, then dispatch into it.`
 	}
 
 	if (outcome.kind === 'unrecordable') return outcome.reason
 
 	if (outcome.kind === LABEL_UNSET_KIND) {
-		return `The child for #${issue} was not started: the \`${IN_PROGRESS_LABEL}\` label could not be applied (${outcome.reason}), so the lane would be counted as empty. Nothing was launched.`
+		return `The child for ${session_cite.issue(issue)} was not started: the \`${IN_PROGRESS_LABEL}\` label could not be applied (${outcome.reason}), so the lane would be counted as empty. Nothing was launched.`
 	}
 
 	if (outcome.kind === 'failed') {
-		return `The child for #${issue} did not start: ${outcome.note}. Its log is at ${outcome.log_path}.`
+		return `The child for ${session_cite.issue(issue)} did not start: ${outcome.note}.${agent_role_profile.default_notice()} Its log is at ${outcome.log_path}.`
 	}
 
-	return `Dispatched \`${outcome.invocation}\` as process ${String(outcome.pid)} in ${outcome.lane.directory} with ${agent_role_profile.describe(outcome.profile)}.${resume_sentence(outcome)}${log_sentence(outcome, issue)}`
+	return `Dispatched \`${outcome.invocation}\` as process ${String(outcome.pid)} in ${outcome.lane.directory} with ${agent_role_profile.describe(outcome.profile)}.${agent_role_profile.default_notice()}${resume_sentence(outcome)}${log_sentence(outcome, issue)}`
 }
 
 /**
@@ -441,7 +430,7 @@ function is_worth_warning(outcome: DispatchOutcome): boolean {
 // own failures to standard error and never throws, so this cannot turn a refusal into an exception.
 async function warn_of_problem(outcome: DispatchOutcome, issue: string): Promise<void> {
 	await telegram_notify.warn({
-		issue_title: `${WARNING_TITLE} #${issue}`,
+		issue_title: `${WARNING_TITLE} ${issue_cite.plain(issue)}`,
 		body: describe(outcome, issue),
 		recovery: WARNING_RECOVERY,
 	})

package/scripts/lane/lane-environment.ts

@@ -1,7 +1,7 @@
 import { LANE_SEAT_KEY, PORT_SEED_KEY, ports } from '#ports'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 
-// The lane's `.env`, built from the root's (joshuafolkken/kit#1490, joshuafolkken/kit#1494).
+// The lane's `.env`, built from the root's.
 //
 // **Port separation is required here, not optional.** `ports/index.js` resolves the project root as
 // the nearest ancestor holding a `package.json` — which, inside a linked work tree, is the lane's
@@ -9,8 +9,8 @@ import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role
 // root's runs on the root's exact offset; either way every lane lands on one pair of ports, and a
 // busy port fails without retrying on another. At the default six lanes that turns E2E from "fails
 // sometimes" into "fails nearly always". So the lane's `.env` keeps the project's `PORT_SEED`
-// unchanged and adds `JOSH_LANE_SEAT`, and `ports/index.js` combines them as `seed × 10 + seat`
-// (joshuafolkken/kit#1494): the file plainly shows which number is the project's and which is the
+// unchanged and adds `JOSH_LANE_SEAT`, and `ports/index.js` combines them as `seed × 10 + seat`:
+// the file plainly shows which number is the project's and which is the
 // seat, and the multiplication that separates the bands lives in one place rather than here.
 //
 // **Everything else in the file is carried across verbatim**, comments and blank lines included:
@@ -18,7 +18,7 @@ import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role
 // are as necessary inside a lane as outside one, and a lane that had to have them re-entered would
 // not be a place a run could start unattended.
 
-// Where the delegated unit running this lane's child writes (joshuafolkken/kit#1713). It goes in the
+// Where the delegated unit running this lane's child writes. It goes in the
 // lane's own `.env` — the store `lane-registry.ts` already reads — rather than in a ledger beside the
 // trees, so `git worktree remove` erases the record along with the lane it described and there is
 // nothing left to go stale. `.env` is gitignored in kit and in every consumer `josh sync` reaches,
@@ -149,7 +149,7 @@ function read_lane_ports(content: string): { development: number; preview: numbe
 /**
  * The output path a lane's `.env` records, or `undefined` where it records none.
  *
- * **A blank assignment is `undefined` rather than an empty path** (joshuafolkken/kit#1713). A lane
+ * **A blank assignment is `undefined` rather than an empty path**. A lane
  * whose record was cleared has nothing to poll, and an empty string handed to
  * `pnpm josh run:liveness --output` is a relative path — refused by its own root check, so the
  * child would come back `undetermined` for ever rather than saying the record is missing.

package/scripts/lane/lane-guard-policy.ts

@@ -1,35 +1,21 @@
 import { lane_child_marker, type MarkerSource } from './lane-child-marker'
 
 // How each `PreToolUse` guard behaves in a dispatched lane child, as an enumeration rather than a
-// judgement (joshuafolkken/kit#2138, joshuafolkken/kit#2164).
+// judgement.
 //
 // **The three guards were built for the interactive main line, where a refusal is guidance.** A denial
 // rewrites the next move of a person's session. A dispatched lane child is a headless `claude -p`
-// process, so a *denial* ends the conversation with nothing committed — joshuafolkken/kit#2138 measured
-// a child killed before its commit by two investigation refusals and one batching refusal, every one of
-// them a read of a file the child was about to edit. So a guard whose correction is a denial cannot fire
-// as one in a child.
+// process, so a *denial* ends the conversation with nothing committed. So a guard whose correction is a
+// denial cannot fire as one in a child.
 //
-// **But a denial is not the only way a guard can speak, and that is what kit#2164 tried.** A guard can
-// also raise a *notice* — a non-blocking `additionalContext` that carries the same guidance without a
-// `permissionDecision`, so the turn is never ended. kit#2164 downgraded the batching guard to a notice
-// in the child for exactly that reason. So the choice is three-valued, not two:
+// **But a denial is not the only way a guard can speak.** A guard can also raise a *notice* — a
+// non-blocking `additionalContext` that carries the same guidance without a `permissionDecision`, so the
+// turn is never ended. So the choice is three-valued, not two:
 //
 //   - `refuse` — deny the call (the main-line default; the child keeps this for the safety rules).
 //   - `notice` — let the call through but attach the guidance, so a headless child is nudged, not killed.
 //   - `off`    — say nothing at all, for a guard whose remedy the child cannot carry out.
 //
-// **The notice did not move the number, kit#2178 took it off, and kit#2276 restores it changed.** The
-// lane child that ran right after kit#2164 merged came in at 1.00 calls per turn on both sides of the
-// first notice (transcript `f39efeb5`), so kit#2178 turned the batching notice `off` in the child rather
-// than pay the per-turn context cost of guidance measured not to work. But with it off, the notice fired
-// **zero** times across the 2026-09-21 backlogrun the density was next measured on, so the 1.147 read
-// there is the rate with no guidance at all — not a second measurement of the notice failing. kit#2276
-// therefore restores it as `notice`, with the two things #2164's lacked: it names the concrete recent
-// calls the run issued one-per-turn, and it recurs every single-call turn rather than every three. The
-// mode stays a genuine experiment — the density is re-measured on the next backlogrun, and a notice that
-// still does not move it is redesigned rather than kept.
-//
 // **It is an enumeration and not a judgement, for the reason `delegation-policy.ts` is one.** "This
 // guard's mode in a child" is a call made under the same pressure that produced the misfire. The list is
 // the whole of it, and a guard nobody classified refuses — the safe direction, since a wrongly-silenced
@@ -37,7 +23,7 @@ import { lane_child_marker, type MarkerSource } from './lane-child-marker'
 // survived once. `lane-guard-policy.test.ts` pins that the enumeration and the guards' live behavior
 // cannot disagree.
 
-// The three ways a guard may behave in a lane child (joshuafolkken/kit#2164). Outside a lane child every
+// The three ways a guard may behave in a lane child. Outside a lane child every
 // guard is `refuse`, which is why that is also the fail-safe default below.
 type LaneGuardMode = 'refuse' | 'notice' | 'off'
 type LaneGuardId = 'investigation' | 'batching' | 'rule' | 'duplicate-read'

package/scripts/lane/lane-handoff.ts

@@ -2,12 +2,12 @@ import { git_common_directory } from '#scripts/git/git-common-directory'
 import { run_ship_detach } from '#scripts/run/ship/run-ship-detach'
 import { lane_child_marker, type MarkerSource } from './lane-child-marker'
 
-// Whether a lane has handed its post-implementation region to the detached ship (joshuafolkken/kit#2962).
+// Whether a lane has handed its post-implementation region to the detached ship.
 //
 // **A child that ran `pnpm josh ship --detach` waits on nobody when it ends.** The supervisor drives the
 // gate, the review and the merge, and notifies on its own outcome, so the `Stop` hook's demand for a
 // `confirmation` notify and `lane-park`'s refusal of that notify only bought a "nothing needed"
-// Telegram and a wasted turn — measured on 2026-10-02 as 43 demands, 21 refusals and ~94 extra turns.
+// Telegram and a wasted turn.
 // Both hooks read this one predicate, so they cannot disagree about whether the lane was handed off.
 //
 // **Running, never merely recorded.** A ship that failed hands its region back to the child, whose