@davesheffer/hunch 1.39.0 → 1.39.2

package/dist/extractors/git.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import { MEMLOG_FORMAT } from "../core/memorylog.js";
 import { hunchAttributesAreSafe, hunchTreeAttributesAreSafe, safeOverlayTree } from "../core/overlaySafety.js";
 import { createRepoFileReader } from "../core/safeRepoFile.js";
+import { DIFF_TRUNCATED_LINE } from "./diff.js";
 import { initiatorChildEnv } from "../synthesis/initiator.js";
 // `git` exports these repository-local variables to hooks. They outrank cwd/-C,
 // so carrying them from the code repository into a command for the memory
@@ -71,6 +72,26 @@ function gitSafe(args, cwd, maxBuffer) {
         return "";
     }
 }
+/** Untrimmed stdout with the same child environment as git(); null on ANY failure
+ *  (non-zero exit, spawn error, output over maxBuffer). For callers that must tell
+ *  "git produced nothing" apart from "git could not answer". */
+function gitOutputOrNull(args, cwd, maxBuffer = 64 * 1024 * 1024) {
+    try {
+        return execFileSync("git", args, {
+            cwd, encoding: "utf8", maxBuffer,
+            env: initiatorChildEnv(),
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/** Split `-z` path output. NUL-delimited paths are never C-quoted, so a path
+ *  holding `"`, `\`, a tab or a newline enumerates as its literal spelling. */
+function nulPaths(out) {
+    return out ? out.split("\0").filter(Boolean) : [];
+}
 /** Object-identity reads must not inherit clone-local replacement refs/grafts.
  * Most Git helpers intentionally preserve ordinary repository behavior; use
  * this narrower path only where a cross-clone canonical identity is minted. */
@@ -1808,6 +1829,14 @@ export function gitUntrackCached(cwd, paths) {
     }
     catch { /* best-effort: not a repo / nothing tracked */ }
 }
+/** Tracked files under the given pathspecs (repo-relative, POSIX). Best-effort:
+ *  `[]` when not a repository or nothing is tracked there. */
+export function gitTrackedPaths(cwd, paths) {
+    if (paths.length === 0)
+        return [];
+    const out = gitSafe(["-c", "core.quotePath=false", "ls-files", "--", ...paths], cwd);
+    return out ? out.split("\n").filter(Boolean) : [];
+}
 /** 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 function revParse(ref, cwd) {
@@ -1851,8 +1880,7 @@ export function currentBranch(cwd) {
 /** Files changed in a single commit. `--root` makes the initial commit (which
  *  has no parent) report its files as additions instead of returning nothing. */
 export function commitFiles(sha, cwd) {
-    const out = gitSafe(["-c", "core.quotePath=false", "diff-tree", "--no-commit-id", "--name-only", "-r", "--root", sha], cwd);
-    return out ? out.split("\n").filter(Boolean) : [];
+    return nulPaths(gitOutputOrNull(["-c", "core.quotePath=false", "diff-tree", "--no-commit-id", "--name-only", "-z", "-r", "--root", sha], cwd));
 }
 /** Raw `git log` over `.hunch/`, paired with parseMemoryLog — the memory-move
  *  timeline (each commit that changed the graph). Newest first; empty on any error
@@ -2302,12 +2330,55 @@ const DIFF_NOISE = [
     ":(exclude,glob)**/__snapshots__/**",
     ":(exclude,glob)**/*.generated.*",
 ];
-/** 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 const SYNTHESIS_DIFF_BUDGET = 60_000;
+function capDiff(out, maxBytes) {
+    return out.length > maxBytes ? out.slice(0, maxBytes) + `\n${DIFF_TRUNCATED_LINE}` : out;
+}
+/** Output ceiling for a gating diff. Past it git's output cannot be captured; the
+ *  diff is then reported incomplete and the gate fails closed (dec_20db57c576). */
+const GATE_DIFF_MAX_BUFFER = 256 * 1024 * 1024;
+/** Pinned so user/repo config cannot change what the diff parser sees: literal
+ *  UTF-8 paths (issue #50) and a/ b/ prefixes regardless of diff.noprefix or
+ *  diff.mnemonicPrefix. */
+const GATE_DIFF_FLAGS = ["--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", "--src-prefix=a/", "--dst-prefix=b/"];
+function gateDiff(args, cwd, what) {
+    const out = gitOutputOrNull(["-c", "core.quotePath=false", ...args], cwd, GATE_DIFF_MAX_BUFFER);
+    return out === null
+        ? { diff: "", incomplete: `git could not produce the ${what} diff (git error, or output over ${GATE_DIFF_MAX_BUFFER / (1024 * 1024)} MB)` }
+        : { diff: out };
+}
+/** C-quote a path the way git does when it holds `"`, `\`, or a control character,
+ *  so a synthetic diff header round-trips through analyzeDiff's unquoting. */
+function quoteDiffPath(path) {
+    if (!/["\\\x00-\x1f\x7f]/.test(path))
+        return path;
+    const named = { '"': '\\"', "\\": "\\\\", "\t": "\\t", "\n": "\\n", "\r": "\\r" };
+    let out = "";
+    for (const ch of path) {
+        const code = ch.charCodeAt(0);
+        if (named[ch])
+            out += named[ch];
+        else if (code < 0x20 || code === 0x7f)
+            out += "\\" + code.toString(8).padStart(3, "0");
+        else
+            out += ch;
+    }
+    return `"${out}"`;
+}
+/** Complete gating diff of one commit (see GateDiff). */
+export function commitGateDiff(sha, cwd) {
+    return gateDiff(["show", sha, "--format=", ...GATE_DIFF_FLAGS], cwd, `commit ${sha}`);
+}
+/** 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. */
-export function commitDiff(sha, cwd, maxBytes = 60_000) {
-    const out = gitSafe(["show", sha, "--no-color", "--format=", "--unified=2", "--", ...DIFF_NOISE], cwd);
-    return out.length > maxBytes ? out.slice(0, maxBytes) + "\n…(diff truncated)…" : out;
+ *  budget on code that encodes intent, not on regenerated lockfiles/build output.
+ *  Not for gating: use commitGateDiff. */
+export function commitDiff(sha, cwd, maxBytes = SYNTHESIS_DIFF_BUDGET) {
+    const out = gitSafe(["-c", "core.quotePath=false", "show", sha, "--no-color", "--format=", "--unified=2", "--", ...DIFF_NOISE], cwd);
+    return capDiff(out, maxBytes);
 }
 /** Number of commits touching a file in the last `days` (churn). */
 export function fileChurn(file, cwd, days = 90) {
@@ -2438,15 +2509,14 @@ export function fileGitMetrics(cwd, want, days = 90) {
  *  POSIX paths nor constraint scope globs — a blocking constraint over such a
  *  file graded as a vacuous PASS, and its churn/last-commit metrics read zero. */
 export function stagedFiles(cwd) {
-    const out = gitSafe(["-c", "core.quotePath=false", "diff", "--cached", "--no-ext-diff", "--no-textconv", "--name-only", "--diff-filter=ACMR"], cwd);
-    return out ? out.split("\n").filter(Boolean) : [];
+    return nulPaths(gitOutputOrNull(["-c", "core.quotePath=false", "diff", "--cached", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--diff-filter=ACMR"], cwd));
 }
 /** Files changed anywhere in the working tree compared with HEAD: both staged
  * and unstaged tracked files, plus untracked files. This powers the local,
  * pre-commit Change Gate; it never mutates the index or asks an agent/model. */
 export function workingFiles(cwd) {
-    const changed = gitSafe(["-c", "core.quotePath=false", "diff", "HEAD", "--no-ext-diff", "--no-textconv", "--name-only", "--diff-filter=ACMR"], cwd).split("\n").filter(Boolean);
-    const untracked = gitSafe(["-c", "core.quotePath=false", "ls-files", "--others", "--exclude-standard"], cwd).split("\n").filter(Boolean);
+    const changed = nulPaths(gitOutputOrNull(["-c", "core.quotePath=false", "diff", "HEAD", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--diff-filter=ACMR"], cwd));
+    const untracked = nulPaths(gitOutputOrNull(["-c", "core.quotePath=false", "ls-files", "-z", "--others", "--exclude-standard"], cwd));
     return [...new Set([...changed, ...untracked])].sort();
 }
 /** Does a ref resolve to a commit in this repo? Lets `--base` fail LOUDLY on an
@@ -2458,8 +2528,7 @@ export function revExists(ref, cwd) {
 /** Files a PR/branch changes vs `base` (3-dot: changes on HEAD since the merge-base,
  *  i.e. exactly the PR's own commits — the CI Constraint Guard's surface). */
 export function rangeFiles(base, cwd, head = "HEAD") {
-    const out = gitSafe(["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--no-textconv", "--name-only", "--diff-filter=ACMR", `${base}...${head}`], cwd);
-    return out ? out.split("\n").filter(Boolean) : [];
+    return nulPaths(gitOutputOrNull(["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--diff-filter=ACMR", `${base}...${head}`], cwd));
 }
 /** Commit subjects on `head` since `base` (2-dot: commits added by the task),
  *  oldest-first, for distilling a runbook's ordered steps (roadmap #5). */
@@ -2467,43 +2536,78 @@ export function rangeSubjects(base, cwd, head = "HEAD", max = 50) {
     const out = gitSafe(["log", "--reverse", `-n${max}`, "--format=%s", `${base}..${head}`], cwd);
     return out ? out.split("\n").filter(Boolean) : [];
 }
-/** 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. */
-export function rangeDiff(base, cwd, head = "HEAD", maxBytes = 60_000) {
-    const out = gitSafe(["diff", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", `${base}...${head}`, "--", ...DIFF_NOISE], cwd);
-    return out.length > maxBytes ? out.slice(0, maxBytes) + "\n…(diff truncated)…" : out;
+/** Complete gating diff of a PR vs `base` (3-dot: the CI Constraint Guard's surface). */
+export function rangeGateDiff(base, cwd, head = "HEAD") {
+    return gateDiff(["diff", ...GATE_DIFF_FLAGS, `${base}...${head}`], cwd, `${base}...${head}`);
+}
+/** 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 function rangeDiff(base, cwd, head = "HEAD", maxBytes = SYNTHESIS_DIFF_BUDGET) {
+    const out = gitSafe(["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", `${base}...${head}`, "--", ...DIFF_NOISE], cwd);
+    return capDiff(out, maxBytes);
 }
-/** 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. */
-export function stagedDiff(cwd, maxBytes = 60_000) {
-    const out = gitSafe(["diff", "--cached", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", "--", ...DIFF_NOISE], cwd);
-    return out.length > maxBytes ? out.slice(0, maxBytes) + "\n…(diff truncated)…" : out;
+/** Complete gating diff of the staged changes (pre-commit `hunch check`). */
+export function stagedGateDiff(cwd) {
+    return gateDiff(["diff", "--cached", ...GATE_DIFF_FLAGS], cwd, "staged");
 }
-/** Unified diff of the complete local working tree vs HEAD. Git's normal diff
+/** Unified diff of the staged changes, noise-excluded and capped at the synthesis
+ *  budget. Bounded-prompt use only; gates use stagedGateDiff. */
+export function stagedDiff(cwd, maxBytes = SYNTHESIS_DIFF_BUDGET) {
+    const out = gitSafe(["-c", "core.quotePath=false", "diff", "--cached", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", "--", ...DIFF_NOISE], cwd);
+    return capDiff(out, maxBytes);
+}
+/** 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. */
-export function workingDiff(cwd, maxBytes = 60_000) {
-    let out = gitSafe(["diff", "HEAD", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=2", "--", ...DIFF_NOISE], cwd);
-    const tracked = new Set(gitSafe(["-c", "core.quotePath=false", "diff", "HEAD", "--no-ext-diff", "--no-textconv", "--name-only", "--diff-filter=ACMR"], cwd).split("\n").filter(Boolean));
-    const untracked = gitSafe(["-c", "core.quotePath=false", "ls-files", "--others", "--exclude-standard"], cwd).split("\n").filter((f) => f && !tracked.has(f));
+ * 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 function workingGateDiff(cwd) {
+    // An unborn HEAD has no tracked diff (workingFiles enumerates only untracked
+    // files there); any other failure to diff makes the gate input incomplete.
+    const hasHead = revExists("HEAD", cwd);
+    const tracked = hasHead ? gateDiff(["diff", "HEAD", ...GATE_DIFF_FLAGS], cwd, "working-tree") : { diff: "" };
+    const trackedNames = hasHead
+        ? gitOutputOrNull(["-c", "core.quotePath=false", "diff", "HEAD", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--diff-filter=ACMR"], cwd)
+        : "";
+    const untrackedNames = gitOutputOrNull(["-c", "core.quotePath=false", "ls-files", "-z", "--others", "--exclude-standard"], cwd);
+    const incomplete = tracked.incomplete
+        ?? (trackedNames === null || untrackedNames === null ? "git could not enumerate the working-tree changes" : undefined);
+    const trackedSet = new Set(nulPaths(trackedNames));
+    const untracked = nulPaths(untrackedNames).filter((f) => !trackedSet.has(f));
     const readWorkingFile = createRepoFileReader(cwd);
+    const unreadFiles = [];
+    let out = tracked.diff;
     for (const file of untracked) {
+        let regular = false;
         try {
-            const text = readWorkingFile(file);
-            if (text === null)
-                continue;
-            if (text.includes("\0"))
-                continue;
-            const lines = text.split("\n");
-            const add = lines.map((line) => `+${line}`).join("\n");
-            out += `${out ? "\n" : ""}diff --git a/${file} b/${file}\nnew file mode 100644\n--- /dev/null\n+++ b/${file}\n@@ -0,0 +1,${lines.length} @@\n${add}\n`;
+            regular = lstatSync(join(cwd, file)).isFile();
         }
-        catch { /* unreadable / directory / binary: scope-only is still safe */ }
-    }
-    return out.length > maxBytes ? out.slice(0, maxBytes) + "\n…(diff truncated)…" : out;
+        catch { /* vanished: nothing to inspect */ }
+        if (!regular)
+            continue; // symlink / directory / gone: no file content to add
+        const text = readWorkingFile(file);
+        if (text === null) {
+            unreadFiles.push(file);
+            continue;
+        }
+        if (text.includes("\0"))
+            continue; // binary: git shows no text hunks for it either
+        const lines = text.split("\n");
+        const add = lines.map((line) => `+${line}`).join("\n");
+        const newPath = quoteDiffPath(`b/${file}`);
+        out += `${out && !out.endsWith("\n") ? "\n" : ""}diff --git ${quoteDiffPath(`a/${file}`)} ${newPath}\nnew file mode 100644\n--- /dev/null\n+++ ${newPath}\n@@ -0,0 +1,${lines.length} @@\n${add}\n`;
+    }
+    return {
+        diff: out,
+        ...(incomplete ? { incomplete } : {}),
+        ...(unreadFiles.length ? { unreadFiles } : {}),
+    };
+}
+/** Working-tree diff vs HEAD capped at the synthesis budget. Bounded-prompt use
+ *  only; gates and rule verification use workingGateDiff. */
+export function workingDiff(cwd, maxBytes = SYNTHESIS_DIFF_BUDGET) {
+    return capDiff(workingGateDiff(cwd).diff, maxBytes);
 }
 /** 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.

package/dist/extractors/workspaces.d.ts

@@ -12,6 +12,16 @@ export interface SnapshotOptions {
     /** Record bound override (tests). Never above the schema's MAX_BRANCHES. */
     maxBranches?: number;
 }
+/** Bound on the ignored paths NAMED in a prune plan; the total is always reported. */
+export declare const MAX_IGNORED_SHOWN = 10;
+/** Ignored files and directories in a worktree — what `git worktree remove` (without
+ *  `--force`) deletes silently. Not a refusal (every Node worktree has node_modules/), but a
+ *  prune plan and its confirmation name them. An ignored directory is one entry. Read live
+ *  for this machine's plan only; never stored in a record. null when git cannot tell. */
+export declare function ignoredPaths(path: string, maxShown?: number): {
+    shown: string[];
+    total: number;
+} | null;
 /** Snapshot this machine's workspace for the repository at `root`. Validated against the
  *  strict schema before it is returned, so the extractor can never emit a record the
  *  loader would refuse. */

package/dist/extractors/workspaces.js

@@ -13,13 +13,15 @@ import { existsSync, realpathSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { foreignRepoEnv, gitCommonDir, mainWorktreeRoot, stableRepositoryName } from "./git.js";
 import { extracted } from "../core/types.js";
-import { MAX_BRANCHES, MAX_WORKTREES, WORKSPACE_SCHEMA_VERSION, WorkspaceSchema, isSafeBranchName, workspaceId, worktreeId, } from "../core/workspace.js";
+import { CONTROL_CHARS, MAX_BRANCHES, MAX_WORKTREES, WORKSPACE_SCHEMA_VERSION, WorkspaceSchema, isSafeBranchName, workspaceId, worktreeId, } from "../core/workspace.js";
 const SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 const MAX_OUTPUT = 64 * 1024 * 1024;
 /** How far back in the default branch a squash-merge is searched for. */
 export const DEFAULT_SQUASH_SEARCH_COMMITS = 2000;
 function env() {
-    return foreignRepoEnv(process.env);
+    // GIT_OPTIONAL_LOCKS=0: a read-only snapshot (it runs from hooks, in the background) must
+    // never take the index lock `git status` would otherwise grab to refresh stat data.
+    return { ...foreignRepoEnv(process.env), GIT_OPTIONAL_LOCKS: "0" };
 }
 function run(cwd, args, timeout = 10_000) {
     try {
@@ -112,13 +114,41 @@ function listWorktrees(root) {
     return items.filter((w) => !w.bare);
 }
 /** `git status --porcelain` is non-empty → uncommitted or untracked work that
- *  `git worktree remove` would refuse to discard. null when the path is gone. */
+ *  `git worktree remove` would refuse to discard. null when the path is gone.
+ *  `--untracked-files=all` is explicit: `status.showUntrackedFiles=no` in the user's config
+ *  would otherwise hide an untracked source file and report the worktree clean. */
 function isDirty(path) {
     if (!existsSync(path))
         return null;
-    const out = run(path, ["status", "--porcelain", "--ignore-submodules"]);
+    const out = run(path, ["status", "--porcelain", "--untracked-files=all"]);
     return out === null ? null : out.trim().length > 0;
 }
+/** Bound on the ignored paths NAMED in a prune plan; the total is always reported. */
+export const MAX_IGNORED_SHOWN = 10;
+/** Ignored files and directories in a worktree — what `git worktree remove` (without
+ *  `--force`) deletes silently. Not a refusal (every Node worktree has node_modules/), but a
+ *  prune plan and its confirmation name them. An ignored directory is one entry. Read live
+ *  for this machine's plan only; never stored in a record. null when git cannot tell. */
+export function ignoredPaths(path, maxShown = MAX_IGNORED_SHOWN) {
+    if (!existsSync(path))
+        return null;
+    // `--untracked-files=normal` is explicit: `--ignored=matching` refuses the `no` a user's
+    // status.showUntrackedFiles would otherwise supply.
+    const out = run(path, ["status", "--porcelain", "-z", "--ignored=matching", "--untracked-files=normal"]);
+    if (out === null)
+        return null;
+    const fields = out.split("\0");
+    const entries = [];
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        if (field.startsWith("!! "))
+            entries.push(field.slice(3));
+        else if (/^(?:[RC].|.[RC]) /.test(field))
+            i++; // a rename/copy carries its source path as the next field
+    }
+    entries.sort();
+    return { shown: entries.slice(0, maxShown), total: entries.length };
+}
 function listBranches(root) {
     const format = ["%(refname)", "%(objectname)", "%(upstream)", "%(upstream:track,nobracket)", "%(committerdate:iso-strict)", "%(worktreepath)"].join("%00");
     const out = run(root, ["for-each-ref", `--format=${format}`, "refs/heads/"]) ?? "";
@@ -221,13 +251,30 @@ function prFromSquashCommit(root, commit) {
 function withPr(verdict, pr) {
     return pr === undefined ? verdict : { ...verdict, pr, evidence: [...verdict.evidence, `pull request #${pr} (from the local commit subject)`] };
 }
-function mergedVerdict(root, name, head, def, patchIds, searched) {
+/** The default branch's first-parent history: the commits made (or fast-forwarded) directly
+ *  on it. null when git cannot list it. */
+function firstParentsOf(root, head) {
+    const out = run(root, ["rev-list", "--first-parent", "--end-of-options", head, "--"], 60_000);
+    if (out === null)
+        return null;
+    return new Set(out.split("\n").map((l) => l.trim()).filter((l) => SHA.test(l)));
+}
+function mergedVerdict(root, name, head, def, patchIds, firstParents, searched) {
     if (!def)
         return { status: "unknown", method: null, evidence: ["no default branch resolved (origin/HEAD, origin/main, origin/master, main, master)"] };
     const ancestor = predicate(root, ["merge-base", "--is-ancestor", head, def.head]);
     if (ancestor === null)
         return { status: "unknown", method: null, evidence: ["git merge-base failed"] };
     if (ancestor) {
+        // A head ON the default branch's first-parent line holds no commits of its own: a branch
+        // created and never committed to (or fast-forwarded in). Ancestry would call it merged
+        // and prune would delete it with its worktree; it is labeled and kept instead.
+        const line = firstParents();
+        if (line === null)
+            return { status: "unknown", method: null, evidence: [`${head.slice(0, 12)} is an ancestor of ${def.ref}; its first-parent history could not be read`] };
+        if (line.has(head)) {
+            return { status: "no-commits", method: null, evidence: [`${head.slice(0, 12)} is on ${def.ref}@${def.head.slice(0, 12)} first-parent history: no commits of its own (or fast-forwarded)`] };
+        }
         const verdict = { status: "merged", method: "ancestry", evidence: [`${head.slice(0, 12)} is an ancestor of ${def.ref}@${def.head.slice(0, 12)}`] };
         return withPr(verdict, prFromMergeCommits(root, name, `${head}..${def.head}`));
     }
@@ -238,20 +285,46 @@ function mergedVerdict(root, name, head, def, patchIds, searched) {
     if (!known.ok) {
         return { status: "unmerged", method: null, evidence: [`not an ancestor of ${def.ref}@${def.head.slice(0, 12)}; squash/rebase search unavailable (default-branch history too large or git failed)`] };
     }
+    // Only default-branch commits AFTER the merge base can have landed this branch — the set
+    // `git cherry` compares against. A matching commit already behind the base is the branch's
+    // own history: a reland (revert of a revert) or a value flipped back matches the ORIGINAL
+    // commit and is not merged. The map keeps the newest commit per patch-id, so when that one
+    // is behind the base every older one is too. null → git failed (never "no").
+    const landedAfterBase = (commit) => {
+        const behind = predicate(root, ["merge-base", "--is-ancestor", commit, base]);
+        return behind === null ? null : !behind;
+    };
     const combined = combinedPatchId(root, base, head);
     if (combined) {
         const commit = known.map.get(combined);
         if (commit) {
-            const verdict = { status: "merged", method: "squash", evidence: [`patch-id of ${base.slice(0, 12)}..${head.slice(0, 12)} equals ${def.ref} commit ${commit.slice(0, 12)}`] };
-            return withPr(verdict, prFromSquashCommit(root, commit));
+            const after = landedAfterBase(commit);
+            if (after === null)
+                return { status: "unknown", method: null, evidence: ["git merge-base failed"] };
+            if (after) {
+                const verdict = { status: "merged", method: "squash", evidence: [`patch-id of ${base.slice(0, 12)}..${head.slice(0, 12)} equals ${def.ref} commit ${commit.slice(0, 12)}`] };
+                return withPr(verdict, prFromSquashCommit(root, commit));
+            }
         }
     }
     // Rebase / cherry-pick: every commit of the branch has a patch-equivalent commit in the
-    // default branch. Uses the one-time map instead of `git cherry`, whose cost grows with
-    // the default branch's history for EVERY branch checked.
+    // default branch after the merge base. Uses the one-time map instead of `git cherry`, whose
+    // cost grows with the default branch's history for EVERY branch checked.
     const own = patchIdsOf(root, [`${base}..${head}`], null, 30_000);
-    if (own.ok && own.map.size && [...own.map.keys()].every((id) => known.map.has(id))) {
-        return { status: "merged", method: "rebase", evidence: [`all ${own.map.size} commit(s) have a patch-equivalent commit in ${def.ref} (last ${searched} searched)`] };
+    if (own.ok && own.map.size) {
+        let all = true;
+        for (const id of own.map.keys()) {
+            const commit = known.map.get(id);
+            const after = commit ? landedAfterBase(commit) : false;
+            if (after === null)
+                return { status: "unknown", method: null, evidence: ["git merge-base failed"] };
+            if (!after) {
+                all = false;
+                break;
+            }
+        }
+        if (all)
+            return { status: "merged", method: "rebase", evidence: [`all ${own.map.size} commit(s) have a patch-equivalent commit in ${def.ref} after the merge base (last ${searched} searched)`] };
     }
     return { status: "unmerged", method: null, evidence: [`not in ${def.ref}@${def.head.slice(0, 12)}; squash/rebase searched last ${searched} commits`] };
 }
@@ -286,6 +359,8 @@ export function snapshotWorkspace(root, opts) {
     const searched = opts.squashSearchCommits ?? DEFAULT_SQUASH_SEARCH_COMMITS;
     let patchIds = null;
     const lazyPatchIds = () => (patchIds ??= def ? patchIdsOf(main, [def.head], searched, 60_000) : { map: new Map(), ok: true });
+    let firstParents;
+    const lazyFirstParents = () => (firstParents === undefined ? (firstParents = def ? firstParentsOf(main, def.head) : null) : firstParents);
     const notes = [];
     const allWorktrees = listWorktrees(main).map((w) => ({ ...w, date: iso(run(main, ["log", "-1", "--format=%cI", "--end-of-options", w.head, "--"])) }));
     const rawWorktrees = allWorktrees.length > MAX_WORKTREES ? newestFirst(allWorktrees).slice(0, MAX_WORKTREES) : allWorktrees;
@@ -294,7 +369,9 @@ export function snapshotWorkspace(root, opts) {
     const mainReal = realpath(main);
     const worktrees = rawWorktrees.map((w) => ({
         id: worktreeId(w.path),
-        path: opts.publish === "full" ? w.path : null,
+        // A path with a control character (newline, ESC) is never recorded or printed; without a
+        // path `prune --apply` refuses the worktree instead of guessing.
+        path: opts.publish === "full" && !CONTROL_CHARS.test(w.path) ? w.path : null,
         branch: w.branch,
         head: w.head,
         is_main: realpath(w.path) === mainReal,
@@ -325,7 +402,7 @@ export function snapshotWorkspace(root, opts) {
             worktree: (b.worktreePath && worktreeByPath.get(b.worktreePath)) || null,
             merged: def?.name === b.name
                 ? { status: "unmerged", method: null, evidence: ["default branch"] }
-                : mergedVerdict(main, b.name, b.head, def, lazyPatchIds, searched),
+                : mergedVerdict(main, b.name, b.head, def, lazyPatchIds, lazyFirstParents, searched),
         };
     });
     const record = {
@@ -340,8 +417,8 @@ export function snapshotWorkspace(root, opts) {
         worktrees,
         branches,
         provenance: extracted(1, [
-            "git worktree list --porcelain", "git for-each-ref refs/heads/", "git status --porcelain",
-            "git merge-base --is-ancestor", "git diff | git patch-id --stable", "git log -p | git patch-id --stable",
+            "git worktree list --porcelain", "git for-each-ref refs/heads/", "git status --porcelain --untracked-files=all",
+            "git merge-base --is-ancestor", "git rev-list --first-parent", "git diff | git patch-id --stable", "git log -p | git patch-id --stable",
             ...notes,
         ]),
     };

package/dist/integrations/gitignore.d.ts

@@ -1,12 +1,20 @@
 export interface GitignoreResult {
     path: string;
-    action: "created" | "appended" | "unchanged";
+    /** `updated` = an existing managed block was brought up to the current entry list. */
+    action: "created" | "appended" | "updated" | "unchanged";
+    /** Entries this call newly wrote into the managed block (empty when unchanged). */
+    added: string[];
 }
 /** Defense in depth for integration files written automatically after a clone.
  * Refuse symlinks, directories/devices, and hard links; require the canonical
  * target to be the expected top-level file inside the canonical repository root. */
 export declare function assertSafeTopLevelConfigFile(root: string, name: string): string;
-export declare function ensureGitignore(root: string): GitignoreResult;
+/** `upgradeExisting: false` only adds a missing block and never rewrites a present
+ *  one — for `hunch index`, which also runs in CI and release gates where rewriting
+ *  a tracked .gitignore would dirty the checkout. Setup and repair commands upgrade. */
+export declare function ensureGitignore(root: string, opts?: {
+    upgradeExisting?: boolean;
+}): GitignoreResult;
 /** Ignore the engineering-memory tree so a private-migrated repo stays code-only.
  *  The kind subdirs the user's records live in (decisions/, bugs/, …) move to the
  *  private overlay; this stops git from re-publishing them. The `.hunch/` dir, its
@@ -14,3 +22,20 @@ export declare function ensureGitignore(root: string): GitignoreResult;
 export declare function ignoreHunchMemory(root: string): GitignoreResult;
 /** The .hunch memory subdirs un-published by a private migration (git pathspecs). */
 export declare const HUNCH_MEMORY_DIRS: string[];
+export interface ManagedGitignoreUpgrade {
+    /** The base runtime block, when this repository already has it. */
+    base: GitignoreResult | null;
+    /** The private-only memory block, when this repository was migrated to an overlay. */
+    memory: GitignoreResult | null;
+    /** Tracked memory files removed from the git INDEX (the files stay on disk). */
+    untracked: string[];
+}
+/** Bring every EXISTING managed block up to the current entry lists without adding
+ *  a block the repository never had (a repair path, not setup). A private-only
+ *  block means the repository already declared its memory tree unpublished, so
+ *  memory directories that a later release added to that block are also removed
+ *  from the git index — never from disk — as `private --migrate` does for the whole
+ *  list. */
+export declare function upgradeManagedGitignore(root: string): ManagedGitignoreUpgrade;
+/** Output lines describing what an upgrade changed; empty when nothing did. */
+export declare function describeGitignoreUpgrade(upgrade: ManagedGitignoreUpgrade): string[];