@davesheffer/hunch 1.46.0 → 1.47.0

package/dist/core/paths.js

@@ -3,12 +3,11 @@ import { join } from "node:path";
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 export const HUNCH_DIR = ".hunch";
-/** Canonicalize a free-form path/target to forward-slash form (Hunch stores every
- *  path with "/" — git emits it on all OSes — so any user- or agent-supplied
- *  target must be normalized before comparison, otherwise a Windows caller passing
- *  `src\auth\session.ts` never matches the stored `src/auth/session.ts`). Safe on
- *  symbol names too: they contain no backslashes. This does NOT make a path
- *  repo-relative — an absolute path passes through with its separators flipped,
+/** Convert a user- or agent-supplied path/target to forward-slash form. Hunch
+ *  stores every path with "/" (git emits it on every OS), so a Windows-style
+ *  backslash path would otherwise never match the stored form. Harmless on
+ *  symbol names, which carry no backslashes. It does NOT make a path
+ *  repo-relative: an absolute path only has its separators flipped and is left
  *  unchanged otherwise; use `repoRelativeTarget` for that.
  *
  *  Inherently ambiguous for a string like `docs/notes\notes.md`: it could be a
@@ -21,47 +20,42 @@ export const HUNCH_DIR = ".hunch";
 export function toPosixTarget(target) {
     return target.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-/** realpath a path even if it doesn't exist yet (e.g. a new file an agent is about
- *  to Write, or a glob whose concrete segments aren't literal): resolve the longest
- *  existing ancestor, then re-append the missing tail. Idempotent on an
- *  already-resolved path. */
+/** Canonical real path of `p`, tolerant of paths that do not exist yet (a file
+ *  about to be written, a glob with non-literal segments): the longest existing
+ *  ancestor is resolved through the native realpath and the missing trailing
+ *  segments are re-appended unchanged. Terminates at the filesystem root,
+ *  is idempotent on a resolved path and never throws for a missing one. */
 export function realpathNorm(p) {
-    try {
-        return realpathSync.native(p);
-    }
-    catch {
-        const parent = dirname(p);
-        if (parent === p)
-            return p; // hit the root; nothing more to resolve
-        return join(realpathNorm(parent), basename(p));
+    const tail = [];
+    let cur = p;
+    for (;;) {
+        try {
+            const real = realpathSync.native(cur);
+            return tail.length ? join(real, ...tail.reverse()) : real;
+        }
+        catch {
+            const parent = dirname(cur);
+            if (parent === cur)
+                return p;
+            tail.push(basename(cur));
+            cur = parent;
+        }
     }
 }
-/** Rewrite an ABSOLUTE target to repo-relative POSIX form when it falls inside
- *  `root`. Hunch's stored paths (symbols, constraint scopes, ...) are always
- *  repo-relative, so a caller that hands over an absolute edit-payload path
- *  matched nothing (issue #296: hunch_check_constraints / hunch_blast_radius
- *  returned empty for an absolute target that plainly had a matching rule). A
- *  relative target, a glob, or an absolute path outside `root` passes through
- *  unchanged (toPosixTarget'd) — there is nothing safe to rewrite it to.
- *
- *  BOTH ends are realpath-normalized before the relative-path computation: on
- *  macOS `process.cwd()` (hence `findRoot`) resolves /var → /private/var, but a
- *  hook event's `file_path` arrives UN-resolved, so a naive `relative()` yields a
- *  bogus "../" path under a symlinked root (/var, /tmp, symlinked $HOME) and the
- *  caller treats the file as outside the repo, silently dropping all context
- *  (dec_e0a36efbf5). */
+/** Rewrite an ABSOLUTE `target` to repo-relative forward-slash form when it lies
+ *  inside `root`. Stored Hunch paths are always repo-relative, so an absolute
+ *  path lifted from an edit payload otherwise matches nothing (issue #296).
+ *  Both ends go through `realpathNorm`, so a symlinked root (macOS /var vs
+ *  /private/var, /tmp, a symlinked home) cancels out (dec_e0a36efbf5). Anything
+ *  with no safe repo-relative form (the root itself, an escape, a drive-letter
+ *  remainder) is returned in its normalized form unchanged. */
 export function repoRelativeTarget(target, root) {
-    const t = toPosixTarget(target);
-    const looksAbsolute = isAbsolute(t) || /^[a-zA-Z]:/.test(t);
-    if (!looksAbsolute)
-        return t;
-    // `root` is posix'd too, not just `target`: realpathNorm's fallback walk decomposes
-    // by "/" (via node:path, which on a POSIX host does NOT treat "\" as a separator),
-    // so an un-posix'd root and a posix'd target would decompose into differently-shaped
-    // ancestor chains and never share a common realpath'd prefix.
-    const rel = toPosixTarget(relative(realpathNorm(toPosixTarget(root)), realpathNorm(t)));
-    if (!rel || rel === ".." || rel.startsWith("../") || isAbsolute(rel) || /^[a-zA-Z]:/.test(rel))
-        return t;
+    const norm = toPosixTarget(target);
+    if (!isAbsolute(norm) && !/^[A-Za-z]:/.test(norm))
+        return norm;
+    const rel = relative(realpathNorm(toPosixTarget(root)), realpathNorm(norm)).replace(/\\/g, "/");
+    if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute(rel) || /^[A-Za-z]:/.test(rel))
+        return norm;
     return rel;
 }
 /** True when `target` (already repo-relative POSIX form) names a regular FILE

package/dist/core/refrepair.d.ts

@@ -12,10 +12,11 @@ export interface DecisionReferenceRepair {
     relatedFiles: number;
     evidence: number;
 }
-export declare function replaceExact(values: string[], from: string, to: string): {
+export type ExactReplacement = {
     values: string[];
     changed: number;
 };
+export declare function replaceExact(refs: string[], target: string, replacement: string): ExactReplacement;
 /**
  * Return a corrected copy of a decision, or `null` when the source reference is
  * not present. The decision's semantic content and verification timestamp are

package/dist/core/refrepair.js

@@ -1,10 +1,10 @@
-export function replaceExact(values, from, to) {
+export function replaceExact(refs, target, replacement) {
     let changed = 0;
-    const replaced = values.map((value) => {
-        if (value !== from)
+    const replaced = refs.map((value) => {
+        if (value !== target)
             return value;
         changed++;
-        return to;
+        return replacement;
     });
     // A decision may already cite the destination. Keep the reference list a set
     // after the repair so a correction cannot create duplicate scope/evidence.

package/dist/core/repairqueue.d.ts

@@ -1,40 +1,23 @@
-import { type CommitRewrite, type DroppedRewrite } from "./commitrepair.js";
-/** Tolerant read: a missing or corrupt queue file is treated as empty — this
- *  is local scratch state, never a source of truth worth failing loudly over. */
+import type { CommitRewrite, DroppedRewrite } from "./commitrepair.js";
+/** The raw queue. Missing, corrupt or non-array files read as `[]`; never throws. */
 export declare function readPendingRepairs(root: string): CommitRewrite[];
