@joshuafolkken/kit 1.978.0 → 1.998.0

package/dist/hooks/{chunk-BNGGEY3Z.js → chunk-762BDXDU.js}

@@ -2,7 +2,6 @@ import {
   ALREADY_DONE_LABEL,
   BREAKING_CHANGE_LABEL,
   BUGFIX_LABEL,
-  BUG_LABEL,
   CONTEXT_CUT_THRESHOLD,
   ENHANCEMENT_LABEL,
   FULL_PAGE_QUERY,
@@ -20,7 +19,6 @@ import {
   git_gh_api_path,
   git_gh_exec,
   has_any_label,
-  has_label_name,
   has_stderr_field,
   lane_background,
   lane_park,
@@ -28,6 +26,7 @@ import {
   parse_json_array_or_undefined,
   parse_json_object_safe,
   read_json_listing,
+  repo_origin,
   repo_party,
   run_carry,
   run_cut,
@@ -37,31 +36,31 @@ import {
   run_watcher_guard,
   shell_segments,
   tail_commands
-} from "./chunk-Q7LE77CO.js";
+} from "./chunk-7WAOP42A.js";
 import {
   find_local_bin_upwards
 } from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-NXL3SBXY.js";
+} from "./chunk-A2H5I2VD.js";
 import {
   investigation_refusal
-} from "./chunk-BVMSPG3M.js";
+} from "./chunk-KPZN42RT.js";
 import {
   duplicate_read_outcome
-} from "./chunk-ZYYSBNR6.js";
+} from "./chunk-4GDR2YTV.js";
 import {
   investigation_reads
-} from "./chunk-F6OM6SIG.js";
+} from "./chunk-WMIR5SNX.js";
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-2K52BRWV.js";
+} from "./chunk-56LGMJJV.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-KQG4776P.js";
+} from "./chunk-GBJUERYK.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -71,14 +70,28 @@ import {
   json_value,
   lane_paths,
   stamp_file,
-  time_density_hook,
   time_shell
-} from "./chunk-ZPLXLJ7O.js";
+} from "./chunk-PAXMLGSS.js";
 
 // scripts/hooks/pretool-guard.ts
 import { text } from "node:stream/consumers";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
