@joshuafolkken/kit 1.1166.0 → 1.1178.0

package/.claude/skills/workflow-commands/backlogrun-lanes.md

@@ -218,8 +218,8 @@ conflict.
 | When | The lane | Why |
 | --- | --- | --- |
 | The child **merged** | `pnpm josh lane:close <N>` | `followup` released the hold and the branch is on `main`; nothing in that tree is wanted |
-| The child was **parked before its commit** | `git -C <dir> stash push -u -m "backlogrun: parked #<N>"`, record it on the Issue, then `pnpm josh lane:close <N>` | The stash is a repository-level ref, so it outlives the work tree — and `lane:close` is a **forced** removal that would otherwise take the work. `epic:next` counts a parked child's lane as released, so a lane left open holds a seat the count believes is free |
-| The child was **parked after its commit and push** | **Left open**, its directory and held seat recorded on the Issue | The stash step is a **no-op** (tree clean because committed). What `lane:close` would take is the **local branch**, which is the resume path |
+| The child was **parked before its commit** | **Left open**, its uncommitted work in place, its directory and held seat recorded on the Issue | The stash stack is shared by every work tree, so a parallel lane can pop another's entry — the tree itself is the safe place for the work. `lane:close` is a **forced** removal that would take it. `pnpm josh lane:launch <N>` dispatches the released child into the kept lane rather than refusing it as `already-open` — only a lane a child was already dispatched into; a failed-install lane is still refused |
+| The child was **parked after its commit and push** | **Left open**, its directory and held seat recorded on the Issue | The tree is clean because committed. What `lane:close` would take is the **local branch**, which is the resume path |
 | The child hit a **merge conflict** | **Left open** — the resolution happens in it | The child resolves in place (`backlogrun-recovery.md` → "Conflicts are not predicted"). A park under that section's four conditions takes the row above |
 | The child stopped on **`needs-human-review`** | **Left open and untouched** | The uncommitted work *is* the artifact a person has to look at. Name the lane directory in the stop report and in the Telegram |
 | The child **failed** | Whichever of the two parked rows applies, plus the consecutive-failure count | Same reasoning; only the counter differs. **A merge conflict is not this row** — it takes the row above, and it is not counted |
@@ -229,7 +229,7 @@ conflict.
 **A lane closed after a push is reopened by `pnpm josh lane:open <N>`**, which attaches to a local
 `<N>-lane` or creates one from `origin/<N>-lane`, saying on standard error which it reused. **The branch
 still has to have reached the remote for that to hold** — a child parked before its commit has nothing
-on `origin`, which is why that row stashes first and the after-push row does not. Rationale:
+on `origin`, which is why that row keeps its lane open rather than closing it. Rationale:
 `docs/maintainers/backlogrun-lanes-rationale.md` → "Why a committed child's lane is kept".
 
 **Which row a child takes is decided by what `followup` printed, not by reading the situation.** **What

package/.claude/skills/workflow-commands/backlogrun-park.md

@@ -75,12 +75,10 @@ pnpm josh issue:comment <N> --body-file <path>   # what needs deciding, and the
 `needs-decision` precedence over `in-progress`, so the next child is offered normally. Then return to
 step 1; the other children are unaffected unless they depend on this one.
 