+/** Atomically replace the queue. Writing `[]` clears it. */
 export declare function writePendingRepairs(root: string, rewrites: readonly CommitRewrite[]): void;
-/** Tolerant read, same discipline as readPendingRepairs. */
+/** The tombstones of rewrites rejected with `--drop`. Same tolerance as the queue. */
 export declare function readDroppedRepairs(root: string): DroppedRewrite[];
+/** Atomically replace the tombstone file. Writing `[]` clears it. */
 export declare function writeDroppedRepairs(root: string, dropped: readonly DroppedRewrite[]): void;
-/** The queue as every READ-ONLY consumer should see it: raw entries minus
- *  anything a human already rejected via `--drop`, regardless of how a
- *  tombstoned entry ended up back in the raw queue file (e.g. the post-merge
- *  hook's backgrounded detection racing a `--drop`). A read-time filter, not
- *  a mutation — the raw queue file is untouched.
- *
- *  `repair-provenance`'s own action is the one exception: it needs the RAW
- *  read (via readPendingRepairs) because it diffs raw-vs-swept to report what
- *  it cleaned up, and it persists the sweep back to disk. Every other
- *  reader — `hunch escalations`, SessionStart orientation, the `hunch_now`
- *  and `hunch_escalations` MCP tools — must call this instead, or a
- *  tombstoned entry that hasn't yet been swept by a `repair-provenance` run
- *  re-surfaces as if the human never answered it. */
+/**
+ * The raw queue minus anything tombstoned. Read-only: it never changes either
+ * file. Every read-only consumer uses this -- `hunch escalations`, SessionStart
+ * orientation, and the `hunch_now` and `hunch_escalations` MCP tools. Only
+ * `repair-provenance` itself reads the raw queue.
+ */
 export declare function readActivePendingRepairs(root: string): CommitRewrite[];
