@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/josh.js

@@ -678,8 +678,8 @@ function run_socket_probe(target2, kill_after_ms = PROBE_TIMEOUT_MS) {
   }).status ?? void 0;
 }
 function is_live_beacon(target2, probe = run_socket_probe) {
-  const own2 = beacons.get(`${BEACON_SCHEME}${target2}`);
-  if (own2 !== void 0) return own2.listening;
+  const own3 = beacons.get(`${BEACON_SCHEME}${target2}`);
+  if (own3 !== void 0) return own3.listening;
   const status2 = probe(target2);
   if (status2 === BEACON_LIVE_STATUS) return true;
   return status2 === BEACON_GONE_STATUS ? false : void 0;
@@ -884,89 +884,83 @@ var init_agent_session_environment = __esm({
   }
 });
 
-// scripts/agent/agent-provider.ts
-import { z as z7 } from "zod";
-function trimmed(value2) {
-  const result = value2?.trim();
-  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
-}
-function rejection(key2, value2, expected) {
-  return { kind: "rejected", note: `${key2}=${value2} ${expected}, so the agent was not started` };
-}
-function has_session(environment2, keys) {
-  return keys.some((key2) => trimmed(environment2[key2]) !== void 0);
-}
-function handed_provider(environment2) {
-  const value2 = trimmed(environment2[HANDED_PROVIDER_KEY]);
-  if (value2 === void 0) return DEFAULT_PROVIDER;
-  const parsed = PROVIDER_SCHEMA.safeParse(value2);
-  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value2, "is not an allowed provider");
-}
-function detected_provider(environment2) {
-  const has_codex = has_session(environment2, [CODEX_SESSION_KEY]);
-  const has_claude = has_session(environment2, agent_session_environment.PARENT_SESSION_KEYS);
-  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
-  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
-}
-function resolve_provider(environment2 = process.env) {
-  return detected_provider(environment2) ?? handed_provider(environment2);
-}
-function default_notice(environment2 = process.env) {
-  const selected = resolve_provider(environment2);
-  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
-}
-function warn_of_default(environment2 = process.env) {
-  const notice = default_notice(environment2).trim();
-  if (notice !== "") console.error(notice);
-}
-function has_completion_callback(environment2 = process.env) {
-  const selected = resolve_provider(environment2);
-  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
+// scripts/lane/lane-ledger-kind.ts
+var KIND, lane_ledger_kind;
+var init_lane_ledger_kind = __esm({
+  "scripts/lane/lane-ledger-kind.ts"() {
+    "use strict";
+    KIND = {
+      STARTUP: "startup",
+      MERGE: "merge",
+      GATE: "gate",
+      LOAD: "load",
+      DISPATCH: "dispatch",
+      STAGE: "stage",
+      STOP: "stop",
+      CHAIN: "chain",
+      OVERLAP: "overlap",
+      HELD: "held",
+      RELEASED: "released",
+      ROUND_ONE: "round-one",
+      ROUND_TWO: "round-two",
+      OFFERABLE: "offerable",
+      OFFER: "offer",
+      CORE_WAIT: "core-wait",
+      CORE_ADMISSION: "core-admission",
+      UNIT_FILES: "unit-files",
+      TEST_RELATED: "test-related",
+      TEST_PINNED: "test-pinned",
+      SPLIT_NOTICE: "split-notice",
+      SPLIT_FILED: "split-filed",
+      UNPLANNED_NOTICE: "unplanned-notice",
+      LANE_STATE: "lane-state",
+      PUSH_MISS: "push-miss",
+      EARLY_PUSH: "early-push",
+      SHIP_LAP: "ship-lap",
+      SIZE: "size",
+      LIMIT: "limit"
+    };
+    lane_ledger_kind = { KIND };
+  }
+});
+
+// scripts/lib/inherited-scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function storage(key2) {
+  const symbol = Symbol.for(key2);
+  const existing = Reflect.get(globalThis, symbol);
+  const scope3 = existing instanceof AsyncLocalStorage ? existing : new AsyncLocalStorage();
+  Reflect.set(globalThis, symbol, scope3);
+  return scope3;
 }
