@davesheffer/hunch 1.46.0 → 1.47.1

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/taskRecord.d.ts

@@ -35,7 +35,7 @@ export declare function computeSupersedes(record: TaskRecord, others: readonly T
 export interface PersistedTaskRecord {
     record: TaskRecord;
     home: TaskRecordHome;
-    flushed: "pushed" | "committed" | null;
+    flushed: "pushed" | "committed" | "held" | null;
     /** False when the same report revision was already in the graph. */
     changed: boolean;
 }

package/dist/core/taskRecord.js

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { flushCapture } from "../integrations/sync.js";
 import { hunchPaths } from "./paths.js";
 import { episodeTasks, isEmptyTaskReport, readTaskReport, reportHash, sessionsOverlap } from "./taskReport.js";
-import { reportSourceSnapshot } from "./taskReportEvidence.js";
+import { currentSource } from "./taskReportEvidence.js";
 import { ENTITY_KINDS, TaskRecordSchema } from "./types.js";
 import { refreshRankEval } from "./taskRankingMode.js";
 import { gitTouchedFiles } from "./taskTouched.js";
@@ -172,7 +172,7 @@ export function computeSupersedes(record, others, limit = 20) {
 export function persistTaskRecord(root, store, taskId, options = {}) {
     if (!taskRecordsEnabled(root))
         return null;
-    const snapshot = reportSourceSnapshot(root).hash;
+    const snapshot = currentSource(root);
     const own = readTaskReport(root, taskId, snapshot);
     if (own.task.state === "open")
         return null;

package/dist/core/taskReport.d.ts

@@ -30,6 +30,7 @@ export declare const ReportCheckSchema: z.ZodObject<{
     snapshot_limitations: z.ZodArray<z.ZodString>;
     timed_out: z.ZodBoolean;
     cancelled: z.ZodOptional<z.ZodBoolean>;
+    work_root: z.ZodOptional<z.ZodString>;
     source: z.ZodLiteral<"local-command-runner">;
 }, z.core.$strict>;
 export type ReportCheck = z.infer<typeof ReportCheckSchema>;
@@ -321,8 +322,8 @@ export interface TaskSummary {
 }
 /** One bounded summary per recent task for status lines and host views; the
  * card and evidence view remain the authoritative renderings. */
-export declare function summarizeTaskReport(root: string, taskId: string, currentSnapshot?: string | null): TaskSummary;
-export declare function listTaskSummaries(root: string, limit?: number, currentSnapshot?: string | null): TaskSummary[];
+export declare function summarizeTaskReport(root: string, taskId: string, currentSnapshot?: CurrentSnapshot): TaskSummary;
+export declare function listTaskSummaries(root: string, limit?: number, currentSnapshot?: CurrentSnapshot): TaskSummary[];
 /** One line for a terminal status line. Empty string when nothing was observed
  * for the task, so a bare prompt shows no Hunch noise at all. */
 export declare function renderTaskStatusLine(summary: TaskSummary | null): string;
@@ -348,5 +349,9 @@ export declare function reportActivity(root: string): string;
 export declare function forgetReportTask(root: string, taskId: string): void;
 export declare function pruneReportHistory(root: string, olderThanDays?: number): number;
 export declare function reportPresentationEnabled(root: string): boolean;
-export declare function readTaskReport(root: string, taskId: string, currentSnapshot?: string | null): TaskReport;
+/** What a reader compares evidence snapshots against: the report root's current source
+ *  hash, or a resolver that also hashes another worktree a check ran in. A plain hash
+ *  never vouches for a check that ran elsewhere. */
+export type CurrentSnapshot = string | null | ((dir?: string) => string | null);
+export declare function readTaskReport(root: string, taskId: string, currentSnapshot?: CurrentSnapshot): TaskReport;
 export {};

package/dist/core/taskReport.js

@@ -43,6 +43,9 @@ export const ReportCheckSchema = z.object({
     snapshot_limitations: z.array(z.string().max(300)).max(16),
     timed_out: z.boolean(),
     cancelled: z.boolean().optional(),
+    /** Where the command ran, recorded only when that is not this ledger's root (a
+     *  sibling worktree): its currentness is judged against that tree's source. */
+    work_root: z.string().min(1).max(4_096).optional(),
     source: z.literal("local-command-runner"),
 }).strict();
 export const ReportSaveSchema = z.object({
@@ -717,6 +720,7 @@ export function reportPresentationEnabled(root) {
     }
 }
 export function readTaskReport(root, taskId, currentSnapshot = null) {
+    const snapshotAt = (dir) => typeof currentSnapshot === "function" ? currentSnapshot(dir) : dir === undefined ? currentSnapshot : null;
     const { task, events } = taskDb(root, db => transaction(db, () => {
         const task = readTask(db, root, taskId);
         const { bytes } = db.prepare("SELECT COALESCE(SUM(length(CAST(body AS BLOB))), 0) AS bytes FROM report_events WHERE task_id = ?").get(taskId);
@@ -743,7 +747,7 @@ export function readTaskReport(root, taskId, currentSnapshot = null) {
             claims.push({ ...ReportClaimSchema.parse(value), at: event.at, attribution: "agent-reported", supported_by: null });
         else if (event.kind === "conformance") {
             const rule = ReportConformanceSchema.parse(value);
-            conformance.push({ ...rule, event_id: event.event_id, at: event.at, current: currentSnapshot !== null && rule.snapshot === currentSnapshot });
+            conformance.push({ ...rule, event_id: event.event_id, at: event.at, current: snapshotAt() !== null && rule.snapshot === snapshotAt() });
         }
         else if (event.kind === "save")
             saves.push({ ...ReportSaveSchema.parse(value), event_id: event.event_id, at: event.at, durability: "local", proofs: [] });
@@ -760,7 +764,8 @@ export function readTaskReport(root, taskId, currentSnapshot = null) {
             refusals.push({ ...ReportRefusalSchema.parse(value), event_id: event.event_id, at: event.at });
         else if (event.kind === "check") {
             const check = ReportCheckSchema.parse(value);
-            checks.push({ ...check, at: event.at, current: currentSnapshot !== null && check.before_snapshot === currentSnapshot && check.after_snapshot === currentSnapshot });
+            const now = snapshotAt(check.work_root);
+            checks.push({ ...check, at: event.at, current: now !== null && check.before_snapshot === now && check.after_snapshot === now });
         }
         else if (event.kind !== "check-start")
             throw new Error("unsupported report event kind; update Hunch before reading this report");

package/dist/core/taskReportEvidence.d.ts

@@ -9,6 +9,9 @@ export interface ReportSnapshot {
 /** Bounded source snapshot, not a committed change proof. Ignored files and
  * Hunch's own memory/cache are excluded and explicitly disclosed. */
 export declare function reportSourceSnapshot(root: string): ReportSnapshot;
+/** The current source of `root` for report readers, as a resolver that also hashes the
+ *  sibling worktree a check ran in (its `work_root`). Each tree is hashed at most once. */
+export declare function currentSource(root: string): (dir?: string) => string | null;
 /** Evaluate every delivered lesson's DECLARED rule against the files this task
  * changed (working tree vs HEAD). Deterministic and Hunch-owned: the agent
  * neither chooses the rule nor submits the verdict. A constraint is judged by its
@@ -28,4 +31,8 @@ export declare function runReportCheck(root: string, taskId: string, command: st
     signal?: AbortSignal;
     onStdout?: (chunk: Buffer) => void;
     onStderr?: (chunk: Buffer) => void;
+    /** Where the command runs and whose source is snapshotted, when the task's
+     *  ledger lives in a sibling worktree of the same repository (the hook opened
+     *  the task at the main checkout, the agent works in a linked one). */
+    workRoot?: string;
 }): Promise<ReportCheck>;

package/dist/core/taskReportEvidence.js

@@ -87,6 +87,16 @@ export function reportSourceSnapshot(root) {
         return { hash: null, limitations: [...limitations, "A complete bounded source snapshot was unavailable; no current-change verification is claimed."] };
     }
 }
+/** The current source of `root` for report readers, as a resolver that also hashes the
+ *  sibling worktree a check ran in (its `work_root`). Each tree is hashed at most once. */
+export function currentSource(root) {
+    const seen = new Map();
+    return (dir = root) => {
+        if (!seen.has(dir))
+            seen.set(dir, reportSourceSnapshot(dir).hash);
+        return seen.get(dir);
+    };
+}
 /** Evaluate every delivered lesson's DECLARED rule against the files this task
  * changed (working tree vs HEAD). Deterministic and Hunch-owned: the agent
  * neither chooses the rule nor submits the verdict. A constraint is judged by its
@@ -210,7 +220,8 @@ export async function runReportCheck(root, taskId, command, label, timeoutMs = D
     const task = readTaskReport(root, taskId).task;
     if (task.state !== "open" && task.closed_by !== "host")
         throw new Error("cannot verify a closed task");
-    const before = reportSourceSnapshot(root);
+    const workRoot = options.workRoot ?? root;
+    const before = reportSourceSnapshot(workRoot);
     // Validate sensitive arguments before executing or writing anything.
     ReportCheckSchema.parse({ label, command, exit_code: null, output_hash: reportHash(""), before_snapshot: before.hash, after_snapshot: null, snapshot_limitations: before.limitations, timed_out: false, source: "local-command-runner" });
     const checkId = beginReportCheck(root, taskId, label, timeoutMs);
@@ -228,7 +239,7 @@ export async function runReportCheck(root, taskId, command, label, timeoutMs = D
         const started = (() => {
             try {
                 const resolved = resolveSpawnCommand(command);
-                return spawn(resolved.file, resolved.args, { cwd: root, shell: false, stdio: ["ignore", "pipe", "pipe"], windowsHide: true, detached: process.platform !== "win32", windowsVerbatimArguments: resolved.windowsVerbatimArguments === true });
+                return spawn(resolved.file, resolved.args, { cwd: workRoot, shell: false, stdio: ["ignore", "pipe", "pipe"], windowsHide: true, detached: process.platform !== "win32", windowsVerbatimArguments: resolved.windowsVerbatimArguments === true });
             }
             catch (error) {
                 // An argument the launcher cannot carry, or a synchronous spawn refusal
@@ -319,9 +330,10 @@ export async function runReportCheck(root, taskId, command, label, timeoutMs = D
         if (options.signal?.aborted)
             cancel();
     });
-    const after = reportSourceSnapshot(root);
+    const after = reportSourceSnapshot(workRoot);
     const check = { check_id: checkId, label, command, exit_code: result.code, output_hash: result.hash, before_snapshot: before.hash, after_snapshot: after.hash,
-        snapshot_limitations: [...new Set([...before.limitations, ...after.limitations])], timed_out: result.timedOut, cancelled: result.cancelled, source: "local-command-runner" };
+        snapshot_limitations: [...new Set([...before.limitations, ...after.limitations])], timed_out: result.timedOut, cancelled: result.cancelled,
+        ...(workRoot !== root ? { work_root: workRoot } : {}), source: "local-command-runner" };
     recordReportCheck(root, taskId, check);
     return check;
 }

package/dist/core/taskReportHook.js

@@ -6,7 +6,7 @@ import { findRoot } from "./paths.js";
 import { canonicalReportRoot } from "./taskReportPaths.js";
 import { isCredentialFreeText } from "./types.js";
 import { aliasReportTask, continuationLinks, finishReportTask, isEmptyTaskReport, latestSessionTask, readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, reportTaskExists, resolveReportTask, settleSessionTasks, startReportTask } from "./taskReport.js";
-import { reportSourceSnapshot } from "./taskReportEvidence.js";
+import { currentSource } from "./taskReportEvidence.js";
 import { renderTaskReport } from "./taskReportRender.js";
 import { verificationLauncher } from "./verifyLauncher.js";
 import { injectionMode } from "./hookcache.js";
@@ -290,7 +290,7 @@ export function stopHookReport(root, provider, event) {
     if (id === "legacy")
         return { systemMessage: "Hunch hook active. This host version does not provide an exact prompt identifier, so contribution for this response is unverified. Explicit task reports remain available with hunch report." };
     try {
-        const report = readTaskReport(root, id, reportSourceSnapshot(root).hash);
+        const report = readTaskReport(root, id, currentSource(root));
         if (isEmptyTaskReport(report))
             return null;
         // The HTML evidence view is a rendering of the local ledger, generated on

package/dist/core/taskReportPublic.js

@@ -3,9 +3,9 @@
 import { JsonStore } from "../store/jsonStore.js";
 import { hunchPaths } from "./paths.js";
 import { readTaskReport, reportHash } from "./taskReport.js";
-import { reportSourceSnapshot } from "./taskReportEvidence.js";
+import { currentSource } from "./taskReportEvidence.js";
 export function publicTaskReport(root, taskId) {
-    const report = readTaskReport(root, taskId, reportSourceSnapshot(root).hash);
+    const report = readTaskReport(root, taskId, currentSource(root));
     const publicStore = new JsonStore(hunchPaths(root));
     const records = new Map();
     const deliveries = [];

package/dist/core/taskReportRender.js

@@ -1,11 +1,11 @@
 import { mkdirSync } from "node:fs";
 import { writeFileAtomic } from "./io.js";
 import { readTaskReport, readLessonHistory } from "./taskReport.js";
-import { reportSourceSnapshot } from "./taskReportEvidence.js";
+import { currentSource } from "./taskReportEvidence.js";
 import { assertReportPath } from "./taskReportPaths.js";
 import { publicTaskReport, renderPublicTaskReportHtml } from "./taskReportPublic.js";
 export function writeTaskReportHtml(root, taskId, publicOnly = false) {
-    const report = readTaskReport(root, taskId, reportSourceSnapshot(root).hash);
+    const report = readTaskReport(root, taskId, currentSource(root));
     const directory = assertReportPath(root, ".hunch-cache", "reports");
     mkdirSync(directory, { recursive: true });
     const file = assertReportPath(root, ".hunch-cache", "reports", `${report.task.task_id}${publicOnly ? ".public" : ""}.html`);