safeword 0.67.0 → 0.68.0

package/dist/boundary-SBKG6B55.js

@@ -0,0 +1,678 @@
+import {
+  classifyAnnotation,
+  detectUnanchoredPhaseTransition,
+  evaluateTicketWrite,
+  frontmatterOf,
+  isValidSha,
+  isValidSkipReason,
+  parseCheckboxAnnotation,
+  scalar
+} from "./chunk-CTHKK2XP.js";
+import {
+  resolveTicketsDirectory
+} from "./chunk-CYICTM6W.js";
+import {
+  readFileSafe
+} from "./chunk-X26EJNPZ.js";
+import {
+  warn
+} from "./chunk-O2ULQPXW.js";
+
+// src/commands/boundary.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import nodePath5 from "path";
+import process2 from "process";
+
+// templates/hooks/lib/ledger-git.ts
+import { execFileSync } from "child_process";
+function git(cwd, args, input) {
+  return execFileSync("git", args, {
+    cwd,
+    input,
+    encoding: "utf8",
+    stdio: input === void 0 ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function resolveCommitSha(cwd, sha) {
+  try {
+    return git(cwd, ["rev-parse", "--verify", `${sha}^{commit}`]);
+  } catch {
+    return void 0;
+  }
+}
+function isAncestorOfHead(cwd, sha) {
+  try {
+    execFileSync("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+      cwd,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function patchIdForCommit(cwd, sha) {
+  try {
+    const patch = git(cwd, ["show", "--format=format:", "--patch", "--no-ext-diff", sha]);
+    const output = git(cwd, ["patch-id", "--stable"], patch);
+    return output.split(/\s+/)[0] || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function allReachableCommits(cwd) {
+  try {
+    const output = git(cwd, ["rev-list", "--no-merges", "HEAD"]);
+    return output === "" ? [] : output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function buildReachablePatchMap(cwd) {
+  const patchIdToCommits = /* @__PURE__ */ new Map();
+  for (const commit of allReachableCommits(cwd)) {
+    const patchId = patchIdForCommit(cwd, commit);
+    if (!patchId) continue;
+    const commits = patchIdToCommits.get(patchId) ?? [];
+    commits.push(commit);
+    patchIdToCommits.set(patchId, commits);
+  }
+  return patchIdToCommits;
+}
+function createLedgerShaResolver(cwd) {
+  let reachablePatchMap;
+  function patchMap() {
+    reachablePatchMap ??= buildReachablePatchMap(cwd);
+    return reachablePatchMap;
+  }
+  return (sha) => {
+    const fullSha = resolveCommitSha(cwd, sha);
+    if (!fullSha) return false;
+    if (isAncestorOfHead(cwd, fullSha)) return fullSha;
+    const stalePatchId = patchIdForCommit(cwd, fullSha);
+    if (!stalePatchId) return false;
+    const candidates = patchMap().get(stalePatchId) ?? [];
+    const [candidate] = candidates;
+    return candidates.length === 1 && candidate ? candidate : false;
+  };
+}
+
+// templates/hooks/lib/done-gate.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import nodePath4 from "path";
+
+// templates/hooks/lib/dependency-readiness.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import nodePath2 from "path";
+
+// templates/hooks/lib/namespace-root.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import nodePath from "path";
+
+// templates/hooks/lib/test-runner.ts
+import { execSync, spawnSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import nodePath3 from "path";
+var projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+// templates/hooks/lib/done-gate.ts
+var PR_SCOPE_LINE_PATTERN = /^\*\*PR Scope:\*\*\s*(?<status>.+)$/im;
+function checkVerifyArtifact(content) {
+  const prScopeMatch = PR_SCOPE_LINE_PATTERN.exec(content);
+  if (!prScopeMatch?.groups?.status) {
+    return {
+      ok: false,
+      reason: "verify.md is missing PR scope evidence. Run /verify again so it records `**PR Scope:**` before marking done."
+    };
+  }
+  const status = prScopeMatch.groups.status;
+  const failed = status.includes("\u274C") || !status.includes("\u2705") && /piggybacked changes/i.test(status);
+  if (failed) {
+    return {
+      ok: false,
+      reason: "verify.md says PR scope failed. Revert or split the piggybacked work, or explicitly accept the scope change in the ticket artifacts before marking done."
+    };
+  }
+  return { ok: true };
+}
+
+// templates/hooks/lib/impl-plan.ts
+var IMPL_PLAN_SECTIONS = [
+  "Approach",
+  "Decisions",
+  "Arch alignment",
+  "Known deviations",
+  "Assessment triggers"
+];
+var STATUS_PREFIX = "**Status:**";
+var SKIP_PREFIX = "skip:";
+var SECTION_NAMES = new Map(
+  IMPL_PLAN_SECTIONS.map((name) => [name.toLowerCase(), name])
+);
+function activeLines(content) {
+  const lines = [];
+  let inComment = false;
+  for (const raw of content.split("\n")) {
+    let line = raw;
+    if (inComment) {
+      const end = line.indexOf("-->");
+      if (end === -1) continue;
+      inComment = false;
+      line = line.slice(end + 3);
+    }
+    let start = line.indexOf("<!--");
+    while (start !== -1) {
+      const end = line.indexOf("-->", start + 4);
+      if (end === -1) {
+        line = line.slice(0, start);
+        inComment = true;
+        break;
+      }
+      line = line.slice(0, start) + line.slice(end + 3);
+      start = line.indexOf("<!--");
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function parseStatus(lines, errors) {
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(STATUS_PREFIX)) continue;
+    const value = trimmed.slice(STATUS_PREFIX.length).trim();
+    if (value === "planned" || value === "implemented") return value;
+    errors.push(`Unknown status "${value}" \u2014 allowed values: planned, implemented.`);
+    return null;
+  }
+  errors.push(`Missing \`${STATUS_PREFIX}\` line \u2014 add \`${STATUS_PREFIX} planned\` near the top.`);
+  return null;
+}
+function collectSectionBodies(lines) {
+  const bodies = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("## ")) {
+      current = SECTION_NAMES.get(trimmed.slice(3).trim().toLowerCase()) ?? null;
+      if (current && !bodies.has(current)) bodies.set(current, []);
+      continue;
+    }
+    if (trimmed.startsWith("# ")) {
+      current = null;
+      continue;
+    }
+    if (current && trimmed !== "") bodies.get(current)?.push(trimmed);
+  }
+  return bodies;
+}
+function parseImplPlan(content) {
+  const errors = [];
+  const lines = activeLines(content);
+  const status = parseStatus(lines, errors);
+  const bodies = collectSectionBodies(lines);
+  const sections = {};
+  for (const name of IMPL_PLAN_SECTIONS) {
+    const body = bodies.get(name);
+    if (body === void 0) {
+      errors.push(`Missing section heading \`## ${name}\` \u2014 all five sections are required.`);
+      continue;
+    }
+    const skipLine = body.length === 1 && body[0]?.toLowerCase().startsWith(SKIP_PREFIX) ? body[0] : null;
+    if (skipLine !== null) {
+      const reason = skipLine.slice(SKIP_PREFIX.length).trim();
+      if (reason === "") {
+        errors.push(`Section "${name}": skip requires a non-empty reason (\`skip: <why>\`).`);
+      }
+      sections[name] = { satisfied: reason !== "", skip: reason };
+      continue;
+    }
+    if (body.length === 0) {
+      errors.push(`Section "${name}" is empty \u2014 add content or \`skip: <why>\`.`);
+    }
+    sections[name] = { satisfied: body.length > 0, skip: null };
+  }
+  return { status, sections, errors };
+}
+
+// templates/hooks/lib/ledger-validation.ts
+function parseLedger(content) {
+  const lines = content.split("\n");
+  const scenarios = [];
+  let current;
+  let crossScenario;
+  for (const line of lines) {
+    const scenarioMatch = /^#{2,3}\s+Scenario:\s*(.+)$/.exec(line);
+    if (scenarioMatch) {
+      current = { name: (scenarioMatch[1] ?? "").trim() };
+      scenarios.push(current);
+      continue;
+    }
+    const parsed = parseCheckboxAnnotation(line);
+    if (!parsed) continue;
+    if (parsed.step === "cross-scenario") {
+      crossScenario = parsed;
+      continue;
+    }
+    if (current) {
+      if (parsed.step === "RED") current.red = parsed;
+      else if (parsed.step === "GREEN") current.green = parsed;
+      else if (parsed.step === "REFACTOR") current.refactor = parsed;
+    }
+  }
+  return { scenarios, crossScenario };
+}
+function checkSha(value, resolveSha, label) {
+  if (!isValidSha(value)) {
+    return {
+      error: `${label}: "${value}" is not a valid commit SHA (expected 7-40 hex chars).`,
+      format: true
+    };
+  }
+  const resolution = resolveSha(value);
+  if (resolution === false) {
+    return { error: `${label}: SHA ${value} is not reachable from HEAD.`, format: false };
+  }
+  return {
+    format: false,
+    canonicalSha: resolution === true ? value : resolution
+  };
+}
+function validateScenario(scenario, resolveSha, errors) {
+  const steps = [
+    { name: "RED", box: scenario.red },
+    { name: "GREEN", box: scenario.green },
+    { name: "REFACTOR", box: scenario.refactor }
+  ];
+  const annotatedSteps = steps.filter((s) => s.box && s.box.annotation !== "");
+  if (annotatedSteps.length === 0) return;
+  const shaToStep = /* @__PURE__ */ new Map();
+  let realShaCount = 0;
+  for (const step of steps) {
+    if (!step.box) continue;
+    const kind = classifyAnnotation(step.box.annotation);
+    if (kind.kind === "none") continue;
+    if (kind.kind === "skip") {
+      if (!isValidSkipReason(kind.reason)) {
+        errors.push(
+          `Scenario "${scenario.name}" ${step.name}: skip reason is empty or whitespace-only. Provide a real reason.`
+        );
+      }
+      continue;
+    }
+    realShaCount++;
+    const checkedSha = checkSha(kind.value, resolveSha, `Scenario "${scenario.name}" ${step.name}`);
+    if (checkedSha.error) {
+      errors.push(checkedSha.error);
+      if (checkedSha.format) continue;
+    }
+    if (!checkedSha.canonicalSha) continue;
+    const existingStep = shaToStep.get(checkedSha.canonicalSha);
+    if (existingStep) {
+      errors.push(
+        `Scenario "${scenario.name}" SHA collision: ${existingStep} and ${step.name} share SHA ${checkedSha.canonicalSha}. Each TDD step must correspond to a distinct commit.`
+      );
+    } else {
+      shaToStep.set(checkedSha.canonicalSha, step.name);
+    }
+  }
+  if (realShaCount === 0) {
+    errors.push(
+      `Scenario "${scenario.name}" represents work that produced no commits \u2014 all steps are skipped. At least one step must carry a real SHA.`
+    );
+  }
+}
+function validateCrossScenario(cs, resolveSha, errors) {
+  if (!cs) {
+    errors.push(
+      "Cross-scenario refactor row is missing. Add `- [ ] cross-scenario` to test-definitions.md and complete it with a SHA or `skip: <reason>` before done."
+    );
+    return;
+  }
+  if (!cs.checked) {
+    errors.push(
+      "Cross-scenario refactor row is unchecked. Mark it with a SHA or `skip: <reason>` before done."
+    );
+    return;
+  }
+  if (cs.annotation === "") return;
+  const kind = classifyAnnotation(cs.annotation);
+  if (kind.kind === "skip") {
+    if (!isValidSkipReason(kind.reason)) {
+      errors.push(
+        "Cross-scenario refactor row: skip reason is empty or whitespace-only. Provide a real reason."
+      );
+    }
+    return;
+  }
+  if (kind.kind === "sha") {
+    const checkedSha = checkSha(kind.value, resolveSha, "Cross-scenario refactor row");
+    if (checkedSha.error) errors.push(checkedSha.error);
+  }
+}
+function wholeTicketPassFromScenarios(scenarios) {
+  const hasAnyAnnotation = scenarios.some(
+    (s) => [s.red, s.green, s.refactor].some((box) => box?.annotation)
+  );
+  return scenarios.length >= 2 && hasAnyAnnotation;
+}
+function validateLedger(content, resolveSha) {
+  const errors = [];
+  const { scenarios, crossScenario } = parseLedger(content);
+  for (const scenario of scenarios) {
+    validateScenario(scenario, resolveSha, errors);
+  }
+  if (wholeTicketPassFromScenarios(scenarios) || crossScenario) {
+    validateCrossScenario(crossScenario, resolveSha, errors);
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+// src/boundary/engine.ts
+var TICKET_ARTIFACTS = /* @__PURE__ */ new Set([
+  "ticket.md",
+  "test-definitions.md",
+  "verify.md",
+  "impl-plan.md",
+  "spec.md"
+]);
+var LEDGER_REQUIRED_PHASES = /* @__PURE__ */ new Set(["scenario-gate", "implement", "verify", "done"]);
+function frontmatterOf2(content) {
+  return frontmatterOf(content.replaceAll("\r\n", "\n"));
+}
+function hasEntries(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value.length > 0 : typeof value === "string" && value !== "";
+}
+function pass(check) {
+  return { check, verdict: "pass" };
+}
+function warnVerdict(check, detail) {
+  return { check, verdict: "warn", detail };
+}
+var UNREACHABLE_CAUSES = "possible causes: a forged anchor, or a shallow clone missing the history (fetch full history to verify)";
+function legalityVerdict(ticketFile, legalitySteps) {
+  let steps = [];
+  if (legalitySteps && legalitySteps.length > 0) {
+    steps = legalitySteps;
+  } else if (ticketFile.proposed !== void 0) {
+    steps = [{ prior: ticketFile.prior, proposed: ticketFile.proposed }];
+  }
+  for (const step of steps) {
+    const verdict = evaluateTicketWrite(step.prior, step.proposed);
+    if (!verdict.ok) {
+      const at = step.commit === void 0 ? "" : ` (commit ${step.commit})`;
+      return warnVerdict("phase-legality", `${verdict.reason}${at}`);
+    }
+  }
+  return pass("phase-legality");
+}
+function ticketFileChecks(ticketFile, resolveSha, legalitySteps) {
+  if (ticketFile.proposed === void 0) return [];
+  const checks = [];
+  if (frontmatterOf2(ticketFile.proposed) === void 0) {
+    checks.push(
+      warnVerdict(
+        "classify",
+        "ticket.md cannot be classified \u2014 its frontmatter is missing or unparseable"
+      )
+    );
+  }
+  checks.push(legalityVerdict(ticketFile, legalitySteps));
+  try {
+    const anchor = detectUnanchoredPhaseTransition(
+      ticketFile.prior,
+      ticketFile.proposed,
+      resolveSha
+    );
+    if (anchor.kind === "unanchored") {
+      const causes = /not reachable/i.test(anchor.reason) ? ` \u2014 ${UNREACHABLE_CAUSES}` : "";
+      checks.push(warnVerdict("phase-anchor", `${anchor.reason}${causes}`));
+    } else {
+      checks.push(pass("phase-anchor"));
+    }
+  } catch {
+    checks.push({
+      check: "phase-anchor",
+      verdict: "indeterminate",
+      detail: "SHA resolution failed mid-run \u2014 reachability could not be determined"
+    });
+  }
+  return checks;
+}
+function atRestBirthCheck(change) {
+  if (change.artifacts.some((a) => a.artifact === "ticket.md")) return [];
+  if (change.ticketCurrent === void 0) return [];
+  const meta = frontmatterOf2(change.ticketCurrent);
+  if (meta === void 0) return [];
+  if (scalar(meta, "type") !== "feature") return [];
+  const phase = scalar(meta, "phase");
+  if (phase === void 0 || phase === "intake") return [];
+  if (hasEntries(meta, "phase_anchors")) return [pass("birth")];
+  const birth = evaluateTicketWrite(void 0, change.ticketCurrent);
+  return birth.ok ? [pass("birth")] : [warnVerdict("birth", `ticket at rest looks born past intake: ${birth.reason}`)];
+}
+function ledgerRequiredPhase(change) {
+  if (change.ticketCurrent === void 0) return void 0;
+  const meta = frontmatterOf2(change.ticketCurrent);
+  if (meta === void 0 || scalar(meta, "type") !== "feature") return void 0;
+  const phase = scalar(meta, "phase");
+  return phase !== void 0 && LEDGER_REQUIRED_PHASES.has(phase) ? phase : void 0;
+}
+function ledgerChecks(change, resolveSha) {
+  const checks = [];
+  const requiredAt = ledgerRequiredPhase(change);
+  if (requiredAt !== void 0 && !change.hasLedger) {
+    checks.push(
+      warnVerdict(
+        "ledger",
+        `feature at phase ${requiredAt} has no test-definitions.md \u2014 the R/G/R ledger is missing`
+      )
+    );
+  }
+  const ledgerFile = change.artifacts.find((a) => a.artifact === "test-definitions.md");
+  if (ledgerFile?.proposed !== void 0) {
+    try {
+      const result = validateLedger(ledgerFile.proposed, resolveSha ?? (() => true));
+      checks.push(
+        result.ok ? pass("ledger-format") : warnVerdict(
+          "ledger-format",
+          `ledger annotation problems: ${result.errors.join(" | ")}`
+        )
+      );
+    } catch {
+      checks.push({
+        check: "ledger-format",
+        verdict: "indeterminate",
+        detail: "SHA resolution failed mid-run \u2014 ledger reachability could not be determined"
+      });
+    }
+  }
+  return checks;
+}
+function artifactShapeChecks(change) {
+  const checks = [];
+  const verifyFile = change.artifacts.find((a) => a.artifact === "verify.md");
+  if (verifyFile?.proposed !== void 0) {
+    const verdict = checkVerifyArtifact(verifyFile.proposed);
+    checks.push(
+      verdict.ok ? pass("verify-shape") : warnVerdict("verify-shape", `verify.md fails its shape check: ${verdict.reason}`)
+    );
+  }
+  const planFile = change.artifacts.find((a) => a.artifact === "impl-plan.md");
+  if (planFile?.proposed !== void 0) {
+    const parsed = parseImplPlan(planFile.proposed);
+    checks.push(
+      parsed.errors.length === 0 ? pass("impl-plan-shape") : warnVerdict(
+        "impl-plan-shape",
+        `impl-plan.md fails its shape check: ${parsed.errors.join(" | ")}`
+      )
+    );
+  }
+  return checks;
+}
+function reconcileTicket(change, resolveSha) {
+  const ticketFile = change.artifacts.find((a) => a.artifact === "ticket.md");
+  return [
+    ...ticketFile ? ticketFileChecks(ticketFile, resolveSha, change.legalitySteps) : [],
+    ...atRestBirthCheck(change),
+    ...ledgerChecks(change, resolveSha),
+    ...artifactShapeChecks(change)
+  ];
+}
+function reconcileChange(changes, resolveSha) {
+  return changes.map((change) => ({
+    ticket: change.ticketFolder,
+    checks: reconcileTicket(change, resolveSha)
+  }));
+}
+function findings(reconciliations) {
+  return reconciliations.flatMap(
+    ({ ticket, checks }) => checks.filter((c) => c.verdict !== "pass").map((check) => ({ ticket, check }))
+  );
+}
+
+// src/commands/boundary.ts
+var AUDIT_RELATIVE_PATH = nodePath5.join(".safeword", "boundary-audit.jsonl");
+function tryGit(cwd, args) {
+  try {
+    return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch {
+    return void 0;
+  }
+}
+function splitLines(listing) {
+  return listing?.split("\n").filter((line) => line !== "");
+}
+function pushRange(cwd) {
+  const upstreamPaths = splitLines(tryGit(cwd, ["diff", "--name-only", "@{u}...HEAD"]));
+  if (upstreamPaths !== void 0) {
+    const base2 = tryGit(cwd, ["merge-base", "@{u}", "HEAD"])?.trim();
+    return { paths: upstreamPaths, priorRef: base2 ?? "@{u}" };
+  }
+  const unpushed = splitLines(tryGit(cwd, ["rev-list", "HEAD", "--not", "--remotes"]));
+  if (unpushed === void 0 || unpushed.length === 0) return void 0;
+  const oldest = unpushed.at(-1) ?? "";
+  const base = tryGit(cwd, ["rev-parse", `${oldest}~1`])?.trim();
+  const listing = tryGit(
+    cwd,
+    base === void 0 ? ["log", "--name-only", "--format=", "HEAD"] : ["diff", "--name-only", `${base}..HEAD`]
+  );
+  const paths = splitLines(listing);
+  return paths === void 0 ? void 0 : { paths: [...new Set(paths)], priorRef: base };
+}
+function boundaryRange(cwd, at) {
+  if (at === "push") return pushRange(cwd);
+  const staged = splitLines(
+    tryGit(cwd, ["diff", "--cached", "--name-only", "--diff-filter=ACMRD"])
+  );
+  return staged === void 0 ? void 0 : { paths: staged, priorRef: "HEAD" };
+}
+function contentAt(cwd, spec) {
+  return tryGit(cwd, ["show", spec]);
+}
+function readArtifact(cwd, path, basename, range, at) {
+  const proposedSpec = at === "commit" ? `:${path}` : `HEAD:${path}`;
+  return {
+    artifact: basename,
+    prior: range.priorRef === void 0 ? void 0 : contentAt(cwd, `${range.priorRef}:${path}`),
+    proposed: contentAt(cwd, proposedSpec)
+  };
+}
+function parseTicketPath(path, prefix) {
+  if (!path.startsWith(prefix)) return void 0;
+  const segments = path.slice(prefix.length).split("/");
+  const ticketFolder = segments[0] ?? "";
+  const basename = segments.slice(1).join("/");
+  if (ticketFolder === "" || !TICKET_ARTIFACTS.has(basename)) return void 0;
+  return { ticketFolder, basename };
+}
+function collectChanges(cwd, range, at) {
+  const ticketsDirectory = nodePath5.relative(cwd, resolveTicketsDirectory(cwd));
+  const prefix = `${ticketsDirectory}/`;
+  const byTicket = /* @__PURE__ */ new Map();
+  for (const path of range.paths) {
+    const parsed = parseTicketPath(path, prefix);
+    if (parsed === void 0) continue;
+    const change = byTicket.get(parsed.ticketFolder) ?? {
+      ticketFolder: parsed.ticketFolder,
+      artifacts: [],
+      hasLedger: false
+    };
+    change.artifacts.push(readArtifact(cwd, path, parsed.basename, range, at));
+    byTicket.set(parsed.ticketFolder, change);
+  }
+  for (const change of byTicket.values()) {
+    const folder = nodePath5.join(cwd, ticketsDirectory, change.ticketFolder);
+    const staged = change.artifacts.find((a) => a.artifact === "ticket.md")?.proposed;
+    change.ticketCurrent = staged ?? readFileSafe(nodePath5.join(folder, "ticket.md"));
+    change.hasLedger = change.artifacts.some(
+      (a) => a.artifact === "test-definitions.md" && a.proposed !== void 0
+    ) || existsSync5(nodePath5.join(folder, "test-definitions.md"));
+    if (at === "push" && change.artifacts.some((a) => a.artifact === "ticket.md")) {
+      const path = `${prefix}${change.ticketFolder}/ticket.md`;
+      change.legalitySteps = legalityStepsFor(cwd, path, range.priorRef);
+    }
+  }
+  return byTicket.values().toArray();
+}
+function legalityStepsFor(cwd, path, priorReference) {
+  const range = priorReference === void 0 ? "HEAD" : `${priorReference}..HEAD`;
+  const commits = splitLines(tryGit(cwd, ["rev-list", "--reverse", range, "--", path])) ?? [];
+  return commits.map((commit) => ({
+    prior: contentAt(cwd, `${commit}~1:${path}`),
+    proposed: contentAt(cwd, `${commit}:${path}`) ?? "",
+    commit: commit.slice(0, 7)
+  }));
+}
+function appendAudit(cwd, entry) {
+  const auditPath = nodePath5.join(cwd, AUDIT_RELATIVE_PATH);
+  mkdirSync2(nodePath5.dirname(auditPath), { recursive: true });
+  appendFileSync(auditPath, `${JSON.stringify(entry)}
+`);
+}
+function reconcileBoundary(cwd, at) {
+  const range = boundaryRange(cwd, at);
+  if (range === void 0 || range.paths.length === 0) return;
+  const changes = collectChanges(cwd, range, at);
+  if (changes.length === 0) return;
+  const resolveSha = at === "push" ? createLedgerShaResolver(cwd) : void 0;
+  const reconciliations = reconcileChange(changes, resolveSha);
+  for (const finding of findings(reconciliations)) {
+    warn(
+      `boundary(${at}) ${finding.ticket}: [${finding.check.check}] ${finding.check.detail ?? finding.check.verdict}`
+    );
+  }
+  appendAudit(cwd, {
+    boundary: at,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    head: tryGit(cwd, ["rev-parse", "--short", "HEAD"])?.trim() ?? "unknown",
+    tickets: reconciliations
+  });
+}
+function boundary(options) {
+  try {
+    const at = options.at === "push" ? "push" : "commit";
+    const cwd = process2.cwd();
+    if (existsSync5(nodePath5.join(cwd, ".safeword"))) {
+      reconcileBoundary(cwd, at);
+    }
+  } catch (error) {
+    warn(
+      `boundary check could not complete: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return Promise.resolve();
+}
+export {
+  boundary
+};
+//# sourceMappingURL=boundary-SBKG6B55.js.map