+// scripts/rules/direct-filing.ts
+var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api \u2026/issues` or `gh issue create`. The command runs every filing step in order \u2014 the duplicate scout, the body lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing into another repository, and `epic:bundle` after the create \u2014 so none of them is a step to remember. When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,\u2026>` for the ones that are separate deliverables. Reference: `docs/josh-commands.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
+function is_any_filing(command) {
+  return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command);
+}
+var ROW = {
+  id: "direct-filing",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_direct_filing),
+  reason: DIRECT_FILING_REASON,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reaches: bash_triggers.on_bash_command(is_any_filing)
+};
+var direct_filing = { DIRECT_FILING_REASON, ROW };
+
 // scripts/run/run-progress.ts
 var DEFAULT_INTERVAL_MINUTES = 20;
 var INTERVAL_KEY = "JOSH_PROGRESS_INTERVAL_MINUTES";
@@ -382,7 +395,7 @@ function carries_a_file_body(command, has_file = existsSync) {
   return writes_existing_file(command, has_file) || has_body_interpreter(command);
 }
 var FILE_BODY_REASON = "\u26D4 file body in a shell command: this carries a file's new text inline \u2014 a heredoc rewriting an existing file, an interpreter (`python3 - <<`, `node -e`) whose body writes, or an in-place `perl -0pi -e`. `CLAUDE.md` forbids it because the command body is re-read on every later request of the run, so an editing script written early is billed for the rest of it (`file-edits.md` measured one run at ~2m45s spent retyping existing lines). Edit a region with the Edit tool (old / new), or pass a body by path (`--field body=@<path>`, `--body-file <path>`). A new-file creation (`cat > <new-file> <<EOF`), a read-only heredoc (`cat <<EOF`), and a short `sed -i` stay allowed. **This rule fires on every occurrence, not once per run.**";
-var ROW = {
+var ROW2 = {
   id: "file-body",
   is_trigger: bash_triggers.on_bash_command((command) => carries_a_file_body(command)),
   reason: FILE_BODY_REASON,
@@ -390,7 +403,7 @@ var ROW = {
 };
 var file_body = {
   FILE_BODY_REASON,
-  ROW,
+  ROW: ROW2,
   carries_a_file_body,
   is_in_place_perl,
   is_interpreter_write,
@@ -518,7 +531,7 @@ function is_force_or_delete(command) {
   return shell_segments.segments_of(command).some((segment) => is_destructive_segment(segment));
 }
 var GIT_FORCE_REASON = "\u26D4 force push or branch delete: this rewrites or removes shared history, which is Tier C and needs explicit current-turn user instruction \u2014 never an AI decision, even to fix a problem you caused (`prompts/collaboration-workflow/operating-rules.md`). The `.claude/settings.json` deny list matches globs, so it misses this spelling: a combined short cluster (`git push -uf`), a `git -C <path>` prefix, and the colon-form delete (`git push origin :branch`) all pass it. This row reads the argv instead, so the spelling does not matter. For an ordinary push use `pnpm josh git`; a force push, a `git push --delete` / `:branch`, or a `git branch -d` / `-D` is the user's to run in their own terminal. **This rule fires on every occurrence, not once per run.**";
-var ROW2 = {
+var ROW3 = {
   id: "git-force",
   is_trigger: bash_triggers.on_bash_command(is_force_or_delete),
   reason: GIT_FORCE_REASON,
@@ -526,7 +539,7 @@ var ROW2 = {
 };
 var git_force = {
   GIT_FORCE_REASON,
-  ROW: ROW2,
+  ROW: ROW3,
   is_branch_delete,
   is_force_or_delete,
   is_force_or_delete_push
@@ -1056,7 +1069,7 @@ function is_reissued_refusal(now_ms, delivered_at_ms) {
 function decide2(_call, run2, _can_record, delivered_at_ms) {
   return !is_reissued_refusal(run2.now_ms, delivered_at_ms);
 }
-var ROW3 = {
+var ROW4 = {
   id: "implementation-cut",
   is_trigger: is_over_threshold_edit,
   reason: IMPLEMENTATION_CUT_REASON,
@@ -1066,7 +1079,7 @@ var ROW3 = {
 var implementation_cut = {
   IMPLEMENTATION_CUT_REASON,
   REISSUE_WINDOW_MS,
-  ROW: ROW3,
+  ROW: ROW4,
   decide: decide2,
   is_edit_tool,
   is_over_threshold_edit,
@@ -1075,201 +1088,6 @@ var implementation_cut = {
   uncut_run_issue
 };
 
-// scripts/rules/issue-bug-label.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import path4 from "node:path";
-
-// scripts/issue/markdown-section.ts
-var HEADING_PREFIX = "## ";
-function is_heading(line) {
-  return line.trimStart().startsWith(HEADING_PREFIX);
-}
-function is_the_heading(line, heading) {
-  return line.trim() === heading;
-}
-function next_fence(line, fence) {
-  const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
-  if (fence === "") return marker;
-  const closing = new RegExp(
-    String.raw`^ {0,3}${fence.charAt(0)}{${String(fence.length)},}\s*$`,
-    "u"
-  );
-  if (closing.test(line)) return "";
-  return void 0;
-}
-function unfenced_lines(body) {
-  let fence = "";
-  const visible = [];
-  for (const line of body.split("\n")) {
-    const next = next_fence(line, fence);
-    const visible_line = line.replace(/^(?: {4}|\t).*/u, "");
-    visible.push(next === void 0 && fence === "" ? visible_line : "");
-    fence = next ?? fence;
-  }
-  return visible;
-}
-function has_unfenced_line(body, text2) {
-  return unfenced_lines(body).some((line) => line.trim() === text2);
-}
-function has_line(body, text2) {
-  return has_unfenced_line(body, text2);
-}
-function section_lines(body, heading) {
-  const lines = body.split("\n");
-  const visible = unfenced_lines(body);
-  const start = visible.findIndex((line) => is_the_heading(line, heading));
-  if (start === -1) return [];
-  const rest = lines.slice(start + 1);
-  const end = visible.slice(start + 1).findIndex((line) => is_heading(line));
-  return end === -1 ? rest : rest.slice(0, end);
-}
-var markdown_section = { section_lines, is_heading, has_line, has_unfenced_line };
-
-// scripts/issue/issue-bug-label.ts
-var BUG_DECLARATION_LINE = "- \u7A2E\u5225: \u4E0D\u5177\u5408";
-function is_bug_fix(body) {
-  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
-  return markdown_section.has_unfenced_line(background, BUG_DECLARATION_LINE);
-}
-var issue_bug_label = { BUG_DECLARATION_LINE, is_bug_fix };
-
-// scripts/issue/issue-classification.ts
-var FEATURE_DECLARATIONS = ["- \u76EE\u7684: \u6A5F\u80FD\u8FFD\u52A0", "- \u76EE\u7684: \u6A5F\u80FD\u6539\u5584"];
-var BREAKING_DECLARATION = "- \u4E92\u63DB\u6027: \u7834\u58CA\u7684\u5909\u66F4";
-var NON_BUG_DECLARATION = "- \u7A2E\u5225: \u975E\u4E0D\u5177\u5408";
-var CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL];
-var CONFLICT = "bug and enhancement declarations cannot be combined";
-var MISSING_BUG_CLASSIFICATION = "missing bug classification";
-var CONFLICTING_BUG_CLASSIFICATIONS = "conflicting bug classifications";
-function required_labels(body) {
-  const labels = [];
-  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
-  if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL);
-  if (FEATURE_DECLARATIONS.some((line) => markdown_section.has_unfenced_line(background, line))) {
-    labels.push(ENHANCEMENT_LABEL);
-  }
-  if (markdown_section.has_unfenced_line(background, BREAKING_DECLARATION)) {
-    labels.push(BREAKING_CHANGE_LABEL);
-  }
-  return labels;
-}
-function labels_for(body, existing) {
-  const missing = required_labels(body).filter((label) => !has_label_name(existing, label));
-  return [...existing, ...missing];
-}
-function bug_classification_problem(body) {
-  const background = markdown_section.section_lines(body, "## \u80CC\u666F").join("\n");
-  const has_bug = issue_bug_label.is_bug_fix(body);
-  const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION);
-  if (!has_bug && !has_non_bug) return MISSING_BUG_CLASSIFICATION;
-  if (has_bug && has_non_bug) return CONFLICTING_BUG_CLASSIFICATIONS;
-  return void 0;
-}
-function problems(body) {
-  const classification_problem = bug_classification_problem(body);
-  const found = [];
-  if (classification_problem !== void 0) found.push(classification_problem);
-  const labels = required_labels(body);
-  if (labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL)) found.push(CONFLICT);
-  return found;
-}
-var issue_classification = {
-  BREAKING_DECLARATION,
-  CLASSIFICATION_LABELS,
-  FEATURE_DECLARATIONS,
-  NON_BUG_DECLARATION,
-  labels_for,
-  problems,
-  required_labels
-};
-
-// scripts/rules/issue-filing-args.ts
-var SHELL_WORD = /(?:[^\s'"]|'[^']*'|"[^"]*")+/gu;
-var QUOTE = /['"]/gu;
-var RAW_FIELDS = /* @__PURE__ */ new Set(["-f", "--raw-field"]);
-var FILE_FIELDS = /* @__PURE__ */ new Set(["-F", "--field"]);
-var LABEL_OPTIONS = /* @__PURE__ */ new Set(["-l", "--label"]);
-var BODY_FILE_OPTIONS = /* @__PURE__ */ new Set(["--body-file"]);
-var INLINE_BODY_OPTIONS = /* @__PURE__ */ new Set(["-b", "--body"]);
-var BODY_FILE_PREFIX = "body=@";
-function words_of2(command) {
-  return [...command.matchAll(SHELL_WORD)].map((match) => match[0].replaceAll(QUOTE, ""));
-}
-function values_after(words, flags) {
-  return words.flatMap((word, index) => {
-    const value = words[index + 1];
-    return value !== void 0 && flags.has(word) ? [value] : [];
-  });
-}
-function has_inline_body(words) {
-  const has_raw = values_after(words, RAW_FIELDS).some((value) => value.startsWith("body="));
-  return has_raw || values_after(words, INLINE_BODY_OPTIONS).length > 0;
-}
-function body_file(command) {
-  const words = words_of2(command);
-  const fields = values_after(words, FILE_FIELDS).filter((value) => value.startsWith("body="));
-  const options = values_after(words, BODY_FILE_OPTIONS);
-  if (has_inline_body(words) || fields.length + options.length !== 1) return void 0;
-  return fields[0]?.startsWith(BODY_FILE_PREFIX) ? fields[0].slice(BODY_FILE_PREFIX.length) : options[0];
-}
-function has_label(command, label) {
-  const words = words_of2(command);
-  const fields = [...values_after(words, RAW_FIELDS), ...values_after(words, FILE_FIELDS)];
-  const options = values_after(words, LABEL_OPTIONS).flatMap((value) => value.split(","));
-  return fields.includes(`labels[]=${label}`) || options.includes(label);
-}
-var issue_filing_args = { body_file, has_label, words_of: words_of2 };
-
-// scripts/rules/issue-bug-label.ts
-var LINT_NAMES = /* @__PURE__ */ new Set(["issue:lint"]);
-var LINT_PATH = /\b(?:issue:lint|iln)\s+(?:'([^']+)'|"([^"]+)"|(\S+))/u;
-function lint_argument(segment) {
-  const [, single_quoted, double_quoted, bare] = LINT_PATH.exec(segment) ?? [];
-  return single_quoted ?? double_quoted ?? bare;
-}
-function latest_lint_path(tail) {
-  const segments = tail_commands.prior_bash_commands(tail).flatMap((command) => shell_segments.segments_of(command));
-  const lint = segments.findLast((segment) => shell_segments.is_josh_command(segment, LINT_NAMES));
-  return lint === void 0 ? void 0 : lint_argument(lint);
-}
-function linted_body(body_path) {
-  try {
-    return readFileSync3(body_path, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-function matches_linted_file(command, lint_path) {
-  const filing_path = issue_filing_args.body_file(command);
-  return filing_path !== void 0 && path4.resolve(filing_path) === path4.resolve(lint_path);
-}
-function needs_classification_labels(command, tail) {
-  const lint_path = latest_lint_path(tail);
-  if (lint_path === void 0) return false;
-  const body = linted_body(lint_path);
-  if (body === void 0) return false;
-  if (!matches_linted_file(command, lint_path) || issue_classification.problems(body).length > 0) {
-    return true;
-  }
-  const expected = issue_classification.required_labels(body);
-  return issue_classification.CLASSIFICATION_LABELS.some(
-    (label) => expected.includes(label) !== issue_filing_args.has_label(command, label)
-  );
-}
-function decide3(call, run2) {
-  const command = time_shell.bash_command(call.input);
-  const tail = time_density_hook.read_tail(run2.transcript);
-  return needs_classification_labels(command, tail);
-}
-var ISSUE_CLASSIFICATION_REASON = "\u26D4 issue classification mismatch: use the exact body file checked by `pnpm josh issue:lint` in this creation call (`-F body=@<path>` or `gh issue create --body-file <path>`) and apply exactly the `labels:` it reports (`bug`, `enhancement`, `breaking-change`). See `prompts/collaboration-workflow/issue-template.md`.";
-var ROW4 = {
-  id: "issue-bug-label",
-  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-  reason: ISSUE_CLASSIFICATION_REASON,
-  decide: decide3
-};
-var issue_bug_label_rule = { ROW: ROW4, latest_lint_path, needs_classification_labels };
-
 // scripts/rules/issue-fold.ts
 var FOLD_NAMES = /* @__PURE__ */ new Set(["issue:fold"]);
 function runs_the_fold(command) {
@@ -1279,7 +1097,7 @@ function already_folded(tail, _call) {
   if (filing_cap.prior_filing_count(tail) === 0) return true;
   return tail_commands.prior_bash_commands(tail).some((command) => runs_the_fold(command));
 }
-var ISSUE_FOLD_REASON = '\u26D4 issue fold: this run has filed an Issue before and is filing another with no `pnpm josh issue:fold` between them. Several findings from one session fold into one Issue by default \u2014 the filing-time counterpart to the split assessment, whose two questions it reuses: are the findings separable, and does the whole clearly exceed one verification gate (the size half is `split:assess`, called not recomputed). Reissue after folding: `pnpm josh issue:fold "<title>" "<title>" \u2026` \u2014 `fold` means file one Issue covering them, `separate` means file them apart (separable findings whose combined size clears the split guide), and the default is `fold`. Add `--not-separable` when they are really one deliverable. The procedure is `.claude/skills/workflow-commands/split-assessment.md` \u2192 "The question". It fires once per run and cannot repeat on the call in hand.';
+var ISSUE_FOLD_REASON = '\u26D4 issue fold: this run has filed an Issue before and is filing another with no `pnpm josh issue:fold` between them. Several findings from one session fold into one Issue by default \u2014 the filing-time counterpart to the split assessment, whose two questions it reuses: are the findings separable, and does the whole clearly exceed one verification gate (the size half is `split:assess`, called not recomputed). Reissue after folding: `pnpm josh issue:fold "<title>" "<title>" \u2026` \u2014 `fold` means file one Issue covering them, `separate` means file them apart (separable findings whose combined size clears the split guide), and the default is `fold`. Add `--not-separable` when they are really one deliverable. The procedure is `.claude/skills/workflow-commands/split-assessment.md` \u2192 "The question". Every later filing is refused until the fold is on the transcript.';
 var ROW5 = {
   id: "issue-fold",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
@@ -1289,24 +1107,6 @@ var ROW5 = {
 };
 var issue_fold = { ISSUE_FOLD_REASON, ROW: ROW5, already_folded, runs_the_fold };
 
-// scripts/rules/issue-scout.ts
-var SCOUT_NAMES = /* @__PURE__ */ new Set(["issue:scout"]);
-function runs_the_scout(command) {
-  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, SCOUT_NAMES));
-}
-function already_scouted(tail, _call) {
-  return tail_commands.prior_bash_commands(tail).some((command) => runs_the_scout(command));
-}
-var ISSUE_SCOUT_REASON = '\u26D4 issue scout: this files an Issue with no `pnpm josh issue:scout` earlier in the run. A duplicate is likeliest for the work that just finished, which is exactly where self-restraint is weakest. Reissue after scouting: `pnpm josh issue:scout "<title>"` (add `--body "<one-line summary, citing #N where the work follows one>"` so the epic half can answer), then read its `Duplicates:` \u2014 an **open** candidate covering the same work stops the run rather than filing a second Issue, and a `(closed)` one means the work is already done \u2014 before reissuing this filing. The procedure is `.claude/skills/workflow-commands/SKILL.md` \u2192 \xA72e. It fires once per run and cannot repeat on the call in hand.';
-var ROW6 = {
-  id: "issue-scout",
-  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-  reason: ISSUE_SCOUT_REASON,
-  already_satisfied: already_scouted,
-  keeps: bash_triggers.on_bash_command(runs_the_scout)
-};
-var issue_scout = { ISSUE_SCOUT_REASON, ROW: ROW6, already_scouted, runs_the_scout };
-
 // scripts/rules/josh-git-bare.ts
 var GIT_COMMAND2 = /* @__PURE__ */ new Set(["git"]);
 var CONFIRM_FLAGS = /* @__PURE__ */ new Set(["-y", "--yes"]);
@@ -1321,7 +1121,7 @@ function is_bare_josh_git(command) {
   return shell_segments.segments_of(command).some((segment) => is_bare_segment(segment));
 }
 var JOSH_GIT_BARE_REASON = '\u26D4 bare `pnpm josh git`: this prompts to confirm the staging, and with no TTY the prompt falls to its cancel branch \u2014 `Checking unstaged files... Found` then `Operation cancelled.` \u2014 so the call throws away the time it takes to fail (about 31 seconds in one measured lane) and you reissue it with `-y` anyway (joshuafolkken/kit#2297). Run it unattended from the start: `pnpm josh git -y "<title> #<N>"`. The recovery form that opens the PR for a push that already landed is `pnpm josh git -y --skip-commit --skip-push`. This rule fires on every occurrence, not once per run.';
-var ROW7 = {
+var ROW6 = {
   id: "josh-git-bare",
   is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
   reason: JOSH_GIT_BARE_REASON,
@@ -1329,7 +1129,7 @@ var ROW7 = {
 };
 var josh_git_bare = {
   JOSH_GIT_BARE_REASON,
-  ROW: ROW7,
+  ROW: ROW6,
   is_bare_josh_git
 };
 
@@ -1343,7 +1143,7 @@ function is_carry_conflict(command, is_lane_child = lane_child_marker.is_child_o
   return is_lane_child;
 }
 var LANE_CARRY_CONFLICT_REASON = '\u26D4 lane child carry conflict: this session is a dispatched lane child, and `pnpm josh run:merge` / `pnpm josh run:carry` are the parent backlogrun budget commands \u2014 a child must never run them. The live carry record here belongs to the parent that launched this child, not to a competing run: the parent holds the one run budget for the repository, and every lane shares the common git directory it is keyed on, so a live owner a lane child reads is always its parent (joshuafolkken/kit#2267, measured 2026-09-21 in backlogrun #2252 \u2014 a child read run:merge `busy` as a competitor and parked #2258 unimplemented). Do not run this command, and do not treat it as a conflict: no `needs-decision`, no `confirmation` Telegram, no question to a person \u2014 a dispatched child cannot ask, and there is nothing to decide. Continue implementing this Issue; the parent owns the budget and counts the outcome at the return. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` and `backlogrun-progress.md` \u2192 "The hand-off". This rule fires on every occurrence, not once per run.';
