@davesheffer/hunch 1.32.2 → 1.32.4

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.
 
-The Codex integration currently supplies MCP and instructions, with no native lifecycle adapter. 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, 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.
 
 Use `hunch integrations check` in CI to prevent pin drift; add `--require` for capabilities your workflow cannot operate without.
 
@@ -183,7 +183,7 @@ Hunch may hold durable state **about** external work with credential-free proven
 
 The first real-world pilot is **Sofia**, a working operations agent over CRM, Gmail and WhatsApp. Sofia's approved actions, follow-ups, customer/source relationships and cited summaries map naturally to action receipts, commitments, entities/relationships and dependency-bound state.
 
-The pilot measures whether Sofia and a second, different agent stop re-deriving contradictory state when the deterministic state is delivered before they answer or act.
+The pilot measures whether Sofia and a second, different agent stop re-deriving contradictory state when the deterministic state is delivered before they answer or act. First live number (2026-09-12, one user): after one CRM read, the next status questions were answered from held state under a receipt, 0 of 3 without a source; the [roadmap](ROADMAP.md) carries the gate table.
 
 ### The state contract, shipped
 
@@ -223,7 +223,7 @@ The current release can keep a team's **repository-scoped** memory in a dedicate
 Today Hunch does not host that shared Git repository; teammates/CI use normal Git access and one maintainer connects it:
 
 ```bash
-npm i -g @davesheffer/hunch@1.28.0
+npm i -g @davesheffer/hunch@1.32.2
 hunch shared --repo git@github.com:acme/project-hunch-memory.git
 git add .gitignore .hunch/team.json
 git commit -m "chore: connect shared Hunch memory"
@@ -233,7 +233,7 @@ git push
 Teammates then install the same version and run:
 
 ```bash
-npm i -g @davesheffer/hunch@1.28.0
+npm i -g @davesheffer/hunch@1.32.2
 git pull
 hunch init
 hunch doctor
@@ -264,6 +264,8 @@ The v1.19 correction-search benchmark remains scoped evidence, but it no longer
 - **v1.21 — Project DNA.** Hunch gained deterministic, revision-specific repository profiles, bounded DNA context delivery, explainable Project Match checks and auditable profile deltas.
 - **v1.22 — authorized collaboration evidence.** Hosts can contribute bounded PR/review evidence to Project DNA through a typed, sealed contract without raw collaboration persistence or policy-authority change.
 - **v1.23 — native change proof and proof-carrying evidence work.** Exact Git change identity, graph before/after, decisions/constraints, blast radius and Change Gate result can be bound into a sealed evidence artifact without granting authority.
+- **v1.25 – v1.30 — the state layer.** `nuryel.state/1` as code, `hunch serve` partitions, union reads, subject identity by external reference, replay determinism, human corrections outranking agent writes.
+- **v1.32 — see what Hunch contributed.** Task contribution reports: what was delivered, what the agent reports it applied, what a rule verified, what a command observed; concise card, local evidence view.
 
 See the [changelog](CHANGELOG.md) for release detail and the [roadmap](ROADMAP.md) for active work.
 
