@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-XXNEY4B3.js

@@ -1,110 +0,0 @@
-import {
-  git_gh_etag_read
-} from "./chunk-EWVR5AEX.js";
-import {
-  shared_cache
-} from "./chunk-C6QSVO5K.js";
-import {
-  author_fields_schema
-} from "./chunk-34DND4BA.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  parse_json
-} from "./chunk-XDF25GSU.js";
-
-// scripts/gh/gh-permission-cache.ts
-import { z } from "zod";
-var MS_KEPT = 36e5;
-var WRITERS_CACHE = { prefix: "josh-write-permission-", ttl_ms: MS_KEPT };
-var entries_schema = z.array(z.object({ login: z.string(), read_at: z.number() }));
-function fresh_entries(repo, now_ms) {
-  const entries = shared_cache.read(WRITERS_CACHE, repo, entries_schema, now_ms) ?? [];
-  return entries.filter((entry) => entry.read_at <= now_ms && now_ms - entry.read_at < MS_KEPT);
-}
-function is_writer(repo, login, now_ms = Date.now()) {
-  return fresh_entries(repo, now_ms).some((entry) => entry.login === login);
-}
-function remember_writer(repo, login, now_ms = Date.now()) {
-  const fresh = fresh_entries(repo, now_ms);
-  if (fresh.some((entry) => entry.login === login)) return;
-  shared_cache.write(WRITERS_CACHE, repo, [...fresh, { login, read_at: now_ms }], now_ms);
-}
-var gh_permission_cache = { WRITERS_CACHE, is_writer, remember_writer };
-
-// scripts/gh/gh-author-association.ts
-import { z as z2 } from "zod";
-var OWNER = "OWNER";
-var ASKED_ASSOCIATIONS = /* @__PURE__ */ new Set(["MEMBER", "COLLABORATOR"]);
-var WRITE_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
-var LOGIN_PATTERN = /^[\da-z](?:[\w-]*[\da-z])?$/iu;
-var TRUSTED_LIST = "OWNER, or MEMBER / COLLABORATOR with write access";
-var AUTHOR_FIELDS = "author_association,user";
-var permission_schema = z2.looseObject({
-  permission: z2.string().nullish(),
-  role_name: z2.string().nullish()
-});
-var answers = /* @__PURE__ */ new Map();
-function permission_path(login, repo) {
-  return `${git_gh_api_path.repo_api_path(repo)}/collaborators/${login}/permission`;
-}
-function has_write_role(raw) {
-  const parsed = parse_json.parse_json_object_or_undefined(raw, permission_schema);
-  const roles = [parsed?.role_name, parsed?.permission];
-  return roles.some((role) => typeof role === "string" && WRITE_ROLES.has(role));
-}
-async function read_permission(asked) {
-  try {
-    const path = permission_path(asked.login, asked.repo);
-    const raw = await git_gh_etag_read.read(path, asked.timeout_ms);
-    return has_write_role(raw);
-  } catch {
-    return void 0;
-  }
-}
-async function ask_permission(asked) {
-  if (asked.is_shared !== true) return await read_permission(asked);
-  const repo = asked.repo ?? "";
-  if (gh_permission_cache.is_writer(repo, asked.login)) return true;
-  const has_write = await read_permission(asked);
-  if (has_write === true) gh_permission_cache.remember_writer(repo, asked.login);
-  return has_write;
-}
-async function can_write(author) {
-  const key = `${author.repo ?? ""} ${author.login}`;
-  const asked = answers.get(key) ?? ask_permission(author);
-  answers.set(key, asked);
-  const has_write = await asked;
-  if (has_write === void 0 && answers.get(key) === asked) answers.delete(key);
-  return has_write;
-}
-function is_user_login(login) {
-  return login !== void 0 && LOGIN_PATTERN.test(login);
-}
-function is_asked(author) {
-  return ASKED_ASSOCIATIONS.has(author.association ?? "") && is_user_login(author.login);
-}
-async function trust_of(author) {
-  if (author.association === OWNER) return true;
-  if (author.login === void 0 || !is_asked(author)) return false;
-  return await can_write({ ...author, login: author.login });
-}
-async function is_trusted(author) {
-  return await trust_of(author) === true;
-}
-function author_of(row, timeout_ms) {
-  return { login: row.user?.login, association: row.author_association, timeout_ms };
-}
-var gh_author_association = {
-  AUTHOR_FIELDS,
-  TRUSTED_LIST,
-  author_fields_schema,
-  author_of,
-  is_trusted,
-  trust_of
-};
-
-export {
-  gh_author_association
-};

package/dist/commands/chunk-Y27PTXXI.js

@@ -1,258 +0,0 @@
-import {
-  related_scope
-} from "./chunk-CFHRNTE5.js";
-import {
-  verification_tail
-} from "./chunk-FGL6DBZU.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-
-// scripts/test/test-pinned-stage.ts
-var WIDE_REACH = 100;
-var WIDE_RATIO = 3;
-var TYPE_RED = { verdict: "red", failed: [], pinned_by: "type-check" };
-function none() {
-  return { direct: 0, typed: 0, escalated: 0 };
-}
-function is_wide(reach, direct) {
-  if (direct === 0 || direct >= reach) return false;
-  return reach >= WIDE_REACH || reach >= WIDE_RATIO * direct;
-}
-function plan_over(file, direct, reach) {
-  return is_wide(reach, direct.length) ? { direct, reach: [file] } : { reach: [file] };
-}
-async function past_direct(plan, run, is_type_red, staged) {
-  if (await is_type_red()) {
-    staged.typed += 1;
-    return TYPE_RED;
-  }
-  staged.escalated += 1;
-  return await run(plan.reach);
-}
-async function staged_verdict(plan, run, is_type_red, staged) {
-  if (plan.direct === void 0) return await run(plan.reach);
-  const first = await run(plan.direct);
-  if (first.verdict !== "red") return await past_direct(plan, run, is_type_red, staged);
-  staged.direct += 1;
-  return first;
-}
-function counts_suffix(staged) {
-  if (staged === void 0 || staged.direct + staged.typed + staged.escalated === 0) return "";
-  const typed = staged.typed === 0 ? "" : ` \xB7 type check ${String(staged.typed)}`;
-  return ` \xB7 direct ${String(staged.direct)}${typed} \xB7 escalated ${String(staged.escalated)}`;
-}
-var test_pinned_stage = { WIDE_RATIO, WIDE_REACH, counts_suffix, none, plan_over, staged_verdict };
-
-// scripts/test/test-pinned-logic.ts
-var DEFAULT_MAX_HUNKS = 20;
-var MAX_TEST_FILES = 150;
-var HEADER = /^@@ -\d+(?:,\d+)? \+(?<start>\d+)(?:,(?<count>\d+))? @@/u;
-var FILE_HEADER = "+++ b/";
-var SECTION_HEADER = "diff --git ";
-var OLD_LINE = "-";
-var OLD_FILE_HEADER = "--- ";
-var NEW_LINE = "+";
-var FILE_HEADER_MARK = "+++ ";
-var OLD_FILE_PATH = "--- a/";
-var LINE_BREAK = "\n";
-var GREEN_REASON = "reverting it left every related test green";
-var NO_TEST_REASON = "no related test ran with it reverted";
-var STUB_GREEN_REASON = "replacing its body with a throw left every related test green";
-var STUB_NO_TEST_REASON = "no related test ran with its body replaced by a throw";
-var UNPARSED_REASON = "an added file, and typescript is not installed to read its functions";
-var NO_RUNNER_REASON = "vitest is not installed to run its related tests";
-var STOPPED_REASON = "vitest stopped before any test ran with it reverted";
-var CUT_REASON = "not probed: the run stopped at the first unpinned hunk";
-var OVER_CAP_REASON = `over the ${String(MAX_TEST_FILES)}-test-file cap`;
-var STOPPED_VERDICT = "stopped";
-var SETTLED_VERDICTS = /* @__PURE__ */ new Set(["red", STOPPED_VERDICT]);
-function is_target(file) {
-  return !test_declared_logic.is_test_file(file) && related_scope.is_relatable(file);
-}
-function count_of(group) {
-  return group === void 0 ? 1 : Number(group);
-}
-function hunk_from(file, line) {
-  const groups = HEADER.exec(line)?.groups;
-  if (groups === void 0) return void 0;
-  return {
-    file,
-    new_start: Number(groups["start"]),
-    new_count: count_of(groups["count"]),
-    old_lines: [],
-    new_lines: []
-  };
-}
-function is_old_line(line) {
-  return line.startsWith(OLD_LINE) && !line.startsWith(OLD_FILE_HEADER);
-}
-function is_new_line(line) {
-  return line.startsWith(NEW_LINE) && !line.startsWith(FILE_HEADER_MARK);
-}
-function record_line(hunk, line) {
-  if (hunk === void 0) return;
-  if (is_old_line(line)) hunk.old_lines.push(line.slice(OLD_LINE.length));
-  else if (is_new_line(line)) hunk.new_lines?.push(line.slice(NEW_LINE.length));
-}
-function file_after(file, line) {
-  if (line.startsWith(FILE_HEADER)) return line.slice(FILE_HEADER.length);
-  if (line.startsWith(OLD_FILE_PATH)) return line.slice(OLD_FILE_PATH.length);
-  return line.startsWith(SECTION_HEADER) ? "" : file;
-}
-function step(walk, line) {
-  walk.file = file_after(walk.file, line);
-  const hunk = hunk_from(walk.file, line);
-  if (hunk === void 0) record_line(walk.hunks.at(-1), line);
-  else walk.hunks.push(hunk);
-}
-function all_hunks(diff) {
-  const walk = { file: "", hunks: [] };
-  for (const line of diff.split(LINE_BREAK)) step(walk, line);
-  return walk.hunks;
-}
-function parse_hunks(diff) {
-  return all_hunks(diff).filter((hunk) => is_target(hunk.file));
-}
-function start_index(hunk) {
-  return hunk.new_count === 0 ? hunk.new_start : hunk.new_start - 1;
-}
-function revert(content, hunk) {
-  const lines = content.split(LINE_BREAK);
-  const parts = (hunk.parts ?? [hunk]).toSorted(
-    (left, right) => start_index(right) - start_index(left)
-  );
-  for (const part of parts) lines.splice(start_index(part), part.new_count, ...part.old_lines);
-  return lines.join(LINE_BREAK);
-}
-function split(hunks, max_hunks) {
-  return { checked: hunks.slice(0, max_hunks), unchecked: hunks.slice(max_hunks) };
-}
-function capped(hunks, reach, max_tests = MAX_TEST_FILES) {
-  function is_over(hunk) {
-    return (reach.get(hunk.file) ?? 0) > max_tests;
-  }
-  return {
-    checked: hunks.filter((hunk) => !is_over(hunk)),
-    unchecked: hunks.filter((hunk) => is_over(hunk))
-  };
-}
-function by_reach(probes, reach) {
-  function count(probe) {
-    return reach.get(probe.hunk.file) ?? 0;
-  }
-  return probes.toSorted((first, second) => count(first) - count(second));
-}
-function is_unpinned(probe) {
-  return !SETTLED_VERDICTS.has(probe.verdict);
-}
-function unpinned_of(hunk, probe) {
-  if (probe === void 0 || !is_unpinned(probe)) return [];
-  return [{ ...hunk, is_green: probe.verdict === "green" }];
-}
-function stopped_of(hunk, probe) {
-  return probe?.verdict === STOPPED_VERDICT ? [hunk] : [];
-}
-function outcome(hunks, verdicts) {
-  return {
-    unpinned: hunks.flatMap((hunk, index) => unpinned_of(hunk, verdicts[index])),
-    stopped: hunks.flatMap((hunk, index) => stopped_of(hunk, verdicts[index]))
-  };
-}
-function location(hunk) {
-  const line = `${hunk.file}:${String(Math.max(hunk.new_start, 1))}`;
-  return hunk.function_name === void 0 ? line : `${line} ${hunk.function_name}`;
-}
-function reason(hunk) {
-  if (hunk.function_name === void 0) return hunk.is_green ? GREEN_REASON : NO_TEST_REASON;
-  return hunk.is_green ? STUB_GREEN_REASON : STUB_NO_TEST_REASON;
-}
-function unchecked_reason(report) {
-  return report.has_runner ? `over the ${String(report.max_hunks)}-hunk cap` : NO_RUNNER_REASON;
-}
-function hint(hunk) {
-  const tests = hunk.related_tests;
-  if (tests === void 0) {
-    return "related tests unavailable; add or strengthen a regression test that fails when this change is reverted";
-  }
-  if (tests.length === 0) {
-    return "no related tests; add a related regression test that fails when this change is reverted";
-  }
-  return `related tests: ${tests.join(", ")}; strengthen a regression assertion that fails when this change is reverted`;
-}
-function unpinned_lines(report) {
-  return report.unpinned.map(
-    (hunk) => `unpinned ${location(hunk)} \u2014 ${reason(hunk)}; ${hint(hunk)}`
-  );
-}
-function place_of(hunk, why) {
-  return { place: location(hunk), why };
-}
-function unchecked_places(report) {
-  return [
-    ...report.unchecked.map((hunk) => place_of(hunk, unchecked_reason(report))),
-    ...(report.over_cap ?? []).map((hunk) => place_of(hunk, OVER_CAP_REASON)),
-    ...report.stopped.map((hunk) => place_of(hunk, STOPPED_REASON)),
-    ...(report.cut ?? []).map((hunk) => place_of(hunk, CUT_REASON)),
-    ...report.unparsed.map((file) => ({ place: file, why: UNPARSED_REASON }))
-  ];
-}
-function has_unchecked(report) {
-  return unchecked_places(report).length > 0;
-}
-function format(report) {
-  const unchecked = unchecked_places(report).map((item) => `unchecked ${item.place} \u2014 ${item.why}`);
-  return [...unpinned_lines(report), ...unchecked].join(LINE_BREAK);
-}
-function folded_unchecked(report) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const { why } of unchecked_places(report)) counts.set(why, (counts.get(why) ?? 0) + 1);
-  return [...counts].map(([why, count]) => `unchecked ${String(count)} \u2014 ${why}`);
-}
-function counts_line(report) {
-  const unchecked = String(unchecked_places(report).length);
-  const staged = test_pinned_stage.counts_suffix(report.staged);
-  return `unpinned ${String(report.unpinned.length)} \xB7 unchecked ${unchecked}${staged}`;
-}
-function report_parts(report) {
-  const lines = [...unpinned_lines(report), ...folded_unchecked(report)];
-  return {
-    text: lines.map((line) => `${line}${LINE_BREAK}`).join(""),
-    counts: counts_line(report),
-    ...report.tree_hash !== void 0 && {
-      tree_hash: report.tree_hash,
-      is_stale: report.is_stale
-    }
-  };
-}
-function report_text(parts, note = "") {
-  const stale = parts.is_stale === true ? " \xB7 stale" : "";
-  const snapshot = parts.tree_hash === void 0 ? "" : `snapshot ${parts.tree_hash}${stale}
-`;
-  const failures = `${snapshot}${parts.text}${note}`;
-  if (parts.counts === void 0) return failures;
-  return verification_tail.format_tail({ failures, log: parts.log, verdict: parts.counts });
-}
-var test_pinned_logic = {
-  all_hunks,
-  DEFAULT_MAX_HUNKS,
-  by_reach,
-  capped,
-  format,
-  has_unchecked,
-  is_target,
-  is_unpinned,
-  location,
-  MAX_TEST_FILES,
-  outcome,
-  parse_hunks,
-  report_parts,
-  report_text,
-  revert,
-  split
-};
-
-export {
-  test_pinned_stage,
-  test_pinned_logic
-};

package/dist/commands/chunk-Y4EBUI6M.js

@@ -1,237 +0,0 @@
-import {
-  issue_park
-} from "./chunk-OIX2363L.js";
-import {
-  run_stalled
-} from "./chunk-S4M6UWR2.js";
-import {
-  agent_worker_profile
-} from "./chunk-FVDQNMP6.js";
-import {
-  document_section
-} from "./chunk-NDWZTWXV.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  RUN_STALLED_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  distributed_paths
-} from "./chunk-66TGK5XL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-
-// scripts/run/park/run-stalled-park.ts
-var { PARK } = run_event_stream.EVENT_KIND;
-async function apply(issue, comment, cause, fields = {}) {
-  const park_write = await issue_park.apply(issue, RUN_STALLED_LABEL, comment);
-  if (!park_write.is_labelled) return false;
-  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, cause), /* @__PURE__ */ new Date(), fields);
-  return true;
-}
-var run_stalled_park = { apply };
-
-// scripts/run/park/run-park-escalate.ts
-var ESCALATE_FLAG = "--escalate";
-var OPTIONS = { escalate: { type: "string" } };
-var DISABLED_NOTE = `run:park ${ESCALATE_FLAG}: refused \u2014 this repository's package.json does not set josh.worker.escalate to true.`;
-function is_requested(argv) {
-  return argv.some((token) => token === ESCALATE_FLAG || token.startsWith(`${ESCALATE_FLAG}=`));
-}
-function is_enabled(directory) {
-  const result = agent_worker_profile.read(directory);
-  return result.kind === "settings" && result.settings.escalate;
-}
-function reason_of(value) {
-  return value?.trim() ?? "";
-}
-function escalation_of(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  if (parsed === void 0) return void 0;
-  const issue = issue_number_shape.single_of(parsed.positionals);
-  const reason = reason_of(parsed.values.escalate);
-  return issue === void 0 || reason === "" ? void 0 : { issue, reason };
-}
-function refusal_of(escalation, directory, usage) {
-  if (escalation === void 0) return usage;
-  return is_enabled(directory) ? void 0 : DISABLED_NOTE;
-}
-function accepted(argv, directory, usage) {
-  const escalation = escalation_of(argv);
-  const refusal = refusal_of(escalation, directory, usage);
-  if (refusal !== void 0) console.error(refusal);
-  return refusal === void 0 ? escalation : void 0;
-}
-function comment_of(escalation) {
-  const { issue, reason } = escalation;
-  return [
-    `Parked with \`${RUN_STALLED_LABEL}\`: ${run_stalled.ESCALATION_REQUESTED.why}`,
-    `- Reason: ${reason}`,
-    `- Next: the backlogrun drive resumes it one \`worker:<name>\` profile up, or hands it to a person at the top profile; without a drive, give it a stronger profile, ${run_stalled.next_step(issue)}.`
-  ].join("\n");
-}
-async function park(argv, directory, usage) {
-  const escalation = accepted(argv, directory, usage);
-  if (escalation === void 0) return void 0;
-  const { short } = run_stalled.escalation_requested(escalation.reason);
-  const is_parked = await run_stalled_park.apply(escalation.issue, comment_of(escalation), short);
-  console.info(`escalate ${session_cite.issue(escalation.issue)} \u2014 parked: ${String(is_parked)}`);
-  return is_parked ? escalation.issue : void 0;
-}
-var run_park_escalate = { ESCALATE_FLAG, is_enabled, is_requested, park };
-
-// scripts/agent/lane-instructions.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-// scripts/cost-runtime/cost-tokens.ts
-var ASCII_CHARS_PER_TOKEN = 3;
-var WIDE_TOKENS_PER_CHAR = 1;
-var ASCII_LIMIT = 128;
-function count_chars(text) {
-  let ascii_chars = 0;
-  let wide_chars = 0;
-  for (const char of text) {
-    if ((char.codePointAt(0) ?? 0) < ASCII_LIMIT) ascii_chars += 1;
-    else wide_chars += 1;
-  }
-  return { ascii_chars, wide_chars };
-}
-function estimate(text) {
-  const { ascii_chars, wide_chars } = count_chars(text);
-  return Math.round(ascii_chars / ASCII_CHARS_PER_TOKEN) + wide_chars * WIDE_TOKENS_PER_CHAR;
-}
-function ascii_bytes_to_tokens(bytes) {
-  return Math.round(bytes / ASCII_CHARS_PER_TOKEN);
-}
-var cost_tokens = {
-  ASCII_CHARS_PER_TOKEN,
-  count_chars,
-  estimate,
-  ascii_bytes_to_tokens
-};
-
-// scripts/agent/lane-instructions.ts
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/agent/lane-instructions.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
-var WORKFLOW_ENTRY = "fullrun-lane.md";
-var WORKFLOW_GUIDE = `A headless fullrun lane child runs pnpm josh doc:read ${WORKFLOW_ENTRY} instead of workflow-commands/SKILL.md, fullrun.md or entry-sequence.md. A resumed child follows its resume prompt first. Review sessions do not start a fullrun.`;
-var RULES_FILE = "CLAUDE.md";
-var POINTER_FILE = "AGENTS.md";
-var INCLUDE_PATTERN = /^<!-- include: CLAUDE\.md → "(?<wanted>.+)" -->$/u;
-var PROMPT_FILE_FLAG = "--append-system-prompt-file";
-var SETTINGS_FLAG = "--settings";
-var PROMPT_FILE_PREFIX = "josh-lane-instructions-";
-var PROMPT_FILE_SUFFIX = ".md";
-var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
-var ESCALATION_GUIDE = [
-  "",
-  "## Escalation",
-  "",
-  '- This Issue needs a stronger model than the one you run on \u2192 `pnpm josh run:park <N> --escalate "<reason>"`, then stop. The reason is required and recorded; the lane resumes one profile up, or goes to a person at the top profile.'
-].join("\n");
-function expand_line(line, rules) {
-  const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
-  if (wanted === void 0) return line;
-  return document_section.section(rules, wanted)?.text;
-}
-function compose(lane_markdown, rules) {
-  const expanded = lane_markdown.split("\n").map((line) => expand_line(line, rules));
-  if (expanded.includes(void 0)) return void 0;
-  return [WORKFLOW_GUIDE, ...expanded].join("\n");
-}
-function rules_sources(cwd) {
-  const imported = distributed_paths.CLAUDE_MD_IMPORT_LINE.replace(/^@/u, "");
-  return [path.join(cwd, RULES_FILE), path.join(cwd, imported)];
-}
-function composed_from(lane_markdown, rules_path) {
-  const rules = document_section.read_optional(rules_path);
-  return rules === void 0 ? void 0 : compose(lane_markdown, rules);
-}
-function rules_set(cwd, package_directory) {
-  const lane_markdown = document_section.read_optional(path.join(package_directory, LANE_DOCUMENT));
-  if (lane_markdown === void 0) return void 0;
-  for (const rules_path of rules_sources(cwd)) {
-    const text = composed_from(lane_markdown, rules_path);
-    if (text !== void 0) return { text, rules_path };
-  }
-  return void 0;
-}
-function composed_set(cwd, package_directory, is_worker = false) {
-  const set = rules_set(cwd, package_directory);
-  if (set === void 0 || !is_worker || !run_park_escalate.is_enabled(cwd)) return set;
-  return { ...set, text: `${set.text}${ESCALATION_GUIDE}` };
-}
-function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
-  return composed_set(cwd, package_directory)?.text;
-}
-function written(text) {
-  const file_path = stamp_file.stamp_path(PROMPT_FILE_PREFIX, text, PROMPT_FILE_SUFFIX);
-  if (stamp_file.read_stamp_text(file_path) === text) return file_path;
-  try {
-    return stamp_file.replace_text_stamp(file_path, text);
-  } catch {
-    return void 0;
-  }
-}
-function excluded_settings(rules_path, cwd) {
-  return JSON.stringify({ claudeMdExcludes: [rules_path, path.join(cwd, POINTER_FILE)] });
-}
-function flags_of(set, cwd) {
-  const prompt_file = set === void 0 ? void 0 : written(set.text);
-  if (set === void 0 || prompt_file === void 0) return [];
-  return [PROMPT_FILE_FLAG, prompt_file, SETTINGS_FLAG, excluded_settings(set.rules_path, cwd)];
-}
-function flags(cwd = process.cwd(), is_worker = false) {
-  return flags_of(composed_set(cwd, PACKAGE_DIRECTORY, is_worker), cwd);
-}
-function tokens_of(text) {
-  return cost_tokens.estimate(text).toLocaleString("en-US");
-}
-function rules_tokens(rules_path) {
-  return tokens_of(document_section.read_optional(rules_path) ?? "");
-}
-function resident_line(cwd = process.cwd()) {
-  const set = composed_set(cwd, PACKAGE_DIRECTORY);
-  const rules = rules_tokens(set?.rules_path ?? path.join(cwd, RULES_FILE));
-  const lane_tokens = set === void 0 ? "not composed" : `${tokens_of(set.text)} tok`;
-  return `  resident: lane instructions ${lane_tokens} in place of ${RULES_FILE} ${rules} tok`;
-}
-var lane_instructions = {
-  WORKFLOW_ENTRY,
-  PROMPT_FILE_FLAG,
-  SETTINGS_FLAG,
-  compose,
-  composed_in,
-  flags,
-  resident_line
-};
-
-export {
-  cost_tokens,
-  run_stalled_park,
-  run_park_escalate,
-  lane_instructions
-};

