@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/tsconfig.sonar.json

@@ -11,6 +11,6 @@
 			"$lib/*": ["./src/lib/*"]
 		}
 	},
-	"include": ["src/**/*.js", "src/**/*.ts", "src/**/*.svelte", "scripts/**/*.ts"],
+	"include": ["src/**/*.js", "src/**/*.ts", "src/**/*.svelte", "scripts/**/*.ts", "tools/**/*.ts"],
 	"exclude": ["node_modules", "build", ".svelte-kit"]
 }

package/.ncurc.json

@@ -1,3 +0,0 @@
-{
-	"cooldown": 1
-}

package/dist/hooks/batch-guard.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env tsx
-import {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  batch_outcome,
-  batch_refusal,
-  deny_envelope,
-  is_enabled,
-  load_environment_file,
-  notice_refusal_path,
-  refusal_path
-} from "./chunk-A65Y4YOR.js";
-import "./chunk-JP45SOCJ.js";
-import "./chunk-6TS2JD6D.js";
-import "./chunk-TNUMY6NL.js";
-import "./chunk-LAOV7NLM.js";
-import "./chunk-APUO6U4J.js";
-import "./chunk-DGT54IH5.js";
-export {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  batch_outcome,
-  batch_refusal,
-  deny_envelope,
-  is_enabled,
-  load_environment_file,
-  notice_refusal_path,
-  refusal_path
-};

package/dist/hooks/chunk-4KKD2UTK.js