-/** The `queued` entries whose proposed `to` doesn't resolve to a real commit
- *  in this repository — the same withheldForUnresolvableTo gate
- *  `repair-provenance --apply` itself runs before writing, surfaced here so
- *  a READ-ONLY consumer (hunch escalations, hunch_now/hunch_escalations,
- *  SessionStart orientation) can tell a permanently-stuck entry apart from
- *  one `--apply` can still resolve, instead of advertising a
- *  `--apply --only <id>` that's guaranteed to no-op forever. `null` from
- *  commitsExist (the check itself failed to run) is treated as fail-open —
- *  same discipline as the apply path — so nothing is misreported as
- *  withheld just because the check couldn't run.
- *
- *  Returns the OBJECTS, not their ids, and every caller must pass the exact
- *  same `queued` array into both this function and whatever it hands the
- *  result to (commitRepairEscalations) — an id-keyed set would collapse a
- *  corrupted queue's two same-id entries (one resolvable, one not) into one
- *  unit, exactly the identity confusion withheldForUnresolvableTo's own
- *  docstring warns about. */
+/**
+ * The queued entries whose proposed `to` does not resolve in this repository.
+ * Fails open (nothing withheld) when git cannot answer. The set holds the
+ * caller's own objects, so callers must pass the same `queued` array here and to
+ * whatever consumes the result.
+ */
 export declare function withheldRewrites(root: string, queued: readonly CommitRewrite[]): Set<CommitRewrite>;

package/dist/core/repairqueue.js

@@ -1,131 +1,81 @@
 /**
- * Local-only queue of commit-provenance repairs detected opportunistically
- * (typically by the post-merge hook, src/integrations/hooks.ts) but not yet
- * applied. `.hunch/pending-commit-repairs.json` is gitignored the same way
- * `.hunch/local.json` is — never committed, never pushed. It exists because
- * the opportunistic detection window is narrow: `ORIG_HEAD` gets overwritten
- * by the next merge, and the matched-away commit can eventually be gc'd —
- * queuing the exact {id, from, to} triple here lets a human confirm the match
- * later (`hunch repair-provenance --apply`) without losing it.
+ * Local-only queue of detected-but-not-yet-applied commit-provenance repairs.
  *
- * `.hunch/dropped-commit-repairs.json` is the sibling tombstone file: a human
- * rejecting a queued match via `--drop` records the exact {id, from, to}
- * triple here, durably, so detection re-deriving the identical match on a
- * later merge doesn't re-queue what was already rejected — a genuinely
- * different replacement (`to`) for the same still-orphaned commit is a new
- * proposal and still surfaces (see commitrepair.ts's withoutDropped). Same
- * local-only, gitignored discipline as the queue.
+ * It is filled opportunistically, usually by the post-merge hook, and is
+ * gitignored like `.hunch/local.json` -- never committed. It exists because the
+ * detection window is narrow: `ORIG_HEAD` gets overwritten and the matched-away
+ * commit can be garbage-collected. A human confirms later with
+ * `hunch repair-provenance --apply`. A sibling tombstone file records the exact
+ * `{id, from, to}` triples rejected with `--drop`, so re-detection does not
+ * re-queue them.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./io.js";
 import { withoutDropped, withheldForUnresolvableTo } from "./commitrepair.js";
 import { commitsExist } from "../extractors/git.js";
-function queuePath(root) {
-    return join(root, ".hunch", "pending-commit-repairs.json");
-}
-function droppedPath(root) {
-    return join(root, ".hunch", "dropped-commit-repairs.json");
-}
-function isCommitRewrite(value) {
-    if (!value || typeof value !== "object")
+const queuePath = (root) => join(root, ".hunch", "pending-commit-repairs.json");
+const droppedPath = (root) => join(root, ".hunch", "dropped-commit-repairs.json");
+const nonEmpty = (v) => typeof v === "string" && v.length > 0;
+/**
+ * Shape-only validation: non-empty string id/from/to, and `to !== from` (a no-op
+ * is rejected). There is deliberately no hex check -- a bad `to` is caught later
+ * by the apply-time existence check, so this loader stays shape-only.
+ */
+function isRewrite(v) {
+    if (typeof v !== "object" || v === null)
         return false;
-    const { id, from, to } = value;
-    // Non-empty, and to !== from — an empty target is never a useful rewrite,
-    // and a no-op entry would apply "successfully" while accomplishing nothing.
-    // Deliberately NOT a hex-shape check: from/to are opaque strings elsewhere
-    // in this codebase's test fixtures, and repairDecisionCommit's own
-    // `d.commit === mine.from` guard already makes a garbage `from` inert (it
-    // can never match a real decision). A garbage `to` is caught elsewhere,
-    // not here: `hunch repair-provenance --apply` runs commitsExist against
-    // every `to` it's actually about to act on (the whole queue, or just the
-    // one entry `--only <id>` targets) before repairDecisionCommit ever sees
-    // it, and leaves a non-resolving entry queued rather than applying it
-    // (withheldForUnresolvableTo, src/core/commitrepair.ts) — with the caveat
-    // that commitsExist itself fails OPEN if the check can't run at all (not a
-    // git repo, git missing, timeout), same as drift.ts's own use of it. This
-    // filter stays shape-only on purpose — the existence check needs a
-    // repository to run against, which this read-only queue loader doesn't
-    // have.
-    return typeof id === "string" && !!id
-        && typeof from === "string" && !!from
-        && typeof to === "string" && !!to
-        && to !== from;
+    const r = v;
+    return nonEmpty(r.id) && nonEmpty(r.from) && nonEmpty(r.to) && r.to !== r.from;
 }
