@davesheffer/hunch 1.45.1 → 1.45.2

package/dist/cli/index.js

@@ -27,7 +27,7 @@ import { HUNCH_VERSION } from "../core/version.js";
 import { registerIntegrationCommands } from "./integrations.js";
 import { registerTaskReportCommands } from "./taskReport.js";
 import { registerStateCommands } from "./state.js";
-import { registerServeCommands } from "./serve.js";
+import { DEFAULT_CONFIG as SERVE_DEFAULT_CONFIG_FILE, registerServeCommands } from "./serve.js";
 import { registerUpdateCommand } from "./update.js";
 import { registerReviewMemoryCommands } from "./reviewMemory.js";
 import { detectInitiator, normalizeInitiator } from "../synthesis/initiator.js";
@@ -43,7 +43,7 @@ import { isParserLoadError, loadNativeTreeSitter } from "../extractors/nativeTre
 import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesize.js";
 import { parseTestReport } from "../extractors/testreport.js";
 import { readSynthesisPreference, resolveSynthesisProvider, selectProvider, SYNTH_PREFERENCES, writeSynthesisPreference, normalizeProviderName, } from "../synthesis/provider.js";
-import { isGitRepo, isGitRepoRoot, sameGitPublication, sameRemoteUrl, canonicalRemoteUrl, repositoryUsesRemote, headSha, isolatedHeadSha, logSince, lastChangeDate, checkFreshnessRevision, teamPullIsFresh, firstCommitForFile, stagedFiles, workingFiles, commitFiles, asOfDate, stagedGateDiff, workingGateDiff, commitGateDiff, rangeFiles, rangeGateDiff, rangeCommits, revExists, revParse, commitAndPushHunch, pullHunchStatus, syncExistingHunch, gitUntrackCached, gitCommonDir, checkoutCommonDir, separateGitDirCandidate, separateGitDirLink, hooksDir, isLinkedWorktree, mainWorktreeRoot, gitMemoryLog, memoryMoveDiff, revertMemoryMove, pushCurrentBranch, commitChanges, commitRepairStatusAgainst, commitPatchIds, mergeRangeChanges, commitsExist } from "../extractors/git.js";
+import { isGitRepo, isGitRepoRoot, sameGitPublication, sameRemoteUrl, canonicalRemoteUrl, repositoryUsesRemote, headSha, isolatedHeadSha, logSince, lastChangeDate, checkFreshnessRevision, teamPullIsFresh, firstCommitForFile, stagedFiles, workingFiles, commitFiles, asOfDate, stagedGateDiff, workingGateDiff, commitGateDiff, rangeFiles, rangeGateDiff, rangeCommits, revExists, revParse, commitAndPushHunch, pullHunchStatus, pullHunchStatusDetailed, describePullFailure, syncExistingHunch, gitUntrackCached, gitCommonDir, checkoutCommonDir, separateGitDirCandidate, separateGitDirLink, hooksDir, isLinkedWorktree, mainWorktreeRoot, gitMemoryLog, memoryMoveDiff, revertMemoryMove, pushCurrentBranch, commitChanges, commitRepairStatusAgainst, commitPatchIds, mergeRangeChanges, commitsExist } from "../extractors/git.js";
 import { runbookDraft } from "../core/runbookDraft.js";
 import { parseMemoryLog } from "../core/memorylog.js";
 import { renamesOf, planRepair, repairDecision, repairConstraint } from "../core/repair.js";
@@ -62,7 +62,7 @@ import { flushCapture, flushMemoryHome, flushMemoryHomes, pinSharedRemote, share
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS, upgradeManagedGitignore, describeGitignoreUpgrade, memoryIgnoreRule, describeMemoryIgnoreRule } from "../integrations/gitignore.js";
 import { writeCiWorkflow } from "../integrations/ciAction.js";
-import { applyUninstall, formatUninstallPlan, isOptedOut, OPT_OUT_FILE, optOutMessage, planUninstall } from "../integrations/uninstall.js";
+import { applyUninstall, formatUninstallPlan, isOptedOut, OPT_OUT_FILE, optedOutAt, optOutMessage, planUninstall } from "../integrations/uninstall.js";
 import { updateClaudeMd, renderHunchSection } from "../integrations/claudemd.js";
 import { HOOK_REMINDER } from "../core/hookText.js";
 import { measureFootprint } from "../core/footprint.js";