@@ -1,66 +0,0 @@
-// scripts/observations/observation-ledger.ts
-var OBSERVATION_LEDGER_DIRECTORY = ".josh/observations";
-var LEGACY_OBSERVATION_LEDGER_DIRECTORY = "docs/maintainers/observations";
-var LEDGER_DIRECTORIES = [
-  OBSERVATION_LEDGER_DIRECTORY,
-  LEGACY_OBSERVATION_LEDGER_DIRECTORY
-];
-var LEDGER_FILE_EXTENSION = ".md";
-var LEGACY_LEDGER_FILE = `legacy${LEDGER_FILE_EXTENSION}`;
-var LEGACY_OBSERVATION_LEDGER_PATHS = [
-  "docs/maintainers/observations.md",
-  "docs/observations.md"
-];
-var STATUS_PATH_INDEX = 3;
-function status_path(line) {
-  return line.slice(STATUS_PATH_INDEX).trim();
-}
-function ledger_file(name) {
-  return `${OBSERVATION_LEDGER_DIRECTORY}/${String(name)}${LEDGER_FILE_EXTENSION}`;
-}
-function is_ledger_file_name(name) {
-  return name.endsWith(LEDGER_FILE_EXTENSION);
-}
-var MIGRATION_CLAIM_SUFFIX = ".migrating";
-function is_legacy_directory_file(file_path) {
-  return file_path.startsWith(`${LEGACY_OBSERVATION_LEDGER_DIRECTORY}/`);
-}
-function is_migration_claim(file_path) {
-  if (!file_path.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
-  return is_legacy_directory_file(file_path) || LEGACY_OBSERVATION_LEDGER_PATHS.some((legacy) => file_path.startsWith(`${legacy}.`));
-}
-function is_in_directory(file_path) {
-  return LEDGER_DIRECTORIES.some((directory) => file_path.startsWith(`${directory}/`));
-}
-function is_ledger_path(file_path) {
-  return is_in_directory(file_path) || LEGACY_OBSERVATION_LEDGER_PATHS.includes(file_path) || is_migration_claim(file_path);
-}
-function is_ledger_line(line) {
-  return is_ledger_path(status_path(line));
-}
-function ledger_paths(status_output) {
-  return status_output.split("\n").filter((line) => is_ledger_line(line)).map((line) => status_path(line));
-}
-function has_pending_append(status_output) {
-  return status_output.split("\n").some((line) => is_ledger_line(line));
-}
-var observation_ledger = {
-  has_pending_append,
-  is_ledger_file_name,
-  is_ledger_line,
-  is_ledger_path,
-  is_migration_claim,
-  ledger_file,
-  ledger_paths,
-  status_path
-};
-
-export {
-  OBSERVATION_LEDGER_DIRECTORY,
-  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
-  LEDGER_FILE_EXTENSION,
-  LEGACY_LEDGER_FILE,
-  LEGACY_OBSERVATION_LEDGER_PATHS,
-  MIGRATION_CLAIM_SUFFIX,
-  observation_ledger
-};

package/dist/hooks/chunk-6TS2JD6D.js

@@ -1,237 +0,0 @@
-import {
-  time_density_hook,
-  time_hook_transcript
-} from "./chunk-TNUMY6NL.js";
-import {
-  josh_environment_file
-} from "./chunk-LAOV7NLM.js";
-import {
-  json_value
-} from "./chunk-APUO6U4J.js";
-import {
-  stamp_file
-} from "./chunk-DGT54IH5.js";
-
-// scripts/josh/hook-decision.ts
-import { z } from "zod";
-var payload_schema = z.object({
-  transcript_path: z.string().min(1),
-  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
-  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
-  // call of the main line, in silence — the failure every other path here is written to avoid.
-  agent_id: z.string().nullish(),
-  tool_name: z.string().min(1),
-  tool_input: z.unknown()
-});
-var refusal_schema = z.object({ refused_at_ms: z.number() });
-var HOOK_EVENT_NAME = "PreToolUse";
-var DENY_DECISION = "deny";
-var ALLOW_DECISION = "allow";
-var NEVER_MS = 0;
-var MISSING_FILE = "ENOENT";
-var DISABLED_VALUES = ["off", "0", "false", "no"];
-function is_switch_enabled(key) {
-  return !DISABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
-}
-var ENABLED_VALUES = ["on", "1", "true", "yes"];
-function is_switch_opt_in(key) {
-  return ENABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
-}
-function parse_hook_payload(raw_payload) {
-  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
-  return parsed.success ? parsed.data : void 0;
-}
-function deny_envelope(reason) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: DENY_DECISION,
-      permissionDecisionReason: reason
-    }
-  });
-}
-function rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: ALLOW_DECISION,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function flow_rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function notice_envelope(notice) {
-  return JSON.stringify({
-    systemMessage: notice,
-    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
-  });
-}
-function stamp_fault(switch_key) {
-  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
-}
-function is_missing_file(error) {
-  if (!(error instanceof Error) || !("code" in error)) return false;
-  return typeof error.code === "string" && error.code === MISSING_FILE;
-}
-function error_text(error) {
-  if (error instanceof Error) return error.message;
-  return typeof error === "string" ? error : "a value that is not an error";
-}
-function fault_notice(switch_key, error) {
-  if (is_missing_file(error)) return void 0;
-  const detail = error_text(error);
-  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
-}
-function last_refusal_ms(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return NEVER_MS;
-  return json_value.parse_with(raw, refusal_schema)?.refused_at_ms ?? NEVER_MS;
-}
-function record_refusal(target, now_ms) {
-  try {
-    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function create_refusal_stamp(prefix) {
-  function path(transcript_path) {
-    return stamp_file.stamp_path(prefix, transcript_path);
-  }
-  return { path, last_ms: last_refusal_ms, record: record_refusal };
-}
-var { load_environment_file } = josh_environment_file;
-var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
-function fire_once(stamp, run, should_fire, switch_key) {
-  const target = stamp.path(run.transcript);
-  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
-  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
-  return { fired: true, fault: void 0 };
-}
-function block_outcome(context) {
-  const { spec, stamp, tail, call, run } = context;
-  const result = fire_once(
-    stamp,
-    run,
-    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function notify_outcome(context) {
-  const { spec, notify_stamp, tail, call, run } = context;
-  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
-  const { notify } = spec;
-  const result = fire_once(
-    notify_stamp,
-    run,
-    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: void 0, notice: notify.text(call, tail), fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function is_clear(outcome) {
-  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
-}
-function guard_reason_for_payload(parts, payload, now_ms) {
-  const call = { name: payload.tool_name, input: payload.tool_input };
-  if (!parts.spec.is_candidate(call)) return NO_OUTCOME;
-  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
-  const tail = time_density_hook.read_tail(transcript);
-  const context = { ...parts, tail, call, run: { transcript, now_ms } };
-  const blocked = block_outcome(context);
-  if (!is_clear(blocked)) return blocked;
-  return notify_outcome(context);
-}
-function guard_outcome(parts, raw_payload, now_ms) {
-  const payload = parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key)) return NO_OUTCOME;
-  return guard_reason_for_payload(parts, payload, now_ms);
-}
-function create_transcript_guard(spec) {
-  const stamp = create_refusal_stamp(spec.prefix);
-  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
-  const parts = { spec, stamp, notify_stamp };
-  function is_enabled() {
-    return is_switch_enabled(spec.switch_key);
-  }
-  function refusal_path(transcript_path) {
-    return stamp.path(transcript_path);
-  }
-  function outcome(raw_payload, now_ms = Date.now()) {
-    try {
-      return guard_outcome(parts, raw_payload, now_ms);
-    } catch (error) {
-      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
-    }
-  }
-  function refusal(raw_payload, now_ms = Date.now()) {
-    return outcome(raw_payload, now_ms).reason;
-  }
-  return { is_enabled, outcome, refusal, refusal_path };
-}
-function emit_outcome(outcome) {
-  const { reason, notice, fault } = outcome;
-  if (reason !== void 0) process.stdout.write(`${deny_envelope(reason)}
-`);
-  else if (notice !== void 0) process.stdout.write(`${notice_envelope(notice)}
-`);
-  else if (fault !== void 0) process.stdout.write(`${notice_envelope(fault)}
-`);
-}
-function write_outcome(raw_payload, outcome) {
-  load_environment_file();
-  emit_outcome(outcome(raw_payload));
-}
-function write_decision(raw_payload, refusal) {
-  write_outcome(raw_payload, (raw) => ({
-    reason: refusal(raw),
-    notice: void 0,
-    fault: void 0
-  }));
-}
-function report_no_payload(command) {
-  process.stderr.write(
-    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
-`
-  );
-}
-var hook_decision = {
-  DISABLED_VALUES,
-  ENABLED_VALUES,
-  NEVER_MS,
-  create_refusal_stamp,
-  create_transcript_guard,
-  deny_envelope,
-  emit_outcome,
-  fault_notice,
-  flow_rewrite_envelope,
-  is_switch_enabled,
-  is_switch_opt_in,
-  load_environment_file,
-  notice_envelope,
-  parse_hook_payload,
-  report_no_payload,
-  rewrite_envelope,
-  stamp_fault,
-  write_decision,
-  write_outcome
-};
-
-export {
-  hook_decision
-};

package/dist/hooks/chunk-7DSBJVFH.js

@@ -1,50 +0,0 @@
-import {
-  investigation_reads
-} from "./chunk-PTICX4OL.js";
-import {
-  agent_session_role
-} from "./chunk-UPUZF3AN.js";
-import {
-  lane_guard_policy
-} from "./chunk-JP45SOCJ.js";
-import {
-  hook_decision
-} from "./chunk-6TS2JD6D.js";
-
-// scripts/delegation/investigation-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_INVESTIGATION_GUARD";
-var STAMP_PREFIX = "josh-investigation-guard-";
-function should_block(tail, call, refused_at_ms, run) {
-  if (agent_session_role.is_reviewer() || lane_guard_policy.mode_here("investigation") !== "refuse") {
-    return false;
-  }
-  return investigation_reads.should_block(tail, call, refused_at_ms, run);
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate: investigation_reads.is_refusable_call,
-  should_block,
-  reason: investigation_reads.REASON
-});
-var investigation_refusal = GUARD.refusal;
-var investigation_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("investigation:guard");
-  else hook_decision.write_outcome(await text(process.stdin), investigation_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  investigation_refusal,
-  investigation_outcome,
-  is_enabled,
-  refusal_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};

package/dist/hooks/chunk-A65Y4YOR.js

@@ -1,79 +0,0 @@
-import {
-  lane_guard_policy
-} from "./chunk-JP45SOCJ.js";
-import {
-  hook_decision
-} from "./chunk-6TS2JD6D.js";
-import {
-  time_batch_guard
-} from "./chunk-TNUMY6NL.js";
-
-// scripts/hooks/batch-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_BATCH_GUARD";
-function is_batch_candidate(call) {
-  return time_batch_guard.is_guarded_call(call) || time_batch_guard.is_notice_call(call);
-}
-function batching_mode() {
-  return lane_guard_policy.mode_here("batching");
-}
-function is_candidate(call) {
-  return is_batch_candidate(call) && batching_mode() !== "off";
-}
-function should_block_here(tail, call, refused_at_ms) {
-  if (batching_mode() !== "refuse") return false;
-  return time_batch_guard.should_block(tail, call, refused_at_ms);
-}
-function should_notify_here(tail, call, notified_at_ms) {
-  if (time_batch_guard.should_notify(tail, call, notified_at_ms)) return true;
-  if (batching_mode() !== "notice") return false;
-  return time_batch_guard.should_block(
-    tail,
-    call,
-    notified_at_ms,
-    time_batch_guard.NOTICE_REFIRE_EVERY
-  );
-}
-function notice_text(call, tail) {
-  const base = time_batch_guard.is_notice_call(call) ? time_batch_guard.NOTICE : time_batch_guard.LANE_NOTICE;
-  return `${base}${time_batch_guard.recent_candidates(tail)}`;
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: time_batch_guard.STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate,
-  should_block: should_block_here,
-  reason: time_batch_guard.REASON,
-  // The whole-file write is notified rather than refused, on a record of its own so it never spends
-  // the refusal's stamp; the lane-child refusable-call notice kit#2164 added
-  // here fires again since kit#2276 restored batching to `notice` in a lane child.
-  notify: {
-    prefix: time_batch_guard.NOTICE_STAMP_PREFIX,
-    should_notify: should_notify_here,
-    text: notice_text
-  }
-});
-var batch_refusal = GUARD.refusal;
-var batch_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var notice_refusal_path = hook_decision.create_refusal_stamp(
-  time_batch_guard.NOTICE_STAMP_PREFIX
-).path;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("batch:guard");
-  else hook_decision.write_outcome(await text(process.stdin), batch_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  batch_refusal,
-  batch_outcome,
-  is_enabled,
-  refusal_path,
-  notice_refusal_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};

package/dist/hooks/chunk-CDY4NFQG.js

@@ -1,15 +0,0 @@
-// scripts/lib/error-message.ts
-function message_of(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-var DEBUG_ENV_KEY = "JOSH_DEBUG";
-function trace_swallowed(where, error) {
-  if ((process.env[DEBUG_ENV_KEY] ?? "").trim() === "") return;
-  process.stderr.write(`josh debug: ${where}: ${message_of(error)}
-`);
-}
-var error_text = { message_of, trace_swallowed };
-
-export {
-  error_text
-};

package/dist/hooks/chunk-EFXE6C37.js

@@ -1,81 +0,0 @@
-import {
-  ancestor_directories
-} from "./chunk-GP4IEC4O.js";
-
-// scripts/build/local-bin.ts
-import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-
-// scripts/lib/schemas.ts
-import { z } from "zod";
-var overrides_snapshot_schema = z.record(z.string(), z.string());
-var package_version_schema = z.object({ version: z.string() });
-var package_named_version_schema = z.looseObject({ name: z.string(), version: z.string() });
-var package_with_version_schema = z.looseObject({ version: z.string() });
-var ls_global_dependency_schema = z.looseObject({ version: z.string() });
-var ls_global_dependencies_schema = z.record(z.string(), ls_global_dependency_schema).optional();
-var pnpm_ls_global_schema = z.array(
-  z.looseObject({
-    dependencies: ls_global_dependencies_schema
-  })
-);
-var vscode_settings_schema = z.record(z.string(), z.unknown());
-var with_scripts_schema = z.looseObject({
-  scripts: z.record(z.string(), z.string()).optional()
-});
-var with_development_deps_schema = z.looseObject({
-  devDependencies: z.record(z.string(), z.string()).optional()
-});
-var with_package_manager_schema = z.looseObject({
-  packageManager: z.string().optional()
-});
-var with_development_engine_schema = z.looseObject({
-  devEngines: z.record(z.string(), z.unknown()).optional()
-});
-var bin_entry_schema = z.union([z.string(), z.record(z.string(), z.string())]).optional();
-var package_bin_schema = z.looseObject({ bin: bin_entry_schema });
-var json_object_schema = z.record(z.string(), z.unknown());
-var string_array_schema = z.array(z.string());
-var string_record_schema = z.record(z.string(), z.string());
-
-// scripts/build/local-bin.ts
-var NODE_MODULES = "node_modules";
-var BIN_DIR = ".bin";
-var WINDOWS_PLATFORM = "win32";
-var WINDOWS_SHIM_SUFFIX = ".cmd";
-var PACKAGE_JSON = "package.json";
-function resolve_local_bin(project_root, bin_name) {
-  const shim = process.platform === WINDOWS_PLATFORM ? `${bin_name}${WINDOWS_SHIM_SUFFIX}` : bin_name;
-  return path.join(project_root, NODE_MODULES, BIN_DIR, shim);
-}
-function find_local_bin_upwards(start_directory, bin_name) {
-  return ancestor_directories.list(start_directory).map((directory) => resolve_local_bin(directory, bin_name)).find((candidate) => existsSync(candidate));
-}
-function read_bin_entry(manifest_path, package_name, bin_name) {
-  const { bin } = package_bin_schema.parse(JSON.parse(readFileSync(manifest_path, "utf8")));
-  if (typeof bin === "string") return bin_name === path.basename(package_name) ? bin : void 0;
-  return bin?.[bin_name];
-}
-function resolve_package_bin(base_directory, package_name, bin_name) {
-  try {
-    const resolve_from = createRequire(path.join(base_directory, PACKAGE_JSON));
-    const manifest_path = resolve_from.resolve(`${package_name}/${PACKAGE_JSON}`);
-    const bin_entry = read_bin_entry(manifest_path, package_name, bin_name);
-    if (bin_entry === void 0) return void 0;
-    const cli_entry = path.join(path.dirname(manifest_path), bin_entry);
-    return existsSync(cli_entry) ? cli_entry : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-export {
-  vscode_settings_schema,
-  json_object_schema,
-  string_array_schema,
-  string_record_schema,
-  resolve_local_bin,
-  find_local_bin_upwards,
-  resolve_package_bin
-};

package/dist/hooks/chunk-GP4IEC4O.js

@@ -1,20 +0,0 @@
-// scripts/lib/ancestor-directories.ts
-import path from "node:path";
-var MAX_DEPTH = 64;
-function list(start_directory) {
-  const directories = [];
-  let current = path.resolve(start_directory);
-  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
-    directories.push(current);
-    current = path.dirname(current);
-  }
-  return directories;
-}
-function nearest(start_directory, is_match) {
-  return list(start_directory).find((directory) => is_match(directory));
-}
-var ancestor_directories = { list, nearest };
-
-export {
-  ancestor_directories
-};

package/dist/hooks/chunk-JP45SOCJ.js

@@ -1,56 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-LAOV7NLM.js";
-
-// scripts/lane/lane-guard-policy.ts
-var DEFAULT_MODE = "refuse";
-var OFF_MODE = "off";
-var LANE_GUARD_POLICY = [
-  {
-    id: "investigation",
-    mode_in_lane_child: "refuse",
-    because: "the notice was measured not to move the reading \u2014 52% of lane cost stayed in main-line exploration \u2014 and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line"
-  },
-  {
-    id: "batching",
-    mode_in_lane_child: "off",
-    because: "a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`"
-  },
-  {
-    id: "duplicate-read",
-    mode_in_lane_child: "notice",
-    because: "a refusal ends a child turn, yet unchanged re-reads are measured in lane children above all, so the child is nudged to scroll up to the earlier read by a notice rather than killed"
-  },
-  {
-    id: "rule",
-    mode_in_lane_child: "refuse",
-    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire"
-  }
-];
-var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
-function entry_for(id) {
-  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
-}
-function mode_in_lane_child(id) {
-  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
-}
-function mode_here(id, directory = process.cwd(), source = process.env) {
-  const lane_mode = mode_in_lane_child(id);
-  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
-  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
-}
-function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
-  return mode_here(id, directory, source) === OFF_MODE;
-}
-var lane_guard_policy = {
-  LANE_GUARD_POLICY,
-  KNOWN_GUARD_IDS,
-  entry_for,
-  mode_in_lane_child,
-  mode_here,
-  is_suppressed_here
-};
-
-export {
-  lane_guard_policy
-};