@joshuafolkken/kit 1.1240.0 → 1.1373.0

package/scripts/rules/issue-comments.ts

@@ -4,7 +4,7 @@ import { prior_comment_read } from './prior-comment-read'
 import { shell_segments } from './shell-segments'
 
 // The trigger and the delivered text behind the `issue-comments` row of `delivered-rules.ts`, moved
-// out of the enumeration so the list stays a list (joshuafolkken/kit#3264).
+// out of the enumeration so the list stays a list.
 
 // **A shell line carries several commands, and the subcommand has to be the one being invoked.**
 // Each segment is judged on its own, anchored at its start, so `gh issue comment <N> -b "… gh issue
@@ -29,7 +29,7 @@ const ISSUES_PATH = /repos\/[^\s'"]*\/issues\//u
 
 // A field projection — `--jq` for `gh api`, `--json` for `gh issue view` — whose value never names the
 // body. `gh api …/issues/<N> --jq '{state, labels}'` fetches the Issue only to read its state or its
-// labels, which is a state check and not the body read this rule guards (joshuafolkken/kit#1905); a
+// labels, which is a state check and not the body read this rule guards; a
 // `--jq '.body'` still names the body and stays a body read. The value is taken quoted or bare, so the
 // comma list `--json state,labels` and the expression `'{state, labels}'` are read the same way.
 const FIELD_PROJECTION = /(?:--jq|--json)[= ]\s*('[^']*'|"[^"]*"|\S+)/u
@@ -78,20 +78,26 @@ function reads_issue_comments(command: string): boolean {
 }
 
 // **The refusal hands over the command that fixes it**, because reading is not the same as
-// obeying: a sentence saying "also read the comments" is prose of exactly the kind
-// joshuafolkken/kit#1344 measured as moving nothing, while a refused body read leaves the run
-// holding the reissue that makes the comments *present*. The conflict rule ships with it — a
-// delivery that said only "read them" would hand back the deciding at the moment nothing else is
-// open to read, the mistake joshuafolkken/kit#1518 corrected for the WIP cap.
+// obeying: a sentence saying "also read the comments" is prose that moves nothing, while a refused
+// body read leaves the run holding the reissue that makes the comments *present*. The conflict rule
+// ships with it — a delivery that said only "read them" would hand back the deciding at the moment
+// nothing else is open to read.
+//
+// **The command comes first, the reason after**. The first line is the guard's
+// label and then the call itself — `issue:read` prints the body and every comment in one read, `<N>`
+// being the Issue the refused call named — so a run that reads only the opening still leaves holding
+// the fix. The label keeps `time_transcript_line.guard_from_refusal` naming this guard, not the command.
 const ISSUE_COMMENTS_REASON =
-	"⛔ an Issue's comments are part of the Issue: read them before implementing, not only the body. " +
-	'A decision recorded after the body was written lives only in a comment — a corrected diagnosis ' +
-	'(joshuafolkken/kit#1537), a changed default and an added acceptance criterion ' +
+	'⛔ issue comments: pnpm josh issue:read <N>\n' +
+	"Run that in place of this read: <N> is the Issue it names, and an Issue's comments are part of " +
+	'the Issue, so the body and every comment come back together. Without josh, add ' +
+	"`gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, " +
+	"body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable.\n" +
+	'Why: a decision recorded after the body was written lives only in a comment — a corrected ' +
+	'diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion ' +
 	'(joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) — and ' +
 	'nothing in the body says it was superseded, so a body-only reader builds the wrong thing and ' +
-	'sees no contradiction. Reissue this read with the comments included: ' +
-	"`gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, " +
-	"body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. " +
+	'sees no contradiction. ' +
 	'Then the later text is the agreement in force — a comment supersedes the body it contradicts — ' +
 	"except for two answers that are not the run's to make: work a comment reassigns to another " +
 	'Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a ' +
@@ -107,6 +113,8 @@ const ROW = {
 	reason: ISSUE_COMMENTS_REASON,
 	already_satisfied: prior_comment_read.already_read_for_call,
 	keeps: bash_triggers.on_bash_command(reads_issue_comments),
+	// The opening the reason carried before it led with the command.
+	former_reasons: ["⛔ an Issue's comments are part of the Issue: read them before implementing"],
 }
 
 const issue_comments = {

package/scripts/rules/josh-git-bare.ts

@@ -2,8 +2,8 @@ import { time_shell } from '#scripts/time-runtime/time-shell'
 import { bash_triggers } from './bash-triggers'
 import { shell_segments } from './shell-segments'
 
-// The trigger and the delivered text behind the `josh-git-bare` row of `delivered-rules.ts`
-// (joshuafolkken/kit#2297): a `pnpm josh git` issued without `-y` / `--yes`.
+// The trigger and the delivered text behind the `josh-git-bare` row of `delivered-rules.ts`:
+// a `pnpm josh git` issued without `-y` / `--yes`.
 //
 // **A bare `pnpm josh git` cannot succeed from an agent, and it wastes the time it takes to fail.** The
 // command prompts to confirm the staging, and with no TTY the prompt falls to its cancel branch —

package/scripts/rules/lane-background.ts

@@ -9,26 +9,24 @@ import {
 } from '#scripts/time-runtime/time-transcript-line'
 import { run_tail_rule } from './run-tail-rule'
 
-// A dispatched lane child is stopped from backgrounding a long-running josh command (joshuafolkken/kit#2704).
+// A dispatched lane child is stopped from backgrounding a long-running josh command.
 //
 // **A headless child's turn-end is its process's end.** A lane child runs as `claude -p`, and there the
 // background Bash tasks die with the turn — so "a background command's exit re-invokes the session"
-// (`background-commands.md`) does not hold. joshuafolkken/kit#2457 refused a non-detached `josh ship`
-// for exactly that reason, but only `ship`: the #2606 child backgrounded `pnpm josh gate && pnpm josh git
-// -y …` directly, ended its turn, and the gate died at `exit code 143` with the implementation, the
-// scoped checks, a review round and the live verification all done — parked instead of merged.
+// (`background-commands.md`) does not hold. A child that backgrounds `pnpm josh gate && pnpm josh git
+// -y …` and ends its turn sees the gate die at `exit code 143` with the implementation, the scoped
+// checks, a review round and the live verification all done — parked instead of merged.
 //
 // **So the refusal is put at the launch, and it names the detached route.** The region from the gate to
 // the merge belongs to `pnpm josh ship --detach` in a child (`chain-rule.md` step 0), whose supervisor
 // outlives the turn.
 //
-// **`ship` is in the set too, `--detach` or not** (joshuafolkken/kit#3027). #2457 detaches it in a child,
-// but only after its preflight — the scoped checks — has passed in the calling process, so a
-// backgrounded `ship` is killed at the turn's end before any supervisor exists: the #3022 child did
-// exactly that and was parked as a failure. Issued in the foreground it returns at `launched` within the
-// tool timeout, and the supervisor carries the rest. A backgrounded `ship` alone is no longer refused but
-// rewritten into that foreground call (`foreground_input`, joshuafolkken/kit#3154); one chained after
-// another long command is still refused.
+// **`ship` is in the set too, `--detach` or not**. It detaches in a child, but only after its
+// preflight — the scoped checks — has passed in the calling process, so a backgrounded `ship` is
+// killed at the turn's end before any supervisor exists. Issued in the foreground it returns at
+// `launched` within the tool timeout, and the supervisor carries the rest. A backgrounded `ship` alone
+// is not refused but rewritten into that foreground call (`foreground_input`); one chained after
+// another long command is refused.
 //
 // **Its stop-time half reads the same fact from the other side.** A backgrounded task the transcript
 // launched but never saw finish is still running, and in a child the stop about to happen kills it —
@@ -60,7 +58,7 @@ function long_commands_of(command: string): Array<string> {
 
 // A call whose long-running work is `ship` alone. In a child a foreground `ship` already detaches
 // itself after its preflight (`run-ship-cli.ts` → `should_detach`), so the only fault in backgrounding
-// it is the flag — and the flag is what the hook rewrites (joshuafolkken/kit#3154).
+// it is the flag — and the flag is what the hook rewrites.
 function ships_alone(command: string): boolean {
 	const names = long_commands_of(command)
 
@@ -103,7 +101,7 @@ function is_background_long_run(
 	return is_candidate(call) && is_lane_child()
 }
 
-// **A backgrounded `ship` in a child is rewritten, not refused** (joshuafolkken/kit#3154). The refusal
+// **A backgrounded `ship` in a child is rewritten, not refused**. The refusal
 // asked for nothing but the same call in the foreground — 14 of 41 lane `ship` refusals in one measured
 // backlogrun were that round trip, paid at the run's largest context. The input with the flag cleared,
 // or `undefined` for every call this does not apply to.
@@ -137,8 +135,8 @@ function unfinished_ids(
 	return launched.filter((id) => id !== '' && !finished.has(id))
 }
 
-// The background tasks the tail launched and never saw finish — commands and subagents alike
-// (joshuafolkken/kit#2774), since a lane child's turn-end kills either.
+// The background tasks the tail launched and never saw finish — commands and subagents alike,
+// since a lane child's turn-end kills either.
 function pending_background_ids(tail: string): ReadonlyArray<string> {
 	return unfinished_ids(tail, (block) => [block.background_id, block.agent_id])
 }

package/scripts/rules/lane-carry-conflict.ts

@@ -1,9 +1,10 @@
+import { platform_temporary } from '#scripts/josh/platform-temporary'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { bash_triggers } from './bash-triggers'
 import { shell_segments } from './shell-segments'
 
 // A dispatched lane child is stopped from running its parent's budget commands, and told the live
-// carry record is its parent's rather than a competing run (joshuafolkken/kit#2267).
+// carry record is its parent's rather than a competing run.
 //
 // **A child read its own parent as a competitor and refused to implement.** On 2026-09-21, inside
 // `backlogrun #2252`, a lane launched for #2258 stopped before touching a line: the child ran
@@ -32,13 +33,46 @@ import { shell_segments } from './shell-segments'
 // canonical form only — `shell_segments.is_josh_command` canonicalizes an alias before the match.
 const RUN_BUDGET_COMMANDS: ReadonlySet<string> = new Set(['run:merge', 'run:carry'])
 
+// **A `run:carry` call prefixed with a non-empty `JOSH_TEMP_ROOT` cannot reach the parent's record**,
+// because every record it keeps is a `stamp_path` under that root. It is how
+// live evidence of it is taken, so it is let through rather than refused — refusing it is what sent a
+// child round the guard to the bare CLI, which then ended its parent's record. `run:merge` stays
+// refused under any root: besides its record it syncs main, closes lanes and writes to GitHub, none of
+// which a redirected root moves. Only a leading
+// assignment counts: an `export` in an earlier segment is not read, and is refused as before. A bare
+// variable is refused too: shell state does not survive between tool calls, so `$EV` set in an
+// earlier call expands to nothing here, and an empty root is the live run's default one.
+//
+// One leading assignment, its value read as the shell reads it: a run of quoted strings, `$(…)`
+// substitutions (one nested level) and plain characters, so a space inside a quote or a substitution
+// does not end it. Cut at the first space, `JOSH_TEMP_ROOT=$(mktemp -d -t ev) pnpm josh run:merge`
+// left `ev) pnpm …` behind, whose head the command reader rejects, and slipped the refusal.
+const LEADING_ASSIGNMENT = String.raw`[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\$\((?:[^()]|\([^()]*\))*\)|[^\s"'])*\s+`
+
+const REDIRECTED_PREFIX = new RegExp(
+	String.raw`^(?:${LEADING_ASSIGNMENT})*${platform_temporary.TEMP_ROOT_KEY}=(?!""|''|\s|$|"?\$\{?[A-Za-z_])`,
+	'u',
+)
+
+// The budget commands with an effect outside the temp root, so a redirected root does not isolate them.
+const SHARED_STATE_COMMANDS: ReadonlySet<string> = new Set(['run:merge'])
+
+// The leading assignments, stripped before the command is read. The shared command reader unwraps
+// `$(…)` into the command position — the subshell is the real work in a cost row — so without this
+// `JOSH_TEMP_ROOT="$(mktemp -d)" pnpm josh run:merge` read as `mktemp` and slipped the refusal.
+const LEADING_ASSIGNMENTS = new RegExp(`^(?:${LEADING_ASSIGNMENT})*`, 'u')
+
+function is_budget_segment(segment: string): boolean {
+	const commands = REDIRECTED_PREFIX.test(segment) ? SHARED_STATE_COMMANDS : RUN_BUDGET_COMMANDS
+
+	return shell_segments.is_josh_command(segment.replace(LEADING_ASSIGNMENTS, ''), commands)
+}
+
 // A segment that invokes one of the parent's budget commands. Segment-wise and alias-expanded for the
 // reason every command predicate in this directory is: one shell line carries several commands, and a
 // name quoted inside a body is not the command being invoked.
 function invokes_budget_command(command: string): boolean {
-	return shell_segments
-		.segments_of(command)
-		.some((segment) => shell_segments.is_josh_command(segment, RUN_BUDGET_COMMANDS))
+	return shell_segments.segments_of(command).some((segment) => is_budget_segment(segment))
 }
 
 // **The command test comes first and the world is consulted second**, so the `is_child_of` read — the
@@ -71,7 +105,9 @@ const LANE_CARRY_CONFLICT_REASON =
 	'dispatched child cannot ask, and there is nothing to decide. Continue implementing this Issue; the ' +
 	'parent owns the budget and counts the outcome at the return. The procedure is ' +
 	'`.claude/skills/workflow-commands/pre-gate-cut.md` and `backlogrun-progress.md` → "The hand-off". ' +
-	'This rule fires on every occurrence, not once per run.'
+	'Live evidence of `run:carry` is taken with a fresh `JOSH_TEMP_ROOT` prefixed to the call, which this ' +
+	'rule lets through (joshuafolkken/kit#3458); `run:merge` is refused under any root, because it also ' +
+	'syncs main, closes lanes and writes to GitHub. This rule fires on every occurrence, not once per run.'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `is_trigger` reads the input through
 // `on_bash_command` — the `Bash` tool-name gate every command row shares — and `decide` returns true

package/scripts/rules/lane-interactive-ask.ts

@@ -3,16 +3,13 @@ import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 
 // A dispatched lane child's interactive ask is refused and routed to the park procedure, delivered at
-// the call it binds on (joshuafolkken/kit#2201).
+// the call it binds on.
 //
-// **This is joshuafolkken/kit#2034's rule, moved one tool-call earlier.** #2034 gave a lane child that
-// stops for a decision the right instruction — park the question on the Issue before it notifies — but
-// wired it to the `confirmation` notify. A child that reaches for `AskUserQuestion` never gets that
-// far: the ask is refused by the harness, the turn ends there, and #2034's guard never fires. Measured
-// on 2026-09-20 inside `backlogrun #2163 --only`: #2178's child hit a Tier B branch, called
-// `AskUserQuestion`, was refused, and died with the question stranded in its exit record's
-// `permission_denials`. So the trigger is the ask itself, not the stop that a routed child would have
-// reached afterward.
+// **This is `lane-park.ts`'s rule, moved one tool-call earlier.** That rule parks the question on the
+// Issue before the `confirmation` notify. A child that reaches for `AskUserQuestion` never gets that
+// far: the ask is refused by the harness, the turn ends there with the question stranded in its exit
+// record's `permission_denials`, and the park guard never fires. So the trigger is the ask itself,
+// not the stop that a routed child would have reached afterward.
 //
 // **A hook denial is guidance, where the harness's own denial is death.** The harness refuses an
 // interactive ask in a headless session by ending the turn; this rule refuses the same call with a

package/scripts/rules/lane-park.ts

@@ -4,18 +4,15 @@ import { lane_handoff } from '#scripts/lane/lane-handoff'
 import { bash_triggers } from './bash-triggers'
 import { shell_segments } from './shell-segments'
 
-// A dispatched lane child records its park before it stops, delivered at the call it binds on
-// (joshuafolkken/kit#2034).
+// A dispatched lane child records its park before it stops, delivered at the call it binds on.
 //
-// **A lane child that stopped for a decision left no question behind.** A `backlogrun` dispatches a
-// child as a detached `fullrun #<N>` process, and its only route to ask a person anything is to park
-// the Issue — `needs-decision` plus a comment carrying the question. Measured twice in one run on
-// 2026-09-14: #2012's child had its `AskUserQuestion` refused (it is headless), wrote the question
-// into its final message, sent a `confirmation` Telegram and exited; #2011 wrote a Tier B decision to
-// its final message and exited the same way. Neither left a label or a comment, so the parent found an
-// OPEN Issue with `in-progress` and no question, and a person looking at the Issue could not tell what
-// to answer. The child is the one process that knows the question, the options and whether it stashed,
-// and that knowledge died with its turn.
+// **A lane child that stops for a decision must leave the question behind.** A `backlogrun`
+// dispatches a child as a detached `fullrun #<N>` process, and its only route to ask a person
+// anything is to park the Issue — `needs-decision` plus a comment carrying the question. A child that
+// writes the question only into its final message leaves the parent an OPEN Issue with `in-progress`
+// and no question, and a person looking at the Issue cannot tell what to answer. The child is the one
+// process that knows the question, the options and whether it stashed, and that knowledge dies with
+// its turn.
 //
 // **The stop is one shell call, so the rule is delivered rather than resident.** `CLAUDE.md` mandates
 // a `confirmation` Telegram before any mid-workflow stop, so `pnpm josh notify --task-type
@@ -53,7 +50,7 @@ function is_confirmation_notify(command: string): boolean {
 }
 
 // The josh notify invocation in either spelling, anywhere in a blob of text. The stop guard
-// (joshuafolkken/kit#2121) asks whether a confirmation notify was issued *this turn* by scanning the
+//  asks whether a confirmation notify was issued *this turn* by scanning the
 // transcript tail rather than one command, so the "is it a stop notification" judgement stays here —
 // the same `CONFIRMATION_TASK_TYPE` regex, never a second copy of it.
 const NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u
@@ -64,7 +61,7 @@ const NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u
 // on purpose — the guard's safe direction is to read a real stop notification as present, so a run
 // that sent one is never told it did not.
 //
-// **A command that sent the Telegram itself prints this line instead** (joshuafolkken/kit#3099):
+// **A command that sent the Telegram itself prints this line instead**:
 // `run:entry` notifies from inside its own stop, so no `josh notify` invocation reaches the transcript,
 // and the line it prints is what the tail carries. One constant, printed there and matched here.
 const COMMAND_NOTIFY_MARKER = 'stop notified: a confirmation Telegram was sent by this command'
@@ -81,7 +78,7 @@ function mentions_confirmation_notify(text: string): boolean {
 // human-or-child fact the pre-gate cut reads: a person working in a lane carries no mark and sees no
 // refusal, and a mark that leaked in naming another issue is read as a person too.
 //
-// **A child that handed its region to the detached ship is not parking** (joshuafolkken/kit#2962): its
+// **A child that handed its region to the detached ship is not parking**: its
 // stop waits on nobody, so the park checklist is the wrong advice. `lane_handoff.is_handed_off` is the
 // reading the `Stop` hook stands its notify demand down on, so the two hooks cannot disagree.
 function is_parking_child(directory: string = process.cwd()): boolean {
@@ -126,8 +123,7 @@ const LANE_PARK_REASON =
 	'before it stops", and the park itself is `backlogrun-park.md` → "park and continue".'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. **Once per run rather than `decide`, and
-// no `already_satisfied`.** The stop ends the turn, so it is not the recurring act joshuafolkken/kit#1570
-// wrote `decide` for. It carries no `already_satisfied` because the park it asks for is a GitHub label a
+// no `already_satisfied`.** The stop ends the turn, so it is not the recurring act `decide` is for. It carries no `already_satisfied` because the park it asks for is a GitHub label a
 // synchronous guard cannot read, and the transcript-tail alternative would read a child that merely
 // *read* `backlogrun-park.md` — whose prose carries the `labels[]=needs-decision` command — as
 // compliant and fall silent on a real violation (the header above). `keeps` reads an actual

package/scripts/rules/lane-split-park.ts

@@ -6,8 +6,7 @@ import { lane_park } from './lane-park'
 import { shell_segments } from './shell-segments'
 import { tail_commands } from './tail-commands'
 
-// A dispatched lane child that split its own Issue is stopped from parking the epic it promoted
-// (joshuafolkken/kit#3296).
+// A dispatched lane child that split its own Issue is stopped from parking the epic it promoted.
 //
 // **A split is not a park.** On 2026-10-06, inside a `backlogrun`, the lane child for #3255 promoted
 // its Issue to an epic with `pnpm josh epic --promote 3255`, filed #3291–#3294, then applied

package/scripts/rules/lane-switch-main.ts

@@ -4,24 +4,21 @@ import { bash_triggers } from './bash-triggers'
 import { git_argv } from './git-argv'
 import { shell_segments } from './shell-segments'
 
-// A dispatched lane child is stopped from running `git switch main` — the fifth of the "always fails or
-// answers nothing" misfires joshuafolkken/kit#2297 catalogued (joshuafolkken/kit#2313). A lane is a
-// linked work tree, `main` is checked out by the primary work tree, and git allows one branch in one
-// work tree at a time — so the call is **structurally guaranteed to fail** with `fatal: 'main' is
-// already used by worktree at '<the primary checkout>'`. It was measured 11 times in the 2026-09-21
-// backlogrun, always in a lane child.
+// A dispatched lane child is stopped from running `git switch main` — a call that always fails. A
+// lane is a linked work tree, `main` is checked out by the primary work tree, and git allows one
+// branch in one work tree at a time — so the call is **structurally guaranteed to fail** with
+// `fatal: 'main' is already used by worktree at '<the primary checkout>'`.
 //
 // **The source is the parent's step, not the child's.** The distributed procedures write
-// `git switch main && git pull` as the step before reading the dependency scope, and that is *correct in
+// `pnpm josh ms` as the step before reading the dependency scope, and that is *correct in
 // the primary checkout* (`backlogrun-lanes.md` → "Once per repository, before the first lane opens"). A
 // child that runs the same line verbatim fails every time, and the failure is not free: a refused call
-// drops the independent calls batched beside it (joshuafolkken/kit#2177), so a batching child loses the
+// drops the independent calls batched beside it, so a batching child loses the
 // most. `josh main:sync` (`main-sync.ts`) already refuses inside a linked work tree for the same reason;
 // this is the *raw* form of the same call, refused before it fails rather than after.
 //
 // **It refuses rather than rewrites, because a `PreToolUse` guard can only `allow` / `deny` a command,
-// never substitute a different one** (joshuafolkken/kit#2313 decision comment). So the refusal hands back
-// the next command, exactly as #2297 required of `test:declared`: the lane is already on its own issue
+// never substitute a different one**. So the refusal hands back the next command: the lane is already on its own issue
 // branch, branched from a fresh default before it opened, and the latest default is brought in during the
 // gate by `pnpm josh main:merge` — so skip the step and keep implementing on the current branch.
 //
@@ -30,8 +27,8 @@ import { shell_segments } from './shell-segments'
 // differs per repository — so hardcoding `main` would both miss a renamed default and need an async
 // `get_default_branch`. A lane child belongs on its own `<issue>-lane` branch; a `git switch` to anything
 // else is the misfire. Its own branch is read synchronously from the checkout path
-// (`lane_paths.lane_issue_of`), the weaker-but-synchronous lane test a guard is bound to
-// (joshuafolkken/kit#1864). `git switch` alone is covered — it never means a pathspec, so there is no
+// (`lane_paths.lane_issue_of`), the weaker-but-synchronous lane test a guard is bound to.
+// `git switch` alone is covered — it never means a pathspec, so there is no
 // ambiguity — and `git checkout -- <path>` stays `worktree-guard.ts`'s.
 //
 // **The command test comes first and the world is consulted second**, so the lane read runs only on the
@@ -113,7 +110,7 @@ const LANE_SWITCH_MAIN_REASON =
 	'and the latest default is brought in during the gate by `pnpm josh main:merge`. So skip this step ' +
 	'and keep implementing on the current branch — no `git switch`, no `git pull`. `pnpm josh main:sync` ' +
 	'(`josh ms`) is refused in a lane for the same reason, and a lane is finished with `pnpm josh ' +
-	'lane:close <issue-number>`. The parent runs `git switch main && git pull` in the primary checkout ' +
+	'lane:close <issue-number>`. The parent runs `pnpm josh ms` in the primary checkout ' +
 	'before each lane opens, never the child — `backlogrun-lanes.md` and `backlogrun-child.md` are the ' +
 	'single sources. This rule fires on every occurrence, not once per run.'
 

package/scripts/rules/last-prompt.ts

@@ -4,7 +4,7 @@ import { z } from 'zod'
 import { filing_cap } from './filing-cap'
 
 // The text of the person's last prompt on a transcript tail — what the stop guard's citation row
-// reads to tell a `#N` the person quoted from one the run brought in itself (joshuafolkken/kit#2819).
+// reads to tell a `#N` the person quoted from one the run brought in itself.
 //
 // **A prompt is `filing_cap`'s prompt line, minus what the harness wrote there.** A skill's body is a
 // `user` line with no tool result too, but it carries `isMeta`; a background task's completion notice

package/scripts/rules/oracle-consulted.ts

@@ -6,15 +6,15 @@ import { oracle_firing, type FiringPoint } from './oracle-firing'
 import { shell_segments } from './shell-segments'
 import { tail_commands } from './tail-commands'
 
-// The one generic rule that turns a declared firing point into a delivered guard (joshuafolkken/kit#2324).
+// The one generic rule that turns a declared firing point into a delivered guard.
 // `oracle-firing.ts` records, per oracle, the action that must consult it first; this generates a
 // `DeliveredRule` for each such oracle — refused when the run performs the governed action without
 // having run the oracle's command earlier, stood down once it has.
 //
 // **It is `issue-scout`'s shape, generalized.** Each generated row refuses until its
-// `already_satisfied` stand-down reads the command off the tail — refuse the governed call, hand back the command,
-// stand down once that command is on the tail. What `issue-scout` and `issue-fold` hand-wrote per
-// oracle, this reads from the registry: the refusal is assembled from the oracle's decision, command,
+// `already_satisfied` stand-down reads the command off the tail — refuse the governed call, hand back
+// the command, stand down once that command is on the tail. What `issue-scout` hand-wrote per oracle,
+// this reads from the registry: the refusal is assembled from the oracle's decision, command,
 // answer vocabulary and single source, so no oracle carries a hand-written refusal of its own. **No new
 // delivery path** — the rows join `DELIVERED_RULES` and fire through the same `create_transcript_guard`
 // shell every other row uses.
@@ -71,7 +71,7 @@ function row_for(oracle: Oracle, firing_point: FiringPoint): DeliveredRule {
 
 // One row per oracle that declared a firing point, in registry order. Spread into `DELIVERED_RULES`
 // after the filing rows, so a firing point that overlaps a filing (`issue:lint`) delivers on the
-// reissue rather than ahead of `wip-cap` / `issue-scout`.
+// reissue rather than ahead of `filing-cap`.
 const ROWS: ReadonlyArray<DeliveredRule> = oracle_firing
 	.firing_oracles()
 	.map(({ oracle, firing_point }) => row_for(oracle, firing_point))

package/scripts/rules/oracle-firing.ts

@@ -1,7 +1,7 @@
 import { decision_oracle } from './decision-oracle'
 import { shell_segments } from './shell-segments'
 
-// The firing-point declaration every decision oracle owes (joshuafolkken/kit#2324). An oracle records a
+// The firing-point declaration every decision oracle owes. An oracle records a
 // *decision*, but nothing on the oracle entry says which action must consult it first — so the 32
 // oracles have a command each and a firing point almost never. This module is the missing half: for
 // every oracle name, either the governed action (a `FiringPoint`, matched as a Bash command) or the
@@ -32,8 +32,8 @@ function is_package_add(command: string): boolean {
 }
 
 // The firing point wired — the oracle whose governed call can be named without guessing: the package
-// add. The Issue filing's `issue:lint` point left with joshuafolkken/kit#2808, when `josh issue:file`
-// began running the lint itself. The rest declare why none can be named, so the unenforced oracles are
+// add. The Issue filing needs no `issue:lint` point, because `josh issue:file` runs the lint itself.
+// The rest declare why none can be named, so the unenforced oracles are
 // visible rather than silently missing.
 const FIRING: ReadonlyMap<string, FiringPoint> = new Map([
 	[
@@ -49,7 +49,7 @@ const FIRING: ReadonlyMap<string, FiringPoint> = new Map([
 // oracles already gated or sequenced elsewhere. `PHASE` — the governed act is a run phase, not one
 // shell call. `READ` — it answers a status question and governs no action of its own. `SELF` — the
 // command is itself the act, with nothing earlier to gate. A guard for any of these would fire on the
-// wrong turn or double-gate a call another rule already claims; `release:scope` (joshuafolkken/kit#2334)
+// wrong turn or double-gate a call another rule already claims; `release:scope`
 // is the one that *trails* rather than gates — it reads state that only exists after the merge.
 const PHASE =
 	'the act it governs is a phase of a run, not a single shell call a trigger can anchor on'
@@ -60,7 +60,7 @@ const LATEST_SCOPE_REASON =
 	'the run it governs (`pnpm josh latest`) is already gated at its point of use by the latest-gate; ' +
 	'a firing here would double-gate it'
 // `josh issue:file` runs the scout, the lint and `epic:bundle` itself, and a filing made any other way
-// is refused by the `direct-filing` row (joshuafolkken/kit#2808) — so none of the three has a call left
+// is refused by the `direct-filing` row — so none of the three has a call left
 // to gate before.
 const FILING_STEP_REASON =
 	'`pnpm josh issue:file` runs it as one of its filing steps, and a direct filing is refused by the ' +
@@ -83,10 +83,7 @@ const NOT_NAMED: ReadonlyMap<string, string> = new Map([
 	['epic:bundle', FILING_STEP_REASON],
 	['issue:scout', FILING_STEP_REASON],
 	['issue:lint', FILING_STEP_REASON],
-	[
-		'issue:fold',
-		'the second filing it governs is already gated by the `issue-fold` delivered rule',
-	],
+	['issue:fold', '`issue:file` asks the fold question itself on the second filing it governs'],
 	['cases', READ],
 	['issue:state', READ],
 	['run:cut:resume', SELF],

package/scripts/rules/oracle-list-cli.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { decision_oracle } from './decision-oracle'
 import { oracle_firing } from './oracle-firing'
 
-// `josh oracle:list` — print the decision oracles enumeration (joshuafolkken/kit#2117).
+// `josh oracle:list` — print the decision oracles enumeration.
 //
 // A command rather than a paragraph: the criterion is `prompts/collaboration-workflow/residency.md`
 // → question 0, and the list is what it points at. Adding an oracle here is the whole action;
@@ -18,7 +18,7 @@ function pad_field(label: string): string {
 }
 
 // The firing point an oracle governs, or the reason none is named — one line either way, so `oracle:list`
-// shows at a glance which oracles a guard enforces and which stay visibly unenforced (joshuafolkken/kit#2324).
+// shows at a glance which oracles a guard enforces and which stay visibly unenforced.
 function firing_line(oracle: (typeof decision_oracle.DECISION_ORACLES)[0]): string {
 	const declaration = oracle_firing.declaration_for(oracle.name)
 

package/scripts/rules/permission-guards.ts

@@ -3,12 +3,12 @@ import { direct_pr_create } from './direct-pr-create'
 import { index_guard } from './index-guard'
 import { protected_files } from './protected-files'
 
-// The three rows that close the deny-list bypasses (joshuafolkken/kit#2983), gathered so
+// The three rows that close the deny-list bypasses, gathered so
 // `delivered-rules.ts` spreads one entry. Each reads argv or a file path rather than a glob: an index
 // mutation in any git spelling, a recursive forced `rm` or a destructive `gh` call, and a Read of
 // `.env` or an edit of a consumer's `.claude/settings.json`. Their triggers are disjoint from every
 // other row's — `git restore` is split with `worktree-mutation` by `--staged` alone. The fourth row,
-// `direct-pr-create` (joshuafolkken/kit#3183), closes the same kind of gap for `gh pr create`, which
+// `direct-pr-create`, closes the same kind of gap for `gh pr create`, which
 // the deny list never listed: it claims `gh pr create` and a `gh api` write to the pulls collection.
 const ROWS = [
 	index_guard.ROW,