-**What happens to a parked child's lane depends on whether it had committed, and the two answers are
-opposite.** **Parked before its commit**, the lane is stashed and closed:
-`git -C <dir> stash push -u -m "backlogrun: parked #<N>"`, the stash recorded on the Issue, then
-`pnpm josh lane:close <N>` (`epic:next` counts a parked child's lane as released, and `lane:close`
-removes the work tree by force). **Parked after its commit and push**, the lane is *kept*: nothing to
-stash, and closing would delete the local branch the resume needs. **A lost merge race is not one of
+**A parked child's lane is kept, whether or not it had committed.** **Parked before its commit**, the
+uncommitted work stays in the lane's tree — never in the stash, which every work tree shares — and
+`lane:close` would remove it by force. **Parked after its commit and push**, closing would delete the
+local branch the resume needs. **A lost merge race is not one of
 these rows** — it resolves in its lane (`backlogrun-recovery.md` → "Conflicts are not predicted"), and parks only under that
 section's four conditions, which take the after-commit row. Both rows and the `pnpm josh run:release
 <N>` every parked ending owes are "What happens to a lane" above, the single source.
@@ -101,7 +99,8 @@ gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-decision 2>/dev/nu
 
 **The released child goes back to a lane, never into the parent's own context.** A parent that is
 *already* running, and clears a label mid-run because a person just answered, dispatches it the same way
-rather than picking up its diff itself — `pnpm josh lane:open <N>` then `pnpm josh lane:dispatch <N>`. A
+rather than picking up its diff itself — `pnpm josh lane:launch <N>`, which dispatches into the lane the
+park kept, or opens one where none is. A
 parent that implements the released child inline is the failure the orchestrator rule is written against:
 "The parent orchestrates and never implements a child in its own context" above.
 

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

@@ -308,8 +308,9 @@ Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the plan an
 whose head is `pnpm josh backlog:offer`: the answer-to-budget mapping, the retry count, the `--exclude`
 feedback and the lane count are its own (`docs/josh-commands-automation.md` → "`josh backlog:offer`"
 and "`josh backlog:drive`"). **An AI session reaches this section only when the driver hands a branch
-back** — the `Driver result:` line names it, and the session acts on it, then hands the loop back with
-`pnpm josh run:carry --cut --owner "$PPID"`:
+back** — the `Driver result:` line names it, and its `Next:` line is the order: claim the record with
+`pnpm josh run:carry --resume "<invocation>" --owner "$PPID"`, act on the branch, then hand the loop
+back with `pnpm josh run:carry --cut --owner "$PPID"`:
 
 | Handed back | What the session judges |
 | --- | --- |

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

@@ -58,7 +58,7 @@ pnpm josh run:cut <N>
 - `cut` (0) — record written and handed to the lane's launch owner (OpenAI supervisor starts the
   successor after this process exits; Anthropic relaunches directly). **End the turn immediately** —
   the fresh process owns the run.
-- `under-threshold` (0) — the recent-window per-request cost is under the shared `CONTEXT_CUT_THRESHOLD`,
+- `under-threshold` (0) — the newest request's billed input is under the shared `CONTEXT_CUT_THRESHOLD`,
   so nothing was cut; **continue to the gate.**
 - `not-a-lane` (0) — no open lane for this issue, so not a dispatched child. **Continue to the gate.**
 - `unready` (1) — the tree is clean or on the default branch, nothing to carry. Continue to the gate.
@@ -79,7 +79,7 @@ carried, handing back the command above. Rationale:
   `<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**. The guard
+- **It fires only when the current 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.
@@ -180,8 +180,8 @@ after the fact by `pnpm josh run:ending <N> --output <path>` (joshuafolkken/kit#
 
 ## The threshold
 
-`CONTEXT_CUT_THRESHOLD` and the recent-window `cost_verdict.per_request_cost` (the last
-`RECENT_REQUEST_WINDOW` requests) are computed by `scripts/cost-runtime/context-cut-payback.ts`, their
+`CONTEXT_CUT_THRESHOLD` and `cost_verdict.per_request_cost` (the newest request's billed input)
+are computed by `scripts/cost-runtime/context-cut-payback.ts`, their
 single source; both cuts and the parent hand-off read the same verdict, and an unmeasurable session is
 always cut. Rationale: `docs/maintainers/pre-gate-cut-rationale.md` → "Why the threshold is a
 break-even". Both cuts end the turn **before** the gate, in the same act that starts the successor, so

package/.github/workflows/ci.yml

@@ -333,10 +333,21 @@ jobs:
   # No ESLint cache here — nothing in this job lints — and no `--maxWorkers`: `gate-plan.ts` leaves
   # any machine below its measured 11 cores uncapped, so vitest sizes its own pool from the runner
   # exactly as it did inside the gate step.
+  # **Sharded across runners, because one runner is already saturated** (joshuafolkken/kit#3220).
+  # Alone on a 4-core runner vitest takes every core, so the suite can only get faster by spreading
+  # its files over more machines. `fail-fast: false` keeps a red shard from cancelling the others,
+  # so one run reports every failing file. The `Checks` aggregate below reads `needs.unit.result`,
+  # which for a matrix is `success` only when every shard succeeded — no change there is needed.
+  # Only kit shards: the distributed template runs the unit suite inside its single `checks` job,
+  # where a small consumer suite would pay the duplicated setup and could leave a shard with no file.
   unit:
-    name: Unit Tests
+    name: Unit Tests (${{ matrix.shard }}/3)
     needs: reuse-pr-checks
     if: ${{ !cancelled() && needs.reuse-pr-checks.outputs.reuse != 'true' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [1, 2, 3]
     runs-on: ubuntu-latest
     timeout-minutes: 8
     permissions:
@@ -366,9 +377,11 @@ jobs:
       # `scripts/ci/ci-yml-unit-job.test.ts` pins the command; the guard itself is
       # `scripts/test/test-unit-guard.ts`.
       - name: Run unit tests
-        run: pnpm josh test:unit
+        run: pnpm josh test:unit --shard=${{ matrix.shard }}/3
 
+      # One shard is enough: the check does not depend on which test files ran beside it.
       - name: Verify optional ESLint consumer install
+        if: matrix.shard == 1
         run: pnpm exec tsx scripts/package/verify-optional-eslint-install.ts
 
   # **The required status check. `Checks` is a name the branch ruleset already requires, and this job

package/dist/hooks/batch-guard.js

@@ -9,10 +9,10 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-V2BTOZHT.js";
-import "./chunk-GYNGP7HI.js";
-import "./chunk-5KTCMCOT.js";
-import "./chunk-DYAVAM6S.js";
+} from "./chunk-VQLLNFNT.js";
+import "./chunk-I4XSL4TT.js";
+import "./chunk-32GQTL4F.js";
+import "./chunk-S6X6WYKR.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 export {

package/dist/hooks/{chunk-5KTCMCOT.js → chunk-32GQTL4F.js}

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

package/dist/hooks/{chunk-URJA6XY4.js → chunk-DO6NWWHU.js}

@@ -1,16 +1,16 @@
 import {
   investigation_reads
-} from "./chunk-A6P7PN7P.js";
+} from "./chunk-ZAL3NRGL.js";
 import {
   lane_guard_policy
-} from "./chunk-GYNGP7HI.js";
+} from "./chunk-I4XSL4TT.js";
 import {
   hook_decision
-} from "./chunk-5KTCMCOT.js";
+} from "./chunk-32GQTL4F.js";
 import {
   json_value,
   time_spans
-} from "./chunk-DYAVAM6S.js";
+} from "./chunk-S6X6WYKR.js";
 
 // scripts/delegation/duplicate-read-guard.ts
 import { statSync } from "node:fs";

