@davesheffer/hunch 1.32.4 → 1.32.7

package/README.md

@@ -61,7 +61,7 @@ hunch integrations check --harness codex --require context,edit-blocking
 
 Capabilities are reported as **verified**, **advisory-only**, **unsupported** or **untested**. `--require` fails unless every named capability is verified. `mcp` is verified by a fresh-server probe; hook capabilities become verified only from lifecycle events actually delivered to Hunch's hook on the expected version within the last 30 days (machine-local evidence, the same trust level as the served ledger), so a repository whose agent has actually run shows it, and one that only has configuration does not.
 
-Codex CLI 0.153+ gets a native lifecycle adapter (`.codex/hooks.json`: session orientation, prompt task IDs from `turn_id`, `apply_patch` pre-edit grounding and strict denial, Stop cards); project-layer hooks load only for a trusted project and must be trusted once in Codex with `/hooks`. The opt-in `--probe` verifies a fresh MCP process, not whether an existing host session or model actually followed the memory.
+Codex CLI 0.153+ gets a native lifecycle adapter (`.codex/hooks.json`: session orientation, prompt task IDs from `turn_id`, `apply_patch` pre-edit grounding and strict denial, native `Bash`/`PowerShell` post-tool observation, Stop cards); project-layer hooks load only for a trusted project and must be trusted once in Codex with `/hooks`. Failure capture is certified only by an explicit failed-tool lifecycle event; a successful `PostToolUse` observation does not prove it. The opt-in `--probe` verifies a fresh MCP process, not whether an existing host session or model actually followed the memory.
 
 Use `hunch integrations check` in CI to prevent pin drift; add `--require` for capabilities your workflow cannot operate without.
 