-function isDroppedRewrite(value) {
-    if (!value || typeof value !== "object")
+function isDropped(v) {
+    if (typeof v !== "object" || v === null)
         return false;
-    const { id, from, to } = value;
-    return typeof id === "string" && !!id
-        && typeof from === "string" && !!from
-        && typeof to === "string" && !!to;
+    const r = v;
+    return nonEmpty(r.id) && nonEmpty(r.from) && nonEmpty(r.to);
 }
-/** Tolerant read: a missing or corrupt queue file is treated as empty — this
- *  is local scratch state, never a source of truth worth failing loudly over. */
-export function readPendingRepairs(root) {
-    const path = queuePath(root);
-    if (!existsSync(path))
+function readList(file, guard) {
+    if (!existsSync(file))
         return [];
     try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return Array.isArray(parsed) ? parsed.filter(isCommitRewrite) : [];
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return Array.isArray(parsed) ? parsed.filter(guard) : [];
     }
     catch {
         return [];
     }
 }
+/** The raw queue. Missing, corrupt or non-array files read as `[]`; never throws. */
+export function readPendingRepairs(root) {
+    return readList(queuePath(root), isRewrite);
+}
+/** Atomically replace the queue. Writing `[]` clears it. */
 export function writePendingRepairs(root, rewrites) {
     writeFileAtomic(queuePath(root), JSON.stringify(rewrites, null, 2) + "\n");
 }
-/** Tolerant read, same discipline as readPendingRepairs. */
+/** The tombstones of rewrites rejected with `--drop`. Same tolerance as the queue. */
 export function readDroppedRepairs(root) {
-    const path = droppedPath(root);
-    if (!existsSync(path))
-        return [];
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return Array.isArray(parsed) ? parsed.filter(isDroppedRewrite) : [];
-    }
-    catch {
-        return [];
-    }
+    return readList(droppedPath(root), isDropped);
 }
+/** Atomically replace the tombstone file. Writing `[]` clears it. */
 export function writeDroppedRepairs(root, dropped) {
     writeFileAtomic(droppedPath(root), JSON.stringify(dropped, null, 2) + "\n");
 }
-/** The queue as every READ-ONLY consumer should see it: raw entries minus
- *  anything a human already rejected via `--drop`, regardless of how a
- *  tombstoned entry ended up back in the raw queue file (e.g. the post-merge
- *  hook's backgrounded detection racing a `--drop`). A read-time filter, not
- *  a mutation — the raw queue file is untouched.
- *
- *  `repair-provenance`'s own action is the one exception: it needs the RAW
- *  read (via readPendingRepairs) because it diffs raw-vs-swept to report what
- *  it cleaned up, and it persists the sweep back to disk. Every other
- *  reader — `hunch escalations`, SessionStart orientation, the `hunch_now`
- *  and `hunch_escalations` MCP tools — must call this instead, or a
- *  tombstoned entry that hasn't yet been swept by a `repair-provenance` run
- *  re-surfaces as if the human never answered it. */
+/**
+ * The raw queue minus anything tombstoned. Read-only: it never changes either
+ * file. Every read-only consumer uses this -- `hunch escalations`, SessionStart
+ * orientation, and the `hunch_now` and `hunch_escalations` MCP tools. Only
+ * `repair-provenance` itself reads the raw queue.
+ */
 export function readActivePendingRepairs(root) {
     return withoutDropped(readPendingRepairs(root), readDroppedRepairs(root));
 }
