@joshuafolkken/kit 1.1128.0 → 1.1166.0

package/templates/workflows/github-release.yml

@@ -1,14 +1,13 @@
 name: GitHub Release
 
 # Creates the GitHub Release, with notes generated from `.github/release.yml`, for each tag
-# `josh release` cuts (joshuafolkken/kit#3007). A repository with a Publish workflow gets its release
-# once that workflow has succeeded for the tag; one without it gets the release when auto-tag.yml
-# announces the tag. kit's own release is the `create-release` job of its publish.yml, which runs the
-# same `josh release:github`, so this file is distributed but never runs in kit.
+# `josh release` cuts (joshuafolkken/kit#3007). It starts when auto-tag.yml announces the tag; a
+# repository with a Publish workflow gets its release once that workflow has succeeded for the tag,
+# waited for inside `josh release:github`. A `workflow_run` on Publish is not used: a Publish run
+# started by the GITHUB_TOKEN never fires one (joshuafolkken/kit#3138). kit's own release is the
+# `create-release` job of its publish.yml, which runs the same `josh release:github`, so this file is
+# distributed but never runs in kit.
 on:
-  workflow_run:
-    workflows: [Publish]
-    types: [completed]
   repository_dispatch:
     types: [new-tag-created]
 
@@ -17,12 +16,6 @@ on:
 
 jobs:
   release:
-    # The Publish run is titled `Publish <tag>`; its head branch is not the tag when it was started by
-    # repository_dispatch, so the title is where the tag is read from.
-    if: >-
-      (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success' &&
-      startsWith(github.event.workflow_run.display_title, 'Publish v')) ||
-      github.event_name == 'repository_dispatch'
     runs-on: ubuntu-latest
     timeout-minutes: 65
     permissions:
@@ -36,23 +29,17 @@ jobs:
           fetch-depth: 0
           persist-credentials: false
 
-      # A repository with a Publish workflow is released from the workflow_run above, after its
-      # publication, so the tag announcement is left alone there and one tag never starts two releases.
+      # A repository with a Publish workflow waits for that workflow's `Publish <tag>` run to succeed
+      # before releasing; the announcement is the only trigger, so one tag never starts two releases.
       - name: Select release tag
         id: release
         env:
-          EVENT_NAME: ${{ github.event_name }}
-          RUN_TITLE: ${{ github.event.workflow_run.display_title }}
-          RUN_WORKFLOW: ${{ github.event.workflow_run.workflow_id }}
           DISPATCH_TAG: ${{ github.event.client_payload.tag }}
         run: |
-          if [ "$EVENT_NAME" = workflow_run ]; then
-            echo "tag=${RUN_TITLE#Publish }" >> "$GITHUB_OUTPUT"
-            echo "workflow=$RUN_WORKFLOW" >> "$GITHUB_OUTPUT"
-          elif [ -f .github/workflows/publish.yml ]; then
-            echo "ℹ️ publish.yml releases this tag once it has published, skipping"
-          else
-            echo "tag=$DISPATCH_TAG" >> "$GITHUB_OUTPUT"
+          echo "tag=$DISPATCH_TAG" >> "$GITHUB_OUTPUT"
+          if [ -f .github/workflows/publish.yml ]; then
+            echo "workflow=publish.yml" >> "$GITHUB_OUTPUT"
+            echo "await=true" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Setup Node.js
@@ -77,3 +64,4 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           RELEASE_TAG: ${{ steps.release.outputs.tag }}
           RELEASE_WORKFLOW: ${{ steps.release.outputs.workflow }}
+          RELEASE_AWAIT_PUBLISH: ${{ steps.release.outputs.await }}

package/.claude/skills/workflow-commands/followup-reference.md

