@syv-ai/rulecast 0.1.1 → 0.3.0

package/dist/chunk-7KUPYT35.js

@@ -0,0 +1,1977 @@
+import {
+  BACKLOG_HINT,
+  DeadlineError,
+  LLM_PROVIDERS,
+  VERSION,
+  compileFilter,
+  compileRule,
+  detectorCacheDir,
+  diskCache,
+  emptyDelivery,
+  errorMessage,
+  fileBytes,
+  formatZodError,
+  isDetectorRule,
+  isNotFound,
+  isOlder,
+  lineStarts,
+  measureRuleBlock,
+  readSourceFile,
+  referenceInputSchema,
+  renderAgentText,
+  renderTemplate,
+  sectionContains,
+  sectionRange,
+  sectionText,
+  templateBindings
+} from "./chunk-HZUATJ53.js";
+
+// src/core/config/load.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { parse } from "yaml";
+
+// src/core/config/schema.ts
+import { z } from "zod";
+var STAGES = ["touch", "edit", "verify"];
+var RULE_ID = /^[a-z0-9-]+(\/[a-z0-9-]+)*$/;
+var RULE_SCOPES = ["instance", "container"];
+var idSchema = z.string().regex(RULE_ID, "must be lowercase segments separated by /");
+var versionSchema = z.string().regex(/^\d+\.\d+\.\d+$/, "must be a version like 0.2.0");
+var stagesSchema = z.array(z.enum(STAGES)).nonempty();
+var exampleSchema = z.object({ path: z.string().min(1), code: z.string() }).strict();
+var ruleKeys = {
+  alias: idSchema.optional(),
+  name: z.string().min(1).optional(),
+  description: z.string().optional(),
+  files: z.string().optional(),
+  exclude: z.string().optional(),
+  types: z.array(z.string()).optional(),
+  types_or: z.array(z.string()).optional(),
+  exclude_types: z.array(z.string()).optional(),
+  stages: stagesSchema.optional(),
+  minimum_rulecast_version: versionSchema.optional(),
+  severity: z.enum(["error", "warning"]).optional(),
+  /**
+   * What the convention belongs to (§8). `instance`: the token the detector matched, classified by
+   * whether the agent's edit touched it. `container`: the node the match spans, classified by
+   * whether that node already violated the rule at the baseline.
+   */
+  scope: z.enum(RULE_SCOPES).optional(),
+  refuse_write: z.boolean().optional(),
+  detect: z.record(z.unknown()).refine((value) => Object.keys(value).length === 1, "must name exactly one detector").optional(),
+  message: z.string().optional(),
+  context: z.array(referenceInputSchema).optional(),
+  /** Code the rule must flag (`bad`) and must not (`good`), run by `rulecast test`. */
+  examples: z.object({ good: z.array(exampleSchema).default([]), bad: z.array(exampleSchema).default([]) }).strict().optional()
+};
+var overrideSchema = z.object({ id: idSchema, ...ruleKeys }).strict();
+var ruleSchema = overrideSchema.extend({ name: z.string().min(1) });
+var repoSchema = z.object({
+  repo: z.string().min(1),
+  rev: z.string().min(1).optional(),
+  /** Parsed rule by rule in compile, so one bad rule does not reject the config. */
+  rules: z.array(z.unknown())
+}).strict();
+var configSchema = z.object({
+  repos: z.array(repoSchema),
+  minimum_rulecast_version: versionSchema.optional(),
+  files: z.string().default(""),
+  exclude: z.string().default("^$"),
+  default_stages: stagesSchema.optional(),
+  context: z.object({
+    mode: z.enum(["inject", "read"]).default("inject"),
+    max_bytes: z.number().int().positive().default(32768)
+  }).strict().default({}),
+  max_matches_per_rule: z.number().int().positive().default(10),
+  /**
+   * Files above this many bytes are skipped by the in-process detectors on edit and guard, where
+   * an agent is waiting. `ast-grep` parses in native code, which the vm timeout that bounds
+   * `regex` cannot interrupt: a 2.6 MB TypeScript file measured 762 ms, and the cost is linear,
+   * so 26 MB would be 7.6 s of a blocked write. verify has seconds to spend and always runs.
+   */
+  max_file_bytes: z.number().int().positive().default(1048576),
+  timeouts: z.object({
+    edit_deadline_ms: z.number().int().positive().default(350),
+    verify_ms: z.number().int().positive().default(6e4)
+  }).strict().default({}),
+  stop_gate: z.object({ max_blocks: z.number().int().nonnegative().default(1) }).strict().default({}),
+  refuse_gate: z.object({ max_refusals: z.number().int().nonnegative().default(1) }).strict().default({}),
+  llm: z.object({
+    // No `model`: every llm rule names its own (plan 6a, Decision 1).
+    provider: z.enum(LLM_PROVIDERS).default("claude-code"),
+    base_url: z.string().nullable().default(null),
+    api_key_env: z.string().default("ANTHROPIC_API_KEY"),
+    max_files_per_verify: z.number().int().positive().default(10)
+  }).strict().default({})
+}).strict().transform((input) => ({
+  repos: input.repos,
+  minimumRulecastVersion: input.minimum_rulecast_version ?? null,
+  files: input.files,
+  exclude: input.exclude,
+  defaultStages: input.default_stages ?? null,
+  context: { mode: input.context.mode, maxBytes: input.context.max_bytes },
+  maxMatchesPerRule: input.max_matches_per_rule,
+  maxFileBytes: input.max_file_bytes,
+  timeouts: { editDeadlineMs: input.timeouts.edit_deadline_ms, verifyMs: input.timeouts.verify_ms },
+  stopGate: { maxBlocks: input.stop_gate.max_blocks },
+  refuseGate: { maxRefusals: input.refuse_gate.max_refusals },
+  llm: {
+    provider: input.llm.provider,
+    baseUrl: input.llm.base_url,
+    apiKeyEnv: input.llm.api_key_env,
+    maxFilesPerVerify: input.llm.max_files_per_verify
+  }
+}));
+function defaultConfig() {
+  return configSchema.parse({ repos: [] });
+}
+
+// src/core/config/load.ts
+var CONFIG_FILE = ".rulecast-config.yaml";
+var MANIFEST_FILE = ".rulecast-rules.yaml";
+async function readYamlFile(file) {
+  const name = path.basename(file);
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return { ok: false, message: `${name} not found` };
+    throw error;
+  }
+  try {
+    return { ok: true, value: parse(text) ?? null };
+  } catch (error) {
+    return { ok: false, message: `${name}: ${errorMessage(error)}` };
+  }
+}
+function readConfigData(root) {
+  return readYamlFile(path.join(root, CONFIG_FILE));
+}
+function parseConfig(data) {
+  const result = configSchema.safeParse(data);
+  if (!result.success) return { ok: false, message: `${CONFIG_FILE}: ${formatZodError(result.error)}` };
+  return { ok: true, value: result.data };
+}
+async function readManifest(dir) {
+  const loaded = await readYamlFile(path.join(dir, MANIFEST_FILE));
+  if (!loaded.ok) return loaded;
+  if (!Array.isArray(loaded.value)) return { ok: false, message: `${MANIFEST_FILE}: must be a list of rules` };
+  return { ok: true, value: loaded.value };
+}
+
+// src/core/home.ts
+import { createHash } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, realpathSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+function cacheHome(env) {
+  if (env.RULECAST_HOME) return path2.resolve(env.RULECAST_HOME);
+  if (env.XDG_CACHE_HOME) return path2.join(path2.resolve(env.XDG_CACHE_HOME), "rulecast");
+  return path2.join(homedir(), ".cache", "rulecast");
+}
+function projectStateDir(home, root) {
+  const hash = createHash("sha256").update(realpathSync(root)).digest("hex").slice(0, 16);
+  return path2.join(home, "projects", hash);
+}
+function ensureProjectState(home, root) {
+  const dir = projectStateDir(home, root);
+  const file = path2.join(dir, "root");
+  if (!existsSync(file)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file, `${realpathSync(root)}
+`);
+  }
+  return dir;
+}
+function debugLogger(stateDir, now = () => /* @__PURE__ */ new Date()) {
+  const file = path2.join(stateDir, "debug.log");
+  return (line) => {
+    try {
+      appendFileSync(file, `${now().toISOString()} ${line}
+`);
+    } catch {
+    }
+  };
+}
+
+// src/core/compile/project.ts
+import { readFile as readFile2 } from "fs/promises";
+function diagnosticText(diagnostic) {
+  const rule = diagnostic.rule ? ` (${diagnostic.rule})` : "";
+  return `${diagnostic.source}${rule}: ${diagnostic.message}`;
+}
+function createReader() {
+  const texts = /* @__PURE__ */ new Map();
+  return (file) => {
+    let text = texts.get(file);
+    if (!text) {
+      text = readFile2(file, "utf8").catch((error) => {
+        if (isNotFound(error)) return null;
+        throw error;
+      });
+      texts.set(file, text);
+    }
+    return text;
+  };
+}
+function idOf(raw) {
+  const id = raw?.id;
+  return typeof id === "string" ? id : null;
+}
+function isBranchLike(rev) {
+  return !rev.includes(".") && !/^[0-9a-f]+$/i.test(rev);
+}
+function uniqueRules(compiled, diagnostics, message) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { rule } of compiled) counts.set(rule.id, (counts.get(rule.id) ?? 0) + 1);
+  const rules = [];
+  for (const { rule, source } of compiled) {
+    if (counts.get(rule.id) === 1) rules.push(rule);
+    else diagnostics.push({ source, rule: rule.id, message: message(rule.id), level: "error" });
+  }
+  return rules;
+}
+async function compile(options) {
+  const { root } = options;
+  const configFailure = (message, config2 = defaultConfig()) => ({
+    root,
+    config: config2,
+    rules: [],
+    diagnostics: [{ source: CONFIG_FILE, rule: null, message, level: "error" }]
+  });
+  const data = options.configData !== void 0 ? { ok: true, value: options.configData } : await readConfigData(root);
+  if (!data.ok) return configFailure(data.message);
+  const parsed = parseConfig(data.value);
+  if (!parsed.ok) return configFailure(parsed.message);
+  const config = parsed.value;
+  if (config.minimumRulecastVersion !== null && isOlder(VERSION, config.minimumRulecastVersion)) {
+    return configFailure(`requires rulecast ${config.minimumRulecastVersion} or newer (running ${VERSION})`, config);
+  }
+  const global = compileFilter({
+    files: config.files,
+    exclude: config.exclude,
+    types: [],
+    typesOr: [],
+    excludeTypes: []
+  });
+  if (typeof global === "string") return configFailure(global, config);
+  const diagnostics = [];
+  const compiled = [];
+  const context = { config, registry: options.registry, global, read: createReader() };
+  const project = { dir: root, label: null };
+  const error = (source, rule, message, hint) => diagnostics.push({ source, rule, message, level: "error", ...hint === void 0 ? {} : { hint } });
+  const add = async (input, source) => {
+    const result = await compileRule(input, context);
+    if (typeof result === "string") error(source, input.data.alias ?? input.data.id, result);
+    else compiled.push({ rule: result, source });
+  };
+  for (const [index, entry] of config.repos.entries()) {
+    if (entry.repo === "local") {
+      if (entry.rev !== void 0) {
+        error(CONFIG_FILE, null, `repos[${index}]: local repos take no rev`);
+        continue;
+      }
+      for (const raw of entry.rules) {
+        const rule = ruleSchema.safeParse(raw);
+        if (!rule.success) error(CONFIG_FILE, idOf(raw), formatZodError(rule.error));
+        else await add({ data: rule.data, source: "local", contextRoot: project }, CONFIG_FILE);
+      }
+      continue;
+    }
+    if (entry.rev === void 0) {
+      error(CONFIG_FILE, null, `repos[${index}] ${entry.repo}: rev is required`);
+      continue;
+    }
+    const source = `${entry.repo}@${entry.rev}`;
+    if (isBranchLike(entry.rev)) {
+      diagnostics.push({
+        source,
+        rule: null,
+        message: `rev "${entry.rev}" looks like a branch: pin a tag or a full commit SHA`,
+        level: "warning"
+      });
+    }
+    const checkout = await options.repos.checkout(entry.repo, entry.rev);
+    if (!checkout.ok) {
+      error(source, null, checkout.message, checkout.missing ? "rulecast install" : void 0);
+      continue;
+    }
+    const manifest = await readManifest(checkout.dir);
+    if (!manifest.ok) {
+      error(source, null, manifest.message);
+      continue;
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const raw of manifest.value) {
+      const id = idOf(raw);
+      if (id !== null) byId.set(id, [...byId.get(id) ?? [], raw]);
+    }
+    const repoRoot = { dir: checkout.dir, label: checkout.label };
+    for (const raw of entry.rules) {
+      const override = overrideSchema.safeParse(raw);
+      if (!override.success) {
+        error(CONFIG_FILE, idOf(raw), formatZodError(override.error));
+        continue;
+      }
+      const { id } = override.data;
+      const candidates = byId.get(id) ?? [];
+      if (candidates.length !== 1) {
+        error(source, id, candidates.length === 0 ? "not in the manifest" : "defined more than once in the manifest");
+        continue;
+      }
+      const base = ruleSchema.safeParse(candidates[0]);
+      if (!base.success) {
+        error(source, id, `manifest: ${formatZodError(base.error)}`);
+        continue;
+      }
+      const data2 = { ...base.data, ...override.data };
+      const contextRoot = "context" in override.data ? project : repoRoot;
+      await add({ data: data2, source: checkout.label, contextRoot }, source);
+    }
+  }
+  const rules = uniqueRules(
+    compiled,
+    diagnostics,
+    (id) => `rule "${id}" is configured more than once: give one an alias`
+  );
+  return { root, config, rules, diagnostics };
+}
+async function compileManifest(dir, registry) {
+  const manifest = await readManifest(dir);
+  if (!manifest.ok) {
+    return {
+      rules: [],
+      diagnostics: [{ source: MANIFEST_FILE, rule: null, message: manifest.message, level: "error" }]
+    };
+  }
+  const diagnostics = [];
+  const compiled = [];
+  const context = { config: defaultConfig(), registry, global: () => true, read: createReader() };
+  for (const raw of manifest.value) {
+    const rule = ruleSchema.safeParse(raw);
+    if (!rule.success) {
+      diagnostics.push({ source: MANIFEST_FILE, rule: idOf(raw), message: formatZodError(rule.error), level: "error" });
+      continue;
+    }
+    const result = await compileRule({ data: rule.data, source: "local", contextRoot: { dir, label: null } }, context);
+    if (typeof result === "string") {
+      diagnostics.push({
+        source: MANIFEST_FILE,
+        rule: rule.data.alias ?? rule.data.id,
+        message: result,
+        level: "error"
+      });
+    } else compiled.push({ rule: result, source: MANIFEST_FILE });
+  }
+  const rules = uniqueRules(compiled, diagnostics, (id) => `rule "${id}" is defined more than once`);
+  return { rules, diagnostics };
+}
+
+// src/core/detection/select.ts
+function selectDetectorRules(rules, event, files, disabled) {
+  return rules.filter(
+    (rule) => isDetectorRule(rule) && rule.stages.includes(event) && !disabled.has(rule.id)
+  ).map((rule) => ({ rule, files: files.filter((file) => rule.matches(file)) })).filter((selection) => selection.files.length > 0);
+}
+function rulesOfKind(rules, kind) {
+  return rules.filter(isDetectorRule).filter((rule) => rule.detector.kind === kind).map((rule) => ({ id: rule.id, config: rule.detector.config }));
+}
+function selectTouchRules(rules, files, touched, disabled) {
+  return rules.filter(
+    (rule) => rule.stages.includes("touch") && !touched.has(rule.id) && !disabled.has(rule.id) && files.some((file) => rule.matches(file))
+  );
+}
+
+// src/core/detection/check.ts
+function checkableKinds(project, registry) {
+  const kinds = /* @__PURE__ */ new Set();
+  for (const rule of project.rules) {
+    const kind = rule.detector?.kind;
+    if (kind !== void 0 && registry.get(kind)?.check !== void 0) kinds.add(kind);
+  }
+  return [...kinds];
+}
+async function checkDetectors(options) {
+  const { project, registry } = options;
+  const kinds = checkableKinds(project, registry);
+  const signal = AbortSignal.timeout(options.timeoutMs);
+  const perKind = await Promise.all(
+    kinds.map(async (kind) => {
+      const detector = registry.get(kind);
+      const rules = rulesOfKind(project.rules, kind);
+      try {
+        const results = await detector.check({
+          rules,
+          settings: options.settings,
+          env: options.env,
+          cwd: project.root,
+          signal
+        });
+        return results.map((result) => ({ kind, ...result }));
+      } catch (error) {
+        return [
+          {
+            kind,
+            what: kind,
+            level: "error",
+            detail: errorMessage(error),
+            rules: rules.map((rule) => rule.id)
+          }
+        ];
+      }
+    })
+  );
+  return perKind.flat();
+}
+
+// src/core/repos/fetch.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, rename, rm as rm2 } from "fs/promises";
+import path5 from "path";
+
+// src/core/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+var INHERITED = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_COMMON_DIR",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_PREFIX"
+];
+function withoutInheritedGitEnv(env) {
+  const scrubbed = { ...env };
+  for (const name of INHERITED) delete scrubbed[name];
+  return scrubbed;
+}
+function environment(extra) {
+  return withoutInheritedGitEnv({ ...process.env, ...extra });
+}
+async function git(cwd, args, env) {
+  try {
+    const { stdout } = await exec("git", args, {
+      cwd,
+      maxBuffer: 64 * 1024 * 1024,
+      env: environment(env)
+    });
+    return { ok: true, stdout };
+  } catch (error) {
+    const failure = error;
+    if (failure.code === "ENOENT") throw new Error("git is not installed or not on PATH");
+    if (typeof failure.code === "number") return { ok: false, stderr: failure.stderr ?? "" };
+    throw error;
+  }
+}
+async function headCommit(cwd) {
+  const result = await git(cwd, ["rev-parse", "--verify", "-q", "HEAD"]);
+  return result.ok ? result.stdout.trim() : null;
+}
+async function fileAtCommit(cwd, commit, file) {
+  const result = await git(cwd, ["show", `${commit}:./${file}`]);
+  return result.ok ? result.stdout : null;
+}
+async function mergeBase(cwd, ref, other = "HEAD") {
+  const result = await git(cwd, ["merge-base", other, ref]);
+  if (!result.ok) throw new Error(`cannot find merge base with ${ref}: ${result.stderr.trim()}`);
+  return result.stdout.trim();
+}
+async function changedFilesSince(cwd, commit) {
+  const diff = await git(cwd, ["diff", "--name-only", "--relative", "--diff-filter=d", commit]);
+  if (!diff.ok) throw new Error(`git diff against ${commit} failed: ${diff.stderr.trim()}`);
+  const untracked = await git(cwd, ["ls-files", "--others", "--exclude-standard"]);
+  if (!untracked.ok) throw new Error(`git ls-files failed: ${untracked.stderr.trim()}`);
+  const files = [...diff.stdout.split("\n"), ...untracked.stdout.split("\n")].filter(Boolean);
+  return [...new Set(files)].sort();
+}
+function nulSeparated(stdout) {
+  return [...new Set(stdout.split("\0").filter(Boolean))].sort();
+}
+async function allFiles(cwd) {
+  const result = await git(cwd, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
+  if (!result.ok) throw new Error(`git ls-files failed: ${result.stderr.trim()}`);
+  return nulSeparated(result.stdout);
+}
+async function stagedFiles(cwd) {
+  const result = await git(cwd, ["diff", "--cached", "--name-only", "-z", "--relative", "--diff-filter=d"]);
+  if (!result.ok) throw new Error(`git diff --cached failed: ${result.stderr.trim()}`);
+  return nulSeparated(result.stdout);
+}
+async function changedFilesBetween(cwd, from, to) {
+  const result = await git(cwd, ["diff", "--name-only", "-z", "--relative", "--diff-filter=d", from, to]);
+  if (!result.ok) throw new Error(`git diff ${from} ${to} failed: ${result.stderr.trim()}`);
+  return nulSeparated(result.stdout);
+}
+
+// src/core/session/lock.ts
+import { mkdir, rm, stat } from "fs/promises";
+import path3 from "path";
+var LockTimeoutError = class extends Error {
+};
+var DEFAULTS = { waitMs: 2e3, staleMs: 5e3, retryMs: 20 };
+function isAlreadyExists(error) {
+  return error instanceof Error && error.code === "EEXIST";
+}
+async function withLock(dir, fn, options = DEFAULTS) {
+  const lock = path3.join(dir, ".lock");
+  await mkdir(dir, { recursive: true });
+  const started = Date.now();
+  for (; ; ) {
+    try {
+      await mkdir(lock);
+      break;
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+    try {
+      const { mtimeMs } = await stat(lock);
+      if (Date.now() - mtimeMs > options.staleMs) {
+        await rm(lock, { recursive: true, force: true });
+        continue;
+      }
+    } catch (error) {
+      if (!isNotFound(error)) throw error;
+      continue;
+    }
+    if (Date.now() - started > options.waitMs)
+      throw new LockTimeoutError(`could not lock ${dir} within ${options.waitMs} ms`);
+    await new Promise((resolve) => setTimeout(resolve, options.retryMs));
+  }
+  try {
+    return await fn();
+  } finally {
+    await rm(lock, { recursive: true, force: true });
+  }
+}
+
+// src/core/repos/layout.ts
+import { createHash as createHash2 } from "crypto";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+var SCP_LIKE = /^[^@/\s]+@([^:/\s]+):(.+)$/;
+function segmentsOf(repoPath) {
+  return repoPath.replace(/\/+$/, "").replace(/\.git$/, "").split("/").filter(Boolean);
+}
+function localName(file) {
+  return path4.basename(file.replace(/[\\/]+$/, "")).replace(/\.git$/, "");
+}
+function parseUrl(url) {
+  if (SCHEME.test(url)) {
+    const parsed = new URL(url);
+    if (parsed.protocol === "file:") return { kind: "local", name: localName(fileURLToPath(parsed)) };
+    return { kind: "hosted", host: parsed.hostname, segments: segmentsOf(decodeURIComponent(parsed.pathname)) };
+  }
+  const scp = url.match(SCP_LIKE);
+  if (scp) return { kind: "hosted", host: scp[1], segments: segmentsOf(scp[2]) };
+  return { kind: "local", name: localName(url) };
+}
+function safeSegment(value) {
+  const segment = value.replace(/[^A-Za-z0-9._-]/g, "_");
+  return /^\.*$/.test(segment) ? `_${segment}` : segment;
+}
+function repoName(url) {
+  const parsed = parseUrl(url);
+  return parsed.kind === "hosted" ? parsed.segments.join("/") || parsed.host : parsed.name;
+}
+function repoSlug(url) {
+  const parsed = parseUrl(url);
+  if (parsed.kind === "hosted") return safeSegment([parsed.host, ...parsed.segments].join("_"));
+  const hash = createHash2("sha256").update(url).digest("hex").slice(0, 8);
+  return safeSegment(`local_${parsed.name}_${hash}`);
+}
+function repoDir(home, url, rev) {
+  return path4.join(home, "repos", repoSlug(url), safeSegment(rev));
+}
+function repoLabel(url, rev) {
+  return `${repoName(url)}@${rev}`;
+}
+
+// src/core/repos/fetch.ts
+var RepoFetchError = class extends Error {
+};
+var NO_PROMPT = { GIT_TERMINAL_PROMPT: "0" };
+var FETCH_LOCK = { waitMs: 12e4, staleMs: 5 * 6e4, retryMs: 50 };
+async function run(cwd, args) {
+  const result = await git(cwd, args, NO_PROMPT);
+  if (!result.ok) throw new RepoFetchError(result.stderr.trim() || `git ${args[0]} failed`);
+}
+async function fetchCheckout(url, rev, into) {
+  await mkdir2(into, { recursive: true });
+  await run(into, ["init", "-q"]);
+  await run(into, ["fetch", "-q", "--depth", "1", url, rev]);
+  await run(into, ["-c", "advice.detachedHead=false", "checkout", "-q", "FETCH_HEAD"]);
+  await rm2(path5.join(into, ".git"), { recursive: true, force: true });
+}
+function cachedRepo(home, url, rev) {
+  const dir = repoDir(home, url, rev);
+  return existsSync2(dir) ? dir : null;
+}
+async function ensureRepo(home, url, rev) {
+  const dir = repoDir(home, url, rev);
+  if (existsSync2(dir)) return dir;
+  const parent = path5.dirname(dir);
+  await withLock(
+    parent,
+    async () => {
+      if (existsSync2(dir)) return;
+      const temp = path5.join(parent, `.tmp-${randomUUID()}`);
+      try {
+        await fetchCheckout(url, rev, temp);
+        await rename(temp, dir);
+      } finally {
+        await rm2(temp, { recursive: true, force: true });
+      }
+    },
+    FETCH_LOCK
+  );
+  return dir;
+}
+
+// src/core/repos/provider.ts
+function cachedRepos(home) {
+  return {
+    async checkout(url, rev) {
+      const dir = cachedRepo(home, url, rev);
+      if (dir === null) return { ok: false, missing: true, message: "not in the cache" };
+      return { ok: true, dir, label: repoLabel(url, rev) };
+    }
+  };
+}
+function fetchingRepos(home) {
+  return {
+    async checkout(url, rev) {
+      try {
+        return { ok: true, dir: await ensureRepo(home, url, rev), label: repoLabel(url, rev) };
+      } catch (error) {
+        return { ok: false, missing: false, message: `fetch failed: ${errorMessage(error)}` };
+      }
+    }
+  };
+}
+function fixedRepo(dir, label) {
+  return {
+    async checkout() {
+      return { ok: true, dir, label };
+    }
+  };
+}
+
+// src/core/pipeline.ts
+import { createHash as createHash3 } from "crypto";
+
+// src/core/baseline/changes.ts
+import { diffArrays } from "diff";
+function diffLines(before, after) {
+  const changed = [];
+  const runs = [];
+  const mark = (start, end) => {
+    const previous = changed.at(-1);
+    if (previous && start <= previous[1] + 1) previous[1] = Math.max(previous[1], end);
+    else changed.push([start, end]);
+  };
+  let line = 1;
+  let baselineLine = 1;
+  for (const part of diffArrays(Array.from(before), Array.from(after))) {
+    const count = part.count ?? part.value.length;
+    if (part.added) {
+      mark(line, line + count - 1);
+      line += count;
+    } else if (part.removed) {
+      if (after.length > 0) {
+        const at = Math.min(line, after.length);
+        mark(at, at);
+      }
+      baselineLine += count;
+    } else {
+      runs.push({ beforeStart: baselineLine, afterStart: line, count });
+      line += count;
+      baselineLine += count;
+    }
+  }
+  return { changed, map: { runs, afterLines: after.length } };
+}
+function identityMap(lines) {
+  return { runs: lines === 0 ? [] : [{ beforeStart: 1, afterStart: 1, count: lines }], afterLines: lines };
+}
+
+// src/core/baseline/hash.ts
+var OFFSET_BASIS = 2166136261;
+var PRIME = 16777619;
+function fnv1a(text) {
+  let hash = OFFSET_BASIS;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, PRIME);
+  }
+  return hash >>> 0;
+}
+function hashLines(text) {
+  const lines = text.split(/\r?\n/);
+  const hashes = new Uint32Array(lines.length);
+  lines.forEach((line, index) => {
+    hashes[index] = fnv1a(line.trim());
+  });
+  return hashes;
+}
+function hashOfHashes(lines) {
+  let hash = OFFSET_BASIS;
+  for (const value of lines) {
+    for (let shift = 0; shift < 32; shift += 8) {
+      hash ^= value >>> shift & 255;
+      hash = Math.imul(hash, PRIME);
+    }
+  }
+  return hash >>> 0;
+}
+function snapshotOf(text) {
+  const lines = hashLines(text);
+  return { fileHash: hashOfHashes(lines), lines };
+}
+
+// src/core/baseline/baseline.ts
+async function computeChanges(root, files, sources) {
+  const changes = { sets: /* @__PURE__ */ new Map(), maps: /* @__PURE__ */ new Map(), fromCommit: /* @__PURE__ */ new Map() };
+  for (const file of files) {
+    if (!sources.snapshots.has(file) && !sources.fallbackCommit) continue;
+    let before = sources.snapshots.get(file) ?? null;
+    let commitText = null;
+    if (!before && sources.fallbackCommit) {
+      commitText = await fileAtCommit(root, sources.fallbackCommit, file);
+      before = commitText === null ? null : snapshotOf(commitText);
+    }
+    if (!before) continue;
+    const current = await readSourceFile(root, file);
+    if (current === null) continue;
+    if (commitText !== null) changes.fromCommit.set(file, commitText);
+    const after = snapshotOf(current);
+    if (after.fileHash === before.fileHash) {
+      changes.sets.set(file, { changedLines: [] });
+      changes.maps.set(file, identityMap(after.lines.length));
+      continue;
+    }
+    const diff = diffLines(before.lines, after.lines);
+    changes.sets.set(file, { changedLines: diff.changed });
+    changes.maps.set(file, diff.map);
+  }
+  return changes;
+}
+function isNew(match, changes) {
+  const change = changes.get(match.file);
+  if (!change) return true;
+  return change.changedLines.some(([start, end]) => match.line <= end && match.endLine >= start);
+}
+
+// src/core/baseline/fingerprint.ts
+function mapRange(map, [start, end]) {
+  let first = null;
+  let last = 0;
+  for (const run2 of map.runs) {
+    const from = Math.max(start, run2.beforeStart);
+    const to = Math.min(end, run2.beforeStart + run2.count - 1);
+    if (from > to) continue;
+    if (first === null) first = run2.afterStart + (from - run2.beforeStart);
+    last = run2.afterStart + (to - run2.beforeStart);
+  }
+  return first === null ? null : [first, last];
+}
+function classify(match, scope, rule, changes, fingerprints) {
+  const instance = () => isNew(match, changes.sets) ? "new" : "preexisting";
+  if (scope === "instance") return instance();
+  const recorded = fingerprints.get(match.file)?.get(rule);
+  const map = changes.maps.get(match.file);
+  if (recorded === void 0 || map === void 0) return instance();
+  for (const range of recorded) {
+    const mapped = mapRange(map, range);
+    if (mapped !== null && match.line <= mapped[1] && match.endLine >= mapped[0]) return "preexisting";
+  }
+  return "new";
+}
+
+// src/core/detection/budget.ts
+function applyFileBudget(kind, selections, maxFiles, recent) {
+  const ofKind = selections.filter((selection) => selection.rule.detector?.kind === kind);
+  const files = [...new Set(ofKind.flatMap((selection) => selection.files))];
+  if (files.length <= maxFiles) return { selections, skipped: [] };
+  const rank = new Map(recent.map((file, index) => [file, index]));
+  const ordered = [...files].sort((a, b) => (rank.get(a) ?? recent.length) - (rank.get(b) ?? recent.length));
+  const keep = new Set(ordered.slice(0, maxFiles));
+  return {
+    selections: selections.map(
+      (selection) => selection.rule.detector?.kind === kind ? { ...selection, files: selection.files.filter((file) => keep.has(file)) } : selection
+    ).filter((selection) => selection.files.length > 0),
+    skipped: ordered.slice(maxFiles)
+  };
+}
+async function applySizeCeiling(selections, maxBytes, bounded, sizeOf) {
+  const files = [...new Set(selections.filter((one) => bounded(one.rule.detector.kind)).flatMap((one) => one.files))];
+  if (files.length === 0) return { selections, skipped: [] };
+  const sizes = await Promise.all(files.map(async (file) => [file, await sizeOf(file)]));
+  const over = new Set(sizes.filter(([, size]) => size !== null && size > maxBytes).map(([file]) => file));
+  if (over.size === 0) return { selections, skipped: [] };
+  return {
+    selections: selections.map(
+      (selection) => bounded(selection.rule.detector.kind) ? { ...selection, files: selection.files.filter((file) => !over.has(file)) } : selection
+    ).filter((selection) => selection.files.length > 0),
+    skipped: files.filter((file) => over.has(file))
+  };
+}
+
+// src/core/detection/run.ts
+var TIMED_OUT = /* @__PURE__ */ Symbol("timed out");
+async function runDetection(input) {
+  const output = { findings: [], errors: [], timedOut: [] };
+  const byKind = /* @__PURE__ */ new Map();
+  for (const selection of input.selections) {
+    const kind = selection.rule.detector.kind;
+    const group = byKind.get(kind);
+    if (group === void 0) byKind.set(kind, [selection]);
+    else group.push(selection);
+  }
+  const controller = new AbortController();
+  const deadline = new Promise((resolve) => {
+    controller.signal.addEventListener("abort", () => resolve(TIMED_OUT), { once: true });
+  });
+  const timer = setTimeout(() => controller.abort(), input.timeoutMs);
+  const deadlineAt = Date.now() + input.timeoutMs;
+  const late = () => Date.now() > deadlineAt;
+  const perKind = await Promise.all(
+    [...byKind].map(async ([kind, selections]) => {
+      const detector = input.registry.get(kind);
+      if (!detector) return { status: "error", kind, selections, message: `detector "${kind}" is not registered` };
+      try {
+        const rules = await Promise.all(
+          selections.map(async ({ rule, files }) => ({
+            id: rule.id,
+            config: rule.detector.config,
+            files,
+            context: await input.contextFor(rule)
+          }))
+        );
+        const result = await Promise.race([
+          detector.run({
+            event: input.event,
+            rules,
+            read: input.read,
+            changes: input.changes,
+            cache: input.cacheFor(kind),
+            settings: input.settings,
+            cwd: input.root,
+            signal: controller.signal,
+            deadlineAt
+          }),
+          deadline
+        ]);
+        if (result === TIMED_OUT || late()) return { status: "timedOut", kind, selections };
+        return { status: "ok", kind, selections, result };
+      } catch (error) {
+        if (error instanceof DeadlineError || controller.signal.aborted || late()) {
+          return { status: "timedOut", kind, selections };
+        }
+        return { status: "error", kind, selections, message: errorMessage(error) };
+      }
+    })
+  );
+  clearTimeout(timer);
+  for (const outcome of perKind) {
+    const ids = outcome.selections.map((selection) => selection.rule.id);
+    if (outcome.status === "timedOut") {
+      output.timedOut.push({ kind: outcome.kind, rules: ids });
+      continue;
+    }
+    if (outcome.status === "error") {
+      output.errors.push({ kind: outcome.kind, rules: ids, message: outcome.message });
+      continue;
+    }
+    const result = outcome.result;
+    const rulesById = new Map(outcome.selections.map((selection) => [selection.rule.id, selection.rule]));
+    const stray = result.findings.find((finding) => !rulesById.has(finding.rule));
+    const wholeRun = result.errors.find((error) => error.rule === null);
+    if (stray || wholeRun) {
+      const message = stray ? `detector reported unknown rule "${stray.rule}"` : wholeRun.message;
+      output.errors.push({ kind: outcome.kind, rules: ids, message });
+      continue;
+    }
+    const failed = /* @__PURE__ */ new Map();
+    for (const error of result.errors) failed.set(error.rule, error.message);
+    for (const finding of result.findings) {
+      const rule = rulesById.get(finding.rule);
+      const missing = rule.detector.captures.find((name) => typeof finding.match.captures[name] !== "string");
+      if (missing && !failed.has(rule.id)) failed.set(rule.id, `match is missing declared capture "${missing}"`);
+    }
+    for (const [rule, message] of failed) output.errors.push({ kind: outcome.kind, rules: [rule], message });
+    for (const finding of result.findings) {
+      if (!failed.has(finding.rule)) output.findings.push({ rule: rulesById.get(finding.rule), match: finding.match });
+    }
+  }
+  return output;
+}
+
+// src/core/baseline/store.ts
+import path7 from "path";
+
+// src/core/jsonl.ts
+import { mkdir as mkdir3, open, readFile as readFile3 } from "fs/promises";
+import path6 from "path";
+var CorruptStoreError = class extends Error {
+};
+async function appendRecords(file, records) {
+  if (records.length === 0) return;
+  await mkdir3(path6.dirname(file), { recursive: true });
+  const handle = await open(file, "a+");
+  try {
+    await dropPartialRecord(handle);
+    await handle.appendFile(records.map((record) => `${JSON.stringify(record)}
+`).join(""));
+  } finally {
+    await handle.close();
+  }
+}
+var TAIL_CHUNK = 64 * 1024;
+async function dropPartialRecord(handle) {
+  const { size } = await handle.stat();
+  let end = size;
+  while (end > 0) {
+    const start = Math.max(0, end - TAIL_CHUNK);
+    const chunk = Buffer.alloc(end - start);
+    await handle.read(chunk, 0, chunk.length, start);
+    const newline = chunk.lastIndexOf(10);
+    if (newline !== -1) {
+      end = start + newline + 1;
+      break;
+    }
+    end = start;
+  }
+  if (end < size) await handle.truncate(end);
+}
+async function readRecords(file) {
+  let text;
+  try {
+    text = await readFile3(file, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return [];
+    throw error;
+  }
+  const lines = text.split("\n");
+  const records = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      if (i === lines.length - 1) break;
+      throw new CorruptStoreError(`${file}: unparseable record on line ${i + 1}`);
+    }
+  }
+  return records;
+}
+
+// src/core/baseline/store.ts
+function storeFile(sessionDir2) {
+  return path7.join(sessionDir2, "baseline.jsonl");
+}
+function encodeLines(lines) {
+  return Buffer.from(lines.buffer, lines.byteOffset, lines.byteLength).toString("base64");
+}
+function decodeLines(encoded) {
+  const bytes = Buffer.from(encoded, "base64");
+  const aligned = new Uint8Array(bytes.length);
+  aligned.set(bytes);
+  return new Uint32Array(aligned.buffer);
+}
+function startRecord(commit) {
+  return { t: "start", commit };
+}
+function snapshotRecord(file, snapshot) {
+  return { t: "snapshot", file, fileHash: snapshot.fileHash, lines: encodeLines(snapshot.lines) };
+}
+function fingerprintRecord(file, rule, ranges) {
+  return { t: "fingerprint", file, rule, ranges };
+}
+async function appendBaseline(sessionDir2, records) {
+  await appendRecords(storeFile(sessionDir2), records);
+}
+async function readBaseline(sessionDir2) {
+  const state = { started: false, startCommit: null, snapshots: /* @__PURE__ */ new Map(), fingerprints: /* @__PURE__ */ new Map() };
+  for (const record of await readRecords(storeFile(sessionDir2))) {
+    if (record.t === "start" && !state.started) {
+      state.started = true;
+      state.startCommit = record.commit;
+    } else if (record.t === "snapshot" && !state.snapshots.has(record.file)) {
+      state.snapshots.set(record.file, { fileHash: record.fileHash, lines: decodeLines(record.lines) });
+    } else if (record.t === "fingerprint") {
+      const byRule = state.fingerprints.get(record.file) ?? /* @__PURE__ */ new Map();
+      state.fingerprints.set(record.file, byRule);
+      if (!byRule.has(record.rule)) byRule.set(record.rule, record.ranges);
+    }
+  }
+  return state;
+}
+
+// src/core/baseline/record.ts
+async function recordFingerprints(input) {
+  if (!input.rules.some((rule) => rule.scope === "container")) return [];
+  const guards = (kind) => input.registry.get(kind)?.guards === true;
+  let selections = selectDetectorRules(input.rules, input.event, input.files, input.disabled).filter(
+    (selection) => selection.rule.scope === "container" && selection.rule.detector.kind !== "llm" && (input.source === "disk" || guards(selection.rule.detector.kind))
+  );
+  if (input.ceiling) {
+    const applied = await applySizeCeiling(selections, input.ceiling.maxFileBytes, guards, input.ceiling.sizeOf);
+    selections = applied.selections;
+  }
+  if (selections.length === 0) return [];
+  const output = await runDetection({
+    root: input.root,
+    event: input.event,
+    selections,
+    // No change set: the baseline content is being measured whole, and there is nothing it is a
+    // change from. A detector that reads `changes` treats an absent file as entirely new, which is
+    // exactly right here.
+    changes: /* @__PURE__ */ new Map(),
+    read: input.read,
+    registry: input.registry,
+    cacheFor: input.cacheFor,
+    contextFor: input.contextFor,
+    settings: input.settings,
+    timeoutMs: input.timeoutMs
+  });
+  const unmeasured = /* @__PURE__ */ new Set();
+  for (const error of output.errors) for (const rule of error.rules) unmeasured.add(rule);
+  for (const timeout of output.timedOut) for (const rule of timeout.rules) unmeasured.add(rule);
+  const key = (file, rule) => `${file}\0${rule}`;
+  const ranges = /* @__PURE__ */ new Map();
+  for (const { rule, match } of output.findings) {
+    const found = ranges.get(key(match.file, rule.id));
+    if (found === void 0) ranges.set(key(match.file, rule.id), [[match.line, match.endLine]]);
+    else found.push([match.line, match.endLine]);
+  }
+  const records = [];
+  for (const { rule, files } of selections) {
+    if (unmeasured.has(rule.id)) continue;
+    for (const file of files) records.push(fingerprintRecord(file, rule.id, ranges.get(key(file, rule.id)) ?? []));
+  }
+  return records;
+}
+
+// src/core/delivery/persist.ts
+import { mkdirSync as mkdirSync2, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import path8 from "path";
+var KEEP = 3;
+var UNLIMITED = { maxMatchesPerRule: Number.MAX_SAFE_INTEGER };
+var safeSegment2 = (value) => value.replace(/[^A-Za-z0-9._-]/g, "_");
+function markdown(delivery, now) {
+  const body = renderAgentText({ ...delivery, overflowPath: null }, UNLIMITED);
+  return [
+    `# rulecast delivery \u2014 ${now.toISOString()}`,
+    "",
+    "Too much to fit in one hook message. Everything rulecast found for the files in this session,",
+    "with the doc section each rule cites:",
+    "",
+    body,
+    ""
+  ].join("\n");
+}
+function writeOverflow(stateDir, session, delivery, now = /* @__PURE__ */ new Date()) {
+  const prefix = safeSegment2(session ?? "no-session");
+  const dir = path8.join(stateDir, "deliveries");
+  const file = path8.join(dir, `${prefix}-${now.toISOString().replace(/[:.]/g, "-")}.md`);
+  try {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(file, markdown(delivery, now));
+    const mine = readdirSync(dir).filter((name) => name.startsWith(`${prefix}-`)).sort();
+    for (const old of mine.slice(0, Math.max(0, mine.length - KEEP))) rmSync(path8.join(dir, old), { force: true });
+    return file;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/delivery/resolve.ts
+async function resolveRuleContext(resolver, context) {
+  const references = [];
+  for (const spec of context) {
+    const resolved = await resolver.resolve(spec);
+    if (resolved.found) references.push({ ref: spec.ref, content: resolved.content });
+  }
+  return references;
+}
+function createReferenceResolver(root) {
+  const texts = /* @__PURE__ */ new Map();
+  const read = (path11) => {
+    let text = texts.get(path11);
+    if (!text) {
+      text = readSourceFile(root, path11);
+      texts.set(path11, text);
+    }
+    return text;
+  };
+  const contentOf = async (path11, anchor) => {
+    const text = await read(path11);
+    if (text === null) return null;
+    if (anchor === null) return text.trimEnd();
+    const section = sectionRange(text, anchor);
+    return section ? sectionText(text, section) : null;
+  };
+  return {
+    async resolve(spec) {
+      const content = await contentOf(spec.path, spec.anchor);
+      if (content === null) return { spec, found: false };
+      return { spec, found: true, content, hash: fnv1a(content), bytes: Buffer.byteLength(content) };
+    },
+    async currentHash(path11, anchor) {
+      const content = await contentOf(path11, anchor);
+      return content === null ? null : fnv1a(content);
+    },
+    async contains(path11, parent, child) {
+      if (parent === null) return true;
+      if (child === null) return false;
+      const text = await read(path11);
+      return text !== null && sectionContains(text, parent, child);
+    }
+  };
+}
+
+// src/core/detection/proposal.ts
+function propose(current, intent) {
+  if (intent.content !== void 0) {
+    return { content: intent.content, inserts: intent.content === "" ? [] : [[0, intent.content.length]] };
+  }
+  if (intent.edit === void 0 || current === null) return null;
+  const { find, replace, all } = intent.edit;
+  if (find === "") return null;
+  const first = current.indexOf(find);
+  if (first === -1) return null;
+  if (!all && current.indexOf(find, first + find.length) !== -1) return null;
+  let content = "";
+  let rest = current;
+  const inserts = [];
+  for (; ; ) {
+    const at = rest.indexOf(find);
+    if (at === -1) break;
+    const start = content.length + at;
+    content += rest.slice(0, at) + replace;
+    if (replace !== "") inserts.push([start, start + replace.length]);
+    rest = rest.slice(at + find.length);
+    if (!all) break;
+  }
+  return { content: content + rest, inserts };
+}
+function isInserted(proposal, match, detector) {
+  if (detector === "path") return true;
+  const starts = lineStarts(proposal.content);
+  const lineStart = starts[match.line - 1];
+  if (lineStart === void 0) return false;
+  const start = lineStart + match.column - 1;
+  const end = start + match.text.length;
+  return proposal.inserts.some(([from, to]) => start < to && end > from);
+}
+
+// src/core/session/decide.ts
+import path9 from "path";
+
+// src/core/session/state.ts
+function preexistingKey(rule, file) {
+  return `${rule} ${file}`;
+}
+var refusalKey = preexistingKey;
+function emptyWork() {
+  return { edited: [], stopBlocks: /* @__PURE__ */ new Map(), refusals: /* @__PURE__ */ new Map(), disabled: /* @__PURE__ */ new Map(), accessed: /* @__PURE__ */ new Map() };
+}
+function emptyContext() {
+  return { delivered: [], touched: /* @__PURE__ */ new Set(), preexisting: /* @__PURE__ */ new Set(), warned: /* @__PURE__ */ new Set() };
+}
+function foldWork(records) {
+  const state = emptyWork();
+  for (const record of records) {
+    switch (record.t) {
+      case "edited":
+        state.edited = [...state.edited.filter((file) => file !== record.file), record.file];
+        break;
+      case "accessed": {
+        const files = state.accessed.get(record.agent) ?? [];
+        state.accessed.set(record.agent, [...files.filter((file) => file !== record.file), record.file]);
+        break;
+      }
+      case "stopBlock":
+        state.stopBlocks.set(record.agent, (state.stopBlocks.get(record.agent) ?? 0) + 1);
+        break;
+      case "refused": {
+        const key = refusalKey(record.rule, record.file);
+        state.refusals.set(key, (state.refusals.get(key) ?? 0) + 1);
+        break;
+      }
+      case "prompt":
+        state.stopBlocks.delete(record.agent);
+        break;
+      case "disabled":
+        if (!state.disabled.has(record.rule)) state.disabled.set(record.rule, record.reason);
+        break;
+    }
+  }
+  return state;
+}
+function foldContext(records) {
+  let state = emptyContext();
+  for (const record of records) {
+    switch (record.t) {
+      case "reset":
+        state = emptyContext();
+        break;
+      case "delivered":
+        state.delivered.push({ path: record.path, anchor: record.anchor, hash: record.hash });
+        break;
+      case "touched":
+        state.touched.add(record.rule);
+        break;
+      case "preexisting":
+        state.preexisting.add(preexistingKey(record.rule, record.file));
+        break;
+      case "warned":
+        state.warned.add(record.key);
+        break;
+    }
+  }
+  return state;
+}
+
+// src/core/session/decide.ts
+var ITEM_OVERHEAD = 64;
+var HEADER_OVERHEAD = 128;
+var OVERFLOW_NOTICE = 256;
+var REFERENCE_OVERHEAD = 96;
+var BACKLOG_HEADING = "backlog in files you touched (not from your edit):";
+var WARNING_SHARE = 0.15;
+var moreWarnings = (count) => `\u2026and ${count} more (run rulecast validate)`;
+function locationOf(spec) {
+  return path9.isAbsolute(spec.path) ? { location: spec.path } : {};
+}
+function capturesFor(rule, match) {
+  const names = templateBindings(rule.message ?? "");
+  if (names.length === 0) return void 0;
+  const values = {};
+  for (const name of names) {
+    const value = name === "text" ? match.text : match.captures[name];
+    if (value !== void 0) values[name] = value;
+  }
+  return values;
+}
+function renderFindings(findings) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const { rule, match } of findings) {
+    const message = renderTemplate(rule.message ?? "", {
+      ...match.captures,
+      file: match.file,
+      line: String(match.line),
+      column: String(match.column),
+      text: match.text,
+      rule: rule.id
+    });
+    const key = `${rule.id} ${match.file} ${message}`;
+    const existing = merged.get(key);
+    if (existing) existing.count++;
+    else
+      merged.set(key, {
+        rule: rule.id,
+        severity: rule.severity,
+        status: "new",
+        file: match.file,
+        line: match.line,
+        column: match.column,
+        message,
+        count: 1,
+        captures: capturesFor(rule, match)
+      });
+  }
+  return [...merged.values()].sort(
+    (a, b) => Number(a.severity === "warning") - Number(b.severity === "warning") || (a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0) || (a.file < b.file ? -1 : a.file > b.file ? 1 : 0) || a.line - b.line
+  );
+}
+function referencesInOrder(rules) {
+  const seen = /* @__PURE__ */ new Set();
+  const specs = [];
+  for (const rule of rules) {
+    for (const spec of rule.context) {
+      if (seen.has(spec.ref)) continue;
+      seen.add(spec.ref);
+      specs.push(spec);
+    }
+  }
+  return specs;
+}
+async function isCovered(spec, delivered, resolver) {
+  for (const entry of delivered) {
+    if (entry.path !== spec.path) continue;
+    if (!await resolver.contains(spec.path, entry.anchor, spec.anchor)) continue;
+    if (await resolver.currentHash(entry.path, entry.anchor) === entry.hash) return true;
+  }
+  return false;
+}
+async function decide(input) {
+  const delivery = emptyDelivery();
+  const work = [];
+  const context = [];
+  const fresh = input.findings.filter((finding) => finding.status === "new");
+  delivery.findings = renderFindings(fresh);
+  const rulesById = new Map(fresh.map(({ rule }) => [rule.id, rule]));
+  for (const { rule } of fresh) if (rule.message !== null) delivery.templates[rule.id] = rule.message;
+  const summaries = /* @__PURE__ */ new Map();
+  for (const { rule, match, status } of input.findings) {
+    if (status !== "preexisting") continue;
+    const key = preexistingKey(rule.id, match.file);
+    if (input.context.preexisting.has(key)) continue;
+    const summary = summaries.get(key) ?? { rule: rule.id, file: match.file, count: 0 };
+    summary.count++;
+    summaries.set(key, summary);
+  }
+  delivery.preexistingSummary = [...summaries.values()];
+  const unwarned = input.warnings.filter((warning) => !input.context.warned.has(warning.key));
+  delivery.warnings = unwarned.map((warning) => warning.text);
+  delivery.touches = input.touches.map((rule) => rule.id);
+  for (const rule of input.touches) context.push({ t: "touched", rule: rule.id });
+  const delivered = [...input.context.delivered];
+  if (input.agentRead !== null) {
+    const hash = await input.resolver.currentHash(input.agentRead, null);
+    if (hash !== null) {
+      delivered.push({ path: input.agentRead, anchor: null, hash });
+      context.push({ t: "delivered", path: input.agentRead, anchor: null, hash });
+    }
+  }
+  const ruleOrder = [...new Map(fresh.map((finding) => [finding.rule.id, finding.rule])).values(), ...input.touches];
+  const candidates = [];
+  for (const spec of referencesInOrder(ruleOrder)) {
+    const resolved = await input.resolver.resolve(spec);
+    if (!resolved.found) {
+      delivery.references.push({ ref: spec.ref, state: "missing" });
+    } else if (await isCovered(spec, delivered, input.resolver)) {
+      delivery.references.push({ ref: spec.ref, state: "pointer" });
+    } else if (spec.mode === "read") {
+      delivery.references.push({ ref: spec.ref, state: "read", reason: "mode", ...locationOf(spec) });
+    } else if (resolved.bytes > input.maxBytes) {
+      delivery.references.push({ ref: spec.ref, state: "read", reason: "tooLarge", ...locationOf(spec) });
+    } else {
+      candidates.push({ index: delivery.references.length, resolved });
+      delivery.references.push({ ref: spec.ref, state: "full", content: resolved.content });
+    }
+  }
+  const limit = input.maxContextChars;
+  const render = { maxMatchesPerRule: input.maxMatchesPerRule };
+  const complete = {
+    ...delivery,
+    findings: [...delivery.findings],
+    preexistingSummary: [...delivery.preexistingSummary],
+    references: [...delivery.references],
+    warnings: [...delivery.warnings],
+    omitted: { findings: [], rules: 0, preexisting: 0 }
+  };
+  const byRule = /* @__PURE__ */ new Map();
+  for (const finding of delivery.findings) {
+    const group = byRule.get(finding.rule);
+    if (group === void 0) byRule.set(finding.rule, [finding]);
+    else group.push(finding);
+  }
+  let used = HEADER_OVERHEAD;
+  const fits = (size) => limit === null || used + size <= limit;
+  const kept = /* @__PURE__ */ new Map();
+  const lineCost = (ref) => ref.length + REFERENCE_OVERHEAD;
+  const resolvedRefs = new Set(delivery.references.map((reference) => reference.ref));
+  const charged = /* @__PURE__ */ new Set();
+  const orphaned = /* @__PURE__ */ new Set();
+  const floorWithin = (cap) => {
+    const spent = { chars: 0, kept: /* @__PURE__ */ new Map(), refs: /* @__PURE__ */ new Set(), dropped: 0 };
+    const uncharged = (rule) => [
+      ...new Set(rule.context.map((spec) => spec.ref).filter((ref) => resolvedRefs.has(ref) && !spent.refs.has(ref)))
+    ];
+    for (const [id, findings] of byRule) {
+      const rule = rulesById.get(id);
+      const refs = rule === void 0 ? [] : uncharged(rule);
+      const size = measureRuleBlock(id, [findings[0]], delivery.templates[id], render) + refs.reduce((sum, ref) => sum + lineCost(ref), 0);
+      if (used + spent.chars + size > cap) {
+        spent.dropped++;
+        continue;
+      }
+      spent.chars += size;
+      for (const ref of refs) spent.refs.add(ref);
+      spent.kept.set(id, [findings[0]]);
+    }
+    for (const touch of input.touches) {
+      for (const ref of uncharged(touch)) {
+        spent.chars += lineCost(ref);
+        spent.refs.add(ref);
+      }
+    }
+    return spent;
+  };
+  if (limit !== null) {
+    let floor = floorWithin(limit);
+    if (floor.dropped > 0) floor = floorWithin(limit - OVERFLOW_NOTICE);
+    used += floor.chars + (floor.dropped > 0 ? OVERFLOW_NOTICE : 0);
+    delivery.omitted.rules = floor.dropped;
+    for (const [id, findings] of floor.kept) kept.set(id, findings);
+    for (const ref of floor.refs) charged.add(ref);
+    for (const ref of resolvedRefs) if (!charged.has(ref)) orphaned.add(ref);
+  }
+  const warningCost = (text) => text.length + ITEM_OVERHEAD;
+  if (limit === null) {
+    for (const warning of unwarned) context.push({ t: "warned", key: warning.key });
+  } else {
+    const ceiling = Math.max(0, Math.min(Math.floor(limit * WARNING_SHARE), limit - used));
+    let spent = 0;
+    let held = 0;
+    while (held < unwarned.length && spent + warningCost(unwarned[held].text) <= ceiling) {
+      spent += warningCost(unwarned[held].text);
+      held++;
+    }
+    if (held < unwarned.length) {
+      while (held > 0 && spent + warningCost(moreWarnings(unwarned.length - held)) > ceiling) {
+        held--;
+        spent -= warningCost(unwarned[held].text);
+      }
+    }
+    delivery.warnings = unwarned.slice(0, held).map((warning) => warning.text);
+    for (const warning of unwarned.slice(0, held)) context.push({ t: "warned", key: warning.key });
+    const cut = unwarned.length - held;
+    if (cut > 0 && spent + warningCost(moreWarnings(cut)) <= ceiling) {
+      spent += warningCost(moreWarnings(cut));
+      delivery.warnings.push(moreWarnings(cut));
+    }
+    used += spent;
+  }
+  for (const { index, resolved } of candidates) {
+    const size = resolved.content.length;
+    if (orphaned.has(resolved.spec.ref)) continue;
+    if (!fits(size)) {
+      delivery.references[index] = {
+        ref: resolved.spec.ref,
+        state: "read",
+        reason: "budget",
+        ...locationOf(resolved.spec)
+      };
+      continue;
+    }
+    used += size;
+    context.push({ t: "delivered", path: resolved.spec.path, anchor: resolved.spec.anchor, hash: resolved.hash });
+  }
+  if (delivery.preexistingSummary.length > 0) used += BACKLOG_HEADING.length + BACKLOG_HINT.length + ITEM_OVERHEAD;
+  const summariesKept = [];
+  for (const summary of delivery.preexistingSummary) {
+    if (!fits(summary.rule.length + summary.file.length + ITEM_OVERHEAD)) {
+      delivery.omitted.preexisting++;
+      continue;
+    }
+    used += summary.rule.length + summary.file.length + ITEM_OVERHEAD;
+    summariesKept.push(summary);
+    context.push({ t: "preexisting", rule: summary.rule, file: summary.file });
+  }
+  delivery.preexistingSummary = summariesKept;
+  if (orphaned.size > 0) delivery.references = delivery.references.filter((one) => !orphaned.has(one.ref));
+  if (limit !== null) {
+    for (let added = true; added; ) {
+      added = false;
+      for (const [rule, findings] of byRule) {
+        const shown = kept.get(rule);
+        if (shown === void 0 || shown.length >= Math.min(findings.length, input.maxMatchesPerRule)) continue;
+        const template = delivery.templates[rule];
+        const delta = measureRuleBlock(rule, [...shown, findings[shown.length]], template, render) - measureRuleBlock(rule, shown, template, render);
+        if (!fits(delta)) continue;
+        used += delta;
+        shown.push(findings[shown.length]);
+        added = true;
+      }
+    }
+    for (const [rule, findings] of byRule) {
+      const shown = kept.get(rule) ?? [];
+      if (shown.length === 0 || shown.length === findings.length) continue;
+      const shownFiles = new Set(shown.map((finding) => finding.file));
+      const dropped = findings.slice(shown.length);
+      delivery.omitted.findings.push({
+        rule,
+        count: dropped.length,
+        files: new Set(dropped.map((finding) => finding.file).filter((file) => !shownFiles.has(file))).size
+      });
+    }
+    delivery.findings = delivery.findings.filter((finding) => kept.get(finding.rule)?.includes(finding) === true);
+  }
+  if (input.stopGate) {
+    const newErrors = fresh.some(({ rule }) => rule.severity === "error");
+    const blocks = input.work.stopBlocks.get(input.agent) ?? 0;
+    if (!newErrors) delivery.stop = "allow";
+    else if (blocks < input.maxBlocks) {
+      delivery.stop = "block";
+      work.push({ t: "stopBlock", agent: input.agent });
+    } else delivery.stop = "capReached";
+    if (delivery.stop === "allow") return { delivery, overflow: null, work, context: [] };
+    if (delivery.stop === "capReached") {
+      return { delivery, overflow: delivery.omitted.rules > 0 ? complete : null, work, context: [] };
+    }
+  }
+  return { delivery, overflow: delivery.omitted.rules > 0 ? complete : null, work, context };
+}
+
+// src/core/guard.ts
+async function guardWrite(input) {
+  const file = input.event.files[0];
+  const intent = input.event.intent;
+  if (file === void 0 || intent === void 0) return emptyDelivery();
+  const rules = input.rules.filter((rule) => rule.refuseWrite && !input.disabled.has(rule.id) && rule.matches(file));
+  if (rules.length === 0) return emptyDelivery();
+  const proposal = propose(await readSourceFile(input.root, file), intent);
+  if (proposal === null) {
+    input.log(`guard: ${file} could not be reconstructed from the tool call; allowing the write`);
+    return emptyDelivery();
+  }
+  if (proposal.inserts.length === 0) return emptyDelivery();
+  if (proposal.content.length > input.config.maxFileBytes) {
+    input.log(`guard: ${file} is over max_file_bytes (${input.config.maxFileBytes}); allowing the write`);
+    return emptyDelivery();
+  }
+  const selections = selectDetectorRules(rules, "edit", [file], input.disabled);
+  if (selections.length === 0) return emptyDelivery();
+  const output = await runDetection({
+    root: input.root,
+    event: "edit",
+    selections,
+    changes: /* @__PURE__ */ new Map(),
+    // The proposed file for the one being written; anything else a detector reaches for is real.
+    read: async (name) => name === file ? proposal.content : readSourceFile(input.root, name),
+    registry: input.registry,
+    cacheFor: (kind) => diskCache(detectorCacheDir(input.stateDir, kind)),
+    contextFor: (rule) => resolveRuleContext(input.resolver, rule.context),
+    settings: { llm: input.config.llm },
+    timeoutMs: input.config.timeouts.editDeadlineMs
+  });
+  const evidence = output.findings.filter(({ rule, match }) => isInserted(proposal, match, rule.detector.kind));
+  if (evidence.length === 0) return emptyDelivery();
+  const spent = (rule) => (input.work.refusals.get(refusalKey(rule, file)) ?? 0) >= input.config.refuseGate.maxRefusals;
+  const refusing = evidence.filter(({ rule }) => !spent(rule.id));
+  if (refusing.length === 0) {
+    input.log(`guard: ${file} has spent its refusals; allowing the write`);
+    return emptyDelivery();
+  }
+  const { delivery } = await decide({
+    agent: "main",
+    findings: refusing.map(({ rule, match }) => ({ rule, match, status: "new" })),
+    touches: [],
+    agentRead: null,
+    warnings: [],
+    work: input.work,
+    // An empty context, so the sections come with the refusal even if they were delivered earlier:
+    // the message has to stand on its own, and nothing here is recorded as delivered because the
+    // write it explains never happened.
+    context: emptyContext(),
+    resolver: input.resolver,
+    maxBytes: input.config.context.maxBytes,
+    maxBlocks: input.config.stopGate.maxBlocks,
+    maxContextChars: input.maxContextChars,
+    maxMatchesPerRule: input.config.maxMatchesPerRule,
+    stopGate: false
+  });
+  await input.record(
+    [...new Set(refusing.map(({ rule }) => rule.id))].map((rule) => ({ t: "refused", rule, file }))
+  );
+  return delivery;
+}
+
+// src/core/session/session.ts
+import path10 from "path";
+function safeSegment3(value) {
+  const segment = value.replace(/[^A-Za-z0-9._-]/g, "_");
+  return /^\.*$/.test(segment) ? `_${segment}` : segment;
+}
+function sessionDir(stateDir, sessionId) {
+  return path10.join(stateDir, "sessions", safeSegment3(sessionId));
+}
+var workFile = (dir) => path10.join(dir, "work.jsonl");
+var contextFile = (dir, agent) => path10.join(dir, `context.${safeSegment3(agent)}.jsonl`);
+async function appendWork(dir, records) {
+  await appendRecords(workFile(dir), records);
+}
+async function appendContext(dir, agent, records) {
+  await appendRecords(contextFile(dir, agent), records);
+}
+async function openSession(dir, agent) {
+  const [work, context] = await Promise.all([
+    readRecords(workFile(dir)),
+    readRecords(contextFile(dir, agent))
+  ]);
+  return { work: foldWork(work), context: foldContext(context) };
+}
+async function commitSession(dir, agent, decideWith) {
+  return withLock(dir, async () => {
+    const decision = await decideWith(await openSession(dir, agent));
+    await appendWork(dir, decision.work);
+    await appendContext(dir, agent, decision.context);
+    return decision;
+  });
+}
+
+// src/core/pipeline.ts
+var SUMMARY_THRESHOLD = 3;
+var DEFAULT_HINT = "rulecast validate";
+function summaryKey(prefix, ids) {
+  const digest = createHash3("sha256").update([...ids].sort().join("\n")).digest("hex").slice(0, 16);
+  return `${prefix}:${digest}`;
+}
+function compileWarnings(errors) {
+  if (errors.length <= SUMMARY_THRESHOLD) {
+    return errors.map((diagnostic) => ({
+      key: `diagnostic:${diagnostic.source}:${diagnostic.rule ?? ""}:${diagnostic.message}`,
+      text: `${diagnosticText(diagnostic)} (run ${diagnostic.hint ?? DEFAULT_HINT})`
+    }));
+  }
+  const hints = new Set(errors.map((diagnostic) => diagnostic.hint ?? DEFAULT_HINT));
+  const hint = hints.size === 1 ? [...hints][0] : DEFAULT_HINT;
+  return [
+    {
+      key: summaryKey(
+        "diagnostics",
+        errors.map((diagnostic) => diagnostic.rule ?? diagnostic.source)
+      ),
+      text: `${errors.length} rules failed to compile and were skipped \u2014 run ${hint}.
+First: ${diagnosticText(errors[0])}`
+    }
+  ];
+}
+function detectorWarnings(errors) {
+  const text = (error) => `${error.kind} detector failed for ${error.rules.join(", ")}: ${error.message}. Disabled for this session.`;
+  const byKind = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const group = byKind.get(error.kind);
+    if (group === void 0) byKind.set(error.kind, [error]);
+    else group.push(error);
+  }
+  const summarised = [];
+  for (const [kind, group] of byKind) {
+    if (group.length <= SUMMARY_THRESHOLD) {
+      summarised.push(
+        ...group.map((error) => ({
+          key: `detector:${kind}:${error.rules.join(",")}:${error.message}`,
+          text: text(error)
+        }))
+      );
+      continue;
+    }
+    const ids = group.flatMap((error) => error.rules);
+    summarised.push({
+      key: summaryKey(`detector:${kind}`, ids),
+      text: `${ids.length} ${kind} rules were disabled this session \u2014 see debug.log.
+First: ${text(group[0])}`
+    });
+  }
+  return summarised;
+}
+async function runPipeline(options) {
+  const { project, stateDir, event, registry } = options;
+  const { root, config } = project;
+  const log = options.log ?? (() => {
+  });
+  const errors = project.diagnostics.filter((diagnostic) => diagnostic.level === "error");
+  const warnings = compileWarnings(errors);
+  let failed = errors.length > 0;
+  const deadlineMissed = [];
+  let session = event.session ? { dir: sessionDir(stateDir, event.session.id), agent: event.session.agentId ?? "main" } : null;
+  const STORE_UNREADABLE = "session state could not be read; delivered without session memory";
+  async function readingStore(read, fallback) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!(error instanceof CorruptStoreError)) throw error;
+      log(`session store unreadable: ${error.message}`);
+      session = null;
+      warnings.push({ key: "store", text: STORE_UNREADABLE });
+      return fallback;
+    }
+  }
+  const restoredFiles = options.restoredFiles ?? 0;
+  if (event.kind === "prompt") {
+    if (session) await appendWork(session.dir, [{ t: "prompt", agent: session.agent }]);
+    return { delivery: emptyDelivery(), failed, deadlineMissed };
+  }
+  if (event.kind === "reset") {
+    if (session) await appendContext(session.dir, session.agent, [{ t: "reset" }]);
+    if (!session || restoredFiles === 0) return { delivery: emptyDelivery(), failed, deadlineMissed };
+  }
+  let baseline = {
+    started: false,
+    startCommit: null,
+    snapshots: /* @__PURE__ */ new Map(),
+    fingerprints: /* @__PURE__ */ new Map()
+  };
+  if (session && event.kind !== "reset" && event.kind !== "guard") {
+    const dir = session.dir;
+    baseline = await readingStore(() => readBaseline(dir), baseline);
+    if (session && !baseline.started) {
+      await appendBaseline(dir, [startRecord(await headCommit(root))]);
+      baseline = await readingStore(() => readBaseline(dir), baseline);
+    }
+  }
+  const empty = () => ({ work: emptyWork(), context: emptyContext() });
+  const view = session ? await readingStore(() => openSession(session.dir, session.agent), empty()) : empty();
+  const disabled = new Set(view.work.disabled.keys());
+  const resolver = createReferenceResolver(root);
+  const workRecords = [];
+  const relevant = (files) => files.filter((file) => project.rules.some((rule) => rule.matches(file)));
+  if (event.kind === "guard") {
+    const open2 = session;
+    const delivery = await guardWrite({
+      root,
+      config,
+      registry,
+      stateDir,
+      event,
+      rules: project.rules,
+      disabled,
+      work: view.work,
+      resolver,
+      maxContextChars: options.maxContextChars,
+      log,
+      record: open2 ? (records) => appendWork(open2.dir, records) : async () => {
+      }
+    });
+    return { delivery, failed, deadlineMissed };
+  }
+  let touches = [];
+  let findings = [];
+  let agentRead = null;
+  if (event.kind === "touch" || event.kind === "edit") {
+    touches = selectTouchRules(project.rules, event.files, view.context.touched, disabled);
+    const open2 = session;
+    if (open2) {
+      await appendWork(
+        open2.dir,
+        event.files.map((file) => ({ t: "accessed", agent: open2.agent, file }))
+      );
+    }
+  }
+  if (event.kind === "reset" && session) {
+    const recent = (view.work.accessed.get(session.agent) ?? []).slice(-restoredFiles).reverse();
+    touches = selectTouchRules(project.rules, recent, view.context.touched, disabled);
+  }
+  if (event.kind === "touch") {
+    if (event.completeRead) agentRead = event.files[0] ?? null;
+    if (session) {
+      const records = [];
+      const snapshotted = [];
+      for (const file of relevant(event.files)) {
+        if (baseline.snapshots.has(file)) continue;
+        const text = await readSourceFile(root, file);
+        if (text === null) continue;
+        records.push(snapshotRecord(file, snapshotOf(text)));
+        snapshotted.push(file);
+      }
+      if (snapshotted.length > 0) {
+        records.push(
+          ...await recordFingerprints({
+            root,
+            files: snapshotted,
+            rules: project.rules,
+            disabled,
+            registry,
+            read: (file) => readSourceFile(root, file),
+            cacheFor: (kind) => diskCache(detectorCacheDir(stateDir, kind)),
+            contextFor: (rule) => resolveRuleContext(resolver, rule.context),
+            settings: { llm: config.llm },
+            event: "edit",
+            source: "disk",
+            timeoutMs: config.timeouts.editDeadlineMs,
+            ceiling: { maxFileBytes: config.maxFileBytes, sizeOf: (file) => fileBytes(root, file) }
+          })
+        );
+      }
+      await appendBaseline(session.dir, records);
+    }
+  }
+  if (event.kind === "edit" || event.kind === "verify") {
+    let files = relevant(event.files);
+    let snapshots = session ? baseline.snapshots : /* @__PURE__ */ new Map();
+    let fallbackCommit = session ? baseline.startCommit : null;
+    if (event.kind === "edit" && session) {
+      await appendWork(
+        session.dir,
+        files.map((file) => ({ t: "edited", file }))
+      );
+    }
+    if (event.kind === "verify") {
+      if (event.baseCommit) {
+        fallbackCommit = event.baseCommit;
+        snapshots = /* @__PURE__ */ new Map();
+      }
+      if (event.files.length === 0 && session) files = relevant(view.work.edited);
+    }
+    const baselineChanges = await computeChanges(root, files, { snapshots, fallbackCommit });
+    const changes = baselineChanges.sets;
+    if (event.kind === "verify" && session && !event.baseCommit) {
+      files = files.filter((file) => changes.get(file)?.changedLines.length !== 0);
+    }
+    if (event.kind === "verify" && baselineChanges.fromCommit.size > 0) {
+      const texts = baselineChanges.fromCommit;
+      const missing = [...texts.keys()].filter((file) => !baseline.fingerprints.has(file));
+      const records = missing.length === 0 ? [] : await recordFingerprints({
+        root,
+        files: missing,
+        rules: project.rules,
+        disabled,
+        registry,
+        read: async (file) => texts.get(file) ?? null,
+        cacheFor: (kind) => diskCache(detectorCacheDir(stateDir, kind)),
+        contextFor: (rule) => resolveRuleContext(resolver, rule.context),
+        settings: { llm: config.llm },
+        event: "verify",
+        source: "memory",
+        timeoutMs: config.timeouts.verifyMs
+      });
+      for (const record of records) {
+        if (record.t !== "fingerprint") continue;
+        const byRule = baseline.fingerprints.get(record.file) ?? /* @__PURE__ */ new Map();
+        baseline.fingerprints.set(record.file, byRule);
+        byRule.set(record.rule, record.ranges);
+      }
+      if (session && records.length > 0) await appendBaseline(session.dir, records);
+    }
+    const skip = options.skipDetectorKinds ?? /* @__PURE__ */ new Set();
+    let selections = selectDetectorRules(project.rules, event.kind, files, disabled).filter(
+      (selection) => !skip.has(selection.rule.detector.kind) && (options.onlyRules?.has(selection.rule.id) ?? true)
+    );
+    let overBudget = [];
+    if (event.kind === "verify") {
+      const budgeted = applyFileBudget("llm", selections, config.llm.maxFilesPerVerify, [...view.work.edited].reverse());
+      selections = budgeted.selections;
+      overBudget = budgeted.skipped;
+    }
+    if (event.kind === "edit") {
+      const ceiling = await applySizeCeiling(
+        selections,
+        config.maxFileBytes,
+        (kind) => registry.get(kind)?.guards === true,
+        (file) => fileBytes(root, file)
+      );
+      selections = ceiling.selections;
+      if (ceiling.skipped.length > 0) {
+        log(`over max_file_bytes (${config.maxFileBytes}), not checked on this edit: ${ceiling.skipped.join(", ")}`);
+      }
+    }
+    const output = await runDetection({
+      root,
+      event: event.kind,
+      selections,
+      changes,
+      read: (file) => readSourceFile(root, file),
+      registry,
+      cacheFor: (kind) => diskCache(detectorCacheDir(stateDir, kind)),
+      contextFor: (rule) => resolveRuleContext(resolver, rule.context),
+      settings: { llm: config.llm },
+      timeoutMs: event.kind === "edit" ? config.timeouts.editDeadlineMs : config.timeouts.verifyMs
+    });
+    findings = output.findings.map(({ rule, match }) => ({
+      rule,
+      match,
+      status: classify(match, rule.scope, rule.id, baselineChanges, baseline.fingerprints)
+    }));
+    for (const error of output.errors) {
+      failed = true;
+      log(`${error.kind} detector failed for ${error.rules.join(", ")}: ${error.message}`);
+      for (const rule of error.rules) workRecords.push({ t: "disabled", rule, reason: error.message });
+    }
+    warnings.push(...detectorWarnings(output.errors));
+    if (overBudget.length > 0) {
+      warnings.push({
+        key: `llm-budget:${overBudget.join(",")}`,
+        text: `llm rules checked ${config.llm.maxFilesPerVerify} files; ${overBudget.length} were not checked: ${overBudget.join(", ")}. Raise llm.max_files_per_verify, or run rulecast run --files on them.`
+      });
+    }
+    for (const timeout of output.timedOut) {
+      if (event.kind === "edit") {
+        log(`edit deadline passed for ${timeout.kind}: ${timeout.rules.join(", ")}`);
+        deadlineMissed.push(timeout.kind);
+      } else {
+        failed = true;
+        warnings.push({
+          key: `timeout:${timeout.kind}:${timeout.rules.join(",")}`,
+          // Naming the lever matters: a field trial measured a single haiku call on a 135-line file
+          // at 89 s against a 60 s default, and "timed out" alone leaves nobody knowing what to do.
+          text: `${timeout.kind} detector timed out after ${config.timeouts.verifyMs} ms for ${timeout.rules.join(", ")}. Raise timeouts.verify_ms${timeout.kind === "llm" ? " (an llm rule on a large file can need 120000 or more)" : ""}.`
+        });
+      }
+    }
+  }
+  const inputFor = (state) => ({
+    agent: session?.agent ?? "main",
+    findings,
+    touches: touches.filter((rule) => !state.context.touched.has(rule.id)),
+    agentRead,
+    warnings,
+    work: state.work,
+    context: state.context,
+    resolver,
+    maxBytes: config.context.maxBytes,
+    maxBlocks: config.stopGate.maxBlocks,
+    maxContextChars: options.maxContextChars,
+    maxMatchesPerRule: config.maxMatchesPerRule,
+    stopGate: options.stopGate === true && event.kind === "verify" && session !== null
+  });
+  const persisted = (decision) => {
+    if (decision.overflow !== null) {
+      decision.delivery.overflowPath = writeOverflow(stateDir, event.session?.id ?? null, decision.overflow);
+    }
+    return decision.delivery;
+  };
+  if (!session) return { delivery: persisted(await decide(inputFor(view))), failed, deadlineMissed };
+  await appendWork(session.dir, workRecords);
+  try {
+    const decision = await commitSession(session.dir, session.agent, (state) => decide(inputFor(state)));
+    return { delivery: persisted(decision), failed, deadlineMissed };
+  } catch (error) {
+    if (error instanceof CorruptStoreError) {
+      log(`session store unreadable: ${error.message}`);
+      warnings.push({ key: "store", text: STORE_UNREADABLE });
+    } else if (error instanceof LockTimeoutError) {
+      warnings.push({ key: "lock", text: "session state was locked; delivered without session memory" });
+    } else throw error;
+    const decision = await decide({ ...inputFor({ work: emptyWork(), context: emptyContext() }), stopGate: false });
+    return { delivery: persisted(decision), failed, deadlineMissed };
+  }
+}
+
+export {
+  defaultConfig,
+  CONFIG_FILE,
+  MANIFEST_FILE,
+  readConfigData,
+  parseConfig,
+  readManifest,
+  git,
+  mergeBase,
+  changedFilesSince,
+  allFiles,
+  stagedFiles,
+  changedFilesBetween,
+  LockTimeoutError,
+  withLock,
+  repoLabel,
+  RepoFetchError,
+  NO_PROMPT,
+  fetchCheckout,
+  cachedRepo,
+  ensureRepo,
+  cacheHome,
+  projectStateDir,
+  ensureProjectState,
+  debugLogger,
+  diagnosticText,
+  compile,
+  compileManifest,
+  rulesOfKind,
+  checkableKinds,
+  checkDetectors,
+  runDetection,
+  cachedRepos,
+  fetchingRepos,
+  fixedRepo,
+  resolveRuleContext,
+  createReferenceResolver,
+  runPipeline
+};