-/** The `queued` entries whose proposed `to` doesn't resolve to a real commit
- *  in this repository — the same withheldForUnresolvableTo gate
- *  `repair-provenance --apply` itself runs before writing, surfaced here so
- *  a READ-ONLY consumer (hunch escalations, hunch_now/hunch_escalations,
- *  SessionStart orientation) can tell a permanently-stuck entry apart from
- *  one `--apply` can still resolve, instead of advertising a
- *  `--apply --only <id>` that's guaranteed to no-op forever. `null` from
- *  commitsExist (the check itself failed to run) is treated as fail-open —
- *  same discipline as the apply path — so nothing is misreported as
- *  withheld just because the check couldn't run.
- *
- *  Returns the OBJECTS, not their ids, and every caller must pass the exact
- *  same `queued` array into both this function and whatever it hands the
- *  result to (commitRepairEscalations) — an id-keyed set would collapse a
- *  corrupted queue's two same-id entries (one resolvable, one not) into one
- *  unit, exactly the identity confusion withheldForUnresolvableTo's own
- *  docstring warns about. */
+/**
+ * The queued entries whose proposed `to` does not resolve in this repository.
+ * Fails open (nothing withheld) when git cannot answer. The set holds the
+ * caller's own objects, so callers must pass the same `queued` array here and to
+ * whatever consumes the result.
+ */
 export function withheldRewrites(root, queued) {
     const existing = commitsExist(queued.map((r) => r.to), root);
     return new Set(withheldForUnresolvableTo(queued, existing).withheld);

package/dist/core/types.d.ts

@@ -111,12 +111,12 @@ export type Resource = z.infer<typeof ResourceSchema>;
 export declare const EdgeType: z.ZodEnum<{
     depends_on: "depends_on";
     calls: "calls";
+    references: "references";
     imports: "imports";
     contains: "contains";
     implements: "implements";
     supersedes: "supersedes";
     related_to: "related_to";
-    references: "references";
     provides: "provides";
     belongs_to: "belongs_to";
     implemented_by: "implemented_by";
@@ -173,12 +173,12 @@ export declare const EdgeSchema: z.ZodObject<{
     type: z.ZodEnum<{
         depends_on: "depends_on";
         calls: "calls";
+        references: "references";
         imports: "imports";
         contains: "contains";
         implements: "implements";
         supersedes: "supersedes";
         related_to: "related_to";
-        references: "references";
         provides: "provides";
         belongs_to: "belongs_to";
         implemented_by: "implemented_by";
@@ -783,12 +783,12 @@ export declare const SCHEMAS: {
         type: z.ZodEnum<{
             depends_on: "depends_on";
             calls: "calls";
+            references: "references";
             imports: "imports";
             contains: "contains";
             implements: "implements";
             supersedes: "supersedes";
             related_to: "related_to";
-            references: "references";
             provides: "provides";
             belongs_to: "belongs_to";
             implemented_by: "implemented_by";

package/dist/core/types.js

@@ -147,12 +147,12 @@ export const ResourceSchema = z.object({
 export const EdgeType = z.enum([
     "depends_on",
     "calls",
+    "references",
     "imports",
     "contains",
     "implements",
     "supersedes",
     "related_to",
-    "references",
     "provides",
     "belongs_to",
     "implemented_by",

package/dist/extractors/diff.d.ts

@@ -29,10 +29,10 @@ export interface DiffAnalysis {
     removedDeps: string[];
     addedLines: number;
     removedLines: number;
-    /** Added line bodies (the "+" content, marker stripped) per file — every file,
-     *  not just substantive ones. The text veto's symbol/pattern tiers match against
-     *  — call sites, not just declarations, which addedSymbols can't see. Keyed by
-     *  the same (new-path) key as perFile. */
+    /** Added line bodies (content after the `+`) per file, for EVERY file, not only
+     *  substantive ones. The text veto's symbol/pattern tiers match call sites, which
+     *  `addedSymbols` cannot see. Keyed by the same new-side path as the per-file
+     *  declarations map. */
     addedLinesByFile: Map<string, string[]>;
 }
 /** Undo git's C-style path quoting. Even with core.quotePath=false, git quotes a

package/dist/extractors/diff.js

@@ -20,25 +20,21 @@ const DECL_PATTERNS = [
     { kind: "type", re: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*[=<]/ },
     { kind: "const", re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/ },
     { kind: "const", re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?function/ },
+    // No Python class pattern: the generic class pattern above already matches a
+    // Python class header, and the first match wins.
     { kind: "function", re: /^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/ },
-    // No Python-specific class pattern needed: the generic TS `class` pattern above has no
-    // trailing-syntax requirement (no `{`/`:`), so it already matches Python's
-    // `class Foo(Bar):` header too, and — since declOf() returns on the first match —
-    // always wins for Python class lines before any Python-specific pattern would run.
 ];
 import { languageFor, isSubstantive } from "./languages.js";
 const IMPORT_RE = /^\s*import\s+(?:[^'"]*from\s+)?['"]([^'"]+)['"]/;
 const CONT_IMPORT_RE = /^\s*\}?\s*from\s+['"]([^'"]+)['"]/; // multi-line: "} from 'x'"
 const REQUIRE_RE = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/;
 const PHP_REQUIRE_RE = /\b(?:require|require_once|include|include_once)\s*(?:\(\s*)?['"]([^'"]+)['"]/;
-// "import os" / "import a.b.c" / "import os as o" / "import os, sys" / trailing "# comment".
-// Anchored to the END of the line (optional "as alias", comma-separated modules, comment)
-// so it matches a COMPLETE Python import statement only — this deliberately rejects
-// TypeScript's `import Foo = Bar.Baz;` (import-equals), which would otherwise falsely
-// look like a Python "import Foo" prefix match.
-const PY_IMPORT_RE = /^\s*import\s+([A-Za-z_][\w.]*)(?:\s+as\s+\w+)?(?:\s*,\s*[A-Za-z_][\w.]*(?:\s+as\s+\w+)?)*\s*(?:#.*)?$/;
-const PY_FROM_IMPORT_RE = /^\s*from\s+([.\w]+)\s+import\s+/; // "from os import path" / "from . import x"
-const isCode = (p) => !!p && languageFor(p) !== null;
+// A COMPLETE Python import statement: comma-separated dotted modules, each with an
+// optional alias, an optional trailing comment, and nothing else. The anchoring is
+// what rejects TypeScript's `import Foo = Bar.Baz;`.
+const PY_IMPORT_RE = /^\s*import\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)(?:\s+as\s+\w+)?(?:\s*,\s*[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s+as\s+\w+)?)*\s*(?:#.*)?$/;
+const PY_FROM_RE = /^\s*from\s+(\.*[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*|\.+)\s+import\b/;
+const isCode = (p) => p.length > 0 && languageFor(p) !== null;
 function declOf(line) {
     for (const { kind, re } of DECL_PATTERNS) {
         const m = re.exec(line);
@@ -52,7 +48,7 @@ function importOf(line) {
         CONT_IMPORT_RE.exec(line) ??
         REQUIRE_RE.exec(line) ??
         PHP_REQUIRE_RE.exec(line) ??
-        PY_FROM_IMPORT_RE.exec(line) ??
+        PY_FROM_RE.exec(line) ??
         PY_IMPORT_RE.exec(line);
     return m ? m[1] : null;
 }
@@ -280,15 +276,15 @@ export function analyzeDiff(diff) {
         // ---- inside a hunk: content lines ----
         if (raw.startsWith("+")) {
             const body = raw.slice(1);
-            // Raw added lines are captured for EVERY file, before the substantive gate:
+            // Raw added lines are captured for every file, before the substantive gate:
             // content-matched constraints and Veto tripwires are not code-only rules
             // (a blocking invariant legitimately scopes .github/workflows/**, *.sql,
             // Dockerfile). Skipping them here left `scopedAdded` empty, which
             // buildCheckReport reads as "cannot prove a violation ⇒ complies" — so the
             // pre-edit hook denied the edit while `hunch check --strict` passed the
-            // very commit that landed it. The churn counters below now also include
-            // prose (isSubstantive, issue #12); symbol/import extraction stays
-            // code-only (isCode/languageFor) since declarations are a code concept.
+            // same diff. Churn counters below now include prose (isSubstantive, issue
+            // #12), while symbol/import extraction stays code-only (isCode): a
+            // declaration is a code concept.
             let lines = addedLinesBy.get(curFile);
             if (!lines) {
                 lines = [];
@@ -301,12 +297,12 @@ export function analyzeDiff(diff) {
             if (!curAdded && !curDeleted)
                 filesModified.add(curFile);
             if (isCode(curFile)) {
-                const d = declOf(body);
-                if (d)
-                    declsFor(curFile)?.added.set(d.name, d);
-                const imp = importOf(body);
-                if (imp && !imp.startsWith("."))
-                    addedImports.add(imp);
+                const decl = declOf(body);
+                if (decl)
+                    declsFor(curFile).added.set(decl.name, decl);
+                const spec = importOf(body);
+                if (spec && !spec.startsWith("."))
+                    addedImports.add(spec);
             }
         }
         else if (raw.startsWith("-")) {
@@ -317,12 +313,12 @@ export function analyzeDiff(diff) {
                 filesModified.add(curFile);
             if (isCode(curFile)) {
                 const body = raw.slice(1);
-                const d = declOf(body);
-                if (d)
-                    declsFor(curFile)?.removed.set(d.name, d);
-                const imp = importOf(body);
-                if (imp && !imp.startsWith("."))
-                    removedImports.add(imp);
+                const decl = declOf(body);
+                if (decl)
+                    declsFor(curFile).removed.set(decl.name, decl);
+                const spec = importOf(body);
+                if (spec && !spec.startsWith("."))
+                    removedImports.add(spec);
             }
         }
     }

package/dist/extractors/git.d.ts

@@ -307,32 +307,17 @@ export interface CommitCandidate {
     sha: string;
     files: string[];
 }
-/** Every commit newly reachable in `oldRef..newRef` (capped to the most
- *  recent `maxCount`), with the files each one changed (rename-aware, via
- *  commitChanges). Used to find the commit a squash-merge produced from a
- *  set of now-orphaned source-branch commits. */
+/** Commits in `oldRef..newRef` (most recent `maxCount`, oldest first), each with the
+ *  non-deleted paths it touched. Squash-merge provenance repair reads this. A git
+ *  failure yields []. */
 export declare function mergeRangeChanges(oldRef: string, newRef: string, cwd: string, maxCount?: number): CommitCandidate[];
-/** Batched existence check for many commit shas at once — one `git cat-file
- *  --batch-check` process instead of one `rev-parse --verify` per sha. Used
- *  by drift.ts's default commitResolvable so hunch drift/heal/doctor spawn a
- *  single git process regardless of how many decisions carry a commit, not
- *  one per decision. Returns the subset of `shas` that resolve to a real
- *  commit object, or `null` if the check itself failed to run (not a git
- *  repo, git missing, timeout) — distinct from an empty set, which means
- *  "checked, and none of them resolve." A caller that collapsed those two
- *  would flag every commit as unresolvable on a transient environment error
- *  instead of failing open. */
+/** Which of `shas` resolve to a commit, via one `git cat-file --batch-check`.
+ *  Malformed values are dropped before the stdin lines are built (positional mapping).
+ *  Returns null when git itself could not run: callers fail open. */
 export declare function commitsExist(shas: readonly string[], cwd: string): Set<string> | null;
 export type CommitRepairStatus = "orphaned" | "current" | "unresolvable" | "unknown";
-/** Classifies `commit` relative to `ref` for squash-merge repair eligibility.
- *  "orphaned" (exists in this repo, but is not an ancestor of `ref`) is the
- *  ONLY status planCommitRepair should ever act on. "unresolvable" (the
- *  commit doesn't exist here at all) is explicitly out of repair scope —
- *  drift.ts's commit-unresolvable kind is what flags that case, because
- *  there's no reliable signal left to match a replacement against. "unknown"
- *  (the git command itself failed to run — timeout, git missing) must never
- *  be treated as repair-eligible; collapsing "false" and "error" into one
- *  boolean is exactly the bug this type exists to prevent. */
+/** Whether `commit` is reachable from `ref`. Never collapses "no" and "error": only
+ *  "orphaned" is repair-eligible. A missing or non-directory cwd is "unresolvable". */
 export declare function commitRepairStatus(commit: string, ref: string, cwd: string): CommitRepairStatus;
 /** commitRepairStatus against several tips: "orphaned" only when NO ref
  *  reaches the commit. A historical `--range old..new` must not make a commit