@davesheffer/hunch 1.39.0 → 1.39.2

package/dist/core/types.d.ts

@@ -1581,6 +1581,7 @@ export declare const SCHEMAS: {
                     unknown: "unknown";
                     merged: "merged";
                     unmerged: "unmerged";
+                    "no-commits": "no-commits";
                 }>;
                 method: z.ZodNullable<z.ZodEnum<{
                     ancestry: "ancestry";

package/dist/core/workspace.d.ts

@@ -23,6 +23,9 @@ export declare const MACHINE_LABEL: RegExp;
  *  `.lock` suffix, leading/trailing `.` or `/`, and bounded length. Every real branch
  *  from `for-each-ref` passes; a crafted record cannot smuggle an argument. */
 export declare function isSafeBranchName(name: string): boolean;
+/** C0/C1 control characters, including newline and ESC: a stored string carrying one could
+ *  forge extra lines or terminal escapes in output a human reads (a printed command). */
+export declare const CONTROL_CHARS: RegExp;
 export declare const WorkspaceWorktreeSchema: z.ZodObject<{
     id: z.ZodString;
     path: z.ZodNullable<z.ZodString>;
@@ -35,13 +38,17 @@ export declare const WorkspaceWorktreeSchema: z.ZodObject<{
     last_commit_at: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type WorkspaceWorktree = z.infer<typeof WorkspaceWorktreeSchema>;
-export declare const MERGED_STATUSES: readonly ["merged", "unmerged", "unknown"];
+/** `no-commits`: the branch head lies on the default branch's first-parent history, so the
+ *  branch holds no commits of its own (freshly created, or fast-forwarded into the default
+ *  branch). Ancestry alone would call it merged; it is never offered for deletion. */
+export declare const MERGED_STATUSES: readonly ["merged", "unmerged", "no-commits", "unknown"];
 export declare const MERGED_METHODS: readonly ["ancestry", "squash", "rebase"];
 export declare const MergedVerdictSchema: z.ZodObject<{
     status: z.ZodEnum<{
         unknown: "unknown";
         merged: "merged";
         unmerged: "unmerged";
+        "no-commits": "no-commits";
     }>;
     method: z.ZodNullable<z.ZodEnum<{
         ancestry: "ancestry";
@@ -67,6 +74,7 @@ export declare const WorkspaceBranchSchema: z.ZodObject<{
             unknown: "unknown";
             merged: "merged";
             unmerged: "unmerged";
+            "no-commits": "no-commits";
         }>;
         method: z.ZodNullable<z.ZodEnum<{
             ancestry: "ancestry";
@@ -124,6 +132,7 @@ export declare const WorkspaceSchema: z.ZodObject<{
                 unknown: "unknown";
                 merged: "merged";
                 unmerged: "unmerged";
+                "no-commits": "no-commits";
             }>;
             method: z.ZodNullable<z.ZodEnum<{
                 ancestry: "ancestry";
@@ -216,7 +225,20 @@ export interface PruneStep {
     } | null;
     commands: string[];
     why: string;
+    /** How the merge was proven; squash and rebase merges are invisible to `git branch -d`. */
+    method: MergedVerdict["method"];
+    /** Ignored files in the worktree that `git worktree remove` deletes without asking (local
+     *  plan only, read live; never stored). `shown` is bounded, `total` counts all entries. */
+    ignored?: {
+        shown: string[];
+        total: number;
+    };
 }
+/** POSIX shell quoting for one token of a PRINTED command (never executed through a shell
+ *  here: execution uses argv arrays). Tokens made only of characters no shell treats
+ *  specially stay bare; anything else is single-quoted with `'` escaped as `'\''`, which is
+ *  also valid in Git Bash for Windows paths. */
+export declare function shellQuote(token: string): string;
 export interface PrunePlan {
     /** Executable on this machine (live record). */
     local: PruneStep[];

package/dist/core/workspace.js

@@ -43,7 +43,12 @@ const UpstreamName = z.string().max(320).refine((v) => {
     const slash = v.indexOf("/");
     return slash > 0 && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(v.slice(0, slash)) && isSafeBranchName(v.slice(slash + 1));
 }, { message: "upstream must be <remote>/<branch>" });
-const credentialFree = (label, max) => z.string().min(1).max(max).refine(isCredentialFreeValue, { message: `${label} must not carry credential material` });
+/** C0/C1 control characters, including newline and ESC: a stored string carrying one could
+ *  forge extra lines or terminal escapes in output a human reads (a printed command). */
+export const CONTROL_CHARS = /[\x00-\x1f\x7f-\x9f]/;
+const credentialFree = (label, max) => z.string().min(1).max(max)
+    .refine((v) => !CONTROL_CHARS.test(v), { message: `${label} must not contain control characters or newlines` })
+    .refine(isCredentialFreeValue, { message: `${label} must not carry credential material` });
 export const WorkspaceWorktreeSchema = z.object({
     /** Stable, path-free handle (hash of the path) so branches can point at a worktree in
      *  `branches` publish mode, where the path itself is omitted. */
@@ -58,12 +63,17 @@ export const WorkspaceWorktreeSchema = z.object({
     prunable: z.boolean(),
     last_commit_at: z.string().regex(ISO).nullable(),
 }).strict();
-export const MERGED_STATUSES = ["merged", "unmerged", "unknown"];
+/** `no-commits`: the branch head lies on the default branch's first-parent history, so the
+ *  branch holds no commits of its own (freshly created, or fast-forwarded into the default
+ *  branch). Ancestry alone would call it merged; it is never offered for deletion. */
+export const MERGED_STATUSES = ["merged", "unmerged", "no-commits", "unknown"];
 export const MERGED_METHODS = ["ancestry", "squash", "rebase"];
 export const MergedVerdictSchema = z.object({
     status: z.enum(MERGED_STATUSES),
     method: z.enum(MERGED_METHODS).nullable(),
-    evidence: z.array(z.string().max(256).refine(isCredentialFreeValue, { message: "verdict evidence must not carry credential material" })).max(8),
+    evidence: z.array(z.string().max(256)
+        .refine((v) => !CONTROL_CHARS.test(v), { message: "verdict evidence must not contain control characters or newlines" })
+        .refine(isCredentialFreeValue, { message: "verdict evidence must not carry credential material" })).max(8),
     /** The pull request that landed a merged branch, read from the LOCAL merge / squash commit
      *  subject ("Merge pull request #N from …", "… (#N)") — never fetched from a forge. */
     pr: z.number().int().min(1).max(100_000_000).optional(),
@@ -218,6 +228,8 @@ export function recommendAction(row, opts = {}) {
     const dirty = row.dirty_on.length ? `; dirty worktree on ${row.dirty_on.join(", ")}` : "";
     if (row.merged.status === "unknown")
         return `review: merge state unknown${dirty}${suffix}`;
+    if (row.merged.status === "no-commits")
+        return `keep: no commits of its own${dirty}${suffix}`;
     if (row.upstream === null || row.upstream_gone) {
         const idle = daysIdle(row.last_commit_at, now);
         const why = row.upstream_gone ? "upstream deleted, unmerged work" : "unpushed";
@@ -233,6 +245,7 @@ export function recommendAction(row, opts = {}) {
 function bestVerdict(verdicts) {
     return verdicts.find((v) => v.status === "merged")
         ?? verdicts.find((v) => v.status === "unmerged")
+        ?? verdicts.find((v) => v.status === "no-commits")
         ?? verdicts[0]
         ?? { status: "unknown", method: null, evidence: [] };
 }
@@ -283,6 +296,15 @@ export function ago(iso, now = new Date()) {
         return `${h}h ago`;
     return `${Math.floor(h / 24)}d ago`;
 }
+/** POSIX shell quoting for one token of a PRINTED command (never executed through a shell
+ *  here: execution uses argv arrays). Tokens made only of characters no shell treats
+ *  specially stay bare; anything else is single-quoted with `'` escaped as `'\''`, which is
+ *  also valid in Git Bash for Windows paths. */
+export function shellQuote(token) {
+    if (/^[A-Za-z0-9_\-./:@+,]+$/.test(token))
+        return token;
+    return `'${token.replace(/'/g, `'\\''`)}'`;
+}
 function pruneStepsFor(record, opts) {
     const steps = [];
     const skipped = [];
@@ -296,11 +318,12 @@ function pruneStepsFor(record, opts) {
         }
         const commands = [];
         if (wt)
-            commands.push(`git worktree remove -- ${wt.path ?? "<its worktree>"}`);
-        commands.push(`git branch -d -- ${b.name}`);
+            commands.push(`git worktree remove -- ${wt.path === null ? "<its worktree>" : shellQuote(wt.path)}`);
+        commands.push(`git branch -d -- ${shellQuote(b.name)}`);
         steps.push({
             branch: b.name, head: b.head, worktree: wt ? { id: wt.id, path: wt.path } : null, commands,
             why: `${b.merged.method}${b.merged.pr ? ` (PR #${b.merged.pr})` : ""}: ${b.merged.evidence[0] ?? ""}`,
+            method: b.merged.method,
         });
     }
     return { steps, skipped };
@@ -310,8 +333,9 @@ function pruneStepsFor(record, opts) {
 export function pruneRefusal(b, wt) {
     if (b.is_default)
         return "default branch";
-    if (b.merged.status !== "merged")
-        return b.merged.status === "unknown" ? "merge state unknown" : "not merged";
+    if (b.merged.status !== "merged") {
+        return b.merged.status === "unknown" ? "merge state unknown" : b.merged.status === "no-commits" ? "no commits of its own" : "not merged";
+    }
     if (wt?.is_main)
         return "checked out in the main worktree (switch away first)";
     if (wt?.locked)

package/dist/extractors/diff.d.ts

@@ -35,6 +35,40 @@ export interface DiffAnalysis {
      *  the same (new-path) key as perFile. */
     addedLinesByFile: Map<string, string[]>;
 }
+/** Undo git's C-style path quoting. Even with core.quotePath=false, git quotes a
+ *  path holding `"`, `\`, or a control character (`"src/a\"b.ts"`); with the
+ *  default quotePath it also octal-escapes every byte above 0x7F. Octal escapes
+ *  are raw bytes, so the unescaped byte string is decoded as UTF-8. An unquoted
+ *  or malformed value is returned unchanged. */
+export declare function unquoteGitPath(p: string): string;
+/** The final line a budget-capped diff ends with (see SYNTHESIS_DIFF_BUDGET in git.ts). */
+export declare const DIFF_TRUNCATED_LINE = "\u2026(diff truncated)\u2026";
+/** Does this diff end with the truncation marker (i.e. is it a prefix of the change)? */
+export declare function isTruncatedDiff(diff: string): boolean;
+/** The (new-side) path of every file block in a unified diff, in order — including
+ *  blocks with no hunks (binary, mode-only). Paths use the same keys as
+ *  DiffAnalysis.addedLinesByFile. */
+export declare function diffBlockFiles(diff: string): string[];
+/** How complete a gate's diff is (git.ts GateDiff satisfies this shape). */
+export interface DiffStatus {
+    /** Why the diff as a whole cannot be trusted as complete. */
+    incomplete?: string;
+    /** The diff is a byte prefix of the change, so its last block may be cut. */
+    truncated?: boolean;
+    /** Files whose content could not be read into the diff. */
+    unreadFiles?: string[];
+}
+export interface DiffContentGaps {
+    /** True when this file's added lines may be missing from the diff. */
+    missing(file: string): boolean;
+    /** A human-readable reason for the given missing files. */
+    reason(files: string[]): string;
+}
+/** Which files a content check cannot trust "no added lines" for. Null when the
+ *  diff is complete, so callers keep the exact small-diff behavior. A truncated
+ *  diff (ends with DIFF_TRUNCATED_LINE) covers only the blocks before its last,
+ *  possibly cut, block; an `incomplete` status covers only the blocks present. */
+export declare function diffContentGaps(diff: string, status?: DiffStatus): DiffContentGaps | null;
 export declare function analyzeDiff(diff: string): DiffAnalysis;
 /** A compact human-readable summary of a DiffAnalysis (used in decision text). */
 export declare function summarizeDiff(a: DiffAnalysis): string;

package/dist/extractors/diff.js

@@ -59,6 +59,148 @@ function importOf(line) {
 function stripAB(p) {
     return p.replace(/^[ab]\//, "");
 }
+const C_ESCAPES = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+/** Undo git's C-style path quoting. Even with core.quotePath=false, git quotes a
+ *  path holding `"`, `\`, or a control character (`"src/a\"b.ts"`); with the
+ *  default quotePath it also octal-escapes every byte above 0x7F. Octal escapes
+ *  are raw bytes, so the unescaped byte string is decoded as UTF-8. An unquoted
+ *  or malformed value is returned unchanged. */
+export function unquoteGitPath(p) {
+    if (p.length < 2 || !p.startsWith('"') || !p.endsWith('"'))
+        return p;
+    const body = p.slice(1, -1);
+    const bytes = [];
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch !== "\\") {
+            for (const b of Buffer.from(ch, "utf8"))
+                bytes.push(b);
+            continue;
+        }
+        const next = body[i + 1];
+        if (next === undefined)
+            return p;
+        if (/[0-7]/.test(next)) {
+            const oct = /^[0-7]{1,3}/.exec(body.slice(i + 1))[0];
+            bytes.push(parseInt(oct, 8) & 0xff);
+            i += oct.length;
+            continue;
+        }
+        const code = C_ESCAPES[next];
+        if (code === undefined)
+            return p;
+        bytes.push(code);
+        i += 1;
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
+/** A `---`/`+++` header path: strip git's trailing tab (added after names with
+ *  spaces), unquote, then drop the a/ b/ prefix. */
+function headerPath(raw) {
+    const value = raw.replace(/\r$/, "").replace(/\t$/, "").trim();
+    return value.startsWith('"') ? unquoteGitPath(value) : value;
+}
+/** The final line a budget-capped diff ends with (see SYNTHESIS_DIFF_BUDGET in git.ts). */
+export const DIFF_TRUNCATED_LINE = "…(diff truncated)…";
+/** Does this diff end with the truncation marker (i.e. is it a prefix of the change)? */
+export function isTruncatedDiff(diff) {
+    return diff === DIFF_TRUNCATED_LINE || diff.endsWith(`\n${DIFF_TRUNCATED_LINE}`);
+}
+/** The (new-side) path of every file block in a unified diff, in order — including
+ *  blocks with no hunks (binary, mode-only). Paths use the same keys as
+ *  DiffAnalysis.addedLinesByFile. */
+export function diffBlockFiles(diff) {
+    const out = [];
+    let cur = null;
+    const flush = () => { if (cur?.path)
+        out.push(cur.path); };
+    for (const raw of diff.split("\n")) {
+        if (raw.startsWith("diff --git ")) {
+            flush();
+            cur = { path: gitHeaderNewPath(raw.slice("diff --git ".length)), inHunk: false };
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (raw.startsWith("@@")) {
+            cur.inHunk = true;
+            continue;
+        }
+        if (cur.inHunk)
+            continue;
+        if (raw.startsWith("rename to ") || raw.startsWith("copy to ")) {
+            cur.path = headerPath(raw.slice(raw.indexOf(" to ") + 4));
+        }
+        else if (raw.startsWith("+++ ")) {
+            const p = headerPath(raw.slice(4));
+            if (p !== "/dev/null")
+                cur.path = stripAB(p);
+        }
+        else if (raw.startsWith("--- ")) {
+            const p = headerPath(raw.slice(4));
+            if (p !== "/dev/null")
+                cur.path = stripAB(p);
+        }
+    }
+    flush();
+    return out;
+}
+/** Which files a content check cannot trust "no added lines" for. Null when the
+ *  diff is complete, so callers keep the exact small-diff behavior. A truncated
+ *  diff (ends with DIFF_TRUNCATED_LINE) covers only the blocks before its last,
+ *  possibly cut, block; an `incomplete` status covers only the blocks present. */
+export function diffContentGaps(diff, status) {
+    const truncated = !!status?.truncated || isTruncatedDiff(diff);
+    const unread = new Set(status?.unreadFiles ?? []);
+    const wholeReason = status?.incomplete ?? (truncated ? "the diff was truncated before this file's changes" : undefined);
+    if (!wholeReason && !unread.size)
+        return null;
+    let covered = null;
+    if (wholeReason) {
+        const blocks = diffBlockFiles(diff);
+        if (truncated)
+            blocks.pop();
+        covered = new Set(blocks);
+    }
+    const outsideDiff = (f) => covered !== null && !covered.has(f);
+    return {
+        missing: (f) => unread.has(f) || outsideDiff(f),
+        reason: (files) => {
+            const parts = [];
+            if (files.some(outsideDiff))
+                parts.push(wholeReason);
+            if (files.some((f) => unread.has(f)))
+                parts.push("file content could not be read");
+            return parts.join("; ");
+        },
+    };
+}
+/** Best-effort new path from a `diff --git <a> <b>` line, used only when a block
+ *  has no ---/+++ header (binary or mode-only). Unambiguous when both sides are
+ *  the same path, which is the case for every non-rename block. */
+function gitHeaderNewPath(rest) {
+    const line = rest.replace(/\r$/, "");
+    if (line.startsWith('"')) {
+        const close = /^"(?:[^"\\]|\\.)*"/.exec(line);
+        if (!close)
+            return "";
+        const second = line.slice(close[0].length + 1);
+        return stripAB(unquoteGitPath(second.startsWith('"') ? second : second.trim()));
+    }
+    if (line.endsWith('"')) {
+        const open = line.lastIndexOf(' "');
+        return open >= 0 ? stripAB(unquoteGitPath(line.slice(open + 1))) : "";
+    }
+    // "a/P b/P": both halves have equal length when old and new path agree.
+    if ((line.length - 1) % 2 === 0) {
+        const half = (line.length - 1) / 2;
+        const a = line.slice(0, half), b = line.slice(half + 1);
+        if (stripAB(a) === stripAB(b))
+            return stripAB(b);
+    }
+    const lastB = line.lastIndexOf(" b/");
+    return lastB >= 0 ? line.slice(lastB + 3) : "";
+}
 export function analyzeDiff(diff) {
     const filesAdded = new Set();
     const filesDeleted = new Set();
@@ -106,24 +248,24 @@ export function analyzeDiff(diff) {
                 curDeleted = true;
             }
             else if (raw.startsWith("rename from ")) {
-                renameFrom = raw.slice("rename from ".length).trim();
+                renameFrom = headerPath(raw.slice("rename from ".length));
             }
             else if (raw.startsWith("copy from ")) {
-                renameFrom = raw.slice("copy from ".length).trim();
+                renameFrom = headerPath(raw.slice("copy from ".length));
             }
             else if (raw.startsWith("rename to ") || raw.startsWith("copy to ")) {
-                const to = raw.slice(raw.indexOf(" to ") + 4).trim();
+                const to = headerPath(raw.slice(raw.indexOf(" to ") + 4));
                 curFile = to;
                 if (isSubstantive(to))
                     filesRenamed.push({ from: renameFrom, to });
             }
             else if (raw.startsWith("--- ")) {
-                const p = raw.slice(4).trim();
+                const p = headerPath(raw.slice(4));
                 if (p !== "/dev/null")
                     curFile = stripAB(p); // old path (may be replaced by +++)
             }
             else if (raw.startsWith("+++ ")) {
-                const p = raw.slice(4).trim();
+                const p = headerPath(raw.slice(4));
                 if (p !== "/dev/null")
                     curFile = stripAB(p); // new path preferred
                 if (isSubstantive(curFile)) {

package/dist/extractors/git.d.ts

@@ -143,6 +143,9 @@ export declare function isolatedHeadSha(cwd: string): string;
  *  without deleting it locally. `--ignore-unmatch` makes an already-untracked path a
  *  no-op rather than an error; best-effort (a non-repo dir just no-ops). */
 export declare function gitUntrackCached(cwd: string, paths: string[]): void;
+/** Tracked files under the given pathspecs (repo-relative, POSIX). Best-effort:
+ *  `[]` when not a repository or nothing is tracked there. */
+export declare function gitTrackedPaths(cwd: string, paths: string[]): string[];
 /** Resolve any commit-ish (short sha / HEAD / branch) to a canonical full sha.
  *  Returns the input unchanged if it can't be resolved (e.g. not a git repo). */
 export declare function revParse(ref: string, cwd: string): string;
@@ -222,9 +225,28 @@ export type CommitRepairStatus = "orphaned" | "current" | "unresolvable" | "unkn
  *  be treated as repair-eligible; collapsing "false" and "error" into one
  *  boolean is exactly the bug this type exists to prevent. */
 export declare function commitRepairStatus(commit: string, ref: string, cwd: string): CommitRepairStatus;
-/** The unified diff for a commit, truncated to keep synthesis prompts bounded.
+/** Byte budget for a diff embedded in a SYNTHESIS prompt. Gates never use it: a
+ *  constraint check over a prefix of a change would read every file past the
+ *  cutoff as "no added lines" and pass it. */
+export declare const SYNTHESIS_DIFF_BUDGET = 60000;
+/** The diff a GATE evaluates (`hunch check`, the CI Constraint Guard, merge verdict,
+ *  veto, PR impact). Complete — no byte budget and no noise exclusion — or explicitly
+ *  marked incomplete, so content-matched constraints fail closed instead of reading a
+ *  missing hunk as "nothing added". */
+export interface GateDiff {
+    diff: string;
+    /** Why the diff cannot be trusted as complete (git failed, or its output exceeded
+     *  the capture ceiling). Every file without a diff block is then unevaluable. */
+    incomplete?: string;
+    /** Files whose content could not be read into the diff; unevaluable individually. */
+    unreadFiles?: string[];
+}
+/** Complete gating diff of one commit (see GateDiff). */
+export declare function commitGateDiff(sha: string, cwd: string): GateDiff;
+/** The unified diff for a commit, truncated to keep SYNTHESIS prompts bounded.
  *  Machine-generated noise (see DIFF_NOISE) is excluded so the model spends its
- *  budget on code that encodes intent, not on regenerated lockfiles/build output. */
+ *  budget on code that encodes intent, not on regenerated lockfiles/build output.
+ *  Not for gating: use commitGateDiff. */
 export declare function commitDiff(sha: string, cwd: string, maxBytes?: number): string;
 /** Number of commits touching a file in the last `days` (churn). */
 export declare function fileChurn(file: string, cwd: string, days?: number): number;
@@ -278,18 +300,25 @@ export declare function rangeFiles(base: string, cwd: string, head?: string): st
 /** Commit subjects on `head` since `base` (2-dot: commits added by the task),
  *  oldest-first, for distilling a runbook's ordered steps (roadmap #5). */
 export declare function rangeSubjects(base: string, cwd: string, head?: string, max?: number): string[];
-/** The PR's unified diff vs `base` (3-dot), for the Regression Guard's structural
- *  analysis. Same noise-exclusion + truncation budget as commit/staged diffs. */
+/** Complete gating diff of a PR vs `base` (3-dot: the CI Constraint Guard's surface). */
+export declare function rangeGateDiff(base: string, cwd: string, head?: string): GateDiff;
+/** The PR's unified diff vs `base` (3-dot), noise-excluded and capped at the
+ *  synthesis budget. Bounded-prompt use only; gates use rangeGateDiff. */
 export declare function rangeDiff(base: string, cwd: string, head?: string, maxBytes?: number): string;
-/** Unified diff of the staged changes (for the Regression Guard's structural
- *  analysis). Excludes machine-generated noise and truncates at the SAME budget as
- *  commitDiff, so the staged and `--commit` guard paths can't diverge on big diffs. */
+/** Complete gating diff of the staged changes (pre-commit `hunch check`). */
+export declare function stagedGateDiff(cwd: string): GateDiff;
+/** Unified diff of the staged changes, noise-excluded and capped at the synthesis
+ *  budget. Bounded-prompt use only; gates use stagedGateDiff. */
 export declare function stagedDiff(cwd: string, maxBytes?: number): string;
-/** Unified diff of the complete local working tree vs HEAD. Git's normal diff
+/** Complete gating diff of the local working tree vs HEAD. Git's normal diff
  * includes both staged and unstaged tracked edits; untracked text files are
- * appended as synthetic additions so guards can also see their added symbols.
- * Binary/unreadable files remain in workingFiles (scope checks still apply) but
- * intentionally contribute no synthetic content to regression analysis. */
+ * appended as synthetic additions so guards can also see their added lines.
+ * Binary files and non-regular paths (symlinks) contribute no content, as in a
+ * git diff; an untracked regular file that cannot be read is listed in
+ * `unreadFiles`, so content checks over it fail closed. */
+export declare function workingGateDiff(cwd: string): GateDiff;
+/** Working-tree diff vs HEAD capped at the synthesis budget. Bounded-prompt use
+ *  only; gates and rule verification use workingGateDiff. */
 export declare function workingDiff(cwd: string, maxBytes?: number): string;
 /** Resolve a time-travel ref (commit / tag / branch / HEAD~n) to the ISO author-
  *  date of that commit — the instant valid-time windows are filtered against.