@joshuafolkken/kit 1.1229.0 → 1.1240.0

package/dist/josh.js

@@ -319,7 +319,7 @@ function resolve_package_bin(base_directory, package_name, bin_name) {
 // scripts/gate/core-budget.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism2 } from "node:os";
+import { availableParallelism as availableParallelism3 } from "node:os";
 import path8 from "node:path";
 
 // scripts/josh/platform-temporary.ts
@@ -712,6 +712,159 @@ var unit_worker_share = {
 
 // scripts/gate/core-budget.ts
 import { z as z4 } from "zod";
+
+// scripts/gate/core-admission.ts
+var MS_PER_SECOND = 1e3;
+var RAMP_UP_MS = 3e4;
+function compare_claim(left, right) {
+  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
+  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
+}
+function add_load(totals, reservation) {
+  totals.cores += reservation.weight;
+  totals.memory_mb += reservation.memory_mb ?? 0;
+}
+function exceeds(totals, budget) {
+  return totals.cores > budget.cores || totals.memory_mb > budget.memory_mb;
+}
+function admitted_keys(reservations, budget, memory_budget = Infinity) {
+  const limit = { cores: budget, memory_mb: memory_budget };
+  const totals = { cores: 0, memory_mb: 0 };
+  const admitted = /* @__PURE__ */ new Set();
+  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
+    add_load(totals, entry.reservation);
+    if (index !== 0 && exceeds(totals, limit)) break;
+    admitted.add(entry.key);
+  }
+  return admitted;
+}
+function is_admitted(key, reservations, budget) {
+  return admitted_keys(reservations, budget.cores, budget.memory_mb).has(key);
+}
+function sum_load(reservations) {
+  const load = { cores: 0, memory_mb: 0 };
+  for (const entry of reservations) add_load(load, entry.reservation);
+  return load;
+}
+function is_ramped(reservation, now) {
+  const { admitted_at } = reservation;
+  return 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));
+  return { cores: sum_load(admitted).cores, memory_mb: sum_load(ramped).memory_mb };
+}
+function total_weight(reservations) {
+  return sum_load(reservations).cores;
+}
+function admitted_load(reservations, budget) {
+  const admitted = admitted_keys(reservations, budget);
+  return total_weight(reservations.filter((entry) => admitted.has(entry.key)));
+}
+function describe_memory(ledger, budget) {
+  if (!Number.isFinite(budget.memory_mb)) return "";
+  return ` and ${String(Math.round(ledger.memory_mb))} MB of memory against ${String(Math.round(budget.memory_mb))} MB`;
+}
+function describe_overflow(admission) {
+  const { overflow } = admission;
+  if (overflow === void 0) return void 0;
+  const { ledger, budget } = overflow;
+  const waited = String(Math.round(overflow.waited_ms / MS_PER_SECOND));
+  const cores = `the ledger held ${String(ledger.cores)} cores against a budget of ${String(budget.cores)}`;
+  return `started past the core budget after ${waited}s \u2014 ${cores}${describe_memory(ledger, budget)}`;
+}
+var core_admission = {
+  RAMP_UP_MS,
+  admitted_keys,
+  admitted_load,
+  describe_overflow,
+  is_admitted,
+  ledger_load,
+  sum_load
+};
+
+// scripts/gate/machine-capacity.ts
+import { readFile } from "node:fs/promises";
+import { availableParallelism as availableParallelism2, cpus, totalmem } from "node:os";
+import { execa } from "execa";
+var SAMPLE_WINDOW_MS = 250;
+var BASELINE_CORES = 2;
+var BYTES_PER_MB = 1048576;
+var KB_PER_MB = 1024;
+var PERCENT = 100;
+var MEMINFO_PATH = "/proc/meminfo";
+var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
+var PRESSURE_ARGUMENTS = ["-n", "kern.memorystatus_level"];
+var PRESSURE_LEVEL = /^\s*(?<level>\d+)\s*$/u;
+function cpu_times() {
+  let busy = 0;
+  let idle = 0;
+  for (const { times } of cpus()) {
+    busy += times.user + times.nice + times.sys + times.irq;
+    idle += times.idle;
+  }
+  return { busy, total: busy + idle };
+}
+function busy_cores_between(before, after, cores) {
+  const total = after.total - before.total;
+  if (total <= 0) return void 0;
+  return (after.busy - before.busy) / total * cores;
+}
+function parse_darwin_pressure(output, total_bytes) {
+  const level = PRESSURE_LEVEL.exec(output)?.groups?.["level"];
+  if (level === void 0) return void 0;
+  return Number(level) / PERCENT * (total_bytes / BYTES_PER_MB);
+}
+function parse_linux_available(meminfo) {
+  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
+  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
+}
+async function read_available_mb(platform2 = process.platform) {
+  try {
+    if (platform2 === "darwin") {
+      const { stdout } = await execa("sysctl", PRESSURE_ARGUMENTS);
+      return parse_darwin_pressure(stdout, totalmem());
+    }
+    return platform2 === "linux" ? parse_linux_available(await readFile(MEMINFO_PATH, "utf8")) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_unquoted() {
+  return cpus().length > 0 && cpus().length === availableParallelism2();
+}
+async function default_sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function read_machine(sleep = default_sleep) {
+  const before = cpu_times();
+  const [available_mb] = await Promise.all([read_available_mb(), sleep(SAMPLE_WINDOW_MS)]);
+  const busy_cores = is_unquoted() ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
+  return { busy_cores, available_mb };
+}
+function external_cores(busy_cores, ledger_cores) {
+  if (busy_cores === void 0) return 0;
+  return Math.floor(Math.max(0, busy_cores - ledger_cores - BASELINE_CORES));
+}
+function machine_budget(cores, reading, ledger) {
+  return {
+    cores: cores - external_cores(reading.busy_cores, ledger.cores),
+    memory_mb: reading.available_mb === void 0 ? Infinity : reading.available_mb + ledger.memory_mb
+  };
+}
+var machine_capacity = {
+  BASELINE_CORES,
+  busy_cores_between,
+  machine_budget,
+  parse_darwin_pressure,
+  parse_linux_available,
+  read_machine
+};
+
+// scripts/gate/core-budget.ts
 var RESERVED_PREFIX = "josh-core-reserved-";
 var RESERVED_SUFFIX = ".json";
 var POLL_INTERVAL_MS = 50;
@@ -723,11 +876,20 @@ var CORE_WEIGHTS = {
   spell_check: 1,
   eslint_scan: 1
 };
+var MEMORY_MB = {
+  lint: 2400,
+  type_check: 1300,
+  spell_check: 350,
+  eslint_scan: 2400,
+  unit_worker: 350
+};
 var HELD_KEY = "JOSH_CORE_RESERVED";
 var HELD_VALUE = "1";
 var reservation_schema = process_owner_schema.extend({
   weight: z4.number(),
-  claimed_at: z4.number()
+  claimed_at: z4.number(),
+  memory_mb: z4.number().optional(),
+  admitted_at: z4.number().optional()
 });
 function marker_name(key) {
   return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
@@ -760,7 +922,9 @@ function live_reservation(source) {
 }
 function marker_files2(directory) {
   try {
-    return readdirSync2(directory).filter((name) => name.startsWith(RESERVED_PREFIX));
+    return readdirSync2(directory).filter(
+      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
+    );
   } catch {
     return [];
   }
@@ -771,67 +935,79 @@ function live_reservations(directory = PLATFORM_TEMP_ROOT) {
     return reservation === void 0 ? [] : { key: name, reservation };
   });
 }
-function compare_claim(left, right) {
-  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
-  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
-}
-function admitted_keys(reservations, budget) {
-  const admitted = /* @__PURE__ */ new Set();
-  let cumulative = 0;
-  for (const [index, entry] of reservations.toSorted(compare_claim).entries()) {
-    cumulative += entry.reservation.weight;
-    if (index !== 0 && cumulative > budget) break;
-    admitted.add(entry.key);
-  }
-  return admitted;
-}
-function is_admitted(key, reservations, budget) {
-  return admitted_keys(reservations, budget).has(key);
-}
-function admitted_load(reservations, budget) {
-  const admitted = admitted_keys(reservations, budget);
-  return reservations.filter((entry) => admitted.has(entry.key)).reduce((total, entry) => total + entry.reservation.weight, 0);
-}
 function normalize_budget(budget) {
   return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
 }
-async function default_sleep(ms) {
+async function default_sleep2(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
-function write_reservation(target, weight, claimed_at) {
-  stamp_file.write_stamp(target, { ...process_identity.own_fields(), weight, claimed_at });
+function write_reservation(target, fields) {
+  stamp_file.replace_stamp(target, { ...process_identity.own_fields(), ...fields });
 }
 function resolve_timing(options) {
   return {
     now: options.now ?? Date.now,
-    sleep: options.sleep ?? default_sleep,
-    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS
+    sleep: options.sleep ?? default_sleep2,
+    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS,
+    wait_cap_ms: options.wait_cap_ms ?? WAIT_CAP_MS
   };
 }
+async function current_budget(context, reservations) {
+  if (reservations.length <= 1) return { cores: context.budget, memory_mb: Infinity };
+  const reading = await context.read_machine();
+  const ledger = core_admission.ledger_load(reservations, context.now());
+  const budget = machine_capacity.machine_budget(context.budget, reading, ledger);
+  return { ...budget, cores: normalize_budget(budget.cores) };
+}
+function admit(context, overflow) {
+  write_reservation(context.target, { ...context.fields, admitted_at: context.now() });
+  return { overflow };
+}
+function overflow_of(context, reservations, budget) {
+  return {
+    waited_ms: context.now() - context.fields.claimed_at,
+    ledger: core_admission.sum_load(reservations),
+    budget
+  };
+}
+async function poll_admission(context) {
+  const reservations = live_reservations(context.directory);
+  const budget = await current_budget(context, reservations);
+  if (core_admission.is_admitted(context.key, reservations, budget)) return admit(context);
+  if (context.now() >= context.deadline) {
+    return admit(context, overflow_of(context, reservations, budget));
+  }
+  return void 0;
+}
 async function await_admission(context) {
-  while (!is_admitted(context.key, live_reservations(context.directory), context.budget)) {
-    if (context.now() >= context.deadline) return;
+  let admission = await poll_admission(context);
+  while (admission === void 0) {
     await context.sleep(context.poll_interval_ms);
+    admission = await poll_admission(context);
   }
+  return admission;
 }
 async function reserve(weight, options = {}) {
   const timing = resolve_timing(options);
   const directory = options.directory ?? PLATFORM_TEMP_ROOT;
-  const budget = normalize_budget(options.budget ?? availableParallelism2());
   const claimed_at = timing.now();
   const name = marker_name(randomUUID3());
   const target = path8.join(directory, name);
-  write_reservation(target, weight, claimed_at);
-  await await_admission({
+  const fields = { weight, claimed_at, memory_mb: options.memory_mb };
+  write_reservation(target, fields);
+  const admission = await await_admission({
     ...timing,
     key: name,
+    target,
     directory,
-    budget,
-    deadline: claimed_at + (options.wait_cap_ms ?? WAIT_CAP_MS)
+    budget: normalize_budget(options.budget ?? availableParallelism3()),
+    deadline: claimed_at + timing.wait_cap_ms,
+    fields,
+    read_machine: options.read_machine ?? machine_capacity.read_machine
   });
-  return { target };
+  return { target, admission };
 }
 function release(handle) {
   sweep_marker2(handle.target);
@@ -839,7 +1015,7 @@ function release(handle) {
 async function with_core_reservation(weight, run2, options = {}) {
   const handle = await reserve(weight, options);
   try {
-    return await run2();
+    return await run2(handle.admission);
   } finally {
     release(handle);
   }
@@ -867,9 +1043,11 @@ var core_budget = {
   CORE_WEIGHTS,
   HELD_KEY,
   HELD_VALUE,
+  MEMORY_MB,
   RESERVED_PREFIX,
-  admitted_keys,
-  admitted_load,
+  admitted_keys: core_admission.admitted_keys,
+  admitted_load: core_admission.admitted_load,
+  describe_overflow: core_admission.describe_overflow,
   is_held,
   live_reservations,
   release,
@@ -1116,10 +1294,16 @@ var ISSUE_COMMANDS = {
     description: "File an Issue with every filing step: lint, Origin, WIP cap, duplicate scout, labels, then epic:bundle",
     category: "AI tools",
     reference: [
-      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok]",
+      "<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,\u2026>] [--over-cap] [--no-auto-ok] [--release]",
       "automation",
       ["network"]
     ]
+  },
+  "issue:release": {
+    script: "scripts/issue/issue-release-cli.ts",
+    description: "Link an Issue to the repository's open release Issue as its blocker, filing one when none is open",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
   }
 };
 
@@ -1155,7 +1339,7 @@ var LANE_COMMANDS = {
   },
   "lane:prune": {
     ...LANE_ARGUMENTS,
-    description: "Close every lane an interruption left without its work tree",
+    description: "Close every lane an interruption left without its work tree, then sweep unregistered leftovers under the lanes root",
     category: "AI tools",
     reference: ["", "automation", ["files", "git"]],
     default_script_arguments: ["prune"]
@@ -1546,7 +1730,7 @@ var CLONE_COMMANDS = {
 };
 
 // scripts/gate/gate-plan.ts
-import { availableParallelism as availableParallelism3 } from "node:os";
+import { availableParallelism as availableParallelism4 } from "node:os";
 
 // scripts/lib/status-icons.ts
 var FAIL_ICON = "\u2717";
@@ -1596,13 +1780,24 @@ var UNIT_LABEL = "test:unit";
 var BEHAVIOR_LABEL = "behavior";
 var WARNING_CHECKER_LABELS = [LINT_LABEL, TYPE_CHECK_LABEL];
 var STATIC_CHECKS = [
-  { label: LINT_LABEL, target: "lint", reserved_cores: core_budget.CORE_WEIGHTS.lint },
+  {
+    label: LINT_LABEL,
+    target: "lint",
+    reserved_cores: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
+  },
   {
     label: TYPE_CHECK_LABEL,
     target: "check",
-    reserved_cores: core_budget.CORE_WEIGHTS.type_check
+    reserved_cores: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
+  },
+  {
+    label: "cspell",
+    target: "cspell:dot",
+    reserved_cores: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
-  { label: "cspell", target: "cspell:dot", reserved_cores: core_budget.CORE_WEIGHTS.spell_check },
   { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
   // **The unused-member check reserves no core** (joshuafolkken/kit#2987): it builds one TypeScript
   // program and walks it for about 5s, and it is over well before lint and the type check. A
@@ -1655,14 +1850,24 @@ function check_weight(check, plan, available_cores) {
   if (check.label !== UNIT_LABEL) return check.reserved_cores;
   return plan.unit_worker_cap ?? solo_unit_weight(available_cores);
 }
-function direct_unit_weight(available_cores = availableParallelism3(), live_runs = unit_worker_share.live_run_count()) {
+function unit_memory(workers) {
+  return workers * core_budget.MEMORY_MB.unit_worker;
+}
+function check_memory(check, plan, available_cores) {
+  if (check.label !== UNIT_LABEL) return check.memory_mb ?? 0;
+  return unit_memory(check_weight(check, plan, available_cores));
+}
+function direct_unit_weight(available_cores = availableParallelism4(), live_runs = unit_worker_share.live_run_count()) {
   const weight = unit_worker_share.current_share(available_cores, live_runs) ?? solo_unit_weight(available_cores);
   return Math.max(unit_worker_share.MIN_WORKERS, weight);
 }
+function direct_unit_memory() {
+  return unit_memory(direct_unit_weight());
+}
 function plan_of(concurrency, unit_worker_cap, checks = GATE_CHECKS) {
   return { checks, concurrency, unit_worker_cap };
 }
-function resolve_gate_plan(available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
+function resolve_gate_plan(available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS, is_unit_included = true) {
   const checks = select_gate_checks(is_unit_included);
   return {
     checks,
@@ -1680,7 +1885,7 @@ function format_unit_cap(plan) {
   if (plan.unit_worker_cap === void 0) return `${UNIT_LABEL} unrestricted`;
   return `${UNIT_LABEL} at ${String(plan.unit_worker_cap)} workers`;
 }
-function format_gate_plan(plan, available_cores = availableParallelism3(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
+function format_gate_plan(plan, available_cores = availableParallelism4(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
   const cap = format_unit_cap(plan);
   const count = `${String(plan.concurrency)} of ${String(plan.checks.length)}`;
   const width = `${count}${josh_verdict.GATE_OPENING_MARK}`;
@@ -1696,7 +1901,9 @@ var gate_plan = {
   TYPE_CHECK_LABEL,
   UNIT_LABEL,
   WARNING_CHECKER_LABELS,
+  check_memory,
   check_weight,
+  direct_unit_memory,
   direct_unit_weight,
   format_gate_plan,
   format_machine,
@@ -1732,28 +1939,32 @@ var DEV_COMMANDS = {
     description: "Check code with prettier and eslint (skips a tool a basic project lacks)",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   "lint:related": {
     script: "scripts/lint/lint-related.ts",
     description: "Check only the changed files with prettier and eslint (whole tree on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.lint
+    core_weight: core_budget.CORE_WEIGHTS.lint,
+    memory_mb: core_budget.MEMORY_MB.lint
   },
   lines: {
     script: "scripts/lines/lines-command.ts",
     description: "Print a file's code lines against the max-lines limit and the headroom left",
     category: "Development",
     reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
   },
   "refactor:scan": {
     script: "scripts/refactor/refactor-scan-cli.ts",
     description: "List refactoring candidates in the changed scope by category and answer clear/candidates",
     category: "Development",
     reference: ["", "automation", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.eslint_scan
+    core_weight: core_budget.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_budget.MEMORY_MB.eslint_scan
   },
   bytes: {
     script: "scripts/lines/bytes-command.ts",
@@ -1833,7 +2044,8 @@ var DEV_COMMANDS = {
     description: "Run spell check including dotfiles",
     category: "Development",
     reference: ["", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.spell_check
+    core_weight: core_budget.CORE_WEIGHTS.spell_check,
+    memory_mb: core_budget.MEMORY_MB.spell_check
   },
   behavior: {
     script: "scripts/behavior/behavior-cli.ts",
@@ -1852,14 +2064,16 @@ var DEV_COMMANDS = {
     description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
     category: "Development",
     reference: [FILTER_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:related": {
     script: "scripts/test/test-related.ts",
     description: "Run only the unit tests related to the changed files (full suite on fallback)",
     category: "Development",
     reference: [FILE_ARGUMENTS, "developer", ["processes"]],
-    core_weight: gate_plan.direct_unit_weight
+    core_weight: gate_plan.direct_unit_weight,
+    memory_mb: gate_plan.direct_unit_memory
   },
   "test:declared": {
     script: "scripts/test/test-declared.ts",
@@ -1903,7 +2117,8 @@ var DEV_COMMANDS = {
     description: "Type-check with tsc (skips a basic project with no TypeScript to check)",
     category: "Development",
     reference: ["[arguments...]", "developer", ["processes"]],
-    core_weight: core_budget.CORE_WEIGHTS.type_check
+    core_weight: core_budget.CORE_WEIGHTS.type_check,
+    memory_mb: core_budget.MEMORY_MB.type_check
   },
   port: {
     script: "scripts/ports/port-command.ts",
@@ -2024,9 +2239,9 @@ var MAINTENANCE_COMMANDS = {
     shell: [
       "sh",
       "-c",
-      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:corepack && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:scope --record"
+      "export NODE_AUTH_TOKEN=$(gh auth token) && pnpm josh latest:guard && pnpm josh latest:update && pnpm josh ranges && pnpm josh audit && pnpm josh latest:corepack && pnpm josh latest:scope --record"
     ],
-    description: "Update pnpm, dependencies, and run security audit",
+    description: "Update dependencies, run security audit, then update pnpm",
     category: "Maintenance",
     reference: ["", "developer", ["files", "network", "processes"]],
     argument_targets: ["latest:corepack", "latest:update", "audit"]
@@ -2745,15 +2960,16 @@ async function run_entry(entry, subcommand_arguments) {
   if (entry.shell) return run_shell_command(entry.shell, subcommand_arguments);
   return await run_script_entry(entry, subcommand_arguments);
 }
-function command_weight(entry) {
-  return typeof entry.core_weight === "function" ? entry.core_weight() : entry.core_weight;
+function declared(value) {
+  return typeof value === "function" ? value() : value;
 }
 async function dispatch_entry(entry, subcommand_arguments) {
-  const weight = command_weight(entry);
+  const weight = declared(entry.core_weight);
   if (weight === void 0) return await run_entry(entry, subcommand_arguments);
   return await core_budget.with_command_reservation(
     weight,
-    async () => await run_entry(entry, subcommand_arguments)
+    async () => await run_entry(entry, subcommand_arguments),
+    { memory_mb: declared(entry.memory_mb) }
   );
 }
 async function run_command(cmd, subcommand_arguments, is_consumer = false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1229.0",
+  "version": "1.1240.0",
   "name": "@joshuafolkken/kit",
   "description": "Development toolkit for AI-assisted projects: formatting, AI assistant rules and a Git/GitHub Issue workflow for any repository, plus lint, type check, tests and hooks for Node projects",
   "keywords": [

package/prompts/collaboration-workflow/issue-template.md

@@ -71,6 +71,7 @@ Issue には次の要素を必ず含める。
 - **`bugfix` は PR のリリース分類であり、Issue の `bug` の代わりにしない。** `enhancement` と `breaking-change` の両方を持つ Issue の PR は `breaking-change` 一つに分類する
 - **`## 発火点`** の名前は `prompts/collaboration-workflow/rule-delivery.md` の配送表と突き合わされる
 - **`## ベースライン`** の測定コマンドは、マージ後に `pnpm josh measure:rerun <N>` が再実行して before / after を印字する（作者が `OWNER` / `MEMBER` / `COLLABORATOR` の Issue に限る）
+- **公開しないと利用側が使えない変更には `--release` を付ける**（既存 Issue は `pnpm josh issue:release <N>`）。リリース用 Issue の blocker になる（`docs/josh-commands-backlog.md` → `josh issue:release`）
 
 ### 起票元へのバックリンク（`## Origin` / `## Upstream issues`）