-var ROW8 = {
+var ROW7 = {
   id: "lane-carry-conflict",
   is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
   reason: LANE_CARRY_CONFLICT_REASON,
@@ -1351,7 +1151,7 @@ var ROW8 = {
 };
 var lane_carry_conflict = {
   LANE_CARRY_CONFLICT_REASON,
-  ROW: ROW8,
+  ROW: ROW7,
   invokes_budget_command,
   is_carry_conflict
 };
@@ -1404,13 +1204,13 @@ function is_interactive_ask(call, is_lane_child = lane_child_marker.is_child_of(
   return is_lane_child;
 }
 var LANE_INTERACTIVE_ASK_REASON = '\u26D4 lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so this call is refused. Left to run it would end the turn with nothing on the Issue \u2014 the parent then finds an OPEN Issue with `in-progress` and no question (joshuafolkken/kit#2201; joshuafolkken/kit#2034 placed the same rule one tool-call too late). Do not ask: park the decision instead. Apply `needs-decision` and post a comment carrying the question, the options and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>` \u2014 then send the `confirmation` Telegram and stop. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue". This rule fires on every occurrence, not once per run.';
-var ROW9 = {
+var ROW8 = {
   id: "lane-interactive-ask",
   is_trigger: is_interactive_ask,
   reason: LANE_INTERACTIVE_ASK_REASON,
   decide: () => true
 };
-var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW9, is_interactive_ask };
+var lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW: ROW8, is_interactive_ask };
 
 // scripts/rules/lane-switch-main.ts
 var SWITCH_SUBCOMMAND = "switch";
@@ -1441,7 +1241,7 @@ function is_switch_away_from_lane(command, is_lane_child = lane_child_marker.is_
   return switch_targets(command).some((target) => target !== own_branch);
 }
 var LANE_SWITCH_MAIN_REASON = "\u26D4 lane child on `git switch main`: this session is a dispatched lane child, and switching to the default branch here always fails \u2014 a lane is a linked work tree, the primary checkout holds the default branch, and git allows one branch in one work tree at a time (`fatal: main is already used by worktree at <the primary checkout>`, measured 11 times in the 2026-09-21 backlogrun). Do not switch: the lane is already on its own issue branch, branched from a fresh default before it opened, and the latest default is brought in during the gate by `pnpm josh main:merge`. So skip this step and keep implementing on the current branch \u2014 no `git switch`, no `git pull`. `pnpm josh main:sync` (`josh ms`) is refused in a lane for the same reason, and a lane is finished with `pnpm josh lane:close <issue-number>`. The parent runs `git switch main && git pull` in the primary checkout before each lane opens, never the child \u2014 `backlogrun-lanes.md` and `backlogrun-child.md` are the single sources. This rule fires on every occurrence, not once per run.";
-var ROW10 = {
+var ROW9 = {
   id: "lane-switch-main",
   is_trigger: bash_triggers.on_bash_command(is_switch_away_from_lane),
   reason: LANE_SWITCH_MAIN_REASON,
@@ -1449,7 +1249,7 @@ var ROW10 = {
 };
 var lane_switch_main = {
   LANE_SWITCH_MAIN_REASON,
-  ROW: ROW10,
+  ROW: ROW9,
   is_switch_away_from_lane,
   switch_target,
   switch_targets
@@ -1752,20 +1552,13 @@ var FIRING = /* @__PURE__ */ new Map([
       describes: "a package-add command (`pnpm add \u2026`, `npm install <pkg>`)",
       governs: is_package_add
     }
-  ],
-  [
-    "issue:lint",
-    {
-      describes: "an Issue-filing call (`gh api \u2026/issues`, `gh issue create`)",
-      governs: bash_triggers.is_issue_filing
-    }
   ]
 ]);
 var PHASE = "the act it governs is a phase of a run, not a single shell call a trigger can anchor on";
 var READ = "it answers a status question and governs no action of its own to gate before";
 var SELF = "the command is itself the governed act; there is no earlier call to gate before it";
 var LATEST_SCOPE_REASON = "the run it governs (`pnpm josh latest`) is already gated at its point of use by the latest-gate; a firing here would double-gate it";
-var EPIC_BUNDLE_REASON = "it runs after a filing to place it, and that filing is already gated by `issue-scout`; it has no earlier call of its own";
+var FILING_STEP_REASON = "`pnpm josh issue:file` runs it as one of its filing steps, and a direct filing is refused by the `direct-filing` delivered rule; there is no separate call left to gate";
 var RELEASE_SCOPE_REASON = "it reads the release owed *after* `pnpm josh followup` has merged (`git_followup_pending`), so it trails the merge rather than gating it; a firing on `followup` would gate a check that must run once the merge is done, reading a pre-merge state that has not yet arrived";
 var NOT_NAMED = /* @__PURE__ */ new Map([
   ["release:scope", RELEASE_SCOPE_REASON],
@@ -1777,8 +1570,9 @@ var NOT_NAMED = /* @__PURE__ */ new Map([
   ["latest:scope", LATEST_SCOPE_REASON],
   ["run:hold", SELF],
   ["cost:cut", READ],
-  ["epic:bundle", EPIC_BUNDLE_REASON],
-  ["issue:scout", "the filing it governs is already gated by the `issue-scout` delivered rule"],
+  ["epic:bundle", FILING_STEP_REASON],
+  ["issue:scout", FILING_STEP_REASON],
+  ["issue:lint", FILING_STEP_REASON],
   [
     "issue:fold",
     "the second filing it governs is already gated by the `issue-fold` delivered rule"
@@ -1834,7 +1628,7 @@ function command_line(oracle) {
   return oracle.args ? `pnpm josh ${command} ${oracle.args}` : `pnpm josh ${command}`;
 }
 function reason_for(oracle, firing_point) {
-  return `\u26D4 decision oracle not consulted: this is ${firing_point.describes}, but the run has not run \`${command_line(oracle)}\` first \u2014 the oracle that decides ${oracle.decision.toLowerCase()}. It answers ${oracle.vocabulary.join(" | ")}; single source ${oracle.single_source}. Reissue after running it and reading its verdict. It fires once per run and cannot repeat on the call in hand.`;
+  return `\u26D4 decision oracle not consulted: this is ${firing_point.describes}, but the run has not run \`${command_line(oracle)}\` first \u2014 the oracle that decides ${oracle.decision.toLowerCase()}. It answers ${oracle.vocabulary.join(" | ")}; single source ${oracle.single_source}. Reissue after running it and reading its verdict. Every such call is refused until that command is on the transcript.`;
 }
 function row_for(oracle, firing_point) {
   const names = command_names(oracle);
@@ -1917,7 +1711,7 @@ function is_poll_loop(command) {
   return LOOP_KEYWORD2.test(plain) && SLEEP_COMMAND.test(plain);
 }
 var POLL_LOOP_REASON = '\u26D4 output poll loop: this hand-writes a `while`/`until` wait loop over a command\'s output, a marker file or a process \u2014 with a `sleep` or, worse, without one \u2014 and the loop does not know when the command finished. A regex that never matches waits to the harness block limit; one that matches a mid-run line exits too early \u2014 either way the command exit is not what ends the wait, and each pass spends a full-context round trip (joshuafolkken/kit#2371 measured about 45 minutes, 13% of six lanes, lost to exactly this). Do not poll the output file. A command known to take minutes \u2014 `pnpm josh gate`, `pnpm josh followup`, `pnpm josh format` \u2014 is started detached from the first with `run_in_background` set, and the harness re-invokes you when it exits: its completion notification is what ends the wait, on the task exit rather than a regex or the block limit. So issue the long command in the background and end the turn \u2014 do not arm a loop; the wake-up brings you back. To glance at interim output, `Read` the output file once, never in a sleep loop. If you are waiting on CI, `pnpm josh followup` waits on it for you. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every occurrence, not once per run.**';
-var ROW11 = {
+var ROW10 = {
   id: "poll-loop",
   is_trigger: bash_triggers.on_bash_command(is_poll_loop),
   reason: POLL_LOOP_REASON,
@@ -1925,7 +1719,7 @@ var ROW11 = {
 };
 var poll_loop = {
   POLL_LOOP_REASON,
-  ROW: ROW11,
+  ROW: ROW10,
   is_poll_loop
 };
 
@@ -2045,16 +1839,16 @@ function posts_at_path_literally(command) {
   return RAW_FIELD_BODY_AT.test(command);
 }
 var RAW_FIELD_BODY_REASON = "\u26D4 literal @path body: this passes `body=@<path>` to `gh api` with a raw field flag (`-f` / `--raw-field`), which sends the value verbatim \u2014 the string `@<path>` is posted as the comment, not the file it points at. `-F` / `--field` is the flag that reads the file, and the two spellings differ by one character while `gh` exits 0 and returns a comment URL either way, so the break is invisible until a person reads the issue (joshuafolkken/kit#2304 lost two park comments this way). Post an issue or PR comment with `pnpm josh issue:comment <N> --body-file <path>` \u2014 the one spelling, which cannot take the wrong flag. The rule and the safe forms are in `prompts/collaboration-workflow/shell-body.md`. This rule fires on every occurrence, not once per run.";
-var ROW12 = {
+var ROW11 = {
   id: "raw-field-body",
   is_trigger: bash_triggers.on_bash_command(posts_at_path_literally),
   reason: RAW_FIELD_BODY_REASON,
   decide: () => true
 };
-var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW12, posts_at_path_literally };
+var raw_field_body = { RAW_FIELD_BODY_REASON, ROW: ROW11, posts_at_path_literally };
 
 // scripts/rules/rule-body-guard.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 var EDIT_TOOL = "Edit";
 var WRITE_TOOL = "Write";
 var CLAUDE_DOCUMENT = /(?:^|\/)CLAUDE\.md$/u;
@@ -2077,7 +1871,7 @@ function string_field(input, key) {
   return typeof value === "string" ? value : "";
 }
 function read_existing(file_path) {
-  return existsSync2(file_path) ? readFileSync4(file_path, "utf8") : "";
+  return existsSync2(file_path) ? readFileSync3(file_path, "utf8") : "";
 }
 function texts_of(name, input, read2) {
   if (name === WRITE_TOOL) {
@@ -2104,7 +1898,7 @@ function writes_rule_prose(call, read2 = read_existing) {
   const { old_text, new_text } = texts_of(call.name, input, read2);
   return adds_rule_prose(old_text, new_text);
 }
-var RULE_BODY_REASON = "\u26D4 rule written into prose: this edit adds rule text to CLAUDE.md, a `prompts/**` doc or a skill body. Before it lands, run the residency questions the addition skips. A rule whose answer is computable from mechanically readable inputs should be a decision oracle, not prose \u2014 question 0; `pnpm josh oracle:list` lists the existing oracles a new one joins (single source `scripts/rules/decision-oracle.ts`). A rule that decides *when* or *in what order* to act belongs in the run driver, not prose \u2014 the ordering question; `pnpm josh run:step` is the state machine a sequencing rule moves into. Only a rule that is neither \u2014 not computable, not ordering \u2014 stays prose, and then as a trigger-plus-pointer line rather than a second copy of its procedure. The criterion is `prompts/collaboration-workflow/residency.md` (question 0 and the ordering question); the delivery enumeration is `prompts/collaboration-workflow/rule-delivery.md`. This fires once per run \u2014 once you have confirmed the rule can be neither an oracle nor an ordering step, reissue this edit and it will go through.";
+var RULE_BODY_REASON = "\u26D4 rule written into prose: this edit adds rule text to CLAUDE.md, a `prompts/**` doc or a skill body. Before it lands, run the residency questions the addition skips. A rule whose answer is computable from mechanically readable inputs should be a decision oracle, not prose \u2014 question 0; `pnpm josh oracle:list` lists the existing oracles a new one joins (single source `scripts/rules/decision-oracle.ts`). A rule that decides *when* or *in what order* to act belongs in the run driver, not prose \u2014 the ordering question; `pnpm josh run:step` is the state machine a sequencing rule moves into. Only a rule that is neither \u2014 not computable, not ordering \u2014 stays prose, and then as a trigger-plus-pointer line rather than a second copy of its procedure. The criterion is `prompts/collaboration-workflow/residency.md` (question 0 and the ordering question); the delivery enumeration is `prompts/collaboration-workflow/rule-delivery.md`. Every such edit is refused until both commands are on the transcript \u2014 run them, confirm the rule can be neither an oracle nor an ordering step, then reissue this edit.";
 var PLACEMENT_ORACLES = [
   /* @__PURE__ */ new Set(["oracle:list"]),
   /* @__PURE__ */ new Set(["run:step", "run:next"])
@@ -2123,7 +1917,7 @@ function runs_placement_oracle(command) {
     (names) => shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, names))
   );
 }
-var ROW13 = {
+var ROW12 = {
   id: "rule-body",
   is_trigger: writes_rule_prose,
   reason: RULE_BODY_REASON,
@@ -2132,7 +1926,7 @@ var ROW13 = {
 };
 var rule_body_guard = {
   RULE_BODY_REASON,
-  ROW: ROW13,
+  ROW: ROW12,
   adds_rule_prose,
   answered_placement,
   is_rule_document,
@@ -2216,9 +2010,133 @@ var shell_body_trigger = {
 import { execFileSync } from "node:child_process";
 
 // scripts/gate/project-checks.ts
-import { existsSync as existsSync3, globSync as globSync2, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync4, globSync as globSync2, readFileSync as readFileSync5 } from "node:fs";
 import path5 from "node:path";
 
+// scripts/init/project-profile.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import path4 from "node:path";
+
+// scripts/version/kit-descriptor.ts
+var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
+
+// scripts/init/project-profile.ts
+import { execaSync } from "execa";
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".svelte-kit"]);
+var WEB_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".css", ".js", ".jsx", ".mjs", ".cjs"]);
+var TYPESCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx"]);
+var PROFILE_ARG_LENGTH = 2;
+var PROFILE_NAMES = {
+  basic: "basic",
+  full: "full",
+  static: "basic",
+  node: "full"
+};
+function parse_profile(value) {
+  return typeof value === "string" && Object.hasOwn(PROFILE_NAMES, value) ? PROFILE_NAMES[value] : void 0;
+}
+var LEGACY_NAMES = { basic: "static", full: "node" };
+function with_legacy_profile_names(args) {
+  return args.map((argument, index) => {
+    const profile = args[index - 1] === "--profile" ? parse_profile(argument) : void 0;
+    return profile === void 0 ? argument : LEGACY_NAMES[profile];
+  });
+}
+function is_profile_pair(args) {
+  return args.length === PROFILE_ARG_LENGTH && args[0] === "--profile";
+}
+function requested_profile(args, usage = "josh init [--profile basic|full]") {
+  if (args.length === 0) return void 0;
+  if (!is_profile_pair(args)) throw new Error(`Usage: ${usage}`);
+  const profile = parse_profile(args[1]);
+  if (profile !== void 0) return profile;
+  throw new Error("Profile must be basic or full");
+}
+function read_manifest(root) {
+  const filename = path4.join(root, "package.json");
+  if (!existsSync3(filename)) return void 0;
+  const parsed = JSON.parse(readFileSync4(filename, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("package.json must contain an object");
+  }
+  return parsed;
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function recorded_profile(manifest) {
+  const { josh } = manifest;
+  return is_record(josh) ? parse_profile(josh["profile"]) : void 0;
+}
+function has_build_script(value) {
+  return is_record(value) && ("build" in value || "dev" in value);
+}
+function has_project_dependencies(value) {
+  if (!is_record(value)) return false;
+  return Object.keys(value).some((name) => name !== KIT_PACKAGE_NAME);
+}
+function inferred_profile(manifest) {
+  if (has_project_dependencies(manifest["dependencies"]) || has_project_dependencies(manifest["devDependencies"])) {
+    return { profile: "full", reason: "package dependencies" };
+  }
+  if (has_build_script(manifest["scripts"])) {
+    return { profile: "full", reason: "build or dev script" };
+  }
+  return { profile: "basic", reason: "metadata-only package.json" };
+}
+function resolve_profile(root, requested) {
+  if (requested !== void 0) return { profile: requested, reason: "explicit --profile" };
+  const manifest = read_manifest(root);
+  if (manifest === void 0) return { profile: "basic", reason: "no package.json" };
+  const profile = recorded_profile(manifest);
+  if (profile !== void 0) return { profile, reason: "package.json josh.profile" };
+  return inferred_profile(manifest);
+}
+function should_visit(entry) {
+  return entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name);
+}
+function scan_directory(directory, pending) {
+  const entries = readdirSync(directory, { withFileTypes: true });
+  pending.push(
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path4.join(directory, entry.name))
+  );
+  return entries.filter((entry) => entry.isFile()).map((entry) => path4.extname(entry.name));
+}
+function file_extensions(root) {
+  const pending = [root];
+  const extensions = [];
+  for (const directory of pending) {
+    extensions.push(...scan_directory(directory, pending));
+  }
+  return extensions;
+}
+function scan_files(root) {
+  const extensions = file_extensions(root);
+  const has_web = extensions.some((extension) => WEB_EXTENSIONS.has(extension));
+  const has_typescript = extensions.some((extension) => TYPESCRIPT_EXTENSIONS.has(extension));
+  return { has_web, has_typescript };
+}
+function has_github_remote(root) {
+  const result = execaSync("git", ["config", "--get", "remote.origin.url"], {
+    cwd: root,
+    reject: false
+  });
+  return result.exitCode === 0 && repo_origin.parse_origin_url(result.stdout) !== void 0;
+}
+function inspect_project(root, requested) {
+  const profile = resolve_profile(root, requested);
+  const files = scan_files(root);
+  const has_git = existsSync3(path4.join(root, ".git"));
+  return { ...profile, ...files, has_git, has_github: has_git && has_github_remote(root) };
+}
+var project_profile = {
+  parse_profile,
+  resolve_profile,
+  inspect_project,
+  requested_profile,
+  with_legacy_profile_names
+};
+
 // scripts/test/skip-marker.ts
 var SKIP_MARKER = "\u2014 skipping";
 
@@ -2261,7 +2179,7 @@ var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
 var object_schema = z5.record(z5.string(), z5.unknown());
 function project_root(directory) {
   let current = directory;
-  while (!existsSync3(path5.join(current, PACKAGE_JSON))) {
+  while (!existsSync4(path5.join(current, PACKAGE_JSON))) {
     const parent = path5.dirname(current);
     if (parent === current) return directory;
     current = parent;
@@ -2275,7 +2193,7 @@ function has_files(directory, pattern) {
   return globSync2(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0;
 }
 function has_config(directory, names) {
-  return names.some((name) => existsSync3(path5.join(project_root(directory), name)));
+  return names.some((name) => existsSync4(path5.join(project_root(directory), name)));
 }
 function has_bin(directory, bin_name) {
   return find_local_bin_upwards(directory, bin_name) !== void 0;
@@ -2284,12 +2202,12 @@ function josh_settings(manifest) {
   if (typeof manifest !== "object" || manifest === null || !("josh" in manifest)) return void 0;
   return manifest.josh;
 }
-function is_static_manifest(manifest) {
+function is_basic_manifest(manifest) {
   const josh = josh_settings(manifest);
   if (typeof josh !== "object" || josh === null || !("profile" in josh)) return false;
-  return josh.profile === "static";
+  return project_profile.parse_profile(josh.profile) === "basic";
 }
-function read_manifest(directory) {
+function read_manifest2(directory) {
   try {
     const manifest_path = path5.join(project_root(directory), PACKAGE_JSON);
     return JSON.parse(readFileSync5(manifest_path, "utf8"));
@@ -2297,11 +2215,11 @@ function read_manifest(directory) {
     return void 0;
   }
 }
-function is_static(directory) {
-  return is_static_manifest(read_manifest(directory));
+function is_basic(directory) {
+  return is_basic_manifest(read_manifest2(directory));
 }
 function is_declared(directory, package_name) {
-  const manifest = object_schema.safeParse(read_manifest(directory));
+  const manifest = object_schema.safeParse(read_manifest2(directory));
   if (!manifest.success) return false;
   return DEPENDENCY_FIELDS.some((field) => {
     const dependencies = object_schema.safeParse(manifest.data[field]);
@@ -2316,18 +2234,18 @@ function skip_notice(check3, reason) {
   return `josh ${check3}: ${reason} ${SKIP_MARKER} ${check3}.`;
 }
 function type_check_skip_reason(directory) {
-  if (!is_static(directory)) return void 0;
+  if (!is_basic(directory)) return void 0;
   if (!has_files(directory, TYPE_FILES)) return "no TypeScript files were found";
   if (!has_config(directory, TYPE_CONFIGS)) return "no TypeScript configuration was found";
   return missing_tool_reason(directory, "typescript", "tsc");
 }
 function prettier_skip_reason(directory) {
-  if (!is_static(directory)) return void 0;
+  if (!is_basic(directory)) return void 0;
   if (!has_files(directory, WEB_FILES)) return "no HTML, CSS or JavaScript files were found";
   return missing_tool_reason(directory, "prettier", "prettier");
 }
 function eslint_skip_reason(directory) {
-  if (!is_static(directory)) return void 0;
+  if (!is_basic(directory)) return void 0;
   if (!has_files(directory, SCRIPT_FILES)) return "no JavaScript or TypeScript files were found";
   if (!has_config(directory, ESLINT_CONFIGS)) return "no ESLint configuration was found";
   return missing_tool_reason(directory, "eslint", "eslint");
@@ -2343,7 +2261,7 @@ var project_checks = {
   has_bin,
   has_config,
   has_files,
-  is_static,
+  is_basic,
   prettier_skip_reason,
   project_root,
   skip_notice,
@@ -2355,34 +2273,59 @@ var TEST_SUFFIXES = [".e2e.ts", ".test.ts"];
 var EXEMPT_PATHS = [".editorconfig"];
 var EXEMPT_PREFIXES = [".idea/", ".vscode/", "prompts/"];
 var EXEMPT_SUFFIXES = [".md"];
-var STATIC_VISUAL_SUFFIXES = [".html", ".css"];
+var BASIC_VISUAL_SUFFIXES = [".html", ".css"];
+var BASIC_REQUIRED_SUFFIXES = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".json",
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+];
 function normalize(paths) {
   return paths.map((path7) => path7.trim()).filter((path7) => path7 !== "");
 }
 function is_test_file(path7) {
   return TEST_SUFFIXES.some((suffix) => path7.endsWith(suffix));
 }
-function is_static_visual(path7, is_static2) {
-  return is_static2 && STATIC_VISUAL_SUFFIXES.some((suffix) => path7.endsWith(suffix));
+function is_basic_manual(path7, is_basic2) {
+  const lower = path7.toLowerCase();
+  return is_basic2 && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
+}
+function is_basic_visual(path7) {
+  const lower = path7.toLowerCase();
+  return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
 }
-function is_exempt(path7, is_static2 = false) {
-  if (EXEMPT_PATHS.includes(path7) || is_static_visual(path7, is_static2)) return true;
+function is_exempt(path7, is_basic2 = false) {
+  if (EXEMPT_PATHS.includes(path7) || is_basic_manual(path7, is_basic2)) return true;
   return EXEMPT_SUFFIXES.some((suffix) => path7.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path7.startsWith(prefix));
 }
-function is_runtime(path7, is_static2 = false) {
-  return !is_test_file(path7) && !is_exempt(path7, is_static2);
+function is_runtime(path7, is_basic2 = false) {
+  return !is_test_file(path7) && !is_exempt(path7, is_basic2);
 }
-function verdict_for(paths, is_static2 = false) {
+function verdict_for(paths, is_basic2 = false) {
   const changed = normalize(paths);
   if (changed.some((path7) => is_test_file(path7))) return "satisfied";
-  if (changed.some((path7) => is_runtime(path7, is_static2))) return "required";
+  if (changed.some((path7) => is_runtime(path7, is_basic2))) return "required";
   return "exempt";
 }
-function runtime_files(paths, is_static2 = false) {
-  return normalize(paths).filter((path7) => is_runtime(path7, is_static2));
+function runtime_files(paths, is_basic2 = false) {
+  return normalize(paths).filter((path7) => is_runtime(path7, is_basic2));
+}
+function exempt_files(paths, is_basic2 = false) {
+  return normalize(paths).filter((path7) => is_exempt(path7, is_basic2));
 }
-function exempt_files(paths, is_static2 = false) {
-  return normalize(paths).filter((path7) => is_exempt(path7, is_static2));
+function manual_check_files(paths, is_basic2) {
+  return normalize(paths).filter((path7) => is_exempt(path7, is_basic2) && !is_exempt(path7));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -2390,9 +2333,11 @@ var test_declared_logic = {
   EXEMPT_SUFFIXES,
   TEST_SUFFIXES,
   exempt_files,
+  is_basic_visual,
   is_exempt,
   is_runtime,
   is_test_file,
+  manual_check_files,
   runtime_files,
   verdict_for
 };
@@ -2421,7 +2366,7 @@ function source_paths() {
   return injected.paths ?? read_changed_paths_sync();
 }
 function current_verdict(paths = source_paths()) {
-  return test_declared_logic.verdict_for(paths, project_checks.is_static(process.cwd()));
+  return test_declared_logic.verdict_for(paths, project_checks.is_basic(process.cwd()));
 }
 function restore_injection(previous) {
   if (previous === void 0) {
@@ -2447,8 +2392,8 @@ function is_untested_commit(call) {
   return test_declared_changed.current_verdict() === "required";
 }
 var REASON = '\u26D4 test declared: this commits a runtime code change with no test beside it \u2014 `pnpm josh test:declared` reads the working tree as `required` (a changed file that is neither a test \u2014 `*.test.ts` / `*.e2e.ts` \u2014 nor a mechanically-exempt non-runtime path). `CLAUDE.md` \u2192 Code Change Rules requires a test for ALL code changes: a bug fix gets a regression test, a refactor gets tests pinning behavior first, logic gets a unit test, an observable UI/timing change gets an E2E. Add the declared test and reissue this commit. **If the change genuinely touches no executable runtime path** it is the pre-approved non-runtime exception \u2014 declare it in your Step 0 work summary with the reason it is exempt (non-executable config, a cosmetic asset swap) and reissue; the exception is a presentation, not a stop. Run `pnpm josh test:declared` to see the files it names. The procedure is `prompts/collaboration-workflow/rule-delivery.md` \u2192 "\u914D\u9001\u3055\u308C\u3066\u3044\u308B\u898F\u5247". This fires once per run, so reissuing will not repeat on the call in hand.';
-var ROW14 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
-var test_declared_commit = { REASON, ROW: ROW14, is_untested_commit };
+var ROW13 = { id: "test-declared", is_trigger: is_untested_commit, reason: REASON };
+var test_declared_commit = { REASON, ROW: ROW13, is_untested_commit };
 
 // scripts/rules/third-party-write.ts
 function is_third_party_write_segment(segment, session_owner) {
@@ -2464,14 +2409,14 @@ function writes_third_party(command, resolve_owner = repo_party.current_owner) {
   return targets.some((segment) => is_third_party_write_segment(segment, session_owner));
 }
 var THIRD_PARTY_WRITE_REASON = '\u26D4 third-party write: this `gh api` call writes to a repository whose owner is not this session \u2014 a tracker we do not own is Tier C, and every write there (Issue, comment, PR, Discussion, review) needs explicit current-turn user instruction; typing the target, or holding a correct diagnosis, is not that instruction (`CLAUDE.md` \u2192 "Third-party repositories are Tier C", `prompts/collaboration-workflow/upstream-interrupt.md`). Confirm the party with `pnpm josh repo:party <owner/repo>` \u2014 owner equality, computed not judged. A read (`-X GET`, or no field flag) passes untouched; only a write (`-f`/`-F`/`--field`/`--raw-field`/`--input`, or `-X POST|PATCH|PUT|DELETE`) is refused. Record the finding on our own Issue and draft the artifact for a person to post \u2014 do not publish it yourself. **This rule fires on every occurrence, not once per run.**';
-var ROW15 = {
+var ROW14 = {
   id: "third-party-write",
   is_trigger: bash_triggers.on_bash_command((command) => writes_third_party(command)),
   reason: THIRD_PARTY_WRITE_REASON,
   decide: () => true
 };
 var third_party_write = {
-  ROW: ROW15,
+  ROW: ROW14,
   THIRD_PARTY_WRITE_REASON,
   is_third_party_write_segment,
   writes_third_party
@@ -2525,14 +2470,14 @@ function is_unauthorized_worktree_change(command) {
   return shell_segments.segments_of(command).some((segment) => is_unauthorized_segment(segment));
 }
 var WORKTREE_MUTATION_REASON = '\u26D4 unauthorized working-tree change: `git checkout -- <path>`, `git restore <path>` and an unauthorized `git stash` mutate the working tree or the repository-wide stash every work tree shares, and none is on the `.claude/settings.json` deny list (`operating-rules.md`). Do not run them on your own judgement. A commit goes through `pnpm josh git`; a stash pop goes through `pnpm josh stash:pop "<message>"`, never a positional `git stash pop` a shared stack lets another lane divert. A stash push is authorized only inside a documented flow and only with a findable message \u2014 `git stash push -u -m "<message>"` \u2014 which this row allows; a bare `git stash`, a message-less push, or `pop` / `apply` / `drop` is refused. **This rule fires on every occurrence, not once per run.**';
-var ROW16 = {
+var ROW15 = {
   id: "worktree-mutation",
   is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
   reason: WORKTREE_MUTATION_REASON,
   decide: () => true
 };
 var worktree_guard = {
-  ROW: ROW16,
+  ROW: ROW15,
   WORKTREE_MUTATION_REASON,
   is_unauthorized_stash,
   is_unauthorized_worktree_change,
@@ -2569,7 +2514,7 @@ function is_body_only_issue_read(command) {
   if (segments.some((segment) => fetches_issue_comments(segment))) return false;
   return segments.some((segment) => is_body_read_segment(segment));
 }
-var ISSUE_COMMENTS_REASON = "\u26D4 an Issue's comments are part of the Issue: read them before implementing, not only the body. A decision recorded after the body was written lives only in a comment \u2014 a corrected diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion (joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) \u2014 and nothing in the body says it was superseded, so a body-only reader builds the wrong thing and sees no contradiction. Reissue this read with the comments included: `gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. Then the later text is the agreement in force \u2014 a comment supersedes the body it contradicts \u2014 except for two answers that are not the run's to make: work a comment reassigns to another Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a reason to exist stops the run with a `confirmation` Telegram. The procedure is `.claude/skills/workflow-commands/SKILL.md` \u2192 \"An Issue's comments are part of the Issue\". It fires once per run and cannot repeat on the call in hand.";
+var ISSUE_COMMENTS_REASON = "\u26D4 an Issue's comments are part of the Issue: read them before implementing, not only the body. A decision recorded after the body was written lives only in a comment \u2014 a corrected diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion (joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) \u2014 and nothing in the body says it was superseded, so a body-only reader builds the wrong thing and sees no contradiction. Reissue this read with the comments included: `gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable. Then the later text is the agreement in force \u2014 a comment supersedes the body it contradicts \u2014 except for two answers that are not the run's to make: work a comment reassigns to another Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a reason to exist stops the run with a `confirmation` Telegram. The procedure is `.claude/skills/workflow-commands/SKILL.md` \u2192 \"An Issue's comments are part of the Issue\". Every body-only read is refused until the comments are read.";
 var { SHELL_BODY_REASON: SHELL_BODY_REASON2, carries_a_body: carries_a_body2, is_shell_evaluated_body: is_shell_evaluated_body2, keeps_body_safe: keeps_body_safe2 } = shell_body_trigger;
 var ISSUE_LISTING = /^gh\s+(?:-{1,2}[\w-]+(?:[= ]\S+)?\s+)*issue\s+list\b/u;
 var ISSUES_QUERY = /repos\/[^\s'"]*\/issues\?[^\s'"]*state=open/u;
@@ -2593,26 +2538,24 @@ var DELIVERED_RULES = [
   // before any of those speak; on a first-party filing it is silent (the owners match), so `wip-cap`
   // still speaks first, exactly as before. It fires on every occurrence (`git-force.ts`).
   third_party_write.ROW,
+  // **A hand-built filing is refused on every occurrence** (joshuafolkken/kit#2808) and pointed at
+  // `josh issue:file`, which runs the scout, the lint, the labels, the `## Origin` check and
+  // `epic:bundle` itself. It claims the direct call only, so the rows below — which trigger on the
+  // `issue:file` call — never overlap it.
+  direct_filing.ROW,
   {
     id: "wip-cap",
     is_trigger: on_bash_command(is_issue_filing),
     reason: WIP_CAP_REASON,
     keeps: on_bash_command(counts_open_issues)
   },
-  // **Three rows share the filing trigger** (joshuafolkken/kit#2119), listed after `wip-cap` so the
-  // backlog count still speaks first: `issue-scout` refuses a filing the run has not scouted (once per
-  // run, stood down once the scout is on the tail), and `filing-cap` refuses every filing past the
-  // per-run ceiling. Each is a real instance of the admissible overlap the comment on `delivery`
-  // describes — the losing rule's delivery is still correct one reissue later — so a scout-less,
-  // over-cap filing is delivered `wip-cap`, then `issue-scout`, then `filing-cap` across its reissues.
-  issue_scout.ROW,
+  // **Two more rows share the filing trigger** (joshuafolkken/kit#2119, joshuafolkken/kit#2213), listed
+  // after `wip-cap` so the backlog count still speaks first: `filing-cap` refuses every filing past
+  // the per-run ceiling, and `issue-fold` refuses a *second* filing the run has not folded. Each is a
+  // real instance of the admissible overlap the comment on `delivery` describes — the losing rule's
+  // delivery is still correct one reissue later — so an unfolded, over-cap second filing is delivered
+  // `wip-cap`, then `filing-cap`, then `issue-fold` across its reissues.
   filing_cap.ROW,
-  // **`issue-fold` shares the same filing trigger** (joshuafolkken/kit#2213), listed after
-  // `filing-cap`: it refuses a *second* filing the run has not folded, once per run, stood down off
-  // the tail when the run has already folded or has filed nothing earlier. It is another instance of
-  // the admissible overlap — the losing rule's delivery is still correct one reissue later — so a
-  // scout-less, unfolded, over-cap second filing is delivered `wip-cap`, then `issue-scout`, then
-  // `filing-cap`, then `issue-fold` across its reissues.
   issue_fold.ROW,
   {
     id: "issue-comments",
@@ -2839,13 +2782,9 @@ var DELIVERED_RULES = [
   rule_body_guard.ROW,
   // **The generic oracle-consulted rows, one per oracle that declared a firing point**
   // (joshuafolkken/kit#2324). Each refuses the action the oracle governs when the run has not run that
-  // oracle's command first, stood down once it has — `issue-scout`'s shape read from the registry
-  // rather than hand-written. Listed last so an oracle whose firing point overlaps a filing
-  // (`issue:lint`) delivers on the reissue, after `wip-cap` / `issue-scout` / `filing-cap` /
-  // `issue-fold` have each had their turn. The non-overlapping firing point (`pkg:scout` on a package
-  // add) claims a command no row above matches.
-  ...oracle_consulted.ROWS,
-  issue_bug_label_rule.ROW
+  // oracle's command first, stood down once it has. Listed last; the one firing point left
+  // (`pkg:scout` on a package add) claims a command no row above matches.
+  ...oracle_consulted.ROWS
 ];
 var ALONE_IN_TURN = 1;
 function batches_the_turn(call, turn) {
@@ -2879,12 +2818,12 @@ function is_first_delivery(tail, call, delivered_at_ms, run2) {
   return delivered_at_ms === hook_decision.NEVER_MS && !will_batch_guard_refuse(tail, call, run2);
 }
 function delivery_decision(rule) {
-  const { decide: decide6, already_satisfied } = rule;
-  if (decide6 === void 0 && already_satisfied === void 0) return is_first_delivery;
+  const { decide: decide5, already_satisfied } = rule;
+  if (decide5 === void 0 && already_satisfied === void 0) return is_first_delivery;
   return function should_block(tail, call, delivered_at_ms, run2) {
     if (already_satisfied?.(tail, call) === true) return false;
-    if (decide6 === void 0) return is_first_delivery(tail, call, delivered_at_ms, run2);
-    return decide6(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
+    if (decide5 === void 0) return true;
+    return decide5(call, run2, !will_batch_guard_refuse(tail, call, run2), delivered_at_ms);
   };
 }
 function guard_of(rule) {
@@ -2914,11 +2853,11 @@ var delivered_rules = {
   DELIVERED_RULES,
   EARLY_HEARTBEAT_REASON: early_heartbeat.EARLY_HEARTBEAT_REASON,
   FILE_BODY_REASON: file_body.FILE_BODY_REASON,
+  DIRECT_FILING_REASON: direct_filing.DIRECT_FILING_REASON,
   FILING_CAP_REASON: filing_cap.FILING_CAP_REASON,
   GIT_FORCE_REASON: git_force.GIT_FORCE_REASON,
   ISSUE_COMMENTS_REASON,
   ISSUE_FOLD_REASON: issue_fold.ISSUE_FOLD_REASON,
-  ISSUE_SCOUT_REASON: issue_scout.ISSUE_SCOUT_REASON,
   LANE_INTERACTIVE_ASK_REASON: lane_interactive_ask.LANE_INTERACTIVE_ASK_REASON,
   LANE_PARK_REASON: lane_park.LANE_PARK_REASON,
   MEASURED_RULES,
@@ -3590,7 +3529,7 @@ var git_gh_issue = {
 // scripts/ci/pr-classification.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { execaSync } from "execa";
+import { execaSync as execaSync2 } from "execa";
 import { z as z8 } from "zod";
 var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
 var ISSUE_BUG_LABEL = "bug";
@@ -3644,7 +3583,7 @@ function select_issue_classification(issue_json) {
   return label;
 }
 function fetch_current_labels(repository, pull_number) {
-  const result = execaSync(
+  const result = execaSync2(
     "gh",
     ["api", `repos/${repository}/issues/${String(pull_number)}/labels`, "--jq", ".[].name"],
     { reject: false }
@@ -4984,7 +4923,7 @@ function to_advice(verdict, has_work_to_stash) {
   if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
   return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
 }
-function decide4(traces) {
+function decide3(traces) {
   const verdict = to_verdict(traces);
   const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
   return {
@@ -5083,11 +5022,11 @@ async function read_traces(request) {
 }
 async function check(request) {
   run_issue_number.require_issue_number(request.issue);
-  return decide4(await read_traces(request));
+  return decide3(await read_traces(request));
 }
 var run_liveness = {
   check,
-  decide: decide4,
+  decide: decide3,
   describe_agent_state,
   read_child_settled,
   read_agent_state,
@@ -5237,7 +5176,7 @@ function to_advice2(verdict, issue, tree) {
   if (verdict === PARK_VERDICT) return PARK_ADVICE;
   return CLEAN_ADVICE;
 }
-function decide5(tree, child, issue) {
+function decide4(tree, child, issue) {
   const verdict = to_verdict2(tree, child);
   return {
     advice: to_advice2(verdict, issue, tree),
@@ -5306,8 +5245,8 @@ async function read_child_state(issue) {
 async function check2(issue) {
   require_issue_number(issue);
   const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide5(tree, NO_CHILD_WORK, issue);
-  return decide5(tree, await read_child_state(issue), issue);
+  if (needs_reclaim(tree)) return decide4(tree, NO_CHILD_WORK, issue);
+  return decide4(tree, await read_child_state(issue), issue);
 }
 var run_preflight = {
   CLEAN_ADVICE,
@@ -5322,7 +5261,7 @@ var run_preflight = {
   MERGED_PR,
   STASH_LABEL_PREFIX,
   check: check2,
-  decide: decide5,
+  decide: decide4,
   read_child_state,
   read_pr_state: read_pr_state2,
   to_pr_state: to_pr_state2