@joshuafolkken/kit 1.1387.0 → 1.1453.0

package/dist/hooks/{chunk-GJ7JPIHN.js → chunk-5C7L6FRC.js}

@@ -1,6 +1,6 @@
 import {
   duplicate_read_outcome
-} from "./chunk-DCY2GWHC.js";
+} from "./chunk-SHYUQOIS.js";
 import {
   ALREADY_DONE_LABEL,
   CONTEXT_CUT_THRESHOLD,
@@ -9,10 +9,14 @@ import {
   NEEDS_HUMAN_REVIEW_LABEL,
   bash_triggers,
   filing_cap,
+  git_gh_api_path,
   git_gh_command,
+  git_gh_exec,
   git_gh_issue_read,
   git_gh_pr_read,
   has_any_label,
+  has_stdout_field,
+  issue_watch_diff,
   lane_background,
   lane_park,
   parse_json_object_or_undefined,
@@ -25,11 +29,15 @@ import {
   session_cite,
   shell_segments,
   tail_commands
-} from "./chunk-GNDJ7NJ7.js";
+} from "./chunk-Y3GKIKGW.js";
 import {
   ancestor_directories,
-  find_local_bin_upwards
-} from "./chunk-JBBMAPC4.js";
+  find_local_bin_upwards,
+  json_object_schema,
+  string_array_schema,
+  string_record_schema,
+  vscode_settings_schema
+} from "./chunk-IX6TTTI6.js";
 import {
   agent_role_profile,
   agent_session_role,
@@ -40,26 +48,27 @@ import {
   run_event_scope,
   run_event_stream,
   run_event_stream_emit,
-  run_headless
-} from "./chunk-U32VSRNG.js";
+  run_headless,
+  session_language
+} from "./chunk-Z4XI7CZS.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
 import {
   batch_outcome
-} from "./chunk-LMWBRJIP.js";
+} from "./chunk-EF5GQ6WS.js";
 import {
   investigation_refusal
-} from "./chunk-IYVOLN6A.js";
+} from "./chunk-LBFYEOXJ.js";
 import {
   investigation_reads
-} from "./chunk-WNFJLBXI.js";
+} from "./chunk-NO4AALP5.js";
 import {
   lane_guard_policy
-} from "./chunk-EAQEGME7.js";
+} from "./chunk-UT7YC3N2.js";
 import {
   hook_decision
-} from "./chunk-EBSHN25W.js";
+} from "./chunk-W5ZKGTSY.js";
 import {
   cost_attribute,
   cost_blocks,
@@ -67,11 +76,12 @@ import {
   time_batch_guard,
   time_density_hook,
   time_shell
-} from "./chunk-SL4GQ2XP.js";
+} from "./chunk-MBJYQPEK.js";
 import {
   lane_child_marker
-} from "./chunk-J3KSS7II.js";
+} from "./chunk-OLMO72ON.js";
 import {
+  GIT_LOCATION_VARIABLES,
   PORCELAIN_FLAG,
   cli_flags,
   cost_transcript,
@@ -84,13 +94,424 @@ import {
   lane_paths,
   own_session,
   run_carry
-} from "./chunk-2YSW3CXH.js";
+} from "./chunk-3C4XRYG6.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
+  PROJECT_ROOT,
+  package_path,
   platform_temporary,
   stamp_file
-} from "./chunk-NEC4AT4Z.js";
+} from "./chunk-DGT54IH5.js";
+
+// scripts/gh/git-gh-conditional.ts
+var NOT_MODIFIED_STATUS = 304;
+var OK_STATUS = 200;
+var INCLUDE_FLAG = "--include";
+var HEADER_FLAG = "-H";
+var IF_NONE_MATCH = "If-None-Match: ";
+var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
+var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
+var UNCHANGED = { kind: "unchanged" };
+var UNREADABLE = { kind: "unreadable" };
+function to_args(path16, etag) {
+  const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
+  return ["api", INCLUDE_FLAG, ...header, path16];
+}
+function to_changed(output) {
+  const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
+  const etag = ETAG_HEADER.exec(headers)?.groups?.["etag"];
+  return { kind: "changed", etag, body: rest.join("\n\n") };
+}
+function to_read(output) {
+  return git_gh_exec.parse_status_line(output) === OK_STATUS ? to_changed(output) : UNREADABLE;
+}
+function failure_status(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
+}
+async function read_conditional(path16, etag, timeout_ms) {
+  try {
+    return to_read(await git_gh_exec.exec_gh_command(to_args(path16, etag), timeout_ms));
+  } catch (error) {
+    return failure_status(error) === NOT_MODIFIED_STATUS ? UNCHANGED : UNREADABLE;
+  }
+}
+var git_gh_conditional = { read_conditional, to_args };
+
+// scripts/issue/issue-watch.ts
+import { z } from "zod";
+var RECORD_PREFIX = "josh-issue-watch-";
+var CLOSED_STATE = "closed";
+var record_schema = z.object({
+  issue: z.string(),
+  body: z.string(),
+  last_comment_id: z.number(),
+  acknowledged_at: z.string(),
+  checked_at: z.string(),
+  etag: z.string().optional(),
+  pending: z.string().optional(),
+  shown: z.string().optional()
+});
+var issue_schema = z.looseObject({ body: z.string().nullish(), state: z.string() });
+var UNREADABLE2 = { kind: "unreadable" };
+function record_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(RECORD_PREFIX, root);
+}
+function read_record(root) {
+  const raw = stamp_file.read_stamp_text(record_path(root));
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
+}
+function write_record(record, root) {
+  stamp_file.replace_stamp(record_path(root), record);
+  return record;
+}
+function clear(root) {
+  stamp_file.remove_stamp(record_path(root));
+}
+async function read_snapshot(request2, body, etag) {
+  const comments = issue_watch_diff.parse_comments(
+    await git_gh_issue_read.issue_list_comments(request2.issue, request2.timeout_ms)
+  );
+  return comments === void 0 ? UNREADABLE2 : { kind: "read", snapshot: { body, comments }, etag };
+}
+async function fetch_issue(request2) {
+  const read2 = await git_gh_conditional.read_conditional(
+    git_gh_api_path.issue_api_path(request2.issue),
+    request2.etag,
+    request2.timeout_ms
+  );
+  if (read2.kind !== "changed") return read2;
+  const fields = json_value.parse_with(read2.body, issue_schema);
+  if (fields === void 0) return UNREADABLE2;
+  if (fields.state === CLOSED_STATE) return { kind: "closed" };
+  return await read_snapshot(request2, fields.body ?? "", read2.etag);
+}
+function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
+  const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
+  const checked_at = now.toISOString();
+  return { issue, ...baseline, acknowledged_at, checked_at, etag: fetched.etag };
+}
+async function record_baseline(issue, root, now = /* @__PURE__ */ new Date()) {
+  const fetched = await fetch_issue({ issue });
+  if (fetched.kind !== "read") return false;
+  write_record(fresh_record(issue, fetched, now), root);
+  return true;
+}
+async function record_baseline_here(issue) {
+  return await record_baseline(issue, await git_command.repository_root());
+}
+async function clear_here() {
+  clear(await git_command.repository_root());
+}
+function with_fetched(record, fetched, checked_at) {
+  if (fetched.kind !== "read") return { ...record, checked_at };
+  const pending = issue_watch_diff.unread_diff(record, fetched.snapshot);
+  return { ...record, checked_at, etag: fetched.etag, pending };
+}
+function is_due(record, options, now) {
+  return now.getTime() - Date.parse(record.checked_at) >= options.interval_ms;
+}
+async function refresh(record, options, now, root) {
+  const fetched = await fetch_issue({
+    issue: record.issue,
+    etag: record.etag,
+    timeout_ms: options.timeout_ms
+  });
+  if (fetched.kind === "closed") {
+    clear(root);
+    return void 0;
+  }
+  return write_record(with_fetched(record, fetched, now.toISOString()), root);
+}
+async function poll(options, root) {
+  const record = read_record(root);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  if (record === void 0 || !is_due(record, options, now)) return record;
+  return await refresh(record, options, now, root);
+}
+function mark_shown(record, root) {
+  return write_record({ ...record, shown: record.pending }, root);
+}
+async function acknowledge(root, now = /* @__PURE__ */ new Date()) {
+  const record = read_record(root);
+  if (record === void 0) return void 0;
+  const fetched = await fetch_issue({ issue: record.issue });
+  if (fetched.kind !== "read") return void 0;
+  const diff = issue_watch_diff.unread_diff(record, fetched.snapshot);
+  const acknowledged_at = diff === void 0 ? record.acknowledged_at : now.toISOString();
+  write_record(fresh_record(record.issue, fetched, now, acknowledged_at), root);
+  return { issue: record.issue, diff };
+}
+var issue_watch = {
+  acknowledge,
+  clear,
+  clear_here,
+  mark_shown,
+  poll,
+  read_record,
+  record_baseline,
+  record_baseline_here,
+  record_path
+};
+
+// scripts/review/review-attest.ts
+import { randomBytes } from "node:crypto";
+import { lstatSync } from "node:fs";
+
+// scripts/review/review-checkout.ts
+async function read_checkout() {
+  const [root, branch, head] = await Promise.all([
+    git_command.repository_root(),
+    git_command.branch(),
+    git_command.head_commit()
+  ]);
+  return { root, branch, head };
+}
+function is_same_checkout(expected, actual) {
+  return expected.root === actual.root && expected.branch === actual.branch && expected.head === actual.head;
+}
+function describe_checkout(checkout) {
+  return `${checkout.root} (branch ${checkout.branch}, HEAD ${checkout.head})`;
+}
+var review_checkout = { describe_checkout, is_same_checkout, read_checkout };
+
+// scripts/review/review-attest.ts
+var POINTER_PREFIX = "josh-review-target-";
+var EXPECT_PREFIX = "josh-review-expect-";
+var ATTEST_PREFIX = "josh-review-attest-";
+var NONCE_BYTES = 8;
+var HOURS_BEFORE_STALE = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var STALE_AFTER_MS = HOURS_BEFORE_STALE * MILLISECONDS_PER_HOUR;
+function pointer_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(POINTER_PREFIX, root);
+}
+function expect_path(nonce) {
+  return stamp_file.stamp_path(EXPECT_PREFIX, nonce);
+}
+function attest_path(nonce) {
+  return stamp_file.stamp_path(ATTEST_PREFIX, nonce);
+}
+function read_json(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  return raw === void 0 ? void 0 : json_value.parse_or_undefined(raw);
+}
+function string_field(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+function to_checkout(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const root = string_field(value, "root");
+  const branch = string_field(value, "branch");
+  const head = string_field(value, "head");
+  if (root === void 0 || branch === void 0 || head === void 0) return void 0;
+  return { root, branch, head };
+}
+function to_pointer(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const nonce = string_field(value, "nonce");
+  const taken_at = string_field(value, "taken_at");
+  if (nonce !== void 0 && taken_at !== void 0) return { nonce, taken_at };
+  return void 0;
+}
+function read_pointer(root) {
+  return to_pointer(read_json(pointer_path(root)));
+}
+function read_expectation(nonce) {
+  return to_checkout(read_json(expect_path(nonce)));
+}
+function read_attestation(nonce) {
+  return to_checkout(read_json(attest_path(nonce)));
+}
+function drop_records(pointer) {
+  if (pointer === void 0) return;
+  stamp_file.remove_stamp(expect_path(pointer.nonce));
+  stamp_file.remove_stamp(attest_path(pointer.nonce));
+}
+function is_stale(taken_at, now) {
+  const taken = Date.parse(taken_at);
+  return Number.isNaN(taken) || now - taken > STALE_AFTER_MS;
+}
+function record_target(checkout, root) {
+  const nonce = randomBytes(NONCE_BYTES).toString("hex");
+  const taken_at = (/* @__PURE__ */ new Date()).toISOString();
+  drop_records(read_pointer(root));
+  stamp_file.write_stamp(expect_path(nonce), { ...checkout, taken_at });
+  stamp_file.write_stamp(pointer_path(root), { nonce, taken_at });
+  return nonce;
+}
+function attest(nonce, actual) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce, actual };
+  stamp_file.write_stamp(attest_path(nonce), { ...actual, taken_at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function not_required() {
+  return { status: "not-required" };
+}
+function verdict_for(nonce) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce };
+  const actual = read_attestation(nonce);
+  if (actual === void 0) return { status: "missing", nonce, expected };
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function check(now = Date.now(), root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0) return not_required();
+  const verdict = verdict_for(pointer.nonce);
+  if (verdict.status === "missing" && is_stale(pointer.taken_at, now)) return not_required();
+  return verdict;
+}
+function is_written_since(source, taken_at) {
+  try {
+    const stats = lstatSync(source);
+    return stats.isFile() && stats.mtimeMs >= Date.parse(taken_at);
+  } catch {
+    return false;
+  }
+}
+function is_reviewed_on(checkout, findings_path, root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0) return false;
+  const verdict = verdict_for(pointer.nonce);
+  if (verdict.status !== "ok" || verdict.expected?.branch !== checkout.branch) return false;
+  return is_written_since(findings_path, pointer.taken_at);
+}
+function is_briefed_since(written_at, root) {
+  const pointer = read_pointer(root);
+  return pointer !== void 0 && written_at >= pointer.taken_at;
+}
+async function check_here(now = Date.now()) {
+  return check(now, await git_command.repository_root());
+}
+function clear2(root) {
+  const pointer = read_pointer(root);
+  stamp_file.remove_stamp(pointer_path(root));
+  drop_records(pointer);
+}
+async function clear_here2() {
+  clear2(await git_command.repository_root());
+}
+var MISMATCH_VERDICT = "REVIEW TARGET MISMATCH";
+function describe_side(label, checkout) {
+  if (checkout === void 0) return `${label}: unknown`;
+  return `${label}: ${review_checkout.describe_checkout(checkout)}`;
+}
+var MISSING_REASON = "The review left no attestation, so there is no evidence it read this checkout at all. A review that read the wrong tree finds nothing wrong and reports no findings, which is indistinguishable from a clean review \u2014 so an absent attestation is treated as no review (joshuafolkken/kit#1522).";
+var MISMATCH_REASON = `${MISMATCH_VERDICT}: the review attested a different checkout from the one it was briefed on. Its findings \u2014 including "no findings" \u2014 describe another tree.`;
+var REMEDY = "Re-run `/code-review` with the brief `pnpm josh review:brief` prints, against the checkout named above, and let it run `pnpm josh review:attest <nonce>` from there before it reports.";
+function refusal_message(verdict) {
+  const reason = verdict.status === "mismatch" ? MISMATCH_REASON : MISSING_REASON;
+  return [
+    reason,
+    describe_side("Briefed on", verdict.expected),
+    describe_side("Reviewed", verdict.actual),
+    REMEDY
+  ].join("\n");
+}
+var review_attest = {
+  attest,
+  attest_path,
+  check,
+  check_here,
+  clear: clear2,
+  clear_here: clear_here2,
+  expect_path,
+  is_briefed_since,
+  is_reviewed_on,
+  MISMATCH_VERDICT,
+  MISSING_REASON,
+  pointer_path,
+  read_attestation,
+  read_expectation,
+  read_pointer,
+  record_target,
+  refusal_message,
+  STALE_AFTER_MS
+};
+
+// scripts/issue/issue-watch-gate.ts
+var EVERY_CALL_MS = 0;
+function ack_command(issue) {
+  return `pnpm josh issue:ack ${issue}`;
+}
+function unread_message(record) {
+  return [
+    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
+    record.pending ?? "",
+    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
+  ].join("\n\n");
+}
+function review_message(record, briefed_at) {
+  return [
+    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
+    "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
+  ].join("\n");
+}
+async function polled(root) {
+  return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
+}
+async function unread_refusal(root) {
+  const record = await polled(root);
+  return record?.pending === void 0 ? void 0 : unread_message(record);
+}
+async function review_refusal(root) {
+  const record = await polled(root);
+  if (record === void 0) return void 0;
+  if (record.pending !== void 0) return unread_message(record);
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
+  return review_message(record, pointer.taken_at);
+}
+async function review_refusal_here() {
+  return await review_refusal(await git_command.repository_root());
+}
+async function assert_read_here() {
+  const refusal = await unread_refusal(await git_command.repository_root());
+  if (refusal !== void 0) throw new Error(refusal);
+}
+var issue_watch_gate = {
+  assert_read_here,
+  review_refusal,
+  review_refusal_here,
+  unread_message,
+  unread_refusal
+};
+
+// scripts/issue/issue-watch-hook.ts
+var POLL_INTERVAL_MS = 18e4;
+var POLL_TIMEOUT_MS = 5e3;
+function is_new_to_run(record) {
+  return record?.pending !== void 0 && record.pending !== record.shown;
+}
+async function new_update_reason(now) {
+  const record = await issue_watch.poll({
+    interval_ms: POLL_INTERVAL_MS,
+    timeout_ms: POLL_TIMEOUT_MS,
+    now
+  });
+  if (!is_new_to_run(record)) return void 0;
+  issue_watch.mark_shown(record);
+  return issue_watch_gate.unread_message(record);
+}
+async function watch_reason(now = /* @__PURE__ */ new Date()) {
+  try {
+    return await new_update_reason(now);
+  } catch (error) {
+    error_text.trace_swallowed("issue_watch_hook.watch_reason", error);
+    return void 0;
+  }
+}
+var issue_watch_hook = { POLL_INTERVAL_MS, watch_reason };
 
 // scripts/run/event/run-event-plan.ts
 var KIND = run_event_stream.EVENT_KIND.PLAN;
@@ -224,7 +645,7 @@ function format_line(observations, timing) {
     next: format_next_report(timing.now_ms, timing.interval_ms)
   });
 }