-function handoff_environment(environment2 = process.env) {
-  const selected = resolve_provider(environment2);
-  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
+function create(key2, schema) {
+  const scope3 = storage(key2);
+  function local() {
+    return schema.safeParse(scope3.getStore()).data;
+  }
+  function current() {
+    return local() ?? json_value.parse_with(process.env[key2] ?? "", schema);
+  }
+  async function within2(value2, run3) {
+    return await scope3.run(value2, run3);
+  }
+  function environment2() {
+    const value2 = current();
+    return value2 === void 0 ? {} : { [key2]: JSON.stringify(value2) };
+  }
+  return { current, local, within: within2, environment: environment2 };
 }
-var EMPTY_LENGTH, PROVIDER_SCHEMA, ANTHROPIC_PROVIDER, OPENAI_PROVIDER, CODEX_SESSION_KEY, CONFLICTING_SESSIONS, HANDED_PROVIDER_KEY, DEFAULT_PROVIDER, DEFAULT_NOTICE, agent_provider;
-var init_agent_provider = __esm({
-  "scripts/agent/agent-provider.ts"() {
+var inherited_scope;
+var init_inherited_scope = __esm({
+  "scripts/lib/inherited-scope.ts"() {
     "use strict";
-    init_agent_session_environment();
-    EMPTY_LENGTH = 0;
-    PROVIDER_SCHEMA = z7.enum(["anthropic", "openai"]);
-    ANTHROPIC_PROVIDER = "anthropic";
-    OPENAI_PROVIDER = "openai";
-    CODEX_SESSION_KEY = "CODEX_THREAD_ID";
-    CONFLICTING_SESSIONS = {
-      kind: "rejected",
-      note: "both Codex and Claude Code sessions were detected"
-    };
-    HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
-    DEFAULT_PROVIDER = {
-      kind: "provider",
-      provider: ANTHROPIC_PROVIDER,
-      is_default: true
-    };
-    DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
-    agent_provider = {
-      ANTHROPIC_PROVIDER,
-      CODEX_SESSION_KEY,
-      HANDED_PROVIDER_KEY,
-      OPENAI_PROVIDER,
-      PROVIDER_SCHEMA,
-      default_notice,
-      handoff_environment,
-      has_completion_callback,
-      rejection,
-      resolve_provider,
-      trimmed,
-      warn_of_default
-    };
+    init_json_value();
+    inherited_scope = { create };
   }
 });
 
 // scripts/git/git-ssh-keepalive.ts
-import { execa as execa3 } from "execa";
+import { execa } from "execa";
 function to_environment_value(name) {
   return process.env[name]?.trim() ?? "";
 }
@@ -978,7 +972,7 @@ async function has_configured_ssh_command() {
   if (to_configured_ssh_command() !== "") return true;
   try {
     const git_command_bin = git_utilities.get_git_command_for_spawn();
-    const { stdout } = await execa3(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
+    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
     return stdout.trim() !== "";
   } catch (error) {
     return has_timed_out(error);
@@ -1009,7 +1003,7 @@ var init_git_ssh_keepalive = __esm({
 });
 
 // scripts/git/git-push-transport.ts
-import { execa as execa4 } from "execa";
+import { execa as execa2 } from "execa";
 async function to_push_options() {
   return {
     stdio: "inherit",
@@ -1021,7 +1015,7 @@ async function did_push_time_out(arguments_list) {
   const git_command_bin = git_utilities.get_git_command_for_spawn();
   const options = await to_push_options();
   try {
-    await execa4(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
     return false;
   } catch (error) {
     if (has_timed_out(error)) return true;
@@ -1064,10 +1058,10 @@ var init_git_push_transport = __esm({
 });
 
 // scripts/git/git-spawn.ts
-import { execa as execa5 } from "execa";
+import { execa as execa3 } from "execa";
 async function read2(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
   const git_cmd = git_utilities.get_git_command_for_spawn();
-  const { stdout } = await execa5(git_cmd, arguments_, { timeout: timeout_ms });
+  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
   return stdout.trimEnd();
 }
 function to_budget_error(command, error, timeout_ms) {
@@ -1080,7 +1074,7 @@ function to_budget_error(command, error, timeout_ms) {
 async function spawn_remote(arguments_, options) {
   const git_cmd = git_utilities.get_git_command_for_spawn();
   try {
-    const { stdout } = await execa5(git_cmd, arguments_, options);
+    const { stdout } = await execa3(git_cmd, arguments_, options);
     return typeof stdout === "string" ? stdout.trimEnd() : "";
   } catch (error) {
     throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
@@ -1104,7 +1098,7 @@ async function with_output(command, arguments_list, options = {}) {
   const git_command_bin = git_utilities.get_git_command_for_spawn();
   const spawn_arguments = [...config_options, command, ...arguments_list];
   try {
-    await execa5(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
+    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
   } catch (error) {
     throw to_budget_error(command, error, timeout_ms);
   }
@@ -1800,6 +1794,87 @@ var init_durable_state = __esm({
   }
 });
 
+// scripts/agent/agent-provider.ts
+import { z as z6 } from "zod";
+function trimmed(value2) {
+  const result = value2?.trim();
+  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+}
+function rejection(key2, value2, expected) {
+  return { kind: "rejected", note: `${key2}=${value2} ${expected}, so the agent was not started` };
+}
+function has_session(environment2, keys) {
+  return keys.some((key2) => trimmed(environment2[key2]) !== void 0);
+}
+function handed_provider(environment2) {
+  const value2 = trimmed(environment2[HANDED_PROVIDER_KEY]);
+  if (value2 === void 0) return DEFAULT_PROVIDER;
+  const parsed = PROVIDER_SCHEMA.safeParse(value2);
+  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value2, "is not an allowed provider");
+}
+function detected_provider(environment2) {
+  const has_codex = has_session(environment2, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment2, agent_session_environment.PARENT_SESSION_KEYS);
+  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
+  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
+}
+function resolve_provider(environment2 = process.env) {
+  return detected_provider(environment2) ?? handed_provider(environment2);
+}
+function default_notice(environment2 = process.env) {
+  const selected = resolve_provider(environment2);
+  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
+}
+function warn_of_default(environment2 = process.env) {
+  const notice = default_notice(environment2).trim();
+  if (notice !== "") console.error(notice);
+}
+function has_completion_callback(environment2 = process.env) {
+  const selected = resolve_provider(environment2);
+  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
+}
+function handoff_environment(environment2 = process.env) {
+  const selected = resolve_provider(environment2);
+  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
+}
+var EMPTY_LENGTH, PROVIDER_SCHEMA, ANTHROPIC_PROVIDER, OPENAI_PROVIDER, CODEX_SESSION_KEY, CONFLICTING_SESSIONS, HANDED_PROVIDER_KEY, DEFAULT_PROVIDER, DEFAULT_NOTICE, agent_provider;
+var init_agent_provider = __esm({
+  "scripts/agent/agent-provider.ts"() {
+    "use strict";
+    init_agent_session_environment();
+    EMPTY_LENGTH = 0;
+    PROVIDER_SCHEMA = z6.enum(["anthropic", "openai"]);
+    ANTHROPIC_PROVIDER = "anthropic";
+    OPENAI_PROVIDER = "openai";
+    CODEX_SESSION_KEY = "CODEX_THREAD_ID";
+    CONFLICTING_SESSIONS = {
+      kind: "rejected",
+      note: "both Codex and Claude Code sessions were detected"
+    };
+    HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
+    DEFAULT_PROVIDER = {
+      kind: "provider",
+      provider: ANTHROPIC_PROVIDER,
+      is_default: true
+    };
+    DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
+    agent_provider = {
+      ANTHROPIC_PROVIDER,
+      CODEX_SESSION_KEY,
+      HANDED_PROVIDER_KEY,
+      OPENAI_PROVIDER,
+      PROVIDER_SCHEMA,
+      default_notice,
+      handoff_environment,
+      has_completion_callback,
+      rejection,
+      resolve_provider,
+      trimmed,
+      warn_of_default
+    };
+  }
+});
+
 // scripts/lib/cli-flags.ts
 import { parseArgs } from "node:util";
 function usage_line(known_flags, command) {
@@ -2027,7 +2102,7 @@ var init_run_invocation = __esm({
 
 // scripts/run/carry/run-carry-added.ts
 function issues_of2(added, is_priority) {
-  return added.filter((entry) => entry.is_priority === is_priority).map((entry) => entry.issue);
+  return added.filter((entry2) => entry2.is_priority === is_priority).map((entry2) => entry2.issue);
 }
 function ordered(declared2, added = []) {
   const sequence = [...issues_of2(added, true), ...declared2, ...issues_of2(added, false)];
@@ -2036,7 +2111,7 @@ function ordered(declared2, added = []) {
 function next_added(carry, additions) {
   const next = [...carry.added ?? []];
   for (const addition of additions) {
-    if (next.every((entry) => entry.issue !== addition.issue)) next.push(addition);
+    if (next.every((entry2) => entry2.issue !== addition.issue)) next.push(addition);
   }
   return next;
 }
@@ -2180,7 +2255,7 @@ var init_time_instant = __esm({
 });
 
 // scripts/cost-runtime/cost-usage.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 function split_cache_write(usage) {
   const total = usage.cache_creation_input_tokens ?? 0;
   const detail = usage.cache_creation;
@@ -2241,10 +2316,10 @@ function later_instant(left, right) {
 }
 function dedupe(records) {
   const by_id = /* @__PURE__ */ new Map();
-  for (const record2 of records) {
-    const seen = by_id.get(record2.request_id);
-    const at_ms = later_instant(seen?.at_ms, record2.at_ms);
-    by_id.set(record2.request_id, { ...seen ?? record2, at_ms });
+  for (const record4 of records) {
+    const seen = by_id.get(record4.request_id);
+    const at_ms = later_instant(seen?.at_ms, record4.at_ms);
+    by_id.set(record4.request_id, { ...seen ?? record4, at_ms });
   }
   return [...by_id.values()];
 }
@@ -2261,7 +2336,7 @@ function add_totals(left, right) {
 }
 function sum_totals(records) {
   let total = EMPTY_TOTALS;
-  for (const record2 of records) total = add_totals(total, record2.totals);
+  for (const record4 of records) total = add_totals(total, record4.totals);
   return total;
 }
 function billed_input(totals) {
@@ -2273,29 +2348,29 @@ var init_cost_usage = __esm({
     "use strict";
     init_json_value();
     init_time_instant();
-    CACHE_CREATION_SCHEMA = z8.object({
-      ephemeral_1h_input_tokens: z8.number().nullish(),
-      ephemeral_5m_input_tokens: z8.number().nullish()
+    CACHE_CREATION_SCHEMA = z7.object({
+      ephemeral_1h_input_tokens: z7.number().nullish(),
+      ephemeral_5m_input_tokens: z7.number().nullish()
     });
-    USAGE_SCHEMA = z8.object({
-      input_tokens: z8.number(),
-      cache_creation_input_tokens: z8.number().nullish(),
-      cache_read_input_tokens: z8.number().nullish(),
-      output_tokens: z8.number(),
-      output_tokens_details: z8.object({ thinking_tokens: z8.number().nullish() }).nullish(),
+    USAGE_SCHEMA = z7.object({
+      input_tokens: z7.number(),
+      cache_creation_input_tokens: z7.number().nullish(),
+      cache_read_input_tokens: z7.number().nullish(),
+      output_tokens: z7.number(),
+      output_tokens_details: z7.object({ thinking_tokens: z7.number().nullish() }).nullish(),
       cache_creation: CACHE_CREATION_SCHEMA.nullish()
     });
-    MESSAGE_SCHEMA = z8.object({
-      id: z8.string().nullish(),
-      model: z8.string().nullish(),
+    MESSAGE_SCHEMA = z7.object({
+      id: z7.string().nullish(),
+      model: z7.string().nullish(),
       usage: USAGE_SCHEMA.nullish()
     });
-    LINE_SCHEMA = z8.object({
-      type: z8.string(),
-      requestId: z8.string().nullish(),
-      uuid: z8.string().nullish(),
-      gitBranch: z8.string().nullish(),
-      timestamp: z8.string().nullish(),
+    LINE_SCHEMA = z7.object({
+      type: z7.string(),
+      requestId: z7.string().nullish(),
+      uuid: z7.string().nullish(),
+      gitBranch: z7.string().nullish(),
+      timestamp: z7.string().nullish(),
       message: MESSAGE_SCHEMA.nullish()
     });
     SYNTHETIC_MODEL = "<synthetic>";
@@ -2363,9 +2438,9 @@ function lane_transcript_directories(main_cwd, home) {
   ).map((name) => path18.join(projects, name));
 }
 function transcript_directories(cwd, home = homedir()) {
-  const own2 = transcript_directory(cwd, home);
+  const own3 = transcript_directory(cwd, home);
   const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
-  return [.../* @__PURE__ */ new Set([own2, ...lanes])];
+  return [.../* @__PURE__ */ new Set([own3, ...lanes])];
 }
 function home_directory() {
   return homedir();
@@ -2457,7 +2532,7 @@ function empty_session() {
     baseline_tokens: 0
   };
 }
-function tally2(content) {
+function tally(content) {
   const outcomes = content.split("\n").map((line2) => cost_usage.parse_line(line2));
   const records = outcomes.flatMap(
     (outcome) => outcome.kind === "record" ? [outcome.record] : []
@@ -2475,7 +2550,7 @@ function tally2(content) {
 function read_session(file) {
   const content = file_reader.read_if_readable(file.path);
   if (content === void 0) return { session_id: file.session_id, ...empty_session() };
-  return { session_id: file.session_id, ...tally2(content) };
+  return { session_id: file.session_id, ...tally(content) };
 }
 function read_raw(file) {
   return file_reader.read_if_readable(file.path) ?? "";
@@ -2544,7 +2619,7 @@ var init_cost_transcript = __esm({
       owning_session_id,
       parent_session_id,
       latest_own_index,
-      tally: tally2,
+      tally,
       read_session,
       read_raw,
       read_optional: read_optional2,
@@ -2633,8 +2708,117 @@ var init_run_carry_conversation = __esm({
   }
 });
 
+// scripts/lane/lane-child-mark-keys.ts
+var KEY, OVERRUN_KEY, MARK_KEYS, lane_child_mark_keys;
+var init_lane_child_mark_keys = __esm({
+  "scripts/lane/lane-child-mark-keys.ts"() {
+    "use strict";
+    KEY = "JOSH_LANE_CHILD";
+    OVERRUN_KEY = "JOSH_LANE_OVERRUN";
+    MARK_KEYS = [KEY, OVERRUN_KEY];
+    lane_child_mark_keys = { KEY, MARK_KEYS, OVERRUN_KEY };
+  }
+});
+
+// scripts/lane/lane-child-marker.ts
+function environment_for(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return { [KEY2]: issue, [CACHE_TTL_KEY]: CACHE_TTL };
+}
+function marked_issue(source = process.env) {
+  const value2 = source[KEY2];
+  if (value2 === void 0) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value2) ? value2 : void 0;
+}
+function overrun_environment_for(issue) {
+  return { ...environment_for(issue), [OVERRUN_KEY2]: OVERRUN_VALUE };
+}
+function is_overrun(source = process.env) {
+  return source[OVERRUN_KEY2] === OVERRUN_VALUE && marked_issue(source) !== void 0;
+}
+function is_child_of(directory, source = process.env) {
+  const marked = marked_issue(source);
+  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
+}
+var KEY2, OVERRUN_KEY2, CACHE_TTL_KEY, CACHE_TTL, OVERRUN_VALUE, lane_child_marker;
+var init_lane_child_marker = __esm({
+  "scripts/lane/lane-child-marker.ts"() {
+    "use strict";
+    init_issue_number_shape();
+    init_lane_child_mark_keys();
+    init_lane_paths();
+    ({ KEY: KEY2, OVERRUN_KEY: OVERRUN_KEY2 } = lane_child_mark_keys);
+    CACHE_TTL_KEY = "CLAUDE_CODE_PROMPT_CACHE_TTL";
+    CACHE_TTL = "5m";
+    OVERRUN_VALUE = "1";
+    lane_child_marker = {
+      KEY: KEY2,
+      OVERRUN_KEY: OVERRUN_KEY2,
+      env_for: environment_for,
+      overrun_env_for: overrun_environment_for,
+      is_child_of,
+      is_overrun,
+      marked_issue
+    };
+  }
+});
+
+// scripts/run/run-headless-keys.ts
+var HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY, MARK_KEYS2, run_headless_keys;
+var init_run_headless_keys = __esm({
+  "scripts/run/run-headless-keys.ts"() {
+    "use strict";
+    HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
+    HANDOFF_CHILD_KEY = "JOSH_HANDOFF_CHILD";
+    BESIDE_CHILD_KEY = "JOSH_BESIDE_CHILD";
+    MARK_KEYS2 = [HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY];
+    run_headless_keys = {
+      BESIDE_CHILD_KEY,
+      HANDOFF_CHILD_KEY,
+      HEADLESS_ENV_KEY,
+      MARK_KEYS: MARK_KEYS2
+    };
+  }
+});
+
+// scripts/run/carry/run-carry-session.ts
+function own2() {
+  if (lane_child_marker.marked_issue(process.env) !== void 0 || process.env[run_headless_keys.BESIDE_CHILD_KEY] === "1" || process.env[run_headless_keys.HANDOFF_CHILD_KEY] === "1") {
+    return void 0;
+  }
+  return process.env[KEY3];
+}
+function is_owned_by(carry, owner) {
+  if (carry.owner_session !== void 0) return carry.owner_session === owner.session;
+  if (run_carry_conversation.is_same_conversation(carry, owner)) return true;
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+}
+function retain_execution(carry, owner) {
+  if (owner.session === void 0 || owner.session !== carry.owner_session || owner.pid !== void 0) {
+    return owner;
+  }
+  return {
+    ...owner,
+    pid: carry.owner_pid,
+    start: carry.owner_start,
+    provider: carry.scheduler_provider,
+    is_headless: carry.is_owner_headless
+  };
+}
+var KEY3, run_carry_session;
+var init_run_carry_session = __esm({
+  "scripts/run/carry/run-carry-session.ts"() {
+    "use strict";
+    init_lane_child_marker();
+    init_run_headless_keys();
+    init_run_carry_conversation();
+    KEY3 = "JOSH_CARRY_SESSION";
+    run_carry_session = { KEY: KEY3, own: own2, is_owned_by, retain_execution };
+  }
+});
+
 // scripts/run/carry/run-carry.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function carry_path(git_directory2) {
   return durable_state.path(CARRY_PREFIX, git_directory2);
 }
@@ -2661,7 +2845,9 @@ function owner_of(pid, read3 = process_identity.read_start, transcript = run_car
 }
 function session_owner() {
   const pid = agent_session_environment.own_session_pid();
-  return pid === void 0 ? NO_OWNER : owner_of(pid);
+  const owner = pid === void 0 ? NO_OWNER : owner_of(pid);
+  const session = run_carry_session.own();
+  return session === void 0 ? owner : { ...owner, session };
 }
 function fresh_carry(invocation, owner, now) {
   return {
@@ -2674,6 +2860,7 @@ function fresh_carry(invocation, owner, now) {
     failures: NO_INCREMENT3,
     outages: NO_INCREMENT3,
     owner_pid: owner.pid,
+    owner_session: owner.session,
     owner_start: owner.start,
     owner_transcript: owner.transcript,
     is_owner_headless: owner.is_headless
@@ -2684,13 +2871,15 @@ function begin_carry(target2, invocation, owner = NO_OWNER, now = /* @__PURE__ *
   return stamp_file.create_stamp(target2, carry) ? carry : void 0;
 }
 function adopt_carry(target2, carry, owner = NO_OWNER) {
+  const next_owner = run_carry_session.retain_execution(carry, owner);
   const next = {
     ...carry,
-    scheduler_provider: owner.provider,
-    owner_pid: owner.pid,
-    owner_start: owner.start,
+    scheduler_provider: next_owner.provider,
+    owner_pid: next_owner.pid,
+    owner_session: owner.session,
+    owner_start: next_owner.start,
     owner_transcript: owner.transcript,
-    is_owner_headless: owner.is_headless,
+    is_owner_headless: next_owner.is_headless,
     is_handed_off: false
   };
   stamp_file.remove_stamp(target2);
@@ -2700,17 +2889,14 @@ function is_owner_live(carry, now = /* @__PURE__ */ new Date(), same_process = p
   if (same_process(carry.owner_pid, carry.owner_start) !== false) return true;
   return carry.is_owner_headless !== true && run_carry_conversation.is_conversation_live(carry, now);
 }
-function is_owned_by(carry, owner) {
-  if (run_carry_conversation.is_same_conversation(carry, owner)) return true;
-  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
-}
 function is_foreign_live_owner(carry, owner) {
-  return is_owner_live(carry) && !is_owned_by(carry, owner);
+  return is_owner_live(carry) && !is_owned_by2(carry, owner);
+}
+function is_held_by_self(carry, caller = owner_of(process.pid)) {
+  return carry.owner_pid === caller.pid && carry.owner_start === caller.start;
 }
 function is_held_by_another(carry, is_live = is_owner_live) {
-  const caller = owner_of(process.pid);
-  const is_own = carry.owner_pid === caller.pid && carry.owner_start === caller.start;
-  return !is_own && is_live(carry);
+  return !is_held_by_self(carry) && is_live(carry);
 }
 function is_handed_off_to(carry, invocation) {
   return carry.is_handed_off === true && carry.invocation === invocation;
@@ -2780,7 +2966,7 @@ function unreadable_message() {
 function unknown_message() {
   return "This repository\u2019s git directory could not be read, so no run record was established.";
 }
-var CARRY_PREFIX, REPOSITORY_DIRECTORY_INDEX, NO_INCREMENT3, MAX_CUTS, END_COMMAND, RESUME_COMMAND, READ_COMMAND, NO_OWNER, carry_addition_schema, run_carry_schema, run_carry;
+var CARRY_PREFIX, REPOSITORY_DIRECTORY_INDEX, NO_INCREMENT3, MAX_CUTS, END_COMMAND, RESUME_COMMAND, READ_COMMAND, NO_OWNER, carry_addition_schema, run_carry_schema, is_owned_by2, run_carry;
 var init_run_carry = __esm({
   "scripts/run/carry/run-carry.ts"() {
     "use strict";
@@ -2795,6 +2981,7 @@ var init_run_carry = __esm({
     init_run_carry_added();
     init_run_carry_change();
     init_run_carry_conversation();
+    init_run_carry_session();
     CARRY_PREFIX = durable_state.PREFIX.CARRY;
     REPOSITORY_DIRECTORY_INDEX = 1;
     NO_INCREMENT3 = 0;
@@ -2803,32 +2990,34 @@ var init_run_carry = __esm({
     RESUME_COMMAND = "pnpm josh run:carry --resume";
     READ_COMMAND = "pnpm josh run:carry --json";
     NO_OWNER = {};
-    carry_addition_schema = z9.object({ issue: z9.number(), is_priority: z9.boolean() });
-    run_carry_schema = z9.object({
+    carry_addition_schema = z8.object({ issue: z8.number(), is_priority: z8.boolean() });
+    run_carry_schema = z8.object({
       scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional(),
-      invocation: z9.string(),
-      started_at: z9.string(),
-      merged: z9.number(),
-      merged_issues: z9.array(z9.number()).optional(),
-      filed: z9.number(),
-      cuts: z9.number(),
+      invocation: z8.string(),
+      started_at: z8.string(),
+      merged: z8.number(),
+      merged_issues: z8.array(z8.number()).optional(),
+      filed: z8.number(),
+      cuts: z8.number(),
       // Defaulted, so a record that lacks the streak parses with a zero streak rather than failing to read.
-      failures: z9.number().default(0),
-      outages: z9.number().default(0),
-      last_outage_at: z9.string().optional(),
+      failures: z8.number().default(0),
+      outages: z8.number().default(0),
+      last_outage_at: z8.string().optional(),
       // An absent owner reads as "no owner declared", which is the not-provably-live answer rather than a
       // live one.
-      owner_pid: z9.number().optional(),
-      owner_start: z9.string().optional(),
-      owner_transcript: z9.string().optional(),
-      is_owner_headless: z9.boolean().optional(),
-      is_handed_off: z9.boolean().optional(),
-      done: z9.array(z9.number()).optional(),
-      retrospective: z9.boolean().optional(),
-      added: z9.array(carry_addition_schema).optional(),
-      lane_limit: z9.number().int().positive().optional(),
-      launch_limit: z9.number().int().positive().optional()
+      owner_pid: z8.number().optional(),
+      owner_session: z8.string().optional(),
+      owner_start: z8.string().optional(),
+      owner_transcript: z8.string().optional(),
+      is_owner_headless: z8.boolean().optional(),
+      is_handed_off: z8.boolean().optional(),
+      done: z8.array(z8.number()).optional(),
+      retrospective: z8.boolean().optional(),
+      added: z8.array(carry_addition_schema).optional(),
+      lane_limit: z8.number().int().positive().optional(),
+      launch_limit: z8.number().int().positive().optional()
     });
+    ({ is_owned_by: is_owned_by2 } = run_carry_session);
     run_carry = {
       END_COMMAND,
       MAX_CUTS,
@@ -2851,6 +3040,7 @@ var init_run_carry = __esm({
       is_count_refused,
       is_foreign_live_owner,
       is_held_by_another,
+      is_held_by_self,
       is_owner_live,
       lost_message,
       nothing_to_resume_message,
@@ -2868,73 +3058,35 @@ var init_run_carry = __esm({
   }
 });
 
-// scripts/lane/lane-ledger-kind.ts
-var KIND, lane_ledger_kind;
-var init_lane_ledger_kind = __esm({
-  "scripts/lane/lane-ledger-kind.ts"() {
-    "use strict";
-    KIND = {
-      MERGE: "merge",
-      GATE: "gate",
-      LOAD: "load",
-      DISPATCH: "dispatch",
-      STAGE: "stage",
-      STOP: "stop",
-      CHAIN: "chain",
-      OVERLAP: "overlap",
-      HELD: "held",
-      RELEASED: "released",
-      ROUND_ONE: "round-one",
-      ROUND_TWO: "round-two",
-      OFFERABLE: "offerable",
-      OFFER: "offer",
-      CORE_WAIT: "core-wait",
-      UNIT_FILES: "unit-files",
-      TEST_RELATED: "test-related",
-      TEST_PINNED: "test-pinned",
-      SPLIT_NOTICE: "split-notice",
-      SPLIT_FILED: "split-filed",
-      UNPLANNED_NOTICE: "unplanned-notice",
-      LANE_STATE: "lane-state",
-      PUSH_MISS: "push-miss",
-      EARLY_PUSH: "early-push",
-      SHIP_LAP: "ship-lap",
-      SIZE: "size",
-      LIMIT: "limit"
-    };
-    lane_ledger_kind = { KIND };
-  }
-});
-
 // scripts/lane/lane-ledger-write.ts
 import { closeSync, constants as constants3, openSync, writeSync } from "node:fs";
-function target_of2(repository2) {
+function target_of(repository2) {
   return durable_state.path(LEDGER_PREFIX, repository2, LEDGER_SUFFIX);
 }
 async function target() {
   if (process.env["VITEST"] !== void 0) return void 0;
   try {
     const repository2 = await run_carry.repository_directory();
-    return repository2 === void 0 ? void 0 : target_of2(repository2);
+    return repository2 === void 0 ? void 0 : target_of(repository2);
   } catch {
     return void 0;
   }
 }
-function append2(path25, entry) {
+function append(path25, entry2) {
   const descriptor = openSync(path25, APPEND_FLAGS, LEDGER_FILE_MODE);
   try {
     if (!stamp_file.is_own_regular_file(path25)) {
       throw new Error("Ledger is not an owned regular file");
     }
-    writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR2}`);
+    writeSync(descriptor, `${JSON.stringify(entry2)}${LINE_SEPARATOR}`);
   } finally {
     closeSync(descriptor);
   }
 }
-async function record(entry, path25) {
+async function record(entry2, path25) {
   try {
     const destination = path25 ?? await target();
-    if (destination !== void 0) append2(destination, entry);
+    if (destination !== void 0) append(destination, entry2);
   } catch {
   }
 }
@@ -2963,8 +3115,8 @@ async function record_overlap(overlap, path25) {
   await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path25);
 }
 async function record_held(held, path25) {
-  const waiting = held.waiting ?? [];
-  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  const waiting2 = held.waiting ?? [];
+  const named = waiting2.length > 0 ? { waiting: [...waiting2] } : {};
   await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path25);
 }
 async function record_released(path25) {
@@ -2986,7 +3138,9 @@ async function record_round_two(round_two, path25) {
   await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path25);
 }
 async function record_core_wait(wait, path25) {
-  await record({ kind: KIND2.CORE_WAIT, at: now_iso(), ...wait }, path25);
+  const is_immediate = wait.admission_reason !== void 0 && wait.wait_reason === void 0;
+  const kind = is_immediate ? KIND2.CORE_ADMISSION : KIND2.CORE_WAIT;
+  await record({ kind, at: now_iso(), ...wait }, path25);
 }
 async function record_unit_files(files, path25) {
   await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path25);
@@ -3003,7 +3157,7 @@ async function record_split_notice(notice, path25) {
 async function record_split_filed(filed, path25) {
   const destination = path25 ?? await target();
   if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
-  append2(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
+  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
 }
 async function record_push_miss(miss, path25) {
   await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path25);
@@ -3020,7 +3174,7 @@ async function record_size(size, path25) {
 async function record_unplanned_notice(notice, path25) {
   await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path25);
 }
-var LEDGER_PREFIX, LEDGER_SUFFIX, LINE_SEPARATOR2, CI_WAIT_STAGE, CODERABBIT_WAIT_STAGE, CODERABBIT_RATE_LIMIT_STAGE, CODERABBIT_RETRIGGER_STAGE, PRE_DETACH_STAGE, ROUND_ONE_REUSED, LEDGER_FILE_MODE, O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY, APPEND_FLAGS, KIND2, lane_ledger_write;
+var LEDGER_PREFIX, LEDGER_SUFFIX, LINE_SEPARATOR, CI_WAIT_STAGE, CODERABBIT_WAIT_STAGE, CODERABBIT_RATE_LIMIT_STAGE, CODERABBIT_RETRIGGER_STAGE, PRE_DETACH_STAGE, ROUND_ONE_REUSED, LEDGER_FILE_MODE, O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY, APPEND_FLAGS, KIND2, lane_ledger_write;
 var init_lane_ledger_write = __esm({
   "scripts/lane/lane-ledger-write.ts"() {
     "use strict";
@@ -3030,7 +3184,7 @@ var init_lane_ledger_write = __esm({
     init_lane_ledger_kind();
     LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
     LEDGER_SUFFIX = ".jsonl";
-    LINE_SEPARATOR2 = "\n";
+    LINE_SEPARATOR = "\n";
     CI_WAIT_STAGE = "ci-wait";
     CODERABBIT_WAIT_STAGE = "coderabbit-wait";
     CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
@@ -3047,10 +3201,10 @@ var init_lane_ledger_write = __esm({
       CODERABBIT_RETRIGGER_STAGE,
       CODERABBIT_WAIT_STAGE,
       KIND: KIND2,
-      LINE_SEPARATOR: LINE_SEPARATOR2,
+      LINE_SEPARATOR,
       PRE_DETACH_STAGE,
       ROUND_ONE_REUSED,
-      append: append2,
+      append,
       record,
       record_chain,
       record_core_wait,
@@ -3078,7 +3232,7 @@ var init_lane_ledger_write = __esm({
       record_unit_files,
       record_unplanned_notice,
       target,
-      target_of: target_of2
+      target_of
     };
   }
 });
@@ -3088,31 +3242,21 @@ var run_ship_lap_exports = {};
 __export(run_ship_lap_exports, {
   run_ship_lap: () => run_ship_lap
 });
-import { AsyncLocalStorage } from "node:async_hooks";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 async function to_ledger2(lap) {
   await lane_ledger_write.record_ship_lap(lap);
 }
 async function within(issue, stage, run3, parent) {
-  return await scope.run({ issue: Number(issue), stage, parent }, run3);
+  return await scope2.within({ issue: Number(issue), stage, parent }, run3);
 }
-function inherited() {
-  const text = process.env[ENVIRONMENT_KEY];
-  if (text === void 0 || text === "") return void 0;
-  try {
-    return lap_scope_schema.safeParse(JSON.parse(text)).data;
-  } catch {
-    return void 0;
-  }
-}
-function current_scope() {
-  return scope.getStore() ?? inherited();
+function current_scope2() {
+  return scope2.current();
 }
 function environment(parent) {
-  const current = current_scope();
+  const current = current_scope2();
   if (current === void 0) return {};
   return {
-    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
+    [ENVIRONMENT_KEY2]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
   };
 }
 function lap_of(current, step, started_ms, note) {
@@ -3124,12 +3268,12 @@ function no_note() {
   return {};
 }
 async function record_startup(current, sink, is_wanted) {
-  if (!is_wanted || startup.recorded || scope.getStore() !== void 0) return;
+  if (!is_wanted || startup.recorded || scope2.local() !== void 0) return;
   startup.recorded = true;
   await sink(lap_of(current, STARTUP_STEP, 0, {}));
 }
 async function timed(step, run3, { sink = to_ledger2, note_of = no_note, startup: with_startup } = {}) {
-  const current = current_scope();
+  const current = current_scope2();
   if (current === void 0) return await run3();
   await record_startup(current, sink, with_startup !== false);
   const started_ms = performance.now();
@@ -3142,18 +3286,19 @@ async function timed(step, run3, { sink = to_ledger2, note_of = no_note, startup
     await sink(lap_of(current, step, started_ms, noted.note));
   }
 }
-var ENVIRONMENT_KEY, PARENT_SEPARATOR, STARTUP_STEP, lap_scope_schema, STEP, scope, startup, run_ship_lap;
+var ENVIRONMENT_KEY2, PARENT_SEPARATOR, STARTUP_STEP, lap_scope_schema, STEP, scope2, startup, run_ship_lap;
 var init_run_ship_lap = __esm({
   "scripts/run/ship/run-ship-lap.ts"() {
     "use strict";
     init_lane_ledger_write();
-    ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
+    init_inherited_scope();
+    ENVIRONMENT_KEY2 = "JOSH_SHIP_LAP_SCOPE";
     PARENT_SEPARATOR = " \u203A ";
     STARTUP_STEP = "startup";
-    lap_scope_schema = z12.object({
-      issue: z12.number(),
-      stage: z12.string(),
-      parent: z12.string().optional()
+    lap_scope_schema = z13.object({
+      issue: z13.number(),
+      stage: z13.string(),
+      parent: z13.string().optional()
     });
     STEP = {
       PRECONDITIONS: "preconditions",
@@ -3165,9 +3310,9 @@ var init_run_ship_lap = __esm({
       PUSH: "push",
       COMMIT: "josh git"
     };
-    scope = new AsyncLocalStorage();
+    scope2 = inherited_scope.create(ENVIRONMENT_KEY2, lap_scope_schema);
     startup = { recorded: false };
-    run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
+    run_ship_lap = { ENVIRONMENT_KEY: ENVIRONMENT_KEY2, STARTUP_STEP, STEP, environment, timed, within };
   }
 });
 
@@ -4538,6 +4683,14 @@ var ISSUE_WRITE_COMMANDS = {
           names: ["--no-auto-ok"],
           description: "needs human judgement or a verified user prohibition; no `auto-ok`."
         },
+        {
+          names: ["--prepare"],
+          description: "create an unpublished child; `--route split` implies this."
+        },
+        {
+          names: ["--publish <E>"],
+          description: "validate/publish epic E's prepared children; retry the same epic on failure."
+        },
         {
           names: ["--release"],
           description: "a consumer can use the change only once it is published. The filed issue becomes a blocker of the target's release issue (step 10)."
@@ -5297,7 +5450,7 @@ var RUN_COMMANDS = {
     // A `--halfrun-stop` / `--human-review-stop` / `--prrun-stop` sends the stop confirmation.
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
     reference: [
-      "[<issue> [--fullrun | --halfrun-stop | --human-review-stop | --prrun-stop]] | --adopt <issue>",
+      "[<issue> [--fullrun | --halfrun-stop | --halfrun-round | --human-review-stop | --prrun-stop]] | --adopt <issue>",
       "automation",
       ["files"]
     ],
@@ -5317,6 +5470,10 @@ var RUN_COMMANDS = {
           names: ["--halfrun-stop"],
           description: "marks a `halfrun` stop for `run:entry` to adopt, and sends its `confirmation` Telegram; answers `e2e-owed` (exit 1) until `test:e2e` answered green on this tree."
         },
+        {
+          names: ["--halfrun-round"],
+          description: "starts a `halfrun` fix round: re-opens the issue's stopped `halfrun` record as running, owned by this session; answers `busy` (exit 1) when the tree holds no such stop."
+        },
         {
           names: ["--human-review-stop"],
           description: "marks a `halfrun` stop and a `human-review` lane, retaining its tree and hold. Sends `confirmation`; its worker's exit frees the execution place. Answers `e2e-owed` (exit 1) until `test:e2e` is green on this tree."
@@ -5622,7 +5779,7 @@ var SHIP_COMMANDS = {
     description: "Start test:pinned in the background, run the gate and, once it is green, write the /code-review brief to a file, printing its path (--join to join them; it stops on an unpinned change)",
     category: "AI tools",
     reference: [
-      '[--code-only] [--unpinned-ok "<reason>"] | --join [--fixing] | --pinned | --push',
+      '[--code-only] [--unpinned-ok "<reason>"] | --join [--fixing] | --pinned | --push [<slots>]',
       "automation",
       ["processes", "files", "git", "network"]
     ],
@@ -5650,11 +5807,11 @@ var SHIP_COMMANDS = {
         },
         {
           arguments: "--pinned",
-          note: "read test:pinned alone (the ship's pre-detach reads it anyway); a lane child returns at once"
+          note: "collect a stopped ship's remaining verdicts before editing or retrying; a lane child waits only for this continuation"
         },
         {
-          arguments: "--push",
-          note: "launched by a lane open: push and open the PR at a green gate"
+          arguments: "--push 2",
+          note: "launched by a lane open: push and open the PR at a green gate, recording the review plan\u2019s slot count on the ledger"
         }
       ]
     }
@@ -5750,7 +5907,7 @@ var SHIP_COMMANDS = {
         { names: ["--notify-message <text>"], description: "forwarded to `followup` alone." },
         {
           names: ["--review"],
-          description: "runs round 1 beside the gate; after sync and round 1, an owed round 2 runs beside the gate and joins before the PR opens. A High or unfixed Medium stops the ship. A pre-detach `test:pinned` stop probes remaining hunks in the background for the next pre-detach."
+          description: "runs round 1 beside the gate; after sync and round 1, an owed round 2 runs beside the gate and joins before the PR opens. A High or unfixed Medium stops the ship. After a pre-detach `test:pinned` stop, collect remaining verdicts with `pnpm josh run:review --pinned` before editing or retrying."
         },
         {
           names: ["--unpinned-ok <reason>"],
@@ -6316,7 +6473,7 @@ var AI_COMMANDS = {
   },
   "lane:stats": {
     ...MEASURE_ARGUMENTS,
-    description: "Print period lane throughput, stage, stop (by failed CI check, longest first), check and machine-load statistics; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs",
+    description: "Print period lane throughput, stage, stop (by failed CI check, longest first), check, runnable-to-dispatch wait and machine-load statistics; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs",
     category: "AI tools",
     reference: [
       "(--period <days> | --since <instant>) [--limit <lane-limit> | --sinks [<minutes>] | --over <minutes> | --why <minutes> | --pairs]",
@@ -6494,12 +6651,12 @@ var GATE_UNVERIFIED_PREFIX = `${WARN_ICON2} ${GATE_SUBJECT} not verified`;
 var PASSED_VERDICT = "passed";
 var FAILED_VERDICT = "failed";
 var UNVERIFIED_VERDICT = "unverified";
-function format_counts(counts) {
-  if (counts.skipped === 0) return `${String(counts.ran)} checks`;
-  return `${String(counts.ran)} ran, ${String(counts.skipped)} skipped`;
+function format_counts(counts2) {
+  if (counts2.skipped === 0) return `${String(counts2.ran)} checks`;
+  return `${String(counts2.ran)} ran, ${String(counts2.skipped)} skipped`;
 }
-function format_gate_passed(counts, total) {
-  return `${GATE_PASSED_PREFIX} (${format_counts(counts)}) in ${total}.`;
+function format_gate_passed(counts2, total) {
+  return `${GATE_PASSED_PREFIX} (${format_counts(counts2)}) in ${total}.`;
 }
 function format_gate_unverified(skipped, total) {
   return `${GATE_UNVERIFIED_PREFIX} (0 ran, ${String(skipped)} skipped) in ${total}.`;
@@ -6590,6 +6747,7 @@ init_json_value();
 import path11 from "node:path";
 import { z as z3 } from "zod";
 var STATE_SUFFIX = ".json";
+var DEPENDENCY_WAIT_COMMAND = "lane:dependency-wait";
 var HUMAN_REVIEW = "human-review";
 var LANE_STATES = ["open", "running", "paused", HUMAN_REVIEW, "ended"];
 var IDLE_STATES = /* @__PURE__ */ new Set(["paused", HUMAN_REVIEW, "ended"]);
@@ -6616,10 +6774,11 @@ function read_record_file(source) {
   return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema);
 }
 function is_idle(state_root3, common, issue) {
-  const record2 = read_record_file(path11.join(state_root3, record_name(common, issue)));
-  return record2 !== void 0 && IDLE_STATES.has(record2.state);
+  const record4 = read_record_file(path11.join(state_root3, record_name(common, issue)));
+  return record4 !== void 0 && IDLE_STATES.has(record4.state);
 }
 var lane_state_record = {
+  DEPENDENCY_WAIT_COMMAND,
   HUMAN_REVIEW,
   LANE_STATES,
   STATE_SUFFIX,
@@ -6642,11 +6801,11 @@ function own_lane(checkout2, environment2) {
 function live_lane_count(checkout2 = process.cwd(), environment2 = process.env) {
   try {
     const lanes_root = lane_paths.lanes_root_of(checkout2, environment2);
-    const own2 = own_lane(checkout2, environment2);
+    const own3 = own_lane(checkout2, environment2);
     const issues = readdirSync(lanes_root).filter(
       (name) => issue_number_shape.ISSUE_NUMBER_PATTERN.test(name)
     );
-    return issues.filter((issue) => issue === own2 || !is_idle_lane(lanes_root, issue, environment2)).length;
+    return issues.filter((issue) => issue === own3 || !is_idle_lane(lanes_root, issue, environment2)).length;
   } catch {
     return 0;
   }
@@ -7293,7 +7452,7 @@ var DEV_COMMANDS = {
   },
   "lint:related": {
     script: "scripts/lint/lint-related.ts",
-    description: "Check only the changed files with prettier and eslint, and in kit the source guard tests (whole tree on fallback)",
+    description: "Apply eslint fixes and prettier to the resolved scope, then check remaining errors and in kit the source guard tests (whole tree on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
     core_weight: core_weights.CORE_WEIGHTS.lint,
@@ -8645,11 +8804,11 @@ function format_usage(name) {
 }
 function format_command_help(input) {
   const name = canonical_command(input);
-  const entry = Object.hasOwn(COMMAND_MAP, name) ? COMMAND_MAP[name] : void 0;
-  if (entry === void 0) return void 0;
-  const [synopsis] = entry.reference;
+  const entry2 = Object.hasOwn(COMMAND_MAP, name) ? COMMAND_MAP[name] : void 0;
+  if (entry2 === void 0) return void 0;
+  const [synopsis] = entry2.reference;
   const head = synopsis ? `josh ${name} ${synopsis}` : `josh ${name}`;
-  return [head, "", entry.description, "", format_usage(name)].join("\n");
+  return [head, "", entry2.description, "", format_usage(name)].join("\n");
 }
 var command_usage = {
   USAGE_PAGES,
@@ -8660,7 +8819,7 @@ var command_usage = {
 // scripts/gh/gh-core-rate-limit.ts
 init_json_value();
 init_timeouts();
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 
 // scripts/gh/git-gh-exec.ts
 init_git_execa_error();
@@ -8677,8 +8836,8 @@ function throw_first_failure(failures) {
   throw first;
 }
 async function drain(pool, worker) {
-  for (let entry = pool.queue.shift(); entry !== void 0 && pool.failures.length === 0; entry = pool.queue.shift()) {
-    const [index, item] = entry;
+  for (let entry2 = pool.queue.shift(); entry2 !== void 0 && pool.failures.length === 0; entry2 = pool.queue.shift()) {
+    const [index, item] = entry2;
     try {
       pool.results.push({ index, value: await worker(item, index) });
     } catch (error) {
@@ -8701,20 +8860,20 @@ async function bounded_map(items, limit, worker) {
 }
 function limiter(limit) {
   const width = pool_width(limit, Infinity);
-  const waiting = [];
+  const waiting2 = [];
   let active = 0;
   return {
     async run(task) {
       if (active < width) active += 1;
       else {
         await new Promise((resolve2) => {
-          waiting.push(resolve2);
+          waiting2.push(resolve2);
         });
       }
       try {
         return await task();
       } finally {
-        const next = waiting.shift();
+        const next = waiting2.shift();
         if (next === void 0) active -= 1;
         else next();
       }
@@ -8788,7 +8947,7 @@ function redact(text) {
 function string_leaves(value2) {
   if (typeof value2 === "string") return [value2];
   if (typeof value2 !== "object" || value2 === null) return [];
-  return Object.values(value2).flatMap((entry) => string_leaves(entry));
+  return Object.values(value2).flatMap((entry2) => string_leaves(entry2));
 }
 function decoded(body) {
   const value2 = json_value.parse_or_undefined(body);
@@ -8806,7 +8965,7 @@ var token_shape = {
 };
 
 // scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync as execaSync2 } from "execa";
+import { execa as execa5, execaSync as execaSync2 } from "execa";
 
 // scripts/rules/git-argv.ts
 var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
@@ -9133,6 +9292,196 @@ function class_of(kind) {
 }
 var gh_call_kind = { of, of_api, class_of };
 
+// scripts/run/startup/run-startup.ts
+init_stamp_file();
+init_lane_ledger_kind();
+init_inherited_scope();
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// scripts/run/startup/run-startup-schema.ts
+init_lane_ledger_kind();
+import { z as z5 } from "zod";
+var scope_schema = z5.object({
+  run: z5.string(),
+  attempt: z5.string(),
+  issue: z5.string().optional(),
+  span: z5.string().optional(),
+  parent: z5.string().optional(),
+  destination: z5.string().optional()
+});
+var entry_schema = scope_schema.omit({ destination: true }).extend({
+  kind: z5.literal(lane_ledger_kind.KIND.STARTUP),
+  at: z5.string(),
+  at_ms: z5.number().nonnegative().optional(),
+  id: z5.string(),
+  parent: z5.string().optional(),
+  phase: z5.string(),
+  edge: z5.enum(["start", "done", "failed", "waiting", "api", "cache"]),
+  elapsed_ms: z5.number().nonnegative().optional(),
+  metric: z5.string().optional(),
+  key: z5.string().optional()
+});
+var run_startup_schema = { scope_schema, entry_schema };
+
+// scripts/run/startup/run-startup-store.ts
+init_lane_ledger_write();
+init_run_carry();
+import { randomUUID as randomUUID3 } from "node:crypto";
+async function carried_identity(issue) {
+  const repository2 = await run_carry.repository_directory();
+  if (repository2 === void 0) return void 0;
+  const read3 = run_carry.read_carry(run_carry.carry_path(repository2));
+  if (read3.kind !== "carried") return void 0;
+  return {
+    run: `${repository2}:${read3.carry.started_at}`,
+    attempt: randomUUID3(),
+    destination: lane_ledger_write.target_of(repository2),
+    ...issue !== void 0 && { issue }
+  };
+}
+async function identity(issue) {
+  try {
+    if (process.env["VITEST"] !== void 0) return void 0;
+    return await carried_identity(issue);
+  } catch {
+    return void 0;
+  }
+}
+async function record2(entry2, destination) {
+  await lane_ledger_write.record(entry2, destination);
+}
+function counts(rows, edge) {
+  const result = {};
+  for (const row of rows) {
+    if (row.edge !== edge) continue;
+    const key2 = row.metric ?? "unknown";
+    result[key2] = (result[key2] ?? 0) + 1;
+  }
+  return result;
+}
+function is_terminal(row) {
+  return row.edge === "done" || row.edge === "failed" || row.edge === "waiting";
+}
+function summary(start, rows) {
+  const ending = rows.find(is_terminal);
+  return {
+    start,
+    status: ending?.edge ?? "incomplete",
+    elapsed_ms: ending?.elapsed_ms,
+    api: counts(rows, "api"),
+    cache: counts(rows, "cache")
+  };
+}
+function by_span(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of entries) {
+    const group = groups.get(row.id) ?? [];
+    group.push(row);
+    groups.set(row.id, group);
+  }
+  return groups;
+}
+function summarize(entries) {
+  const groups = by_span(entries);
+  return entries.filter((row) => row.edge === "start").map((start) => summary(start, groups.get(start.id) ?? []));
+}
+function timestamp(row) {
+  return row.at_ms ?? Date.parse(row.at);
+}
+function before_end(row, other, endings) {
+  const end = endings.get(other.id);
+  return end !== void 0 && timestamp(row) < end;
+}
+function overlaps(left, right, endings) {
+  if (left.id === right.id || left.key !== right.key) return false;
+  return before_end(left, right, endings) && before_end(right, left, endings);
+}
+function concurrent_misses(entries) {
+  const fills = entries.filter((row) => row.edge === "cache" && row.metric === "fill");
+  const endings = new Map(entries.filter(is_terminal).map((row) => [row.id, timestamp(row)]));
+  return fills.filter((row) => fills.some((other) => overlaps(row, other, endings)));
+}
+var run_startup_store = { identity, record: record2, summarize, concurrent_misses };
+
+// scripts/run/startup/run-startup.ts
+var ENVIRONMENT_KEY = "JOSH_STARTUP_SCOPE";
+var scope = inherited_scope.create(ENVIRONMENT_KEY, run_startup_schema.scope_schema);
+async function record3(row) {
+  try {
+    await run_startup_store.record(row, scope.current()?.destination);
+  } catch {
+  }
+}
+function entry(current, name, edge) {
+  return run_startup_schema.entry_schema.parse({
+    ...current,
+    kind: lane_ledger_kind.KIND.STARTUP,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    at_ms: performance.timeOrigin + performance.now(),
+    id: current.span ?? randomUUID4(),
+    phase: name,
+    edge
+  });
+}
+async function completed(name, run3, options) {
+  const current = scope.current();
+  if (current === void 0) return await run3();
+  const started = performance.now();
+  await record3(entry(current, name, "start"));
+  const ending = { edge: "failed" };
+  try {
+    const value2 = await run3();
+    ending.edge = options.edge_of?.(value2) ?? "done";
+    return value2;
+  } finally {
+    await record3({ ...entry(current, name, ending.edge), elapsed_ms: performance.now() - started });
+  }
+}
+async function current_scope(options) {
+  return scope.current() ?? (options.root === true ? await run_startup_store.identity(options.issue) : void 0);
+}
+async function phase(name, run3, options = {}) {
+  const current = await current_scope(options);
+  if (current === void 0) return await run3();
+  const next = {
+    ...current,
+    parent: current.span,
+    span: randomUUID4(),
+    ...options.issue !== void 0 && { issue: options.issue }
+  };
+  return await scope.within(next, async () => await completed(name, run3, options));
+}
+function metric(edge, name, key2) {
+  const current = scope.current();
+  if (current === void 0) return;
+  void record3({
+    ...entry(current, "", edge),
+    metric: name,
+    ...key2 !== void 0 && { key: stamp_file.digest(key2) }
+  });
+}
+async function waiting(name) {
+  const current = scope.current();
+  const started = performance.now();
+  const place2 = { ...current, span: randomUUID4(), parent: current?.span };
+  if (current !== void 0) await record3(entry({ ...current, ...place2 }, name, "start"));
+  return async () => {
+    if (current === void 0) return;
+    await record3({
+      ...entry({ ...current, ...place2 }, name, "waiting"),
+      elapsed_ms: performance.now() - started
+    });
+  };
+}
+var run_startup = {
+  ENVIRONMENT_KEY,
+  phase,
+  metric,
+  waiting,
+  environment: scope.environment,
+  within: scope.within
+};
+
 // scripts/gh/gh-request-tally.ts
 var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
 function is_state(value2) {
@@ -9149,7 +9498,7 @@ function shared_state() {
   Reflect.set(globalThis, STATE_KEY, state2);
   return state2;
 }
-var { tally, endpoints, core } = shared_state();
+var { tally: tally2, endpoints, core } = shared_state();
 function watch_core(read3) {
   core.read = async () => {
     try {
@@ -9166,15 +9515,16 @@ function endpoint_of(kind) {
 }
 function snapshot() {
   const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
-  return { ...tally, endpoints: Object.fromEntries(entries) };
+  return { ...tally2, endpoints: Object.fromEntries(entries) };
 }
 function count_call(kind) {
+  run_startup.metric("api", gh_call_kind.class_of(kind));
   if (core.read !== void 0) core.start ??= core.read();
-  tally.calls += 1;
+  tally2.calls += 1;
   endpoint_of(kind).calls += 1;
 }
 function count_not_modified(kind) {
-  tally.not_modified += 1;
+  tally2.not_modified += 1;
   endpoint_of(kind).not_modified += 1;
 }
 function to_delta(start, end) {
@@ -9187,8 +9537,8 @@ async function core_delta() {
   return to_delta(start, end);
 }
 function reset() {
-  tally.calls = 0;
-  tally.not_modified = 0;
+  tally2.calls = 0;
+  tally2.not_modified = 0;
   endpoints.clear();
   core.read = void 0;
   core.start = void 0;
@@ -9204,12 +9554,12 @@ var gh_request_tally = {
 
 // scripts/gh/git-gh-check.ts
 init_timeouts();
-import { execa } from "execa";
+import { execa as execa4 } from "execa";
 var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
 var gh_check = {};
 async function run_gh_check() {
   try {
-    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
+    await execa4("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
   } catch {
     delete gh_check.promise;
     throw new Error(GH_NOT_INSTALLED_MSG);
@@ -9235,8 +9585,8 @@ var parse_json = {
 };
 
 // scripts/gh/git-gh-failure.ts
-import { z as z5 } from "zod";
-var error_document_schema = z5.object({ status: z5.union([z5.string(), z5.number()]).optional() }).catch({});
+import { z as z9 } from "zod";
+var error_document_schema = z9.object({ status: z9.union([z9.string(), z9.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_stdout_field(error) {
   return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
@@ -9392,9 +9742,9 @@ function to_timeout_prefix(error) {
 function to_gh_error(error) {
   const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
   const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
-  const detail = stdout.length > 0 ? `${summary}
-${stdout}` : summary;
+  const summary2 = stderr.length > 0 ? stderr : error_text.message_of(error);
+  const detail = stdout.length > 0 ? `${summary2}
+${stdout}` : summary2;
   return gh_failure.attach(
     new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
     gh_failure.classify_stdout(stdout)
@@ -9406,7 +9756,7 @@ async function spawn_gh_command(arguments_, timeout_ms, cwd) {
   const options = to_spawn_options(timeout_ms, cwd);
   gh_request_tally.count_call(gh_call_kind.of(arguments_));
   try {
-    const { stdout } = await execa2("gh", arguments_, options);
+    const { stdout } = await execa5("gh", arguments_, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -9420,7 +9770,7 @@ async function spawn_gh_command_with_stdin(input) {
   const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
   gh_request_tally.count_call(gh_call_kind.of(input.args));
   try {
-    const { stdout } = await execa2("gh", input.args, options);
+    const { stdout } = await execa5("gh", input.args, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -9442,7 +9792,7 @@ async function spawn_gh_api_status(path25, timeout_ms) {
   try {
     await check_gh_installed();
     gh_request_tally.count_call(gh_call_kind.of_api(path25));
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path25], options);
+    const { stdout } = await execa5("gh", ["api", "--include", "--silent", path25], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -9511,7 +9861,7 @@ async function exec_gh_api(request) {
 async function exec_gh_api_uncounted(request) {
   const options = to_spawn_options(request.timeout_ms, request.cwd);
   try {
-    const { stdout } = await execa2("gh", to_gh_api_args(request), options);
+    const { stdout } = await execa5("gh", to_gh_api_args(request), options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -9552,13 +9902,13 @@ var git_gh_exec = {
 
 // scripts/gh/gh-core-rate-limit.ts
 var FRESH_MS = 3e4;
-var core_schema = z6.object({
-  used: z6.number().int().nonnegative(),
-  remaining: z6.number().int().nonnegative(),
-  limit: z6.number().int().positive(),
-  reset: z6.number().int().nonnegative()
+var core_schema = z10.object({
+  used: z10.number().int().nonnegative(),
+  remaining: z10.number().int().nonnegative(),
+  limit: z10.number().int().positive(),
+  reset: z10.number().int().nonnegative()
 });
-var resources_schema = z6.object({
+var resources_schema = z10.object({
   core: core_schema,
   graphql: core_schema.optional().catch(void 0)
 });
@@ -9579,8 +9929,8 @@ function kept_reader(request, schema) {
   const kept = /* @__PURE__ */ new Map();
   return async function read3(exec) {
     const now_ms = Date.now();
-    const entry = kept.get(exec);
-    if (entry !== void 0 && now_ms - entry.at_ms < FRESH_MS) return entry.value;
+    const entry2 = kept.get(exec);
+    if (entry2 !== void 0 && now_ms - entry2.at_ms < FRESH_MS) return entry2.value;
     const value2 = await read_with(exec, request, schema);
     if (value2 !== void 0) kept.set(exec, { at_ms: now_ms, value: value2 });
     return value2;
@@ -9621,7 +9971,7 @@ init_run_carry();
 
 // scripts/git/repository-lock.ts
 init_process_identity();
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { linkSync, renameSync as renameSync2, rmSync as rmSync5 } from "node:fs";
 init_stamp_file();
 init_json_value();
@@ -9719,7 +10069,7 @@ function stale_record(target2, is_gone) {
   return owner !== void 0 && is_gone(owner) ? raw : void 0;
 }
 function move_aside(target2) {
-  const aside = `${target2}.${String(process.pid)}.${randomUUID3()}`;
+  const aside = `${target2}.${String(process.pid)}.${randomUUID5()}`;
   try {
     renameSync2(target2, aside);
     return aside;
@@ -9791,26 +10141,26 @@ var USAGE_SUFFIX = ".jsonl";
 var USAGE_CAP = 2e3;
 var LOCK_SUFFIX = ".lock";
 var LOCK_WAIT_MS = 5e3;
-var LINE_SEPARATOR = "\n";
-function target_of(repository2) {
+var LINE_SEPARATOR2 = "\n";
+function target_of2(repository2) {
   return durable_state.path(durable_state.PREFIX.GH_USAGE, repository2, USAGE_SUFFIX);
 }
 function read_lines(target2) {
   const raw = stamp_file.read_stamp_text(target2) ?? "";
-  return raw.split(LINE_SEPARATOR).filter((line2) => line2 !== "");
+  return raw.split(LINE_SEPARATOR2).filter((line2) => line2 !== "");
 }
 function append_held(target2, line2) {
   const lines = [...read_lines(target2), line2].slice(-USAGE_CAP);
-  stamp_file.replace_text_stamp(target2, `${lines.join(LINE_SEPARATOR)}${LINE_SEPARATOR}`);
+  stamp_file.replace_text_stamp(target2, `${lines.join(LINE_SEPARATOR2)}${LINE_SEPARATOR2}`);
   return true;
 }
-function append(target2, record2) {
+function append2(target2, record4) {
   const lock = `${target2}${LOCK_SUFFIX}`;
-  const line2 = JSON.stringify(record2);
+  const line2 = JSON.stringify(record4);
   if (repository_lock.with_lock_sync(() => append_held(target2, line2), lock, LOCK_WAIT_MS)) return;
   throw new Error(`gh usage log: gave up waiting for the lock at ${lock}`);
 }
-var gh_usage_log = { USAGE_CAP, append, read_lines, target_of };
+var gh_usage_log = { USAGE_CAP, append: append2, read_lines, target_of: target_of2 };
 
 // scripts/gh/gh-usage-event.ts
 var state = { is_written: false };
@@ -9883,86 +10233,46 @@ var NOT_ON_PATH_NOTICE = [
 ].join("\n");
 
 // scripts/lib/schemas.ts
-import { z as z10 } from "zod";
-var overrides_snapshot_schema = z10.record(z10.string(), z10.string());
-var package_version_schema = z10.object({ version: z10.string() });
-var package_named_version_schema = z10.looseObject({ name: z10.string(), version: z10.string() });
-var package_with_version_schema = z10.looseObject({ version: z10.string() });
-var ls_global_dependency_schema = z10.looseObject({ version: z10.string() });
-var ls_global_dependencies_schema = z10.record(z10.string(), ls_global_dependency_schema).optional();
-var pnpm_ls_global_schema = z10.array(
-  z10.looseObject({
+import { z as z11 } from "zod";
+var overrides_snapshot_schema = z11.record(z11.string(), z11.string());
+var package_version_schema = z11.object({ version: z11.string() });
+var package_named_version_schema = z11.looseObject({ name: z11.string(), version: z11.string() });
+var package_with_version_schema = z11.looseObject({ version: z11.string() });
+var ls_global_dependency_schema = z11.looseObject({ version: z11.string() });
+var ls_global_dependencies_schema = z11.record(z11.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z11.array(
+  z11.looseObject({
     dependencies: ls_global_dependencies_schema
   })
 );
-var vscode_settings_schema = z10.record(z10.string(), z10.unknown());
-var with_scripts_schema = z10.looseObject({
-  scripts: z10.record(z10.string(), z10.string()).optional()
+var vscode_settings_schema = z11.record(z11.string(), z11.unknown());
+var with_scripts_schema = z11.looseObject({
+  scripts: z11.record(z11.string(), z11.string()).optional()
 });
-var with_development_deps_schema = z10.looseObject({
-  devDependencies: z10.record(z10.string(), z10.string()).optional()
+var with_development_deps_schema = z11.looseObject({
+  devDependencies: z11.record(z11.string(), z11.string()).optional()
 });
-var with_package_manager_schema = z10.looseObject({
-  packageManager: z10.string().optional()
+var with_package_manager_schema = z11.looseObject({
+  packageManager: z11.string().optional()
 });
-var with_development_engine_schema = z10.looseObject({
-  devEngines: z10.record(z10.string(), z10.unknown()).optional()
+var with_development_engine_schema = z11.looseObject({
+  devEngines: z11.record(z11.string(), z11.unknown()).optional()
 });
-var bin_entry_schema = z10.union([z10.string(), z10.record(z10.string(), z10.string())]).optional();
-var package_bin_schema = z10.looseObject({ bin: bin_entry_schema });
-var json_object_schema = z10.record(z10.string(), z10.unknown());
-var string_array_schema = z10.array(z10.string());
-var string_record_schema = z10.record(z10.string(), z10.string());
+var bin_entry_schema = z11.union([z11.string(), z11.record(z11.string(), z11.string())]).optional();
+var package_bin_schema = z11.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z11.record(z11.string(), z11.unknown());
+var string_array_schema = z11.array(z11.string());
+var string_record_schema = z11.record(z11.string(), z11.string());
 
 // scripts/gate/core-budget.ts
 init_platform_temporary();
 init_process_identity();
 init_stamp_file();
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { readdirSync as readdirSync5 } from "node:fs";
 import { availableParallelism as availableParallelism4 } from "node:os";
 import path21 from "node:path";
 
-// scripts/gate/busy-average.ts
-var AVERAGE_WINDOW_MS = 3e3;
-function with_reading(samples, reading, ledger_cores, now) {
-  const kept = samples.filter((sample) => now - sample.at < AVERAGE_WINDOW_MS);
-  const { busy_cores } = reading;
-  if (busy_cores === void 0) return kept;
-  return [...kept, { at: now, external_cores: Math.max(0, busy_cores - ledger_cores), busy_cores }];
-}
-function mean_busy(samples) {
-  if (samples.length === 0) return void 0;
-  let total = 0;
-  for (const sample of samples) total += sample.busy_cores;
-  return total / samples.length;
-}
-function averaged(reading, samples, ledger_cores) {
-  if (reading.busy_cores === void 0 || samples.length === 0) return reading;
-  let total = 0;
-  for (const sample of samples) total += sample.external_cores;
-  return { ...reading, busy_cores: ledger_cores + total / samples.length };
-}
-var EASE_CORES = 1;
-function with_ease(ease, busy_cores, now) {
-  if (busy_cores === void 0) return ease;
-  if (ease === void 0 || busy_cores <= ease.level - EASE_CORES) {
-    return { level: busy_cores, eased_at: now };
-  }
-  return ease;
-}
-function is_unrelieved(ease, now, window_ms) {
-  return ease !== void 0 && now - ease.eased_at >= window_ms;
-}
-var busy_average = {
-  AVERAGE_WINDOW_MS,
-  averaged,
-  is_unrelieved,
-  mean_busy,
-  with_ease,
-  with_reading
-};
-
 // scripts/gate/core-admission.ts
 init_timeouts();
 
@@ -10016,72 +10326,73 @@ function exceeds(totals, budget) {
 }
 function sum_load(reservations) {
   const load = { cores: 0, memory_mb: 0 };
-  for (const entry of reservations) add_load(load, entry.reservation);
+  for (const entry2 of reservations) add_load(load, entry2.reservation);
   return load;
 }
-function is_waiting(entry) {
-  return entry.reservation.admitted_at === void 0;
+function is_waiting(entry2) {
+  return entry2.reservation.admitted_at === void 0;
 }
 function fits(entries, limit) {
   return !exceeds(sum_load(entries), limit);
 }
 function place(key2, reservations) {
   const ordered2 = reservations.toSorted(compare_claim);
-  const index = ordered2.findIndex((entry) => entry.key === key2);
-  const own2 = ordered2[index];
-  if (own2 === void 0) return void 0;
+  const index = ordered2.findIndex((entry2) => entry2.key === key2);
+  const own3 = ordered2[index];
+  if (own3 === void 0) return void 0;
   return {
-    own: own2,
+    own: own3,
     is_oldest: index === 0,
-    ahead: ordered2.slice(0, index).filter((entry) => is_waiting(entry)),
-    running: ordered2.filter((entry) => entry.key !== key2 && !is_waiting(entry))
+    ahead: ordered2.slice(0, index).filter((entry2) => is_waiting(entry2)),
+    running: ordered2.filter((entry2) => entry2.key !== key2 && !is_waiting(entry2))
   };
 }
 function first_waiter_limit(budget) {
   if (budget.is_overloaded === true) return budget;
   return { cores: budget.cores + (budget.busy_excess ?? 0), memory_mb: budget.memory_mb };
 }
-function may_pass_waiter(own2, waiter) {
-  const since_ms = own2.claimed_at - waiter.claimed_at;
-  if (priority_rank(waiter) < priority_rank(own2)) return false;
+function may_pass_waiter(own3, waiter) {
+  const since_ms = own3.claimed_at - waiter.claimed_at;
+  if (priority_rank(waiter) < priority_rank(own3)) return false;
   if (since_ms < BYPASS_WINDOW_MS) return true;
-  return waiter.weight > own2.weight && since_ms < HEAVIER_BYPASS_WINDOW_MS;
+  return waiter.weight > own3.weight && since_ms < HEAVIER_BYPASS_WINDOW_MS;
 }
-function may_pass({ own: own2, ahead, running }, budget) {
-  const is_passable = ahead.every((entry) => may_pass_waiter(own2.reservation, entry.reservation));
-  return is_passable && fits([...running, own2], budget);
+function may_pass({ own: own3, ahead, running }, budget) {
+  const is_passable = ahead.every((entry2) => may_pass_waiter(own3.reservation, entry2.reservation));
+  return is_passable && fits([...running, own3], budget);
 }
-function fits_in_order({ own: own2, ahead, running }, budget) {
+function fits_in_order({ own: own3, ahead, running }, budget) {
   const limit = ahead.length === 0 ? first_waiter_limit(budget) : budget;
-  return fits([...running, ...ahead, own2], limit);
-}
-function is_swap_stalled({ own: own2, running }, budget) {
-  const needed_mb = sum_load([...running, own2]).memory_mb;
-  return budget.memory_pressured === true && needed_mb > budget.memory_mb;
+  return fits([...running, ...ahead, own3], limit);
 }
-function is_swap_held(key2, reservations, budget) {
+function is_memory_held(key2, reservations, budget) {
   const placement = place(key2, reservations);
-  return placement !== void 0 && is_swap_stalled(placement, budget);
+  if (placement === void 0) return false;
+  if (placement.own.reservation.is_unit === true && budget.memory_pressured !== true) return false;
+  return !fits([...placement.running, placement.own], {
+    cores: Infinity,
+    memory_mb: budget.memory_mb
+  });
 }
 function runs_alone(placement, budget) {
   if (!placement.is_oldest || placement.running.length > 0 || placement.own.reservation.is_strict_admission === true) {
     return false;
   }
-  return budget.is_overloaded !== true && !is_swap_stalled(placement, budget);
+  return budget.is_overloaded !== true;
 }
 function is_admitted(key2, reservations, budget) {
   const placement = place(key2, reservations);
-  if (placement === void 0) return false;
+  if (placement === void 0 || is_memory_held(key2, reservations, budget)) return false;
   if (runs_alone(placement, budget)) return true;
   return fits_in_order(placement, budget) || may_pass(placement, budget);
 }
 function mark_admitted(entries, key2) {
-  const index = entries.findIndex((entry2) => entry2.key === key2);
-  const entry = entries[index];
-  if (entry === void 0) return;
+  const index = entries.findIndex((entry3) => entry3.key === key2);
+  const entry2 = entries[index];
+  if (entry2 === void 0) return;
   entries[index] = {
-    ...entry,
-    reservation: { ...entry.reservation, admitted_at: entry.reservation.claimed_at }
+    ...entry2,
+    reservation: { ...entry2.reservation, admitted_at: entry2.reservation.claimed_at }
   };
 }
 function admitted_keys(reservations, budget, memory_budget = Infinity) {
@@ -10100,36 +10411,36 @@ function is_ramped(reservation, now) {
   return reservation.is_memory_pending !== true && admitted_at !== void 0 && now - admitted_at >= RAMP_UP_MS;
 }
 function ledger_load(reservations, now) {
-  const admitted = reservations.filter((entry) => entry.reservation.admitted_at !== void 0);
-  const ramped = admitted.filter((entry) => is_ramped(entry.reservation, now));
+  const admitted = reservations.filter((entry2) => entry2.reservation.admitted_at !== void 0);
+  const ramped = admitted.filter((entry2) => is_ramped(entry2.reservation, now));
   return { cores: sum_load(admitted).cores, memory_mb: sum_load(ramped).memory_mb };
 }
 function total_weight(reservations) {
   return sum_load(reservations).cores;
 }
 function narrowed_weight(key2, reservations, budget) {
-  const own2 = reservations.find((entry) => entry.key === key2)?.reservation;
-  if (own2?.is_unit !== true) return void 0;
+  const own3 = reservations.find((entry2) => entry2.key === key2)?.reservation;
+  if (own3?.is_unit !== true) return void 0;
   const others = reservations.filter(
-    (entry) => entry.key !== key2 && entry.reservation.admitted_at !== void 0
+    (entry2) => entry2.key !== key2 && entry2.reservation.admitted_at !== void 0
   );
   const room = Math.max(MIN_GRANT, Math.floor(budget - total_weight(others)));
-  return room >= own2.weight ? void 0 : room;
+  return room >= own3.weight ? void 0 : room;
 }
 function is_too_narrow(key2, reservations, granted) {
   if (granted === void 0) return false;
-  const own2 = reservations.find((entry) => entry.key === key2)?.reservation;
-  return own2 !== void 0 && granted * NARROW_DIVISOR < own2.weight;
+  const own3 = reservations.find((entry2) => entry2.key === key2)?.reservation;
+  return own3 !== void 0 && granted * NARROW_DIVISOR < own3.weight;
 }
 function with_grant(key2, reservations, granted) {
   if (granted === void 0) return [...reservations];
   return reservations.map(
-    (entry) => entry.key === key2 ? { ...entry, reservation: { ...entry.reservation, granted } } : entry
+    (entry2) => entry2.key === key2 ? { ...entry2, reservation: { ...entry2.reservation, granted } } : entry2
   );
 }
 function admitted_load(reservations, budget) {
   const admitted = admitted_keys(reservations, budget);
-  return total_weight(reservations.filter((entry) => admitted.has(entry.key)));
+  return total_weight(reservations.filter((entry2) => admitted.has(entry2.key)));
 }
 function describe_memory(ledger, budget) {
   if (!Number.isFinite(budget.memory_mb)) return "";
@@ -10152,7 +10463,7 @@ var core_admission = {
   compare_claim,
   describe_overflow,
   is_admitted,
-  is_swap_held,
+  is_memory_held,
   is_too_narrow,
   ledger_load,
   narrowed_weight,
@@ -10160,11 +10471,51 @@ var core_admission = {
   with_grant
 };
 
+// scripts/gate/busy-average.ts
+var AVERAGE_WINDOW_MS = 3e3;
+function with_reading(samples, reading, ledger_cores, now) {
+  const kept = samples.filter((sample) => now - sample.at < AVERAGE_WINDOW_MS);
+  const { busy_cores } = reading;
+  if (busy_cores === void 0) return kept;
+  return [...kept, { at: now, external_cores: Math.max(0, busy_cores - ledger_cores), busy_cores }];
+}
+function mean_busy(samples) {
+  if (samples.length === 0) return void 0;
+  let total = 0;
+  for (const sample of samples) total += sample.busy_cores;
+  return total / samples.length;
+}
+function averaged(reading, samples, ledger_cores) {
+  if (reading.busy_cores === void 0 || samples.length === 0) return reading;
+  let total = 0;
+  for (const sample of samples) total += sample.external_cores;
+  return { ...reading, busy_cores: ledger_cores + total / samples.length };
+}
+var EASE_CORES = 1;
+function with_ease(ease, busy_cores, now) {
+  if (busy_cores === void 0) return ease;
+  if (ease === void 0 || busy_cores <= ease.level - EASE_CORES) {
+    return { level: busy_cores, eased_at: now };
+  }
+  return ease;
+}
+function is_unrelieved(ease, now, window_ms) {
+  return ease !== void 0 && now - ease.eased_at >= window_ms;
+}
+var busy_average = {
+  AVERAGE_WINDOW_MS,
+  averaged,
+  is_unrelieved,
+  mean_busy,
+  with_ease,
+  with_reading
+};
+
 // scripts/gate/core-reservation.ts
 init_process_identity();
 init_stamp_file();
 init_json_value();
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // scripts/gate/core-priority.ts
 var PRIORITY_KEY = "JOSH_CORE_PRIORITY";
@@ -10215,10 +10566,10 @@ function is_outside_held(key2, reservations, budget) {
   return hold_reason(key2, reservations, unloaded, granted) === void 0;
 }
 var SMALL_CLAIM_CORES = core_weights.CORE_WEIGHTS.lint;
-function unseen_cores(own2, reservations, now) {
-  const fresh = reservations.filter((entry) => {
-    const { admitted_at } = entry.reservation;
-    if (admitted_at === void 0) return core_admission.compare_claim(entry, own2) < 0;
+function unseen_cores(own3, reservations, now) {
+  const fresh = reservations.filter((entry2) => {
+    const { admitted_at } = entry2.reservation;
+    if (admitted_at === void 0) return core_admission.compare_claim(entry2, own3) < 0;
     return now - admitted_at < busy_average.AVERAGE_WINDOW_MS;
   });
   return core_admission.sum_load(fresh).cores;
@@ -10228,10 +10579,10 @@ function has_room(weight, budget, room, unseen) {
   return room.busy_cores !== void 0 && room.busy_cores + unseen + weight <= room.cores;
 }
 function is_ledger_held_small(key2, reservations, budget, room) {
-  const own2 = reservations.find((entry) => entry.key === key2);
-  if (own2 === void 0) return false;
-  const unseen = unseen_cores(own2, reservations, room.now);
-  if (!has_room(own2.reservation.weight, budget, room, unseen)) return false;
+  const own3 = reservations.find((entry2) => entry2.key === key2);
+  if (own3 === void 0) return false;
+  const unseen = unseen_cores(own3, reservations, room.now);
+  if (!has_room(own3.reservation.weight, budget, room, unseen)) return false;
   return core_admission.is_admitted(key2, reservations, { ...budget, cores: Infinity });
 }
 function is_held_in_vain(key2, reservations, budget, room) {
@@ -10263,7 +10614,7 @@ function wait_of(marker, now, home_root) {
 }
 function waits_of(entries, now, home) {
   const home_root = lane_paths.lanes_root_of(home);
-  return entries.flatMap((entry) => wait_of(entry.reservation, now, home_root)).toSorted((left, right) => right.waited_ms - left.waited_ms);
+  return entries.flatMap((entry2) => wait_of(entry2.reservation, now, home_root)).toSorted((left, right) => right.waited_ms - left.waited_ms);
 }
 var core_wait = {
   WAIT_REASONS,
@@ -10278,20 +10629,20 @@ var core_wait = {
 
 // scripts/gate/core-reservation.ts
 var reservation_schema = process_owner_schema.extend({
-  weight: z11.number(),
-  claimed_at: z11.number(),
-  memory_mb: z11.number().optional(),
-  admitted_at: z11.number().optional(),
-  is_unit: z11.boolean().optional(),
-  is_strict_admission: z11.boolean().optional(),
-  is_memory_pending: z11.boolean().optional(),
-  is_priority: z11.boolean().optional(),
-  granted: z11.number().optional(),
-  command: z11.string().optional(),
-  checkout: z11.string().optional(),
-  lane: z11.string().optional(),
-  lanes_root: z11.string().optional(),
-  wait_reason: z11.enum(core_wait.WAIT_REASONS).optional()
+  weight: z12.number(),
+  claimed_at: z12.number(),
+  memory_mb: z12.number().optional(),
+  admitted_at: z12.number().optional(),
+  is_unit: z12.boolean().optional(),
+  is_strict_admission: z12.boolean().optional(),
+  is_memory_pending: z12.boolean().optional(),
+  is_priority: z12.boolean().optional(),
+  granted: z12.number().optional(),
+  command: z12.string().optional(),
+  checkout: z12.string().optional(),
+  lane: z12.string().optional(),
+  lanes_root: z12.string().optional(),
+  wait_reason: z12.enum(core_wait.WAIT_REASONS).optional()
 });
 function claim_fields(weight, claimed_at, options) {
   const { memory_mb, command, is_unit, is_strict_admission, is_memory_pending } = options;
@@ -10329,57 +10680,6 @@ function transfer(handle, pid) {
 }
 var core_reservation = { claim_fields, read_reservation, transfer, write_reservation };
 
-// scripts/gate/core-wait-record.ts
-init_lane_ledger_write();
-var UNNAMED_COMMAND = "a step";
-async function to_ledger(wait) {
-  await lane_ledger_write.record_core_wait(wait);
-}
-function wait_of2(claim3, now) {
-  if (claim3.wait_reason === void 0) return void 0;
-  const wait = { command: claim3.command ?? UNNAMED_COMMAND, waited_ms: now - claim3.claimed_at };
-  return claim3.lane === void 0 ? wait : { ...wait, issue: Number(claim3.lane) };
-}
-async function record_admitted(claim3, now, sink = to_ledger) {
-  const wait = wait_of2(claim3, now);
-  if (wait !== void 0) await sink(wait);
-}
-var core_wait_record = { record_admitted, wait_of: wait_of2 };
-
-// scripts/gate/held-mark.ts
-var HELD_KEY = "JOSH_CORE_RESERVED";
-var HELD_VALUE = "1";
-var HELD_RESERVATION_KEY = "JOSH_CORE_RESERVATION";
-function is_held() {
-  return process.env[HELD_KEY] === HELD_VALUE;
-}
-function held_reservation() {
-  const key2 = process.env[HELD_RESERVATION_KEY] ?? "";
-  return key2 === "" ? void 0 : key2;
-}
-function set_held_mark(value2, reservation) {
-  process.env[HELD_KEY] = value2;
-  process.env[HELD_RESERVATION_KEY] = reservation;
-}
-async function with_held_mark(run3, reservation = "") {
-  const previous = process.env[HELD_KEY] ?? "";
-  const previous_reservation = process.env[HELD_RESERVATION_KEY] ?? "";
-  set_held_mark(HELD_VALUE, reservation);
-  try {
-    return await run3();
-  } finally {
-    set_held_mark(previous, previous_reservation);
-  }
-}
-var held_mark = {
-  HELD_KEY,
-  HELD_RESERVATION_KEY,
-  HELD_VALUE,
-  held_reservation,
-  is_held,
-  with_held_mark
-};
-
 // scripts/gate/machine-capacity.ts
 init_timeouts();
 import { readFile } from "node:fs/promises";
@@ -10546,7 +10846,9 @@ async function read_machine(sleep2 = default_sleep2) {
     busy_cores,
     run_queue: is_host ? loadavg()[0] : void 0,
     available_mb: pressured_available(memory_after, memory_before),
-    memory_pressured: is_pressured(memory_before, memory_after)
+    memory_pressured: is_pressured(memory_before, memory_after),
+    memory_supported: process.platform === "darwin" || process.platform === "linux",
+    total_mb: totalmem() / BYTES_PER_MB2
   };
 }
 async function read_sample() {
@@ -10588,6 +10890,193 @@ var machine_capacity = {
   swapped_between
 };
 
+// scripts/gate/core-budget-poll.ts
+function check_measurement(command, reading) {
+  if (reading.memory_supported === true && !Number.isFinite(reading.available_mb)) {
+    throw new Error(`${command}: memory measurement failed; admission refused`);
+  }
+}
+function check_capacity(command, requested, total_mb) {
+  if (total_mb === void 0) return;
+  if (requested > total_mb) {
+    throw new Error(
+      `${command}: requested ${String(requested)} MB exceeds physical memory ${String(total_mb)} MB`
+    );
+  }
+}
+function check_memory2(context, reading) {
+  const requested = context.fields.memory_mb ?? 0;
+  if (requested === 0) return;
+  const command = context.fields.command ?? "a step";
+  const minimum = context.fields.is_unit === true ? requested / Math.max(1, context.fields.weight) : requested;
+  check_measurement(command, reading);
+  check_capacity(command, minimum, reading.total_mb);
+}
+async function current_reading(context, reservations) {
+  const reading = await context.read_machine();
+  const ledger = core_admission.ledger_load(reservations, context.now());
+  check_memory2(context, reading);
+  context.busy_samples = busy_average.with_reading(
+    context.busy_samples,
+    reading,
+    ledger.cores,
+    context.now()
+  );
+  const mean = busy_average.averaged(reading, context.busy_samples, ledger.cores);
+  context.ease = busy_average.with_ease(context.ease, mean.busy_cores, context.now());
+  return { budget: machine_capacity.machine_budget(context.budget, mean, ledger), reading };
+}
+function admit(context, decision) {
+  const admitted_at = context.now();
+  const { granted, overflow, reason, budget, reading } = decision;
+  core_reservation.write_reservation(context.target, { ...context.fields, admitted_at, granted });
+  return {
+    overflow,
+    granted,
+    waited_ms: admitted_at - context.fields.claimed_at,
+    decision: { reason, budget, reading }
+  };
+}
+function mark_waiting(context, reason) {
+  const previous = context.fields.wait_reason;
+  if (previous === reason) return;
+  context.fields = { ...context.fields, wait_reason: reason };
+  core_reservation.write_reservation(context.target, context.fields);
+  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
+}
+function spent_reason(context, reservations, budget) {
+  const now = context.now();
+  if (now >= context.deadline) return "cpu-deadline";
+  const busy_cores = busy_average.mean_busy(context.busy_samples);
+  const room = { busy_cores, cores: context.budget, now };
+  return busy_average.is_unrelieved(context.ease, now, context.ease_window_ms) && core_wait.is_held_in_vain(context.key, reservations, budget, room) ? "cpu-unrelieved" : void 0;
+}
+function overflow_reason(context, reservations, budget) {
+  if (context.fields.is_strict_admission === true || core_admission.is_memory_held(context.key, reservations, budget)) {
+    return void 0;
+  }
+  return spent_reason(context, reservations, budget);
+}
+function overflow_of(context, reservations, decision) {
+  const held = core_admission.with_grant(context.key, reservations, decision.granted);
+  const overflow = {
+    waited_ms: context.now() - context.fields.claimed_at,
+    ledger: core_admission.sum_load(held),
+    budget: decision.budget
+  };
+  return admit(context, { ...decision, overflow });
+}
+function fit_reason(context, reservations, budget) {
+  const requested = context.fields.memory_mb ?? 0;
+  if (context.fields.is_unit === true && requested > budget.memory_mb) {
+    return "unit-memory-narrowing";
+  }
+  const strict = { ...budget, busy_excess: 0, is_overloaded: true };
+  return core_admission.is_admitted(context.key, reservations, strict) ? "budget-fit" : "cpu-first-waiter";
+}
+async function poll_admission(context, reservations) {
+  const { budget, reading } = await current_reading(context, reservations);
+  const granted = core_admission.narrowed_weight(context.key, reservations, budget.cores);
+  const reason = core_wait.hold_reason(context.key, reservations, budget, granted);
+  if (reason === void 0) {
+    return admit(context, {
+      budget,
+      reading,
+      granted,
+      reason: fit_reason(context, reservations, budget)
+    });
+  }
+  const overflow = overflow_reason(context, reservations, budget);
+  if (overflow !== void 0) {
+    return overflow_of(context, reservations, { budget, reading, granted, reason: overflow });
+  }
+  mark_waiting(context, reason);
+  return void 0;
+}
+var core_budget_poll = { poll_admission };
+
+// scripts/gate/core-wait-record.ts
+init_lane_ledger_write();
+var UNNAMED_COMMAND = "a step";
+async function to_ledger(wait) {
+  await lane_ledger_write.record_core_wait(wait);
+}
+function request_fields(claim3, admission) {
+  return {
+    requested_cores: claim3.weight,
+    granted_cores: admission?.granted ?? claim3.weight,
+    memory_mb: claim3.memory_mb ?? 0,
+    wait_reason: claim3.wait_reason,
+    admission_waited_ms: admission?.waited_ms
+  };
+}
+function admission_fields(claim3, admission) {
+  const decision = admission?.decision;
+  if (decision === void 0) return {};
+  return {
+    ...request_fields(claim3, admission),
+    admission_reason: decision.reason,
+    overflow: admission?.overflow !== void 0,
+    budget_cores: decision.budget.cores,
+    budget_memory_mb: Number.isFinite(decision.budget.memory_mb) ? decision.budget.memory_mb : void 0,
+    available_mb: decision.reading.available_mb,
+    busy_cores: decision.reading.busy_cores,
+    memory_pressured: decision.reading.memory_pressured
+  };
+}
+function should_record(claim3, admission) {
+  return claim3.wait_reason !== void 0 || admission?.decision !== void 0;
+}
+function wait_of2(claim3, now, admission) {
+  if (!should_record(claim3, admission)) return void 0;
+  const waited_ms = claim3.wait_reason === void 0 ? 0 : now - claim3.claimed_at;
+  const wait = {
+    command: claim3.command ?? UNNAMED_COMMAND,
+    waited_ms,
+    ...admission_fields(claim3, admission)
+  };
+  return claim3.lane === void 0 ? wait : { ...wait, issue: Number(claim3.lane) };
+}
+async function record_admitted(claim3, now, sink = to_ledger, admission) {
+  const wait = wait_of2(claim3, now, admission);
+  if (wait !== void 0) await sink(wait);
+}
+var core_wait_record = { record_admitted, wait_of: wait_of2 };
+
+// scripts/gate/held-mark.ts
+var HELD_KEY = "JOSH_CORE_RESERVED";
+var HELD_VALUE = "1";
+var HELD_RESERVATION_KEY = "JOSH_CORE_RESERVATION";
+function is_held() {
+  return process.env[HELD_KEY] === HELD_VALUE;
+}
+function held_reservation() {
+  const key2 = process.env[HELD_RESERVATION_KEY] ?? "";
+  return key2 === "" ? void 0 : key2;
+}
+function set_held_mark(value2, reservation) {
+  process.env[HELD_KEY] = value2;
+  process.env[HELD_RESERVATION_KEY] = reservation;
+}
+async function with_held_mark(run3, reservation = "") {
+  const previous = process.env[HELD_KEY] ?? "";
+  const previous_reservation = process.env[HELD_RESERVATION_KEY] ?? "";
+  set_held_mark(HELD_VALUE, reservation);
+  try {
+    return await run3();
+  } finally {
+    set_held_mark(previous, previous_reservation);
+  }
+}
+var held_mark = {
+  HELD_KEY,
+  HELD_RESERVATION_KEY,
+  HELD_VALUE,
+  held_reservation,
+  is_held,
+  with_held_mark
+};
+
 // scripts/gate/core-budget.ts
 var RESERVED_PREFIX = "josh-core-reserved-";
 var RESERVED_SUFFIX = ".json";
@@ -10634,67 +11123,25 @@ function report_wait(line2) {
   process.stderr.write(`${line2}
 `);
 }
-async function current_budget(context, reservations) {
-  const reading = await context.read_machine();
-  const ledger = core_admission.ledger_load(reservations, context.now());
-  context.busy_samples = busy_average.with_reading(
-    context.busy_samples,
-    reading,
-    ledger.cores,
-    context.now()
-  );
-  const mean = busy_average.averaged(reading, context.busy_samples, ledger.cores);
-  context.ease = busy_average.with_ease(context.ease, mean.busy_cores, context.now());
-  return machine_capacity.machine_budget(context.budget, mean, ledger);
-}
-function admit(context, overflow, granted) {
-  const admitted_at = context.now();
-  write_reservation2(context.target, { ...context.fields, admitted_at, granted });
-  return { overflow, granted, waited_ms: admitted_at - context.fields.claimed_at };
-}
-function overflow_of(context, reservations, budget) {
-  return {
-    waited_ms: context.now() - context.fields.claimed_at,
-    ledger: core_admission.sum_load(reservations),
-    budget
-  };
-}
-function mark_waiting(context, reason) {
-  const previous = context.fields.wait_reason;
-  if (previous === reason) return;
-  context.fields = { ...context.fields, wait_reason: reason };
-  write_reservation2(context.target, context.fields);
-  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
-}
-function is_wait_spent(context, reservations, budget) {
-  if (context.fields.is_strict_admission === true || core_admission.is_swap_held(context.key, reservations, budget)) {
-    return false;
-  }
-  const now = context.now();
-  if (now >= context.deadline) return true;
-  const busy_cores = busy_average.mean_busy(context.busy_samples);
-  const room = { busy_cores, cores: context.budget, now };
-  return busy_average.is_unrelieved(context.ease, now, context.ease_window_ms) && core_wait.is_held_in_vain(context.key, reservations, budget, room);
-}
-async function poll_admission(context) {
-  const reservations = live_reservations(context.directory);
-  const budget = await current_budget(context, reservations);
-  const granted = core_admission.narrowed_weight(context.key, reservations, budget.cores);
-  const reason = core_wait.hold_reason(context.key, reservations, budget, granted);
-  if (reason === void 0) return admit(context, void 0, granted);
-  if (is_wait_spent(context, reservations, budget)) {
-    const held = core_admission.with_grant(context.key, reservations, granted);
-    return admit(context, overflow_of(context, held, budget), granted);
+async function poll_admission2(context) {
+  try {
+    return await core_budget_poll.poll_admission(context, live_reservations(context.directory));
+  } catch (error) {
+    sweep_marker2(context.target);
+    throw error;
   }
-  mark_waiting(context, reason);
-  return void 0;
 }
 async function await_admission(context) {
-  const admission = await poll.wait_for(async () => await poll_admission(context), {
+  const admission = await poll.wait_for(async () => await poll_admission2(context), {
     interval_ms: context.poll_interval_ms,
     sleeper: context.sleep
   });
-  await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait);
+  await core_wait_record.record_admitted(
+    context.fields,
+    context.now(),
+    context.record_wait,
+    admission
+  );
   return admission;
 }
 function resolve_ports(options) {
@@ -10708,7 +11155,7 @@ function claim2(weight, options = {}) {
   const timing = core_budget_timing.resolve_timing(options);
   const directory = options.directory ?? PLATFORM_TEMP_ROOT;
   const claimed_at = timing.now();
-  const name = marker_name(randomUUID4());
+  const name = marker_name(randomUUID6());
   const target2 = path21.join(directory, name);
   const fields = claim_fields2(weight, claimed_at, options);
   write_reservation2(target2, fields);
@@ -10730,9 +11177,14 @@ async function reserve(weight, options = {}) {
   return { target: context.target, admission };
 }
 async function poll_claim(context) {
-  const admission = await poll_admission(context);
+  const admission = await poll_admission2(context);
   if (admission === void 0) return void 0;
-  await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait);
+  await core_wait_record.record_admitted(
+    context.fields,
+    context.now(),
+    context.record_wait,
+    admission
+  );
   return { target: context.target, admission };
 }
 function budget_waits(directory = PLATFORM_TEMP_ROOT, now = Date.now(), home = process.cwd()) {
@@ -10763,7 +11215,7 @@ async function with_command_reservation(weight, run3, options = {}) {
 function held_unit_claim(directory = PLATFORM_TEMP_ROOT) {
   const key2 = held_mark.held_reservation();
   if (key2 === void 0) return void 0;
-  const held = live_reservations(directory).find((entry) => entry.key === key2);
+  const held = live_reservations(directory).find((entry2) => entry2.key === key2);
   return held?.reservation.is_unit === true ? held.reservation : void 0;
 }
 var core_budget = {
@@ -10881,9 +11333,9 @@ function format_rejection(cmd, targets) {
   const hint = targets.length > 0 ? `pass them to ${format_targets(targets)} instead` : "it runs a fixed sequence and forwards nothing";
   return `josh ${cmd} takes no extra arguments \u2014 ${hint}`;
 }
-function reject_extra_arguments(cmd, entry, extra) {
-  if (extra.length === 0 || !is_composite_shell(entry.shell)) return void 0;
-  return format_rejection(cmd, entry.argument_targets ?? []);
+function reject_extra_arguments(cmd, entry2, extra) {
+  if (extra.length === 0 || !is_composite_shell(entry2.shell)) return void 0;
+  return format_rejection(cmd, entry2.argument_targets ?? []);
 }
 var composite_arguments = { format_rejection, is_composite_shell, reject_extra_arguments };
 
@@ -10966,11 +11418,11 @@ var josh_in_process = { bundled_script_path, in_process_target, run_in_process }
 function kit_only_notice(cmd) {
   return `\`josh ${cmd}\` is a kit-only command \u2014 run it from the kit repository (joshuafolkken/kit), not from a consumer project.`;
 }
-function is_kit_only(entry) {
-  return entry.is_kit_only === true;
+function is_kit_only(entry2) {
+  return entry2.is_kit_only === true;
 }
 function kit_only_command_names() {
-  return Object.entries(COMMAND_MAP).filter(([, entry]) => is_kit_only(entry)).map(([name]) => name);
+  return Object.entries(COMMAND_MAP).filter(([, entry2]) => is_kit_only(entry2)).map(([name]) => name);
 }
 var kit_only = {
   is_kit_only,
@@ -11074,8 +11526,8 @@ function parse_remote_urls_from_config(content) {
   const lines = content.split("\n").map((line2) => line2.trim());
   return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line2) => url_value(line2))).filter((url) => url !== void 0);
 }
-function format_identity(identity) {
-  return `${identity.owner}${PATH_SEPARATOR4}${identity.repo}`.toLowerCase();
+function format_identity(identity2) {
+  return `${identity2.owner}${PATH_SEPARATOR4}${identity2.repo}`.toLowerCase();
 }
 var repo_origin = {
   GITHUB_HOST,
@@ -11128,27 +11580,27 @@ function build_alias_lookup() {
 function resolve_alias(cmd) {
   return Object.hasOwn(ALIASES, cmd) ? ALIASES[cmd] ?? cmd : cmd;
 }
-function format_command_line(cmd, entry, alias) {
+function format_command_line(cmd, entry2, alias) {
   const prefix2 = alias ? `${alias}, `.padEnd(ALIAS_PAD_WIDTH + ALIAS_PAD_WIDTH) : "";
-  return `  ${(prefix2 + cmd).padEnd(COLUMN_WIDTH)}${entry.description}`;
+  return `  ${(prefix2 + cmd).padEnd(COLUMN_WIDTH)}${entry2.description}`;
 }
 function format_category_section(category, entries, alias_lookup) {
   const lines = entries.map(
-    ([cmd, entry]) => format_command_line(cmd, entry, alias_lookup.get(cmd))
+    ([cmd, entry2]) => format_command_line(cmd, entry2, alias_lookup.get(cmd))
   );
   return [`${category}:`, ...lines].join("\n");
 }
-function is_visible_command(entry, is_all, is_consumer) {
-  if (is_consumer && kit_only.is_kit_only(entry)) return false;
-  return is_all || entry.reference[1] === "developer";
+function is_visible_command(entry2, is_all, is_consumer) {
+  if (is_consumer && kit_only.is_kit_only(entry2)) return false;
+  return is_all || entry2.reference[1] === "developer";
 }
 function collect_visible(is_all, is_consumer) {
   const by_category = new Map(
     CATEGORY_ORDER.map((cat) => [cat, []])
   );
-  for (const [cmd, entry] of Object.entries(COMMAND_MAP)) {
-    if (is_visible_command(entry, is_all, is_consumer)) {
-      by_category.get(entry.category)?.push([cmd, entry]);
+  for (const [cmd, entry2] of Object.entries(COMMAND_MAP)) {
+    if (is_visible_command(entry2, is_all, is_consumer)) {
+      by_category.get(entry2.category)?.push([cmd, entry2]);
     }
   }
   return by_category;
@@ -11177,10 +11629,10 @@ function run_shell_command(shell, extra) {
   });
   return resolve_spawn_exit(executable, result);
 }
-async function run_script_entry(entry, script, subcommand_arguments) {
-  const script_arguments = [...entry.default_script_arguments ?? [], ...subcommand_arguments];
+async function run_script_entry(entry2, script, subcommand_arguments) {
+  const script_arguments = [...entry2.default_script_arguments ?? [], ...subcommand_arguments];
   const target2 = josh_in_process.in_process_target(script, PACKAGE_DIR2, import.meta.url);
-  josh_environment_file.apply_node_flags(entry.tsx_arguments ?? []);
+  josh_environment_file.apply_node_flags(entry2.tsx_arguments ?? []);
   return await josh_in_process.run_in_process(target2, script_arguments);
 }
 function github_prerequisite_exit(resolved, is_consumer) {
@@ -11190,8 +11642,8 @@ function github_prerequisite_exit(resolved, is_consumer) {
   console.error(prerequisite);
   return USAGE_ERROR_EXIT_CODE;
 }
-function pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer) {
-  if (is_consumer && kit_only.is_kit_only(entry)) {
+function pre_dispatch_exit(resolved, entry2, subcommand_arguments, is_consumer) {
+  if (is_consumer && kit_only.is_kit_only(entry2)) {
     console.error(kit_only.notice(resolved));
     return USAGE_ERROR_EXIT_CODE;
   }
@@ -11199,40 +11651,40 @@ function pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer) {
   if (prerequisite_exit !== void 0) return prerequisite_exit;
   const rejection2 = composite_arguments.reject_extra_arguments(
     resolved,
-    entry,
+    entry2,
     subcommand_arguments
   );
   if (rejection2 === void 0) return void 0;
   console.error(rejection2);
   return USAGE_ERROR_EXIT_CODE;
 }
-async function run_entry(entry, subcommand_arguments) {
-  if (entry.shell) return run_shell_command(entry.shell, subcommand_arguments);
-  return await run_script_entry(entry, entry.script ?? "", subcommand_arguments);
+async function run_entry(entry2, subcommand_arguments) {
+  if (entry2.shell) return run_shell_command(entry2.shell, subcommand_arguments);
+  return await run_script_entry(entry2, entry2.script ?? "", subcommand_arguments);
 }
 function declared(value2) {
   return typeof value2 === "function" ? value2() : value2;
 }
-async function dispatch_entry(command, entry, subcommand_arguments) {
-  const weight = declared(entry.core_weight);
-  if (weight === void 0) return await run_entry(entry, subcommand_arguments);
+async function dispatch_entry(command, entry2, subcommand_arguments) {
+  const weight = declared(entry2.core_weight);
+  if (weight === void 0) return await run_entry(entry2, subcommand_arguments);
   return await core_budget.with_command_reservation(
     weight,
-    async () => await run_entry(entry, subcommand_arguments),
-    { memory_mb: declared(entry.memory_mb), command, is_unit: entry.is_unit_claim }
+    async () => await run_entry(entry2, subcommand_arguments),
+    { memory_mb: declared(entry2.memory_mb), command, is_unit: entry2.is_unit_claim }
   );
 }
 async function run_command(cmd, subcommand_arguments, is_consumer = false) {
   const resolved = resolve_alias(cmd);
-  const entry = Object.hasOwn(COMMAND_MAP, resolved) ? COMMAND_MAP[resolved] : void 0;
-  if (!entry) return UNKNOWN_COMMAND_EXIT_CODE;
-  const early_exit = pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer);
+  const entry2 = Object.hasOwn(COMMAND_MAP, resolved) ? COMMAND_MAP[resolved] : void 0;
+  if (!entry2) return UNKNOWN_COMMAND_EXIT_CODE;
+  const early_exit = pre_dispatch_exit(resolved, entry2, subcommand_arguments, is_consumer);
   if (early_exit !== void 0) return early_exit;
   return await hook_lap.timed_command(
     resolved,
-    entry.category,
+    entry2.category,
     subcommand_arguments,
-    async () => await dispatch_entry(resolved, entry, subcommand_arguments)
+    async () => await dispatch_entry(resolved, entry2, subcommand_arguments)
   );
 }
 var josh_logic = {
@@ -11253,18 +11705,18 @@ function entry_of(name) {
   const command = canonical_command(name);
   return Object.hasOwn(COMMAND_MAP, command) ? COMMAND_MAP[command] : void 0;
 }
-function is_read_only_call(entry, rest) {
-  const write_flags = entry.write_flags ?? [];
+function is_read_only_call(entry2, rest) {
+  const write_flags = entry2.write_flags ?? [];
   if (rest.some((argument) => write_flags.includes(argument.split("=", 1)[0] ?? ""))) return false;
-  if (entry.is_read_only === true) return true;
-  const flags = entry.read_only_flags ?? [];
+  if (entry2.is_read_only === true) return true;
+  const flags = entry2.read_only_flags ?? [];
   return rest.some((argument) => flags.includes(argument));
 }
 function refusal(args) {
   const [command = "", ...rest] = args;
   if (is_help_request(args[0])) return void 0;
-  const entry = entry_of(command);
-  if (entry !== void 0 && is_read_only_call(entry, rest)) return void 0;
+  const entry2 = entry_of(command);
+  if (entry2 !== void 0 && is_read_only_call(entry2, rest)) return void 0;
   return `\`josh ${command}\` is not read-only: it carries a declared write flag, or its entry is not declared read-only and it carries no read-only flag its entry declares; read its usage with \`pnpm josh help ${command}\``;
 }
 var josh_read_only = { ALL_FLAG, entry_of, is_help_request, refusal };