@@ -277,6 +279,9 @@ See the [changelog](CHANGELOG.md) for release detail and the [roadmap](ROADMAP.m
 - [Project DNA](docs/project-dna.md)
 - [Native change proof](docs/change-proof.md)
 - [The autonomy ladder](docs/autonomy-ladder.md)
+- [Task contribution reports](docs/task-reports.md)
+- [Autonomous development](docs/autonomous-development.md)
+- [Local cookbook](docs/cookbook.md)
 - [Engineering Landscape Graph](docs/engineering-landscape.md)
 - [Hunch roadmap](ROADMAP.md)
 - [VS Code extension](vscode-extension/README.md)

package/dist/cli/index.js

@@ -31,6 +31,7 @@ import { registerUpdateCommand } from "./update.js";
 import { registerReviewMemoryCommands } from "./reviewMemory.js";
 import { detectInitiator, normalizeInitiator } from "../synthesis/initiator.js";
 import { inspectIntegrations, formatIntegrationHealth, integrationHealthFails, integrationSessionWarning } from "../integrations/health.js";
+import { publishedStatus } from "../integrations/registry.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { JsonStore } from "../store/jsonStore.js";
 import { selectEmbedder } from "../store/embedder.js";
@@ -4451,15 +4452,21 @@ program
     .option("--provider <provider>", "hook event dialect: claude | vscode | cursor | windsurf | antigravity", "claude")
     .action(async (opts) => {
     // A hook MUST NEVER break the agent: on ANY error or unrecognized input we
-    // emit nothing and exit 0 (the action defers to Claude Code's normal flow).
+    // exit 0 and never deny (the action defers to the host's normal flow).
+    // Unrecognized input stays silent; an error after the event was recognized
+    // says "grounding unavailable" in one context line — see the catch below.
     let store = null;
+    // Hoisted so the fail-open catch below can still say which grounding was lost.
+    let provider = null;
+    let eventName = null;
     try {
-        const provider = hookProvider(opts.provider);
+        provider = hookProvider(opts.provider);
         if (!provider)
             return;
         const evt = normalizeHookEvent(JSON.parse(await readStdin()), provider);
         if (!evt)
             return;
+        eventName = evt.hook_event_name;
         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.
@@ -4769,15 +4776,16 @@ program
         }
         // Pre-edit grounding must resolve the same advertised graph as every CLI
         // and MCP consumer. Any unavailable/mismatched team route falls through to
-        // the outer fail-open catch and emits nothing, preserving the hook's
-        // non-blocking invariant without false-passing against public/stale memory.
+        // the outer fail-open catch: one "grounding unavailable" line, never a deny,
+        // never grounding from public/stale memory (dec_77d99014e0).
         const opened = openTeamStore(root, { requireFreshTeamMemory: firmness === "strict" });
         store = opened.store;
         if (firmness === "strict" && opened.teamPullStatus
             && opened.teamPullStatus !== "updated" && opened.teamPullStatus !== "current") {
             // A strict deny is only trustworthy when it includes the latest team
             // rules. Offline/busy/unconfigured team memory is unavailable, so the
-            // non-blocking hook emits nothing instead of denying from stale state.
+            // non-blocking hook says so instead of denying from stale state.
+            emitContext(provider, "PreToolUse", `Hunch grounding unavailable for this edit; it proceeds ungrounded (team memory is ${opened.teamPullStatus}; strict mode never denies from stale rules). Run \`hunch doctor\`.`);
             return;
         }
         // strict: refuse an edit that hits a BLOCKING invariant (direct OR via blast
@@ -4900,8 +4908,18 @@ program
         }
         emitContext(provider, "PreToolUse", text + reportNotice, recalled ?? undefined);
     }
-    catch {
-        // swallow — never block an edit on a hook failure
+    catch (e) {
+        // Never block an edit on a hook failure — and never go silent either: an
+        // ungrounded edit that looks grounded gets diagnosed as model flakiness.
+        // One context line, exit 0 (the launcher itself failing stays out of reach).
+        const reason = e instanceof Error ? e.message.split("\n")[0] : "unknown error";
+        if (provider && (eventName === "PreToolUse" || eventName === "SessionStart" || eventName === "UserPromptSubmit")) {
+            const what = eventName === "PreToolUse" ? "for this edit; it proceeds ungrounded" : "for this session";
+            try {
+                emitContext(provider, eventName, `Hunch grounding unavailable ${what} (${reason}). Run \`hunch doctor\`.`);
+            }
+            catch { /* stdout gone */ }
+        }
     }
     finally {
         store?.close();
@@ -6626,6 +6644,21 @@ program
     .action(async () => {
     const integrations = inspectIntegrations(findRoot());
     console.log(formatIntegrationHealth(integrations));
+    // A pin npm cannot serve kills every npx launcher (hooks and MCP) before Hunch
+    // runs, and the hosts report nothing. Name it here; bounded, offline-safe.
+    const published = new Map();
+    for (const v of new Set([integrations.expectedVersion, ...integrations.pins.map(p => p.version)]))
+        published.set(v, publishedStatus(v));
+    const expectedUnpublished = published.get(integrations.expectedVersion) === "unpublished";
+    for (const pin of integrations.pins) {
+        if (published.get(pin.version) !== "unpublished")
+            continue;
+        console.log(`ERROR ${pin.file}: pins Hunch ${pin.version}, which npm cannot serve (ETARGET) — every hook run and MCP launch from this file fails before Hunch starts, silently. Run \`hunch integrations repair-pins\`${expectedUnpublished ? " once the release publishes" : ""}.`);
+        process.exitCode = 1;
+    }
+    if (expectedUnpublished && integrations.pins.every(p => p.version !== integrations.expectedVersion)) {
+        console.log(`note: package.json says ${integrations.expectedVersion}, which is not on npm yet; machine-local pins stay on the last published release until it is (then run \`hunch integrations repair-pins\`).`);
+    }
     // A shared-memory or CLI-only checkout may intentionally have no local
     // assistant config. The explicit integrations check still fails that case.
     if (integrations.harnesses.length > 0 && integrationHealthFails(integrations))

package/dist/cli/taskReport.js

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { findRoot } from "../core/paths.js";
 import { writeFileAtomic } from "../core/io.js";
-import { finishReportTask, forgetReportTask, listReportTasks, pruneReportHistory, readTaskReport, readLessonHistory, startReportTask } from "../core/taskReport.js";
+import { finishReportTask, forgetReportTask, listReportTasks, listTaskSummaries, pruneReportHistory, readTaskReport, readLessonHistory, renderTaskStatusLine, startReportTask, summarizeTaskReport, taskReportStats } from "../core/taskReport.js";
+import { promptTaskId } from "../core/taskReportHook.js";
 import { DEFAULT_CHECK_TIMEOUT_MS, MAX_CHECK_TIMEOUT_MS, reportSourceSnapshot, runReportCheck, runReportConformance } from "../core/taskReportEvidence.js";
 import { renderTaskReport, writeTaskReportHtml } from "../core/taskReportRender.js";
 import { assertReportPath } from "../core/taskReportPaths.js";
@@ -40,6 +41,72 @@ export function registerTaskReportCommands(program, openStore) {
         finishReportTask(root, id, opts.interrupted ? "interrupted" : "completed");
         console.log(renderTaskReport(readTaskReport(root, id, reportSourceSnapshot(root).hash)));
     });
+    task.command("list").description("Recent tasks observed in this repository with what Hunch delivered, saved, guarded, and checked")
+        .option("--limit <n>", "how many recent tasks (max 30)", "30")
+        .option("--json", "machine-readable summaries (consumed by the VS Code Contribution view)")
+        .action((opts) => {
+        const root = findRoot();
+        const summaries = listTaskSummaries(root, Number(opts.limit) || 30, reportSourceSnapshot(root).hash);
+        if (opts.json) {
+            console.log(JSON.stringify(summaries, null, 2));
+            return;
+        }
+        if (!summaries.length) {
+            console.log("No task activity observed yet.");
+            return;
+        }
+        for (const s of summaries)
+            console.log(`${s.task.started_at.slice(0, 16).replace("T", " ")}  ${s.task.task_id}  ${s.task.state.padEnd(11)} ${renderTaskStatusLine(s) || "nothing observed"}`);
+    });
+    task.command("stats").description("Adherence over a window: how many prompts Hunch reached (delivery), checked, saved, or guarded — from the ledger, never from agent claims")
+        .option("--days <days>", "window in days", "7")
+        .option("--json", "machine-readable")
+        .action((opts) => {
+        const stats = taskReportStats(findRoot(), Number(opts.days) || 7);
+        if (opts.json) {
+            console.log(JSON.stringify(stats, null, 2));
+            return;
+        }
+        const pct = (n) => stats.tasks ? `${Math.round((n / stats.tasks) * 100)}%` : "–";
+        console.log(`Hunch adherence, last ${Number(opts.days) || 7} day(s): ${stats.tasks} task(s), ${stats.completed} completed`);
+        console.log(`  reached by memory (delivery)  ${stats.with_delivery}  ${pct(stats.with_delivery)}`);
+        console.log(`  independent check recorded    ${stats.with_check}  ${pct(stats.with_check)}`);
+        console.log(`  application claimed by agent  ${stats.with_claim}  ${pct(stats.with_claim)}`);
+        console.log(`  memory saved                  ${stats.with_save}  ${pct(stats.with_save)}`);
+        console.log(`  edit denied                   ${stats.with_refusal}  ${pct(stats.with_refusal)}`);
+        console.log(`  nothing observed              ${stats.empty}  ${pct(stats.empty)}`);
+    });
+    task.command("status").description("One line for a terminal status line: the current prompt's task when Claude Code's status-line JSON arrives on stdin, otherwise the most recent task here")
+        .option("--json", "machine-readable summary")
+        .action(async (opts) => {
+        const input = process.stdin.isTTY ? "" : await readStdinText();
+        let root = findRoot();
+        let taskId = null;
+        try {
+            const host = input.trim() ? JSON.parse(input) : {};
+            const dir = host.workspace?.current_dir ?? host.cwd;
+            if (dir)
+                root = findRoot(dir);
+            if (host.session_id && host.prompt_id)
+                taskId = promptTaskId(root, host.session_id, host.prompt_id);
+        }
+        catch { /* a malformed host payload falls back to the most recent task */ }
+        let summary = null;
+        try {
+            const snapshot = reportSourceSnapshot(root).hash;
+            summary = taskId ? summarizeTaskReport(root, taskId, snapshot) : listTaskSummaries(root, 1, snapshot)[0] ?? null;
+        }
+        catch {
+            summary = null;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(summary));
+            return;
+        }
+        const line = renderTaskStatusLine(summary);
+        if (line)
+            console.log(line);
+    });
     task.command("forget <id>").description("Delete this closed task's local observations and generated report; retains project memory")
         .action((id) => { forgetReportTask(findRoot(), id); console.log("Task report history removed; project memory retained."); });
     task.command("prune").description("Delete local report history for tasks closed more than the retention period ago")
@@ -125,4 +192,16 @@ export function registerTaskReportCommands(program, openStore) {
         console.log(opts.json ? JSON.stringify(report, null, 2) : renderTaskReport(report));
     });
 }
+function readStdinText() {
+    return new Promise(resolve => {
+        let data = "";
+        const done = () => resolve(data);
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", chunk => { data += chunk; });
+        process.stdin.on("end", done);
+        process.stdin.on("error", done);
+        // A host that opened stdin but never writes must not hang the status line.
+        setTimeout(done, 1500).unref();
+    });
+}
 //# sourceMappingURL=taskReport.js.map

package/dist/core/agenthook.d.ts

@@ -5,7 +5,7 @@
  * fields or tools. Keep that variability here so the policy engine receives
  * the same small, fail-open shape regardless of the assistant that emitted it.
  */
-export declare const HOOK_PROVIDERS: readonly ["claude", "vscode", "windsurf", "antigravity", "cursor"];
+export declare const HOOK_PROVIDERS: readonly ["claude", "codex", "vscode", "windsurf", "antigravity", "cursor"];
 export type HookProvider = (typeof HOOK_PROVIDERS)[number];
 export type HunchHookEvent = "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "UserPromptSubmit" | "SessionStart" | "SubagentStart" | "PreCompact" | "Stop";
 export interface HunchToolInput {

package/dist/core/agenthook.js

@@ -5,7 +5,7 @@
  * fields or tools. Keep that variability here so the policy engine receives
  * the same small, fail-open shape regardless of the assistant that emitted it.
  */
-export const HOOK_PROVIDERS = ["claude", "vscode", "windsurf", "antigravity", "cursor"];
+export const HOOK_PROVIDERS = ["claude", "codex", "vscode", "windsurf", "antigravity", "cursor"];
 function obj(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -49,10 +49,24 @@ function edits(value) {
         .map((item) => ({ new_string: stringAt(item, "new_string", "newString", "ReplacementContent", "replacementContent") }));
     return normalized.length ? normalized : undefined;
 }
+/** Codex edits files through `apply_patch`, whose input is the patch text itself
+ * (`*** Update File: path`). The first touched path becomes the edit target so the
+ * per-file pre-edit gate applies; the whole patch stands in for the new content. */
+const PATCH_FILE = /^\*\*\* (?:Update|Add|Delete) File: (.+?)\s*$/m;
+function applyPatchInput(raw) {
+    const patch = [raw.input, raw.patch, raw.content].find((v) => typeof v === "string" && /\*\*\* Begin Patch/.test(v));
+    if (!patch)
+        return undefined;
+    const file = PATCH_FILE.exec(patch)?.[1];
+    return file ? { file_path: file, content: patch } : undefined;
+}
 function normalizeToolInput(value) {
     const raw = obj(value);
     if (!raw)
         return undefined;
+    const patched = applyPatchInput(raw);
+    if (patched)
+        return patched;
     const replacementChunks = Array.isArray(raw.ReplacementChunks) ? raw.ReplacementChunks : raw.replacementChunks;
     const chunkEdits = Array.isArray(replacementChunks)
         ? replacementChunks.map((chunk) => obj(chunk)).filter((chunk) => !!chunk)
@@ -63,7 +77,9 @@ function normalizeToolInput(value) {
         new_string: stringAt(raw, "new_string", "newString", "ReplacementContent", "replacementContent", "TargetContent", "targetContent"),
         content: stringAt(raw, "content", "contents", "CodeContent", "codeContent"),
         edits: edits(raw.edits) ?? edits(raw.files) ?? chunkEdits,
-        command: stringAt(raw, "command", "commandLine", "CommandLine", "cmd"),
+        // Codex's shell tools carry argv arrays (["bash", "-lc", "…"]); policies read one string.
+        command: stringAt(raw, "command", "commandLine", "CommandLine", "cmd")
+            ?? (Array.isArray(raw.command) && raw.command.every(p => typeof p === "string") ? raw.command.join(" ") : undefined),
         skill: stringAt(raw, "skill", "skillName", "name"),
     };
     return Object.values(out).some((v) => v !== undefined) ? out : undefined;
@@ -194,7 +210,10 @@ export function normalizeHookEvent(raw, provider) {
     return {
         hook_event_name: event,
         session_id: stringAt(input, "session_id", "sessionId", "conversation_id", "conversationId"),
-        ...(provider === "claude" ? Object.fromEntries(["prompt_id", "cwd", "agent_id"].filter(key => input[key] !== undefined).map(key => [key, typeof input[key] === "string" ? input[key] : ""])) : {}),
+        // Codex delivers the same lifecycle payload with `turn_id` where Claude Code
+        // 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_input: toolInput,
         ...(toolOutcome ? { tool_outcome: toolOutcome } : {}),

package/dist/core/config.d.ts

@@ -11,6 +11,9 @@ export declare const FIRMNESS_LEVELS: readonly Firmness[];
 export declare const DEFAULT_FIRMNESS: Firmness;
 export interface HunchConfig {
     firmness: Firmness;
+    /** MCP tool groups beyond the everyday set: `all`, `core`, or `core,nuryel`
+     *  (see src/mcp/toolset.ts). Undefined = decide from the root's contents. */
+    mcp_tools?: string;
 }
 export declare function isFirmness(v: unknown): v is Firmness;
 /** Read `.hunch/config.json`. A missing/unparseable file, or an unknown firmness

package/dist/core/config.js

@@ -19,7 +19,10 @@ export function readConfig(paths) {
         return defaults();
     try {
         const raw = JSON.parse(readFileSync(paths.config, "utf8"));
-        return { firmness: isFirmness(raw.firmness) ? raw.firmness : DEFAULT_FIRMNESS };
+        return {
+            firmness: isFirmness(raw.firmness) ? raw.firmness : DEFAULT_FIRMNESS,
+            ...(typeof raw.mcp_tools === "string" && raw.mcp_tools.trim() ? { mcp_tools: raw.mcp_tools.trim() } : {}),
+        };
     }
     catch {
         return defaults();

package/dist/core/stateContract.d.ts

@@ -961,6 +961,9 @@ export declare const STATE_INVARIANTS: readonly [{
 }, {
     readonly id: "derived-state-writer-owns-currentness";
     readonly statement: "No source writes the drawer. The writer of a current derived statement owns keeping its dependencies true: re-validate them on a schedule or on a source event, and write the statement back stale with the moved pointer as cause when one no longer holds. Without this duty an agent may capture source-backed observations only as unknown; observations never assert currentness.";
+}, {
+    readonly id: "one-current-derived-per-subject-transform";
+    readonly statement: "A subject holds at most one current derived statement per transform: a new one must name the incumbent in supersedes (refused 409 with the incumbent named otherwise); the same identity written again updates or replays that record.";
 }];
 /** The memory supply chain's top tier: a record whose provenance a human signed. Same tier rule
  *  as the strict gate's (strictgate.isHumanConfirmed), applied to a record instead of a source. */

package/dist/core/stateContract.js

@@ -306,6 +306,7 @@ export const STATE_INVARIANTS = [
     { id: "one-entity-per-external-ref", statement: "One external record is one entity in a partition: a second active entity carrying an external key an incumbent already carries is refused with the incumbent named, and a subject written as that record's external key is refused with the entity's id named. Identity is explicit refs, never similarity; merge is explicit — a retired entity names the survivor in `merged_into`, the ledger holds the `retired` event, nothing under the old id is rewritten and reads resolve to the survivor — and split is the explicit reverse; never a silent rewrite." },
     { id: "human-correction-outranks-agent-writes", statement: "A record a human confirmed is never overwritten or superseded by an agent or service principal: the agent may replay it, write derived state back stale with the external cause that moved, or close a commitment with a receipt on record. Changing what the human said takes a human." },
     { id: "derived-state-writer-owns-currentness", statement: "No source writes the drawer. The writer of a current derived statement owns keeping its dependencies true: re-validate them on a schedule or on a source event, and write the statement back stale with the moved pointer as cause when one no longer holds. Without this duty an agent may capture source-backed observations only as unknown; observations never assert currentness." },
+    { id: "one-current-derived-per-subject-transform", statement: "A subject holds at most one current derived statement per transform: a new one must name the incumbent in supersedes (refused 409 with the incumbent named otherwise); the same identity written again updates or replays that record." },
 ];
 const grantKey = (scope) => scopePath(scope);
 /** The memory supply chain's top tier: a record whose provenance a human signed. Same tier rule

package/dist/core/taskReport.d.ts

@@ -222,6 +222,55 @@ export declare function recordReportConformance(root: string, taskId: string, co
 export declare function recordReportCheck(root: string, taskId: string, check: ReportCheck): string;
 export declare function beginReportCheck(root: string, taskId: string, label: string): string;
 export declare function finishReportTask(root: string, taskId: string, state?: "completed" | "interrupted"): ReportTask;
+/** A report with no observation of any kind. Presentation surfaces may stay
+ * silent for it; the task row itself is retained so "never touched Hunch" is
+ * still countable (hunch report / the VS Code view / task list). */
+export declare function isEmptyTaskReport(report: Pick<TaskReport, "deliveries" | "claims" | "checks" | "conformance" | "saves" | "refusals">): boolean;
+export interface TaskSummary {
+    task: ReportTask;
+    deliveries: number;
+    lessons: number;
+    claims: number;
+    saves: number;
+    refusals: number;
+    /** Standing of the last recorded check, or null when none ran. */
+    check: {
+        label: string;
+        state: "passed" | "failed" | "timed out" | "cancelled";
+        current: boolean;
+    } | null;
+    /** Any delivered rule evaluated as violated on the changed files. */
+    violated: boolean;
+    coverage: TaskReport["coverage"];
+    empty: boolean;
+    /** Generated evidence view, when one has been written for this task. */
+    report_html: string | null;
+    /** Set when the observation ledger could not be read for this task. */
+    error: string | null;
+}
+/** 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[];
+/** 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;
+export interface TaskReportStats {
+    since: string;
+    tasks: number;
+    completed: number;
+    with_delivery: number;
+    with_check: number;
+    with_claim: number;
+    with_save: number;
+    with_refusal: number;
+    empty: number;
+    /** with_delivery / tasks, the adherence number worth watching; null when no tasks. */
+    delivery_rate: number | null;
+}
+/** Adherence over a window: how many prompts Hunch actually reached. Counts
+ * come from the ledger, never from agent claims; a claim is counted as a claim. */
+export declare function taskReportStats(root: string, days?: number): TaskReportStats;
 export declare function listReportTasks(root: string): ReportTask[];
 export declare function reportActivity(root: string): string;
 /** Exact task deletion is a user-invoked operation, never a memory deletion. */

package/dist/core/taskReport.js

@@ -368,6 +368,105 @@ export function finishReportTask(root, taskId, state = "completed") {
         return finished;
     }));
 }
+/** A report with no observation of any kind. Presentation surfaces may stay
+ * silent for it; the task row itself is retained so "never touched Hunch" is
+ * still countable (hunch report / the VS Code view / task list). */
+export function isEmptyTaskReport(report) {
+    return !report.deliveries.length && !report.claims.length && !report.checks.length && !report.conformance.length && !report.saves.length && !report.refusals.length;
+}
+/** One bounded summary per recent task for status lines and host views; the
+ * card and evidence view remain the authoritative renderings. */
+export function summarizeTaskReport(root, taskId, currentSnapshot = null) {
+    const html = join(root, ".hunch-cache", "reports", `${taskId}.html`);
+    try {
+        const report = readTaskReport(root, taskId, currentSnapshot);
+        const last = report.checks.at(-1);
+        const standing = new Map(report.conformance.map(r => [`${r.kind}:${r.record_id}:${r.content_hash}`, r]));
+        return {
+            task: report.task,
+            deliveries: report.deliveries.length,
+            lessons: new Set(report.deliveries.flatMap(d => d.records).map(r => `${r.kind}:${r.record_id}`)).size,
+            claims: report.claims.length,
+            saves: report.saves.length,
+            refusals: report.refusals.length,
+            check: last ? { label: last.label, state: last.cancelled ? "cancelled" : last.timed_out ? "timed out" : last.exit_code === 0 ? "passed" : "failed", current: last.current } : null,
+            violated: [...standing.values()].some(r => r.outcome === "violated"),
+            coverage: report.coverage,
+            empty: isEmptyTaskReport(report),
+            report_html: existsSync(html) ? html : null,
+            error: null,
+        };
+    }
+    catch (e) {
+        return taskDb(root, db => {
+            const row = db.prepare("SELECT body FROM report_tasks WHERE task_id = ?").get(taskId);
+            if (!row)
+                throw e;
+            return { task: TaskSchema.parse(JSON.parse(row.body)), deliveries: 0, lessons: 0, claims: 0, saves: 0, refusals: 0, check: null, violated: false, coverage: "no-delivery-observed", empty: true, report_html: existsSync(html) ? html : null, error: e.message };
+        });
+    }
+}
+export function listTaskSummaries(root, limit = 30, currentSnapshot = null) {
+    if (!existsSync(join(root, ".hunch-cache", "served.db")))
+        return [];
+    return listReportTasks(root).slice(0, Math.max(1, Math.min(limit, 30))).map(task => summarizeTaskReport(root, task.task_id, currentSnapshot));
+}
+/** 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 function renderTaskStatusLine(summary) {
+    if (!summary || summary.empty)
+        return "";
+    const parts = [`Hunch`];
+    parts.push(summary.lessons ? `${summary.lessons} lesson${summary.lessons === 1 ? "" : "s"} recalled` : summary.deliveries ? "memory delivered" : "no delivery");
+    if (summary.violated)
+        parts.push("rule violated");
+    else if (summary.claims)
+        parts.push(`${summary.claims} applied`);
+    if (summary.saves)
+        parts.push(`${summary.saves} saved`);
+    if (summary.refusals)
+        parts.push("edit denied");
+    if (summary.check)
+        parts.push(`${summary.check.label}: ${summary.check.state}${summary.check.current ? "" : " (source changed)"}`);
+    else
+        parts.push("no check recorded");
+    return parts.join(" · ");
+}
+/** Adherence over a window: how many prompts Hunch actually reached. Counts
+ * come from the ledger, never from agent claims; a claim is counted as a claim. */
+export function taskReportStats(root, days = 7) {
+    const since = new Date(Date.now() - Math.max(1, days) * 86_400_000).toISOString();
+    const empty = { since, tasks: 0, completed: 0, with_delivery: 0, with_check: 0, with_claim: 0, with_save: 0, with_refusal: 0, empty: 0, delivery_rate: null };
+    if (!existsSync(join(root, ".hunch-cache", "served.db")))
+        return empty;
+    return taskDb(root, db => {
+        const tasks = db.prepare("SELECT body FROM report_tasks WHERE scope = ? AND json_extract(body, '$.started_at') >= ?").all(scopeOf(root), since)
+            .map(r => TaskSchema.parse(JSON.parse(r.body)));
+        if (!tasks.length)
+            return empty;
+        const kinds = (taskId) => new Set(db.prepare("SELECT DISTINCT kind FROM report_events WHERE task_id = ?").all(taskId).map(r => r.kind));
+        const stats = { ...empty, tasks: tasks.length };
+        for (const task of tasks) {
+            const k = kinds(task.task_id);
+            if (task.state === "completed")
+                stats.completed++;
+            if (k.has("delivery"))
+                stats.with_delivery++;
+            if (k.has("check") || k.has("check-start"))
+                stats.with_check++;
+            if (k.has("claim"))
+                stats.with_claim++;
+            if (k.has("save"))
+                stats.with_save++;
+            if (k.has("refusal"))
+                stats.with_refusal++;
+            if (!k.size)
+                stats.empty++;
+        }
+        stats.delivery_rate = stats.with_delivery / stats.tasks;
+        return stats;
+    });
+}
 export function listReportTasks(root) {
     return taskDb(root, db => db.prepare("SELECT body FROM report_tasks WHERE scope = ? ORDER BY rowid DESC LIMIT 30").all(scopeOf(root)).map(r => TaskSchema.parse(JSON.parse(r.body))));
 }

package/dist/core/taskReportHook.d.ts

@@ -1,10 +1,16 @@
 import type { HookProvider, HunchHookInput } from "./agenthook.js";
+/** The exact task identity a Claude Code prompt maps to. The status line receives
+ * the same session_id/prompt_id on stdin, so it can name the prompt's task too. */
+export declare function promptTaskId(root: string, sessionId: string, promptId: string, agentId?: string | null, provider?: HookProvider): string;
 export declare function hookReportTaskId(root: string, provider: HookProvider, event: HunchHookInput): string | null;
 /** Every prompt receives its exact ID, even when ambient reminders were deduped.
  * No raw prompt, host session identifier, or transcript is retained. */
 export declare function startHookReport(root: string, provider: HookProvider, event: HunchHookInput): string | null;
 /** A presentation notice never denies Stop or injects another model turn. Stop
- * can precede another hook's continuation, so it does not close an open task. */
+ * can precede another hook's continuation, so it does not close an open task.
+ * A prompt with no observation at all prints nothing: the empty task row stays
+ * in the ledger (hunch task list, the VS Code Contribution view) so "never
+ * touched Hunch" remains countable without a five-line notice per prompt. */
 export declare function stopHookReport(root: string, provider: HookProvider, event: HunchHookInput): {
     systemMessage: string;
 } | null;

package/dist/core/taskReportHook.js

@@ -3,11 +3,19 @@
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { findRoot } from "./paths.js";
-import { readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, startReportTask } from "./taskReport.js";
+import { isEmptyTaskReport, readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, startReportTask } from "./taskReport.js";
 import { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { renderTaskReport, writeTaskReportHtml } from "./taskReportRender.js";
+/** The exact task identity a Claude Code prompt maps to. The status line receives
+ * the same session_id/prompt_id on stdin, so it can name the prompt's task too. */
+export function promptTaskId(root, sessionId, promptId, agentId = null, provider = "claude") {
+    return `htask_${reportHash([realpathSync(root), provider, sessionId, promptId, agentId]).slice(7, 31)}`;
+}
+/** Hosts whose hooks deliver a native per-prompt identity (Claude Code's
+ * prompt_id, Codex's turn_id). Others get no task from a hook. */
+const NATIVE_PROMPT_HOSTS = new Set(["claude", "codex"]);
 function identity(root, provider, event) {
-    if (provider !== "claude" || !event.cwd || realpathSync(findRoot(event.cwd)) !== realpathSync(root))
+    if (!NATIVE_PROMPT_HOSTS.has(provider) || !event.cwd || realpathSync(findRoot(event.cwd)) !== realpathSync(root))
         return null;
     for (const value of [event.session_id, event.prompt_id, event.agent_id]) {
         if (value !== undefined && (!value.length || value.length > 1024 || /[\u0000-\u001f\u007f]/.test(value)))
@@ -17,7 +25,7 @@ function identity(root, provider, event) {
         return null;
     if (!event.prompt_id)
         return "legacy";
-    return `htask_${reportHash([realpathSync(root), provider, event.session_id, event.prompt_id, event.agent_id ?? null]).slice(7, 31)}`;
+    return promptTaskId(root, event.session_id, event.prompt_id, event.agent_id ?? null, provider);
 }
 export function hookReportTaskId(root, provider, event) {
     try {
@@ -38,7 +46,10 @@ export function startHookReport(root, provider, event) {
     return `Hunch has opened this prompt's report: ${task.task_id}. Reuse this exact ID for this prompt. Call hunch_task(action: "start", task_id: "${task.task_id}", title: "Claude task") to obtain verification_argv; do not create another report. Pass this task_id to hunch_context and decision/correction/finding captures, and finish with hunch_task before responding. A host Stop notice will show the evidence even if no task-linked memory was observed.`;
 }
 /** A presentation notice never denies Stop or injects another model turn. Stop
- * can precede another hook's continuation, so it does not close an open task. */
+ * can precede another hook's continuation, so it does not close an open task.
+ * A prompt with no observation at all prints nothing: the empty task row stays
+ * in the ledger (hunch task list, the VS Code Contribution view) so "never
+ * touched Hunch" remains countable without a five-line notice per prompt. */
 export function stopHookReport(root, provider, event) {
     if (!reportPresentationEnabled(root))
         return null;
@@ -46,9 +57,11 @@ export function stopHookReport(root, provider, event) {
     if (!id)
         return null;
     if (id === "legacy")
-        return { systemMessage: "Hunch hook active. This Claude version does not provide an exact prompt identifier, so contribution for this response is unverified. Explicit task reports remain available with hunch report." };
+        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);
+        if (isEmptyTaskReport(report))
+            return null;
         let card = renderTaskReport(report);
         try {
             const file = writeTaskReportHtml(root, id);