@@ -1,118 +0,0 @@
-# `pnpm josh followup` — the post-execution reference
-
-The parts of the `followup` procedure a run reaches **after** it has issued `pnpm josh followup`: how
-to read the stage-timing block the command prints, the AI-reviewer comment scan and the config-file
-report it runs, and the release ask that closes the completion summary. `followup.md` carries what a
-run needs **before** it issues the command and points here for the rest, so the read that lands in the
-turn that issues `pnpm josh followup` stays small (joshuafolkken/kit#1905).
-
-This file is the single source of the sections below; `followup.md`, `fullrun.md`, `backlogrun.md` and
-`backlogrun.md` point here rather than restating them.
-
-## Reading the stage-timing block
-
-### It prints how long each of those stages took
-
-Since joshuafolkken/kit#1349 the command closes with one row per stage and a total, so "where did
-`followup` spend its time" is read rather than guessed. The shape, with illustrative durations:
-
-```
-followup stage: closes-and-context        2.1 s
-followup stage: checks-wait               28.4 s
-followup stage: coderabbit-comments       1.3 s
-followup stage: ai-review-comments        2.0 s
-followup stage: telegram                  1.1 s
-followup stage: merge                     2.6 s
-followup stage: completion-and-epic-close 1.4 s
-followup stages total:                    38.9 s
-```
-
-- **The block is printed on a failed run too**, up to and including the stage that threw, which is
-  named `interrupted`. A `followup` that exits non-zero on an AI-review blocker or a red check is the
-  invocation whose wait was longest, and one that printed nothing would leave the measurement blind to
-  exactly those. **A short block there is the run stopping early, not the printer breaking**: the
-  stages after the failure never ran, so they have no duration to report.
-- **The `merge` row appears only on a run that merged**, so a `--no-merge` block is a row shorter.
-- **Two rows say `and` because the requests behind them go out together** (joshuafolkken/kit#1446).
-  `closes-and-context` is the former `closes-check` plus `context` — the pull request body, the
-  repository name, the pull request URL and the issue title, four reads that need nothing from one
-  another; `completion-and-epic-close` is the former `completion-comment` plus `epic-close`. A lap
-  records an interval rather than a call, so a batch is one row, and the name is what says which
-  stages it holds. **The one dependency inside the batch is kept**: with no issue number on the
-  command line the title read waits for the body that names it, and only that read waits.
-  **`checks-wait` is untouched**, which is the point — what was overlapped was never a wait.
-- **The total is the sum of the stages, not the command's whole wall clock.** What sits outside it is
-  the tail the workflow script runs afterwards — the review-record clears, the hold
-  release, the next-issue listing and the version line — so a run-timing reading of the same
-  span is longer, and that gap is the tail. It is normally a second or two.
-- **What was measured is on joshuafolkken/kit#1349**, and cutting any of it is deliberately not this
-  block's business: the required-check wait and the AI-review scan are the merge gate, and narrowing
-  either to make a number smaller is the workaround `CLAUDE.md` prohibits.
-
-A `failure` Telegram is sent **by hand, exactly once**, and only when the agent has finally given up
-recovering — never once per retry:
-
-```bash
-pnpm josh notify --task-type failure --issue-url "<issue-url>" --body "<the reason and what is unresolved>"
-```
-
-## AI reviewer comment scan (automatic in `pnpm josh followup`)
-
-`pnpm josh followup` scans top-level PR comments from AI reviewers (Claude Review, CodeRabbit summary comments) **independently of CI status**. This scan runs after CI is green and after the existing CodeRabbit line-comment check. The goal is to ensure substantive findings posted by AI reviewers _after_ CI goes green are not silently shipped.
-
-**Temporary (kit#753)**: while CodeRabbit reviews are slow, CodeRabbit is non-blocking end to end — it is excluded from the default required checks (restore via `JOSH_REQUIRED_CHECKS`), `Actionable comments posted: N` is downgraded to an informational log, and unresolved CodeRabbit line comments no longer require an ignore reason. Every skip is printed to the console and appended to the completion Telegram body. Claude Review blockers are unchanged. Revert together with kit#752.
-
-- Blocker heuristics (conservative, structural — not NLP):
-  - **Claude Review** (`author.login = claude`): body contains `### Issues`, `### Problem`, `#### Logic bug`, or a numbered finding heading like `### 1. ...`
-  - **CodeRabbit** (`author.login = coderabbitai` / `coderabbitai[bot]`): body contains `Actionable comments posted: N` with N > 0. Rate-limit notices (`rate limited by coderabbit.ai` / `Rate limit exceeded`) and "No actionable comments" summaries are ignored.
-- If blockers exist and **no** ignore reason is supplied: `pnpm josh followup` sends a `confirmation` Telegram and exits non-zero. Fix the findings (or provide an ignore reason) and re-run.
-- If blockers exist and `--ai-review-ignore-reason "<reason>"` is supplied: the workflow posts an ignore-reason comment to the PR (mirroring the CodeRabbit ignore-reason flow) and proceeds to completion.
-- Acknowledgment-only Claude comments (`All issues resolved ✓`, `Everything else looks good`) do not match the blocker heuristics, so rounds where the AI reviewer explicitly signs off do not trigger a false positive.
-- **A comment listing that could not be read is treated exactly like a standing blocker.** A rate limit, expired auth, a dropped connection — every one of them used to arrive as an empty listing, so the gate passed without having read anything (joshuafolkken/kit#973). `confirmation` Telegram, non-zero exit, re-run once the read succeeds. `--ai-review-ignore-reason` still gets past it, because what it means is unchanged: a person has looked — and the run then carries an audit note saying the scan was bypassed.
-- **The CodeRabbit line-comment listing is the exception**: unreadable there is reported as an audit note rather than blocking, because kit#753 has CodeRabbit not blocking the merge at all. That reader also answers unreadable when the PR number itself would not resolve, which the top-level scan never has to do. Revert with kit#752.
-
-## Config file reporting (inside `pnpm josh followup`)
-
-**Nothing here asks you to compare anything by eye** (joshuafolkken/kit#1578). `pnpm josh followup` reads the tracked branch diff itself and matches every changed path against everything `josh sync` distributes — the three lists `AI_COPY_FILES`, `AI_COPY_FILE_MAPPINGS`, `AI_COPY_DIRECTORIES`, plus `SYNCED_PATHS`, the destinations `sync` writes directly (`playwright.config.ts`, `eslint.config.js`, the rest).
-
-**It stops nothing** (joshuafolkken/kit#1592). What it produces is a report: the claimed paths and the list that claimed each one go into **the completion notification and the completion report on the Issue**, and the run continues to the CI wait and the merge exactly as a run that distributes nothing does. A run passing `--no-merge` is not reported on, because nothing has been distributed yet.
-
-**It was a confirmation stop until joshuafolkken/kit#1592, and measurement is what removed it rather than preference.** In kit the condition is nearly always true, because kit is the distribution source: every change to `CLAUDE.md`, to `prompts/`, to `.claude/skills/` or to the distributed part of `docs/` is by definition a change to a distributed path. Measured on `epicrun #1413`, **two of three children stopped here** — and in both, the distributed file was the one that child's own acceptance criteria had ordered changed. The gate was not catching an unintended edit; it was stopping the work, and ending unattended execution until a person retyped one command.
-
-**There is deliberately no branch on which repository this is.** Stopping in a consumer project — where editing a distributed file really is the mistake `CLAUDE.md` → "Route distributed-doc / config changes upstream to kit" names, since the next `josh sync` overwrites it silently — while staying quiet in kit was weighed and rejected on joshuafolkken/kit#1592: it needs a distribution-source test this package does not have, no case is recorded of the gate having saved a consumer's work, and the report below reaches a consumer's reader just as well.
-
-**The matching itself is unchanged, and so is the reason it is mechanical.** The instruction the mechanical read replaced was skipped in two runs out of three on the day it was measured, and one of those two could not have succeeded by eye at all: `AI_COPY_DIRECTORIES` holds directories, so a distributed path such as `.claude/skills/workflow-commands/backlogrun.md` appears in no list textually.
-
-```bash
-pnpm josh sync:scope    # managed | clean, naming which list claimed each path
-```
-
-- **There is no flag to pass and nothing to approve.** `--managed-config-ignore-reason` is gone with the stop it existed to get past.
-- This report is produced independently of AI reviewer comment scanning, which still stops the run on a standing blocker
-
-## When `pnpm josh release` runs
-
-**The release point is a position plus a command's answer, never a judgement** (joshuafolkken/kit#1582). joshuafolkken/kit#1169 took the version off the branch and put it behind one command a person types; nothing said *when* to type it, and because nothing fails when nobody does — CI green, every pull request merged, every Issue closed — 53 merges reached main unreleased and no consumer of this package saw one of them.
-
-**The position: once per invocation, after the last merge.** Ask when `pnpm josh followup` has merged the last pull request *this invocation* authorized — a lone `fullrun`'s only one, a `backlogrun`'s **last** child, never once per child. In a lane the parent asks it, in the primary checkout, after the last lane is closed. Asked per child it would cut a release in the middle of a batch whose remaining children are still moving main.
-
-**The answer: `pnpm josh release:scope`.**
-
-```bash
-pnpm josh release:scope          # → required | skip | unknown
-pnpm josh release:scope --json   # the same answer as one JSON object
-```
-
-| It answers | What it means                                                    | What the run does                                                               |
-| ---------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------- |
-| `required` | main has taken at least one merge since the version last changed | Close the completion report with the release request, naming `pnpm josh release` |
-| `skip`     | the count is zero — nothing is waiting to ship                    | Say so in one line and finish                                                     |
-| `unknown`  | the count could not be read                                      | **Report it as `unknown`** — it is never read as `skip`                          |
-
-**The threshold is one, and that is deliberate.** joshuafolkken/kit#1582's own complaint is that accumulating makes a single version larger and its contents harder to trace afterwards, so a release per invocation is the cadence rather than a compromise — and it is the cadence that already held while every child bumped, before joshuafolkken/kit#1486 removed that. What keeps it from firing per child is the position above, not a larger number.
-
-**The run never types `pnpm josh release` itself.** That command opens a pull request of its own, merges it, and starts the tag → publish → `production` chain: outward-facing and effectively irreversible, so it is Tier C (`CLAUDE.md` → "Decision autonomy"). Typing `fullrun` authorizes merging *this Issue's* pull request and nothing past it. On `required` the run reports the request as its closing line and stops there; a person types the command in the primary checkout, on the default branch, with a clean tree.
-
-**`pnpm josh release --dry-run` was checked first and does not answer this.** It refuses off the default branch and on a dirty working tree, and it counts against `HEAD` rather than `origin/<default>` — and every position above is a feature branch or a lane, which is exactly where it throws. So `release:scope` adds **no counting of its own**: it reads `git_followup_pending.read_pending`, the same fetch-then-count `pnpm josh followup` already uses for the Telegram line, and the two therefore cannot disagree.
-
-**This section is the single source.** `fullrun.md`, `backlogrun.md` and `backlogrun.md` point here rather than restating it, and `docs/josh-commands-automation.md` → "`josh release:scope`" documents the command itself.

package/dist/hooks/chunk-QVLT52OV.js

@@ -1,464 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-MKVGBQPA.js";
-import {
-  time_bundle_call,
-  time_format,
-  time_round_trips,
-  time_spans,
-  time_transcript_line
-} from "./chunk-4JZDP5X5.js";
-
-// scripts/lane/lane-guard-policy.ts
-var DEFAULT_MODE = "refuse";
-var OFF_MODE = "off";
-var LANE_GUARD_POLICY = [
-  {
-    id: "investigation",
-    mode_in_lane_child: "notice",
-    because: 'a refusal ends a child turn so it cannot fire as one (kit#2138), which is why it was `off` from #2138 to #2382. The exemption reason \u2014 "the child is itself the delegated unit, so it cannot dispatch a sub-unit to read its own edit targets" \u2014 did not hold in measurement: kit#2382 re-measured the six lane children after #2347 (#2366 #2370 #2371 #2372 #2374 #2375) and every one dispatched sub-agents (10 launches, 2 of them investigation fan-outs) and read 4\u201317 files it never edited, all six over the threshold of 3. So the reading the guard exists to send out was there to send. It takes `notice`, not `off`: the child is nudged to delegate rather than killed, on the `additionalContext` path batching and duplicate-read already use, and the notice names the concrete unedited files this run read (the #2276 precedent) rather than the generic "delegate" #2164 \u2192 #2178 measured not to move the number. The density is a genuine experiment \u2014 re-measured on the next backlogrun, and a notice that still does not move it is redesigned rather than kept'
-  },
-  {
-    id: "batching",
-    mode_in_lane_child: "off",
-    because: "a refusal ends a child turn so it cannot fire as one (kit#2138); kit#2164 replaced it with a notice, kit#2178 took that notice off after it did not move the density, and kit#2276 restored it \u2014 naming the concrete recent calls and recurring every single-call turn \u2014 as a genuine experiment to be redesigned rather than kept if the next backlogrun still missed 1.40. kit#2405 is that re-measurement, and it cuts the notice off (`off`). `josh time:density` read 1.13 calls per round trip over the ten most recent lanes (1.04 in the Issue\u2019s per-message frame), short of the 1.40 target as every advisory attempt before it was (kit#1304/#1329/#1337/#1390/#2164/#2276). The cause is structural rather than wording: a `PreToolUse` hook cannot see the turn it is in \u2014 a turn\u2019s later `tool_use` lines arrive 1.4\u201315s after its first \u2014 so it judges only closed turns, and a notice at turn close still asks for the parallel `tool_use` blocks the model resists. The one lever measured to move the density is a composite command the model emits in a single call (`read:files`/`edit:files`, kit#2202/#2311), which needs no notice. So per the issue\u2019s instruction to discontinue advisory means when the target is missed, the notice is cut off rather than rewritten a seventh time; the density stays readable through `josh time:density`"
-  },
-  {
-    id: "duplicate-read",
-    mode_in_lane_child: "notice",
-    because: "a refusal ends a child turn so it cannot fire as one (kit#2138), and the unchanged re-reads the guard catches are measured in lane children above all (kit#2298 baseline: 8.0 per lane run) \u2014 so silencing it there (`off`) would neuter it exactly where the count lives. It takes `notice` instead: the child is nudged to scroll up to the earlier read rather than killed. The mode is a genuine experiment, as the batching notice is \u2014 a notice that does not reduce the duplicate reads on the next backlogrun is redesigned rather than kept"
-  },
-  {
-    id: "rule",
-    mode_in_lane_child: "refuse",
-    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules a child must still obey (`shell-body`, `piped-verification`); a blanket suppression would disarm exactly the guards written for the child. `implementation-cut` (joshuafolkken/kit#2310) needs `refuse` for the same reason the pre-gate cut does \u2014 kit#1864 and kit#2310 both measured a cut carried as prose firing 0 times, so a notice, being prose in front of the run, would drop enforcement without a procedural replacement. The pre-gate-cut refusal does collateral a sibling call batched in the same turn \u2014 a `PreToolUse` deny cancels the turn's other parallel calls, which is the harness behavior kit#2177 measured on #2160 (gate refused, its batched `review:brief` cancelled) \u2014 and that collateral is not avoidable at the guard level. `notice` was considered for the pre-gate-cut point and rejected: kit#1864 measured the cut taken 0 times while it was carried as prose, and a notice is prose in front of the run (kit#2178 measured a lane-child notice not moving the number), so a notice would drop enforcement without a procedural replacement. kit#2177 supplies that replacement in the procedure instead \u2014 the chain orders the cut before the gate, so the cut is issued on its own (its `cut` verdict ends the turn, batching with nothing) and the gate runs in the fresh process where the carried cut keeps this guard silent; the refusal therefore stays `refuse` as insurance and the collateral is gone from the default path rather than from the guard"
-  }
-];
-var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
-function entry_for(id) {
-  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
-}
-function mode_in_lane_child(id) {
-  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
-}
-function mode_here(id, directory = process.cwd(), source = process.env) {
-  const lane_mode = mode_in_lane_child(id);
-  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
-  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
-}
-function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
-  return mode_here(id, directory, source) === OFF_MODE;
-}
-var lane_guard_policy = {
-  LANE_GUARD_POLICY,
-  KNOWN_GUARD_IDS,
-  entry_for,
-  mode_in_lane_child,
-  mode_here,
-  is_suppressed_here
-};
-
-// scripts/time-runtime/time-agent-bundles.ts
-var NONE = 0;
-var ONE = 1;
-var MIN_GROUP = 2;
-function is_launch(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation && time_bundle_call.is_launch_tool(span.label);
-}
-function new_walk() {
-  return { closed: [], open: NONE, wrote_since: false, turn_id: time_spans.NO_MESSAGE_ID };
-}
-function close_group(walk) {
-  if (walk.open >= MIN_GROUP) walk.closed.push(walk.open);
-  walk.open = NONE;
-}
-function is_same_turn(walk, span) {
-  return span.message_id !== time_spans.NO_MESSAGE_ID && span.message_id === walk.turn_id;
-}
-function open_turn(walk, span) {
-  if (walk.wrote_since || span.has_prior_reference) close_group(walk);
-  walk.open += ONE;
-  walk.turn_id = span.message_id;
-  walk.wrote_since = false;
-}
-function step(walk, span) {
-  if (span.is_writing) {
-    walk.wrote_since = true;
-    return;
-  }
-  if (!is_launch(span) || is_same_turn(walk, span)) return;
-  open_turn(walk, span);
-}
-function agent_bundles(spans) {
-  const walk = new_walk();
-  for (const span of time_round_trips.in_time_order(spans)) step(walk, span);
-  close_group(walk);
-  return walk.closed;
-}
-var time_agent_bundles = { agent_bundles };
-
-// scripts/time-runtime/time-bundles.ts
-var { unmeasured_row } = time_format;
-var HEADING = "Bundling:";
-var SEQUENCE_LABEL = "bundleable sequences";
-var RECOVERABLE_LABEL = "recoverable round trips";
-var SAVING_LABEL = "recoverable wait";
-var BY_TOOL_LABEL = "recoverable by tool";
-var AGENT_ROW_LABEL = "Agent";
-var ROW_INDENT = "  ";
-var MIN_SEQUENCE = 2;
-var ONE_CALL = 1;
-var NONE2 = 0;
-var PATH_SEPARATOR = "/";
-var FIRST_CALL = 1;
-var NO_LABEL = "";
-var NO_BUNDLES = {
-  sequence_count: 0,
-  longest_sequence: 0,
-  recoverable_round_trips: 0,
-  by_tool: [],
-  unattributed_round_trips: 0,
-  is_measured: false
-};
-function contains_segments(whole, part) {
-  if (whole.startsWith(`${part}${PATH_SEPARATOR}`)) return true;
-  return whole.endsWith(`${PATH_SEPARATOR}${part}`) || whole.includes(`${PATH_SEPARATOR}${part}${PATH_SEPARATOR}`);
-}
-function is_related(left, right) {
-  if (left === right) return true;
-  return contains_segments(left, right) || contains_segments(right, left);
-}
-function shares_target(left, right) {
-  return left.some((one) => right.some((other) => is_related(one, other)));
-}
-function is_dependent(earlier, later) {
-  if (earlier.is_writing && later.is_writing) return false;
-  return shares_target(earlier.targets, later.targets);
-}
-function conflicts(span, sequence) {
-  return sequence.some((earlier) => is_dependent(earlier, span));
-}
-function is_call(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
-}
-function is_turn_boundary(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function new_walk2() {
-  return { pending: [], sequence: [], closed: [] };
-}
-function flush(walk) {
-  if (walk.sequence.length >= MIN_SEQUENCE) walk.closed.push(walk.sequence);
-  walk.sequence = [];
-}
-function extend(walk, span) {
-  if (conflicts(span, walk.sequence)) flush(walk);
-  walk.sequence.push(span);
-}
-function close_trip(walk) {
-  const [only] = walk.pending;
-  if (walk.pending.length === ONE_CALL && only?.is_bundleable === true) extend(walk, only);
-  else if (walk.pending.length > NONE2) flush(walk);
-  walk.pending = [];
-}
-function is_same_turn2(span, pending) {
-  const [first] = pending;
-  if (first === void 0 || span.is_continuation || span.message_id === time_spans.NO_MESSAGE_ID) {
-    return false;
-  }
-  return span.message_id === first.message_id;
-}
-function step2(walk, span) {
-  if (is_call(span)) {
-    walk.pending.push(span);
-    return;
-  }
-  if (is_same_turn2(span, walk.pending)) return;
-  close_trip(walk);
-  if (!is_turn_boundary(span)) flush(walk);
-}
-function longest_of(sizes) {
-  return sizes.length === NONE2 ? NONE2 : Math.max(...sizes);
-}
-function recoverable_of(sizes) {
-  return sizes.reduce((sum, size) => sum + size - ONE_CALL, NONE2);
-}
-function sizes_of(closed) {
-  return closed.map((sequence) => sequence.length);
-}
-function tally_for(tallies, label) {
-  const found = tallies.get(label);
-  if (found !== void 0) return found;
-  const created = { sequence_count: NONE2, recoverable_round_trips: NONE2 };
-  tallies.set(label, created);
-  return created;
-}
-function count_trip(tallies, counted, label) {
-  const tally = tally_for(tallies, label);
-  tally.recoverable_round_trips += ONE_CALL;
-  if (!counted.has(label)) tally.sequence_count += ONE_CALL;
-  counted.add(label);
-}
-function tally_sequence(tallies, sequence) {
-  const counted = /* @__PURE__ */ new Set();
-  for (const span of sequence.slice(FIRST_CALL)) {
-    if (span.label !== NO_LABEL) count_trip(tallies, counted, span.label);
-  }
-}
-function by_weight(left, right) {
-  if (left.recoverable_round_trips !== right.recoverable_round_trips) {
-    return right.recoverable_round_trips - left.recoverable_round_trips;
-  }
-  return left.label.localeCompare(right.label);
-}
-function tool_rows(closed) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const sequence of closed) tally_sequence(tallies, sequence);
-  return [...tallies].map(([label, tally]) => ({ label, ...tally })).toSorted(by_weight);
-}
-function attributed_of(rows) {
-  return rows.reduce((sum, row) => sum + row.recoverable_round_trips, NONE2);
-}
-function with_agent_row(rows, agent_sizes) {
-  const recoverable_round_trips = recoverable_of(agent_sizes);
-  if (recoverable_round_trips === NONE2) return [...rows];
-  const row = {
-    label: AGENT_ROW_LABEL,
-    sequence_count: agent_sizes.length,
-    recoverable_round_trips
-  };
-  return [...rows, row].toSorted(by_weight);
-}
-function build_bundles(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  close_trip(walk);
-  flush(walk);
-  const sizes = sizes_of(walk.closed);
-  const agent_sizes = time_agent_bundles.agent_bundles(spans);
-  const by_tool = with_agent_row(tool_rows(walk.closed), agent_sizes);
-  const recoverable_round_trips = recoverable_of(sizes) + recoverable_of(agent_sizes);
-  return {
-    sequence_count: sizes.length + agent_sizes.length,
-    longest_sequence: Math.max(longest_of(sizes), longest_of(agent_sizes)),
-    recoverable_round_trips,
-    by_tool,
-    unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
-    is_measured: time_spans.has_transcript_data(spans.length)
-  };
-}
-function open_sequence(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  return walk.sequence;
-}
-function sequence_suffix(totals) {
-  return `longest ${String(totals.longest_sequence)} turn(s)`;
-}
-function recoverable_suffix(totals, round_trip_count) {
-  const share = time_format.format_share(totals.recoverable_round_trips, round_trip_count);
-  return `${share} of ${String(round_trip_count)} round trip(s)`;
-}
-function saving_line(totals, model_ms_per_round_trip) {
-  const saved_ms = totals.recoverable_round_trips * model_ms_per_round_trip;
-  const rate = `at ${time_format.format_seconds(model_ms_per_round_trip)} model time per round trip`;
-  return time_format.format_row(SAVING_LABEL, saved_ms, rate);
-}
-function by_tool_suffix(totals) {
-  const attributed = totals.recoverable_round_trips - totals.unattributed_round_trips;
-  return `${String(attributed)} of ${String(totals.recoverable_round_trips)} attributed`;
-}
-function tool_row(row) {
-  return time_format.format_columns(
-    `${ROW_INDENT}${row.label}`,
-    String(row.recoverable_round_trips),
-    `in ${String(row.sequence_count)} sequence(s)`
-  );
-}
-function by_tool_lines(totals) {
-  const heading = time_format.format_columns(
-    BY_TOOL_LABEL,
-    String(totals.by_tool.length),
-    by_tool_suffix(totals)
-  );
-  const rows = totals.by_tool.slice(NONE2, time_format.MAX_ROWS).map((row) => tool_row(row));
-  return [heading, ...rows, ...time_format.overflow_line(totals.by_tool.length)];
-}
-function measured_lines(totals, price) {
-  return [
-    time_format.format_columns(
-      SEQUENCE_LABEL,
-      String(totals.sequence_count),
-      sequence_suffix(totals)
-    ),
-    time_format.format_columns(
-      RECOVERABLE_LABEL,
-      String(totals.recoverable_round_trips),
-      recoverable_suffix(totals, price.round_trip_count)
-    ),
-    saving_line(totals, price.model_ms_per_round_trip),
-    ...by_tool_lines(totals)
-  ];
-}
-var LABELS = [SEQUENCE_LABEL, RECOVERABLE_LABEL, SAVING_LABEL, BY_TOOL_LABEL];
-function no_divisor_lines() {
-  return LABELS.map((label) => time_format.format_columns(label, "", time_format.NO_CALLS));
-}
-function bundle_lines(totals, price) {
-  const heading = ["", HEADING];
-  if (!totals.is_measured) return [...heading, ...LABELS.map((label) => unmeasured_row(label))];
-  if (price.round_trip_count === NONE2) return [...heading, ...no_divisor_lines()];
-  return [...heading, ...measured_lines(totals, price)];
-}
-var time_bundles = {
-  HEADING,
-  BY_TOOL_LABEL,
-  NO_BUNDLES,
-  build_bundles,
-  bundle_lines,
-  is_dependent,
-  open_sequence,
-  shares_target
-};
-
-// scripts/time-runtime/time-command-key.ts
-var UNNAMED_KEY = "";
-function command_key(span) {
-  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
-  return span.josh_command === "" ? span.label : span.josh_command;
-}
-var time_command_key = { UNNAMED_KEY, command_key };
-
-// scripts/time-runtime/time-call-identity.ts
-var IDENTITY_SEPARATOR = "\0";
-function identity_of(call) {
-  return [
-    time_command_key.command_key(call),
-    call.check_key,
-    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
-  ].join(IDENTITY_SEPARATOR);
-}
-var time_call_identity = { identity_of };
-
-// scripts/time-runtime/time-batch-guard.ts
-var CONSECUTIVE_LIMIT = 3;
-var REFIRE_EVERY = CONSECUTIVE_LIMIT;
-var ONE_TURN = 1;
-var NONE3 = 0;
-var NOTICE_REFIRE_EVERY = ONE_TURN;
-var NAMED_CANDIDATE_COUNT = 3;
-var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-var REASON = `\u26D4 batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one would make ${String(CONSECUTIVE_LIMIT)} in a row. Reissue it in one turn together with the calls meant to follow it that do not need its result. **The criterion is whether this call's input needs another call's result, not what kind of call it is** \u2014 edits are covered exactly as reads are, and it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this turn was already batching, or the call genuinely has nothing to go beside it, reissue it as it was: this fires once per run of single-call turns and cannot repeat on the call in hand.`;
-var NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this Write makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the write proceeds. Where the writes meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the write genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
-var LANE_NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the call proceeds, because a dispatched lane child ends its turn on a denial. Where the calls meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the call genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
-var WHOLE_FILE_WRITE_TOOL = "Write";
-var EDIT_TOOL = "Edit";
-function is_guarded_call(call) {
-  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
-  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
-}
-function is_notice_call(call) {
-  return call.name === WHOLE_FILE_WRITE_TOOL;
-}
-function is_read_only_call(call) {
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  return facts.is_bundleable && !facts.may_write;
-}
-function depends_on_sequence(sequence, facts) {
-  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
-}
-function sequence_started_ms(sequence) {
-  return sequence[0]?.ended_ms ?? NONE3;
-}
-function turns_since(sequence, last_fired_ms) {
-  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
-}
-function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
-  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
-  if (last_fired_ms < sequence_started_ms(sequence)) return true;
-  return turns_since(sequence, last_fired_ms) >= refire_every;
-}
-function is_at_limit(spans, call, last_fired_ms, refire_every) {
-  return is_sequence_at_limit(
-    time_bundles.open_sequence(spans),
-    time_bundle_call.call_facts(call.name, call.input),
-    last_fired_ms,
-    refire_every
-  );
-}
-var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
-function is_reissued_refusal(spans, call) {
-  const identity = time_call_identity.identity_of(
-    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
-  );
-  return spans.some(
-    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
-  );
-}
-function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
-  if (!is_guarded_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  if (is_reissued_refusal(spans, call)) return false;
-  return is_at_limit(spans, call, refused_at_ms, refire_every);
-}
-function should_notify(text, call, notified_at_ms) {
-  if (!is_notice_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
-}
-function describe_span(span) {
-  const target = span.targets[0] ?? "";
-  if (target === "" || span.label.includes(target)) return span.label;
-  return `${span.label} ${target}`;
-}
-var FOLD_MINIMUM = 2;
-function read_targets(sequence) {
-  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
-  return [...new Set(paths)];
-}
-function read_fold_directive(sequence) {
-  const paths = read_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
-}
-function write_targets(sequence) {
-  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
-  return [...new Set(paths)];
-}
-function write_fold_directive(sequence) {
-  const paths = write_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
-}
-function recent_candidates(tail) {
-  const recent = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT);
-  if (recent.length === NONE3) return "";
-  const named = recent.map((span) => describe_span(span)).join(", ");
-  const folds = `${read_fold_directive(recent)}${write_fold_directive(recent)}`;
-  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  LANE_NOTICE,
-  NOTICE,
-  NOTICE_REFIRE_EVERY,
-  NOTICE_STAMP_PREFIX,
-  REASON,
-  REFIRE_EVERY,
-  SEQUENCE_BEFORE_LIMIT,
-  STAMP_PREFIX,
-  is_guarded_call,
-  is_notice_call,
-  is_read_only_call,
-  recent_candidates,
-  should_block,
-  should_notify
-};
-
-export {
-  lane_guard_policy,
-  time_batch_guard
-};