@joshuafolkken/kit 1.978.0 → 1.983.0

package/.claude/skills/epic-commands/SKILL.md

@@ -350,8 +350,9 @@ a publish that predates the change.
 
 ## `josh epic:bundle <N>` — does this new issue belong with one already filed?
 
-Run it right after an issue is filed: by `kickoff` / `fullrun` / `halfrun`, or by any Tier A filing
-mid-implementation, including inside a `backlogrun`. **It recommends; it writes nothing.**
+It runs right after an issue is filed: by `kickoff` / `fullrun` / `halfrun`, or by any Tier A filing
+mid-implementation, including inside a `backlogrun`. **`pnpm josh issue:file` runs it as its last step**;
+run it by hand only when that step printed `⚠`. **It recommends; it writes nothing.**
 
 "Two or more always means an epic" only fires when one request is split on the spot. Two issues filed
 days apart that turn out to be the front and back of one job are executed separately, in whatever
@@ -454,9 +455,9 @@ decisions" section above says what to do instead.
 answers the same epic question for an issue that does not exist yet — this decision, called rather
 than restated — and beside it the one thing this one deliberately refuses: whether the work has
 already been filed, from a title comparison (joshuafolkken/kit#1252). **Both run**, and neither
-replaces the other: the scout is what a `new` entry point asks before `gh api … issues`, and
-`epic:bundle` is what it asks afterwards, from the real number and the relations recorded against it.
-Full behavior: `docs/josh-commands.md` → "`josh issue:scout`".
+replaces the other: `pnpm josh issue:file` runs the scout before it creates the issue, and
+`epic:bundle` afterwards, from the real number and the relations recorded against it.
+Full behavior: `docs/josh-commands.md` → "`josh issue:file`".
 
 **When the relation carries an order, record it** in `blocked-by` and in the epic's `Dependencies` —
 on an addition as much as on a new epic. Without it the batch survives and the reason for it does

package/.claude/skills/workflow-commands/SKILL.md

@@ -193,15 +193,15 @@ third of four mid-run discoveries, distinct from an upstream defect, a split (`s
 and an observation (§2i). The full table, the filing command, the `-u`/`stash:pop` steps and the
 10-per-run cap are `prerequisite.md`, its single source, read at that trigger. **When the prerequisite
 is the run's second filing, `pnpm josh issue:fold` runs first** (§2e), and `pnpm josh rule:guard`
-refuses the second `gh api … issues` call until it has.
+refuses the second `pnpm josh issue:file` call until it has.
 
 ## 2e. Before filing a new Issue — `pnpm josh issue:scout`
 
-**Before every new Issue is filed, run `pnpm josh issue:scout <title>` and read its duplicate and epic
-answers.** This applies inside every workflow, including observations and review follow-ups. The
-guard refuses a filing without it. Read `issue-scout.md` at that point for the duplicate, closed-Issue
-and epic decisions; `issue-fold-existing.md` handles a compatible duplicate. `docs/josh-commands.md`
-→ "`josh issue:scout`" defines the command's output.
+**Every new Issue is filed with `pnpm josh issue:file`, which runs the `issue:scout` scan first — read
+its duplicate and epic answers.** This applies inside every workflow, including observations and review
+follow-ups. The guard refuses any other filing call. Read `issue-scout.md` at that point for the
+duplicate, closed-Issue and epic decisions and for `--distinct`; `issue-fold-existing.md` handles a
+compatible duplicate. `docs/josh-commands.md` → "`josh issue:file`" defines the command.
 
 ## 2f. The working-tree hold — one run per tree
 
@@ -239,14 +239,14 @@ parent-wake half at `backlogrun-progress.md` → "The parent keeps no clock of i
 **When a first-party observation is worth filing, file it without asking and continue the run.**
 Read `observation-filing.md` in full before filing: it decides the depth test, filing ceilings, labels,
 second-filing fold, ledger fallback and delegated-child handoff. Use `pnpm josh repo:party` to decide
-first-party status, then run `pnpm josh issue:scout` before filing (§2e). A third-party target remains
+first-party status, then file with `pnpm josh issue:file` (§2e). A third-party target remains
 Tier C (`CLAUDE.md`).
 
 ## 2j. The end-of-run retrospective — read when `run:step` prints it
 
 **When `pnpm josh run:step` prints the retrospective step, read `retrospective.md` in full and run the
-digest it names once.** File up to two worthwhile improvements through `issue:scout` and
-`epic:bundle`, stack the rest in the observation ledger, and close the step with the command described
+digest it names once.** File up to two worthwhile improvements through `issue:file` (scout and
+`epic:bundle` included), stack the rest in the observation ledger, and close the step with the command described
 there. A dispatched lane child never runs the retrospective.
 
 ## 3. What stays resident, and what is read from here

package/.claude/skills/workflow-commands/background-commands.md

@@ -110,7 +110,7 @@ with. Applied to the three waits a run actually has:
 | --------------- | ----------------- |
 | `pnpm josh gate` | a subagent running `/code-review` with the brief `pnpm josh review:brief` prints |
 | `pnpm josh git -y` | Write the completion notification body to a file for `--notify-message-file`, and settle the three-way disposition of any remaining non-High finding |
-| CI, after the push | The second review round where one is due, the branch-2 filing, and `pnpm josh epic:bundle <new>` (`prompts/review.md` → "Review round cap") |
+| CI, after the push | The second review round where one is due, the branch-2 filing through `pnpm josh issue:file`, which runs `epic:bundle` itself (`prompts/review.md` → "Review round cap") |
 | `pnpm josh followup` | Nothing — it is foreground and holds the session. **The post-merge tail is what overlaps here, and it is taken before the call rather than beside it**: compose the epic progress counters first, and leave after the merge only the steps that read its result, plus `pnpm josh cost --cut` |
 
 **The turn never ends at the push.** The completion notification for `pnpm josh git -y` is what

package/.claude/skills/workflow-commands/fullrun-steps.md

@@ -7,7 +7,7 @@ the run is at, and the sections below carry that step in full.
 
 ## The `fullrun #N` step list
 
-Use `pnpm josh issue:lint` `labels:`; see `prompts/collaboration-workflow/issue-template.md`.
+File Issues with `pnpm josh issue:file` (it applies the classification labels); see `prompts/collaboration-workflow/issue-template.md`.
 
 **Add `in-progress` the moment `run:hold` answered `hold`** (create if missing:
 `gh api repos/{owner}/{repo}/labels -f name=in-progress -f color=0075ca -f description="Work is
@@ -29,7 +29,7 @@ with the brief `pnpm josh review:brief` prints on `git diff main`, join the gate
 iterate to no high/medium findings, at most two reviews → **the clean path folds the ship region into
 one call**, `pnpm josh ship "<title> #<N>"` (gate → commit/push/PR → the CI-wait `followup` → the
 `run:tail` report bookkeeping, stopping at the first failed step; joshuafolkken/kit#2398), with any
-branch-2 filing and `pnpm josh epic:bundle` run before it → **when a second round is due `ship` does not
+branch-2 filing (`pnpm josh issue:file`, which runs `epic:bundle` itself) run before it → **when a second round is due `ship` does not
 fit**: open the PR between the rounds with `pnpm josh git -y "<title> #<N>"`, run round 2 beside CI, then
 `pnpm josh followup` and `pnpm josh run:tail <N>`). Issue plan comments are written in the session language (`JOSH_SESSION_LANG`,
 default `ja`). Before implementing, run `git switch main && git pull`, then `pnpm josh latest:scope`
@@ -49,10 +49,10 @@ completion notification, then merges; if blockers are found it exits non-zero
 ## The `fullrun new` step list
 
 `kickoff new` + `fullrun #N` in one run. Steps: (1) Derive an English title, or use the provided one.
-**(1a) Run `pnpm josh issue:scout "<title>" [--body "<summary>"]` before creating the Issue** — a
-candidate that covers the same work stops the run rather than filing a second Issue (`SKILL.md` → §2e).
-(2) Create Issue: `gh api repos/{owner}/{repo}/issues -f title="<title>" -f 'labels[]=depth:<n>' -F
-body=@<body-file>` (per `prompts/collaboration-workflow/issue-template.md`). Capture `<N>`. (3) Add
+(2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>` (per
+`prompts/collaboration-workflow/issue-template.md`) — its duplicate scan runs first, and a candidate
+that covers the same work stops the run rather than filing a second Issue (`SKILL.md` → §2e). Capture
+`<N>`. (3) Add
 `in-progress` (as above). (4) Post the agreed plan in the session language: fill the body if blank,
 otherwise add a comment. (5) If the working tree already has staged or modified files,
 `git stash push -m "fullrun new: pre-existing changes"` first. (6) `git switch main && git pull`. (7)
@@ -65,8 +65,8 @@ round 1's fixes are in and before the commit. (10) Where the tree was edited aft
 started, re-run `pnpm josh gate` and join it. (11) `pnpm josh git -y "<title> #<N>"` — the pull request
 opens here, between the two rounds. (11a) Run the **second round** now beside the CI, where (9a)
 answered `required` (brief `pnpm josh review:brief --round 2`); a finding it fixes in place is pushed
-before its gate. (12) File whatever the review round cap routed to branch 2, run `pnpm josh epic:bundle
-<new>` on each, and where (9a) answered `skip` record the skip on the Issue. (13) **Where no second
+before its gate. (12) File whatever the review round cap routed to branch 2 with `pnpm josh issue:file`
+(it runs `epic:bundle` on each), and where (9a) answered `skip` record the skip on the Issue. (13) **Where no second
 round was due** (9a `skip`), fold steps (10)–(13) and the release bookkeeping into one call — `pnpm josh
 ship "<title> #<N>" --notify-message "..."` (gate → commit/push/PR → the CI-wait `followup` → `run:tail`,
 stopping at the first failed step; joshuafolkken/kit#2398); **where a second round ran**, the PR opened

package/.claude/skills/workflow-commands/halfrun.md

@@ -1,6 +1,6 @@
 # `halfrun` — the manifest (implement + verify, stop before commit)
 
-When this run files a new Issue, run `pnpm josh issue:lint <body-file>` and apply every label in its `labels:` answer at creation; `prompts/collaboration-workflow/issue-template.md` is the single source for this classification. Keep the existing `depth` and `route` labels.
+When this run files a new Issue, file it with `pnpm josh issue:file`, which lints the body and applies the classification labels it declares beside the `--depth` and `--route` labels; `prompts/collaboration-workflow/issue-template.md` is the single source for this classification.
 
 `halfrun` sits between `kickoff` (plan only) and `fullrun` (full execution with auto-merge). It
 implements the change and runs the full verification gate, then **stops before commit** — nothing is
@@ -56,10 +56,9 @@ back with fixes, treat each as a new round: implement, re-run `pnpm josh gate`,
 `confirmation` Telegram, stop again.
 
 `halfrun new` or `halfrun new "<title>"`: `kickoff new` + `halfrun #<N>` (no Issue exists yet). Steps
-mirror `fullrun new` (1)–(8): derive an English title (or use the provided one) → **run `pnpm josh
-issue:scout "<title>" [--body "<summary>"]` before creating the Issue** (`SKILL.md` → §2e) → create the
-Issue (`gh api repos/{owner}/{repo}/issues -f title="<title>" -f 'labels[]=depth:<n>' -F body=@<body-file>`,
-body per `prompts/collaboration-workflow/issue-template.md`) → add `in-progress` → post the agreed plan → stash
+mirror `fullrun new` (1)–(8): derive an English title (or use the provided one) → create the Issue
+(`pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>`, body per
+`prompts/collaboration-workflow/issue-template.md`; its duplicate scan is read per `SKILL.md` → §2e) → add `in-progress` → post the agreed plan → stash
 any pre-existing changes with `git stash push -m "halfrun new: pre-existing changes"`, popped by
 message with `pnpm josh stash:pop "halfrun new: pre-existing changes"`, never a positional `git stash pop` →
 `git switch main && git pull` → `pnpm josh latest:scope` → implement → run the gate (as above, `pnpm

package/.claude/skills/workflow-commands/issue-comments.md

@@ -104,6 +104,6 @@ never the comment text.
 
 **`pnpm josh rule:guard` refuses the body-only read** and hands over the reissue and the conflict rule
 at the moment they bind (`prompts/collaboration-workflow/rule-delivery.md`,
-`scripts/rules/delivered-rules.test.ts`). The refusal reaches Claude Code alone and fires once per run,
+`scripts/rules/delivered-rules.test.ts`). The refusal reaches Claude Code alone and repeats until the comments are read,
 so **this file is the rule and the hook is what makes it hard to walk past** — a session that runs
 no hooks still owes the read.

package/.claude/skills/workflow-commands/issue-scout.md

@@ -1,12 +1,13 @@
 # Filing an Issue — `SKILL.md` §2e's procedure
 
-Read this file when an Issue title exists and before the `gh api … issues` call that files it. Every
-filing asks whether the work already exists and which epic owns it; one command answers both:
+Read this file when an Issue title exists and before the `pnpm josh issue:file` call that files it.
+Every filing asks whether the work already exists and which epic owns it; the command runs the
+`issue:scout` scan on the title and body first and holds the filing until every printed candidate is
+named in `--distinct`:
 
 ```bash
-pnpm josh issue:scout "<title>"                                   # alias: josh isc
-pnpm josh issue:scout "<title>" --body "<one-line summary, citing #N where the work follows one>"
-pnpm josh issue:scout "<title>" --body-file <complete-draft.md>
+pnpm josh issue:file "<title>" --body-file <complete-draft.md> --depth <n> [--route <route>]
+pnpm josh issue:file "<title>" --body-file <complete-draft.md> --depth <n> --distinct 2801,2795
 ```
 
 - **`Duplicates:` is read, not skimmed.** Open each candidate and apply `issue-fold-existing.md`
@@ -14,32 +15,30 @@ pnpm josh issue:scout "<title>" --body-file <complete-draft.md>
   Telegram and "Please run `fullrun #<existing>` to execute this Issue." A compatible addition follows
   that file's fold path; a separate deliverable follows the ordinary filing path. A title match alone
   never authorizes an edit.
+- **`--distinct` records that each candidate was read.** Reissue the call listing every candidate you
+  read and judged separate; never list one you have not read.
 - **A candidate marked `(closed)` is a different answer.** The scan covers what closed recently as
   well as what is open, because the work most likely to be filed twice is the work that just finished.
   A closed candidate that covers the same work means **the work is already done** — so there is nothing
   to run. Verify it against the merged code, then take the exit in `issue-comments.md` → "When the work
   turns out to be already merged". A closed candidate that does *not* cover the work is noted in one
-  line and the filing carries on.
+  line, named in `--distinct`, and the filing carries on.
 - **`none` is an answer.** The command reports no candidate rather than the closest miss.
 - **`Epic:` front-loads the placement.** Its recommendation is `epic:bundle`'s, which makes
   `add_to_epic` / `create_epic` Tier A and `ask` a stop, in exactly the reading `SKILL.md` → §2a's
   `into <target>` suffix would have given by hand. Where the user typed `into <target>`, that naming wins.
-- **`Epic: not asked` is not `Epic: none`.** The epic half decides from the issue numbers the summary
-  names, so a title-only call gives it nothing. **Pass `--body` whenever the work follows an existing
-  Issue** — one line citing `#N` is enough, and naming the epic itself (`part of epic #<E>`) is
-  answered with that epic.
-- **It does not replace `epic:bundle`, which still runs after the filing.** This one answers about an
-  Issue that does not exist yet, from a title; that one answers about an Issue that does. Both calls
-  happen — the scout before the `issues` call, `epic:bundle` after it.
-- **Every filing route runs it, not only a `new` entry point, and `pnpm josh rule:guard` refuses a
-  filing the run has not scouted** (`prompts/collaboration-workflow/rule-delivery.md`) — the trigger is
-  the `gh api … issues` call, never which keyword started the run, so `SKILL.md` → §2d's prerequisite,
-  §2i's observation and the review round cap's branch-2 filing all go through it.
-- **A `#N` entry point does not run it *for the Issue it was handed*.** `fullrun #N` / `halfrun #N` /
+- **`Epic: not asked` is not `Epic: none`.** The epic half decides from the issue numbers the body
+  names. **Cite `#N` in the body whenever the work follows an existing Issue** — one line is enough,
+  and naming the epic itself (`part of epic #<E>`) is answered with that epic.
+- **`epic:bundle` then runs on the new Issue, in the same call.** Act on its printed answer; a `⚠`
+  means rerun `pnpm josh epic:bundle <N>` — the Issue exists, so never refile.
+- **Every filing route goes through it** — §2d's prerequisite, §2i's observation and the review round
+  cap's branch-2 filing alike; the guard refuses any other filing call
+  (`prompts/collaboration-workflow/rule-delivery.md`).
+- **A `#N` entry point does not file *the Issue it was handed*.** `fullrun #N` / `halfrun #N` /
   `kickoff #N` are given an Issue that already exists. That says nothing about an Issue such a run goes
   on to file later, which the bullet above covers.
-- **The split path files each child through the same step.** The epic itself is not scouted: it is
-  created over children that were, and `epic:bundle` places it afterwards.
+- **The split path files each child through the same command.** The epic is created with
+  `pnpm josh epic` over children that were scanned.
 
-Full behavior, the thresholds and why the duplicate half compares titles rather than bodies:
-`docs/josh-commands.md` → "`josh issue:scout`".
+Full behavior: `docs/josh-commands.md` → "`josh issue:file`" and "`josh issue:scout`".

package/.claude/skills/workflow-commands/kickoff.md

@@ -44,16 +44,15 @@ split is found.
 - `kickoff new` or `kickoff new "<title>"`: No Issue exists yet. Steps: (0) **Scope assessment** per
   `split-assessment.md`. If multiple → the **multi-issue split path**; if single → the **single-issue
   path**. **Single-issue path**: (1) Derive an English title from the conversation, or use the provided
-  title. **(1a) Run `pnpm josh issue:scout "<title>" [--body "<summary>"]` before creating the Issue** —
-  a candidate that covers the same work stops the run rather than filing a second Issue (`SKILL.md` →
-  §2e). (2) Create Issue: `gh api repos/{owner}/{repo}/issues -f title="<title>" -f 'labels[]=depth:<n>'
-  -F body=@<body-file>` (body per `prompts/collaboration-workflow/issue-template.md`). Capture `<N>`. (3)
+  title. (2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>` (body
+  per `prompts/collaboration-workflow/issue-template.md`) — its duplicate scan runs first, and a
+  candidate that covers the same work stops the run rather than filing a second Issue (`SKILL.md` →
+  §2e). Capture `<N>`. (3)
   Post the plan in the session language, using the same body/comment logic as `kickoff #<N>`. (4) Send
   Telegram notification. (5) **Stop** — do not implement. **Multi-issue split path**: (1) For each
-  independent deliverable, derive a focused English title, **run `pnpm josh issue:scout "<sub-title>"`
-  on it** (`SKILL.md` → §2e), and create a separate Issue with the `route:split` label: `gh api
-  repos/{owner}/{repo}/issues -f title="<sub-title>" -f 'labels[]=route:split' -f 'labels[]=depth:<n>'
-  -F body=@<body-file>`. Capture each Issue number. **When the split is filed into a repository other than
+  independent deliverable, derive a focused English title and create a separate Issue with the
+  `route:split` label (its duplicate scan is read per `SKILL.md` → §2e): `pnpm josh issue:file
+  "<sub-title>" --body-file <body-file> --depth <n> --route split`. Capture each Issue number. **When the split is filed into a repository other than
   the one this session is running in**, every child body gets the `## Origin` backlink described in the
   cross-package rule the AI documents keep resident, the epic body carries the same link as prose or a
   plain bullet (never as a checkbox row, which would disable its auto-close), and the originating Issue
@@ -81,4 +80,4 @@ split is found.
   creation call. (3) Send Telegram notification listing all created issues. (4) Present the command
   `backlogrun #<E> --only`. (5) **Stop** — do not implement.
 
-Before filing, run `pnpm josh issue:lint <body-file>` and apply every label in its `labels:` answer at creation, following `prompts/collaboration-workflow/issue-template.md` for classification.
+`pnpm josh issue:file` lints the body and applies the classification labels it declares, following `prompts/collaboration-workflow/issue-template.md` for classification (`docs/josh-commands.md` → `josh issue:file`).

package/.claude/skills/workflow-commands/observation-filing.md

@@ -20,17 +20,16 @@ on is dropped rather than filed.
 
 **The filing ceilings still apply.** Count this filing in the ten-Issue limit for the run. An
 observation is discretionary, so above 30 open Issues in the target repository, close one first or do
-not file (`prompts/collaboration-workflow/wip-cap.md`). Before the `gh api … issues` call, run
-`pnpm josh issue:scout "<title>"` (`issue-scout.md`). When it is the second filing of the run, run
+not file (`prompts/collaboration-workflow/wip-cap.md`). File it with `pnpm josh issue:file`
+(`issue-scout.md`), which lints the body against `prompts/collaboration-workflow/issue-template.md`,
+applies the classification labels it declares, runs the duplicate scan, and runs `epic:bundle` on the
+new Issue so it is offered by its epic; an `auto-ok` epic adds it to the backlog pool
+(`backlogrun-steps.md` → "What one invocation approves"). When it is the second filing of the run, run
 `pnpm josh issue:fold` first; the guard refuses that filing without the fold
-(`split-assessment.md` → "The same two questions decide the filing-time fold"). After filing, run
-`pnpm josh epic:bundle <new>` so the Issue is offered by its epic; an `auto-ok` epic adds it to the
-backlog pool (`backlogrun-steps.md` → "What one invocation approves").
+(`split-assessment.md` → "The same two questions decide the filing-time fold").
 
 The detail below is read at the filing decision, and the marker suite pins the rules here.
 
-Before filing an observation, run `pnpm josh issue:lint <body-file>` and apply every label in its `labels:` answer at creation; `prompts/collaboration-workflow/issue-template.md` is the single source. Keep the depth label.
-
 ### The depth test — a discretionary filing cites the product work it blocked
 
 **A run that has just spent an hour inside the workflow tooling files findings about the workflow
@@ -53,11 +52,11 @@ it — read off the subject rather than judged**:
 single source**, and a label description that paraphrased it would be a second copy of the rule.
 **Every filing route applies one**, this route and the other three of §2d's table alike: a `new`
 entry point, a `route:tier-a` prerequisite, a `route:interrupt`, a split child and a review round
-cap's branch-2 filing all pass through a `gh api … issues` call, and the depth label goes in it
-beside whatever `route:` label that call already carries.
+cap's branch-2 filing all pass through a `pnpm josh issue:file` call, and the depth goes in it as
+`--depth <n>` beside whatever `--route` that call already carries.
 
 ```bash
-gh api repos/{owner}/{repo}/issues -f title="<title>" -f 'labels[]=depth:1' -F body=@<body-file>
+pnpm josh issue:file "<title>" --body-file <body-file> --depth 1
 gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=depth:1'   # an Issue already filed
 ```
 

package/.claude/skills/workflow-commands/prerequisite.md

@@ -25,16 +25,17 @@ stays countable by filing route afterwards. **This paragraph belongs to the prer
 the table** — the label means a filing the run is *blocked by*, so the observation row carries no
 `route:` label of its own (§2i):
 
-Before that call, run `pnpm josh issue:lint <body-file>` and apply every label in its `labels:` answer at creation; `prompts/collaboration-workflow/issue-template.md` is the single source. Keep `route:tier-a` and `depth`.
-
 ```bash
-gh api repos/{owner}/{repo}/issues -f title="<title>" -f 'labels[]=route:tier-a' -f 'labels[]=depth:<n>' -F body=@<body-file>
+pnpm josh issue:file "<title>" --body-file <body-file> --depth <n> --route tier-a
 ```
 
+The command lints the body against `prompts/collaboration-workflow/issue-template.md`, applies the
+classification labels it declares, and runs the duplicate scan and `epic:bundle` itself
+(`docs/josh-commands.md` → `josh issue:file`).
+
 Every "file the prerequisite" below means that labelled filing, and it always happens **first**: the
-steps after it name a number that does not exist until it is. **`pnpm josh issue:scout "<title>"` goes
-in front of that call, exactly as it does for a `new` entry** (§2e): a filing made mid-run is the one
-most likely to duplicate something.
+steps after it name a number that does not exist until it is. **Its duplicate scan is read exactly as
+it is for a `new` entry** (§2e): a filing made mid-run is the one most likely to duplicate something.
 
 **Each entry point's own branch stays in that entry's file:**
 

package/.claude/skills/workflow-commands/retrospective.md

@@ -53,11 +53,11 @@ ceiling on what may be recorded. **File nothing when nothing passes** — a run
 improvement worth carrying files zero Issues, and that is what makes the "file → drain → file again"
 loop converge.
 
-**Exclude what is already filed or already done, through the existing scout** (`SKILL.md` → §2e). Run
-`pnpm josh issue:scout "<title>"` before each `gh api … issues` call: an **open** candidate covering the
-same work means do not file it, and a `(closed)` candidate covering it means the work is already merged.
-Neither exclusion is a new mechanism. After filing, `pnpm josh epic:bundle <new>` places each Issue, as
-after any filing.
+**Exclude what is already filed or already done, through the existing scout** (`SKILL.md` → §2e). File
+each with `pnpm josh issue:file`, which runs the scout before creating anything: an **open** candidate
+covering the same work means do not file it, and a `(closed)` candidate covering it means the work is
+already merged. Neither exclusion is a new mechanism. The same call runs `epic:bundle` on each new
+Issue, as after any filing.
 
 ## `auto-ok`, and closing the step
 

package/.claude/skills/workflow-commands/rule-residency.md

@@ -165,8 +165,8 @@ again (joshuafolkken/kit#1525).
 - **The Issue's comments** — `pnpm josh rule:guard` refuses the `Bash` call that reads an Issue's
   body without them (`gh issue view <N>`, or a `GET` of a path ending `…/issues/<N>`) and hands over
   the reissue that carries them plus the rule for a comment that contradicts the body. It is the one
-  row whose trigger `batch:guard` also considers, so it stands aside on that guard's turn and fires
-  on the reissue. §2g is the procedure and stays here, because a session that runs no hooks still
+  row whose trigger `batch:guard` also considers, yet it refuses on that guard's turn too, since it
+  repeats until the comments are read. §2g is the procedure and stays here, because a session that runs no hooks still
   owes the read (`prompts/collaboration-workflow/rule-delivery.md`,
   `scripts/rules/delivered-rules.test.ts`).
 - **The prohibition on putting a body inside shell double quotes** — `pnpm josh rule:guard` refuses

package/.claude/skills/workflow-commands/split-assessment.md

@@ -31,7 +31,7 @@ same conjunction**: separability, and whether the whole clearly exceeds one gate
 `pnpm josh split:assess`, called not recomputed, and `separate` needs both halves exactly as `split`
 does. **There is no second criterion.** §2i's observation, the review round cap's branch 2 and §2d's
 prerequisite each route a second filing through it, delivered by `pnpm josh rule:guard` at the run's
-second `gh api … issues` call, never the first.
+second `pnpm josh issue:file` call, never the first.
 
 ## Why the default is not to split
 
@@ -88,8 +88,9 @@ the whole point of one definition is that where the split was noticed cannot cha
 The epic is the non-closing home for the split rationale. A comment on the first child is buried the
 moment that child merges and closes.
 
-**Each split child is filed with the `route:split` label**, so the backlog's composition stays
-countable by filing route rather than by grepping issue bodies.
+**Each split child is filed with the `route:split` label** —
+`pnpm josh issue:file "<sub-title>" --body-file <body-file> --depth <n> --route split` — so the
+backlog's composition stays countable by filing route rather than by grepping issue bodies.
 
 ## Promote, or create a new epic
 

package/.claude/skills/workflow-commands/target-repository.md

@@ -37,12 +37,13 @@ backlogrun joshuafolkken/kit#858 --only
   explicit instruction that rule requires. **Send a `confirmation` Telegram and stop** — nothing has
   been produced yet, so there is no finding to record and no draft to prepare.
 - **No prefix leaves the behavior exactly as it was** — the target is the session's repository.
-- **`kickoff` needs no checkout**: name the target repository in the path of every `gh api` call and
-  never clone. The one exception is the split path's epic, since `pnpm josh epic` only writes the
-  repository it runs in — run it in that repository's checkout, or fall back to `gh api
-  repos/<owner/repo>/labels …` followed by `gh api repos/<owner/repo>/issues -f title="<epic-title>" -f
-  'labels[]=epic' -F body=@<body-file>`, and report that `epic:check` could not be run. The promote arm has
-  no such fallback: with no checkout there, file the children and stop.
+- **`kickoff` needs no checkout**: name the target repository with `--repo <owner/repo>` on every
+  `pnpm josh issue:file` call and in the path of every `gh api` call, and never clone. The one exception
+  is the split path's epic, since `pnpm josh epic` only writes the repository it runs in — run it in
+  that repository's checkout. With no checkout there, file the children, report that the epic could
+  not be created, and stop — a hand-built `gh api …/issues` filing of the epic is refused by the
+  `direct-filing` guard, and `pnpm josh issue:file` lints an epic body against the Issue template. The
+  promote arm stops the same way.
 - **The implementing entries require a checkout and never create one — when the target is another
   repository.** A prefix naming the session's own repository changes nothing (`fullrun kit#412` in the
   kit checkout behaves exactly as `fullrun #412`). Otherwise resolve the checkout from `pnpm josh

package/dist/hooks/batch-guard.js

@@ -9,10 +9,10 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-NXL3SBXY.js";
-import "./chunk-2K52BRWV.js";
-import "./chunk-KQG4776P.js";
-import "./chunk-ZPLXLJ7O.js";
+} from "./chunk-P3UX7SFN.js";
+import "./chunk-ASUZGZFT.js";
+import "./chunk-APVOACVT.js";
+import "./chunk-47SPMGOD.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/{chunk-ZPLXLJ7O.js → chunk-47SPMGOD.js}

@@ -290,6 +290,16 @@ var ISSUE_COMMANDS = {
     description: "Post one comment to an issue from a file, so no shell expands the body",
     category: "AI tools",
     reference: ["<issue> --body <text> | --body-file <path>", "automation", ["network"]]
+  },
+  "issue:file": {
+    script: "scripts/issue/issue-file-cli.ts",
+    description: "File an Issue with every filing step: lint, Origin, duplicate scout, labels, then epic:bundle",
+    category: "AI tools",
+    reference: [
+      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>]",
+      "automation",
+      ["network"]
+    ]
   }
 };
 
@@ -1068,7 +1078,11 @@ var PROJECT_COMMANDS = {
     script: "scripts/propagate/propagate.ts",
     description: "Carry the published release into every consumer repository next to this one",
     category: "Project",
-    reference: ["[--dry-run] [--skip-publish-wait]", "maintainer", ["files", "network"]]
+    reference: [
+      "[--dry-run] [--skip-publish-wait] [--target <repo>]",
+      "maintainer",
+      ["files", "network"]
+    ]
   },
   adopt: {
     script: "scripts/adopt/adopt.ts",
@@ -1306,6 +1320,7 @@ var ALIASES = {
   ird: "issue:read",
   ist: "issue:state",
   isc: "issue:scout",
+  ifl: "issue:file",
   isf: "issue:fold",
   isfe: "issue:fold-existing",
   dfr: "defect:rate",

package/dist/hooks/{chunk-BVMSPG3M.js → chunk-5JX6HXDX.js}

@@ -1,12 +1,12 @@
 import {
   investigation_reads
-} from "./chunk-F6OM6SIG.js";
+} from "./chunk-RFPHKU7C.js";
 import {
   lane_guard_policy
-} from "./chunk-2K52BRWV.js";
+} from "./chunk-ASUZGZFT.js";
 import {
   hook_decision
-} from "./chunk-KQG4776P.js";
+} from "./chunk-APVOACVT.js";
 
 // scripts/delegation/investigation-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-KQG4776P.js → chunk-APVOACVT.js}

@@ -3,7 +3,7 @@ import {
   stamp_file,
   time_density_hook,
   time_hook_transcript
-} from "./chunk-ZPLXLJ7O.js";
+} from "./chunk-47SPMGOD.js";
 import {
   josh_environment_file
 } from "./chunk-WPALEIRX.js";

package/dist/hooks/{chunk-2K52BRWV.js → chunk-ASUZGZFT.js}

@@ -1,13 +1,13 @@
 import {
   lane_child_marker
-} from "./chunk-KQG4776P.js";
+} from "./chunk-APVOACVT.js";
 import {
   time_bundle_call,
   time_format,
   time_round_trips,
   time_spans,
   time_transcript_line
-} from "./chunk-ZPLXLJ7O.js";
+} from "./chunk-47SPMGOD.js";
 
 // scripts/lane/lane-guard-policy.ts
 var DEFAULT_MODE = "refuse";

package/dist/hooks/{chunk-CRGJTD6E.js → chunk-ERXMJJOV.js}

@@ -5,7 +5,7 @@ import {
 import {
   ESLINT_EDIT_CACHE_FLAGS,
   time_density_hook
-} from "./chunk-ZPLXLJ7O.js";
+} from "./chunk-47SPMGOD.js";
 
 // scripts/hooks/format-edited-file.ts
 import { existsSync as existsSync2 } from "node:fs";