@@ -102,7 +102,7 @@ import { renderRecalledLine } from "../core/taskReportRender.js";
 import { closeHookTask, hookReportTaskId, isNotificationPrompt, nativeHookCwd, settleHookSession, startHookReport, stopHookReport, observeHookDenial } from "../core/taskReportHook.js";
 import { persistTaskRecord } from "../core/taskRecord.js";
 import { recordHookObservation } from "../core/hookObservations.js";
-import { contextHookOutput, deliversPromptEvent, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
+import { contextHookOutput, deliversCommandOutcome, deliversPromptEvent, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
 import { PIPELINE_LOOP, armExecutionObligations, beforeEditProbeVerdict, compileExecutableProbes, environmentExecutableProbes, environmentExecutionObligations, executionObligationBrief, isProductPath, loadPipelineState, onCommand, onEdit, onPrompt, onSkill, pipelineEnabled, proofCheckpoint, savePipelineState, stopVerdict, onLessonsDelivered, lessonReminder, unverifiedNag, } from "../core/pipeline.js";
 import { draftDuplicateOf, isAcceptedDuplicateAnchor } from "../core/dupdetect.js";
 import { planAutoReview, planMutations } from "../core/autoreview.js";
@@ -147,6 +147,7 @@ import { partitionOf, stateHomeFor } from "../store/stateBinding.js";
 import { scopePath } from "../core/stateContract.js";
 import { movePublicMemoryToPrivate } from "../store/privateMigrate.js";
 import { ENTITY_KINDS } from "../core/types.js";
+import { formatWhyRecord } from "../core/whyRecord.js";
 import { planCompaction } from "../store/compact.js";
 import { repairDecisionReference } from "../core/refrepair.js";
 import { resolveInvocation, dim, synthesisStatusLines, maybeWarnOllamaContext } from "./invocation.js";
@@ -234,7 +235,20 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
     const name = top.name();
     if (OPT_OUT_ALLOWED.has(name))
         return;
-    if (!isOptedOut(findRoot()))
+    // Gate the repository the command acts on (#458): a `--root` names it (`hunch mcp
+    // --root`, `hunch serve ... --root`), so its real path is gated with every ancestor
+    // up to its store or repository and the cwd's repository is irrelevant; without
+    // one, the command acts on the cwd's repository. `serve init` also writes its
+    // config file (resolved against the cwd), so the directory it lands in gates it too.
+    const rootOpt = actionCommand.opts().root;
+    const rootGiven = typeof rootOpt === "string" && rootOpt.trim() !== "";
+    let gated = rootGiven ? optedOutAt(realpathNorm(resolve(rootOpt))) : isOptedOut(findRoot());
+    if (!gated && name === "serve" && actionCommand.name() === "init") {
+        const configOpt = top.opts().config ?? actionCommand.opts().config;
+        const configFile = resolve(typeof configOpt === "string" ? configOpt : SERVE_DEFAULT_CONFIG_FILE);
+        gated = optedOutAt(realpathNorm(dirname(configFile)));
+    }
+    if (!gated)
         return;
     if (name !== "hook")
         console.error(optOutMessage());
@@ -301,6 +315,7 @@ function openTeamStore(root, opts = {}) {
     // from their durable local overlay when the network is temporarily down, but a
     // strict guard must prove it saw the advertised remote before it may pass.
     let pullStatus = null;
+    let pullDetail;
     if (teamAdvertised && store.mode === "shared" && store.privateDir) {
         const remote = advertisedTeamRemoteContract(root, dirname(store.privateDir));
         if (!remote || !remote.verify()) {
@@ -309,10 +324,9 @@ function openTeamStore(root, opts = {}) {
             throw new Error("the advertised team memory route could not be pinned for this command");
         }
         pinSharedRemote(store, remote);
-        pullStatus = pullHunchStatus(store.privateDir, {
-            timeoutMs: 5_000,
+        ({ status: pullStatus, detail: pullDetail } = pullHunchStatusDetailed(store.privateDir, {
             remote,
-        });
+        }));
         // The route may be coherently rewritten while the bounded pull is blocked.
         // No handler — including an ordinary non-strict read — may run after the
         // graph epoch that admitted this command stops verifying.
@@ -322,12 +336,12 @@ function openTeamStore(root, opts = {}) {
             throw new Error("the advertised team memory route changed while this command was refreshing; refusing to serve or mutate stale memory");
         }
     }
-    return { store, teamWired, teamPullStatus: opts.requireFreshTeamMemory ? pullStatus : null };
+    return { store, teamWired, teamPullStatus: opts.requireFreshTeamMemory ? pullStatus : null, teamPullDetail: opts.requireFreshTeamMemory ? pullDetail : undefined };
 }
 function storeFor(opts = {}) {
     const root = findRoot();
-    const { store, teamPullStatus } = openTeamStore(root, opts);
-    return { store, root, teamPullStatus };
+    const { store, teamPullStatus, teamPullDetail } = openTeamStore(root, opts);
+    return { store, root, teamPullStatus, teamPullDetail };
 }
 function pumpMemoryHome(store, root, home, message) {
     flushMemoryHome(store, hunchPaths(root).hunch, home, message);
@@ -1054,7 +1068,6 @@ function configureExistingValidatedOverlay(destRoot, codeRoot, requestedRemote,
     }
     else {
         const pulled = pullHunchStatus(hunchDir, {
-            timeoutMs: 5_000,
             remote: contract,
             allowUnrelatedHistories: true,
         });
@@ -3783,7 +3796,7 @@ program
 program
     .command("why")
     .description("Explain why a file/symbol is the way it is (decisions, bugs, constraints).")
-    .argument("<target>", "file path or symbol name")
+    .argument("<target>", "file path, symbol name, or record id (dec_/con_/bug_/fnd_/cmp_)")
     .option("--as-of <ref>", "time-travel: what was believed as of a commit/tag/branch (e.g. v0.7.0, HEAD~5)")
     .action((target, opts) => {
     const { store, root } = storeFor();
@@ -3791,6 +3804,13 @@ program
     if (opts.asOf && !asOf)
         return fail(`could not resolve --as-of "${opts.asOf}" to a commit (need a git repo and a valid ref)`);
     const w = store.why(target, { asOf });
+    if (w.byId?.record) {
+        if (asOf)
+            console.log(`Why "${target}" (as of ${opts.asOf} — ${asOf.slice(0, 10)}):\n`);
+        console.log(formatWhyRecord(w.byId).join("\n"));
+        store.close();
+        return;
+    }
     const staleIds = new Set(store.staleness((f) => lastChangeDate(f, root)).map((s) => s.id));
     const drift = (id) => (staleIds.has(id) ? " ⚠STALE" : "");
     console.log(asOf ? `Why "${target}" (as of ${opts.asOf} — ${asOf.slice(0, 10)}):\n` : `Why "${target}":\n`);
@@ -3810,7 +3830,7 @@ program
             console.log(`  • ${b.id} [${b.status}] ${b.title} — ${b.root_cause}`);
     }
     if (!w.decisions.length && !w.constraints.length && !w.bugs.length) {
-        console.log("(No recorded decisions/bugs/constraints yet. Try `hunch backfill` or make a commit.)");
+        console.log(w.byId ? formatWhyRecord(w.byId).join("\n") : "(No recorded decisions/bugs/constraints yet. Try `hunch backfill` or make a commit.)");
     }
     if (w.symbols.length)
         console.log(`\nSYMBOLS: ${w.symbols.map((s) => `${s.name} [fan-in ${s.metrics.fan_in}, churn ${s.metrics.churn_90d}]`).join(", ")}`);
@@ -4233,9 +4253,10 @@ program
     // interleaved section prints are suppressed for this format.
     const sarif = opts.format === "sarif";
     const emptyReport = { fileCount: 0, strict: !!opts.strict, direct: [], near: [], regressions: [], vetoes: [], redundant: [], strictBlockers: 0, regBlocking: 0, vetoBlocking: 0 };
-    const { store, root, teamPullStatus } = storeFor({ requireFreshTeamMemory: !!opts.strict && !opts.publicOnly });
+    const { store, root, teamPullStatus, teamPullDetail } = storeFor({ requireFreshTeamMemory: !!opts.strict && !opts.publicOnly });
     const teamFreshnessFailure = teamPullStatus !== null && !teamPullIsFresh(teamPullStatus)
         ? `strict check could not refresh the advertised team memory (${teamPullStatus}); refusing a stale pass` +
+            (teamPullDetail ? ` (${describePullFailure(teamPullDetail)})` : "") +
             (teamPullStatus === "unconfigured" ? " — the shared memory remote has no published branch while this clone has memory; publish it with `hunch shared --sync`" : "")
         : null;
     // An empty team remote is in sync with a never-committed clone, but it is also what
@@ -5466,7 +5487,11 @@ program
         // before implementation. Firm/strict may deny two edits per prompt, then
         // fail open so a malformed or unavailable probe can never deadlock work.
         if ((firmness === "firm" || firmness === "strict") && evt.session_id && pipelineEnabled() && targets.some((t) => isProductPath(t.target))) {
-            const baseline = beforeEditProbeVerdict(loadPipelineState(evt.session_id));
+            const baseline = beforeEditProbeVerdict(loadPipelineState(evt.session_id), { commandOutcomes: deliversCommandOutcome(provider) });
+            // Unverifiable on this host: the edit proceeds and the hook says why on
+            // stderr (stdout stays free for the grounding/deny response below).
+            if (baseline.unverifiable && baseline.reason)
+                process.stderr.write(`${baseline.reason}\n`);
             if (baseline.block) {
                 savePipelineState(evt.session_id, baseline.state);
                 emitDeny(provider, baseline.reason ?? "Hunch evidence gate — establish the pre-edit probe baseline first.");

package/dist/cli/serve.d.ts

@@ -13,4 +13,6 @@ export declare function compactPartition(root: string, scope: {
     floor_seq: number;
     head_seq: number;
 }>;
+/** The serve config file used when no --config is given, resolved against the cwd. */
+export declare const DEFAULT_CONFIG = "hunch-serve.json";
 export declare function registerServeCommands(program: Command): void;

package/dist/cli/serve.js

@@ -32,8 +32,9 @@ export async function compactPartition(root, scope, keep, lockOptions = {}) {
         store.close();
     }
 }
+/** The serve config file used when no --config is given, resolved against the cwd. */
+export const DEFAULT_CONFIG = "hunch-serve.json";
 export function registerServeCommands(program) {
-    const DEFAULT_CONFIG = "hunch-serve.json";
     const serve = program.command("serve")
         .description("Serve nuryel.state/1 over HTTP for organization / team / user / repository partitions (binds 127.0.0.1; put it behind SSH or a reverse proxy)")
         .option("--config <file>", `serve config (nuryel.serve-config/1); default ${DEFAULT_CONFIG}`)

package/dist/core/agenthook.d.ts

@@ -8,6 +8,7 @@
 export declare const HOOK_PROVIDERS: readonly ["claude", "codex", "vscode", "windsurf", "antigravity", "cursor"];
 export type HookProvider = (typeof HOOK_PROVIDERS)[number];
 export declare function deliversPromptEvent(provider: HookProvider): boolean;
+export declare function deliversCommandOutcome(provider: HookProvider): boolean;
 export type HunchHookEvent = "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "UserPromptSubmit" | "SessionStart" | "SubagentStart" | "PreCompact" | "Stop";
 /** One file section of a Codex `apply_patch` payload. */
 export interface HunchPatchFile {

package/dist/core/agenthook.js

@@ -17,6 +17,18 @@ const PROMPT_EVENT = {
 export function deliversPromptEvent(provider) {
     return PROMPT_EVENT[provider];
 }
+/** Whether a provider's post-command hook carries the command's result (exit
+ * status or an explicit success/failure). Windsurf's post_run_command sends only
+ * the command line and cwd; Antigravity's installed hooks (PreInvocation,
+ * PreToolUse on edit tools, Stop) include no post-tool event at all. Evidence
+ * gates keyed on a command's result can never be satisfied there and must stay
+ * advisory. A Record, so a new provider must declare its answer. */
+const COMMAND_OUTCOME = {
+    claude: true, codex: true, vscode: true, windsurf: false, cursor: true, antigravity: false,
+};
+export function deliversCommandOutcome(provider) {
+    return COMMAND_OUTCOME[provider];
+}
 function obj(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -235,12 +247,11 @@ function eventName(value, provider) {
             return "PostToolUse";
     }
     if (provider === "windsurf") {
-        if (name === "pre_write_code" || name === "pre_run_command")
-            return "PreToolUse";
-        if (name === "post_write_code" || name === "post_run_command")
-            return "PostToolUse";
         if (name === "pre_user_prompt")
             return "UserPromptSubmit";
+        const action = /^(pre|post)_(write_code|run_command|read_code|mcp_tool_use)$/.exec(name);
+        if (action)
+            return action[1] === "pre" ? "PreToolUse" : "PostToolUse";
     }
     // Antigravity's PreInvocation is the lifecycle point which can inject a
     // transient message before the model sees the turn. Internally it provides
@@ -256,6 +267,45 @@ export function hookProvider(value) {
         ? value.toLowerCase()
         : null;
 }
+/** Windsurf Cascade (docs.windsurf.com/windsurf/cascade/hooks) names the event in
+ * top-level `agent_action_name` (`pre_write_code`, `post_run_command`, …) and
+ * carries per-event data in `tool_info`. The tool is implied by the event. Payloads
+ * written before #484 (`event` + `agent_action_name: "write_code"`) still parse. */
+function normalizeWindsurfEvent(input) {
+    const action = stringAt(input, "agent_action_name")?.toLowerCase();
+    const legacy = typeof input.event === "string" ? input.event : typeof input.hook_event_name === "string" ? input.hook_event_name : undefined;
+    const name = eventName(action, "windsurf") ? action : legacy?.toLowerCase();
+    const event = eventName(name, "windsurf");
+    if (!name || !event)
+        return null;
+    const info = obj(input.tool_info) ?? obj(input.toolInput) ?? obj(input.tool_input) ?? {};
+    const kind = name.replace(/^(?:pre|post)_/, "");
+    const base = {
+        hook_event_name: event,
+        session_id: stringAt(input, "trajectory_id", "session_id", "sessionId"),
+    };
+    if (event === "UserPromptSubmit") {
+        return { ...base, prompt: stringAt(info, "user_prompt", "prompt") ?? stringAt(input, "prompt", "user_prompt", "userPrompt") };
+    }
+    const toolOutcome = normalizeToolOutcome(input, event);
+    const outcome = toolOutcome ? { tool_outcome: toolOutcome } : {};
+    if (kind === "run_command") {
+        const command = stringAt(info, "command_line", "command", "commandLine");
+        const cwd = stringAt(info, "cwd");
+        return { ...base, ...(cwd ? { cwd } : {}), tool_name: "Bash", tool_input: command ? { command } : undefined, ...outcome };
+    }
+    // Reads and MCP calls are observed only: their arguments never reach the
+    // pre-edit gate, which treats any file_path as an edit target.
+    if (kind === "read_code")
+        return { ...base, tool_name: "Read", ...outcome };
+    if (kind === "mcp_tool_use") {
+        const server = stringAt(info, "mcp_server_name", "server_name", "server");
+        const tool = stringAt(info, "mcp_tool_name", "tool_name", "tool");
+        return { ...base, tool_name: server && tool ? `mcp__${server}__${tool}` : tool ?? "mcp", ...outcome };
+    }
+    const toolInput = normalizeToolInput(info);
+    return { ...base, tool_name: kind === "write_code" ? "Edit" : hunchToolName(stringAt(input, "tool_name", "toolName"), toolInput ?? {}), tool_input: toolInput, ...outcome };
+}
 /** Normalize a hook stdin payload. Unknown/malformed events return null and the
  * CLI exits successfully without output — the Never Block on Hook Failure rule. */
 export function normalizeHookEvent(raw, provider) {
@@ -276,22 +326,8 @@ export function normalizeHookEvent(raw, provider) {
             tool_input: toolInput,
         };
     }
-    if (provider === "windsurf") {
-        const event = eventName(input.event ?? input.hook_event_name, provider);
-        if (!event)
-            return null;
-        const info = obj(input.tool_info) ?? obj(input.toolInput) ?? obj(input.tool_input);
-        const toolInput = normalizeToolInput(info);
-        const toolOutcome = normalizeToolOutcome(input, event);
-        return {
-            hook_event_name: event,
-            session_id: stringAt(input, "trajectory_id", "session_id", "sessionId"),
-            tool_name: hunchToolName(stringAt(input, "agent_action_name", "tool_name", "toolName"), toolInput ?? {}),
-            tool_input: toolInput,
-            ...(toolOutcome ? { tool_outcome: toolOutcome } : {}),
-            prompt: stringAt(input, "prompt", "user_prompt", "userPrompt"),
-        };
-    }
+    if (provider === "windsurf")
+        return normalizeWindsurfEvent(input);
     const event = eventName(input.hook_event_name ?? input.hookEventName ?? input.event, provider);
     if (!event)
         return null;

package/dist/core/delivery.d.ts

@@ -124,6 +124,11 @@ export declare const SEVERITY: {
 export declare const PROFILE_BASE_SCORE: Record<DeliveryProfile, Record<DeliveryKind, number>>;
 export declare const TASK_STOP_WORDS: Set<string>;
 export declare function lexicalTokens(value: string): Set<string>;
+/** Test hook: forget memoized commit verdicts. */
+export declare function resetCommitReachabilityMemo(): void;
+/** Test hook: number of git spawns issued by delivery provenance probes so far. */
+export declare function commitReachabilityProbeCount(): number;
+export declare function localCommitReachability(root: string): (commit: string) => CommitReachability;
 /** Validate the public receipt without trusting a caller-supplied identity. */
 export declare function assertDeliveryEnvelope(envelope: DeliveryEnvelope): void;
 /** The string a hash-based injection dedup (`injectionMode`'s `hashInput`) must

package/dist/core/delivery.js

@@ -311,7 +311,9 @@ function componentResolves(id, target, options) {
     const component = (options.components ?? []).find((candidate) => candidate.id === id && candidate.status === "active");
     return !!component && component.paths.some((path) => anchorResolves(path, target, options));
 }
+let gitProbeCount = 0;
 function gitProbe(root, args) {
+    gitProbeCount++;
     const result = spawnSync("git", ["-C", root, ...args], {
         encoding: "utf8",
         env: { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" },
@@ -336,30 +338,70 @@ function defaultBranchRef(root) {
     }
     return null;
 }
-function localCommitReachability(root) {
+// Process-wide memo (#473): every delivery build used to re-probe git for the
+// same capture commits. Verdicts are keyed by the default branch's TIP sha, so a
+// long-lived process stays correct after new commits land. Only ancestry
+// answers (merge-base exit 0/1) are cached; a missing object or a transient
+// spawn failure is re-probed on the next call.
+const REACHABILITY_MEMO_CAP = 10_000;
+const reachabilityMemo = new Map();
+/** Test hook: forget memoized commit verdicts. */
+export function resetCommitReachabilityMemo() {
+    reachabilityMemo.clear();
+}
+/** Test hook: number of git spawns issued by delivery provenance probes so far. */
+export function commitReachabilityProbeCount() {
+    return gitProbeCount;
+}
+function memoizeReachability(key, verdict) {
+    if (reachabilityMemo.size >= REACHABILITY_MEMO_CAP)
+        reachabilityMemo.clear();
+    reachabilityMemo.set(key, verdict);
+    return verdict;
+}
+export function localCommitReachability(root) {
     let initialized = false;
     let branch = null;
+    let tip = null;
     return (commit) => {
         if (!initialized) {
+            // The default ref is looked up every build (origin/HEAD can be retargeted
+            // while the old ref still exists); only verdicts are shared across builds.
             branch = defaultBranchRef(root);
+            if (branch) {
+                // One spawn: the tip sha plus whether the repo is shallow. A shallow
+                // boundary can make a present commit look unreachable until a deepen,
+                // so a shallow build never memoizes. Unexpected output disables the memo.
+                const resolved = gitProbe(root, ["rev-parse", "--is-shallow-repository", "--verify", "--quiet", `${branch}^{commit}`]);
+                const [shallow, sha, ...rest] = resolved.stdout.split(/\r?\n/);
+                if (resolved.available && resolved.status === 0 && !rest.length && shallow === "false" && sha && /^[0-9a-f]{40,64}$/i.test(sha)) {
+                    tip = sha;
+                }
+            }
             initialized = true;
         }
         if (!branch)
             return "unknown";
         if (!/^[0-9a-f]{7,64}$/i.test(commit))
             return "unreachable";
+        const key = tip ? `${root}\0${tip}\0${commit}` : null;
+        const memo = key ? reachabilityMemo.get(key) : undefined;
+        if (memo)
+            return memo;
+        const remember = (verdict) => key ? memoizeReachability(key, verdict) : verdict;
         const exact = gitProbe(root, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
         if (!exact.available)
             return "unknown";
+        // A missing object is not memoized: a later fetch/deepen can bring it in under the same tip.
         if (exact.status !== 0)
             return "unreachable";
-        const ancestry = gitProbe(root, ["merge-base", "--is-ancestor", exact.stdout, branch]);
+        const ancestry = gitProbe(root, ["merge-base", "--is-ancestor", exact.stdout, tip ?? branch]);
         if (!ancestry.available)
             return "unknown";
         if (ancestry.status === 0)
-            return "reachable";
+            return remember("reachable");
         if (ancestry.status === 1)
-            return "unreachable";
+            return remember("unreachable");
         return "unknown";
     };
 }

package/dist/core/pipeline.d.ts

@@ -231,11 +231,18 @@ export interface BeforeEditProbeVerdict {
     block: boolean;
     state: PipelineState;
     reason?: string;
+    /** The host cannot report command results, so the evidence is unverifiable:
+     * the gate is advisory and `reason` says why instead of denying. */
+    unverifiable?: boolean;
 }
 /** Before-edit evidence is useful only before implementation. At firm/strict,
  * deny at most two product edits per prompt until all such receipts exist;
- * then fail open so a broken probe or discriminator cannot deadlock the agent. */
-export declare function beforeEditProbeVerdict(state: PipelineState): BeforeEditProbeVerdict;
+ * then fail open so a broken probe or discriminator cannot deadlock the agent.
+ * A host whose hooks carry no command outcome (`commandOutcomes: false`) can
+ * never produce a receipt, so its gate is advisory: it never denies. */
+export declare function beforeEditProbeVerdict(state: PipelineState, opts?: {
+    commandOutcomes?: boolean;
+}): BeforeEditProbeVerdict;
 export declare function executionObligationBrief(state: PipelineState): string;
 /** Harness/orchestrator injection. Malformed input returns no obligations. */
 export declare function environmentExecutionObligations(value?: string | undefined): ExecutionObligation[];

package/dist/core/pipeline.js

@@ -704,10 +704,20 @@ export function pendingExecutionObligations(state) {
 }
 /** Before-edit evidence is useful only before implementation. At firm/strict,
  * deny at most two product edits per prompt until all such receipts exist;
- * then fail open so a broken probe or discriminator cannot deadlock the agent. */
-export function beforeEditProbeVerdict(state) {
+ * then fail open so a broken probe or discriminator cannot deadlock the agent.
+ * A host whose hooks carry no command outcome (`commandOutcomes: false`) can
+ * never produce a receipt, so its gate is advisory: it never denies. */
+export function beforeEditProbeVerdict(state, opts = {}) {
     const pending = state.obligations.filter((item) => item.phase === "before-edit" && item.status !== "satisfied");
-    if (!pending.length || state.probeBlocks >= 2)
+    if (!pending.length)
+        return { block: false, state };
+    if (opts.commandOutcomes === false) {
+        return {
+            block: false, state, unverifiable: true,
+            reason: `Hunch evidence gate is advisory here: this host's hooks do not report command results, so ${pending.length} pre-edit evidence obligation(s) cannot be verified and do not block edits. Run them anyway and check their output yourself.`,
+        };
+    }
+    if (state.probeBlocks >= 2)
         return { block: false, state };
     const instructions = pending.slice(0, 3).map((item) => {
         const command = item.probe?.command ?? firstCommand(item);

package/dist/core/procstart.d.ts

@@ -69,9 +69,9 @@ export declare const heldLockNonces: Set<string>;
  *  - `stale`    — provably not the owner's process any more: take it over.
  *  - `live`     — authoritative, however old the file looks: never steal it.
  *  - `unproven` — a live pid whose process instance no token can compare (macOS,
- *                 Windows, a legacy record). Treated as live; a caller with a
- *                 better probe may still disprove it (src/serve/writelock.ts
- *                 asks the OS when that process was created, issue #287).
+ *                 Windows, a legacy record). Treated as live unless
+ *                 `createdAfterLock` proves the pid reused (both locks ask the
+ *                 OS when that process was created, issues #287, #457).
  *  - `age`      — nothing is proven; fall back to the caller's own age rule. */
 export type SameHostVerdict = "stale" | "live" | "unproven" | "age";
 /** The parts of a lock record this decision reads. Both lock formats supply it. */
@@ -102,4 +102,18 @@ export declare function judgeSameHostOwner(owner: SameHostOwner, env: SameHostEn
  *  other platform: linux derives `lstart` from boot time, which a forward clock
  *  step shifts for live processes too (see the header). */
 export declare function processStartedAt(pid: number): number | null;
+/** How much later than the lock's recorded `at` the pid's current process must
+ *  have been created before it is proven not to be the owner. A genuine owner
+ *  started BEFORE it took the lock; the slack only absorbs clock granularity. */
+export declare const CREATED_AFTER_SLACK_MS = 5000;
+/** Is the process now holding the owner's pid provably newer than the lock?
+ *  The one rule both `src/serve/writelock.ts` and jsonStore's `.rmw-lock` apply
+ *  to an "unproven" verdict (issues #287, #457). Unreadable either way — no `at`
+ *  recorded (a legacy record), or no creation time from the OS — means not
+ *  proven, and a live pid keeps its lock. SPAWNS through `processStartedAt`, so
+ *  callers consult it only for a lock that already looks stale by age. */
+export declare function createdAfterLock(owner: {
+    pid: number;
+    at?: string;
+}, startedAt?: (pid: number) => number | null): boolean;
 export {};

package/dist/core/procstart.js

@@ -26,8 +26,9 @@
  * OFF LINUX (issue #287). Only linux exposes a spawn-free, stable process-instance
  * id (`/proc/<pid>/stat` field 22 plus the boot id and the pid/time namespaces), so
  * on macOS and Windows a DIFFERENT live process that recycled the owner's pid is
- * "unproven" here, which this table treats as live. The write lock closes that
- * forever-deadlock on its own rare path, once a lock already looks stale: it asks
+ * "unproven" here, which this table treats as live. Both locks close that
+ * forever-deadlock on their own rare path, once a lock already looks stale
+ * (`createdAfterLock`; the `.rmw-lock` since issue #457): they ask
  * the OS when the process now holding the pid was CREATED (`processStartedAt`, a
  * spawn) and compares that with the `at` the owner recorded when it took the lock.
  * A process created after the lock was taken cannot have taken it. Both instants
@@ -56,7 +57,7 @@
  * holder may judge itself against a token that no longer describes it. Tokenless
  * records (a legacy pre-token hunch, any non-linux writer, an unreadable /proc)
  * get main's unchanged pid rule — a live same-host pid keeps its lock (unless the
- * write lock's creation-time check above proves the pid reused), a dead one is
+ * creation-time check above proves the pid reused), a dead one is
  * stealable — with exactly one exception, the own-pid + foreign-nonce row
  * described in `judgeSameHostOwner`, which gets the AGE rule instead of main's
  * "live forever".
@@ -245,8 +246,9 @@ export function judgeSameHostOwner(owner, env) {
         return "age";
     // 7. A live pid no token can compare — another process's, or a nonce-less
     //    record of our own pid. Never stolen on a guess: "unproven" is "live" to a
-    //    caller that has nothing better. The write lock asks the OS for that
-    //    process's creation time, which can prove the pid was reused (issue #287).
+    //    caller that has nothing better. Both locks ask the OS for that process's
+    //    creation time (`createdAfterLock`), which can prove the pid was reused
+    //    (issues #287, #457).
     return "unproven";
 }
 /** Wall-clock ms at which the process now holding `pid` was created, from the
@@ -279,4 +281,23 @@ export function processStartedAt(pid) {
         return null;
     }
 }
+/** How much later than the lock's recorded `at` the pid's current process must
+ *  have been created before it is proven not to be the owner. A genuine owner
+ *  started BEFORE it took the lock; the slack only absorbs clock granularity. */
+export const CREATED_AFTER_SLACK_MS = 5_000;
+/** Is the process now holding the owner's pid provably newer than the lock?
+ *  The one rule both `src/serve/writelock.ts` and jsonStore's `.rmw-lock` apply
+ *  to an "unproven" verdict (issues #287, #457). Unreadable either way — no `at`
+ *  recorded (a legacy record), or no creation time from the OS — means not
+ *  proven, and a live pid keeps its lock. SPAWNS through `processStartedAt`, so
+ *  callers consult it only for a lock that already looks stale by age. */
+export function createdAfterLock(owner, startedAt = processStartedAt) {
+    if (owner.at === undefined)
+        return false;
+    const at = Date.parse(owner.at);
+    if (!Number.isFinite(at))
+        return false;
+    const started = startedAt(owner.pid);
+    return started !== null && started > at + CREATED_AFTER_SLACK_MS;
+}
 //# sourceMappingURL=procstart.js.map

package/dist/core/taskSelection.d.ts

@@ -59,6 +59,7 @@ export declare function liveSelectionRecords(all: TaskSelectionRecords): TaskSel
  *  or `:start-end` and a possessive `'s`, forward-slashed, repo-relative. A drive-letter root compares
  *  case-insensitively (Windows paths are case-insensitive on every host). */
 export declare function promptPaths(prompt: string, root?: string): string[];
+export declare function identifierTokens(text: string): Set<string>;
 /** Score live records against one prompt. Text fields per kind (title + rationale):
  *  decision title/context/decision; bug title/symptom/root_cause; constraint
  *  statement/rationale; finding title/observation. Path anchors: decision