package/dist/hooks/{chunk-GU5MATVE.js → chunk-G6KRCKEC.js}

@@ -5,7 +5,6 @@ import {
   NEEDS_DECISION_LABEL,
   NEEDS_HUMAN_REVIEW_LABEL,
   PORCELAIN_FLAG,
-  RECENT_REQUEST_WINDOW,
   agent_role_profile,
   bash_triggers,
   cli_flags,
@@ -22,7 +21,6 @@ import {
   lane_background,
   lane_park,
   lane_registry,
-  open_issue_schema,
   own_session,
   parse_json_object_safe,
   read_json_listing,
@@ -36,30 +34,30 @@ import {
   run_tail,
   shell_segments,
   tail_commands
-} from "./chunk-ZDZ555YH.js";
+} from "./chunk-GDS5N2KB.js";
 import {
   find_local_bin_upwards
 } from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-V2BTOZHT.js";
+} from "./chunk-VQLLNFNT.js";
 import {
   investigation_refusal
-} from "./chunk-ENA7P5FB.js";
+} from "./chunk-VESKRQOF.js";
 import {
   duplicate_read_outcome
-} from "./chunk-URJA6XY4.js";
+} from "./chunk-DO6NWWHU.js";
 import {
   investigation_reads
-} from "./chunk-A6P7PN7P.js";
+} from "./chunk-ZAL3NRGL.js";
 import {
   lane_guard_policy
-} from "./chunk-GYNGP7HI.js";
+} from "./chunk-I4XSL4TT.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-5KTCMCOT.js";
+} from "./chunk-32GQTL4F.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -69,10 +67,11 @@ import {
   file_reader,
   json_value,
   lane_paths,
+  open_issue_schema,
   stamp_file,
   time_batch_guard,
   time_shell
-} from "./chunk-DYAVAM6S.js";
+} from "./chunk-S6X6WYKR.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-automation.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
@@ -897,22 +896,15 @@ var cost_corpus = {
 var FAILURE_EXIT_CODE = 1;
 var OVER_VERDICT = "over";
 var UNDER_VERDICT = "under";
-function recent_requests(measurement2) {
-  return measurement2.billed_input_per_request.slice(-RECENT_REQUEST_WINDOW);
-}
 function per_request_cost(measurement2) {
-  const window = recent_requests(measurement2);
-  if (window.length === 0) return 0;
-  const total = window.reduce((sum, billed) => sum + billed, 0);
-  return Math.round(total / window.length);
+  return measurement2.billed_input_per_request.at(-1) ?? 0;
 }
 function classify(measurement2, limit) {
   return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
 }
 function over_summary(measurement2, limit) {
   const total = measurement2.billed_input_per_request.length;
-  const window = recent_requests(measurement2).length;
-  return `${String(per_request_cost(measurement2))} billed input tokens per request over the last ${String(window)} of ${String(total)} request(s); limit ${String(limit)}`;
+  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
 }
 function report_over(measurement2, limit) {
   if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {