@joshuafolkken/kit 1.872.0

package/dist/josh.js

@@ -0,0 +1,1795 @@
+#!/usr/bin/env node
+
+// scripts/doctor/doctor-consumer.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+// scripts/lib/spawn-exit.ts
+var SPAWN_ERROR_EXIT_CODE = 2;
+var SIGNAL_KILL_EXIT_CODE = 1;
+function resolve_spawn_exit(executable, result) {
+  if (result.exitCode !== void 0) return result.exitCode;
+  if (result.isTerminated === true) return SIGNAL_KILL_EXIT_CODE;
+  console.error(`Failed to execute ${executable}: ${result.shortMessage ?? "spawn failed"}`);
+  return SPAWN_ERROR_EXIT_CODE;
+}
+function read_spawn_stdout(result) {
+  return result.stdout ?? "";
+}
+
+// scripts/version/kit-descriptor.ts
+var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
+
+// scripts/version/parse-json.ts
+function safe_json_parse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// scripts/doctor/doctor-consumer.ts
+import { execaSync } from "execa";
+import { z } from "zod";
+var NODE_MODULES = "node_modules";
+var SETTINGS_PATH = path.join(".claude", "settings.json");
+var CLAUDE_MD = "CLAUDE.md";
+var PLUGIN_ID = "kit@kit";
+var CLAUDE_MD_POINTER = `@${NODE_MODULES}/${KIT_PACKAGE_NAME}/dist/${CLAUDE_MD}`;
+var SECRETLINT_BIN = path.join(NODE_MODULES, ".bin", "secretlint");
+var GIT_TIMEOUT_MS = 2e3;
+var manifest_schema = z.object({
+  name: z.string().optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  devDependencies: z.record(z.string(), z.string()).optional()
+});
+var settings_schema = z.object({
+  enabledPlugins: z.record(z.string(), z.boolean()).optional()
+});
+var STATE_OK = "ok";
+var STATE_TARGET_MISSING = "target-missing";
+var STATE_MISSING = "missing";
+function read_optional(file_path) {
+  try {
+    return existsSync(file_path) ? readFileSync(file_path, "utf8") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parse_manifest(root) {
+  const content = read_optional(path.join(root, "package.json"));
+  if (content === void 0) return void 0;
+  const parsed = manifest_schema.safeParse(safe_json_parse(content));
+  return parsed.success ? parsed.data : void 0;
+}
+function lists_kit_dependency(manifest) {
+  if (manifest === void 0) return false;
+  return Object.hasOwn(manifest.dependencies ?? {}, KIT_PACKAGE_NAME) || Object.hasOwn(manifest.devDependencies ?? {}, KIT_PACKAGE_NAME);
+}
+function is_kit_consumer(root) {
+  const manifest = parse_manifest(root);
+  if (manifest?.name === KIT_PACKAGE_NAME) return false;
+  return lists_kit_dependency(manifest) || existsSync(path.join(root, NODE_MODULES, KIT_PACKAGE_NAME));
+}
+function is_plugin_declared(root) {
+  const content = read_optional(path.join(root, SETTINGS_PATH));
+  if (content === void 0) return false;
+  const parsed = settings_schema.safeParse(safe_json_parse(content));
+  return parsed.success && parsed.data.enabledPlugins?.[PLUGIN_ID] === true;
+}
+function configured_hooks_path(root) {
+  const result = execaSync("git", ["-C", root, "config", "--get", "core.hooksPath"], {
+    reject: false,
+    timeout: GIT_TIMEOUT_MS
+  });
+  const value = read_spawn_stdout(result).trim();
+  return value === "" ? void 0 : value;
+}
+function claude_md_state(root) {
+  const content = read_optional(path.join(root, CLAUDE_MD));
+  if (content === void 0) return STATE_MISSING;
+  if (!content.includes(CLAUDE_MD_POINTER)) return STATE_OK;
+  return existsSync(path.join(root, NODE_MODULES, KIT_PACKAGE_NAME, "dist", CLAUDE_MD)) ? STATE_OK : STATE_TARGET_MISSING;
+}
+function is_secretlint_runnable(root) {
+  return existsSync(path.join(root, SECRETLINT_BIN));
+}
+function status_line(is_ok, ok_text, warn_text) {
+  return is_ok ? `  \u2713 ${ok_text}` : `  \u26A0 ${warn_text}`;
+}
+function plugin_line(is_declared) {
+  return status_line(
+    is_declared,
+    `kit plugin declared (run \`claude plugin install ${PLUGIN_ID}\` once if skills are missing)`,
+    "kit plugin not declared in .claude/settings.json \u2014 run `pnpm josh sync`"
+  );
+}
+function hooks_path_line(hooks_path) {
+  return status_line(
+    hooks_path === void 0,
+    "git hooks install normally (core.hooksPath unset)",
+    `core.hooksPath is set (${hooks_path ?? ""}) \u2014 lefthook installs no git hooks; unset it`
+  );
+}
+function claude_md_line(state) {
+  if (state === STATE_OK) return "  \u2713 CLAUDE.md resolves to the installed kit rules";
+  if (state === STATE_TARGET_MISSING) {
+    return "  \u26A0 CLAUDE.md points at rules that are not installed \u2014 run `pnpm install`";
+  }
+  return "  \u26A0 CLAUDE.md is missing \u2014 run `pnpm josh init`";
+}
+function secretlint_line(is_runnable) {
+  return status_line(
+    is_runnable,
+    "secretlint is runnable",
+    "secretlint is not installed \u2014 run `pnpm install`"
+  );
+}
+function consumer_setup_lines(root) {
+  return [
+    plugin_line(is_plugin_declared(root)),
+    hooks_path_line(configured_hooks_path(root)),
+    claude_md_line(claude_md_state(root)),
+    secretlint_line(is_secretlint_runnable(root))
+  ];
+}
+function report_consumer_setup(root) {
+  if (!is_kit_consumer(root)) return;
+  console.info("");
+  console.info("Consumer setup:");
+  for (const line of consumer_setup_lines(root)) console.info(line);
+}
+var doctor_consumer = {
+  claude_md_line,
+  claude_md_state,
+  configured_hooks_path,
+  consumer_setup_lines,
+  hooks_path_line,
+  is_kit_consumer,
+  is_plugin_declared,
+  is_secretlint_runnable,
+  plugin_line,
+  report_consumer_setup,
+  secretlint_line
+};
+
+// scripts/josh/josh-logic.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/build/local-bin.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+
+// scripts/lib/schemas.ts
+import { z as z2 } from "zod";
+var overrides_snapshot_schema = z2.record(z2.string(), z2.string());
+var package_version_schema = z2.object({ version: z2.string() });
+var package_named_version_schema = z2.looseObject({ name: z2.string(), version: z2.string() });
+var package_with_version_schema = z2.looseObject({ version: z2.string() });
+var ls_global_dependency_schema = z2.looseObject({ version: z2.string() });
+var ls_global_dependencies_schema = z2.record(z2.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z2.array(
+  z2.looseObject({
+    dependencies: ls_global_dependencies_schema
+  })
+);
+var vscode_settings_schema = z2.record(z2.string(), z2.unknown());
+var with_scripts_schema = z2.looseObject({
+  scripts: z2.record(z2.string(), z2.string()).optional()
+});
+var with_development_deps_schema = z2.looseObject({
+  devDependencies: z2.record(z2.string(), z2.string()).optional()
+});
+var with_package_manager_schema = z2.looseObject({
+  packageManager: z2.string().optional()
+});
+var with_development_engine_schema = z2.looseObject({
+  devEngines: z2.record(z2.string(), z2.unknown()).optional()
+});
+var bin_entry_schema = z2.union([z2.string(), z2.record(z2.string(), z2.string())]).optional();
+var package_bin_schema = z2.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z2.record(z2.string(), z2.unknown());
+var string_array_schema = z2.array(z2.string());
+var string_record_schema = z2.record(z2.string(), z2.string());
+
+// scripts/build/local-bin.ts
+var NODE_MODULES2 = "node_modules";
+var BIN_DIR = ".bin";
+var WINDOWS_PLATFORM = "win32";
+var WINDOWS_SHIM_SUFFIX = ".cmd";
+var PACKAGE_JSON = "package.json";
+function resolve_local_bin(project_root, bin_name) {
+  const shim = process.platform === WINDOWS_PLATFORM ? `${bin_name}${WINDOWS_SHIM_SUFFIX}` : bin_name;
+  return path2.join(project_root, NODE_MODULES2, BIN_DIR, shim);
+}
+function read_bin_entry(manifest_path, package_name, bin_name) {
+  const { bin } = package_bin_schema.parse(JSON.parse(readFileSync2(manifest_path, "utf8")));
+  if (typeof bin === "string") return bin_name === path2.basename(package_name) ? bin : void 0;
+  return bin?.[bin_name];
+}
+function resolve_package_bin(base_directory, package_name, bin_name) {
+  try {
+    const resolve_from = createRequire(path2.join(base_directory, PACKAGE_JSON));
+    const manifest_path = resolve_from.resolve(`${package_name}/${PACKAGE_JSON}`);
+    const bin_entry = read_bin_entry(manifest_path, package_name, bin_name);
+    if (bin_entry === void 0) return void 0;
+    const cli_entry = path2.join(path2.dirname(manifest_path), bin_entry);
+    return existsSync2(cli_entry) ? cli_entry : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// scripts/josh/josh-logic.ts
+import { execaSync as execaSync2 } from "execa";
+
+// scripts/josh/command-suggest.ts
+var MAX_SUGGESTION_DISTANCE = 3;
+function at(values, index) {
+  return values[index] ?? 0;
+}
+function fill_distance_row(source, target, row, previous) {
+  const current = [row];
+  for (let col = 1; col <= target.length; col++) {
+    const cost = source[row - 1] === target[col - 1] ? 0 : 1;
+    const deletion = at(previous, col) + 1;
+    const insertion = at(current, col - 1) + 1;
+    const substitution = at(previous, col - 1) + cost;
+    current.push(Math.min(deletion, insertion, substitution));
+  }
+  return current;
+}
+function edit_distance(source, target) {
+  let previous = Array.from({ length: target.length + 1 }, (_unused, index) => index);
+  for (let row = 1; row <= source.length; row++) {
+    previous = fill_distance_row(source, target, row, previous);
+  }
+  return at(previous, target.length);
+}
+function closest_command(input, commands) {
+  const within = commands.map((command) => ({ command, distance: edit_distance(input, command) })).filter((scored) => scored.distance <= MAX_SUGGESTION_DISTANCE).toSorted((left, right) => left.distance - right.distance);
+  return within[0]?.command;
+}
+var command_suggest = { closest_command, edit_distance };
+
+// ports/index.js
+var ENV_FILE_NAME = ".env";
+
+// scripts/josh/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var GATE_COMMAND = "gate";
+var PE = ["pnpm", "exec"];
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var TS_CACHE_FLAGS = ["--incremental", "--tsBuildInfoFile", TS_BUILD_INFO_FILE];
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+
+// scripts/josh/josh-commands-backlog.ts
+var BACKLOG_COMMANDS = {
+  "backlog:next": {
+    script: "scripts/backlog/backlog-next.ts",
+    description: "Order the whole opted-in backlog: auto-ok issues and the descendants of auto-ok epics, transitively through nested epics",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "backlog:offer": {
+    script: "scripts/backlog/backlog-offer-cli.ts",
+    description: "Collapse a backlogrun loop-head event into one call: read backlog:next, ask backlog:budget, return the verdict and any issues to start",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["network"]]
+  },
+  "backlog:drive": {
+    script: "scripts/backlog/backlog-drive-cli.ts",
+    description: "Drive backlogrun through offer, launch and merge; restore this run\u2019s lanes and report when complete",
+    category: "AI tools",
+    reference: ["--owner <pid> [options]", "automation", ["network"]]
+  },
+  "backlog:plan": {
+    script: "scripts/backlog/backlog-plan-cli.ts",
+    description: "Print the whole backlog as a plan: ready now, waiting on what, waiting on a person, out of scope",
+    category: "AI tools",
+    reference: ["[issue...] [--only]", "automation", ["network"]]
+  },
+  "backlog:stalled": {
+    script: "scripts/backlog/backlog-stalled-cli.ts",
+    description: "Report whether ready backlog work is sitting undispatched with a free lane and no recent dispatch",
+    category: "AI tools",
+    reference: ["", "automation", ["network"]]
+  },
+  "backlog:budget": {
+    script: "scripts/backlog/backlog-budget-cli.ts",
+    description: "Say whether a backlogrun may start more work, keep watching, or finish",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-document.ts
+var DOCUMENT_COMMANDS = {
+  "doc:section": {
+    script: "scripts/document/document-section-cli.ts",
+    description: 'Print one section of a markdown document, for a `file.md` \u2192 "Heading" reference',
+    category: "AI tools",
+    reference: ["<file> <heading>", "automation", ["none"]]
+  },
+  "read:set": {
+    script: "scripts/document/read-set-cli.ts",
+    description: "Print what an entry point reads before it starts, and what that read costs",
+    category: "AI tools",
+    reference: ["[<entry>] [--json]", "automation", ["none"]]
+  },
+  "doc:read": {
+    script: "scripts/document/document-read-cli.ts",
+    description: "Read a whole document safely: print it, or point at the Read tool when over the Bash cap",
+    category: "AI tools",
+    reference: ["<file>", "automation", ["none"]]
+  },
+  "read:files": {
+    script: "scripts/document/read-files-cli.ts",
+    description: "Read several files in one call so edit targets fold into one turn",
+    category: "AI tools",
+    reference: ["<path> [<path> ...]", "automation", ["none"]]
+  },
+  "edit:files": {
+    script: "scripts/document/edit-files-cli.ts",
+    description: "Apply several content-addressed edits from a plan in one call",
+    category: "AI tools",
+    reference: ["<plan-path | ->", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-guard.ts
+var GUARD_COMMANDS = {
+  "investigation:guard": {
+    script: "scripts/delegation/investigation-guard.ts",
+    description: "Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "duplicate-read:guard": {
+    script: "scripts/delegation/duplicate-read-guard.ts",
+    description: "Claude Code hook: refuse a second whole-file read of a path whose content has not changed since the run last read it (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "rule:guard": {
+    script: "scripts/rules/rule-guard.ts",
+    description: "Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-issue.ts
+var ISSUES_WITH_REPO = "<issue...> [--repo <owner/repo>]";
+var ISSUE_COMMANDS = {
+  "issue:read": {
+    script: "scripts/issue/issue-read-cli.ts",
+    description: "Print each issue's title, body and every comment on it, in one call",
+    category: "AI tools",
+    reference: ["<issue...>", "automation", ["network"]]
+  },
+  "issue:state": {
+    script: "scripts/issue/issue-state-cli.ts",
+    description: "Print each issue's state and labels, in the spelling the documents compare against",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  },
+  "issue:scout": {
+    script: "scripts/issue/issue-scout-cli.ts",
+    description: "Before filing: say whether an issue like this exists and which epic it belongs to",
+    category: "AI tools",
+    reference: ["<title> [--body <summary>]", "automation", ["network"]]
+  },
+  "defect:rate": {
+    script: "scripts/issue/defect-rate-cli.ts",
+    description: "Print the defect rate of merged work: defects filed per behavior change completed",
+    category: "AI tools",
+    reference: ["[--days <n>]", "automation", ["network"]]
+  },
+  "issue:fold": {
+    script: "scripts/issue/issue-fold-cli.ts",
+    description: "Before a second filing: say whether findings from this session fold into one issue",
+    category: "AI tools",
+    reference: ["<title>... [--not-separable] [--json]", "automation", ["none"]]
+  },
+  "issue:fold-existing": {
+    script: "scripts/issue/issue-fold-existing-cli.ts",
+    description: "Assess whether a complete draft can join an unstarted issue",
+    category: "AI tools",
+    reference: ["<assessment.json>", "automation", ["none"]]
+  },
+  "issue:cite": {
+    script: "scripts/issue/issue-cite-cli.ts",
+    description: "Print the paste-ready number-link citation line for each issue, in one call",
+    category: "AI tools",
+    reference: [ISSUES_WITH_REPO, "automation", ["network"]]
+  },
+  "issue:comment": {
+    script: "scripts/issue/issue-comment-cli.ts",
+    description: "Post one comment to an issue from a file, so no shell expands the body",
+    category: "AI tools",
+    reference: ["<issue> --body <text> | --body-file <path>", "automation", ["network"]]
+  }
+};
+
+// scripts/josh/josh-commands-lane.ts
+var LANE_SCRIPT = "scripts/lane/lane-cli.ts";
+var LANE_ARGUMENTS = { script: LANE_SCRIPT, tsx_arguments: OPTIONAL_ENV_FILE_FLAGS };
+var ISSUE_WITH_OPTIONS = "<issue> [options]";
+var LANE_COMMANDS = {
+  "lane:open": {
+    ...LANE_ARGUMENTS,
+    description: "Open a lane: a linked work tree with its own branch and its own port seed",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS, "automation", ["files", "git"]],
+    default_script_arguments: ["open"]
+  },
+  "lane:close": {
+    ...LANE_ARGUMENTS,
+    description: "Close a lane, leaving no work tree, branch or directory behind",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["files", "git"]],
+    default_script_arguments: ["close"]
+  },
+  "lane:list": {
+    ...LANE_ARGUMENTS,
+    description: "List the open lanes: which issue, which ports, and where each one is",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]],
+    default_script_arguments: ["list"]
+  },
+  "lane:prune": {
+    ...LANE_ARGUMENTS,
+    description: "Close every lane an interruption left without its work tree",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "git"]],
+    default_script_arguments: ["prune"]
+  },
+  "lane:output": {
+    ...LANE_ARGUMENTS,
+    description: "Record, or read back, where the unit running a lane\u2019s child writes",
+    category: "AI tools",
+    reference: ["<issue> [path]", "automation", ["files"]],
+    default_script_arguments: ["output"]
+  },
+  "lane:dispatch": {
+    ...LANE_ARGUMENTS,
+    description: "Start a lane\u2019s child as a detached process that outlives this session",
+    category: "AI tools",
+    reference: ["<issue> <prompt>", "automation", ["processes"]],
+    default_script_arguments: ["dispatch"]
+  },
+  "lane:await": {
+    ...LANE_ARGUMENTS,
+    description: "Block until any of the named in-flight lane children completes; prints which one finished",
+    category: "AI tools",
+    reference: ["<issue> [<issue>...]", "automation", ["processes"]],
+    default_script_arguments: ["await"]
+  },
+  "lane:launch": {
+    script: "scripts/lane/lane-launch-cli.ts",
+    description: "Collapse a backlogrun lane-start event into one call: open the lane, pop and re-install on the first, dispatch the child",
+    category: "AI tools",
+    reference: ["<issue> [--stash <message>]", "automation", ["files", "git", "processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-split.ts
+var SPLIT_COMMANDS = {
+  "split:assess": {
+    script: "scripts/split/split-assess-cli.ts",
+    description: "Measure the branch change size (tests excluded) and answer the split assessment size question: split | single",
+    category: "AI tools",
+    reference: ["[--json]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-ai.ts
+var RUN_HOLD_SCRIPT = "scripts/run/run-hold-cli.ts";
+var ISSUE_WITH_OPTIONS2 = "<issue> [options]";
+var AI_COMMANDS = {
+  ...ISSUE_COMMANDS,
+  "pkg:scout": {
+    script: "scripts/package/package-scout-cli.ts",
+    description: "Rank package candidates by measured metrics so the Package-First tier decision is read, not judged",
+    category: "AI tools",
+    reference: ["<keywords> [--size <n>]", "automation", ["network"]]
+  },
+  "stash:pop": {
+    script: "scripts/git/stash-pop-cli.ts",
+    description: "Pop the stash matching this message, not whichever a shared stack has on top",
+    category: "AI tools",
+    reference: ["<message>", "automation", ["git"]]
+  },
+  epic: {
+    script: "scripts-ai/epic.ts",
+    description: "Create an epic issue from its child issue numbers",
+    category: "AI tools",
+    reference: ["<title> <issue...> [--ordered]", "automation", ["network"]]
+  },
+  "epic:next": {
+    script: "scripts/epic/epic-next.ts",
+    description: "List an epic's runnable children, bundled per repository",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "epic:bundle": {
+    script: "scripts/epic/epic-bundle-cli.ts",
+    description: "Say whether a newly filed issue belongs with ones already in the backlog",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "epic:audit": {
+    script: "scripts/epic/epic-audit-cli.ts",
+    description: "Audit an epic's children against each other for contradictions",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "epic:check": {
+    script: "scripts-ai/epic-check.ts",
+    description: "Check an epic issue against the tracking requirements",
+    category: "AI tools",
+    reference: ["<epic>", "automation", ["network"]]
+  },
+  "auto-ok:next": {
+    script: "scripts/auto-ok/auto-ok-cli.ts",
+    description: "Print the next opted-in issue an unattended run may pick up outside an epic",
+    category: "AI tools",
+    reference: ["[--exclude <n>[,<n>...]] [--label <name>]", "automation", ["network"]]
+  },
+  ...BACKLOG_COMMANDS,
+  cost: {
+    script: "scripts/cost-runtime/cost-cli.ts",
+    description: "Report a run's token and credit cost from Claude Code's session transcripts",
+    category: "AI tools",
+    reference: ["[--cut|--over]", "automation", ["none"]]
+  },
+  ...DOCUMENT_COMMANDS,
+  time: {
+    script: "scripts/time/time-cli.ts",
+    description: "Report where a run's wall clock went: model wait, tool execution, human wait",
+    category: "AI tools",
+    reference: ["[options]", "maintainer", ["none"]],
+    // Kit-only: it measures kit's own development runs and its report modules live under the
+    // undistributed `scripts/time/`, so it means nothing in a consumer project and is dropped from a
+    // consumer's help (joshuafolkken/kit#1997). The runtime analysis hooks and guards rely on stays
+    // distributed under `scripts/time-runtime/`.
+    is_kit_only: true
+  },
+  // The tool-calls-per-round-trip density the batching guard is measured on, aggregated across the
+  // recent lane sessions (joshuafolkken/kit#2405). Kit-only for the same reason `time` is: it reads
+  // kit's own lane transcripts and means nothing in a consumer project.
+  "time:density": {
+    script: "scripts/time/time-density-cli.ts",
+    description: "Report tool calls per round trip across the recent lane sessions",
+    category: "AI tools",
+    reference: ["[--lanes <n>] [--path <dir>]", "maintainer", ["none"]],
+    is_kit_only: true
+  },
+  retrospective: {
+    script: "scripts/retrospective/retrospective-cli.ts",
+    description: "Aggregate a finished run's cost, review findings, observation ledger and events into one digest",
+    category: "AI tools",
+    reference: ["", "maintainer", ["none"]],
+    // Kit-only: it reads kit's own development run — the transcript store, the review ledger and the
+    // run event stream — so it means nothing in a consumer project and is dropped from a consumer's
+    // help (joshuafolkken/kit#2328), through the same declaration `josh time` uses for the same reason.
+    is_kit_only: true
+  },
+  "review:brief": {
+    script: "scripts/review/review-brief-cli.ts",
+    description: "Print the whole /code-review invocation: level, what the gate already proved, target (--level-only for the level alone)",
+    category: "AI tools",
+    reference: ["[--round <1|2>] | --level-only [--staged] [--json]", "automation", ["files"]]
+  },
+  "review:attest": {
+    script: "scripts/review/review-attest-cli.ts",
+    description: "Record, or verify, which checkout a /code-review actually read",
+    category: "AI tools",
+    reference: ["<nonce> | --check", "automation", ["files"]]
+  },
+  "review:round2": {
+    script: "scripts/review/review-round2-cli.ts",
+    description: "Say whether the second /code-review round is due, or may be skipped entirely",
+    category: "AI tools",
+    reference: ["[--round-1-closed] [--json]", "automation", ["none"]]
+  },
+  delegate: {
+    script: "scripts/delegation/delegation-cli.ts",
+    description: "Say whether a run step may go to a cheaper execution tier",
+    category: "AI tools",
+    reference: ["<step> | --list", "automation", ["none"]]
+  },
+  fanout: {
+    script: "scripts/delegation/fanout-cli.ts",
+    description: "Say whether proposed implementation units are file-disjoint, so they may run in parallel",
+    category: "AI tools",
+    reference: ["<unit-files> <unit-files> [<unit-files> \u2026]", "automation", ["none"]]
+  },
+  "run:hold": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Claim this working tree for a run, or say which run already holds it",
+    category: "AI tools",
+    reference: ["[issue]", "automation", ["files"]]
+  },
+  "run:release": {
+    script: RUN_HOLD_SCRIPT,
+    description: "Release this working tree's run record",
+    category: "AI tools",
+    reference: ["[issue|--force]", "automation", ["files"]],
+    default_script_arguments: ["--release"]
+  },
+  "run:carry": {
+    script: "scripts/run/run-carry-cli.ts",
+    description: "Carry one invocation\u2019s budget across its own session cuts",
+    category: "AI tools",
+    reference: ["<operation> [arguments...]", "automation", ["files"]]
+  },
+  "run:wake": {
+    script: "scripts/run/run-wake-cli.ts",
+    // `.env` rather than the ambient environment:
+    // the failure warning needs the Telegram credentials, the same
+    // reasons `notify` and `followup` carry these flags.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Wake the next session of a cut backlogrun from outside the conversation",
+    category: "AI tools",
+    reference: ["[options]", "automation", ["processes", "notifications"]]
+  },
+  "run:cut": {
+    script: "scripts/run/run-cut-cli.ts",
+    description: "Cut a lane child before the gate and resume a fresh process",
+    category: "AI tools",
+    reference: ["[--resume] <issue> [--impl] [--handoff <path>]", "automation", ["files"]]
+  },
+  "run:liveness": {
+    script: "scripts/run/run-liveness-cli.ts",
+    description: "Say whether a delegated unit is still working, or stopped without reporting",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [options]", "automation", ["processes"]]
+  },
+  "run:ending": {
+    script: "scripts/run/run-ending-cli.ts",
+    description: "Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)",
+    category: "AI tools",
+    reference: ["<issue> --output <path> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:progress": {
+    script: "scripts/run/run-progress-cli.ts",
+    description: "Report an unattended run\u2019s progress once it has gone quiet for an interval",
+    category: "AI tools",
+    reference: ["[--wait|--mark]", "automation", ["files"]]
+  },
+  "run:prep": {
+    script: "scripts/run/run-prep-cli.ts",
+    description: "Bundle a run\u2019s pre-edit reads: body, comments, state, dependency scope",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  // The entry sequence a lane opened on, folded into one call (joshuafolkken/kit#2372): claim the tree,
+  // read the budget, gather the issue reads and decide the pre-implementation step. `run:hold`,
+  // `cost --cut`, `run:prep` and `run:step` were four round trips re-billing a lane's full context each.
+  "run:entry": {
+    script: "scripts/run/run-entry-cli.ts",
+    description: "Open a run in one call: claim the tree, read the budget, bundle the reads, decide the pre-implementation step",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["git", "network", "files"]]
+  },
+  "run:status": {
+    script: "scripts/run/run-status-cli.ts",
+    description: "Bundle a run\u2019s read-only status: issue state, cost verdict, carry counters",
+    category: "AI tools",
+    reference: ["<issue> [--repo <owner/repo>]", "automation", ["network"]]
+  },
+  "run:next": {
+    script: "scripts/run/run-next-cli.ts",
+    description: "Print the next step a fullrun takes, computed from the run\u2019s state",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "run:step": {
+    script: "scripts/run/run-step-cli.ts",
+    description: "Print the run\u2019s next single action, computed from the event stream, carry record and issue state",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network", "files"]]
+  },
+  "repo:party": {
+    script: "scripts/discovery/repo-party-cli.ts",
+    description: "Say whether a repository is first-party or third-party by owner equality (computed, not judged)",
+    category: "AI tools",
+    reference: ["[<owner/repo>]", "automation", ["none"]]
+  },
+  "run:merge": {
+    script: "scripts/run/run-merge-cli.ts",
+    description: "Collapse a backlogrun merge event into one call: confirm the child, do the post-merge steps, offer the next child",
+    category: "AI tools",
+    reference: [ISSUE_WITH_OPTIONS2, "automation", ["git", "network"]]
+  },
+  "run:review": {
+    script: "scripts/run/run-review-cli.ts",
+    description: "Start the gate in the background and print the /code-review brief in one call so the two overlap (--join to join the gate and check its verdict)",
+    category: "AI tools",
+    reference: ["[--join]", "automation", ["processes", "files"]]
+  },
+  // The post-merge sequence a run closed on, folded into one call (joshuafolkken/kit#2372): commit the
+  // observation ledger, read the completion citations and decide the release scope. `observations:flush`,
+  // `issue:cite` and `release:scope` were three round trips re-billing the run's full context each.
+  "run:tail": {
+    script: "scripts/run/run-tail-cli.ts",
+    description: "Close a run in one call: commit the observation ledger, read the citations, decide the release scope",
+    category: "AI tools",
+    reference: ["[<issue> ...]", "automation", ["git", "network"]]
+  },
+  // The commit-to-report region a run ships a change on, folded into one call (joshuafolkken/kit#2398):
+  // the gate, the commit/push/PR (`git -y`), the CI-wait merge (`followup`) and the report bookkeeping
+  // (`run:tail`) were four round trips re-billing the run's full context each. It stops at the first
+  // failed step and names it, so the run reads only the step to fix.
+  ship: {
+    script: "scripts/run/run-ship-cli.ts",
+    description: "Ship a change in one call: gate, commit/push/PR, the CI-wait merge and the report bookkeeping, stopping at the first failed step",
+    category: "AI tools",
+    reference: [
+      '"<title> #<N>" [<follow-up-N> ...] [--cite <N>] [--review] [--detach] [--notify-message <text> | --notify-message-file <path>] | --log <N>',
+      "automation",
+      ["git", "network"]
+    ]
+  },
+  "run:event": {
+    script: "scripts/run/run-event-cli.ts",
+    description: "Append to, read or watch the run\u2019s append-only event stream (--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last)",
+    category: "AI tools",
+    reference: [
+      "--append <kind> <text> | --from|--follow <n> | --watch [<n>] | --last",
+      "automation",
+      ["files"]
+    ]
+  },
+  "run:report": {
+    script: "scripts/run/run-report-cli.ts",
+    description: "Generate the session-facing report for this invocation from the run\u2019s event stream (merges, parks, cuts) with the release tail \u2014 the same text josh notify sends",
+    category: "AI tools",
+    reference: ["", "automation", ["files", "network"]]
+  },
+  ...LANE_COMMANDS,
+  ...GUARD_COMMANDS,
+  "run:watcher:guard": {
+    script: "scripts/run/run-watcher-guard-cli.ts",
+    description: "Guard: exits non-zero when lane children are in-flight but the watcher has not pinged recently",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  "run:stranded": {
+    script: "scripts/run/run-stranded-cli.ts",
+    // `.env` rather than the ambient environment: the strand notification needs the Telegram
+    // credentials, the same reason `run:wake` carries these flags.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+    description: "Report whether the run is stranded \u2014 budget handed off, owner gone, and no supervisor watching",
+    category: "AI tools",
+    reference: ["", "automation", ["processes", "notifications"]]
+  },
+  ...SPLIT_COMMANDS,
+  "oracle:list": {
+    script: "scripts/rules/oracle-list-cli.ts",
+    description: "Print the decision oracles \u2014 commands that answer a rule question mechanically",
+    category: "AI tools",
+    reference: ["", "automation", ["none"]]
+  },
+  eval: {
+    script: "scripts/eval/eval-run.ts",
+    description: "Run the agent rule-compliance scenarios (real Claude sessions)",
+    category: "AI tools",
+    reference: ["[scenario...]", "maintainer", ["processes", "network"]],
+    // Kit-only: it replays kit's own distributed rules against real Claude sessions, so it means
+    // nothing in a consumer project and is dropped from a consumer's help (joshuafolkken/kit#1988).
+    is_kit_only: true
+  }
+};
+
+// scripts/josh/josh-commands-clone.ts
+var CLONE_COMMANDS = {
+  "clone:scan": {
+    script: "scripts/clone/clone-scan-cli.ts",
+    description: "Count code duplication across files and first-party repositories, printing each clone as file:line pairs",
+    category: "AI tools",
+    reference: ["", "automation", ["files"]]
+  }
+};
+
+// scripts/josh/josh-commands-development.ts
+var FILE_ARGUMENTS = "[files...]";
+var REQUIRED_FILE_ARGUMENTS = "<files...>";
+var FILTER_ARGUMENTS = "[filters...]";
+var MATCH_ARGUMENTS = "[--match]";
+var PATH_ARGUMENTS = "<path...>";
+var DEV_COMMANDS = {
+  [GATE_COMMAND]: {
+    script: "scripts/gate/verification-gate.ts",
+    description: "Run lint, type check, spell check and unit tests concurrently",
+    category: "Development",
+    reference: ["[--verbose|--force|--no-unit]", "developer", ["files", "processes"]]
+  },
+  lint: {
+    script: "scripts/lint/lint-parallel.ts",
+    description: "Check code with prettier and eslint",
+    category: "Development",
+    reference: ["", "developer", ["processes"]]
+  },
+  "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"]]
+  },
+  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"]]
+  },
+  "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"]]
+  },
+  bytes: {
+    script: "scripts/bytes/bytes-command.ts",
+    description: "Print an agent-read document's byte size against its ceiling and the headroom left",
+    category: "Development",
+    reference: [REQUIRED_FILE_ARGUMENTS, "developer", ["none"]]
+  },
+  "rule:value": {
+    script: "scripts/rules/rule-value-cli.ts",
+    description: "Print each delivered rule's unaided compliance \u2014 runs reached, kept rate, refusals",
+    category: "AI tools",
+    reference: ["", "developer", ["none"]]
+  },
+  format: {
+    // prettier first here, unlike `format:edited`, and deliberately: `eslint --fix` exits 1
+    // whenever a non-autofixable error remains, so putting it first behind `&&` would mean one
+    // unused variable anywhere in the tree stops prettier from running at all.
+    shell: [
+      "sh",
+      "-c",
+      `pnpm exec prettier --write . && pnpm exec eslint . --fix ${ESLINT_CACHE_FLAGS.join(" ")}`
+    ],
+    description: "Format code with prettier and eslint",
+    category: "Development",
+    reference: ["", "developer", ["files", "processes"]]
+  },
+  "format:edited": {
+    script: "scripts/hooks/format-edited-file.ts",
+    description: "Claude Code hook: format the file just edited (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["files", "processes"]]
+  },
+  "batch:guard": {
+    script: "scripts/hooks/batch-guard.ts",
+    description: "Claude Code hook: refuse a third consecutive single-call turn (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately.** `JOSH_BATCH_GUARD` is a per-machine preference kept in
+    // `.env`, which every other command reads through `OPTIONAL_ENV_FILE_FLAGS` — but declaring any
+    // `tsx_arguments` disqualifies a command from in-process dispatch (`josh-in-process.ts`), and
+    // this one runs before every `Bash` call. That is the hot path joshuafolkken/kit#1342 took a
+    // second ~0.16 s tsx start off. The script calls `process.loadEnvFile` itself instead, which is
+    // node's own `--env-file` parser with node's own precedence.
+  },
+  "pretool:guard": {
+    script: "scripts/hooks/pretool-guard.ts",
+    description: "Claude Code hook: the batch, investigation and rule guards in one process (reads the tool call on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this is the one
+    // PreToolUse hook consumers run before every guarded call, so it must stay eligible for
+    // in-process dispatch rather than pay a second tsx start. Each guard it composes loads `.env`
+    // through the shared loader.
+  },
+  "stop:guard": {
+    script: "scripts/hooks/stop-guard.ts",
+    description: "Claude Code Stop hook: deliver the three stop-time rules \u2014 hold notify/release and issue citation (reads the Stop payload on stdin)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `pretool:guard` above: this runs at every
+    // turn end, so it must stay eligible for in-process dispatch rather than pay a second tsx start.
+    // It loads `.env` through the shared `hook-decision.ts` loader.
+  },
+  "session:lang": {
+    script: "scripts/josh/session-language-cli.ts",
+    description: "Claude Code hook: print the resolved JOSH_SESSION_LANG (defaults to ja) for the session context",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+    // **No `tsx_arguments`, deliberately**, the same as `batch:guard` above: this runs on every
+    // `UserPromptSubmit`, so it must stay eligible for in-process dispatch rather than pay a second
+    // tsx start each turn. It calls `process.loadEnvFile` itself through the shared loader.
+  },
+  "cspell:dot": {
+    script: "scripts/lint/cspell-cached.ts",
+    description: "Run spell check including dotfiles",
+    category: "Development",
+    reference: ["", "developer", ["processes"]]
+  },
+  behavior: {
+    script: "scripts/behavior/behavior-cli.ts",
+    description: "Check the current run's recorded transcript against the behavior assertions (no model call)",
+    category: "Development",
+    reference: ["", "developer", ["files"]]
+  },
+  "test:unit": {
+    script: "scripts/test/test-unit-guard.ts",
+    description: "Run unit tests with Vitest (skips when Vitest is absent; fails when it has no tests)",
+    category: "Development",
+    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
+  },
+  "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"]]
+  },
+  "test:declared": {
+    script: "scripts/test/test-declared.ts",
+    description: "Report whether the working-tree change needs a test (required/exempt/satisfied); --match checks Step 0 declarations on stdin",
+    category: "Development",
+    reference: [MATCH_ARGUMENTS, "developer", ["processes"]]
+  },
+  "test:red": {
+    script: "scripts/test/test-red.ts",
+    description: "Run the changed unit tests against the pre-fix tree (merge-base worktree) and report red/green/no-test",
+    category: "Development",
+    reference: ["", "developer", ["git", "processes"]]
+  },
+  disposition: {
+    script: "scripts/review/disposition-cli.ts",
+    description: "Say whether a review finding reaches a runtime path (runtime) or is inert (non-runtime)",
+    category: "AI tools",
+    reference: [PATH_ARGUMENTS, "automation", ["none"]]
+  },
+  "e2e:retry-check": {
+    script: "scripts/test/e2e-retry-check.ts",
+    description: "Report whether the preview server crashed during a failed E2E attempt (CI)",
+    category: "Development",
+    reference: ["", "automation", ["none"]]
+  },
+  "test:e2e": {
+    script: "scripts/test/test-e2e-guard.ts",
+    description: "Run E2E tests with Playwright (skips when absent or no e2e files)",
+    category: "Development",
+    reference: [FILTER_ARGUMENTS, "developer", ["processes"]]
+  },
+  test: {
+    shell: ["sh", "-c", "pnpm josh test:unit && pnpm josh test:e2e"],
+    description: "Run unit and E2E tests",
+    category: "Development",
+    reference: ["", "developer", ["processes"]],
+    argument_targets: ["test:unit", "test:e2e"]
+  },
+  check: {
+    shell: [...PE, "tsc", "--noEmit", ...TS_CACHE_FLAGS],
+    description: "Type-check TypeScript project",
+    category: "Development",
+    reference: ["[arguments...]", "developer", ["processes"]]
+  },
+  port: {
+    script: "scripts/ports/port-command.ts",
+    description: "Print the PORT_SEED-resolved dev or preview port",
+    category: "Development",
+    reference: ["<dev|preview>", "developer", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-hooks.ts
+var HOOKS_COMMANDS = {
+  "prevent-main-commit": {
+    script: "scripts/hooks/prevent-main-commit.ts",
+    description: "Git hook: block commits to main",
+    category: "Git hooks",
+    reference: ["", "automation", ["none"]]
+  },
+  "check-commit-message": {
+    script: "scripts/hooks/check-commit-message.ts",
+    description: "Git hook: validate commit message",
+    category: "Git hooks",
+    reference: ["[<message-file>]", "automation", ["none"]]
+  },
+  "secretlint-scan": {
+    script: "scripts/security/secretlint-scan.ts",
+    description: "Git hook: scan staged files for secrets",
+    category: "Git hooks",
+    reference: ["[paths...]", "automation", ["none"]]
+  },
+  "pre-push-unit": {
+    script: "scripts/hooks/pre-push-unit.ts",
+    description: "Git hook: run unit tests, reusing a green gate recorded on the pushed tree",
+    category: "Git hooks",
+    reference: ["", "automation", ["processes"]]
+  },
+  "reserved-run": {
+    script: "scripts/hooks/reserved-run.ts",
+    description: "Git hook: run a command while holding a place in the machine-wide core budget",
+    category: "Git hooks",
+    reference: ["<weight> -- <command...>", "automation", ["processes"]]
+  },
+  "pre-commit-type-check": {
+    script: "scripts/gate/pre-commit-type-check.ts",
+    description: "Git hook: type-check, reusing a green gate recorded on the committed tree",
+    category: "Git hooks",
+    reference: ["", "automation", ["processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-lint.ts
+var LINT_COMMANDS = {
+  "issue:lint": {
+    script: "scripts/issue/issue-lint-cli.ts",
+    description: "Check an issue body file for the template's required headings",
+    category: "AI tools",
+    reference: ["<path>", "automation", ["files"]]
+  },
+  "issue:backlinks": {
+    script: "scripts/issue/issue-backlinks-cli.ts",
+    description: "Classify an origin issue\u2019s upstream backlinks: ok, missing, or wrong heading",
+    category: "AI tools",
+    reference: ["<issue>", "automation", ["network"]]
+  },
+  "report:lint": {
+    script: "scripts/report/report-lint-cli.ts",
+    description: "Check a two-layer work summary on stdin against its mechanical format rules",
+    category: "AI tools",
+    reference: ["(reads stdin)", "automation", ["none"]]
+  },
+  cases: {
+    script: "scripts/cases/cases-cli.ts",
+    description: "Read changed paths and print the I/O boundaries crossed and their mandatory abnormal cases: network | process | fs | none",
+    category: "AI tools",
+    reference: ["<path...>", "automation", ["files"]]
+  }
+};
+
+// scripts/josh/josh-commands-maintenance.ts
+var MAINTENANCE_COMMANDS = {
+  doctor: {
+    script: "scripts/doctor/doctor.ts",
+    description: "Diagnose PATH shadowing of the global josh and show the discovered repository map (--fix reclaims a stale shim)",
+    category: "Maintenance",
+    reference: ["[--fix]", "developer", ["files"]],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  overrides: {
+    script: "scripts/overrides/overrides-check.ts",
+    description: "Check pnpm overrides for drift",
+    category: "Maintenance",
+    reference: ["[--save]", "maintainer", ["files"]]
+  },
+  audit: {
+    script: "scripts/security/security-audit.ts",
+    description: "Run security audit",
+    category: "Maintenance",
+    reference: ["", "developer", ["processes"]]
+  },
+  "audit:provision": {
+    script: "scripts/security/security-audit-provision.ts",
+    description: "Install the pinned osv-scanner when the audit cannot find one (no-op if present)",
+    category: "Maintenance",
+    reference: ["", "automation", ["files", "network"]]
+  },
+  "reconcile-templates": {
+    script: "scripts/sync/reconcile-templates.ts",
+    description: "Record template source hashes (--check to verify drift)",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files"]]
+  },
+  latest: {
+    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"
+    ],
+    description: "Update pnpm, dependencies, and run security audit",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network", "processes"]],
+    argument_targets: ["latest:corepack", "latest:update", "audit"]
+  },
+  "latest:scope": {
+    script: "scripts/version/latest-scope-cli.ts",
+    description: "Say whether this run has to update dependencies, from when josh latest last finished (--record notes a run)",
+    category: "Maintenance",
+    reference: ["[--record] [--json]", "automation", ["files"]],
+    // `JOSH_LATEST_MAX_AGE_HOURS` is documented as a project setting, so it has to be readable
+    // where the project keeps its settings — a variable that only works when exported from the
+    // shell is one a user follows the documentation for and gets the default from, silently.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  "latest:guard": {
+    script: "scripts/version/latest-lane-guard.ts",
+    description: "Refuse josh latest inside a lane (the update stamp is keyed to the project root)",
+    category: "Maintenance",
+    reference: ["", "automation", ["files"]]
+  },
+  "latest:corepack": {
+    script: "scripts/version/latest-corepack.ts",
+    description: "Update pnpm on the current major while preserving the integrity pin",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network"]]
+  },
+  "latest:update": {
+    script: "scripts/version/latest-update.ts",
+    description: "Update all dependencies to latest",
+    category: "Maintenance",
+    reference: ["", "maintainer", ["files", "network"]]
+  }
+};
+
+// scripts/josh/josh-commands-project.ts
+var PROJECT_COMMANDS = {
+  init: {
+    script: "scripts/init/init.ts",
+    description: "Initialize config in a new project",
+    category: "Project",
+    reference: ["", "developer", ["files", "processes"]]
+  },
+  sync: {
+    script: "scripts/sync/sync.ts",
+    description: "Sync config files",
+    category: "Project",
+    reference: ["", "developer", ["files"]]
+  },
+  "sync:scope": {
+    script: "scripts/sync/managed-config-scope-cli.ts",
+    description: "Say whether this change touches a file josh sync distributes",
+    category: "Project",
+    reference: ["[--staged] [--json]", "automation", ["none"]]
+  },
+  "sonar:hotspots": {
+    script: "scripts/sonar/sonar-hotspots-cli.ts",
+    description: "Fetch SonarCloud hotspots on a pull request and print each one's Step B disposition",
+    category: "Project",
+    reference: ["<PR>", "automation", ["network"]]
+  },
+  "ui:routes": {
+    script: "scripts/ui/ui-routes-cli.ts",
+    description: "List the screenshot-target routes the current change touches",
+    category: "Project",
+    reference: ["[--staged]", "automation", ["none"]]
+  },
+  propagate: {
+    script: "scripts/propagate/propagate.ts",
+    description: "Carry the published release into every consumer repository next to this one",
+    category: "Project",
+    reference: ["[--dry-run] [--skip-publish-wait]", "maintainer", ["files", "network"]]
+  },
+  adopt: {
+    script: "scripts/adopt/adopt.ts",
+    description: "Upgrade every installed @joshuafolkken toolkit here and open the pull request",
+    category: "Project",
+    reference: ["[--dry-run]", "developer", ["files", "git", "network", "processes"]]
+  }
+};
+
+// scripts/josh/josh-commands-versioning.ts
+var VERSIONING_COMMANDS = {
+  bump: {
+    script: "scripts/version/bump-version.ts",
+    description: "Bump package version",
+    category: "Versioning",
+    reference: ["[major|minor|patch]", "maintainer", ["files"]]
+  },
+  version: {
+    script: "scripts/version/version-check.ts",
+    description: "Show kit versions; --upgrade updates the global and project install",
+    category: "Versioning",
+    reference: ["[--upgrade]", "developer", ["files", "network", "processes"]]
+  },
+  // A `script` entry, not a shell one: script paths resolve against the kit package root, so this
+  // keeps working from a consumer repo where the file lives under node_modules. The registry
+  // probes need NODE_AUTH_TOKEN for any `@joshuafolkken/*` dependency; `josh latest` exports it
+  // before chaining here, exactly as it already does for `latest:update`.
+  ranges: {
+    script: "scripts/version/publishable-range-check.ts",
+    description: "Check that every published dependency range still resolves for a consumer",
+    category: "Versioning",
+    reference: ["", "developer", ["network"]]
+  },
+  // The one place that decides a version (joshuafolkken/kit#1169). A `script` entry for the same
+  // reason `ranges` is one: script paths resolve against the kit package root, so it keeps working
+  // from a consumer repository where the file lives under node_modules.
+  release: {
+    script: "scripts/release/release-cli.ts",
+    description: "Release the merges main has taken since the version last changed",
+    category: "Versioning",
+    reference: ["[version]", "maintainer", ["git", "network", "release"]]
+  },
+  // The read-only half of the one above (joshuafolkken/kit#1582). `release --dry-run` cannot
+  // answer this question: it refuses off the default branch and on a dirty tree, which is every
+  // position a run asks it from. A `script` entry for the same reason `release` is one.
+  "release:scope": {
+    script: "scripts/release/release-scope-cli.ts",
+    description: "Say whether a release is owed, from the unreleased merges on main",
+    category: "Versioning",
+    reference: ["[--json]", "automation", ["none"]]
+  }
+};
+
+// scripts/josh/josh-commands-workflow.ts
+var GIT_WORKFLOW_SCRIPT = "scripts-ai/git-workflow.ts";
+var GIT_MESSAGE_ARGUMENTS = "[-y] <message>";
+var WORKFLOW_COMMANDS = {
+  git: {
+    script: GIT_WORKFLOW_SCRIPT,
+    description: "Git workflow helper",
+    category: "Workflow",
+    reference: [GIT_MESSAGE_ARGUMENTS, "developer", ["git", "network"]]
+  },
+  pr: {
+    script: GIT_WORKFLOW_SCRIPT,
+    description: "Create PR only (skip commit and push)",
+    category: "Workflow",
+    // Not `GIT_MESSAGE_ARGUMENTS`: `-y` is already in the default arguments below, so advertising
+    // it would document a flag that cannot change what this command does.
+    reference: ["<message>", "developer", ["network"]],
+    default_script_arguments: ["-y", "--skip-commit", "--skip-push"]
+  },
+  // **The optional form, on both** (joshuafolkken/kit#1564). These two were the last commands
+  // passing the mandatory `--env-file=.env`, which node resolves before the script's first line: on
+  // a machine with no `.env` they died as `.env: not found` with exit code 9, even where
+  // `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` existed as real environment variables — a cloud
+  // session, and `followup` with them the merge step of every `fullrun` there. `doctor` was moved to
+  // this form for the same reason in joshuafolkken/kit#869.
+  //
+  // Nothing is lost by relaxing it: both scripts already call `load_optional_environment()`
+  // themselves, so the file is read either way and node's precedence — an existing environment
+  // variable wins over the file — is node's own in both spellings.
+  //
+  // **What the mandatory flag was accidentally providing was noise**, and that is replaced rather
+  // than dropped: `telegram_notify.send` now throws on missing credentials and on a failed send, so
+  // `josh notify` exits non-zero instead of warning and answering 0.
+  followup: {
+    script: "scripts-ai/git-followup-workflow.ts",
+    description: "Follow-up git workflow",
+    category: "Workflow",
+    reference: [
+      "<title> [--notify-message <text>]",
+      "automation",
+      ["git", "network", "notifications"]
+    ],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  notify: {
+    script: "scripts-ai/telegram-test.ts",
+    description: "Send Telegram notification",
+    category: "Workflow",
+    reference: ["--task-type <type> --body <text>", "automation", ["notifications"]],
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
+  },
+  // The observation ledger's only commit path (joshuafolkken/kit#1756). `pnpm josh git` excludes the
+  // ledger from what it stages, so without this command a parent's appended line has no route to the
+  // default branch at all — and the recurrence count the promotion rule reads is a count of main.
+  "observations:flush": {
+    script: "scripts/observations/observations-flush-cli.ts",
+    description: "Commit the observation ledger as a pull request of its own, and merge it",
+    category: "Workflow",
+    reference: ["", "automation", ["git", "network"]]
+  },
+  // The one write path for a `/code-review` round's findings (joshuafolkken/kit#2325), plus the
+  // `--check` gate `followup` runs before it merges (joshuafolkken/kit#2343). It appends a `- rf:`
+  // line per finding — or one zero-finding line for a clean round — to the observation ledger, so
+  // `observations:flush` commits them and the recurrence count survives the run.
+  "review:record": {
+    script: "scripts/review/review-record-cli.ts",
+    description: "Record a review round\u2019s findings, or check a round was recorded",
+    category: "Workflow",
+    reference: [
+      "--issue <N> [<category>:<severity>:<file> ...] | --check --issue <N>",
+      "automation",
+      ["files"]
+    ]
+  },
+  // The reader over what `review:record` wrote (joshuafolkken/kit#2325): each recurring category’s
+  // count, and the number of zero-finding rounds that distinguishes a quiet category from an unwatched one.
+  "review:findings": {
+    script: "scripts/review/review-findings-cli.ts",
+    description: "Count review findings by category from the observation ledger",
+    category: "Workflow",
+    reference: ["", "developer", ["files"]]
+  },
+  // After a behavior-change Issue merges, re-run its declared baseline and print before/after; a value
+  // that did not move appends a refuted-premise line to the observation ledger (joshuafolkken/kit#2212).
+  "measure:rerun": {
+    script: "scripts/issue/measure-rerun-cli.ts",
+    description: "Re-run a merged issue\u2019s baseline command and print the before/after pair",
+    category: "Workflow",
+    reference: ["<path>", "automation", ["processes", "files"]]
+  },
+  // A script rather than an `sh -c` chain, because it has a precondition to enforce: run inside a
+  // linked work tree it would hijack the default branch from every other one (joshuafolkken/kit#1535).
+  "main:sync": {
+    script: "scripts/git/main-sync.ts",
+    description: "Checkout default branch, pull latest, and prune merged remote-gone branches (refuses inside a lane)",
+    category: "Workflow",
+    reference: ["", "developer", ["git", "network"]]
+  },
+  // A script rather than an `sh -c` chain, because the strategy has to be named rather than left to
+  // the caller's git configuration: the `git pull` this replaced aborted with `Need to specify how
+  // to reconcile divergent branches` on exactly the diverged branch the command exists for
+  // (joshuafolkken/kit#1659).
+  "main:merge": {
+    script: "scripts/git/main-merge.ts",
+    description: "Merge origin default branch into the current branch",
+    category: "Workflow",
+    reference: ["", "developer", ["git", "network"]]
+  }
+};
+
+// scripts/josh/josh-command-map.ts
+var CATEGORY_ORDER = [
+  "Development",
+  "Project",
+  "Workflow",
+  "Versioning",
+  "Maintenance",
+  "Git hooks",
+  "AI tools"
+];
+var COMMAND_MAP = {
+  ...DEV_COMMANDS,
+  ...PROJECT_COMMANDS,
+  ...WORKFLOW_COMMANDS,
+  ...VERSIONING_COMMANDS,
+  ...MAINTENANCE_COMMANDS,
+  ...HOOKS_COMMANDS,
+  ...AI_COMMANDS,
+  ...LINT_COMMANDS,
+  ...CLONE_COMMANDS
+};
+var ALIASES = {
+  ga: "gate",
+  l: "lint",
+  lr: "lint:related",
+  ln: "lines",
+  by: "bytes",
+  f: "format",
+  fd: "format:edited",
+  bg: "batch:guard",
+  sd: "cspell:dot",
+  bh: "behavior",
+  t: "test",
+  tu: "test:unit",
+  tr: "test:related",
+  td: "test:declared",
+  trd: "test:red",
+  te: "test:e2e",
+  er: "e2e:retry-check",
+  sl: "session:lang",
+  c: "check",
+  pt: "port",
+  i: "init",
+  sy: "sync",
+  sys: "sync:scope",
+  g: "git",
+  gp: "pr",
+  fu: "followup",
+  nf: "notify",
+  obf: "observations:flush",
+  mrr: "measure:rerun",
+  ms: "main:sync",
+  mm: "main:merge",
+  bp: "bump",
+  re: "release",
+  res: "release:scope",
+  v: "version",
+  r: "ranges",
+  dr: "doctor",
+  pg: "propagate",
+  ad: "adopt",
+  ov: "overrides",
+  a: "audit",
+  ap: "audit:provision",
+  rt: "reconcile-templates",
+  u: "latest",
+  lg: "latest:guard",
+  lc: "latest:corepack",
+  lu: "latest:update",
+  ls: "latest:scope",
+  pm: "prevent-main-commit",
+  cm: "check-commit-message",
+  ss: "secretlint-scan",
+  ppu: "pre-push-unit",
+  rer: "reserved-run",
+  ptc: "pre-commit-type-check",
+  ird: "issue:read",
+  ist: "issue:state",
+  isc: "issue:scout",
+  isf: "issue:fold",
+  isfe: "issue:fold-existing",
+  dfr: "defect:rate",
+  ici: "issue:cite",
+  icm: "issue:comment",
+  pks: "pkg:scout",
+  iln: "issue:lint",
+  ibl: "issue:backlinks",
+  rl: "report:lint",
+  ep: "epic",
+  ec: "epic:check",
+  en: "epic:next",
+  ea: "epic:audit",
+  eb: "epic:bundle",
+  ao: "auto-ok:next",
+  bl: "backlog:next",
+  blo: "backlog:offer",
+  bld: "backlog:drive",
+  blp: "backlog:plan",
+  bls: "backlog:stalled",
+  bb: "backlog:budget",
+  co: "cost",
+  ds: "doc:section",
+  rs: "read:set",
+  dcr: "doc:read",
+  rf: "read:files",
+  ef: "edit:files",
+  rfs: "refactor:scan",
+  tm: "time",
+  tmd: "time:density",
+  rtr: "retrospective",
+  rb: "review:brief",
+  r2: "review:round2",
+  ra: "review:attest",
+  rvr: "review:record",
+  rvf: "review:findings",
+  dp: "disposition",
+  dg: "delegate",
+  fo: "fanout",
+  rh: "run:hold",
+  rr: "run:release",
+  rc: "run:carry",
+  rw: "run:wake",
+  rct: "run:cut",
+  rv: "run:liveness",
+  red: "run:ending",
+  rg: "run:progress",
+  rp: "run:prep",
+  ren: "run:entry",
+  rtl: "run:tail",
+  shp: "ship",
+  rst: "run:status",
+  rn: "run:next",
+  rsp: "run:step",
+  rpy: "repo:party",
+  rmg: "run:merge",
+  rrp: "run:report",
+  rrv: "run:review",
+  rev: "run:event",
+  sp: "stash:pop",
+  lno: "lane:open",
+  lnc: "lane:close",
+  lnl: "lane:list",
+  lnp: "lane:prune",
+  lnv: "lane:output",
+  lnd: "lane:dispatch",
+  lna: "lane:await",
+  lnla: "lane:launch",
+  rwg: "run:watcher:guard",
+  rsd: "run:stranded",
+  ig: "investigation:guard",
+  drg: "duplicate-read:guard",
+  rug: "rule:guard",
+  ruv: "rule:value",
+  ptg: "pretool:guard",
+  sg: "stop:guard",
+  ev: "eval",
+  ol: "oracle:list",
+  sa: "split:assess",
+  shs: "sonar:hotspots",
+  uir: "ui:routes",
+  cs: "clone:scan",
+  ca: "cases"
+};
+
+// scripts/josh/josh-composite-arguments.ts
+var SHELL_INTERPRETERS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash"]);
+var SHELL_COMMAND_FLAG = "-c";
+var PATH_SEPARATOR = "/";
+var USAGE_ERROR_EXIT_CODE = 1;
+function is_shell_interpreter(executable) {
+  return SHELL_INTERPRETERS.has(executable.split(PATH_SEPARATOR).at(-1) ?? executable);
+}
+function is_composite_shell(shell) {
+  const [executable, flag] = shell ?? [];
+  if (executable === void 0) return false;
+  return is_shell_interpreter(executable) && flag === SHELL_COMMAND_FLAG;
+}
+function format_targets(targets) {
+  return targets.map((target) => `josh ${target}`).join(" or ");
+}
+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 ?? []);
+}
+var composite_arguments = { format_rejection, is_composite_shell, reject_extra_arguments };
+
+// scripts/josh/josh-in-process.ts
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+var TYPESCRIPT_EXTENSION = ".ts";
+var FAILURE_EXIT_CODE = 1;
+function is_typescript_dispatcher(dispatcher_url) {
+  return dispatcher_url.endsWith(TYPESCRIPT_EXTENSION);
+}
+function can_run_in_process(entry, dispatcher_url) {
+  if (entry.script === void 0 || entry.tsx_arguments !== void 0) return false;
+  return is_typescript_dispatcher(dispatcher_url);
+}
+function read_exit_code() {
+  const code = process.exitCode;
+  return typeof code === "number" ? code : 0;
+}
+function resolve_real_path(script_path) {
+  try {
+    return realpathSync(script_path);
+  } catch {
+    return script_path;
+  }
+}
+async function run_in_process(script_path, script_arguments) {
+  const resolved_path = resolve_real_path(script_path);
+  process.argv = [process.execPath, resolved_path, ...script_arguments];
+  try {
+    await import(pathToFileURL(resolved_path).href);
+  } catch (error) {
+    console.error(error);
+    return FAILURE_EXIT_CODE;
+  }
+  return read_exit_code();
+}
+var josh_in_process = { can_run_in_process, run_in_process };
+
+// scripts/josh/kit-only.ts
+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 kit_only_command_names() {
+  return Object.entries(COMMAND_MAP).filter(([, entry]) => is_kit_only(entry)).map(([name]) => name);
+}
+var kit_only = {
+  is_kit_only,
+  command_names: kit_only_command_names,
+  notice: kit_only_notice
+};
+
+// scripts/josh/josh-logic.ts
+var COLUMN_WIDTH = 26;
+var ALIAS_PAD_WIDTH = 2;
+var TSX_BIN = "tsx";
+var TSX_PACKAGE = "tsx";
+var PACKAGE_JSON2 = "package.json";
+var UNKNOWN_COMMAND_EXIT_CODE = -1;
+function find_package_directory(start_directory) {
+  let current = start_directory;
+  while (!existsSync3(path3.join(current, PACKAGE_JSON2))) {
+    const parent = path3.dirname(current);
+    if (parent === current) return start_directory;
+    current = parent;
+  }
+  return current;
+}
+var PACKAGE_DIR = find_package_directory(path3.dirname(fileURLToPath(import.meta.url)));
+function resolve_tsx_executable() {
+  const candidates = [
+    resolve_local_bin(PACKAGE_DIR, TSX_BIN),
+    resolve_local_bin(process.cwd(), TSX_BIN)
+  ];
+  return candidates.find(existsSync3) ?? TSX_BIN;
+}
+function resolve_tsx_cli_entry() {
+  for (const base_directory of [PACKAGE_DIR, process.cwd()]) {
+    const cli_entry = resolve_package_bin(base_directory, TSX_PACKAGE, TSX_BIN);
+    if (cli_entry !== void 0) return cli_entry;
+  }
+  return void 0;
+}
+function resolve_tsx_runner() {
+  const cli_entry = resolve_tsx_cli_entry();
+  if (cli_entry !== void 0) {
+    return { executable: process.execPath, leading_arguments: [cli_entry] };
+  }
+  return { executable: resolve_tsx_executable(), leading_arguments: [] };
+}
+function read_package_version() {
+  const raw = readFileSync3(path3.join(PACKAGE_DIR, PACKAGE_JSON2), "utf8");
+  return package_version_schema.parse(JSON.parse(raw)).version;
+}
+var HEADER = `josh v${read_package_version()} \u2014 Joshua Folkken's dev toolkit`;
+var USAGE = "Usage: josh <command> [options]";
+var ALL_HINT = "Run 'josh --all' to list every available command.";
+function build_alias_lookup() {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const [alias, cmd] of Object.entries(ALIASES)) lookup.set(cmd, alias);
+  return lookup;
+}
+function resolve_alias(cmd) {
+  return Object.hasOwn(ALIASES, cmd) ? ALIASES[cmd] ?? cmd : cmd;
+}
+function format_command_line(cmd, entry, alias) {
+  const prefix = alias ? `${alias}, `.padEnd(ALIAS_PAD_WIDTH + ALIAS_PAD_WIDTH) : "";
+  return `  ${(prefix + cmd).padEnd(COLUMN_WIDTH)}${entry.description}`;
+}
+function format_category_section(category, entries, alias_lookup) {
+  const lines = entries.map(
+    ([cmd, entry]) => format_command_line(cmd, entry, 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 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]);
+    }
+  }
+  return by_category;
+}
+function format_help(is_all = false, is_consumer = false) {
+  const by_category = collect_visible(is_all, is_consumer);
+  const alias_lookup = build_alias_lookup();
+  const sections = CATEGORY_ORDER.map((cat) => [cat, by_category.get(cat) ?? []]).filter(([, entries]) => entries.length > 0).map(([cat, entries]) => format_category_section(cat, entries, alias_lookup));
+  const footer = is_all ? USAGE : `${USAGE}
+${ALL_HINT}`;
+  return [HEADER, "", sections.join("\n\n"), "", footer].join("\n");
+}
+function all_command_names() {
+  return [...Object.keys(COMMAND_MAP), ...Object.keys(ALIASES)];
+}
+function format_unknown_command(cmd) {
+  const suggestion = command_suggest.closest_command(cmd, all_command_names());
+  const hint = suggestion === void 0 ? "" : ` Did you mean '${suggestion}'?`;
+  return `Unknown command: ${cmd}.${hint} Run 'josh --help' for common commands or 'josh --all' for the full list.`;
+}
+function should_use_shell(executable) {
+  return process.platform === "win32" && executable !== process.execPath;
+}
+function spawn_script(tsx_executable, script_arguments) {
+  const result = execaSync2(tsx_executable, script_arguments, {
+    stdio: "inherit",
+    shell: should_use_shell(tsx_executable),
+    reject: false
+  });
+  return resolve_spawn_exit(tsx_executable, result);
+}
+function run_shell_command(shell, extra) {
+  const [executable = "", ...rest_arguments] = shell;
+  const result = execaSync2(executable, [...rest_arguments, ...extra], {
+    stdio: "inherit",
+    reject: false
+  });
+  return resolve_spawn_exit(executable, result);
+}
+function spawn_script_entry(entry, script_path, script_arguments) {
+  const runner = resolve_tsx_runner();
+  return spawn_script(runner.executable, [
+    ...runner.leading_arguments,
+    ...entry.tsx_arguments ?? [],
+    script_path,
+    ...script_arguments
+  ]);
+}
+async function run_script_entry(entry, subcommand_arguments) {
+  const script_path = path3.join(PACKAGE_DIR, entry.script ?? "");
+  const script_arguments = [...entry.default_script_arguments ?? [], ...subcommand_arguments];
+  if (josh_in_process.can_run_in_process(entry, import.meta.url)) {
+    return await josh_in_process.run_in_process(script_path, script_arguments);
+  }
+  return spawn_script_entry(entry, script_path, script_arguments);
+}
+function pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer) {
+  if (is_consumer && kit_only.is_kit_only(entry)) {
+    console.error(kit_only.notice(resolved));
+    return USAGE_ERROR_EXIT_CODE;
+  }
+  const rejection = composite_arguments.reject_extra_arguments(
+    resolved,
+    entry,
+    subcommand_arguments
+  );
+  if (rejection === void 0) return void 0;
+  console.error(rejection);
+  return USAGE_ERROR_EXIT_CODE;
+}
+async function dispatch_entry(entry, subcommand_arguments) {
+  if (entry.shell) return run_shell_command(entry.shell, subcommand_arguments);
+  return await run_script_entry(entry, subcommand_arguments);
+}
+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);
+  if (early_exit !== void 0) return early_exit;
+  return await dispatch_entry(entry, subcommand_arguments);
+}
+var josh_logic = {
+  format_help,
+  format_unknown_command,
+  run_command,
+  spawn_script,
+  run_shell_command
+};
+
+// scripts/josh/josh.ts
+var ARGV_OFFSET = 2;
+var HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
+var ALL_FLAG = "--all";
+function print_help(is_all, is_consumer) {
+  console.info(josh_logic.format_help(is_all, is_consumer));
+}
+function handle_unknown(cmd) {
+  console.error(josh_logic.format_unknown_command(cmd));
+  process.exit(1);
+}
+function record_exit_code(exit_code) {
+  if (exit_code !== 0) process.exitCode = exit_code;
+}
+async function main() {
+  const cmd = process.argv[ARGV_OFFSET];
+  const is_all = process.argv.includes(ALL_FLAG);
+  const is_consumer = doctor_consumer.is_kit_consumer(find_package_directory(process.cwd()));
+  if (!cmd || cmd === ALL_FLAG || HELP_COMMANDS.has(cmd)) {
+    print_help(is_all, is_consumer);
+    return;
+  }
+  const subcommand_arguments = process.argv.slice(ARGV_OFFSET + 1);
+  const exit_code = await josh_logic.run_command(cmd, subcommand_arguments, is_consumer);
+  if (exit_code === UNKNOWN_COMMAND_EXIT_CODE) handle_unknown(cmd);
+  record_exit_code(exit_code);
+}
+await main();