@@ -288,4 +288,4 @@ See the [changelog](CHANGELOG.md) for release detail and the [roadmap](ROADMAP.m
 - [Architecture benchmark](bench/architectural-conformance.md)
 - [Contributing](CONTRIBUTING.md)
 
-Apache-2.0
+Apache-2.0

package/dist/cli/index.js

@@ -4470,7 +4470,7 @@ program
         const root = findRoot();
         // The host delivered this event: runtime evidence for `hunch integrations check`,
         // recorded before any policy decision so firmness never hides delivery itself.
-        recordHookObservation(root, provider, evt.hook_event_name);
+        recordHookObservation(root, provider, evt.hook_event_name, evt.tool_outcome?.status);
         const paths = hunchPaths(root);
         const firmness = readConfig(paths).firmness;
         if (firmness === "off")

package/dist/constitution/behaviorEvaluator.js

@@ -130,7 +130,7 @@ export function evaluateExecutableBehaviorPolicy(root, policy, opts = {}) {
         // longer match the commit's dependency inputs. Name each with its recovery;
         // both stay `error`, never a coerced pass.
         if (!existsSync(join(root, ".hunch-cache", "behavior-deps"))) {
-            return evaluation(policy, commit, { ...baseExecution, commit, error_code: "dependency-snapshot-cache-absent" }, "error", "no dependency snapshot cache exists on this machine (.hunch-cache/behavior-deps); executable behavior is unevaluated here, not failed — provision the policy's snapshots (hunch constitution bootstrap --behavior-deps <candidate>) or evaluate where they were built");
+            return evaluation(policy, commit, { ...baseExecution, commit, error_code: "dependency-snapshot-cache-absent" }, "error", "no dependency snapshot cache exists on this machine (.hunch-cache/behavior-deps); executable behavior is unevaluated here, not failed — provision the policy's snapshots (hunch constitution g2 --behavior-deps <candidate> --behavior-review-hash <hash>) or evaluate where they were built");
         }
         return evaluation(policy, commit, { ...baseExecution, commit, error_code: "dependency-snapshot-unavailable" }, "error", `no unique exact dependency snapshot matches this commit's package.json/package-lock.json among the policy's pinned ids (${assertion.dependency_snapshot_ids.join(", ")}); dependency inputs changed since compilation — re-plan and re-prove the policy (rb_g2_stale_policy_01)`);
     }

package/dist/constitution/repository.d.ts

@@ -9,6 +9,7 @@ export declare class PolicyRepository {
     private readonly privateHome?;
     constructor(root: string, store: HunchStore);
     private dir;
+    private ensureDir;
     private policiesIn;
     private proofsIn;
     private evidenceIn;

package/dist/constitution/repository.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { writeFileAtomic, writeFileAtomicIfAbsent } from "../core/io.js";
+import { readStoreArtifact, storeArtifactPath } from "../core/storeArtifact.js";
 import { shortHash } from "../core/ids.js";
 import { canonicalHash, policySemanticHash, proofPlanContentHash } from "./canonical.js";
 import { proofCorpusContentHash } from "./corpus.js";
@@ -9,13 +10,40 @@ import { assertCompositionBinding, compositionDescendants, policyProofHash } fro
 import { currentShadowDispositions, policyEvaluationContentHash, shadowDispositionContentHash, shadowDispositionJudgmentHash, shadowEvaluationContentHash, shadowEvaluationIdentityHash, } from "./shadow.js";
 import { HistoryDispositionSchema, ProofCorpusSchema, PolicyProofSchema, ProofPlanSchema, PolicySpecSchema, ShadowRecordSchema, EvidenceEventSchema, } from "./schema.js";
 const encode = (value) => JSON.stringify(value, null, 2) + "\n";
+const MAX_POLICY_ARTIFACT_BYTES = 8 * 1024 * 1024;
+function assertPolicyArtifactSize(data) {
+    if (Buffer.byteLength(data, "utf8") > MAX_POLICY_ARTIFACT_BYTES) {
+        throw new Error(`policy artifact exceeds the ${MAX_POLICY_ARTIFACT_BYTES}-byte limit`);
+    }
+}
+function artifactFile(dir, name) {
+    return storeArtifactPath(dir, name);
+}
+function writeArtifact(dir, name, data) {
+    assertPolicyArtifactSize(data);
+    const file = artifactFile(dir, name);
+    writeFileAtomic(file, data);
+    artifactFile(dir, name);
+}
+function writeArtifactIfAbsent(dir, name, data) {
+    assertPolicyArtifactSize(data);
+    const file = artifactFile(dir, name);
+    const created = writeFileAtomicIfAbsent(file, data);
+    if (created)
+        artifactFile(dir, name);
+    return created;
+}
 function loadRecords(dir, parse, label) {
-    if (!existsSync(dir))
+    const safeDir = storeArtifactPath(dirname(dir), basename(dir));
+    if (!existsSync(safeDir))
         return [];
     const out = [];
-    for (const name of readdirSync(dir).filter((n) => n.endsWith(".json")).sort()) {
+    for (const name of readdirSync(safeDir).filter((n) => n.endsWith(".json")).sort()) {
         try {
-            out.push(parse(JSON.parse(readFileSync(join(dir, name), "utf8"))));
+            const raw = readStoreArtifact(safeDir, [name], MAX_POLICY_ARTIFACT_BYTES);
+            if (raw === null)
+                throw new Error("record disappeared while it was being read");
+            out.push(parse(JSON.parse(raw)));
         }
         catch (e) {
             // A policy store can control CI. Skipping a corrupt record would turn an
@@ -41,7 +69,12 @@ export class PolicyRepository {
         const base = home === "private" ? this.privateHome : this.publicHome;
         if (!base)
             throw new Error("No private Hunch overlay is configured; refusing to write a private policy.");
-        return join(base, kind);
+        return storeArtifactPath(base, kind);
+    }
+    ensureDir(home, kind) {
+        const dir = this.dir(home, kind);
+        mkdirSync(dir, { recursive: true });
+        return storeArtifactPath(dirname(dir), basename(dir));
     }
     policiesIn(home) {
         if (home === "private" && !this.privateHome)
@@ -200,9 +233,9 @@ export class PolicyRepository {
         return dispositions.sort((left, right) => left.id.localeCompare(right.id));
     }
     homeOfPolicy(id) {
-        if (this.privateHome && existsSync(join(this.dir("private", "policies"), `${id}.json`)))
+        if (this.privateHome && existsSync(artifactFile(this.dir("private", "policies"), `${id}.json`)))
             return "private";
-        if (existsSync(join(this.dir("public", "policies"), `${id}.json`)))
+        if (existsSync(artifactFile(this.dir("public", "policies"), `${id}.json`)))
             return "public";
         return undefined;
     }
@@ -213,9 +246,8 @@ export class PolicyRepository {
             throw new Error(`refusing to write ${parsed.data_class} policy ${parsed.id} into its existing public home; migrate it to the private overlay first`);
         }
         const home = opts.private ? "private" : existing ?? (parsed.data_class !== "public" || this.store.unified ? "private" : "public");
-        const dir = this.dir(home, "policies");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "policies");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     /** Publish a new policy lifecycle record without overwriting a concurrent
@@ -238,9 +270,8 @@ export class PolicyRepository {
             return { policy: existing, created: false };
         if (otherHome)
             throw new Error(`policy ${parsed.id} already exists in the ${home === "public" ? "private" : "public"} home`);
-        const dir = this.dir(home, "policies");
-        mkdirSync(dir, { recursive: true });
-        if (writeFileAtomicIfAbsent(join(dir, `${parsed.id}.json`), encode(parsed))) {
+        const dir = this.ensureDir(home, "policies");
+        if (writeArtifactIfAbsent(dir, `${parsed.id}.json`, encode(parsed))) {
             const racedOtherHome = this.getPolicy(parsed.id, home === "public" ? { privateOnly: true } : { publicOnly: true });
             if (racedOtherHome)
                 throw new Error(`policy ${parsed.id} was published concurrently in both public and private homes`);
@@ -277,9 +308,8 @@ export class PolicyRepository {
                 assertCompositionBinding(policy, composition, plan.composition);
             }
         }
-        const dir = this.dir(home, "proofs");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "proofs");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     /** Publish an immutable proof without replacing a concurrent writer. */
@@ -315,9 +345,8 @@ export class PolicyRepository {
                 throw new Error(`proof ${parsed.id} already exists with different immutable content`);
             return { proof: existing, created: false };
         }
-        const dir = this.dir(home, "proofs");
-        mkdirSync(dir, { recursive: true });
-        if (writeFileAtomicIfAbsent(join(dir, `${parsed.id}.json`), encode(parsed)))
+        const dir = this.ensureDir(home, "proofs");
+        if (writeArtifactIfAbsent(dir, `${parsed.id}.json`, encode(parsed)))
             return { proof: parsed, created: true };
         const winner = this.getProof(parsed.id, homeOpts);
         if (!winner)
@@ -346,9 +375,8 @@ export class PolicyRepository {
             if (parsed.policy_candidate_hash !== policyProofHash(policy, composition))
                 throw new Error(`composite plan ${parsed.id} policy hash mismatch`);
         }
-        const dir = this.dir(home, "plans");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "plans");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     /** Publish an immutable proof plan without replacing a concurrent writer. */
@@ -378,9 +406,8 @@ export class PolicyRepository {
                 throw new Error(`proof plan ${parsed.id} already exists with different immutable content`);
             return { plan: existing, created: false };
         }
-        const dir = this.dir(home, "plans");
-        mkdirSync(dir, { recursive: true });
-        if (writeFileAtomicIfAbsent(join(dir, `${parsed.id}.json`), encode(parsed)))
+        const dir = this.ensureDir(home, "plans");
+        if (writeArtifactIfAbsent(dir, `${parsed.id}.json`, encode(parsed)))
             return { plan: parsed, created: true };
         const winner = this.getPlan(parsed.id, homeOpts);
         if (!winner)
@@ -400,9 +427,8 @@ export class PolicyRepository {
         if (!policy || parsed.data_class !== policy.data_class || parsed.policy_hash !== policySemanticHash(policy)) {
             throw new Error(`corpus ${parsed.id} does not match policy ${policyId} semantics/data class`);
         }
-        const dir = this.dir(home, "corpora");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${policyId}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "corpora");
+        writeArtifact(dir, `${policyId}.json`, encode(parsed));
         return parsed;
     }
     putEvidence(event, opts = {}) {
@@ -413,9 +439,8 @@ export class PolicyRepository {
         if (home === "public" && parsed.data_class !== "public") {
             throw new Error(`refusing to write ${parsed.data_class} evidence ${parsed.id} into the public home`);
         }
-        const dir = this.dir(home, "evidence");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "evidence");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     putDisposition(disposition, policyId) {
@@ -451,9 +476,8 @@ export class PolicyRepository {
         if (!current && parsed.supersedes)
             throw new Error(`history disposition ${parsed.id} supersedes no current disposition for this proof hit`);
         currentHistoryDispositions([...records, parsed]);
-        const dir = this.dir(home, "dispositions");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "dispositions");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     putShadowEvaluation(evaluation, policyId) {
@@ -483,9 +507,8 @@ export class PolicyRepository {
         const existing = this.listShadowEvaluations(homeOpts).find((record) => shadowEvaluationIdentityHash(record) === shadowEvaluationIdentityHash(parsed));
         if (existing)
             return existing;
-        const dir = this.dir(home, "shadow");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "shadow");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
     putShadowDisposition(disposition, policyId) {
@@ -521,9 +544,8 @@ export class PolicyRepository {
         if (!current && parsed.supersedes)
             throw new Error(`shadow disposition ${parsed.id} supersedes no current disposition for this evaluation`);
         currentShadowDispositions([...records, parsed]);
-        const dir = this.dir(home, "shadow");
-        mkdirSync(dir, { recursive: true });
-        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        const dir = this.ensureDir(home, "shadow");
+        writeArtifact(dir, `${parsed.id}.json`, encode(parsed));
         return parsed;
     }
 }
@@ -653,14 +675,18 @@ export function movePolicyArtifactsToPrivate(publicHunchDir, privateHunchDir) {
         }
     }
     for (const { kind, from, to, pub, priv, keyFor } of staged) {
+        storeArtifactPath(dirname(from), basename(from));
         if (!pub.length && !existsSync(from))
             continue;
+        storeArtifactPath(dirname(to), basename(to));
         mkdirSync(to, { recursive: true });
+        storeArtifactPath(dirname(to), basename(to));
         for (const rec of pub) {
             const key = keyFor(rec);
             if (!priv.has(key))
-                writeFileAtomic(join(to, `${key}.json`), encode(rec));
+                writeArtifact(to, `${key}.json`, encode(rec));
         }
+        storeArtifactPath(dirname(from), basename(from));
         rmSync(from, { recursive: true, force: true });
         counts[kind] = pub.length;
     }

package/dist/core/agenthook.js

@@ -60,11 +60,15 @@ function applyPatchInput(raw) {
     const file = PATCH_FILE.exec(patch)?.[1];
     return file ? { file_path: file, content: patch } : undefined;
 }
-function normalizeToolInput(value) {
+function normalizeToolInput(value, allowPatch = false) {
     const raw = obj(value);
     if (!raw)
         return undefined;
-    const patched = applyPatchInput(raw);
+    // Only Codex's apply_patch tool carries patch text in a generic `input`,
+    // `patch`, or `content` field. A normal Write can contain documentation or
+    // examples with these markers; interpreting those as a patch would retarget
+    // policy to the first file named in the prose.
+    const patched = allowPatch ? applyPatchInput(raw) : undefined;
     if (patched)
         return patched;
     const replacementChunks = Array.isArray(raw.ReplacementChunks) ? raw.ReplacementChunks : raw.replacementChunks;
@@ -103,6 +107,38 @@ function toolOutput(value) {
         return "";
     }
 }
+function explicitToolOutcome(response) {
+    const raw = obj(response);
+    if (!raw)
+        return typeof response === "string" && response.trim() ? "success" : "unknown";
+    if (raw.success === false || raw.is_error === true || raw.isError === true || (raw.error !== undefined && raw.error !== null))
+        return "failure";
+    const status = raw.status;
+    if (typeof status === "string") {
+        if (/^(?:failure|failed|error|errored)$/i.test(status.trim()))
+            return "failure";
+    }
+    let explicitSuccess = raw.success === true || raw.is_error === false || raw.isError === false;
+    for (const key of ["exit_code", "exitCode", "return_code", "returnCode"]) {
+        const value = raw[key];
+        const numeric = typeof value === "number" ? value : typeof value === "string" && /^-?\d+$/.test(value.trim()) ? Number(value) : undefined;
+        if (numeric === undefined || !Number.isFinite(numeric))
+            continue;
+        if (numeric !== 0)
+            return "failure";
+        explicitSuccess = true;
+    }
+    if (typeof status === "string" && /^(?:success|succeeded|ok|completed)$/i.test(status.trim()))
+        explicitSuccess = true;
+    if (explicitSuccess)
+        return "success";
+    // Common successful tool-result shapes carry output fields even when the
+    // output is empty. An unstructured empty string (Codex's native failure
+    // payload) remains unknown until the host supplies an explicit status.
+    if (["stdout", "stderr", "output", "content"].some(key => Object.prototype.hasOwnProperty.call(raw, key)))
+        return "success";
+    return "unknown";
+}
 function normalizeToolOutcome(input, event) {
     if (event !== "PostToolUse" && event !== "PostToolUseFailure")
         return undefined;
@@ -110,11 +146,7 @@ function normalizeToolOutcome(input, event) {
     return {
         // Claude Code splits successful and failed calls into separate lifecycle
         // events. Providers without that split may expose an explicit result flag.
-        status: event === "PostToolUseFailure"
-            ? "failure"
-            : obj(response)?.success === false || obj(response)?.is_error === true || obj(response)?.isError === true
-                ? "failure"
-                : "success",
+        status: event === "PostToolUseFailure" ? "failure" : explicitToolOutcome(response),
         output: event === "PostToolUseFailure"
             ? toolOutput(input.error ?? response)
             : toolOutput(response),
@@ -205,7 +237,8 @@ export function normalizeHookEvent(raw, provider) {
     const event = eventName(input.hook_event_name ?? input.hookEventName ?? input.event, provider);
     if (!event)
         return null;
-    const toolInput = normalizeToolInput(input.tool_input ?? input.toolInput);
+    const rawToolName = stringAt(input, "tool_name", "toolName");
+    const toolInput = normalizeToolInput(input.tool_input ?? input.toolInput, provider === "codex" && /^(?:apply_patch|patch)$/i.test(rawToolName ?? ""));
     const toolOutcome = normalizeToolOutcome(input, event);
     return {
         hook_event_name: event,
@@ -214,7 +247,7 @@ export function normalizeHookEvent(raw, provider) {
         // says `prompt_id`; both are native per-prompt identities, never synthesized.
         ...(provider === "codex" && input.prompt_id === undefined && input.turn_id !== undefined ? { prompt_id: typeof input.turn_id === "string" ? input.turn_id : "" } : {}),
         ...(provider === "claude" || provider === "codex" ? Object.fromEntries(["prompt_id", "cwd", "agent_id"].filter(key => input[key] !== undefined).map(key => [key, typeof input[key] === "string" ? input[key] : ""])) : {}),
-        tool_name: hunchToolName(stringAt(input, "tool_name", "toolName"), toolInput ?? {}),
+        tool_name: hunchToolName(rawToolName, toolInput ?? {}),
         tool_input: toolInput,
         ...(toolOutcome ? { tool_outcome: toolOutcome } : {}),
         prompt: stringAt(input, "prompt", "user_prompt", "userPrompt"),

package/dist/core/checkreport.js

@@ -200,7 +200,7 @@ export function renderMarkdown(r) {
             r.regBlocking ? `${r.regBlocking} blocking-linked regression(s)` : "",
             r.vetoBlocking ? `${r.vetoBlocking} reversed-decision veto(es)` : "",
         ].filter(Boolean).join(" + ");
-        out.push(`❌ **This PR breaks ${reasons}.** Resolve or supersede the decision before merge.`);
+        out.push(`❌ **Merge requires review: ${reasons}.** Check the cited evidence and verify that the recorded requirements still hold before merging.`);
     }
     else if (r.strict) {
         out.push(`ℹ️ Nothing here is a direct, high-confidence, non-stale blocking invariant — **not blocking** this PR.`);

package/dist/core/events.js

@@ -16,8 +16,9 @@
  *  assert — those are conformance-only predicates checked by a different gate
  *  (`hunch conform`), not the edit hook. This schema records only what each gate
  *  actually knows; it never fabricates the conformance shape for a plain block. */
-import { appendFileSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, constants, fstatSync, lstatSync, openSync } from "node:fs";
 import { join } from "node:path";
+import { readStoreArtifact, storeArtifactPath } from "./storeArtifact.js";
 export function eventsLogPath(paths) {
     return join(paths.hunch, "events.log");
 }
@@ -25,19 +26,34 @@ export function eventsLogPath(paths) {
  *  call site is the edit hook, which MUST NEVER break an agent on failure
  *  (con_03a0b94b2e). A dropped catch-log line is an acceptable loss. */
 export function appendEvent(paths, event) {
+    let fd;
     try {
-        appendFileSync(eventsLogPath(paths), `${JSON.stringify(event)}\n`);
+        const file = storeArtifactPath(paths.hunch, "events.log");
+        fd = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW);
+        const opened = fstatSync(fd);
+        const current = lstatSync(storeArtifactPath(paths.hunch, "events.log"));
+        if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== current.dev || opened.ino !== current.ino)
+            return;
+        appendFileSync(fd, `${JSON.stringify(event)}\n`);
     }
     catch {
         /* best effort — a lost audit line must never surface to the agent */
     }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* logging remains best effort on close failure too */ }
+        }
+    }
 }
 /** Read + parse the catch-log. Malformed lines are skipped, not fatal (the log is
  *  derived; one bad line never poisons the aggregation). Missing log → []. */
 export function readEvents(paths) {
     let raw;
     try {
-        raw = readFileSync(eventsLogPath(paths), "utf8");
+        raw = readStoreArtifact(paths.hunch, ["events.log"]) ?? "";
     }
     catch {
         return []; // no catches recorded yet

package/dist/core/hookObservations.d.ts

@@ -1,9 +1,12 @@
+export type HookOutcomeEvidence = "success" | "failure" | "unknown";
 export interface HookObservation {
     provider: string;
     event: string;
     at: string;
     version: string;
+    /** Present for observations recorded after outcome tracking was added. */
+    outcome?: HookOutcomeEvidence | null;
 }
 /** Never throws (con_03a0b94b2e): a missing ledger costs evidence, not the edit. */
-export declare function recordHookObservation(root: string, provider: string, event: string): void;
+export declare function recordHookObservation(root: string, provider: string, event: string, outcome?: HookOutcomeEvidence): void;
 export declare function readHookObservations(root: string): HookObservation[];

package/dist/core/hookObservations.js

@@ -9,15 +9,28 @@ import { HUNCH_VERSION } from "./version.js";
 function ensureTable(db) {
     db.exec(`CREATE TABLE IF NOT EXISTS hook_observations (
     provider TEXT NOT NULL, event TEXT NOT NULL, at TEXT NOT NULL, version TEXT NOT NULL,
+    outcome TEXT,
     PRIMARY KEY (provider, event)
   )`);
+    // Existing machine ledgers predate outcome tracking. Their rows remain
+    // intentionally unknown until a later hook delivery supplies a result.
+    const columns = db.prepare("PRAGMA table_info(hook_observations)").all();
+    if (!columns.some(column => column.name === "outcome"))
+        db.exec("ALTER TABLE hook_observations ADD COLUMN outcome TEXT");
 }
 /** Never throws (con_03a0b94b2e): a missing ledger costs evidence, not the edit. */
-export function recordHookObservation(root, provider, event) {
+export function recordHookObservation(root, provider, event, outcome) {
     try {
         withServedDatabase(root, db => {
             ensureTable(db);
-            db.prepare("INSERT OR REPLACE INTO hook_observations VALUES (?, ?, ?, ?)").run(provider, event, new Date().toISOString(), HUNCH_VERSION);
+            const evidence = outcome === "failure" || outcome === "success" ? outcome : null;
+            const at = new Date().toISOString();
+            db.prepare(`INSERT INTO hook_observations (provider, event, at, version, outcome)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(provider, event) DO UPDATE SET
+          at = CASE WHEN excluded.outcome = 'failure' OR hook_observations.outcome IS NULL OR hook_observations.outcome != 'failure' THEN excluded.at ELSE hook_observations.at END,
+          version = CASE WHEN excluded.outcome = 'failure' OR hook_observations.outcome IS NULL OR hook_observations.outcome != 'failure' THEN excluded.version ELSE hook_observations.version END,
+          outcome = CASE WHEN excluded.outcome = 'failure' OR hook_observations.outcome = 'failure' THEN 'failure' ELSE excluded.outcome END`).run(provider, event, at, HUNCH_VERSION, evidence);
         });
     }
     catch { /* evidence is optional; the hook response is not */ }
@@ -27,7 +40,7 @@ export function readHookObservations(root) {
         return [];
     return withServedDatabase(root, db => {
         ensureTable(db);
-        return db.prepare("SELECT provider, event, at, version FROM hook_observations ORDER BY at DESC").all();
+        return db.prepare("SELECT provider, event, at, version, outcome FROM hook_observations ORDER BY at DESC").all();
     });
 }
 //# sourceMappingURL=hookObservations.js.map

package/dist/core/io.js

@@ -1,5 +1,5 @@
 /** Durable file writes for the Hunch. */
-import { closeSync, fsyncSync, linkSync, openSync, renameSync, rmSync, writeSync } from "node:fs";
+import { closeSync, fchmodSync, fsyncSync, linkSync, lstatSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 let counter = 0;
 const renameRetryDelaysMs = [10, 20, 40, 80];
@@ -24,20 +24,17 @@ const renameRetryWaiter = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_
  */
 export function writeFileAtomic(file, data) {
     const tmp = `${file}.tmp${process.pid}.${counter++}`;
+    let mode;
     try {
-        const fd = openSync(tmp, "w");
-        try {
-            writeSync(fd, data);
-            fsyncSync(fd); // data blocks reach disk before the rename's metadata can
-        }
-        finally {
-            closeSync(fd);
-        }
+        const existing = lstatSync(file);
+        if (existing.isFile())
+            mode = existing.mode & 0o777;
     }
-    catch (e) {
-        cleanupTmp(tmp);
-        throw e;
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
     }
+    writeFileAtomicTmp(tmp, data, mode);
     try {
         renameWithContentionRetry(tmp, file);
     }
@@ -85,8 +82,10 @@ function isRenameContention(error) {
  * semantics, so concurrent lifecycle writers can never be overwritten. */
 export function writeFileAtomicIfAbsent(file, data) {
     const tmp = `${file}.tmp${process.pid}.${counter++}`;
+    // An occupied temp path is an error, not evidence that the target exists.
+    // Only enter the publication/cleanup block once we own the temporary file.
+    writeFileAtomicTmp(tmp, data);
     try {
-        writeFileAtomicTmp(tmp, data);
         linkSync(tmp, file);
         return true;
     }
@@ -104,14 +103,26 @@ export function writeFileAtomicIfAbsent(file, data) {
     }
 }
 /** Write + fsync a fresh temp file (shared by both atomic writers). */
-function writeFileAtomicTmp(tmp, data) {
-    const fd = openSync(tmp, "w");
+function writeFileAtomicTmp(tmp, data, mode) {
+    // Exclusive creation rejects stale files and links without truncating their
+    // contents. If open fails, the path belongs to somebody else: never unlink it.
+    const fd = openSync(tmp, "wx", mode ?? 0o666);
     try {
-        writeSync(fd, data);
-        fsyncSync(fd);
+        try {
+            writeFileSync(fd, data);
+            // The replacement inode must retain an existing file's permissions,
+            // including private config files that contain credentials.
+            if (mode !== undefined)
+                fchmodSync(fd, mode);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
     }
-    finally {
-        closeSync(fd);
+    catch (error) {
+        cleanupTmp(tmp);
+        throw error;
     }
 }
 /** Remove a temp file, riding out a transient external hold (AV/indexer) with one

package/dist/core/jsonc.js

@@ -24,7 +24,7 @@ export function parseJsonc(raw) {
             continue;
         }
         if (char === "/" && next === "/") {
-            while (index < raw.length && raw[index] !== "\n")
+            while (index < raw.length && raw[index] !== "\n" && raw[index] !== "\r")
                 index += 1;
             withoutComments += "\n";
             continue;
@@ -33,7 +33,12 @@ export function parseJsonc(raw) {
             index += 2;
             while (index < raw.length && !(raw[index] === "*" && raw[index + 1] === "/"))
                 index += 1;
+            if (index >= raw.length)
+                throw new SyntaxError("unterminated JSONC block comment");
             index += 1;
+            // A comment separates tokens. Removing it outright would silently turn
+            // invalid input such as 1/* comment */2 into the valid number 12.
+            withoutComments += " ";
             continue;
         }
         withoutComments += char;
@@ -62,8 +67,13 @@ export function parseJsonc(raw) {
             let cursor = index + 1;
             while (cursor < withoutComments.length && /\s/.test(withoutComments[cursor]))
                 cursor += 1;
-            if (withoutComments[cursor] === "}" || withoutComments[cursor] === "]")
-                continue;
+            if (withoutComments[cursor] === "}" || withoutComments[cursor] === "]") {
+                const previous = normalized.trimEnd().at(-1);
+                // A trailing comma must follow a value, never an empty collection or
+                // another comma. Keep malformed input intact for JSON.parse to reject.
+                if (previous && !"[{,:".includes(previous))
+                    continue;
+            }
         }
         normalized += char;
     }

package/dist/core/storeArtifact.d.ts

@@ -0,0 +1,7 @@
+/** Containment for store artifacts outside JsonStore's entity registry (ledgers,
+ * policy proofs, and local audit logs). The explicitly selected store's parent
+ * may have a platform alias, but no component inside that store may be a link. */
+export declare function storeArtifactPath(hunchDir: string, ...parts: string[]): string;
+/** A missing artifact is distinct from an unsafe/unreadable artifact. Reuse the
+ * scanner's bounded descriptor read; policy and ledger corruption must fail visibly. */
+export declare function readStoreArtifact(hunchDir: string, parts: string[], maxBytes?: number): string | null;