@joshuafolkken/kit 1.1035.0 → 1.1050.0

package/.claude/skills/workflow-commands/pre-gate-cut.md

@@ -7,7 +7,7 @@ from the gate onward. Rationale: `docs/maintainers/pre-gate-cut-rationale.md`
 
 This file is the single source of the boundary. `run:cut` takes it, and `run:cut --resume` is the
 check a fresh process makes at its own entry. **A second boundary is added below** — the
-implementation-phase cut (joshuafolkken/kit#1933), at a context threshold _during_ implementation.
+implementation-phase cut, at a context threshold _during_ implementation.
 Everything through "What is carried" describes the pre-gate cut; the later section states only what
 differs.
 
@@ -23,7 +23,7 @@ verification the fresh process runs on the tree.
 
 The cut is for a **detached** `fullrun` a lane dispatched; a person's interactive `fullrun` never
 relaunches itself. A dispatched child is told apart **mechanically, by a mark the dispatch sets** — never
-by the model reading the shape of its own prompt (joshuafolkken/kit#1904).
+by the model reading the shape of its own prompt.
 
 ### The dispatch mark
 
@@ -44,16 +44,15 @@ checkout, a cut in a lane.
 
 ## Taking the cut
 
-**The order is fixed in the chain** (joshuafolkken/kit#2177): `chain-rule.md` step 1 issues
+**The order is fixed in the chain**: `chain-rule.md` step 1 issues
 `pnpm josh run:cut <N>` after `pnpm josh main:merge`, before the scoped pair and the gate. **The command
-is issued unconditionally**; `run:cut` itself decides whether the cut is warranted
-(joshuafolkken/kit#2312), so a short lane with nothing to drop is answered `under-threshold` and walks on
+is issued unconditionally**; `run:cut` itself decides whether the cut is warranted, so a short lane with nothing to drop is answered `under-threshold` and walks on
 to the gate rather than relaunching.
 
 At the pre-gate boundary, issue:
 
 ```bash
-pnpm josh run:cut <N>          # alias: josh rct
+pnpm josh run:cut <N>
 ```
 
 - `cut` (0) — record written and handed to the lane's launch owner (OpenAI supervisor starts the
@@ -72,25 +71,25 @@ the current process to carry the run on itself.
 
 ### The gate refuses until the cut has been taken (joshuafolkken/kit#1864)
 
-**This step was carried as prose and fired exactly never.** Across six measured lane children the cut
-was taken **0 times**. So `pnpm josh rule:guard` **refuses `pnpm josh gate`** while this checkout is a
-lane and no cut record is carried, handing back the command above. With the ordered step above the
-refusal is insurance, not the primary trigger. Rationale:
+**This step was carried as prose and fired exactly never.** In measured lane children the cut was taken **0 times**, so
+`pnpm josh rule:guard` **refuses `pnpm josh gate`** while this checkout is a lane and no cut record is
+carried, handing back the command above. Rationale:
 `docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
 
 - **It fires for a marked child and nowhere else**: the working directory is a lane —
   `<lane root>/<issue number>` — **and** `JOSH_LANE_CHILD` names that same issue. An interactive
   `fullrun` carries no mark and runs its gate untouched. `run:cut` uses an open-lane lookup instead, so
   the guard and the command need not agree byte for byte.
-- **It fires only when the recent-window context warrants a cut** (joshuafolkken/kit#2312). The guard
+- **It fires only when the recent-window context warrants a cut**. The guard
   reads the same `cost_cli.session_verdict` `run:cut` reads, so an `under`-threshold lane is let through
   to the gate rather than refused.
 - **It is silent once the cut is carried**, so the resumed process goes straight to the gate.
-- **It fires once per run.** A refusal that repeated would wedge the runs that obeyed.
+- **It fires once per run.**
 - **`--resume`, `--end` and `--json` do not count as taking the cut.**
 
 The row, its trigger and the enumeration it joins are
-`prompts/collaboration-workflow/rule-delivery.md`; `scripts/rules/pre-gate-cut.test.ts` pins it.
+`prompts/collaboration-workflow/rule-delivery.md`. The suites that pin this and the three guards below:
+`docs/maintainers/pre-gate-cut-rationale.md` → "Which suites pin each guard".
 
 ## Resuming — the fresh process's entry check
 
@@ -106,8 +105,7 @@ pnpm josh run:cut --resume <N>
 - `resume` (0) — a declared pre-gate cut whose tree matches was verified and taken over. **Skip the
   title, the plan, the fresh hold claim and the implementation**; re-read the issue body and comments
   for the plan and the recorded decisions, then go straight to `pnpm josh gate`.
-- `resume-impl` (0) — like `resume`, but the cut was taken **during** implementation
-  (joshuafolkken/kit#1933). Skip the title, the plan, the fresh hold claim and the split assessment,
+- `resume-impl` (0) — like `resume`, but the cut was taken **during** implementation. Skip the title, the plan, the fresh hold claim and the split assessment,
   re-read the plan, then **continue implementation** — do **not** go straight to the gate.
 - `handed-off` (0) — a successor has already adopted this cut, `is_handed_off` is spent
   (joshuafolkken/kit#1935). This process was woken **after** its own cut. **End the turn quietly and do
@@ -154,7 +152,7 @@ decisions are read back from the issue. Rationale:
 
 ## The implementation-phase cut — a lane child cuts before the gate too
 
-The **implementation-phase cut** (joshuafolkken/kit#1933) caps the context accumulated _during_
+The **implementation-phase cut** caps the context accumulated _during_
 implementation — the child ends mid-implementation and a fresh one resumes the lane **back into
 implementation**.
 
@@ -162,15 +160,15 @@ implementation**.
 
 The guard below refuses on the same measurement the parent uses between children —
 `cost_verdict.per_request_cost`, read through `cost_cli.session_verdict` (the read-only form of
-`pnpm josh cost --cut`, joshuafolkken/kit#2312), single-sourced at `backlogrun-progress.md` → "The
+`pnpm josh cost --cut`), single-sourced at `backlogrun-progress.md` → "The
 hand-off". The parent's seam and the child's `run_cut.IMPLEMENTATION_CONTEXT_THRESHOLD` share the
 **135_000** `CONTEXT_CUT_THRESHOLD` (aliased so the tests cannot drift). No separate measurement is
 built for the lane child.
 
 ### It is a guard, fired at the edit that crosses the threshold (joshuafolkken/kit#2310)
 
-**This step was carried as prose and fired exactly never** — measured across five lanes, the cut fired
-**0 times** while 33.9% of their requests ran past 200,000 tokens. Rationale:
+**This step was carried as prose and fired exactly never** — the cut fired **0 times** while 33.9% of
+lane requests ran past 200,000 tokens. Rationale:
 `docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
 
 So `pnpm josh rule:guard` **refuses an `Edit` / `Write`** while this checkout is a dispatched lane child
@@ -185,7 +183,7 @@ crossing one successor.
 - **It fires for a marked child, or a run held outside a lane on a measured `over`**
   (joshuafolkken/kit#2760); a person's tree holds no run. Outside a lane `cut` relaunches nothing: keep
   the hold, send a `confirmation` Telegram naming `fullrun #<N>`, end the turn.
-- **It fires on every threshold crossing, not once per run** (joshuafolkken/kit#2385) — it re-asks on
+- **It fires on every threshold crossing, not once per run** — it re-asks on
   each over-threshold edit, including after a `busy` / `failed` / `unready` verdict.
 - **An edit reissued right after a refusal passes** — so a `busy` / `failed` cut cannot wedge the run:
   the reissue lands inside a short window and goes through, a genuinely new crossing past it refuses
@@ -196,8 +194,8 @@ crossing one successor.
 - **The verdict read is reused over a short window** — cached per checkout for a few seconds, so a
   turn's burst of edits shares one read.
 
-`scripts/rules/implementation-cut.ts` implements the trigger, `scripts/rules/implementation-cut.test.ts`
-pins it, and the row joins `prompts/collaboration-workflow/rule-delivery.md`. **A child that ended
+`scripts/rules/implementation-cut.ts` implements the trigger, and the row joins
+`prompts/collaboration-workflow/rule-delivery.md`. **A child that ended
 without cutting is still detected after the fact by `pnpm josh run:ending <N> --output <path>`**
 (joshuafolkken/kit#2139). **A single check (`lint:related` / `test:related`) is run after a batch of
 edits, not after each one.**
@@ -206,12 +204,10 @@ edits, not after each one.**
 
 **`CONTEXT_CUT_THRESHOLD` (135_000) is one value, and `cost_verdict.per_request_cost` — the one
 statistic the parent and the lane child both read — averages the most recent `RECENT_REQUEST_WINDOW`
-(10) requests, not the whole session** (joshuafolkken/kit#2295). The value is a derived break-even, not a
-chosen number (joshuafolkken/kit#2406): `scripts/cost-runtime/context-cut-payback.ts` computes it from a
-cut's one-time preamble rewrite (`POST_CUT_CONTEXT`, ~60_000 tokens — a cut carries a request from ~130k
-down to ~60k), the cache multipliers in `cost-pricing.ts`, and a 10-request horizon.
+(10) requests, not the whole session**. The value is computed by
+`scripts/cost-runtime/context-cut-payback.ts`, its single source.
 
-**The cut is conditional** (joshuafolkken/kit#2312): taken only when the recent-window per-request cost
+**The cut is conditional**: taken only when the recent-window per-request cost
 is over `CONTEXT_CUT_THRESHOLD` — the same statistic and threshold the implementation-phase cut reads, so
 no second threshold exists. Below it `run:cut` answers `under-threshold` and the gate runs uncut; the
 guard reads the same verdict and stays silent. An **unmeasurable** session is always cut.
@@ -227,8 +223,8 @@ cut is the same pattern one boundary earlier.
 ## A lane child records its park before it stops
 
 **A dispatched lane child records its park on the Issue before it stops for a decision**
-(joshuafolkken/kit#2034). A headless child's only route to ask a person is to park the Issue — measured
-on #2012 and #2011, whose questions reached only their final message. Rationale:
+(joshuafolkken/kit#2034). A headless child's only route to ask a person is to park the Issue (#2012,
+#2011). Rationale:
 `docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
 
 **The record, before the Telegram, is the park procedure exactly** — `needs-decision` plus a comment
@@ -255,21 +251,22 @@ lane child — the mark `JOSH_LANE_CHILD` names this lane's own issue — handin
   on the compliant path is safe.
 
 This section is the single source of the lane-child park rule; `scripts/rules/lane-park.ts` implements
-the trigger, `scripts/rules/lane-park.test.ts` pins it, and the row joins the enumeration in
+the trigger, and the row joins the enumeration in
 `prompts/collaboration-workflow/rule-delivery.md`.
 
 ### The interactive ask is refused one call earlier
 
 (joshuafolkken/kit#2201) The harness refuses an interactive ask in a headless session by **ending the
-turn**, so the notify guard never fires — #2178's child did exactly that, the failure
-joshuafolkken/kit#2034 set out to prevent, one call upstream. So `pnpm josh rule:guard` **refuses
-`AskUserQuestion` for a marked lane child**; the deny returns to the model, and the instruction is to
-park the question. It fires on **every occurrence** and stays silent for a person working in a lane.
+turn**, so the notify guard never fires (#2178 — the failure joshuafolkken/kit#2034 set out to prevent,
+one call upstream). So `pnpm josh rule:guard` **refuses `AskUserQuestion` for a marked lane child**; the
+deny returns to the model, and the instruction is to park the question. It fires on **every occurrence**
+and stays silent for a person working in a lane. Rationale:
+`docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
 
 **A child that slips past it is still recoverable** — `pnpm josh run:ending` lifts the refused ask out
 of the exit record's `permission_denials` into the `abandoned` verdict's park basis, so the parent puts
-it into the park comment. `scripts/rules/lane-interactive-ask.ts` implements the trigger,
-`scripts/rules/lane-interactive-ask.test.ts` pins it, and `scripts/agent/interactive-ask.ts` is the
+it into the park comment. `scripts/rules/lane-interactive-ask.ts` implements the trigger, and
+`scripts/agent/interactive-ask.ts` is the
 shared extractor the guard and `run:ending` both read.
 
 This file is the single source of the rule.

package/.claude/skills/workflow-commands/working-tree-hold.md

@@ -11,9 +11,9 @@ a `new` entry files its Issue**, because a run stopped after the filing has alre
 artifact it should not have created.
 
 ```bash
-pnpm josh run:hold <N>        # a `#N` entry point ; alias: josh rh
+pnpm josh run:hold <N>        # a `#N` entry point
 pnpm josh run:hold            # a `new` entry point, before the issue exists
-pnpm josh run:release <N>     # that same run releasing its own record ; alias: josh rr
+pnpm josh run:release <N>     # that same run releasing its own record
 pnpm josh run:release         # the bare form releases the unnumbered run's own record
 pnpm josh run:release --force # a record left behind by a run that has ended
 ```

package/.github/workflows/auto-tag.yml

@@ -9,6 +9,7 @@ jobs:
     name: Create Git Tag if Version Changed
     runs-on: ubuntu-latest
     permissions:
+      actions: write
       contents: write
     steps:
       - name: Checkout code
@@ -109,3 +110,23 @@ jobs:
         with:
           event-type: new-tag-created
           client-payload: '{"tag": "${{ steps.create_tag.outputs.tag }}"}'
+
+      # A publish workflow run on the tag ref records the tag's commit in npm provenance; a
+      # repository_dispatch run records the default branch head, which may already be past the tag.
+      # A publish.yml that still listens for new-tag-created is left to the dispatch above, so one
+      # release never starts two publish runs. This step runs after that dispatch so its failure
+      # cannot keep the dispatch from reaching production.yml.
+      - name: Start publish workflow on the tag
+        if: steps.create_tag.outputs.completed == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          TAG: ${{ steps.create_tag.outputs.tag }}
+        run: |
+          WORKFLOW=.github/workflows/publish.yml
+          if [ -f "$WORKFLOW" ] && grep -Eq '^[[:space:]]*workflow_dispatch:' "$WORKFLOW" && ! grep -q 'new-tag-created' "$WORKFLOW"; then
+            gh workflow run publish.yml --ref "$TAG"
+            echo "✅ Started publish.yml on $TAG"
+          else
+            echo "ℹ️ publish.yml is not a workflow_dispatch-only publisher, skipping"
+          fi

package/.github/workflows/publish.yml

@@ -1,12 +1,15 @@
 name: Publish
-run-name: Publish ${{ github.event.client_payload.tag }}
+run-name: Publish ${{ github.ref_name }}
 
+# auto-tag.yml starts this workflow with `gh workflow run publish.yml --ref <tag>`, so the run's
+# commit and ref are the release tag's. npm provenance records the run's commit from the OIDC token,
+# and a repository_dispatch run is pinned to the default branch head, which can be newer than the tag.
 on:
-  repository_dispatch:
-    types: [new-tag-created]
+  workflow_dispatch:
 
 jobs:
   publish-github:
+    if: startsWith(github.ref, 'refs/tags/v')
     concurrency:
       group: package-publish
       queue: max
@@ -17,8 +20,6 @@ jobs:
       packages: write
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.client_payload.tag }}
 
       - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
@@ -55,6 +56,7 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   publish-npm:
+    if: startsWith(github.ref, 'refs/tags/v')
     concurrency:
       group: package-publish
       queue: max
@@ -65,8 +67,6 @@ jobs:
       id-token: write
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.client_payload.tag }}
 
       - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
@@ -106,7 +106,7 @@ jobs:
       contents: write
     uses: ./.github/workflows/production.yml
     with:
-      tag: ${{ github.event.client_payload.tag }}
+      tag: ${{ github.ref_name }}
 
   create-release:
     needs: [publish-github, publish-npm, update-production]
@@ -118,7 +118,6 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
-          ref: ${{ github.event.client_payload.tag }}
           fetch-depth: 0
 
       - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
@@ -143,4 +142,4 @@ jobs:
         run: pnpm exec tsx scripts/release/github-release-cli.ts
         env:
           GH_TOKEN: ${{ github.token }}
-          RELEASE_TAG: ${{ github.event.client_payload.tag }}
+          RELEASE_TAG: ${{ github.ref_name }}

package/dist/hooks/batch-guard.js

@@ -9,10 +9,10 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-KG6PZD72.js";
-import "./chunk-ZXNE6NY3.js";
-import "./chunk-HOYJU5RM.js";
-import "./chunk-GLBDBJOK.js";
+} from "./chunk-GQ7KP45M.js";
+import "./chunk-NJQOBE6L.js";
+import "./chunk-WQ4OSBSS.js";
+import "./chunk-7VPDUBRN.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/{chunk-HU66PWWL.js → chunk-5BK3K7V4.js}

@@ -21,6 +21,7 @@ import {
   git_gh_exec,
   has_any_label,
   has_stderr_field,
+  issue_cite,
   lane_background,
   lane_park,
   lane_registry,
@@ -31,37 +32,38 @@ import {
   repo_party,
   run_carry,
   run_cut,
+  run_headless,
   run_hold,
   run_progress_clock,
   run_tail,
   run_watcher_guard,
   shell_segments,
   tail_commands
-} from "./chunk-EIFCAJRB.js";
+} from "./chunk-RLDX5SOC.js";
 import {
   find_local_bin_upwards
 } from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-KG6PZD72.js";
+} from "./chunk-GQ7KP45M.js";
 import {
   investigation_refusal
-} from "./chunk-GJT4BNVE.js";
+} from "./chunk-DMQN45FN.js";
 import {
   duplicate_read_outcome
-} from "./chunk-Y27M6A7X.js";
+} from "./chunk-HJIISEAC.js";
 import {
   investigation_reads
-} from "./chunk-D67KVGGY.js";
+} from "./chunk-EJDX2TOB.js";
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-ZXNE6NY3.js";
+} from "./chunk-NJQOBE6L.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-HOYJU5RM.js";
+} from "./chunk-WQ4OSBSS.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -73,11 +75,7 @@ import {
   lane_paths,
   stamp_file,
   time_shell
-} from "./chunk-GLBDBJOK.js";
-
-// scripts/hooks/pretool-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+} from "./chunk-7VPDUBRN.js";
 
 // scripts/rules/direct-filing.ts
 var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api \u2026/issues` or `gh issue create`. The command runs every filing step in order \u2014 the duplicate scout, the body lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing into another repository, and `epic:bundle` after the create \u2014 so none of them is a step to remember. When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,\u2026>` for the ones that are separate deliverables. Reference: `docs/josh-commands.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
@@ -138,17 +136,19 @@ function next_state(previous, key, now_ms) {
   if (previous?.key === key) return previous;
   return { key, unchanged_since_ms: now_ms };
 }
-function format_child(child) {
+function format_child(child, cite) {
   const labels = child.labels.length > 0 ? child.labels.join(",") : "(no labels)";
-  return `#${child.issue} ${labels} PR:${child.pr_state}`;
+  return `${cite(child.issue)} ${labels} PR:${child.pr_state}`;
 }
-function format_children(children) {
+function format_children(children, repo) {
   if (children.length === 0) return NO_CHILD_YET;
-  return children.map((child) => format_child(child)).join(" \xB7 ");
+  const cite = issue_cite.citer(repo, new Map(children.map((child) => [child.issue, child.title])));
+  return children.map((child) => format_child(child, cite)).join(" \xB7 ");
 }
-function format_lanes(lanes) {
+function format_lanes(lanes, repo) {
   if (lanes.length === 0) return NO_LANES;
-  return lanes.map((lane) => `${lane.issue}:${lane.state}`).join(" ");
+  const cite = issue_cite.citer(repo, /* @__PURE__ */ new Map());
+  return lanes.map((lane) => `${cite(lane.issue)}:${lane.state}`).join(" ");
 }
 function format_record(record_age_ms) {
   return record_age_ms === void 0 ? "unread" : `+${format_minutes(record_age_ms)}`;
@@ -173,8 +173,8 @@ function format_line(observations, timing) {
     observed_at: format_observed_at(timing.now_ms),
     quiet: format_minutes(timing.now_ms - timing.quiet_since_ms),
     unchanged: format_minutes(timing.now_ms - timing.unchanged_since_ms),
-    children: format_children(observations.children),
-    lanes: format_lanes(observations.lanes),
+    children: format_children(observations.children, observations.repo),
+    lanes: format_lanes(observations.lanes, observations.repo),
     load: observations.load_average.toFixed(1),
     record: format_record(observations.record_age_ms),
     next: format_next_report(timing.now_ms, timing.interval_ms)
@@ -1182,8 +1182,8 @@ function labels_of(question) {
 }
 function render_question(question) {
   const labels = labels_of(question);
-  const text2 = question.question ?? UNKNOWN_QUESTION;
-  return labels.length === 0 ? text2 : `${text2} [${labels.join(OPTION_SEPARATOR)}]`;
+  const text = question.question ?? UNKNOWN_QUESTION;
+  return labels.length === 0 ? text : `${text} [${labels.join(OPTION_SEPARATOR)}]`;
 }
 function interactive_input(raw) {
   const denial = DENIAL_SCHEMA.safeParse(raw);
@@ -1860,8 +1860,8 @@ function is_rule_document(file_path) {
 }
 var LINK_TARGET = /\]\([^)]*\)/gu;
 var BARE_URL = /https?:\/\/\S+/gu;
-function prose_of(text2) {
-  return text2.replaceAll(LINK_TARGET, "]()").replaceAll(BARE_URL, "");
+function prose_of(text) {
+  return text.replaceAll(LINK_TARGET, "]()").replaceAll(BARE_URL, "");
 }
 var MIN_APPENDED_PROSE = 120;
 function adds_rule_prose(old_text, new_text) {
@@ -4719,7 +4719,7 @@ function usable_text(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
 function claude_progress(content) {
-  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text2) => text2.trim() !== "");
+  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text) => text.trim() !== "");
 }
 function claude_result(value, state) {
   const result = claude_result_event.decode(value);
@@ -5041,9 +5041,10 @@ function event_column(lane) {
   const state = run_liveness.describe_agent_state(lane.output);
   return state ?? "agent -";
 }
-function describe_lane(lane) {
+var PLAIN_CITE = issue_cite.citer(void 0, /* @__PURE__ */ new Map());
+function describe_lane(lane, cite = PLAIN_CITE) {
   return [
-    `#${lane.issue}`,
+    cite(lane.issue),
     `seat ${value_or_unknown(lane.seat)}`,
     `dev ${value_or_unknown(lane.development_port)}`,
     `preview ${value_or_unknown(lane.preview_port)}`,
@@ -5055,9 +5056,9 @@ function describe_lane(lane) {
     event_column(lane)
   ].join(COLUMN_SEPARATOR);
 }
-function describe_lanes(lanes) {
+function describe_lanes(lanes, cite = PLAIN_CITE) {
   if (lanes.length === 0) return NO_LANES2;
-  return lanes.map((lane) => describe_lane(lane)).join("\n");
+  return lanes.map((lane) => describe_lane(lane, cite)).join("\n");
 }
 function describe_ports(lane) {
   if (lane.seat === void 0) return "no lane seat could be read";
@@ -5304,7 +5305,7 @@ function to_labels(issue) {
 async function to_child(issue) {
   const number = String(issue.number);
   const child = await run_preflight.read_child_state(number);
-  return { issue: number, labels: to_labels(issue), pr_state: child.pr_state };
+  return { issue: number, title: issue.title, labels: to_labels(issue), pr_state: child.pr_state };
 }
 async function read_children(repo) {
   const read2 = await epic_busy.read_repository(repo);
@@ -5349,6 +5350,7 @@ async function read_observations(request) {
   if (children === void 0) return UNREADABLE_READ;
   if (children.length === 0 && !await has_run_started(lanes)) return IDLE_READ;
   const observations = {
+    repo: request.repo,
     children,
     lanes,
     load_average: loadavg()[FIRST_LOAD_AVERAGE] ?? 0,
@@ -5403,7 +5405,58 @@ async function watcher_hook_reason(raw_payload, now_ms = Date.now()) {
   if (transcript === void 0) return void 0;
   return await stale_reason(transcript, now_ms);
 }
-var run_watcher_hook = { SWITCH_ENV_KEY: SWITCH_ENV_KEY2, STAMP_PREFIX: STAMP_PREFIX2, watcher_hook_reason };
+var run_watcher_hook = { SWITCH_ENV_KEY: SWITCH_ENV_KEY2, STAMP_PREFIX: STAMP_PREFIX2, transcript_of, watcher_hook_reason };
+
+// scripts/run/run-parent-cut-hook.ts
+var SWITCH_ENV_KEY3 = "JOSH_PARENT_CUT_GUARD";
+var STAMP_PREFIX3 = "josh-parent-cut-guard-";
+var QUIET_WINDOW_MS = 6e5;
+function current_state3() {
+  return {
+    carry: async () => await run_headless.driving_carry(),
+    verdict: () => implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict())
+  };
+}
+var THRESHOLD_TEXT2 = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
+var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` (it owns the live carry record) and its recent-context cost has crossed the shared ${THRESHOLD_TEXT2} threshold between merges, so every later request re-reads the accumulated context (joshuafolkken/kit#2947). Take the hand-off now rather than at the next merge: follow \`.claude/skills/workflow-commands/backlogrun-progress.md\` \u2192 "The hand-off" from its \`over\` branch \u2014 open no new lane and take no new child, read \`pnpm josh lane:list\`, make sure every lane in flight records an output path, then run \`pnpm josh run:carry --cut --owner "$PPID"\` and, unless it answers \`capped\`, \`pnpm josh run:wake\`, post the progress comment and end the turn. A lane nobody can poll means the cut does not happen; carry on and this asks again later. Reissue this call when the hand-off is done or cannot be taken \u2014 the guard stays quiet for a while after it refuses, so the hand-off calls themselves are not refused.`;
+async function is_due2(state) {
+  const carry = await state.carry();
+  if (carry === void 0 || run_carry.is_at_cut_cap(carry)) return false;
+  return state.verdict() === cost_verdict.OVER_VERDICT;
+}
+function is_quiet(target, now_ms) {
+  const last_ms = hook_decision.create_refusal_stamp(STAMP_PREFIX3).last_ms(target);
+  return last_ms !== hook_decision.NEVER_MS && now_ms - last_ms < QUIET_WINDOW_MS;
+}
+async function refusal_for(transcript, now_ms, state) {
+  const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX3);
+  const target = stamp.path(transcript);
+  if (is_quiet(target, now_ms) || !await is_due2(state)) return void 0;
+  return stamp.record(target, now_ms) ? PARENT_CUT_REASON : void 0;
+}
+function is_unit_call(raw_payload) {
+  try {
+    return (hook_decision.parse_hook_payload(raw_payload)?.agent_id ?? "") !== "";
+  } catch {
+    return false;
+  }
+}
+function is_exempt2(raw_payload) {
+  return !hook_decision.is_switch_enabled(SWITCH_ENV_KEY3) || is_unit_call(raw_payload);
+}
+async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state3()) {
+  if (is_exempt2(raw_payload)) return void 0;
+  const transcript = run_watcher_hook.transcript_of(raw_payload);
+  if (transcript === void 0) return void 0;
+  return await refusal_for(transcript, now_ms, state);
+}
+var run_parent_cut_hook = {
+  PARENT_CUT_REASON,
+  QUIET_WINDOW_MS,
+  STAMP_PREFIX: STAMP_PREFIX3,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY3,
+  parent_cut_reason
+};
 
 // scripts/hooks/pretool-guard.ts
 function combine_outcomes(batch, extra_reason) {
@@ -5429,24 +5482,19 @@ function pretool_outcome(raw_payload) {
   const combined = combine_outcomes(batch, investigation ?? duplicate_refusal ?? rule);
   return with_duplicate_notice(combined, duplicate.notice);
 }
+async function async_reason(raw_payload) {
+  const watcher = await run_watcher_hook.watcher_hook_reason(raw_payload);
+  return watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload);
+}
 async function pretool_outcome_async(raw_payload) {
   const base = pretool_outcome(raw_payload);
   if (!is_clear(base)) return base;
-  const reason = await run_watcher_hook.watcher_hook_reason(raw_payload);
+  const reason = await async_reason(raw_payload);
   return reason === void 0 ? base : { reason, notice: void 0, fault: void 0 };
 }
 var pretool_guard = { combine_outcomes, pretool_outcome, pretool_outcome_async };
-if (process.argv[1] === fileURLToPath3(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("pretool:guard");
-  else {
-    const raw_payload = await text(process.stdin);
-    hook_decision.load_environment_file();
-    hook_decision.emit_outcome(await pretool_outcome_async(raw_payload));
-  }
-}
 
 export {
-  pretool_outcome,
   pretool_outcome_async,
   pretool_guard
 };