package/dist/commands/chunk-YAU3LYNF.js

@@ -1,60 +0,0 @@
-import {
-  hook_ledger
-} from "./chunk-XHGWMD3L.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/hooks/hook-demoted.ts
-import { readFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-var DEMOTED_FILE = ".josh/hook-demoted.json";
-var NOTICE_HEADER = "\u2139 Demoted rule \u2014 this call ran; do not reissue it. The refusal it would have given:\n";
-var INDENT = "	";
-var rules_schema = z.object({ rules: z.array(z.string()) });
-function read_rules(file = DEMOTED_FILE) {
-  try {
-    return new Set(json_value.parse_with(readFileSync(file, "utf8"), rules_schema)?.rules);
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-function rules(environment = process.env) {
-  return environment["VITEST"] === void 0 ? read_rules() : /* @__PURE__ */ new Set();
-}
-async function write_rules(demoted, file = DEMOTED_FILE) {
-  const sorted = [...demoted].toSorted((left, right) => left.localeCompare(right));
-  const body = JSON.stringify({ rules: sorted }, void 0, INDENT);
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, `${body}
-`);
-}
-function is_demoted(reason, demoted) {
-  return demoted.has(hook_ledger.rule_of(reason));
-}
-function verdict(reasons, demoted) {
-  const blocking = reasons.find((reason) => !is_demoted(reason, demoted));
-  if (blocking !== void 0) return { reason: blocking, notice: void 0, fault: void 0 };
-  const [first] = reasons;
-  return first === void 0 ? void 0 : { reason: void 0, notice: `${NOTICE_HEADER}${first}`, fault: void 0 };
-}
-function refusal_of(notice, demoted) {
-  if (notice?.startsWith(NOTICE_HEADER) !== true) return void 0;
-  const reason = notice.slice(NOTICE_HEADER.length);
-  return is_demoted(reason, demoted) ? reason : void 0;
-}
-var hook_demoted = {
-  DEMOTED_FILE,
-  NOTICE_HEADER,
-  read_rules,
-  refusal_of,
-  rules,
-  verdict,
-  write_rules
-};
-
-export {
-  hook_demoted
-};