-function is_due(last_report_ms, now_ms, interval_ms) {
+function is_due2(last_report_ms, now_ms, interval_ms) {
   return now_ms - last_report_ms >= interval_ms;
 }
 function minutes_from(raw) {
@@ -255,14 +676,14 @@ var run_progress = {
   format_next_report,
   format_report,
   is_disabled,
-  is_due,
+  is_due: is_due2,
   minutes_from,
   next_state,
   observation_key
 };
 
 // scripts/run/progress/run-progress-clock.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var PROGRESS_PREFIX = "josh-run-progress-";
 var LIFE_PREFIX = "josh-run-progress-life-";
 var LOG_SUFFIX = ".log";
@@ -271,7 +692,7 @@ var MS_PER_MINUTE2 = 6e4;
 var LOG_STALE_MINUTES = 90;
 var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE2;
 var BLOCK_SEPARATOR = "\n\n";
-var report_stamp_schema = z.object({ reported_at: z.string(), line: z.string().optional() });
+var report_stamp_schema = z2.object({ reported_at: z2.string(), line: z2.string().optional() });
 function parse_stamp(raw) {
   const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
   if (!parsed.success) return void 0;
@@ -326,7 +747,7 @@ function stamp_target_of(git_directory) {
 function life_target_of(git_directory) {
   return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
 }
-var life_schema = z.object({ alive: z.literal(true), pinged_at: z.string().optional() });
+var life_schema = z2.object({ alive: z2.literal(true), pinged_at: z2.string().optional() });
 function begin_life(target) {
   stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
 }
@@ -386,10 +807,10 @@ var run_progress_clock = {
 // scripts/run/progress/run-progress-config.ts
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var PACKAGE_FILE = "package.json";
-var package_schema = z2.object({
-  josh: z2.object({ progress_interval_minutes: z2.number().positive() }).optional()
+var package_schema = z3.object({
+  josh: z3.object({ progress_interval_minutes: z3.number().positive() }).optional()
 });
 function read_declared_minutes(directory) {
   try {
@@ -707,18 +1128,18 @@ import { fileURLToPath } from "node:url";
 // scripts/cost-runtime/codex-usage.ts
 import { globSync, readFileSync as readFileSync2 } from "node:fs";
 import path2 from "node:path";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
-var SESSION_META_SCHEMA = z3.looseObject({
-  type: z3.literal("session_meta"),
-  payload: z3.looseObject({ id: z3.string(), cwd: z3.string() })
+var SESSION_META_SCHEMA = z4.looseObject({
+  type: z4.literal("session_meta"),
+  payload: z4.looseObject({ id: z4.string(), cwd: z4.string() })
 });
-var TOTAL_USAGE_SCHEMA = z3.looseObject({ input_tokens: z3.number().nonnegative() });
-var TOKEN_COUNT_SCHEMA = z3.looseObject({
-  type: z3.literal("event_msg"),
-  payload: z3.looseObject({
-    type: z3.literal("token_count"),
-    info: z3.looseObject({
+var TOTAL_USAGE_SCHEMA = z4.looseObject({ input_tokens: z4.number().nonnegative() });
+var TOKEN_COUNT_SCHEMA = z4.looseObject({
+  type: z4.literal("event_msg"),
+  payload: z4.looseObject({
+    type: z4.literal("token_count"),
+    info: z4.looseObject({
       total_token_usage: TOTAL_USAGE_SCHEMA,
       last_token_usage: TOTAL_USAGE_SCHEMA
     })
@@ -948,8 +1369,8 @@ function selected_threshold(values) {
 function threshold_option(over) {
   return over === void 0 ? {} : { over };
 }
-function path_option(path10) {
-  return path10 === void 0 ? {} : { path: path10 };
+function path_option(path16) {
+  return path16 === void 0 ? {} : { path: path16 };
 }
 function to_options(values) {
   if (values.cut === true && values.over !== void 0) return void 0;
@@ -1088,7 +1509,7 @@ var cost_format = {
 };
 
 // scripts/rules/implementation-cut-verdict.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
 var VERDICT_REUSE_MS = 5e3;
 var VERDICT_VALUES = [
@@ -1096,7 +1517,7 @@ var VERDICT_VALUES = [
   "under",
   "unmeasurable"
 ];
-var cache_schema = z4.object({ read_at_ms: z4.number(), verdict: z4.enum(VERDICT_VALUES) });
+var cache_schema = z5.object({ read_at_ms: z5.number(), verdict: z5.enum(VERDICT_VALUES) });
 function cache_path(directory) {
   return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
 }
@@ -1173,7 +1594,7 @@ function is_over_threshold_edit(call, state = current_state()) {
   return warrants_the_cut(state);
 }
 var THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
-var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for this issue (joshuafolkken/kit#2760), and its recent-context cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated so far is now re-read on every later request. Take the cut before this edit. First write a handoff file at \`${run_cut_handoff.HANDOFF_PATH}\` (ignored, so it is never committed) with the Write tool \u2014 the user\u2019s instruction verbatim, what you have completed, what remains, and what you deliberately did not touch, as ${run_cut_handoff.HANDOFF_FORMAT} (Markdown is refused) \u2014 and pass it as \`--handoff <path>\`, so the fresh process resumes on the original instruction rather than the working tree alone (joshuafolkken/kit#2354); a resume that finds no instruction is refused \`incomplete\` rather than continuing blind. \`pnpm josh run:cut --impl <N> --handoff <path>\` ends this process and relaunches a fresh one that resumes back into implementation (\`resume-impl\`), dropping the accumulated context rather than carrying it \u2014 joshuafolkken/kit#1933 built the boundary and joshuafolkken/kit#2310 measured it firing 0 times because the verdict was only ever read at session entry, where the context has not yet grown. The verdict is \`pnpm josh cost --cut\`'s exactly \u2014 the same per-request billed-input statistic against the same threshold, never a second measurement. Issue \`pnpm josh run:cut --impl <N> --handoff <path>\` now and read the verdict: on \`cut\`, **end the turn immediately** \u2014 in a lane the fresh process owns the run and continues implementing, so it must not be waited for; outside a lane nothing is relaunched, so first send the \`confirmation\` Telegram naming the resume command \`fullrun #<N>\` and keep the hold; on \`not-a-lane\`, \`unready\`, \`busy\`, \`failed\` or \`unknown\`, this process carries the run on and the edit is simply the next call. Never relaunch a second process after \`busy\`. This fired because the dispatch mark names this lane or the run hold names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The procedure is \`.claude/skills/workflow-commands/pre-gate-cut.md\`. Reissue this edit once the cut has answered \u2014 an edit reissued right after this refusal passes, so \`busy\` / \`failed\` cannot wedge the run edit after edit; this fires again on the next threshold crossing rather than once per run.`;
+var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for this issue (joshuafolkken/kit#2760), and its recent-context cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated so far is now re-read on every later request. Take the cut before this edit. First write a handoff file at \`${run_cut_handoff.HANDOFF_PATH}\` (ignored, so it is never committed) with the Write tool \u2014 the user\u2019s instruction verbatim, what you have completed, what remains, and what you deliberately did not touch, as ${run_cut_handoff.HANDOFF_FORMAT} (Markdown is refused) \u2014 and pass it as \`--handoff <path>\`, so the fresh process resumes on the original instruction rather than the working tree alone (joshuafolkken/kit#2354); a resume that finds no instruction is refused \`incomplete\` rather than continuing blind. \`pnpm josh run:cut --impl <N> --handoff <path>\` ends this process and relaunches a fresh one that resumes back into implementation (\`resume-impl\`), dropping the accumulated context rather than carrying it \u2014 joshuafolkken/kit#1933 built the boundary and joshuafolkken/kit#2310 measured it firing 0 times because the verdict was only ever read at session entry, where the context has not yet grown. The verdict is \`pnpm josh cost --cut\`'s exactly \u2014 the same per-request billed-input statistic against the same threshold, never a second measurement. Issue \`pnpm josh run:cut --impl <N> --handoff <path>\` now and read the verdict: on \`cut\`, read what the command printed. Where it relaunched a fresh process, **end the turn immediately** \u2014 that process owns the run and continues implementing, so it must not be waited for, and **no Telegram is owed**: a cut that resumes itself leaves a person nothing to act on. Where it printed that nothing was relaunched, do what it prints, then end the turn; on \`not-a-lane\`, \`unready\`, \`busy\`, \`failed\` or \`unknown\`, this process carries the run on and the edit is simply the next call. Never relaunch a second process after \`busy\`. This fired because the dispatch mark names this lane or the run hold names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The procedure is \`.claude/skills/workflow-commands/pre-gate-cut.md\`. Reissue this edit once the cut has answered \u2014 an edit reissued right after this refusal passes, so \`busy\` / \`failed\` cannot wedge the run edit after edit; this fires again on the next threshold crossing rather than once per run.`;
 var REISSUE_WINDOW_MS = 9e4;
 function is_reissued_refusal(now_ms, delivered_at_ms) {
   return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
@@ -1395,20 +1816,20 @@ var lane_carry_conflict = {
 };
 
 // scripts/agent/interactive-ask.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
 function is_interactive_tool(name) {
   return INTERACTIVE_TOOLS.has(name);
 }
-var OPTION_SCHEMA = z5.looseObject({ label: z5.string().optional() });
-var QUESTION_SCHEMA = z5.looseObject({
-  question: z5.string().optional(),
-  options: z5.array(OPTION_SCHEMA).optional()
+var OPTION_SCHEMA = z6.looseObject({ label: z6.string().optional() });
+var QUESTION_SCHEMA = z6.looseObject({
+  question: z6.string().optional(),
+  options: z6.array(OPTION_SCHEMA).optional()
 });
-var ASK_INPUT_SCHEMA = z5.looseObject({ questions: z5.array(QUESTION_SCHEMA).optional() });
-var DENIAL_SCHEMA = z5.looseObject({
-  tool_name: z5.string().optional(),
-  tool_input: z5.unknown().optional()
+var ASK_INPUT_SCHEMA = z6.looseObject({ questions: z6.array(QUESTION_SCHEMA).optional() });
+var DENIAL_SCHEMA = z6.looseObject({
+  tool_name: z6.string().optional(),
+  tool_input: z6.unknown().optional()
 });
 var UNKNOWN_QUESTION = "(question text unavailable)";
 var OPTION_SEPARATOR = " / ";
@@ -2301,20 +2722,20 @@ import path4 from "node:path";
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var NODE_MODULES = "node_modules";
 var SETTINGS_PATH = path4.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 = path4.join(NODE_MODULES, ".bin", "secretlint");
-var manifest_schema = z6.object({
-  name: z6.string().optional(),
-  dependencies: z6.record(z6.string(), z6.string()).optional(),
-  devDependencies: z6.record(z6.string(), z6.string()).optional()
+var manifest_schema = z7.object({
+  name: z7.string().optional(),
+  dependencies: z7.record(z7.string(), z7.string()).optional(),
+  devDependencies: z7.record(z7.string(), z7.string()).optional()
 });
-var settings_schema = z6.object({
-  enabledPlugins: z6.record(z6.string(), z6.boolean()).optional()
+var settings_schema = z7.object({
+  enabledPlugins: z7.record(z7.string(), z7.boolean()).optional()
 });
 var STATE_OK = "ok";
 var STATE_TARGET_MISSING = "target-missing";
@@ -2358,9 +2779,9 @@ function is_secretlint_runnable(root) {
 function status_line(is_ok, ok_text, warn_text) {
   return is_ok ? `  \u2713 ${ok_text}` : `  \u26A0 ${warn_text}`;
 }
-function plugin_line(is_declared2) {
+function plugin_line(is_declared3) {
   return status_line(
-    is_declared2,
+    is_declared3,
     "kit plugin declared (skills load in a trusted workspace; headless from its second session)",
     "kit plugin not declared in .claude/settings.json \u2014 run `pnpm josh sync`"
   );
@@ -2653,7 +3074,7 @@ function is_uncut_gate(command, state = current_state2()) {
   if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
   return warrants_the_cut2(state.context_verdict());
 }
-var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at, so take the cut before running it. `pnpm josh run:cut <N>` ends this process and relaunches a fresh one that resumes from the gate, dropping the thinking built up while implementing rather than carrying it on every later request \u2014 joshuafolkken/kit#1839 measured 176K of 204K output riding across that boundary, and joshuafolkken/kit#1864 measured the step itself firing 0 times in 6 lane children while it was carried as prose. Issue `pnpm josh run:cut <N>` now, and read the verdict: on `cut`, **end the turn immediately** \u2014 the fresh process owns the run from there and must not be waited for; on `not-a-lane`, `unready`, `busy`, `failed` or `unknown`, this process carries the run on and the gate is simply the next call. Never relaunch a second process after `busy`. This fired because the dispatch mark names this lane; a person working here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue the gate once the cut has answered \u2014 this fires once per run, so it cannot repeat on the call in hand.";
+var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at, so take the cut before running it. `pnpm josh run:cut <N>` ends this process and relaunches a fresh one that resumes from the gate, dropping the thinking built up while implementing rather than carrying it on every later request \u2014 joshuafolkken/kit#1839 measured 176K of 204K output riding across that boundary, and joshuafolkken/kit#1864 measured the step itself firing 0 times in 6 lane children while it was carried as prose. Issue `pnpm josh run:cut <N>` now, and read the verdict: on `cut`, **end the turn immediately** \u2014 the fresh process owns the run from there and must not be waited for, and **no Telegram is owed** for a cut that resumes itself; on `not-a-lane`, `unready`, `busy`, `failed` or `unknown`, this process carries the run on and the gate is simply the next call. Never relaunch a second process after `busy`. This fired because the dispatch mark names this lane; a person working here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue the gate once the cut has answered \u2014 this fires once per run, so it cannot repeat on the call in hand.";
 function reaches_the_pre_gate_boundary(call, _turn, run2) {
   if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
   return run2.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
@@ -2701,7 +3122,7 @@ var MIN_APPENDED_PROSE = 120;
 function adds_rule_prose(old_text, new_text) {
   return prose_of(new_text).length - prose_of(old_text).length >= MIN_APPENDED_PROSE;
 }
-function string_field(input, key) {
+function string_field2(input, key) {
   const value = input[key];
   return typeof value === "string" ? value : "";
 }
@@ -2711,13 +3132,13 @@ function read_existing(file_path) {
 function texts_of(name, input, read2) {
   if (name === WRITE_TOOL) {
     return {
-      old_text: read2(string_field(input, "file_path")),
-      new_text: string_field(input, "content")
+      old_text: read2(string_field2(input, "file_path")),
+      new_text: string_field2(input, "content")
     };
   }
   return {
-    old_text: string_field(input, "old_string"),
-    new_text: string_field(input, "new_string")
+    old_text: string_field2(input, "old_string"),
+    new_text: string_field2(input, "new_string")
   };
 }
 function is_edit_tool2(name) {
@@ -2725,7 +3146,7 @@ function is_edit_tool2(name) {
 }
 function rule_document_input(call) {
   if (!is_edit_tool2(call.name) || !json_value.is_record(call.input)) return void 0;
-  return is_rule_document(string_field(call.input, "file_path")) ? call.input : void 0;
+  return is_rule_document(string_field2(call.input, "file_path")) ? call.input : void 0;
 }
 function writes_rule_prose(call, read2 = read_existing) {
   const input = rule_document_input(call);
@@ -2838,12 +3259,2070 @@ var shell_body_trigger = {
 };
 
 // scripts/gate/project-checks.ts
-import { existsSync as existsSync4, globSync as globSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync7, globSync as globSync2, readFileSync as readFileSync6 } from "node:fs";
+import path13 from "node:path";
+
+// scripts/init/own-formatter.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path6 from "node:path";
+var OWN_FORMATTER_CONFIGS = [
+  "biome.json",
+  "biome.jsonc",
+  "dprint.json",
+  "dprint.jsonc",
+  ".dprint.json",
+  ".dprint.jsonc"
+];
+function find_config(root) {
+  return OWN_FORMATTER_CONFIGS.find((name) => existsSync3(path6.join(root, name)));
+}
+var own_formatter = { find_config };
+
+// scripts/init/project-profile.ts
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5 } from "node:fs";
+import path12 from "node:path";
+
+// scripts/safe-chain/pack-hook.ts
+import { z as z8 } from "zod";
+var PACK_HOOK_FILE = ".pnpmfile.mjs";
+var manifest_schema2 = z8.looseObject({ private: z8.boolean().optional() });
+var MESSAGES = {
+  written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
+  unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
+  private: void 0,
+  owned: `  \u26A0 skipped   ${PACK_HOOK_FILE} \u2014 the project has its own pnpmfile; strip the safe-chain preinstall at pack time there`,
+  withdrawn: `  \u26A0 removed   ${PACK_HOOK_FILE} \u2014 it shadowed the project's own pnpmfile; strip the safe-chain preinstall at pack time there`
+};
+
+// scripts/lib/yaml-document.ts
+import { load, loadAll, YAMLException } from "js-yaml";
+var EMPTY_YAML_REASON = "expected a document, but the input is empty";
+function load_yaml_or_empty(content) {
+  try {
+    return load(content);
+  } catch (error) {
+    if (error instanceof YAMLException && error.reason === EMPTY_YAML_REASON) return {};
+    throw error;
+  }
+}
+function parse_yaml(content) {
+  const raw = load_yaml_or_empty(content);
+  if (raw === null || raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_mapping_document(value) {
+  return json_value.is_record(value);
+}
+function parse_yaml_documents(content) {
+  if (content.trim().length === 0) return [];
+  return loadAll(content).filter(is_mapping_document);
+}
+var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
+
+// scripts/version/release-age.ts
+import semver from "semver";
+import { z as z9 } from "zod";
+var workspace_age_schema = z9.object({ minimumReleaseAge: z9.number().int().nonnegative() });
+var release_times_schema = z9.record(z9.string(), z9.string());
+
+// scripts/safe-chain/project-config.ts
+import { dump } from "js-yaml";
+import { z as z10 } from "zod";
+var PROJECT_CONFIG_FILE = ".aikido";
+var workspace_schema = z10.object({ minimumReleaseAgeExclude: z10.array(z10.string()).optional() });
+
+// scripts/config-merge/json-format.ts
+var PRINT_WIDTH = 100;
+var TAB_WIDTH = 2;
+var ARRAY_CLOSE = /^\t*\],?$/u;
+function is_array_open(line) {
+  return line.endsWith("[");
+}
+function is_leaf_element(line) {
+  return !line.endsWith("{") && !line.endsWith("[");
+}
+function line_width(line) {
+  const tabs = line.length - line.trimStart().length;
+  return tabs * TAB_WIDTH + (line.length - tabs);
+}
+function flatten_elements(elements) {
+  const scalars = elements.map((line) => line.trim().replace(/,$/u, ""));
+  return `[${scalars.join(", ")}]`;
+}
+function collect_block(lines, start) {
+  const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line));
+  if (close === -1) return void 0;
+  const elements = lines.slice(start + 1, close);
+  if (elements.some((line) => !is_leaf_element(line))) return void 0;
+  return { elements, close: lines[close] ?? "", end: close };
+}
+function try_inline(open, block) {
+  const trailing_comma = block.close.trimStart() === "]," ? "," : "";
+  const inlined = `${open.slice(0, -1)}${flatten_elements(block.elements)}${trailing_comma}`;
+  return line_width(inlined) <= PRINT_WIDTH ? inlined : void 0;
+}
+function rewrite_at(lines, index, line) {
+  const verbatim = { lines: [line], next: index + 1 };
+  const block = is_array_open(line) ? collect_block(lines, index) : void 0;
+  if (block === void 0) return verbatim;
+  const inlined = try_inline(line, block);
+  if (inlined === void 0) return verbatim;
+  return { lines: [inlined], next: block.end + 1 };
+}
+function inline_short_arrays(text) {
+  const lines = text.split("\n");
+  const output = [];
+  let index = 0;
+  while (index < lines.length) {
+    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite.lines);
+    index = rewrite.next;
+  }
+  return output.join("\n");
+}
+function format_json(value) {
+  return `${inline_short_arrays(JSON.stringify(value, void 0, "	"))}
+`;
+}
+function format_package_json(value) {
+  return `${JSON.stringify(value, void 0, "	")}
+`;
+}
+var json_format = {
+  format_json,
+  format_package_json
+};
+
+// scripts/safe-chain/preinstall-command.ts
+var INSTALL_GUIDE_ANCHOR = "installing-safe-chain";
+var INSTALL_GUIDE_URL = `https://github.com/joshuafolkken/kit/blob/main/SECURITY.md#${INSTALL_GUIDE_ANCHOR}`;
+var INTEGRATION_HINT = `Warning: safe-chain (@aikidosec/safe-chain) is not scanning this install because its shell integration is not active. Install it with the hash-verified steps at ${INSTALL_GUIDE_URL} - then restart your terminal.`;
+var LOCAL_INTEGRATION_CHECK_SOURCE = `if(!process.env.CI&&!process.env.GLOBAL_AGENT_HTTP_PROXY)console.warn('${INTEGRATION_HINT}')`;
+var SAFE_CHAIN_CMD = `node -e "${LOCAL_INTEGRATION_CHECK_SOURCE}"`;
+var LEGACY_PREINSTALL_RE = /^pnpm dlx @aikidosec\/safe-chain(?:@\S+)? setup-ci(?: && node -e "[^"]*")?$/u;
+function migrate_preinstall(value) {
+  return LEGACY_PREINSTALL_RE.test(value) ? SAFE_CHAIN_CMD : value;
+}
+var safe_chain_preinstall = {
+  SAFE_CHAIN_CMD,
+  LOCAL_INTEGRATION_CHECK_SOURCE,
+  INTEGRATION_HINT,
+  INSTALL_GUIDE_ANCHOR,
+  migrate_preinstall
+};
+
+// scripts/init/distributed-paths.ts
+var KIT_PACKAGE_PATH_PREFIX = "node_modules/@joshuafolkken/kit/";
+var PROMPTS_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}prompts/`;
+var ESLINT_PACKAGE_PREFIX = `${KIT_PACKAGE_PATH_PREFIX}eslint/`;
+var GITHUB_REPO_BLOB_BASE = "https://github.com/joshuafolkken/kit/blob/main/";
+var GITHUB_REPO_TREE_BASE = "https://github.com/joshuafolkken/kit/tree/main/";
+var CLAUDE_MD_IMPORT_LINE = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.md";
+var OLD_CLAUDE_MD_BOOTSTRAP = "> Fresh checkout: if kit is not installed, run `pnpm install` first, then reread this file before doing any other work.";
+var CLAUDE_MD_BOOTSTRAP = '> Fresh checkout: before `pnpm install`, run `pnpm config get "@joshuafolkken:registry"` from the project root to check the effective registry, including user-level settings. If it points to GitHub Packages, [set up authentication](https://github.com/joshuafolkken/kit/blob/main/docs/authentication.md#1-get-a-token-from-the-gh-cli) first. Then run `pnpm install` and reread this file before doing any other work.';
+function transform_prompt_paths(content) {
+  return content.replaceAll(
+    /`prompts\/([^`*]+)`/gu,
+    (_match, prompt_path) => `\`${PROMPTS_PACKAGE_PREFIX}${prompt_path}\``
+  );
+}
+function transform_eslint_paths(content) {
+  return content.replaceAll(
+    /`eslint\/([^`*]+)`/gu,
+    (_match, eslint_path) => `\`${ESLINT_PACKAGE_PREFIX}${eslint_path}\``
+  );
+}
+function transform_test_file_paths(content) {
+  return content.replaceAll(
+    /`([^`*]+\.(?:test|spec)\.ts)`/gu,
+    (_match, test_path) => `\`${GITHUB_REPO_BLOB_BASE}${test_path}\``
+  );
+}
+function github_url_base(reference_path) {
+  return reference_path.endsWith("/") ? GITHUB_REPO_TREE_BASE : GITHUB_REPO_BLOB_BASE;
+}
+function transform_documentation_paths(content) {
+  return content.replaceAll(
+    /`(docs\/[^`*]*)`/gu,
+    (_match, documentation_path) => `\`${github_url_base(documentation_path)}${documentation_path}\``
+  );
+}
+function transform_distributed_paths(content) {
+  const with_prompts = transform_prompt_paths(content);
+  const with_eslint = transform_eslint_paths(with_prompts);
+  const with_tests = transform_test_file_paths(with_eslint);
+  return transform_documentation_paths(with_tests);
+}
+function ensure_claude_md_import(existing) {
+  if (existing === void 0) return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+`;
+  const updated = existing.replace(OLD_CLAUDE_MD_BOOTSTRAP, () => CLAUDE_MD_BOOTSTRAP);
+  if (updated.includes(CLAUDE_MD_IMPORT_LINE)) {
+    if (updated.includes(CLAUDE_MD_BOOTSTRAP)) return updated;
+    return `${CLAUDE_MD_BOOTSTRAP}
+
+${updated}`;
+  }
+  return `${CLAUDE_MD_BOOTSTRAP}
+
+${CLAUDE_MD_IMPORT_LINE}
+
+${updated}`;
+}
+var FULL_CLAUDE_MD_LINES = /* @__PURE__ */ new Set([
+  CLAUDE_MD_BOOTSTRAP,
+  OLD_CLAUDE_MD_BOOTSTRAP,
+  CLAUDE_MD_IMPORT_LINE
+]);
+function remove_claude_md_import(content) {
+  const lines = content.split("\n");
+  return lines.filter((line, index) => {
+    if (FULL_CLAUDE_MD_LINES.has(line)) return false;
+    return line !== "" || !FULL_CLAUDE_MD_LINES.has(lines[index - 1] ?? "");
+  }).join("\n");
+}
+var distributed_paths = {
+  transform_prompt_paths,
+  transform_distributed_paths,
+  ensure_claude_md_import,
+  remove_claude_md_import,
+  CLAUDE_MD_IMPORT_LINE
+};
+
+// scripts/init/init-logic-deploy-vps.ts
+import semver2 from "semver";
+var PNPM_INSTALL_PATTERN = /npm install -g pnpm@\d[\d.]{0,19}/gu;
+var PNPM12_INSTALL = "npm install -g pnpm@12.6.0";
+var MINIMUM_PNPM_VERSION = "12.1.0";
+var OLD_PNPM_CHECK_PATTERN = /^([ \t]*)if ! command -v pnpm &> \/dev\/null(?: \|\| \[ "\$PNPM_MAJOR" -lt \d+ \])?; then$/mu;
+var OLD_MAJOR_LINE_PATTERN = /^[ \t]*PNPM_MAJOR=\$\(pnpm --version 2>\/dev\/null \| cut -d\. -f1 \|\| echo "0"\)\n/mu;
+var VERSION_CHECK_MARKER = '[ "$PNPM_MINOR" -lt 1 ]';
+function replace_outdated_install(command) {
+  const version = command.slice("npm install -g pnpm@".length);
+  const valid_version = semver2.valid(version);
+  if (valid_version === null) return command;
+  return semver2.lt(valid_version, MINIMUM_PNPM_VERSION) ? PNPM12_INSTALL : command;
+}
+function build_version_check(indent) {
+  return [
+    `${indent}PNPM_VERSION=$(pnpm --version 2>/dev/null || echo "0.0.0")`,
+    `${indent}PNPM_MAJOR=$(echo "$PNPM_VERSION" | cut -d. -f1)`,
+    `${indent}PNPM_MINOR=$(echo "$PNPM_VERSION" | cut -d. -f2)`,
+    `${indent}if [ "$PNPM_MAJOR" -lt 12 ] || { [ "$PNPM_MAJOR" -eq 12 ] && [ "$PNPM_MINOR" -lt 1 ]; }; then`
+  ].join("\n");
+}
+function patch_deploy_vps_pnpm(content) {
+  const with_pnpm12 = content.replaceAll(
+    PNPM_INSTALL_PATTERN,
+    (command) => replace_outdated_install(command)
+  );
+  if (with_pnpm12.includes(VERSION_CHECK_MARKER)) return with_pnpm12;
+  if (!OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) return with_pnpm12;
+  return with_pnpm12.replace(OLD_MAJOR_LINE_PATTERN, "").replace(OLD_PNPM_CHECK_PATTERN, (_, indent) => build_version_check(indent));
+}
+var init_logic_deploy_vps = { patch_deploy_vps_pnpm };
+
+// scripts/config-merge/list-patch.ts
+function is_matching(entry, matchers) {
+  return matchers.some(
+    (matcher) => typeof matcher === "string" ? matcher === entry : matcher.test(entry)
+  );
+}
+function apply_remove(existing, remove) {
+  if (remove === void 0 || remove.length === 0) return existing;
+  return existing.filter((entry) => !is_matching(entry, remove));
+}
+function collect_additions(kept, ensure) {
+  if (ensure === void 0) return [];
+  return ensure.filter((entry) => !kept.includes(entry));
+}
+function apply_list_patch(existing, patch) {
+  const kept = apply_remove(existing, patch.remove);
+  const additions = collect_additions(kept, patch.ensure);
+  const is_changed = additions.length > 0 || kept.length !== existing.length;
+  return { next: [...additions, ...kept], is_changed };
+}
+var list_patch = {
+  is_matching,
+  apply_list_patch
+};
+
+// scripts/config-merge/parse-jsonc.ts
+import { parseTree, printParseErrorCode } from "jsonc-parser";
+function property_key(property) {
+  return String(property.children?.[0]?.value);
+}
+function node_value(node) {
+  if (node === void 0) return void 0;
+  const children = node.children ?? [];
+  if (node.type === "array") return children.map((child) => node_value(child));
+  if (node.type !== "object") return node.value;
+  return Object.fromEntries(
+    children.map((property) => [property_key(property), node_value(property.children?.[1])])
+  );
+}
+function parse_jsonc(content) {
+  const errors = [];
+  const tree = parseTree(content, errors, { allowTrailingComma: true });
+  const [first_error] = errors;
+  if (first_error !== void 0) {
+    throw new SyntaxError(
+      `Invalid JSONC: ${printParseErrorCode(first_error.error)} at offset ${String(first_error.offset)}`
+    );
+  }
+  return json_object_schema.parse(node_value(tree));
+}
+
+// scripts/config-merge/patch-json-key.ts
+import {
+  createScanner,
+  findNodeAtLocation,
+  getNodeValue,
+  parseTree as parseTree2,
+  stripComments
+} from "jsonc-parser";
+var DOCUMENT_SUFFIX = "\n}\n";
+var DEFAULT_INDENT = "	";
+var LEADING_BLANKS = /^[\t ]*/u;
+var PREVIOUS_LINE_OFFSET = 2;
+var CRLF = "\r\n";
+var COMMA_PROBE_VALUE = 0;
+function render_value(key, value, has_trailing_comma) {
+  const probe_key = `${key} `;
+  const probe = has_trailing_comma ? { [key]: value, [probe_key]: COMMA_PROBE_VALUE } : { [key]: value };
+  const document = json_format.format_json(probe);
+  const prefix = `{
+	${JSON.stringify(key)}: `;
+  const suffix = has_trailing_comma ? `,
+	${JSON.stringify(probe_key)}: ${String(COMMA_PROBE_VALUE)}${DOCUMENT_SUFFIX}` : DOCUMENT_SUFFIX;
+  return document.slice(prefix.length, document.length - suffix.length);
+}
+function parse_root(content) {
+  const root = parseTree2(content);
+  return root?.type === "object" ? root : void 0;
+}
+function replace_range(content, range, text) {
+  return content.slice(0, range.offset) + text + content.slice(range.offset + range.length);
+}
+function insert_at(content, offset, text) {
+  return replace_range(content, { offset, length: 0 }, text);
+}
+function render_indent(value_text, unit) {
+  if (unit === DEFAULT_INDENT || unit.length === 0) return value_text;
+  return value_text.replaceAll(/^\t+/gmu, (tabs) => unit.repeat(tabs.length));
+}
+function eol_of(content) {
+  return content.includes(CRLF) ? CRLF : "\n";
+}
+function fit_value(content, value_text, indent) {
+  const indented = render_indent(value_text, indent);
+  if (eol_of(content) === "\n") return indented;
+  return indented.split("\n").join(CRLF);
+}
+function line_indent(content, offset) {
+  const line_start = content.lastIndexOf("\n", offset - 1) + 1;
+  return LEADING_BLANKS.exec(content.slice(line_start, offset))?.[0] ?? "";
+}
+function line_end(content, offset) {
+  const index = content.indexOf("\n", offset);
+  if (index === -1) return content.length;
+  return index > offset && content[index - 1] === "\r" ? index - 1 : index;
+}
+function render_property(content, key, value_text, indent) {
+  return `${JSON.stringify(key)}: ${fit_value(content, value_text, indent)}`;
+}
+function insertion_offset(content, root, value_end) {
+  return Math.min(line_end(content, value_end), root.offset + root.length - 1);
+}
+function separator_offset(content, offset, limit) {
+  const scanner = createScanner(content, true);
+  scanner.setPosition(offset);
+  scanner.scan();
+  const at = scanner.getTokenOffset();
+  return at < limit && content[at] === "," ? at : -1;
+}
+function has_separator_after(content, offset, limit) {
+  return separator_offset(content, offset, limit) !== -1;
+}
+function property_key2(property) {
+  const key = property.children?.[0]?.value;
+  return typeof key === "string" ? key : void 0;
+}
+function target_value_end(property) {
+  const value_node = property?.children?.[1];
+  return value_node === void 0 ? void 0 : value_node.offset + value_node.length;
+}
+function contains_comment(content, node) {
+  const text = content.slice(node.offset, node.offset + node.length);
+  return stripComments(text) !== text;
+}
+function rebalanced_value(content, key, value_node, has_trailing_comma) {
+  if (contains_comment(content, value_node)) return void 0;
+  const indent = line_indent(content, value_node.offset);
+  const rendered = fit_value(
+    content,
+    render_value(key, getNodeValue(value_node), has_trailing_comma),
+    indent
+  );
+  const current = content.slice(value_node.offset, value_node.offset + value_node.length);
+  return rendered === current ? void 0 : rendered;
+}
+function rebalance(content, property, has_trailing_comma) {
+  const key = property_key2(property);
+  const value_node = property.children?.[1];
+  if (key === void 0 || value_node === void 0) return content;
+  const rendered = rebalanced_value(content, key, value_node, has_trailing_comma);
+  return rendered === void 0 ? content : replace_range(content, value_node, rendered);
+}
+function append_after(content, root, last, property) {
+  const value_end = last.offset + last.length;
+  const closing_brace = root.offset + root.length - 1;
+  const separator = has_separator_after(content, value_end, closing_brace) ? "" : ",";
+  const with_property = insert_at(content, insertion_offset(content, root, value_end), property);
+  return insert_at(with_property, value_end, separator);
+}
+function insert_only_property(content, root, property) {
+  const closing_brace = root.offset + root.length - 1;
+  const lead = content[closing_brace - 1] === "\n" ? "" : eol_of(content);
+  return insert_at(content, closing_brace, `${lead}${DEFAULT_INDENT}${property}${eol_of(content)}`);
+}
+function insert_property(content, root, key, value_text) {
+  const last = root.children?.at(-1);
+  if (last === void 0) {
+    const only = render_property(content, key, value_text, DEFAULT_INDENT);
+    return insert_only_property(content, root, only);
+  }
+  const indent = line_indent(content, last.offset);
+  const property = `${eol_of(content)}${indent}${render_property(content, key, value_text, indent)}`;
+  return rebalance(append_after(content, root, last, property), last, true);
+}
+function end_of_trailing_comment(content, end) {
+  const stop = line_end(content, end);
+  return content.slice(end, stop).trimStart().startsWith("//") ? stop : end;
+}
+function start_of_leading_comments(content, line_start, floor) {
+  let start = line_start;
+  while (start > floor) {
+    const previous = content.lastIndexOf("\n", start - PREVIOUS_LINE_OFFSET) + 1;
+    const is_comment_line = content.slice(previous, start).trimStart().startsWith("//");
+    if (!is_comment_line || previous < floor) return start;
+    start = previous;
+  }
+  return start;
+}
+function end_of_line_break(content, offset) {
+  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + PREVIOUS_LINE_OFFSET;
+  return content[offset] === "\n" ? offset + 1 : offset;
+}
+function body_range(content, root, target, separator_limit) {
+  const value_end = target.offset + target.length;
+  const comma = separator_limit === -1 ? -1 : separator_offset(content, value_end, separator_limit);
+  const end = end_of_trailing_comment(content, comma === -1 ? value_end : comma + 1);
+  const line_start = content.lastIndexOf("\n", target.offset - 1) + 1;
+  const is_own_line = content.slice(line_start, target.offset).trim().length === 0;
+  if (!is_own_line) return { offset: target.offset, length: end - target.offset };
+  const start = start_of_leading_comments(content, line_start, root.offset + 1);
+  return { offset: start, length: end_of_line_break(content, end) - start };
+}
+function ranges_for_last_property(content, root, previous, target) {
+  const comma = separator_offset(content, previous.offset + previous.length, target.offset);
+  const body = body_range(content, root, target, -1);
+  return comma === -1 ? [body] : [{ offset: comma, length: 1 }, body];
+}
+function removal_ranges(content, root, index) {
+  const children = root.children ?? [];
+  const target = children[index];
+  if (target === void 0) return [];
+  const next = children[index + 1];
+  if (next !== void 0) return [body_range(content, root, target, next.offset)];
+  const previous = children[index - 1];
+  if (previous === void 0) return [{ offset: root.offset, length: root.length }];
+  return ranges_for_last_property(content, root, previous, target);
+}
+function property_index(root, key) {
+  return (root.children ?? []).findIndex((child) => child.children?.[0]?.value === key);
+}
+function with_trailing_newline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function is_followed_by_comma(content, root, key) {
+  const children = root.children ?? [];
+  const index = property_index(root, key);
+  if (index < 0) return false;
+  if (index < children.length - 1) return true;
+  const value_end = target_value_end(children[index]);
+  return value_end !== void 0 && has_separator_after(content, value_end, root.offset + root.length);
+}
+function set_json_key(content, key, value) {
+  const root = parse_root(content);
+  if (root === void 0) return content;
+  const existing = findNodeAtLocation(root, [key]);
+  const value_text = render_value(
+    key,
+    value,
+    existing !== void 0 && is_followed_by_comma(content, root, key)
+  );
+  if (existing === void 0) {
+    return with_trailing_newline(insert_property(content, root, key, value_text));
+  }
+  const indented = fit_value(content, value_text, line_indent(content, existing.offset));
+  return with_trailing_newline(replace_range(content, existing, indented));
+}
+function resolve_parent(content, path16) {
+  const root = parse_root(content);
+  if (root === void 0) return void 0;
+  const parent = path16.length > 1 ? findNodeAtLocation(root, path16.slice(0, -1)) : root;
+  return parent?.type === "object" ? parent : void 0;
+}
+function cut_ranges(content, parent, ranges) {
+  const ordered = ranges.toSorted((left, right) => right.offset - left.offset);
+  let next = content;
+  for (const range of ordered) {
+    next = replace_range(next, range, range.offset === parent.offset ? "{}" : "");
+  }
+  return next;
+}
+function rebalance_new_last(content, path16) {
+  const parent = resolve_parent(content, path16);
+  const last = parent?.children?.at(-1);
+  if (parent === void 0 || last === void 0) return content;
+  return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
+}
+function cut_property(content, parent, path16) {
+  const index = property_index(parent, path16.at(-1) ?? "");
+  const ranges = removal_ranges(content, parent, index);
+  if (ranges.length === 0) return content;
+  const cut = cut_ranges(content, parent, ranges);
+  const did_end_object = index === (parent.children ?? []).length - 1;
+  return did_end_object ? rebalance_new_last(cut, path16) : cut;
+}
+function remove_json_path(content, path16) {
+  const parent = resolve_parent(content, path16);
+  if (parent === void 0) return content;
+  const next = cut_property(content, parent, path16);
+  return next === content ? content : with_trailing_newline(next);
+}
+function remove_json_key(content, key) {
+  return remove_json_path(content, [key]);
+}
+var patch_json_key = {
+  set_json_key,
+  remove_json_key,
+  remove_json_path,
+  eol_of,
+  fit_value,
+  line_indent
+};
+
+// scripts/config-merge/patch-json-list.ts
+function normalize_list(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.map(String);
+  return [];
+}
+function patch_json_list_field(content, options) {
+  const parsed = parse_jsonc(content);
+  const existing = normalize_list(parsed[options.field]);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  return patch_json_key.set_json_key(content, options.field, [...next]);
+}
+var json_list = {
+  patch_json_list_field
+};
+
+// scripts/config-merge/patch-yaml-list.ts
+import { dump as dump2 } from "js-yaml";
+var { parse_yaml: parse_yaml2 } = yaml_document;
+function read_yaml_list_field(content, field) {
+  const raw = parse_yaml2(content)[field];
+  if (typeof raw === "string") return [raw];
+  return Array.isArray(raw) ? string_array_schema.parse(raw) : [];
+}
+function replace_field(parsed, field, value) {
+  return Object.fromEntries(
+    Object.entries(parsed).map(([key, entry]) => [key, key === field ? [...value] : entry])
+  );
+}
+function insert_after(parsed, field, value, anchor) {
+  const entries = Object.entries(parsed);
+  const index = entries.findIndex(([key]) => key === anchor);
+  if (index === -1) return { ...parsed, [field]: [...value] };
+  return Object.fromEntries([
+    ...entries.slice(0, index + 1),
+    [field, [...value]],
+    ...entries.slice(index + 1)
+  ]);
+}
+function insert_new_field(parsed, field, value, position) {
+  if (position === "front") return { [field]: [...value], ...parsed };
+  if (position === "end") return { ...parsed, [field]: [...value] };
+  return insert_after(parsed, field, value, position.after);
+}
+function place_field(parsed, field, value, position) {
+  if (Object.hasOwn(parsed, field)) return replace_field(parsed, field, value);
+  return insert_new_field(parsed, field, value, position);
+}
+function patch_yaml_list_field(content, options) {
+  const parsed = parse_yaml2(content);
+  const existing = read_yaml_list_field(content, options.field);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  const placed = place_field(parsed, options.field, next, options.position ?? "front");
+  return dump2(placed, options.quote_style === void 0 ? {} : { quoteStyle: options.quote_style });
+}
+var yaml_list = {
+  patch_yaml_list_field,
+  read_yaml_list_field
+};
+
+// scripts/config-merge/index.ts
+var config_merge = {
+  patch_yaml_list_field: yaml_list.patch_yaml_list_field,
+  read_yaml_list_field: yaml_list.read_yaml_list_field,
+  patch_json_list_field: json_list.patch_json_list_field
+};
+
+// scripts/init/init-logic-migrate.ts
+var PREINSTALL_KEY = "preinstall";
+var JF_PREFIX = "jf-";
+var JOSH_PREFIX = "josh ";
+var PRE_JOSH_SCRIPT_VALUES = /* @__PURE__ */ new Map([
+  ["lint", "pnpm lint:prettier && pnpm lint:eslint"],
+  ["lint:prettier", "prettier --check ."],
+  ["lint:eslint", "eslint . --cache --cache-strategy content"],
+  ["format", "pnpm format:prettier && pnpm format:eslint"],
+  ["format:prettier", "prettier --write ."],
+  ["format:eslint", "eslint . --fix --cache --cache-strategy content"],
+  ["cspell", 'cspell lint --no-must-find-files --no-progress "**/*.{ts,js,md,yaml,yml,json}"'],
+  ["cspell:dot", "pnpm cspell . --dot"],
+  ["test:unit", "vitest run"],
+  ["lefthook:install", "lefthook install"],
+  ["lefthook:uninstall", "lefthook uninstall"],
+  ["lefthook:commit", "lefthook run pre-commit"],
+  ["lefthook:push", "lefthook run pre-push"],
+  ["main:sync", "git checkout main && git pull"],
+  ["main:merge", "git pull origin main"],
+  ["check:ci", "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --threshold error"]
+]);
+var RETIRED_MANAGED_SCRIPTS = /* @__PURE__ */ new Set([
+  "git",
+  "git:followup",
+  "telegram:test",
+  "audit:security",
+  "prep",
+  "issue:prep",
+  "prevent-main-commit",
+  "check-commit-message",
+  "version:major",
+  "version:minor",
+  "version:patch",
+  "version:current",
+  "overrides:check",
+  "test:e2e",
+  "test",
+  "latest",
+  "latest:corepack",
+  "latest:update",
+  "check",
+  "check:svelte",
+  "check:svelte:ci",
+  ...PRE_JOSH_SCRIPT_VALUES.keys()
+]);
+function migrate_jf_value(value) {
+  if (!value.startsWith(JF_PREFIX)) return value;
+  return `${JOSH_PREFIX}${value.slice(JF_PREFIX.length)}`;
+}
+function migrate_script(key, value) {
+  const migrated = migrate_jf_value(value);
+  return key === PREINSTALL_KEY ? safe_chain_preinstall.migrate_preinstall(migrated) : migrated;
+}
+function apply_jf_migrations(scripts) {
+  return Object.fromEntries(
+    Object.entries(scripts).map(([key, value]) => [key, migrate_script(key, value)])
+  );
+}
+function is_kit_written(key, value) {
+  if (value.startsWith(JOSH_PREFIX) || value.startsWith(JF_PREFIX)) return true;
+  return PRE_JOSH_SCRIPT_VALUES.get(key) === value;
+}
+function is_retired_script(key, value) {
+  return RETIRED_MANAGED_SCRIPTS.has(key) && is_kit_written(key, value);
+}
+function remove_retired_scripts(scripts) {
+  return Object.fromEntries(
+    Object.entries(scripts).filter(([key, value]) => !is_retired_script(key, value))
+  );
+}
+
+// scripts/init/init-logic-package-key-order.ts
+var PACKAGE_JSON_KEY_ORDER = [
+  "name",
+  "version",
+  "description",
+  "keywords",
+  "homepage",
+  "bugs",
+  "license",
+  "author",
+  "contributors",
+  "funding",
+  "files",
+  "main",
+  "browser",
+  "exports",
+  "imports",
+  "bin",
+  "man",
+  "directories",
+  "repository",
+  "type",
+  "types",
+  "typings",
+  "typesVersions",
+  "publishConfig",
+  "private",
+  "scripts",
+  "config",
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "bundleDependencies",
+  "bundledDependencies",
+  "optionalDependencies",
+  "overrides",
+  "resolutions",
+  "packageManager",
+  "engines",
+  "devEngines",
+  "os",
+  "cpu",
+  "size-limit",
+  "pnpm"
+];
+
+// scripts/init/kit-base-preset.ts
+var KIT_LEFTHOOK_PRESET = /@joshuafolkken\/[^/]+\/lefthook\//u;
+var KIT_CSPELL_PRESET = /@joshuafolkken\/[^/]+\/cspell(?:\/|$)/u;
+var KIT_TSCONFIG_PRESET = /@joshuafolkken\/[^/]+\/tsconfig\//u;
+var SVELTEKIT_PRESET = /(?<![\w-])sveltekit(?![\w-])/u;
+function has_match(entries, pattern) {
+  return entries.some((entry) => pattern.test(entry));
+}
+function is_base_present(entries, subsystem_pattern) {
+  return has_match(entries, subsystem_pattern) || has_match(entries, SVELTEKIT_PRESET);
+}
+function is_lefthook_base_present(entries) {
+  return is_base_present(entries, KIT_LEFTHOOK_PRESET);
+}
+function is_cspell_base_present(entries) {
+  return is_base_present(entries, KIT_CSPELL_PRESET);
+}
+function is_tsconfig_base_present(entries) {
+  return is_base_present(entries, KIT_TSCONFIG_PRESET);
+}
+var kit_base_preset = {
+  is_lefthook_base_present,
+  is_cspell_base_present,
+  is_tsconfig_base_present
+};
+
+// scripts/init/tsconfig-preset-migration.ts
+import { existsSync as existsSync4 } from "node:fs";
 import path7 from "node:path";
+var LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u;
+var LEGACY_SUFFIX = ".jsonc";
+var CURRENT_SUFFIX = ".json";
+var EXTENDS_FIELD = "extends";
+function is_migration_target_present(base_directory, entry) {
+  return existsSync4(path7.resolve(base_directory, entry));
+}
+function migrate_entry(base_directory, entry) {
+  if (!LEGACY_PRESET_ENTRY.test(entry)) return entry;
+  const migrated = `${entry.slice(0, -LEGACY_SUFFIX.length)}${CURRENT_SUFFIX}`;
+  return is_migration_target_present(base_directory, migrated) ? migrated : entry;
+}
+function migrate_extends_value(base_directory, raw) {
+  if (typeof raw === "string") return migrate_entry(base_directory, raw);
+  if (Array.isArray(raw)) {
+    return string_array_schema.parse(raw).map((entry) => migrate_entry(base_directory, entry));
+  }
+  return raw;
+}
+function migrate_preset_paths(content, base_directory) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed[EXTENDS_FIELD];
+  const migrated = migrate_extends_value(base_directory, raw);
+  if (JSON.stringify(migrated) === JSON.stringify(raw)) return content;
+  return patch_json_key.set_json_key(content, EXTENDS_FIELD, migrated);
+}
+var tsconfig_preset_migration = {
+  migrate_preset_paths
+};
+
+// scripts/init/init-logic-json-merge.ts
+function merge_json_extends(content, entry) {
+  return config_merge.patch_json_list_field(content, { field: EXTENDS_FIELD, ensure: [entry] });
+}
+function read_extends_entries(content) {
+  const raw = parse_jsonc(content)[EXTENDS_FIELD];
+  if (typeof raw === "string") return [raw];
+  if (Array.isArray(raw)) return string_array_schema.parse(raw);
+  return [];
+}
+function merge_tsconfig_extends(content, entry, base_directory) {
+  const migrated = tsconfig_preset_migration.migrate_preset_paths(content, base_directory);
+  if (kit_base_preset.is_tsconfig_base_present(read_extends_entries(migrated))) return migrated;
+  return merge_json_extends(migrated, entry);
+}
+function extract_compiler_options(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["compilerOptions"];
+  if (raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_redundant_option(value, key, base_options) {
+  if (!Object.hasOwn(base_options, key)) return false;
+  return JSON.stringify(base_options[key]) === JSON.stringify(value);
+}
+var COMPILER_OPTIONS_FIELD = "compilerOptions";
+function drop_redundant_options(content, redundant) {
+  let current = content;
+  for (const key of redundant) {
+    current = patch_json_key.remove_json_path(current, [COMPILER_OPTIONS_FIELD, key]);
+  }
+  return current;
+}
+function serialize_stripped(content, kept, redundant) {
+  if (Object.keys(kept).length === 0) {
+    return patch_json_key.remove_json_key(content, COMPILER_OPTIONS_FIELD);
+  }
+  return drop_redundant_options(content, redundant);
+}
+function redundant_option_keys(current, base_options) {
+  return Object.entries(current).filter(([key, value]) => is_redundant_option(value, key, base_options)).map(([key]) => key);
+}
+function strip_redundant_compiler_options(content, base_options) {
+  const raw = parse_jsonc(content)[COMPILER_OPTIONS_FIELD];
+  if (raw === void 0) return content;
+  const current = json_object_schema.parse(raw);
+  const redundant = redundant_option_keys(current, base_options);
+  if (redundant.length === 0) return content;
+  const kept = Object.entries(current).filter(([key]) => !redundant.includes(key));
+  return serialize_stripped(content, Object.fromEntries(kept), redundant);
+}
+function merge_json_array_field(content, key, values) {
+  const parsed = parse_jsonc(content);
+  const existing = Object.hasOwn(parsed, key) ? string_array_schema.parse(parsed[key]) : [];
+  const to_add = values.filter((value) => !existing.includes(value));
+  if (to_add.length === 0) return content;
+  return patch_json_key.set_json_key(content, key, [...existing, ...to_add]);
+}
+function missing_entries(existing, additions) {
+  return Object.entries(additions).filter(([key]) => !Object.hasOwn(existing, key));
+}
+function merge_owned_entries(current, update) {
+  const current_object = json_object_schema.safeParse(current);
+  const update_object = json_object_schema.safeParse(update);
+  if (!current_object.success || !update_object.success) return void 0;
+  const owned = current_object.data;
+  const missing = missing_entries(owned, update_object.data);
+  if (missing.length === 0) return void 0;
+  return { ...owned, ...Object.fromEntries(missing) };
+}
+function collect_applicable_updates(parsed, updates) {
+  const resolved = Object.entries(updates).map(([key, value]) => [
+    key,
+    Object.hasOwn(parsed, key) ? merge_owned_entries(parsed[key], value) : value
+  ]);
+  return Object.fromEntries(resolved.filter(([, merged]) => merged !== void 0));
+}
+function merge_json_object(content, updates) {
+  const parsed = parse_jsonc(content);
+  const applicable = collect_applicable_updates(parsed, updates);
+  if (Object.keys(applicable).length === 0) return content;
+  let current = content;
+  for (const [key, value] of Object.entries(applicable)) {
+    current = patch_json_key.set_json_key(current, key, value);
+  }
+  return current;
+}
+function serialize_package_json(value) {
+  return json_format.format_package_json(value);
+}
+var SCRIPTS_PREPEND_KEYS = /* @__PURE__ */ new Set(["preinstall"]);
+function merge_package_scripts(content, scripts) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const migrated = remove_retired_scripts(apply_jf_migrations(existing));
+  const to_add = missing_entries(migrated, scripts);
+  const did_migrate = JSON.stringify(migrated) !== JSON.stringify(existing);
+  if (!did_migrate && to_add.length === 0) return content;
+  const prepend = Object.fromEntries(to_add.filter(([k]) => SCRIPTS_PREPEND_KEYS.has(k)));
+  const append = Object.fromEntries(to_add.filter(([k]) => !SCRIPTS_PREPEND_KEYS.has(k)));
+  return serialize_package_json({ ...parsed, scripts: { ...prepend, ...migrated, ...append } });
+}
+function upgrade_safe_chain_preinstall(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const current = scripts["preinstall"];
+  if (current === void 0) return content;
+  const migrated = safe_chain_preinstall.migrate_preinstall(current);
+  if (migrated === current) return content;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, preinstall: migrated } });
+}
+function merge_development_dependencies(content, additions) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["devDependencies"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const to_add = missing_entries(existing, additions);
+  if (to_add.length === 0) return content;
+  return serialize_package_json({
+    ...parsed,
+    devDependencies: { ...existing, ...Object.fromEntries(to_add) }
+  });
+}
+function merge_package_manager(content, value) {
+  if (value.length === 0) return content;
+  const parsed = parse_jsonc(content);
+  if ("packageManager" in parsed) return content;
+  return serialize_package_json({ ...parsed, packageManager: value });
+}
+function merge_development_engines(content, value) {
+  const parsed = parse_jsonc(content);
+  if ("devEngines" in parsed) return content;
+  return serialize_package_json({ ...parsed, devEngines: value });
+}
+function has_package_scripts_marker(content, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return false;
+  const scripts = string_record_schema.parse(raw);
+  return Object.values(scripts).some((cmd) => cmd.includes(marker));
+}
+function merge_package_script_suffix(content, key, cmd) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (existing === void 0 || existing.includes(cmd)) return content;
+  const updated_value = existing.trim().length === 0 ? cmd : `${existing} && ${cmd}`;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, [key]: updated_value } });
+}
+function replace_in_package_script(content, key, from, to) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (!existing?.includes(from)) return content;
+  return serialize_package_json({
+    ...parsed,
+    // The replacer is a function so `to` is inserted verbatim: passed as a string, a `$&` or `$1`
+    // inside it would be read as a substitution pattern rather than as the text it is.
+    scripts: { ...scripts, [key]: existing.replace(from, () => to) }
+  });
+}
+function remove_script_with_marker(content, key, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  if (!scripts[key]?.includes(marker)) return content;
+  const rest = Object.fromEntries(Object.entries(scripts).filter(([k]) => k !== key));
+  return serialize_package_json({ ...parsed, scripts: rest });
+}
+function sort_package_json_keys(content) {
+  const parsed = parse_jsonc(content);
+  const all_keys = Object.keys(parsed);
+  const known = PACKAGE_JSON_KEY_ORDER.filter((k) => Object.hasOwn(parsed, k));
+  const unknown = all_keys.filter((k) => !PACKAGE_JSON_KEY_ORDER.includes(k));
+  const ordered = Object.fromEntries([...known, ...unknown].map((k) => [k, parsed[k]]));
+  const serialized = serialize_package_json(ordered);
+  const current = serialize_package_json(parsed);
+  if (serialized === current) return content;
+  return serialized;
+}
+var init_logic_json_merge = {
+  merge_json_extends,
+  merge_tsconfig_extends,
+  extract_compiler_options,
+  strip_redundant_compiler_options,
+  merge_json_array_field,
+  merge_json_object,
+  merge_package_scripts,
+  upgrade_safe_chain_preinstall,
+  merge_package_script_suffix,
+  replace_in_package_script,
+  remove_script_with_marker,
+  has_package_scripts_marker,
+  merge_development_dependencies,
+  merge_package_manager,
+  merge_development_engines,
+  sort_package_json_keys
+};
+
+// scripts/init/kit-development-versions.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { z as z11 } from "zod";
+var PACKAGE_JSON = "package.json";
+var kit_manifest_schema = z11.object({
+  peerDependencies: z11.record(z11.string(), z11.string()).default({}),
+  devDependencies: z11.record(z11.string(), z11.string())
+});
+function read_kit_manifest() {
+  const content = readFileSync3(package_path(PACKAGE_JSON), "utf8");
+  return kit_manifest_schema.parse(JSON.parse(content));
+}
+function versions_of(names) {
+  const { devDependencies: versions } = read_kit_manifest();
+  const entries = names.map((name) => {
+    const version = versions[name];
+    if (version === void 0) throw new Error(`Missing development version for ${name}`);
+    return [name, version];
+  });
+  return Object.fromEntries(entries);
+}
+function peer_names() {
+  return Object.keys(read_kit_manifest().peerDependencies);
+}
+var kit_development_versions = { peer_names, versions_of };
+
+// scripts/init/init-logic-secretlint.ts
+var SECRETLINT_CONFIG_FILENAME = ".secretlintrc.json";
+var SECRETLINT_RULE_PRESET = "@secretlint/secretlint-rule-preset-recommend";
+var SECRETLINT_PACKAGES = ["secretlint", SECRETLINT_RULE_PRESET];
+function generate_secretlint_config() {
+  const config = { rules: [{ id: SECRETLINT_RULE_PRESET }] };
+  return `${JSON.stringify(config, void 0, "	")}
+`;
+}
+function get_secretlint_config_filename() {
+  return SECRETLINT_CONFIG_FILENAME;
+}
+function merge_secretlint_development_deps(content) {
+  return init_logic_json_merge.merge_development_dependencies(
+    content,
+    kit_development_versions.versions_of(SECRETLINT_PACKAGES)
+  );
+}
+var init_logic_secretlint = {
+  generate_secretlint_config,
+  get_secretlint_config_filename,
+  merge_secretlint_development_deps
+};
+
+// scripts/init/init-logic-sonar.ts
+var SONAR_PROJECT_KEY_PLACEHOLDER = "{{PROJECT_KEY}}";
+var SONAR_ORGANIZATION_PLACEHOLDER = "{{ORGANIZATION}}";
+var SONAR_TEMPLATE_SRC = "templates/sonar-project.properties";
+var SONAR_TEMPLATE_DEST = "sonar-project.properties";
+var PROPERTY_LINE_PATTERN = /^([\w.]+)=/u;
+var MULTICRITERIA_KEY = "sonar.issue.ignore.multicriteria";
+var MULTICRITERIA_LINE_PATTERN = /^sonar\.issue\.ignore\.multicriteria=(.*)$/mu;
+function apply_sonar_template(content, project_key, organization) {
+  return content.replaceAll(SONAR_PROJECT_KEY_PLACEHOLDER, () => project_key).replaceAll(SONAR_ORGANIZATION_PLACEHOLDER, () => organization);
+}
+function derive_sonar_identifiers(name_with_owner) {
+  const [organization, repository, ...extra] = name_with_owner.trim().split("/");
+  if (!organization || !repository || extra.length > 0) {
+    throw new Error(`Invalid GitHub repository nameWithOwner: ${name_with_owner}`);
+  }
+  return {
+    organization,
+    project_key: `${organization}_${repository}`
+  };
+}
+function get_sonar_template_source() {
+  return SONAR_TEMPLATE_SRC;
+}
+function get_sonar_template_destination() {
+  return SONAR_TEMPLATE_DEST;
+}
+function extract_properties_keys(content) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const match = PROPERTY_LINE_PATTERN.exec(line);
+    if (match?.[1] !== void 0) keys.add(match[1]);
+  }
+  return keys;
+}
+function get_multicriteria_value(content) {
+  return MULTICRITERIA_LINE_PATTERN.exec(content)?.[1];
+}
+function get_multicriteria_ids(content) {
+  return (get_multicriteria_value(content) ?? "").split(",").map((id) => id.trim()).filter(Boolean);
+}
+function get_property_value(content, key) {
+  return content.split("\n").find((line) => line.startsWith(`${key}=`))?.slice(key.length + 1);
+}
+function has_criterion_conflict(existing, template, id) {
+  return ["ruleKey", "resourceKey"].some((field) => {
+    const key = `${MULTICRITERIA_KEY}.${id}.${field}`;
+    const existing_value = get_property_value(existing, key);
+    const template_value = get_property_value(template, key);
+    return existing_value !== void 0 && template_value !== void 0 && existing_value !== template_value;
+  });
+}
+function criterion_matches(existing, template, existing_id, template_id) {
+  const template_prefix = `${MULTICRITERIA_KEY}.${template_id}`;
+  const existing_prefix = `${MULTICRITERIA_KEY}.${existing_id}`;
+  const rule = get_property_value(template, `${template_prefix}.ruleKey`);
+  const resource = get_property_value(template, `${template_prefix}.resourceKey`);
+  if (rule === void 0 || resource === void 0) return false;
+  return rule === get_property_value(existing, `${existing_prefix}.ruleKey`) && resource === get_property_value(existing, `${existing_prefix}.resourceKey`);
+}
+function allocate_criterion_id(used_ids) {
+  let next_index = 1;
+  for (const id of used_ids) {
+    const numeric_id = /^e(\d+)$/u.exec(id)?.[1];
+    if (numeric_id !== void 0) next_index = Math.max(next_index, Number(numeric_id) + 1);
+  }
+  return `e${next_index.toString()}`;
+}
+function rename_criterion(template, id, replacement_id) {
+  const ids = get_multicriteria_ids(template).map(
+    (entry) => entry === id ? replacement_id : entry
+  );
+  const updated_list = template.replace(
+    MULTICRITERIA_LINE_PATTERN,
+    () => `${MULTICRITERIA_KEY}=${ids.join(",")}`
+  );
+  return updated_list.replaceAll(
+    `${MULTICRITERIA_KEY}.${id}.`,
+    () => `${MULTICRITERIA_KEY}.${replacement_id}.`
+  );
+}
+function find_matching_criterion(existing, template, ids, id) {
+  return ids.find((candidate) => criterion_matches(existing, template, candidate, id));
+}
+function resolve_multicriteria_conflicts(existing, template) {
+  const existing_ids = get_multicriteria_ids(existing);
+  const template_ids = get_multicriteria_ids(template);
+  const reusable_ids = existing_ids.filter((id) => !template_ids.includes(id));
+  let resolved = template;
+  for (const id of template_ids) {
+    if (!existing_ids.includes(id) || !has_criterion_conflict(existing, resolved, id)) continue;
+    const matching_id = find_matching_criterion(existing, resolved, reusable_ids, id);
+    const replacement_id = matching_id ?? allocate_criterion_id(/* @__PURE__ */ new Set([...existing_ids, ...get_multicriteria_ids(resolved)]));
+    resolved = rename_criterion(resolved, id, replacement_id);
+  }
+  return resolved;
+}
+function merge_multicriteria_ids(existing, template_content) {
+  const existing_value = get_multicriteria_value(existing);
+  if (existing_value === void 0) return existing;
+  const template_value = get_multicriteria_value(template_content);
+  if (template_value === void 0) return existing;
+  const existing_ids = get_multicriteria_ids(existing);
+  const template_ids = get_multicriteria_ids(template_content);
+  const merged_ids = [.../* @__PURE__ */ new Set([...existing_ids, ...template_ids])];
+  if (merged_ids.join(",") === existing_value) return existing;
+  return existing.replace(
+    MULTICRITERIA_LINE_PATTERN,
+    () => `${MULTICRITERIA_KEY}=${merged_ids.join(",")}`
+  );
+}
+function merge_sonar_properties(existing, template_content) {
+  const resolved_template = resolve_multicriteria_conflicts(existing, template_content);
+  const merged_existing = merge_multicriteria_ids(existing, resolved_template);
+  const existing_keys = extract_properties_keys(merged_existing);
+  const lines_to_add = resolved_template.split("\n").filter((line) => {
+    const key = PROPERTY_LINE_PATTERN.exec(line)?.[1];
+    return key !== void 0 && !existing_keys.has(key);
+  });
+  if (lines_to_add.length === 0) return merged_existing;
+  const normalized2 = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
+`;
+  return `${normalized2}
+${lines_to_add.join("\n")}
+`;
+}
+var init_logic_sonar = {
+  apply_sonar_template,
+  derive_sonar_identifiers,
+  get_sonar_template_source,
+  get_sonar_template_destination,
+  merge_sonar_properties
+};
+
+// scripts/init/init-logic-templates.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import path8 from "node:path";
+var ESLINT_VANILLA = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
+
+export default create_vanilla_config({
+	gitignore_path: new URL('./.gitignore', import.meta.url),
+	tsconfig_root_dir: import.meta.dirname,
+})
+`;
+var DEFAULT_TAILWIND_STYLESHEET = "./src/routes/layout.css";
+var TAILWIND_STYLESHEET_PATTERN = /tailwindStylesheet"?:\s*['"]([^'"]+)['"]/u;
+var KIT_ESLINT_IMPORT_MARKER = "@joshuafolkken/kit/eslint/";
+var VANILLA_ESLINT_MARKERS = [
+  "js.configs.recommended",
+  "ts.configs.recommended",
+  "svelte.configs.recommended"
+];
+var RULES_BLOCK_PATTERN = /rules\s*:\s*\{/gu;
+var RULES_INDENT_DEPTH = 3;
+var RULES_INDENT = "	".repeat(RULES_INDENT_DEPTH);
+var PLAYWRIGHT_TEMPLATE_PATH = package_path("playwright.config.ts");
+var VANILLA_WITH_RULES_TPL = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
+
+export default [
+	...create_vanilla_config({
+		gitignore_path: new URL('./.gitignore', import.meta.url),
+		tsconfig_root_dir: import.meta.dirname,
+	}),
+	{
+		rules: {
+$RULES
+		},
+	},
+]
+`;
+var RULES_PLACEHOLDER = "$RULES";
+var NOT_FOUND = -1;
+function generate_eslint_config() {
+  return ESLINT_VANILLA;
+}
+function is_vanilla_eslint_config(existing) {
+  if (existing.includes(KIT_ESLINT_IMPORT_MARKER)) return false;
+  return VANILLA_ESLINT_MARKERS.some((marker) => existing.includes(marker));
+}
+function update_brace_depth(char, depth) {
+  if (char === "{") return depth + 1;
+  if (char === "}") return depth - 1;
+  return depth;
+}
+function find_matching_close_brace(source, open_index) {
+  let depth = 0;
+  for (let index = open_index; index < source.length; index += 1) {
+    depth = update_brace_depth(source[index], depth);
+    if (depth === 0 && source[index] === "}") return index;
+  }
+  return NOT_FOUND;
+}
+function extract_block_from_open(source, open_index) {
+  const close = find_matching_close_brace(source, open_index);
+  if (close === NOT_FOUND) return void 0;
+  const inner = source.slice(open_index + 1, close).trim();
+  return inner.length > 0 ? inner : void 0;
+}
+function extract_rules_inner_blocks(existing) {
+  const blocks = [];
+  for (const match of existing.matchAll(RULES_BLOCK_PATTERN)) {
+    const open = match.index + match[0].length - 1;
+    const inner = extract_block_from_open(existing, open);
+    if (inner !== void 0) blocks.push(inner);
+  }
+  return blocks;
+}
+function indent_block(text, indent) {
+  return text.split("\n").map((line) => line.length === 0 ? line : `${indent}${line.trimStart()}`).join("\n");
+}
+function apply_rules_template(rules_body) {
+  const rules_block = indent_block(rules_body, RULES_INDENT);
+  return VANILLA_WITH_RULES_TPL.replace(RULES_PLACEHOLDER, () => rules_block);
+}
+function merge_eslint_config(existing) {
+  if (!is_vanilla_eslint_config(existing)) return existing;
+  const rules_blocks = extract_rules_inner_blocks(existing);
+  if (rules_blocks.length === 0) return generate_eslint_config();
+  return apply_rules_template(rules_blocks.join(",\n"));
+}
+function detect_tailwind_stylesheet(project_root2) {
+  return existsSync5(path8.join(project_root2, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
+}
+function generate_prettier_config(stylesheet) {
+  const stylesheet_line = stylesheet === void 0 ? "" : `	tailwindStylesheet: '${stylesheet}',
+`;
+  return `import { config } from '@joshuafolkken/kit/prettier'
+
+export default {
+	...config,
+${stylesheet_line}}
+`;
+}
+function existing_stylesheet(existing, project_root2) {
+  const named = TAILWIND_STYLESHEET_PATTERN.exec(existing)?.[1];
+  return named !== void 0 && existsSync5(path8.resolve(project_root2, named)) ? named : void 0;
+}
+function merge_prettier_config(existing, project_root2) {
+  const stylesheet = existing_stylesheet(existing, project_root2) ?? detect_tailwind_stylesheet(project_root2);
+  return generate_prettier_config(stylesheet);
+}
+function generate_playwright_config() {
+  return readFileSync4(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
+}
+var init_logic_templates = {
+  generate_eslint_config,
+  merge_eslint_config,
+  detect_tailwind_stylesheet,
+  generate_prettier_config,
+  merge_prettier_config,
+  generate_playwright_config
+};
+
+// scripts/init/init-logic-toolchain.ts
+var CONSUMER_RESOLVED_TOOLS = [
+  "eslint",
+  "prettier",
+  "typescript",
+  "@playwright/test",
+  "@ianvs/prettier-plugin-sort-imports",
+  "prettier-plugin-svelte",
+  "prettier-plugin-tailwindcss",
+  "cspell",
+  "@types/node"
+];
+var LEFTHOOK_DEVELOPMENT_DEPENDENCY = "lefthook";
+var DECLARING_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function consumer_resolved_names(has_git2) {
+  return has_git2 ? [...CONSUMER_RESOLVED_TOOLS, LEFTHOOK_DEVELOPMENT_DEPENDENCY] : CONSUMER_RESOLVED_TOOLS;
+}
+function get_toolchain_development_dependencies(has_git2) {
+  return kit_development_versions.versions_of([
+    ...kit_development_versions.peer_names(),
+    ...consumer_resolved_names(has_git2)
+  ]);
+}
+function is_declared(manifest, name) {
+  return DECLARING_FIELDS.some((field) => {
+    const dependencies = manifest[field];
+    return json_value.is_record(dependencies) && Object.hasOwn(dependencies, name);
+  });
+}
+function merge_consumer_resolved_development_deps(content, has_git2) {
+  const manifest = parse_jsonc(content);
+  const missing = consumer_resolved_names(has_git2).filter((name) => !is_declared(manifest, name));
+  return init_logic_json_merge.merge_development_dependencies(
+    content,
+    kit_development_versions.versions_of(missing)
+  );
+}
+var init_logic_toolchain = {
+  consumer_resolved_names,
+  get_toolchain_development_dependencies,
+  merge_consumer_resolved_development_deps
+};
+
+// scripts/init/init-logic-workspace.ts
+function extract_yaml_top_level_keys(content) {
+  return content.split("\n").flatMap((line) => {
+    const key = /^([a-zA-Z][a-zA-Z0-9_-]*):/u.exec(line)?.[1];
+    return key ?? [];
+  });
+}
+function extract_yaml_block(content, key) {
+  const pattern = new RegExp(String.raw`(^${key}:[^\n]*\n(?:(?:[ \t][^\n]*|)\n)*)`, "mu");
+  return pattern.exec(content)?.[1]?.trimEnd() ?? "";
+}
+function append_user_blocks(base, user_keys, existing) {
+  const user_blocks = user_keys.map((k) => extract_yaml_block(existing, k)).filter(Boolean).join("\n");
+  const normalized2 = base.endsWith("\n") ? base : `${base}
+`;
+  return `${normalized2}
+${user_blocks}
+`;
+}
+var DEPRECATED_KEYS = /* @__PURE__ */ new Set(["onlyBuiltDependencies"]);
+function remove_deprecated_yaml_key(content, key) {
+  const block = extract_yaml_block(content, key);
+  if (block.length === 0) return content;
+  const removed = content.replaceAll(`${block}
+`, "");
+  return removed.replaceAll(/\n{3,}/gu, "\n\n");
+}
+function remove_deprecated_yaml_keys(content) {
+  let result = content;
+  for (const key of DEPRECATED_KEYS) {
+    result = remove_deprecated_yaml_key(result, key);
+  }
+  return `${result.trimEnd()}
+`;
+}
+var BUILD_PLACEHOLDER_PATTERN = /^([ \t]+)([^\s:#][^:#]*): set this to true or false$/gmu;
+var TEMPLATE_BUILD_PATTERN = /^[ \t]+(?<key>[^\s:#][^:#]*):[ \t]*(?<value>true|false)\b/u;
+function unquote(key) {
+  return key.trim().replaceAll(/^['"]|['"]$/gu, "");
+}
+function template_build_values(template) {
+  const lines = extract_yaml_block(template, "allowBuilds").split("\n");
+  return new Map(
+    lines.flatMap((line) => {
+      const { key, value } = TEMPLATE_BUILD_PATTERN.exec(line)?.groups ?? {};
+      return key && value ? [[unquote(key), value]] : [];
+    })
+  );
+}
+function answer_build_placeholders(existing, template) {
+  const values = template_build_values(template);
+  return existing.replaceAll(BUILD_PLACEHOLDER_PATTERN, (line, indent, key) => {
+    const value = values.get(unquote(key));
+    return value === void 0 ? line : `${indent}${key}: ${value}`;
+  });
+}
+var BUILD_ENTRY_KEY_PATTERN = /^[ \t]+(?<key>[^\s:#][^:#]*):/u;
+function build_entry_key(line) {
+  const key = BUILD_ENTRY_KEY_PATTERN.exec(line)?.groups?.["key"];
+  return key === void 0 ? void 0 : unquote(key);
+}
+function build_entry_keys(block) {
+  return new Set(block.split("\n").flatMap((line) => build_entry_key(line) ?? []));
+}
+var BLOCK_MAPPING_HEADER_PATTERN = /^allowBuilds:[ \t]*(?:#[^\n]*)?(?:\n|$)/u;
+var LEADING_INDENT_PATTERN = /^[ \t]+/u;
+function block_entry_indent(block) {
+  const entry = block.split("\n").find((line) => build_entry_key(line) !== void 0);
+  return entry === void 0 ? void 0 : LEADING_INDENT_PATTERN.exec(entry)?.[0];
+}
+function reindent(line, indent) {
+  return indent === void 0 ? line : line.replace(LEADING_INDENT_PATTERN, () => indent);
+}
+function add_missing_build_entries(existing, template) {
+  const block = extract_yaml_block(existing, "allowBuilds");
+  if (!BLOCK_MAPPING_HEADER_PATTERN.test(block)) return existing;
+  const present = build_entry_keys(block);
+  const indent = block_entry_indent(block);
+  const missing = extract_yaml_block(template, "allowBuilds").split("\n").filter((line) => {
+    const key = build_entry_key(line);
+    return key !== void 0 && !present.has(key);
+  }).map((line) => reindent(line, indent));
+  if (missing.length === 0) return existing;
+  return existing.replace(block, () => [block, ...missing].join("\n"));
+}
+var MOVED_NPMRC_SETTINGS = [
+  { npmrc_key: "minimum-release-age", workspace_key: "minimumReleaseAge", value_pattern: /^\d+$/u },
+  { npmrc_key: "engine-strict", workspace_key: "engineStrict", value_pattern: /^(?:true|false)$/u }
+];
+function npmrc_value(npmrc, key) {
+  const pattern = new RegExp(String.raw`^[ \t]*${key}[ \t]*=[ \t]*(\S+)[ \t]*$`, "gmu");
+  return [...npmrc.matchAll(pattern)].at(-1)?.[1];
+}
+function carry_npmrc_setting(template, npmrc, setting) {
+  const value = npmrc_value(npmrc, setting.npmrc_key);
+  if (value === void 0 || !setting.value_pattern.test(value)) return template;
+  const line_pattern = new RegExp(`^${setting.workspace_key}:.*$`, "mu");
+  return template.replace(line_pattern, () => `${setting.workspace_key}: ${value}`);
+}
+function carry_npmrc_settings(template, npmrc) {
+  let result = template;
+  for (const setting of MOVED_NPMRC_SETTINGS) {
+    result = carry_npmrc_setting(result, npmrc, setting);
+  }
+  return result;
+}
+function merge_workspace_yaml(existing, template) {
+  if (!existing.trim()) return template;
+  const normalized2 = existing.endsWith("\n") ? existing : `${existing}
+`;
+  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized2), template);
+  const cleaned = add_missing_build_entries(answered, template);
+  if (!cleaned.trim()) return template;
+  const existing_keys = new Set(extract_yaml_top_level_keys(cleaned));
+  const new_keys = extract_yaml_top_level_keys(template).filter((k) => !existing_keys.has(k));
+  if (new_keys.length === 0) return cleaned;
+  return append_user_blocks(cleaned, new_keys, template);
+}
+var init_logic_workspace = { carry_npmrc_settings, merge_workspace_yaml, template_build_values };
+
+// scripts/init/init-logic-yaml-merge.ts
+var CSPELL_IMPORT_FIELD = "import";
+var LEFTHOOK_EXTENDS_FIELD = "extends";
+var CSPELL_IMPORT_POSITION = { after: "version" };
+var CSPELL_QUOTE_STYLE = "double";
+function merge_yaml_list_entry(content, key, value) {
+  return config_merge.patch_yaml_list_field(content, {
+    field: key,
+    ensure: [value],
+    position: "front"
+  });
+}
+function merge_lefthook_extends(content, value) {
+  const entries = config_merge.read_yaml_list_field(content, LEFTHOOK_EXTENDS_FIELD);
+  if (kit_base_preset.is_lefthook_base_present(entries)) return content;
+  return merge_yaml_list_entry(content, LEFTHOOK_EXTENDS_FIELD, value);
+}
+function merge_cspell_import(content, value) {
+  const entries = config_merge.read_yaml_list_field(content, CSPELL_IMPORT_FIELD);
+  if (kit_base_preset.is_cspell_base_present(entries)) return content;
+  return config_merge.patch_yaml_list_field(content, {
+    field: CSPELL_IMPORT_FIELD,
+    ensure: [value],
+    position: CSPELL_IMPORT_POSITION,
+    quote_style: CSPELL_QUOTE_STYLE
+  });
+}
+var init_logic_yaml_merge = {
+  merge_yaml_list_entry,
+  merge_lefthook_extends,
+  merge_cspell_import
+};
+
+// scripts/init/init-logic.ts
+var DEV_ENGINES_VALUE = {
+  packageManager: { name: "pnpm", version: ">=12.1.0", onFail: "download" }
+};
+var LEGACY_NPMRC_LINES = /* @__PURE__ */ new Set([
+  "engine-strict=true",
+  "minimum-release-age=1440",
+  "confirmModulesPurge=false",
+  "lockfile-include-tarball-url=true"
+]);
+var CSPELL_IMPORT = "@joshuafolkken/kit/cspell";
+var LEFTHOOK_INSTALL_CMD = "lefthook install";
+var { SAFE_CHAIN_CMD: SAFE_CHAIN_CMD2 } = safe_chain_preinstall;
+var FIX_GH_PACKAGES_CMD = "tsx node_modules/@joshuafolkken/kit/scripts/gh/fix-gh-packages.ts";
+var FIX_GH_PACKAGES_MARKER = "fix-gh-packages";
+var PREPARE_KEY = "prepare";
+var LEGACY_POSTINSTALL_KEY = "postinstall";
+var HOOK_INSTALL_WARNING = "lefthook install failed: git hooks are NOT installed. A set core.hooksPath is the usual cause. See https://github.com/joshuafolkken/kit/blob/main/docs/init.md#corehookspath-stops-lefthook-installing-anything";
+var LEFTHOOK_BINARY_GUARD = "command -v lefthook >/dev/null 2>&1";
+var GUARDED_LEFTHOOK_CMD = `${LEFTHOOK_BINARY_GUARD} && { ${LEFTHOOK_INSTALL_CMD} || echo '${HOOK_INSTALL_WARNING}' >&2; }`;
+var LEGACY_GUARDED_LEFTHOOK_CMD = `${LEFTHOOK_BINARY_GUARD} && ${LEFTHOOK_INSTALL_CMD}`;
+var GUARDED_FIX_GH_PACKAGES_CMD = `command -v tsx >/dev/null 2>&1 && ${FIX_GH_PACKAGES_CMD}`;
+var PREPARE_CMD = `(${GUARDED_LEFTHOOK_CMD} || true) && (${GUARDED_FIX_GH_PACKAGES_CMD} || true)`;
+var AI_COPY_FILES = [
+  "AGENTS.md",
+  "GEMINI.md",
+  "CODE_OF_CONDUCT.md",
+  ".cursorrules",
+  ".coderabbit.yaml",
+  ".gitattributes",
+  ".mcp.json",
+  ".ncurc.json",
+  ".prettierignore",
+  "SECURITY.md",
+  "pnpm-workspace.yaml",
+  "tsconfig.sonar.json",
+  ".github/workflows/auto-tag.yml",
+  ".github/workflows/production.yml",
+  ".github/workflows/sonar-qube.yml",
+  ".github/workflows/pr-classification.yml",
+  // Called by `ci.yml` and `pr-classification.yml` as `uses: ./.github/actions/setup-pnpm`; without
+  // it the consumer's jobs cannot resolve the action and their checks fail.
+  ".github/actions/setup-pnpm/action.yml",
+  // The one place the workflows' Node.js version is written, called by every distributed workflow
+  // that sets Node.js up.
+  ".github/actions/setup-node/action.yml",
+  ".github/pull_request_template.md",
+  ".github/release.yml",
+  ".github/dependabot.yml",
+  ".claude/settings.json",
+  ".codex/config.toml",
+  ".codex/hooks.json"
+];
+var AI_COPY_FILE_MAPPINGS = [
+  { src: "templates/workflows/ci.yml", dest: ".github/workflows/ci.yml" },
+  // The counterpart to the distributed `.github/dependabot.yml`: without it a consumer receives
+  // the machinery that opens Dependabot pull requests and none of the machinery that closes them,
+  // so every github-actions bump sits green and unmerged.
+  {
+    src: "templates/workflows/dependabot-auto-merge.yml",
+    dest: ".github/workflows/dependabot-auto-merge.yml"
+  },
+  // A template rather than a copy of kit's own file: kit releases from its publish.yml, so the file
+  // must not run in kit as well.
+  { src: "templates/workflows/github-release.yml", dest: ".github/workflows/github-release.yml" }
+];
+var AI_COPY_DIRECTORIES = [];
+var LEFTHOOK_EXTENDS = "node_modules/@joshuafolkken/kit/lefthook/vanilla.yml";
+var TSCONFIG_EXTENDS = "./node_modules/@joshuafolkken/kit/tsconfig/base.json";
+var TSCONFIG_PRESET_FILENAME = "base.json";
+var TSCONFIG_EXCLUDE_FIELD = "exclude";
+var TSCONFIG_GENERATED_OUTPUT_EXCLUDE = [
+  "node_modules",
+  "build",
+  "dist",
+  "playwright-report",
+  "test-results"
+];
+var TSCONFIG_SVELTEKIT_EXCLUDE = [
+  "src/service-worker.js",
+  "src/service-worker/**/*.js",
+  "src/service-worker.ts",
+  "src/service-worker/**/*.ts",
+  "src/service-worker.d.ts",
+  "src/service-worker/**/*.d.ts"
+];
+var TSCONFIG_EXCLUDE = [
+  ...TSCONFIG_GENERATED_OUTPUT_EXCLUDE,
+  ...TSCONFIG_SVELTEKIT_EXCLUDE
+];
+var VSCODE_EXTENSIONS_FILENAME = "extensions.json";
+var VSCODE_SETTINGS_FILENAME = "settings.json";
+var KIT_ONLY_VSCODE_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+  "sonarlint.connectedMode.project"
+]);
+var SUGGESTED_SCRIPTS_COMMON = {
+  preinstall: SAFE_CHAIN_CMD2,
+  prepare: PREPARE_CMD,
+  josh: "josh"
+};
+function generate_tsconfig() {
+  return json_format.format_json({
+    extends: TSCONFIG_EXTENDS,
+    compilerOptions: { types: ["node"] },
+    [TSCONFIG_EXCLUDE_FIELD]: TSCONFIG_EXCLUDE
+  });
+}
+function merge_tsconfig_exclude(content) {
+  const field = TSCONFIG_EXCLUDE_FIELD;
+  return init_logic_json_merge.merge_json_array_field(content, field, TSCONFIG_EXCLUDE);
+}
+function generate_lefthook_config() {
+  return `extends:
+  - ${LEFTHOOK_EXTENDS}
+`;
+}
+function generate_cspell_config() {
+  return `version: "0.2"
+import:
+  - "${CSPELL_IMPORT}"
+words: []
+ignorePaths: []
+`;
+}
+function append_missing_lines(existing, missing) {
+  if (missing.length === 0) return existing;
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
+` : existing;
+  return `${prefix}${missing.join("\n")}
+`;
+}
+function merge_npmrc(content) {
+  const lines = content.split("\n");
+  const kept = lines.filter((line) => !LEGACY_NPMRC_LINES.has(line.trim()));
+  return kept.length === lines.length ? content : kept.join("\n");
+}
+function is_gitignore_pattern(line) {
+  const trimmed = line.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("#");
+}
+function merge_gitignore(existing, template) {
+  const existing_lines = new Set(existing.split("\n"));
+  const missing = template.split("\n").filter((line) => is_gitignore_pattern(line) && !existing_lines.has(line));
+  return append_missing_lines(existing, missing);
+}
+function get_tsconfig_extends_entry() {
+  return TSCONFIG_EXTENDS;
+}
+function get_tsconfig_preset_filename() {
+  return TSCONFIG_PRESET_FILENAME;
+}
+function get_tsconfig_exclude_entries() {
+  return TSCONFIG_EXCLUDE;
+}
+function get_lefthook_extends_value() {
+  return LEFTHOOK_EXTENDS;
+}
+function get_cspell_import_value() {
+  return CSPELL_IMPORT;
+}
+function get_vscode_settings_filename() {
+  return VSCODE_SETTINGS_FILENAME;
+}
+function strip_kit_only_vscode_settings(settings) {
+  const entries = Object.entries(settings).filter(
+    ([key]) => !KIT_ONLY_VSCODE_SETTINGS_KEYS.has(key)
+  );
+  return Object.fromEntries(entries);
+}
+function strip_kit_only_vscode_settings_content(raw) {
+  const parsed = vscode_settings_schema.parse(JSON.parse(raw));
+  const stripped = strip_kit_only_vscode_settings(parsed);
+  if (Object.keys(stripped).length === Object.keys(parsed).length) return raw;
+  return json_format.format_json(stripped);
+}
+function get_development_engines_value() {
+  return DEV_ENGINES_VALUE;
+}
+function get_ai_copy_files() {
+  return AI_COPY_FILES;
+}
+function get_ai_copy_file_mappings() {
+  return AI_COPY_FILE_MAPPINGS;
+}
+function get_ai_copy_directories() {
+  return AI_COPY_DIRECTORIES;
+}
+function get_suggested_scripts() {
+  return SUGGESTED_SCRIPTS_COMMON;
+}
+function get_suggested_scripts_for_content(content) {
+  const scripts = get_suggested_scripts();
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (!has_fix) return scripts;
+  return Object.fromEntries(Object.entries(scripts).filter(([key]) => key !== PREPARE_KEY));
+}
+function upgrade_prepare_lefthook_warning(content) {
+  return init_logic_json_merge.replace_in_package_script(
+    content,
+    PREPARE_KEY,
+    LEGACY_GUARDED_LEFTHOOK_CMD,
+    GUARDED_LEFTHOOK_CMD
+  );
+}
+function merge_prepare_lifecycle_cmd(content) {
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (has_fix) return content;
+  return init_logic_json_merge.merge_package_script_suffix(content, PREPARE_KEY, PREPARE_CMD);
+}
+function strip_managed_postinstall(content) {
+  return init_logic_json_merge.remove_script_with_marker(
+    content,
+    LEGACY_POSTINSTALL_KEY,
+    FIX_GH_PACKAGES_CMD
+  );
+}
+var init_logic = {
+  ...init_logic_templates,
+  ...init_logic_workspace,
+  ...init_logic_sonar,
+  ...init_logic_json_merge,
+  ...init_logic_secretlint,
+  ...init_logic_toolchain,
+  ...init_logic_yaml_merge,
+  ...init_logic_deploy_vps,
+  ...distributed_paths,
+  generate_tsconfig,
+  merge_tsconfig_exclude,
+  get_tsconfig_exclude_entries,
+  generate_lefthook_config,
+  generate_cspell_config,
+  merge_npmrc,
+  merge_gitignore,
+  get_tsconfig_extends_entry,
+  get_tsconfig_preset_filename,
+  get_lefthook_extends_value,
+  get_cspell_import_value,
+  get_vscode_settings_filename,
+  strip_kit_only_vscode_settings,
+  strip_kit_only_vscode_settings_content,
+  VSCODE_EXTENSIONS_FILENAME,
+  SAFE_CHAIN_CMD: SAFE_CHAIN_CMD2,
+  GUARDED_LEFTHOOK_CMD,
+  upgrade_prepare_lefthook_warning,
+  get_development_engines_value,
+  get_ai_copy_files,
+  get_ai_copy_file_mappings,
+  get_ai_copy_directories,
+  get_suggested_scripts,
+  get_suggested_scripts_for_content,
+  merge_prepare_lifecycle_cmd,
+  strip_managed_postinstall
+};
+
+// scripts/sync/plugin-skill-directories.ts
+var PLUGIN_SKILL_DIRECTORIES = [
+  ".claude/skills/workflow-commands",
+  ".claude/skills/epic-commands",
+  ".claude/skills/dependency-update",
+  ".claude/skills/verify-ui"
+];
+
+// scripts/sync/synced-paths.ts
+var SYNCED_ARTIFACT_PATHS = [
+  "prettier.config.js",
+  "playwright.config.ts",
+  ".github/workflows/deploy-vps.yml"
+];
+var SYNCED_CONFIG_PATHS = [
+  ".npmrc",
+  ".gitignore",
+  "eslint.config.js",
+  "tsconfig.json",
+  "cspell.config.yaml",
+  "lefthook.yml",
+  ".secretlintrc.json",
+  ".vscode/extensions.json",
+  ".vscode/settings.json",
+  ".vscode/tasks.json"
+];
+function get_synced_paths() {
+  return [
+    ...SYNCED_ARTIFACT_PATHS,
+    ...SYNCED_CONFIG_PATHS,
+    init_logic.get_sonar_template_destination()
+  ];
+}
+var synced_paths = { get_synced_paths };
+
+// scripts/sync/managed-config-scope.ts
+var AI_COPY_FILES_LIST = "AI_COPY_FILES";
+var AI_COPY_FILE_MAPPINGS_LIST = "AI_COPY_FILE_MAPPINGS";
+var AI_COPY_DIRECTORIES_LIST = "AI_COPY_DIRECTORIES";
+var SYNCED_PATHS_LIST = "SYNCED_PATHS";
+var PLUGIN_SKILL_DIRECTORIES_LIST = "PLUGIN_SKILL_DIRECTORIES";
+var PATH_SEPARATOR = "/";
+function is_inside(path16, directory) {
+  return path16 === directory || path16.startsWith(`${directory}${PATH_SEPARATOR}`);
+}
+function matches_file(path16) {
+  return init_logic.get_ai_copy_files().includes(path16);
+}
+function matches_mapping(path16) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path16 || mapping.dest === path16);
+}
+function matches_directory(path16) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path16, directory));
+}
+function matches_plugin_skill(path16) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path16, directory));
+}
+function matches_synced_path(path16) {
+  return synced_paths.get_synced_paths().includes(path16);
+}
+var MATCHERS = [
+  { list: AI_COPY_FILES_LIST, matches: matches_file },
+  { list: AI_COPY_FILE_MAPPINGS_LIST, matches: matches_mapping },
+  { list: AI_COPY_DIRECTORIES_LIST, matches: matches_directory },
+  { list: PLUGIN_SKILL_DIRECTORIES_LIST, matches: matches_plugin_skill },
+  { list: SYNCED_PATHS_LIST, matches: matches_synced_path }
+];
+function find_list(path16) {
+  return MATCHERS.find((matcher) => matcher.matches(path16))?.list;
+}
+function to_hit(path16) {
+  const list = find_list(path16);
+  return list === void 0 ? void 0 : { path: path16, list };
+}
+function find_managed_paths(paths) {
+  return paths.flatMap((path16) => to_hit(path16) ?? []);
+}
+function has_managed_path(paths) {
+  return paths.some((path16) => find_list(path16) !== void 0);
+}
+function format_hit(hit) {
+  return `${hit.path} (${hit.list})`;
+}
+function format_hits(hits) {
+  return hits.map((hit) => format_hit(hit)).join("\n");
+}
+var managed_config_scope = {
+  find_managed_paths,
+  has_managed_path,
+  format_hit,
+  format_hits
+};
+
+// scripts/init/session-language-environment.ts
+import path9 from "node:path";
+var CLAUDE_SETTINGS_PATH = path9.join(".claude", "settings.json");
+var KEY_LINE_PATTERN = new RegExp(
+  String.raw`^\s*(?:export\s+)?${session_language.ENV_KEY}\s*=`,
+  "mu"
+);
+
+// scripts/config-merge/patch-json-array.ts
+import { findNodeAtLocation as findNodeAtLocation2, getNodeValue as getNodeValue2, parseTree as parseTree3 } from "jsonc-parser";
+
+// scripts/init/vscode-tasks.ts
+import { z as z12 } from "zod";
+var task_array_schema = z12.array(json_object_schema);
+
+// scripts/init/init-actions.ts
+var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
+
+// scripts/managed-marker/managed-marker-logic.ts
+var MARKER_TOKEN = "josh-managed-workflow:";
+var MARKER_PREFIX = `# ${MARKER_TOKEN}`;
+
+// scripts/init/claude-plugin-config.ts
+import path10 from "node:path";
+var MARKETPLACE_NAME = "kit";
+var PLUGIN_ID2 = "kit@kit";
+var MARKETPLACE_PATH = "./node_modules/@joshuafolkken/kit";
+var CLAUDE_SETTINGS_DESTINATION = path10.join(".claude", "settings.json");
+var PLUGIN_SETTINGS = {
+  extraKnownMarketplaces: {
+    [MARKETPLACE_NAME]: { source: { source: "directory", path: MARKETPLACE_PATH } }
+  },
+  enabledPlugins: { [PLUGIN_ID2]: true }
+};
+function inject_plugin_config(content) {
+  return init_logic_json_merge.merge_json_object(content, PLUGIN_SETTINGS);
+}
+function apply_plugin_config_for_destination(destination_path, content) {
+  return destination_path.endsWith(CLAUDE_SETTINGS_DESTINATION) ? inject_plugin_config(content) : content;
+}
+var claude_plugin_config = {
+  PLUGIN_ID: PLUGIN_ID2,
+  MARKETPLACE_PATH,
+  CLAUDE_SETTINGS_DESTINATION,
+  inject_plugin_config,
+  apply_plugin_config_for_destination
+};
+
+// scripts/init/hook-launch.ts
+var HOOK_DIST_DIR = "dist/hooks";
+var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
+var UNSET_OPTIONS = GIT_LOCATION_VARIABLES.map((name) => `-u ${name}`).join(" ");
+var ROOT_LOOKUP = "git rev-parse --show-toplevel";
+var PROJECT_ROOT_PREFIX = `project_root="$(env ${UNSET_OPTIONS} ${ROOT_LOOKUP} 2>/dev/null || ${ROOT_LOOKUP})" && cd "$project_root" && `;
+function hook_launch_command(name) {
+  return `${PROJECT_ROOT_PREFIX}sh ${RUN_HOOK_SCRIPT} ${name}`;
+}
+function fallback_command(name) {
+  return name.replace("-", ":");
+}
+var hook_launch = {
+  fallback_command,
+  HOOK_DIST_DIR,
+  hook_launch_command,
+  PROJECT_ROOT_PREFIX,
+  RUN_HOOK_SCRIPT
+};
+
+// scripts/init/hook-command-rewrite.ts
+var PNPM_JOSH_PREFIX = "pnpm josh ";
+var BUNDLE_INVOCATION = `node ${claude_plugin_config.MARKETPLACE_PATH}/dist/josh.js `;
+var RUN_HOOK_INVOCATION = `sh ${hook_launch.RUN_HOOK_SCRIPT} `;
+var CONSUMER_RUN_HOOK_INVOCATION = `sh ${claude_plugin_config.MARKETPLACE_PATH}/${hook_launch.RUN_HOOK_SCRIPT} `;
+var CONSUMER_PACKAGE_MANIFEST = `${claude_plugin_config.MARKETPLACE_PATH}/package.json`;
+var MISSING_INSTALL_NOTICE = "kit hooks inactive: run pnpm install, then reread CLAUDE.md";
+var MISSING_INSTALL_GUARD = `if [ ! -f ${CONSUMER_PACKAGE_MANIFEST} ]; then echo '${MISSING_INSTALL_NOTICE}' >&2; exit 0; fi; `;
+var PLAIN_KIT_COMMANDS = new Set(
+  [
+    "audit:provision",
+    "batch:guard",
+    "format:edited",
+    "investigation:guard",
+    "rule:guard",
+    "session:lang"
+  ].map((command) => `${PNPM_JOSH_PREFIX}${command}`)
+);
+var PROJECT_ROOT_PREFIX2 = JSON.stringify(hook_launch.PROJECT_ROOT_PREFIX).slice(1, -1);
+
+// scripts/init/security-policy.ts
+import path11 from "node:path";
+var SECURITY_MD = "SECURITY.md";
+var SECURITY_TEMPLATE = "templates/SECURITY.md";
+var REPOSITORY_PLACEHOLDER = "{{REPOSITORY}}";
+var KIT_ADVISORY_URL = "https://github.com/joshuafolkken/kit/security/advisories/new";
+var UNRESOLVED_REASON = "`origin` is not a GitHub repository `owner/repo` can be read from";
+var LINK_DELIMITER = /[\s()<>[\]]+/u;
+function repository_at(root) {
+  const url = git_spawn_sync.origin_url(root);
+  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+function apply_repository(content, repository) {
+  return content.replaceAll(REPOSITORY_PLACEHOLDER, () => repository);
+}
+function apply_repository_for_destination(destination_path, content) {
+  if (path11.basename(destination_path) !== SECURITY_MD) return content;
+  const repository = repository_at(path11.dirname(destination_path));
+  if (repository === void 0) {
+    throw new Error(`${SECURITY_MD} needs a GitHub origin to name the repository it reports to`);
+  }
+  return apply_repository(content, repository);
+}
+function does_report_to_kit(root) {
+  const existing = file_reader.read_if_readable(path11.join(root, SECURITY_MD)) ?? "";
+  return new Set(existing.split(LINK_DELIMITER)).has(KIT_ADVISORY_URL);
+}
+function unresolved_warning(root) {
+  if (!does_report_to_kit(root)) return `  \u26A0 skipped   ${SECURITY_MD} (${UNRESOLVED_REASON})`;
+  return `  \u26A0 stale     ${SECURITY_MD} still reports vulnerabilities to joshuafolkken/kit \u2014 replace it with your own policy or delete it (${UNRESOLVED_REASON})`;
+}
+function did_skip_unresolved(filename, root) {
+  if (filename !== SECURITY_MD || repository_at(root) !== void 0) return false;
+  console.warn(unresolved_warning(root));
+  return true;
+}
+var security_policy = {
+  SECURITY_MD,
+  SECURITY_TEMPLATE,
+  REPOSITORY_PLACEHOLDER,
+  KIT_ADVISORY_URL,
+  repository_at,
+  apply_repository_for_destination,
+  did_skip_unresolved
+};
+
+// scripts/init/init-ai-copy.ts
+var WORKSPACE_YAML = "pnpm-workspace.yaml";
+var CLAUDE_MD_FILENAME = "CLAUDE.md";
+var PRETTIER_IGNORE = ".prettierignore";
+var GIT_ATTRIBUTES = ".gitattributes";
+var CODE_OF_CONDUCT = "CODE_OF_CONDUCT.md";
+var { SECURITY_MD: SECURITY_MD2 } = security_policy;
+var AGENTS_MD = "AGENTS.md";
+var GEMINI_MD = "GEMINI.md";
+var BASIC_AI_FILES = [
+  AGENTS_MD,
+  GEMINI_MD,
+  PRETTIER_IGNORE,
+  GIT_ATTRIBUTES,
+  CODE_OF_CONDUCT,
+  SECURITY_MD2,
+  WORKSPACE_YAML
+];
+var BASIC_SOURCES = {
+  [AGENTS_MD]: "templates/AGENTS.basic.md",
+  [GEMINI_MD]: "templates/GEMINI.basic.md",
+  [PRETTIER_IGNORE]: "templates/prettierignore.basic",
+  [WORKSPACE_YAML]: "templates/pnpm-workspace.basic.yaml"
+};
+var CONSUMER_SOURCES = {
+  [SECURITY_MD2]: security_policy.SECURITY_TEMPLATE
+};
+var BASIC_WORKFLOW_AI_FILES = [...BASIC_AI_FILES, ".claude/settings.json"];
+
+// scripts/init/kit-written-paths.ts
+var MANIFEST_FILE = "package.json";
+var LOCKFILE = "pnpm-lock.yaml";
+var SETUP_ONLY_PATHS = /* @__PURE__ */ new Set([
+  CLAUDE_MD_FILENAME,
+  BASIC_PRETTIER_CONFIG,
+  PROJECT_CONFIG_FILE,
+  PACK_HOOK_FILE,
+  MANIFEST_FILE,
+  LOCKFILE
+]);
+function is_kit_written2(file_path) {
+  return SETUP_ONLY_PATHS.has(file_path) || managed_config_scope.has_managed_path([file_path]);
+}
+function select(paths) {
+  return paths.filter((file_path) => is_kit_written2(file_path));
+}
+var kit_written_paths = { is_kit_written: is_kit_written2, select };
+
+// scripts/init/workflow-mark.ts
+var WORKFLOW_ENV = "JOSH_WORKFLOW";
+var GITHUB_WORKFLOW = "github";
+function is_requested(environment = process.env) {
+  return environment[WORKFLOW_ENV] === GITHUB_WORKFLOW;
+}
+function is_recorded(manifest) {
+  const josh = manifest?.["josh"];
+  return json_value.is_record(josh) && josh["workflow"] === GITHUB_WORKFLOW;
+}
+function request(environment = process.env) {
+  environment[WORKFLOW_ENV] = GITHUB_WORKFLOW;
+}
+function recorded_fields(has_workflow2) {
+  return has_workflow2 ? { workflow: GITHUB_WORKFLOW } : {};
+}
+var workflow_mark = { is_requested, is_recorded, request, recorded_fields };
 
 // scripts/init/project-profile.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
-import path6 from "node:path";
 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"]);
@@ -2875,9 +5354,9 @@ function requested_profile(args, usage = "josh init [--profile basic|full]") {
   throw new Error("Profile must be basic or full");
 }
 function read_manifest(root) {
-  const filename = path6.join(root, "package.json");
-  if (!existsSync3(filename)) return void 0;
-  const parsed = JSON.parse(readFileSync3(filename, "utf8"));
+  const filename = path12.join(root, "package.json");
+  if (!existsSync6(filename)) return void 0;
+  const parsed = JSON.parse(readFileSync5(filename, "utf8"));
   if (!json_value.is_record(parsed)) throw new Error("package.json must contain an object");
   return parsed;
 }
@@ -2909,54 +5388,81 @@ function resolve_profile(root, requested) {
   if (profile !== void 0) return { profile, reason: "package.json josh.profile" };
   return inferred_profile(manifest);
 }
+function is_ignored_directory(name) {
+  return IGNORED_DIRECTORIES.has(name);
+}
 function should_visit(entry) {
-  return entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name);
+  return entry.isDirectory() && !is_ignored_directory(entry.name);
 }
 function scan_directory(directory, pending) {
   const entries = readdirSync(directory, { withFileTypes: true });
   pending.push(
-    ...entries.filter((entry) => should_visit(entry)).map((entry) => path6.join(directory, entry.name))
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path12.join(directory, entry.name))
   );
-  return entries.filter((entry) => entry.isFile()).map((entry) => path6.extname(entry.name));
+  return entries.filter((entry) => entry.isFile()).map((entry) => path12.join(directory, entry.name));
 }
-function file_extensions(root) {
+function is_project_file(root, file) {
+  const relative_path = path12.relative(root, file).split(path12.sep).join(path12.posix.sep);
+  return !kit_written_paths.is_kit_written(relative_path);
+}
+function list_files(root) {
   const pending = [root];
-  const extensions = [];
+  const files = [];
   for (const directory of pending) {
-    extensions.push(...scan_directory(directory, pending));
+    files.push(...scan_directory(directory, pending));
   }
-  return extensions;
+  return files;
+}
+function file_extensions(root) {
+  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path12.extname(file));
 }
 function scan_files(root) {
   const extensions = file_extensions(root);
   const has_web = extensions.some((extension) => WEB_EXTENSIONS.has(extension));
+  const should_use_prettier = has_web && own_formatter.find_config(root) === void 0;
   const has_typescript = extensions.some((extension) => TYPESCRIPT_EXTENSIONS.has(extension));
-  return { has_web, has_typescript };
+  return { should_use_prettier, has_typescript };
 }
 function has_github_remote(root) {
   const url = git_spawn_sync.origin_url(root);
   return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
 }
+function has_git(root) {
+  return existsSync6(path12.join(root, ".git"));
+}
+function has_workflow(root) {
+  return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root));
+}
 function inspect_project(root, requested) {
   const profile = resolve_profile(root, requested);
   const files = scan_files(root);
-  const has_git = existsSync3(path6.join(root, ".git"));
-  return { ...profile, ...files, has_git, has_github: has_git && has_github_remote(root) };
+  const is_git = has_git(root);
+  return {
+    ...profile,
+    ...files,
+    has_git: is_git,
+    has_github: is_git && has_github_remote(root),
+    has_workflow: has_workflow(root)
+  };
 }
 var project_profile = {
   parse_profile,
   resolve_profile,
+  has_git,
   inspect_project,
+  is_ignored_directory,
+  list_files,
   requested_profile,
   with_legacy_profile_names
 };
 
 // scripts/test/skip-marker.ts
 var SKIP_MARKER = "\u2014 skipping";
+var NOT_USED_MARKER = "which this project does not use";
 
 // scripts/gate/project-checks.ts
-import { z as z7 } from "zod";
-var PACKAGE_JSON = "package.json";
+import { z as z13 } from "zod";
+var PACKAGE_JSON2 = "package.json";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -2990,11 +5496,11 @@ var CSPELL_CONFIGS = [
 ];
 var TYPE_CONFIGS = ["tsconfig.json", "jsconfig.json"];
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];
-var object_schema = z7.record(z7.string(), z7.unknown());
+var object_schema = z13.record(z13.string(), z13.unknown());
 function project_root(directory) {
   return ancestor_directories.nearest(
     directory,
-    (candidate) => existsSync4(path7.join(candidate, PACKAGE_JSON))
+    (candidate) => existsSync7(path13.join(candidate, PACKAGE_JSON2))
   ) ?? directory;
 }
 function is_kit_repository(directory) {
@@ -3007,7 +5513,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) => existsSync4(path7.join(project_root(directory), name)));
+  return names.some((name) => existsSync7(path13.join(project_root(directory), name)));
 }
 function has_bin(directory, bin_name) {
   return find_local_bin_upwards(directory, bin_name) !== void 0;
@@ -3022,8 +5528,8 @@ function is_basic_manifest(manifest) {
 }
 function read_manifest2(directory) {
   try {
-    const manifest_path = path7.join(project_root(directory), PACKAGE_JSON);
-    return json_value.parse_or_undefined(readFileSync4(manifest_path, "utf8"));
+    const manifest_path = path13.join(project_root(directory), PACKAGE_JSON2);
+    return json_value.parse_or_undefined(readFileSync6(manifest_path, "utf8"));
   } catch {
     return void 0;
   }
@@ -3031,7 +5537,7 @@ function read_manifest2(directory) {
 function is_basic(directory) {
   return is_basic_manifest(read_manifest2(directory));
 }
-function is_declared(directory, package_name) {
+function is_declared2(directory, package_name) {
   const manifest = object_schema.safeParse(read_manifest2(directory));
   if (!manifest.success) return false;
   return DEPENDENCY_FIELDS.some((field) => {
@@ -3040,11 +5546,14 @@ function is_declared(directory, package_name) {
   });
 }
 function missing_tool_reason(directory, package_name, bin_name) {
-  if (has_bin(directory, bin_name) || is_declared(directory, package_name)) return void 0;
+  if (has_bin(directory, bin_name) || is_declared2(directory, package_name)) return void 0;
   return `${package_name} is not installed`;
 }
-function skip_notice(check4, reason) {
-  return `josh ${check4}: ${reason} ${SKIP_MARKER} ${check4}.`;
+function skip_notice(check5, reason) {
+  return `josh ${check5}: ${reason} ${SKIP_MARKER} ${check5}, ${NOT_USED_MARKER}.`;
+}
+function ran_notice(check5) {
+  return `josh ${check5}: ran and reported no problems.`;
 }
 function type_check_skip_reason(directory) {
   if (!is_basic(directory)) return void 0;
@@ -3054,6 +5563,8 @@ function type_check_skip_reason(directory) {
 }
 function prettier_skip_reason(directory) {
   if (!is_basic(directory)) return void 0;
+  const formatter = own_formatter.find_config(project_root(directory));
+  if (formatter !== void 0) return `${formatter} configures the project's own formatter`;
   if (!has_files(directory, WEB_FILES)) return "no HTML, CSS or JavaScript files were found";
   return missing_tool_reason(directory, "prettier", "prettier");
 }
@@ -3076,6 +5587,8 @@ var project_checks = {
   is_kit_repository,
   prettier_skip_reason,
   project_root,
+  ran_notice,
+  read_manifest: read_manifest2,
   skip_notice,
   type_check_skip_reason
 };
@@ -3104,40 +5617,40 @@ var BASIC_REQUIRED_SUFFIXES = [
   ".toml"
 ];
 function normalize(paths) {
-  return paths.map((path10) => path10.trim()).filter((path10) => path10 !== "");
+  return paths.map((path16) => path16.trim()).filter((path16) => path16 !== "");
 }
-function is_test_file(path10) {
-  return TEST_SUFFIXES.some((suffix) => path10.endsWith(suffix));
+function is_test_file(path16) {
+  return TEST_SUFFIXES.some((suffix) => path16.endsWith(suffix));
 }
-function is_basic_manual(path10, is_basic2) {
-  const lower = path10.toLowerCase();
+function is_basic_manual(path16, is_basic2) {
+  const lower = path16.toLowerCase();
   return is_basic2 && BASIC_REQUIRED_SUFFIXES.every((suffix) => !lower.endsWith(suffix));
 }
-function is_basic_visual(path10) {
-  const lower = path10.toLowerCase();
+function is_basic_visual(path16) {
+  const lower = path16.toLowerCase();
   return BASIC_VISUAL_SUFFIXES.some((suffix) => lower.endsWith(suffix));
 }
-function is_exempt(path10, is_basic2 = false) {
-  if (EXEMPT_PATHS.includes(path10) || is_basic_manual(path10, is_basic2)) return true;
-  return EXEMPT_SUFFIXES.some((suffix) => path10.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path10.startsWith(prefix));
+function is_exempt(path16, is_basic2 = false) {
+  if (EXEMPT_PATHS.includes(path16) || is_basic_manual(path16, is_basic2)) return true;
+  return EXEMPT_SUFFIXES.some((suffix) => path16.endsWith(suffix)) || EXEMPT_PREFIXES.some((prefix) => path16.startsWith(prefix));
 }
-function is_runtime(path10, is_basic2 = false) {
-  return !is_test_file(path10) && !is_exempt(path10, is_basic2);
+function is_runtime(path16, is_basic2 = false) {
+  return !is_test_file(path16) && !is_exempt(path16, is_basic2);
 }
-function verdict_for(paths, is_basic2 = false) {
+function verdict_for2(paths, is_basic2 = false) {
   const changed = normalize(paths);
-  if (changed.some((path10) => is_test_file(path10))) return "satisfied";
-  if (changed.some((path10) => is_runtime(path10, is_basic2))) return "required";
+  if (changed.some((path16) => is_test_file(path16))) return "satisfied";
+  if (changed.some((path16) => is_runtime(path16, is_basic2))) return "required";
   return "exempt";
 }
 function runtime_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path10) => is_runtime(path10, is_basic2));
+  return normalize(paths).filter((path16) => is_runtime(path16, is_basic2));
 }
 function exempt_files(paths, is_basic2 = false) {
-  return normalize(paths).filter((path10) => is_exempt(path10, is_basic2));
+  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2));
 }
 function manual_check_files(paths, is_basic2) {
-  return normalize(paths).filter((path10) => is_exempt(path10, is_basic2) && !is_exempt(path10));
+  return normalize(paths).filter((path16) => is_exempt(path16, is_basic2) && !is_exempt(path16));
 }
 var test_declared_logic = {
   EXEMPT_PATHS,
@@ -3150,7 +5663,7 @@ var test_declared_logic = {
   is_test_file,
   manual_check_files,
   runtime_files,
-  verdict_for
+  verdict_for: verdict_for2
 };
 
 // scripts/test/test-declared-changed.ts
@@ -3492,30 +6005,30 @@ var epic_busy = {
 };
 
 // scripts/run/run-liveness.ts
-import { readFileSync as readFileSync5, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync7, realpathSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import path8 from "node:path";
+import path14 from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // scripts/agent/agent-event.ts
-import { z as z9 } from "zod";
+import { z as z15 } from "zod";
 
 // scripts/agent/claude-result-event.ts
-import { z as z8 } from "zod";
-var RESULT_EVENT_SCHEMA = z8.looseObject({
-  type: z8.literal("result"),
-  is_error: z8.unknown().optional(),
-  subtype: z8.unknown().optional(),
-  num_turns: z8.unknown().optional(),
-  permission_denials: z8.unknown().optional(),
-  result: z8.unknown().optional(),
-  session_id: z8.unknown().optional(),
-  usage: z8.unknown().optional()
+import { z as z14 } from "zod";
+var RESULT_EVENT_SCHEMA = z14.looseObject({
+  type: z14.literal("result"),
+  is_error: z14.unknown().optional(),
+  subtype: z14.unknown().optional(),
+  num_turns: z14.unknown().optional(),
+  permission_denials: z14.unknown().optional(),
+  result: z14.unknown().optional(),
+  session_id: z14.unknown().optional(),
+  usage: z14.unknown().optional()
 });
-var USAGE_SCHEMA = z8.looseObject({
-  input_tokens: z8.unknown().optional(),
-  cache_read_input_tokens: z8.unknown().optional(),
-  output_tokens: z8.unknown().optional()
+var USAGE_SCHEMA = z14.looseObject({
+  input_tokens: z14.unknown().optional(),
+  cache_read_input_tokens: z14.unknown().optional(),
+  output_tokens: z14.unknown().optional()
 });
 function usable_reason(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -3554,31 +6067,31 @@ function decode(value) {
 var claude_result_event = { decode };
 
 // scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z9.looseObject({ type: z9.literal("text"), text: z9.string() });
-var CLAUDE_MESSAGE_SCHEMA = z9.looseObject({ content: z9.array(z9.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z9.looseObject({ type: z9.literal("system"), subtype: z9.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z9.looseObject({
-  type: z9.literal("assistant"),
+var TEXT_BLOCK_SCHEMA = z15.looseObject({ type: z15.literal("text"), text: z15.string() });
+var CLAUDE_MESSAGE_SCHEMA = z15.looseObject({ content: z15.array(z15.unknown()).optional() });
+var CLAUDE_INIT_SCHEMA = z15.looseObject({ type: z15.literal("system"), subtype: z15.literal("init") });
+var CLAUDE_ASSISTANT_SCHEMA = z15.looseObject({
+  type: z15.literal("assistant"),
   message: CLAUDE_MESSAGE_SCHEMA
 });
-var USAGE_SCHEMA2 = z9.looseObject({
-  input_tokens: z9.number().optional(),
-  cached_input_tokens: z9.number().optional(),
-  output_tokens: z9.number().optional()
+var USAGE_SCHEMA2 = z15.looseObject({
+  input_tokens: z15.number().optional(),
+  cached_input_tokens: z15.number().optional(),
+  output_tokens: z15.number().optional()
 });
-var CODEX_START_SCHEMA = z9.looseObject({ type: z9.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z9.looseObject({
-  type: z9.enum(["item.started", "item.updated", "item.completed"]),
-  item: z9.looseObject({ type: z9.string(), text: z9.string().optional() }).optional()
+var CODEX_START_SCHEMA = z15.looseObject({ type: z15.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z15.looseObject({
+  type: z15.enum(["item.started", "item.updated", "item.completed"]),
+  item: z15.looseObject({ type: z15.string(), text: z15.string().optional() }).optional()
 });
-var CODEX_COMPLETE_SCHEMA = z9.looseObject({
-  type: z9.literal("turn.completed"),
+var CODEX_COMPLETE_SCHEMA = z15.looseObject({
+  type: z15.literal("turn.completed"),
   usage: USAGE_SCHEMA2.optional()
 });
-var CODEX_FAILURE_SCHEMA = z9.looseObject({
-  type: z9.enum(["turn.failed", "error"]),
-  error: z9.looseObject({ message: z9.string().optional() }).optional(),
-  message: z9.string().optional()
+var CODEX_FAILURE_SCHEMA = z15.looseObject({
+  type: z15.enum(["turn.failed", "error"]),
+  error: z15.looseObject({ message: z15.string().optional() }).optional(),
+  message: z15.string().optional()
 });
 var EMPTY_STATE = {
   provider: void 0,
@@ -3669,7 +6182,7 @@ function describe(state) {
 var agent_event = { describe, read };
 
 // scripts/issue/issue-state.ts
-import { z as z10 } from "zod";
+import { z as z16 } from "zod";
 var NO_LABELS = "(none)";
 var LABEL_SEPARATOR = ", ";
 var STATE_LABEL = "state: ";
@@ -3679,9 +6192,9 @@ var YES = "yes";
 var NO = "no";
 var ISSUE_LABEL = "issue: ";
 var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z10.looseObject({ name: z10.string() });
-var issue_state_schema = z10.looseObject({
-  state: z10.string(),
+var label_schema = z16.looseObject({ name: z16.string() });
+var issue_state_schema = z16.looseObject({
+  state: z16.string(),
   labels: label_schema.array().optional()
 });
 function parse_issue_state(json) {
@@ -3798,12 +6311,12 @@ var ALLOWED_ROOTS = [
   )
 ];
 function is_within(candidate, root) {
-  const relative = path8.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path8.isAbsolute(relative);
+  const relative = path14.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path14.isAbsolute(relative);
 }
 function to_safe_path(output_path) {
-  const normalized2 = path8.normalize(output_path);
-  if (!path8.isAbsolute(normalized2)) return void 0;
+  const normalized2 = path14.normalize(output_path);
+  if (!path14.isAbsolute(normalized2)) return void 0;
   return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
 }
 function sample_output(output_path) {
@@ -3817,7 +6330,7 @@ function read_agent_state(output_path) {
   const safe_path = to_safe_path(output_path);
   if (safe_path === void 0) return void 0;
   try {
-    const state = agent_event.read(readFileSync5(safe_path, "utf8"));
+    const state = agent_event.read(readFileSync7(safe_path, "utf8"));
     return state.provider === void 0 ? void 0 : state;
   } catch {
     return void 0;
@@ -3827,12 +6340,12 @@ function describe_agent_state(output_path) {
   const state = read_agent_state(output_path);
   return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
 }
-async function read_output_frozen(request) {
-  const first = sample_output(request.output_path);
+async function read_output_frozen(request2) {
+  const first = sample_output(request2.output_path);
   if (first === void 0) return void 0;
-  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
-  await sleep(request.gap_ms);
-  const second = sample_output(request.output_path);
+  if (request2.now_ms - first.mtime_ms < request2.silent_window_ms) return false;
+  await sleep(request2.gap_ms);
+  const second = sample_output(request2.output_path);
   if (second === void 0) return void 0;
   return second.mtime_ms === first.mtime_ms && second.size === first.size;
 }
@@ -3850,34 +6363,34 @@ async function read_child_settled(issue, repo) {
   if (state === void 0) return void 0;
   return state.state !== OPEN_STATE || carries_settled_label(state.labels);
 }
-async function read_traces(request) {
+async function read_traces(request2) {
   const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
-    read_child_settled(request.issue, request.repo),
+    read_child_settled(request2.issue, request2.repo),
     read_output_frozen({
-      gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND2,
+      gap_ms: request2.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND2,
       now_ms: Date.now(),
-      output_path: request.output_path,
-      silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE3
+      output_path: request2.output_path,
+      silent_window_ms: request2.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE3
     }),
     run_hold.is_tree_dirty()
   ]);
-  const agent_state = read_agent_state(request.output_path);
-  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
+  const agent_state = read_agent_state(request2.output_path);
+  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request2.issue, request2.repo) : void 0;
   const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
   return {
     agent_state,
     is_child_settled,
     is_output_frozen,
     is_tree_dirty,
-    process_trace: request.process_trace
+    process_trace: request2.process_trace
   };
 }
-async function check(request) {
-  issue_number_shape.require_issue_number(request.issue);
-  return decide5(await read_traces(request));
+async function check2(request2) {
+  issue_number_shape.require_issue_number(request2.issue);
+  return decide5(await read_traces(request2));
 }
 var run_liveness = {
-  check,
+  check: check2,
   decide: decide5,
   describe_agent_state,
   read_child_settled,
@@ -3949,7 +6462,7 @@ var lane_report = {
 };
 
 // scripts/run/run-preflight.ts
-import { z as z11 } from "zod";
+import { z as z17 } from "zod";
 var CLEAN_VERDICT = "clean";
 var RECLAIM_VERDICT = "reclaim";
 var RESUME_VERDICT = "resume";
@@ -3959,7 +6472,7 @@ var OPEN_PR = "open";
 var MERGED_PR = "merged";
 var CLOSED_PR = "closed";
 var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z11.object({ state: z11.string().optional() });
+var pr_info_schema = z17.object({ state: z17.string().optional() });
 var GH_PR_STATES = /* @__PURE__ */ new Map([
   ["CLOSED", CLOSED_PR],
   ["MERGED", MERGED_PR],
@@ -4122,7 +6635,7 @@ async function read_child_state(issue) {
   );
   return pick_child_state(reads.filter((read2) => read2 !== void 0));
 }
-async function check2(issue) {
+async function check3(issue) {
   require_issue_number(issue);
   const tree = await read_tree_state();
   if (needs_reclaim(tree)) return decide6(tree, NO_CHILD_WORK, issue);
@@ -4133,7 +6646,7 @@ var run_preflight = {
   RESUME_ADVICE,
   MERGED_PR,
   STASH_LABEL_PREFIX,
-  check: check2,
+  check: check3,
   decide: decide6,
   read_child_state,
   read_pr_state,
@@ -4204,16 +6717,16 @@ async function has_run_record() {
 async function has_run_started(lanes) {
   return lanes.length > 0 || await has_run_record();
 }
-async function read_observations(request) {
-  const [children, lanes] = await Promise.all([read_children(request.repo), read_lanes()]);
+async function read_observations(request2) {
+  const [children, lanes] = await Promise.all([read_children(request2.repo), read_lanes()]);
   if (children === void 0) return UNREADABLE_READ;
   if (children.length === 0 && !await has_run_started(lanes)) return IDLE_READ;
   const observations = {
-    repo: request.repo,
+    repo: request2.repo,
     children,
     lanes,
     load_average: loadavg()[FIRST_LOAD_AVERAGE] ?? 0,
-    record_age_ms: read_record_age(request.output_paths, request.now_ms)
+    record_age_ms: read_record_age(request2.output_paths, request2.now_ms)
   };
   return { kind: "observed", observations };
 }
@@ -4232,7 +6745,7 @@ var run_progress_read = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z12 } from "zod";
+import { z as z18 } from "zod";
 
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
@@ -4246,7 +6759,7 @@ async function owes_watcher() {
   if (run_headless.is_headless() || !await run_headless.is_backlog_parent()) return false;
   return await lane_registry.has_lanes_in_flight();
 }
-async function check3(life_target) {
+async function check4(life_target) {
   if (!await owes_watcher()) return OK_RESULT;
   if (run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) return OK_RESULT;
   return { kind: "stale", note: STALE_NOTE };
@@ -4254,13 +6767,13 @@ async function check3(life_target) {
 var run_watcher_guard = {
   STALE_NOTE,
   STALE_THRESHOLD_MS,
-  check: check3
+  check: check4
 };
 
 // scripts/run/run-watcher-hook.ts
 var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
 var STAMP_PREFIX2 = "josh-watcher-guard-";
-var payload_schema = z12.object({ transcript_path: z12.string().min(1) });
+var payload_schema = z18.object({ transcript_path: z18.string().min(1) });
 function transcript_of(raw_payload) {
   return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
 }
@@ -4298,7 +6811,7 @@ function current_state3() {
 }
 var THRESHOLD_TEXT2 = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`;
 var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` (it owns the live carry record) and its recent-context cost has crossed the shared ${THRESHOLD_TEXT2} threshold between merges, so every later request re-reads the accumulated context (joshuafolkken/kit#2947). Take the hand-off now rather than at the next merge: follow \`.claude/skills/workflow-commands/backlogrun-progress.md\` \u2192 "The hand-off" from its \`over\` branch \u2014 open no new lane and take no new child, read \`pnpm josh lane:list\`, make sure every lane in flight records an output path, then run \`pnpm josh run:carry --cut --owner "$PPID"\` and, unless it answers \`capped\`, \`pnpm josh run:wake\`, post the progress comment and end the turn. A lane nobody can poll means the cut does not happen; carry on and this asks again later. Reissue this call when the hand-off is done or cannot be taken \u2014 the guard stays quiet for a while after it refuses, so the hand-off calls themselves are not refused.`;
-async function is_due2(state) {
+async function is_due3(state) {
   const carry = await state.carry();
   if (carry === void 0 || run_headless.is_cut_capped(carry)) return false;
   return state.verdict() === cost_verdict.OVER_VERDICT;
@@ -4310,7 +6823,7 @@ function is_quiet(target, now_ms) {
 async function refusal_for(transcript, now_ms, state) {
   const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX3);
   const target = stamp.path(transcript);
-  if (is_quiet(target, now_ms) || !await is_due2(state)) return void 0;
+  if (is_quiet(target, now_ms) || !await is_due3(state)) return void 0;
   return stamp.record(target, now_ms) ? PARENT_CUT_REASON : void 0;
 }
 function is_unit_call(raw_payload) {
@@ -4338,7 +6851,7 @@ var run_parent_cut_hook = {
 };
 
 // scripts/hooks/step-zero-notice.ts
-import path9 from "node:path";
+import path15 from "node:path";
 var STAMP_PREFIX4 = "josh-step-zero-notice-";
 var EDIT_TOOLS3 = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var PARENT_PREFIX = "..";
@@ -4353,9 +6866,9 @@ function edited_paths(tool_input) {
   );
 }
 function is_runtime_file(file_path, root) {
-  const relative = path9.relative(root, path9.resolve(root, file_path));
-  if (relative.startsWith(PARENT_PREFIX) || path9.isAbsolute(relative)) return false;
-  return !test_declared_logic.is_exempt(relative.split(path9.sep).join("/"));
+  const relative = path15.relative(root, path15.resolve(root, file_path));
+  if (relative.startsWith(PARENT_PREFIX) || path15.isAbsolute(relative)) return false;
+  return !test_declared_logic.is_exempt(relative.split(path15.sep).join("/"));
 }
 function is_candidate2(raw_payload, root) {
   const payload = hook_decision.parse_hook_payload(raw_payload);
@@ -4412,7 +6925,8 @@ async function mark_phase(outcome) {
 }
 async function async_reason(raw_payload) {
   const watcher = await run_watcher_hook.watcher_hook_reason(raw_payload);
-  return watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload);
+  const cut = watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload);
+  return cut ?? await issue_watch_hook.watch_reason();
 }
 async function pretool_outcome_async(raw_payload) {
   const base = guard_outcome(raw_payload);