@davesheffer/hunch 1.44.0 → 1.45.1

package/README.md

@@ -127,7 +127,7 @@ hunch task list
 hunch report <task-id> --html
 ```
 
-A delivered lesson, an agent's claim, and a passing test are different evidence. Hunch keeps them separate. Automatic presentation depends on the host following the task lifecycle; missing evidence stays unverified. [Read the reporting guide](docs/task-reports.md).
+A delivered lesson, an agent's claim, and a passing test are different evidence. Hunch keeps them separate. Automatic presentation depends on the host following the task lifecycle; missing evidence stays unverified.
 
 ## Share one living repository memory with your team
 
@@ -152,19 +152,19 @@ Hunch ships `hunch serve`: a self-hosted HTTP service for organization, team, us
 
 Open `/operator` on your server to inspect current records, completed work and commitments in a read-only browser view. Writer-supplied citations can point to an exact summary field or text passage and its recorded sources. They show traceability; they do not prove that a source supports a claim.
 
-Agents can use the same contract through MCP, `hunch state read|write|records|subscribe`, the `@davesheffer/hunch/state` TypeScript client, or the [Python client](docs/python-state-client.md). The Python package is built and tested from this repository; it is not yet published to PyPI. [Scoped conventions](docs/scoped-conventions.md) let a person record sourced user, team or organization preferences. Those preferences remain advisory and do not silently become blocking rules.
+Agents can use the same contract through MCP, `hunch state read|write|records|subscribe`, the `@davesheffer/hunch/state` TypeScript client, or the Python client. The Python package is built and tested from this repository; it is not yet published to PyPI. Scoped conventions let a person record sourced user, team or organization preferences. Those preferences remain advisory and do not silently become blocking rules.
 
 Records can describe decisions, action outcomes, commitments, entities, relationships, and summaries that name their dependencies. Actions retain their status, including unknown or unverified outcomes. Repeated writes have stable identities, conflicting current decisions are refused, and confirmed human records receive protections against agent overwrites. These are defined checks on structured records; Hunch cannot establish every fact in the outside world on its own.
 
 This is what **deterministic state** means here: explicit rules govern the stored record, rather than having each agent reconstruct it from scratch. Git holds the durable data; SQLite is a rebuildable index. The server binds to loopback and requires deployment and agent integration by its operator. Hunch does not provide a managed CRM or email connector service.
 
-[Set up and understand the state server](docs/deterministic-state.md) · [State contract and client reference](docs/nuryel-state-contract.md) · [Upgrade to 1.33](docs/upgrade-1.33.md)
+See the [full documentation](https://www.hunchmemory.com/docs).
 
 ### The vision, and what is still being tested
 
 The vision is continuity across people, tools, and agents: an operations agent records a customer issue, a coding agent finds the relevant decision and fixes the cause, and the operations agent closes the commitment using evidence of the fix.
 
-The underlying memory and state tools ship today. The broader claim—that different agents reliably use that shared state and avoid contradictory work—is still being measured in the Sofia pilot. Simulated results and a limited live pilot are not proof of that outcome across organizations. The [roadmap](ROADMAP.md) tracks the remaining acceptance gates.
+The underlying memory and state tools ship today. The broader claim—that different agents reliably use that shared state and avoid contradictory work—is still being measured.
 
 **Hunch remains the product name.** The `nuryel.state/1` protocol and `nuryel_*` tool names are existing technical identifiers; a possible future rename is undecided.
 
@@ -178,7 +178,7 @@ hunch dna context
 hunch dna diff <older-ref> <newer-ref>
 ```
 
-Profiles retain their revision, sources, confidence, and freshness. [Project DNA contract](docs/project-dna.md) · [Broader DNA vision](docs/project-dna-engine.md)
+Profiles retain their revision, sources, confidence, and freshness.
 
 ## Your data and your authority
 
@@ -192,18 +192,8 @@ Profiles retain their revision, sources, confidence, and freshness. [Project DNA
 
 - [Full documentation](https://www.hunchmemory.com/docs)
 - [Copy-paste cookbook](https://www.hunchmemory.com/cookbook)
-- [Task contribution reports](docs/task-reports.md)
-- [Deterministic organizational state](docs/deterministic-state.md)
-- [Project DNA](docs/project-dna.md)
-- [Native change proof](docs/change-proof.md)
-- [Engineering Landscape](docs/engineering-landscape.md)
-- [Review memory](docs/review-memory.md)
-- [Agent-origin handling](docs/agent-origin.md)
-- [Autonomy ladder](docs/autonomy-ladder.md)
-- [Autonomous development](https://github.com/davesheffer/hunch-private/blob/main/projects/hunch/docs/autonomous-development.md)
-- [Changelog](CHANGELOG.md) · [Roadmap](ROADMAP.md)
+- [Changelog](CHANGELOG.md)
 - [VS Code extension](vscode-extension/README.md)
-- [Architecture benchmark](bench/architectural-conformance.md)
 - [Contributing](CONTRIBUTING.md)
 
 Apache-2.0

package/dist/cli/index.js

@@ -60,7 +60,7 @@ import { installPostCommitHook, installPreCommitHook, installPostMergeHook, inst
 import { ensureSharedOverlayPointer } from "../integrations/worktree.js";
 import { flushCapture, flushMemoryHome, flushMemoryHomes, pinSharedRemote, sharedRemoteFor } from "../integrations/sync.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
-import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS, upgradeManagedGitignore, describeGitignoreUpgrade } from "../integrations/gitignore.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 { updateClaudeMd, renderHunchSection } from "../integrations/claudemd.js";
@@ -69,7 +69,7 @@ import { measureFootprint } from "../core/footprint.js";
 import { classifyGroundingBlock, describeGroundingFreshness } from "../core/groundingLag.js";
 import { mergeGroundingFile } from "../core/groundingMerge.js";
 import { writeMcpJson, writeSlashCommands, installClaudeHooks } from "../integrations/scaffold.js";
-import { scaffoldProviders, regenerateGrounding, refreshExistingGrounding, refreshCommittableGrounding, GROUNDING_DOC_PATHS } from "../integrations/providers.js";
+import { scaffoldProviders, detectAssistants, PROVIDER_ASSISTANTS, regenerateGrounding, refreshExistingGrounding, refreshCommittableGrounding, GROUNDING_DOC_PATHS } from "../integrations/providers.js";
 import { healClaudeConfigCaseSplit } from "../integrations/claudeConfig.js";
 import { formatSearchHit, formatStructure } from "../core/format.js";
 import { isStateKind, renderStateLine, stateSupplements } from "../core/stateDelivery.js";
@@ -94,7 +94,7 @@ import { isHumanConfirmed } from "../core/strictgate.js";
 import { appendEvent, readEvents } from "../core/events.js";
 import { computeStats, formatStats } from "../core/stats.js";
 import { clearTaskSelection, injectionMode, loadTaskSelection, resetSessionInjections, saveTaskSelection, taskSelectionEnabled } from "../core/hookcache.js";
-import { isBareFollowUp, isFilterableSelectionId, liveSelectionRecords, selectForTask } from "../core/taskSelection.js";
+import { isBareFollowUp, isFilterableSelectionId, liveSelectionRecords, promptPaths, selectForTask } from "../core/taskSelection.js";
 import { recordServed, servedSummary } from "../core/served.js";
 import { readTaskReport, recordTaskDelivery, reportActivity, reportHash, reportPresentationEnabled, unseenLessons } from "../core/taskReport.js";
 import { snapshotDeliveredRecords } from "../core/taskReportEvidence.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, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
+import { contextHookOutput, 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";
@@ -118,7 +118,7 @@ import { countersignConstraint, countersignDecision } from "../core/countersign.
 import { applyImportedAdrReview, carryImportedAdrReview, importedAdrReviewHash, importedAdrSourceHash, isImportedAdrDecision, pendingImportedAdrReviews } from "../core/importReview.js";
 import { exportMadrCorpus, isRegenerableMadr } from "../integrations/madrExport.js";
 import { buildMadrManifest, writeMadrManifest, refreshMadrCorpus } from "../integrations/madrManifest.js";
-import { pendingEscalations, policyEscalations, commitRepairEscalations, actionableEscalations, escalationHeadline } from "../core/escalations.js";
+import { pendingEscalations, policyEscalations, commitRepairEscalations, actionableEscalations, escalationHeadline, relevantEscalations } from "../core/escalations.js";
 import { premiseEscalations } from "../core/premises.js";
 import { parseDocAnchors, renderDocGrounding } from "../core/docanchors.js";
 import { pathMatchesGlob } from "../core/glob.js";
@@ -354,6 +354,8 @@ program
     .option("--private-sync", "post-commit synthesis writes captured decisions into the overlay repo (HUNCH_PRIVATE_DIR), never the public store")
     .option("--shared-sync", "alias of --private-sync (for teams using one shared overlay repo for any code repo)")
     .option("--no-auto-commit", "DON'T auto-commit captures (default: ON in every mode — the overlay repo is committed+pushed; the public .hunch/ is committed only and rides your next push)")
+    .option("--all-assistants", "configure every supported assistant, not only those found on this machine or in this repository")
+    .option("--details", "print every setup step and the per-assistant integration status")
     .action((opts) => {
     // Validate --firmness up front, before any side effects (indexing, git hooks,
     // .mcp.json) or opening the store — a bad value must not leave a half-init.
@@ -367,32 +369,51 @@ program
     // teammate/agent resolves the same single source of truth with zero manual setup.
     const { store, teamWired } = openTeamStore(root);
     const inv = resolveInvocation();
-    console.log(`🧠 Initializing Hunch at ${root}`);
+    // Step lines are collected: the default output is a short summary with one next
+    // step; `--details` prints every step as written. Warnings always print.
+    const lines = [];
+    const say = (text) => { lines.push({ text, warn: text.includes("⚠") }); };
+    // A hook warning is followed by the snippet to add by hand: keep the group together.
+    const sayHook = (group, installed) => {
+        const warn = group.some((l) => l.includes("⚠"));
+        for (const text of group)
+            lines.push({ text, warn });
+        if (!warn)
+            summary.hooks.push(installed);
+    };
+    const summary = { index: "", hooks: [], assistants: ["Claude Code"], skipped: [] };
+    say(`🧠 Initializing Hunch at ${root}`);
     store.json.ensureDirs(); // stamps the manifest at the current version when fresh
-    console.log(`  ✓ .hunch/ scaffolded (schema v${readManifest(paths).schema_version})`);
+    say(`  ✓ .hunch/ scaffolded (schema v${readManifest(paths).schema_version})`);
     if (teamWired)
-        console.log(`  ✓ connected to the team's shared memory store (from .hunch/team.json) → ${teamWired}`);
+        say(`  ✓ connected to the team's shared memory store (from .hunch/team.json) → ${teamWired}`);
     // Exclude the derived SQLite index BEFORE it's written, so the working tree
     // never goes dirty on the MCP server's index writes (which blocks branch
     // switches). The .hunch/*.json graph stays tracked.
     const gi = ensureGitignore(root);
     if (gi.action !== "unchanged")
-        console.log(`  ✓ .gitignore ${gi.action} (Hunch runtime index excluded)`);
+        say(`  ✓ .gitignore ${gi.action} (Hunch runtime index excluded)`);
     // A repo migrated to a private overlay by an older release: bring its private-only
     // block up to date (and stop publishing newly ignored memory dirs).
     for (const line of describeGitignoreUpgrade(upgradeManagedGitignore(root)))
-        console.log(`  ✓ ${line}`);
+        say(`  ✓ ${line}`);
+    if (!store.privateDir) {
+        const ignored = memoryIgnoreRule(root);
+        if (ignored)
+            say(`  ⚠ ${describeMemoryIgnoreRule(ignored)}`);
+    }
     if (opts.index !== false) {
         if (isGitRepo(root) && revExists("HEAD", root)) {
             const res = indexRepo(store, root, { source: { kind: "commit", ref: "HEAD" } });
             store.reindex();
-            console.log(`  ✓ indexed committed HEAD (${res.files} files) → ${res.symbols} symbols, ${res.edges} edges, ${res.components} components`);
+            say(`  ✓ indexed committed HEAD (${res.files} files) → ${res.symbols} symbols, ${res.edges} edges, ${res.components} components`);
+            summary.index = `indexed committed HEAD (${res.files} files, ${res.symbols} symbols)`;
             for (const item of res.coverage) {
                 const reasons = Object.entries(item.reasons).map(([reason, count]) => `${reason}:${count}`).join(", ");
-                console.log(`    coverage ${item.language}: ${item.eligible} eligible · ${item.parsed} parsed · ${item.skipped} skipped${reasons ? ` (${reasons})` : ""}`);
+                say(`    coverage ${item.language}: ${item.eligible} eligible · ${item.parsed} parsed · ${item.skipped} skipped${reasons ? ` (${reasons})` : ""}`);
             }
             if (res.skipped)
-                console.log(`  ⚠ ${res.skipped} file(s) could not be parsed (skipped)`);
+                say(`  ⚠ ${res.skipped} file(s) could not be parsed (skipped)`);
         }
         else {
             // A checkout-derived graph can be swept into a later memory commit by
@@ -402,7 +423,7 @@ program
             store.json.replaceAll("edges", mergeScannedEdges(store.json.loadAll("edges"), []));
             store.json.replaceAll("components", []);
             store.reindex();
-            console.log("  ⚠ skipped code graph: no committed HEAD — commit code, then run `hunch index`");
+            say("  ⚠ skipped code graph: no committed HEAD — commit code, then run `hunch index`");
         }
     }
     // Auto-commit is ON by default in every mode; --no-auto-commit persists the opt-out in
@@ -424,11 +445,11 @@ program
             }
         }
         if (existing === null) {
-            console.warn(`  ⚠ refusing to rewrite ${localFile}: it is not a JSON object and may hold your private-overlay pointer. Fix or remove it, then re-run \`hunch init --no-auto-commit\`.`);
+            say(`  ⚠ refusing to rewrite ${localFile}: it is not a JSON object and may hold your private-overlay pointer. Fix or remove it, then re-run \`hunch init --no-auto-commit\`.`);
         }
         else {
             writeFileAtomic(localFile, JSON.stringify({ ...existing, autoCommit: false }, null, 2) + "\n");
-            console.log("  ✓ local auto-commit preference OFF (an explicit hook --commit flag still takes precedence)");
+            say("  ✓ local auto-commit preference OFF (an explicit hook --commit flag still takes precedence)");
         }
     }
     // Collected so the linked-worktree note below can say what actually happened
@@ -446,21 +467,18 @@ program
         }
         const h = installPostCommitHook(root, inv.shell, { private: syncToOverlay, commit: hookCommit, localOnly: syncToOverlay });
         installs.push(h);
-        for (const line of formatHookInstall(root, "post-commit hook", h, ` (learning loop)${syncToOverlay ? " — syncs to the shared overlay" : ""}${hookCommit ? " — auto-commit on" : ""}`))
-            console.log(line);
+        sayHook(formatHookInstall(root, "post-commit hook", h, ` (learning loop)${syncToOverlay ? " — syncs to the shared overlay" : ""}${hookCommit ? " — auto-commit on" : ""}`), hookCommit ? "post-commit (auto-commit on)" : "post-commit");
         if (opts.autoCommit === false && hookReport(root).postCommit.flags?.includes("--commit")) {
-            console.log("  ⚠ the shared post-commit hook still auto-commits. To change it, re-run `hunch init --no-auto-commit` using a global install or the main checkout's Hunch.");
+            say("  ⚠ the shared post-commit hook still auto-commits. To change it, re-run `hunch init --no-auto-commit` using a global install or the main checkout's Hunch.");
         }
         const pm = installPostMergeHook(root, inv.shell);
         installs.push(pm);
-        for (const line of formatHookInstall(root, "post-merge hook", pm, " (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)"))
-            console.log(line);
+        sayHook(formatHookInstall(root, "post-merge hook", pm, " (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)"), "post-merge");
         const pc = installPostCheckoutHook(root, inv.shell);
         installs.push(pc);
-        for (const line of formatHookInstall(root, "post-checkout hook", pc, " (workspace ledger: records this machine's branches + worktrees on checkout)"))
-            console.log(line);
+        sayHook(formatHookInstall(root, "post-checkout hook", pc, " (workspace ledger: records this machine's branches + worktrees on checkout)"), "post-checkout");
         const m = installMergeDriver(root, inv.shell);
-        console.log(`  ✓ team merge driver ${m.action}`);
+        say(`  ✓ team merge driver ${m.action}`);
         // Auto-install the pre-commit guard by default (advisory: flags invariants
         // touched directly OR via blast radius, never blocks). Opt out with
         // --no-enforce; --enforce-strict makes blocking near/direct hits fail the commit.
@@ -468,12 +486,11 @@ program
             const strict = !!opts.enforceStrict;
             const p = installPreCommitHook(root, inv.shell, strict);
             installs.push(p);
-            for (const line of formatHookInstall(root, "pre-commit constraint guard", p, ` (${strict ? "strict — fails only on direct, high-confidence, non-stale blocking invariants" : "advisory — flags invariants in scope or blast radius"})`))
-                console.log(line);
+            sayHook(formatHookInstall(root, "pre-commit constraint guard", p, ` (${strict ? "strict — fails only on direct, high-confidence, non-stale blocking invariants" : "advisory — flags invariants in scope or blast radius"})`), `pre-commit guard (${strict ? "strict" : "advisory"})`);
         }
     }
     else {
-        console.log("  ⚠ not a git repo — skipped hooks (run `git init` to enable the learning loop)");
+        say("  ⚠ not a git repo — skipped hooks (run `git init` to enable the learning loop)");
     }
     // .mcp.json is the CANONICAL registration: Claude Code resolves it by file path,
     // so it's immune to the Windows ~/.claude.json drive-letter case-split that a
@@ -481,18 +498,18 @@ program
     // existing file is refused (con_8460b6770f) — warn and continue, never clobber.
     try {
         const mcp = writeMcpJson(root, inv.mcp);
-        console.log(`  ✓ wrote ${rel(root, mcp)} (registers the Hunch MCP server — canonical, path-keyed; prefer over a global \`claude mcp add\`)`);
+        say(`  ✓ wrote ${rel(root, mcp)} (registers the Hunch MCP server — canonical, path-keyed; prefer over a global \`claude mcp add\`)`);
     }
     catch (e) {
-        console.log(`  ⚠ skipped .mcp.json: ${e.message}`);
+        say(`  ⚠ skipped .mcp.json: ${e.message}`);
     }
     const cmds = writeSlashCommands(root);
-    console.log(`  ✓ wrote ${cmds.written.length} slash commands (/hunch-why, /hunch-fix, /hunch-fragile, /capture, /heal, /audit)`);
+    say(`  ✓ wrote ${cmds.written.length} slash commands (/hunch-why, /hunch-fix, /hunch-fragile, /capture, /heal, /audit)`);
     for (const s of cmds.skipped) {
-        console.log(`  ⚠ kept your existing ${rel(root, s)} (no hunch:generated marker — delete the file and re-run init to adopt Hunch's version)`);
+        say(`  ⚠ kept your existing ${rel(root, s)} (no hunch:generated marker — delete the file and re-run init to adopt Hunch's version)`);
     }
     const cmd = updateClaudeMd(root, store);
-    console.log(`  ✓ updated ${rel(root, cmd)} with ambient Hunch context`);
+    say(`  ✓ updated ${rel(root, cmd)} with ambient Hunch context`);
     // Firmness: stamp .hunch/config.json (default advisory) so `hunch hook` reads a
     // level even before the user runs `hunch firmness` (--firmness validated above).
     const firmness = writeConfig(paths, opts.firmness ? { firmness: opts.firmness } : {}).firmness;
@@ -500,18 +517,25 @@ program
     // adapter reads firmness at run time, so changing it needs no config rewrite.
     if (opts.agentHooks !== false) {
         const a = installClaudeHooks(root, `${inv.agentHookShell} hook`);
-        console.log(`  ✓ Claude Code agent hooks ${a.action} (firmness: ${firmness} — change with \`hunch firmness <level>\`)`);
+        say(`  ✓ Claude Code agent hooks ${a.action} (firmness: ${firmness} — change with \`hunch firmness <level>\`)`);
     }
     // Multi-assistant compatibility: MCP + grounding + lifecycle adapters share
     // the same .hunch/ graph across Cursor / VS Code / Windsurf / Antigravity.
     if (opts.providers !== false) {
-        const ps = scaffoldProviders(root, inv.mcp, store, { agentHooks: opts.agentHooks !== false });
+        const detected = detectAssistants(root);
+        const only = opts.allAssistants || detected.size === 0 ? undefined : detected;
+        const ps = scaffoldProviders(root, inv.mcp, store, { agentHooks: opts.agentHooks !== false, only });
         const ok = ps.filter((p) => !p.error);
+        summary.assistants.push(...ok.map((p) => p.assistant === "Any (AGENTS.md)" ? "any tool that reads AGENTS.md" : p.assistant));
+        if (only)
+            summary.skipped = PROVIDER_ASSISTANTS.filter((a) => !only.has(a));
+        if (summary.skipped.length)
+            say(`  ✓ not configured (not found on this machine or in this repository): ${summary.skipped.join(", ")} — add them with \`hunch init --all-assistants\``);
         const total = ok.reduce((a, p) => a + p.files.length, 0);
-        console.log(`  ✓ wrote ${total} multi-assistant config file(s) → ${ok.map((p) => p.assistant).join(", ")}`);
+        say(`  ✓ wrote ${total} multi-assistant config file(s) → ${ok.map((p) => p.assistant).join(", ")}`);
         for (const p of ps)
             if (p.error)
-                console.log(`  ⚠ skipped ${p.assistant}: ${p.error}`);
+                say(`  ⚠ skipped ${p.assistant}: ${p.error}`);
     }
     // Windows self-heal: if an earlier global `claude mcp add` left a drive-letter
     // case-split in ~/.claude.json, merge it so hunch resolves under either casing.
@@ -521,16 +545,36 @@ program
     // worktree of this repo auto-discovers it (also backfills pre-0.32 single-worktree setups),
     // and note when we're initializing inside a linked worktree (memory is shared, not separate).
     if (ensureSharedOverlayPointer(root, store.privateDir, store.privateAutoCommit, store.mode === "shared" ? "shared" : "private", true)) {
-        console.log(`  ✓ private overlay registered at the git common dir — shared by every worktree of this repo`);
+        say(`  ✓ private overlay registered at the git common dir — shared by every worktree of this repo`);
     }
     for (const line of sharedHooksNote(root, installs))
-        console.log(line);
+        say(line);
     store.close();
-    console.log("\n" + formatIntegrationHealth(inspectIntegrations(root)));
-    console.log("\nTask reporting is configured through Hunch's agent instructions; actual agent activity has not been verified by setup. Reconnect the agent, then work normally. Completed task reports are available with `hunch report`.");
-    console.log(reportActivity(root));
-    console.log("Cold start? Seed from history:  hunch backfill --since 90d");
-    console.log("\n⭐ If Hunch earns its keep, a star helps others find it → https://github.com/davesheffer/hunch");
+    if (opts.details) {
+        for (const l of lines)
+            console.log(l.text);
+        console.log("\n" + formatIntegrationHealth(inspectIntegrations(root)));
+        console.log("\nTask reporting is configured through Hunch's agent instructions; actual agent activity has not been verified by setup. Reconnect the agent, then work normally. Completed task reports are available with `hunch report`.");
+        console.log(reportActivity(root));
+        console.log("Cold start? Seed from history:  hunch backfill --since 90d");
+        console.log("\n⭐ If Hunch earns its keep, a star helps others find it → https://github.com/davesheffer/hunch");
+        return;
+    }
+    console.log(`🧠 Hunch is set up in ${root}`);
+    console.log(`  ✓ memory: .hunch/${teamWired ? ` (connected to your team's shared store)` : ""}`);
+    if (summary.index)
+        console.log(`  ✓ code index: ${summary.index}`);
+    if (summary.hooks.length)
+        console.log(`  ✓ git hooks: ${summary.hooks.join(", ")}`);
+    console.log(`  ✓ assistants: ${summary.assistants.join(", ")}`);
+    if (summary.skipped.length)
+        console.log(`    not found here, so not configured: ${summary.skipped.join(", ")} (add with --all-assistants)`);
+    for (const l of lines)
+        if (l.warn)
+            console.log(l.text);
+    console.log("\nNext: reload your assistant, then ask it why a file you're about to change is built that way.");
+    console.log("No memory yet? Draft it from this repository's history: hunch backfill --since 90d");
+    console.log("More: hunch init --details (everything that was written) · hunch doctor (check the setup)");
 });
 // ---- uninstall ------------------------------------------------------------
 program
@@ -5190,6 +5234,16 @@ program
                 }
             }
             catch { /* the next Stop or prompt retries */ }
+            // Escalations this prompt's task touches (dec_12ba37db1c): asked once per
+            // session, never answered for the human; the rest stay pending in
+            // `hunch escalations`. A broken store must not take the prompt hook down.
+            try {
+                store ??= new HunchStore(paths);
+                const ask = await promptEscalations(root, store, provider, evt);
+                if (ask)
+                    parts.push(ask);
+            }
+            catch { /* escalations stay listed by `hunch escalations` */ }
             // Pipeline turn bookkeeping (fresh block budget) + the one nag that must
             // repeat: edits from an earlier turn still unverified.
             if (evt.session_id && pipelineEnabled()) {
@@ -5351,36 +5405,17 @@ program
                 // further than a terminal.
                 const decisions = s.advisoryRecs("decisions");
                 const { pendingReview } = nowData(decisions, 3);
-                const escalations = pendingEscalations(decisions);
-                escalations.push(...premiseEscalations(decisions, { now: new Date().toISOString(), exists: (p) => existsSync(join(paths.root, p)) }));
-                // liveness checked against the full store even in private mode — a
-                // private-overlay decision's repair is fully answerable via
-                // `hunch repair-provenance` (which reads the full store), so it
-                // must not go silently unanswerable just because its title stays
-                // out of session transcripts. Only the id and commit shas surface.
-                const sessionStartQueue = readActivePendingRepairs(paths.root);
-                escalations.push(...commitRepairEscalations(sessionStartQueue, decisions, s.recs("decisions"), withheldRewrites(paths.root, sessionStartQueue)));
-                try {
-                    // Constitution human moments ride the same line; a broken policy store
-                    // must never take session-start orientation down (fail open). Public
-                    // store only — session transcripts travel further than a terminal.
-                    const { ConstitutionService: CS } = await import("../constitution/service.js");
-                    escalations.push(...policyEscalations(new CS(s, paths.root).list({ publicOnly: true }).map((p) => ({ ...p, last_action: p.audit.at(-1)?.action ?? null }))));
-                }
-                catch { /* constitution unavailable */ }
-                // Only ACTIONABLE entries are worth asking inline — a duplicate-id
-                // commit-repair follower whose own resolution says "act on a
-                // different entry first" isn't a question the assistant can put to
-                // the human directly (#61). Filtered BEFORE the bail check below so
-                // "is there anything to say" and "what do we say" share one
-                // predicate — an escalations list that's entirely non-actionable
-                // must bail exactly like an empty one would.
-                const actionableEsc = actionableEscalations(escalations);
+                // Escalations are task-scoped (dec_12ba37db1c): session start has no task
+                // yet, so it asks nothing when the provider delivers prompts — the prompt
+                // hook asks about the ones a prompt touches; every entry stays pending in
+                // `hunch escalations`. A provider with no prompt event would never ask,
+                // so its orientation event keeps asking every actionable entry.
+                const actionableEsc = deliversPromptEvent(provider) ? [] : (await actionableEscalationsWithAnchors(paths.root, s)).actionable;
                 if (!decisions.length && !actionableEsc.length) {
                     // Fresh graph and nothing else to raise: nothing to orient on, but
                     // the operating loop still ships. A queued commit-repair escalation
-                    // (checked against the full store above) is enough reason NOT to
-                    // bail here even when the visible decisions list is empty.
+                    // (checked against the full store) is enough reason NOT to bail here
+                    // even when the visible decisions list is empty.
                     if (pipelineEnabled())
                         emitContext(provider, "SessionStart", [PIPELINE_LOOP, controllerBrief].filter(Boolean).join("\n\n"));
                     return;
@@ -7501,6 +7536,9 @@ program
         console.log(team
             ? `overlay:    off, but .hunch/team.json advertises the team store (${team.shared_repo}) — ${isTeamStoreTrusted(root, team) ? "run \`hunch init\` to auto-connect" : "if it is your team's store, run \`hunch shared --trust\` to connect"}`
             : dim(`private:    off — run \`hunch shared\` (or \`hunch private\`) to use one overlay repo across teammates/worktrees (or set HUNCH_PRIVATE_DIR)`));
+        const ignored = memoryIgnoreRule(root);
+        if (ignored)
+            console.log(`memory:     ⚠ ${describeMemoryIgnoreRule(ignored)}`);
     }
     // Worktree posture: linked worktrees share ONE memory via the git common dir. Only
     // surfaced in a linked worktree (no noise in a normal single checkout), so a
@@ -7625,6 +7663,51 @@ function shellWriteGrounding(root, store, provider, evt, written) {
  *  A follow-up prompt widens the qualifying set rather than replacing it, so a
  *  "go" cannot unselect the task's memory. */
 const TASK_SELECTION_TITLE_CHARS = 80;
+/** Every actionable escalation plus each entry id's anchor paths (a decision's
+ *  related_files, a policy's scope paths/globs). Titles come from the advisory
+ *  scope (public-only in private mode: session transcripts travel further than
+ *  a terminal); commit-repair liveness and the anchors read the full store, so a
+ *  private decision's repair stays answerable by id. */
+async function actionableEscalationsWithAnchors(root, store) {
+    const decisions = store.advisoryRecs("decisions");
+    const all = store.recs("decisions");
+    const anchors = new Map(all.map((d) => [d.id, d.related_files]));
+    const escalations = pendingEscalations(decisions);
+    escalations.push(...premiseEscalations(decisions, { now: new Date().toISOString(), exists: (p) => existsSync(join(root, p)) }));
+    const queue = readActivePendingRepairs(root);
+    escalations.push(...commitRepairEscalations(queue, decisions, all, withheldRewrites(root, queue)));
+    try {
+        // Constitution human moments ride the same line; a broken policy store must
+        // never take the hook down (fail open). Public store only.
+        const { ConstitutionService: CS } = await import("../constitution/service.js");
+        const policies = new CS(store, root).list({ publicOnly: true });
+        for (const p of policies)
+            anchors.set(p.id, p.scope.paths);
+        escalations.push(...policyEscalations(policies.map((p) => ({ ...p, last_action: p.audit.at(-1)?.action ?? null }))));
+    }
+    catch { /* constitution unavailable */ }
+    // Only ACTIONABLE entries are worth asking inline — a duplicate-id commit-repair
+    // follower whose resolution says "act on a different entry first" isn't a
+    // question the assistant can put to the human directly (#61).
+    return { actionable: actionableEscalations(escalations), anchors };
+}
+/** The ASK line for the escalations one prompt touches, or "" (dec_12ba37db1c). */
+async function promptEscalations(root, store, provider, evt) {
+    if (!evt.prompt || isNotificationPrompt(evt.prompt))
+        return "";
+    const { actionable, anchors } = await actionableEscalationsWithAnchors(root, store);
+    if (!actionable.length)
+        return "";
+    // A qualifying record outside the top-K is still part of this task.
+    const selection = loadTaskSelection(hookReportTaskId(root, provider, evt));
+    const selectedIds = new Set([...(selection?.top ?? []), ...(selection?.qualifying ?? [])]);
+    const relevant = relevantEscalations(actionable, { prompt: evt.prompt, paths: promptPaths(evt.prompt, root), selectedIds }, (id) => anchors.get(id) ?? []);
+    // Each question is asked once per session, however the touched set changes.
+    const unasked = relevant.filter((e) => injectionMode(evt.session_id, `prompt-escalation:${e.kind}:${e.topic}:${e.decisionIds.join(",")}`, e.question) === "full");
+    if (!unasked.length)
+        return "";
+    return `⚖ ${unasked.length} decision(s) this task touches need the human's call — ASK the user inline, never decide for them: ${unasked.map((e) => e.question).join(" · ")}`;
+}
 function promptTaskSelection(root, store, provider, evt) {
     // A host notification is not a task prompt: the earlier selection stands untouched.
     if (!taskSelectionEnabled() || isNotificationPrompt(evt.prompt))

package/dist/core/agenthook.d.ts

@@ -7,6 +7,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 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

@@ -6,6 +6,17 @@
  * the same small, fail-open shape regardless of the assistant that emitted it.
  */
 export const HOOK_PROVIDERS = ["claude", "codex", "vscode", "windsurf", "antigravity", "cursor"];
+/** Whether a provider's hooks deliver the user's prompt text (a UserPromptSubmit
+ * equivalent). Prompt-scoped behavior needs it; a provider without one gets that
+ * behavior at its session/orientation event instead. Antigravity's PreInvocation
+ * payload carries only conversation/invocation counters, no turn text. A Record,
+ * so a new provider must declare its answer. */
+const PROMPT_EVENT = {
+    claude: true, codex: true, vscode: true, windsurf: true, cursor: true, antigravity: false,
+};
+export function deliversPromptEvent(provider) {
+    return PROMPT_EVENT[provider];
+}
 function obj(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }

package/dist/core/escalations.d.ts

@@ -127,3 +127,23 @@ export interface PolicyLite {
  *  accept/reject) is a human call. Machine conclusions never appear here as
  *  approvals — every entry is a QUESTION with its explicit resolution verb. */
 export declare function policyEscalations(policies: readonly PolicyLite[]): Escalation[];
+/** What one prompt is about, for task-scoped escalation delivery (dec_12ba37db1c). */
+export interface EscalationScope {
+    /** the prompt text as the human wrote it. */
+    prompt: string;
+    /** repo-relative paths the prompt names (taskSelection.promptPaths). */
+    paths: readonly string[];
+    /** record ids the prompt's task selection put on top, when there is one. */
+    selectedIds?: ReadonlySet<string>;
+}
+/** The escalations one prompt's task touches. A prompt hook asks the human only
+ *  about these; every other entry stays exactly as pending — still listed by
+ *  `hunch escalations`, hunch_escalations and hunch_now, never dropped and
+ *  never answered for the human. Deterministic explicit anchors only: a
+ *  prompt that asks about escalations themselves (path tokens aside), an entry
+ *  id or topic the prompt names, an id the task selection chose, or a recorded
+ *  anchor path the prompt names (a directory covers the files under it; a glob
+ *  covers the paths it matches). `relatedFiles` maps an entry id to its anchor
+ *  paths: a decision's related_files, a policy's scope paths/globs. An entry
+ *  with no anchor the prompt names stays CLI/MCP-only. */
+export declare function relevantEscalations(items: readonly Escalation[], scope: EscalationScope, relatedFiles: (id: string) => readonly string[]): Escalation[];

package/dist/core/escalations.js

@@ -1,6 +1,7 @@
 import { topicCollisions } from "./topics.js";
 import { liveRewrites, deadRewrites, commitRepairReviewHash, firstFor } from "./commitrepair.js";
 import { importedAdrReviewHash, importedAdrSourceHash, pendingImportedAdrReviews } from "./importReview.js";
+import { pathMatchesGlob } from "./glob.js";
 /** Escalations gating surfaces (CI exit codes, "needs your call" counts/lists)
  *  should act on: everything except an entry explicitly marked
  *  actionable:false (#61). The full list — including non-actionable
@@ -259,4 +260,50 @@ export function policyEscalations(policies) {
     }
     return out;
 }
+const trimSlash = (x) => x.replace(/\/+$/, "");
+const samePathOrNested = (x, y) => {
+    const a = trimSlash(x), b = trimSlash(y);
+    return !!a && !!b && (a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`));
+};
+/** A recorded related path or scope glob vs a path the prompt names. A plain
+ *  entry relates both ways by directory nesting; a glob entry matches a path it
+ *  covers, or a directory that holds its literal prefix (`src/` ~ `src/store/**`). */
+const relatedPathHit = (entry, promptPath) => {
+    if (!/[*?]/.test(entry))
+        return samePathOrNested(entry, promptPath);
+    if (pathMatchesGlob(promptPath, entry))
+        return true;
+    const literal = trimSlash(entry.split("/").filter((_, i, segs) => !segs.slice(0, i + 1).some((s) => /[*?]/.test(s))).join("/"));
+    const dir = trimSlash(promptPath);
+    return !!literal && !!dir && (literal === dir || literal.startsWith(`${dir}/`));
+};
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** The prompt's prose without path-like tokens (a `/` or a file extension), so a
+ *  file named `escalations.test.ts` is not a question about escalations. */
+const proseOnly = (prompt) => prompt.split(/\s+/).filter((t) => { const w = t.replace(/[)\],.;:!?'"`]+$/, ""); return !w.includes("/") && !/\.[a-z0-9]{1,8}$/i.test(w); }).join(" ");
+/** The escalations one prompt's task touches. A prompt hook asks the human only
+ *  about these; every other entry stays exactly as pending — still listed by
+ *  `hunch escalations`, hunch_escalations and hunch_now, never dropped and
+ *  never answered for the human. Deterministic explicit anchors only: a
+ *  prompt that asks about escalations themselves (path tokens aside), an entry
+ *  id or topic the prompt names, an id the task selection chose, or a recorded
+ *  anchor path the prompt names (a directory covers the files under it; a glob
+ *  covers the paths it matches). `relatedFiles` maps an entry id to its anchor
+ *  paths: a decision's related_files, a policy's scope paths/globs. An entry
+ *  with no anchor the prompt names stays CLI/MCP-only. */
+export function relevantEscalations(items, scope, relatedFiles) {
+    const prompt = scope.prompt ?? "";
+    if (/(?:^|[^a-z0-9-])escalations?(?:$|[^a-z0-9])/i.test(proseOnly(prompt)))
+        return [...items];
+    const lower = prompt.toLowerCase();
+    const named = (term) => {
+        const t = term.trim().toLowerCase();
+        if (t.length < 3)
+            return false;
+        return new RegExp(`(?:^|[^a-z0-9_-])${escapeRegExp(t)}(?:$|[^a-z0-9_-])`).test(lower);
+    };
+    return items.filter((e) => named(e.topic)
+        || e.decisionIds.some((id) => named(id) || scope.selectedIds?.has(id))
+        || e.decisionIds.some((id) => relatedFiles(id).some((file) => scope.paths.some((p) => relatedPathHit(file, p)))));
+}
 //# sourceMappingURL=escalations.js.map

package/dist/core/hookText.js

@@ -4,5 +4,5 @@
 export const HOOK_REMINDER = "Hunch (engineering memory) is available for this repo. Before editing, call " +
     "hunch_check_constraints(scope) for do-not-break invariants and hunch_why(target) " +
     "for the rationale; use hunch_get_dependents for blast radius and hunch_bug_lineage " +
-    "for prior root causes. After a non-trivial choice, record it with hunch_record_decision.";
+    "for prior root causes. Record only what the human decides or corrects.";
 //# sourceMappingURL=hookText.js.map

package/dist/integrations/claudemd.js

@@ -98,7 +98,7 @@ export function renderHunchSection(store, root) {
     lines.push("This repo has **Hunch**, a graph of *why* the code is the way it is. It holds " +
         `${renderCountsMatch(counts)}. Use the \`hunch_*\` MCP tools by moment:`);
     lines.push("");
-    lines.push("- **Start:** reuse the task ID and `task verify` command the prompt hook printed; with none, call `hunch_task(action: \"start\", title)` once. Then `hunch_context(target, task_id)` first. Orient with `hunch_structure`, `hunch_workspaces`, `hunch_runbook(task)`. Ask the user about each `hunch_escalations()` entry; silence is never approval.");
+    lines.push("- **Start:** reuse the task ID and `task verify` command the prompt hook printed; with none, call `hunch_task(action: \"start\", title)` once. Then `hunch_context(target, task_id)` first. Orient with `hunch_structure`, `hunch_workspaces`, `hunch_runbook(task)`. When the prompt hook raises an escalation this task touches, ask the user; silence is never approval. `hunch_escalations()` lists the rest.");
     lines.push("- **Design:** `hunch_why(target)` (includes what was rejected), `hunch_current_decision(topic)`, `hunch_bug_lineage(symptom_or_symbol)`, `hunch_compare(candidates)`, `hunch_query(query)`.");
     lines.push("- **Edit:** `hunch_check_constraints(scope)`, `hunch_get_dependents(symbol)` / `hunch_blast_radius(target)`, `hunch_findings(scope?)`.");
     lines.push("- **Merge:** `hunch_conformance()`, `hunch_pr_impact(base?)`, `hunch_merge_verdict`." +

package/dist/integrations/gitignore.d.ts

@@ -39,6 +39,22 @@ export interface ManagedGitignoreUpgrade {
 export declare function upgradeManagedGitignore(root: string): ManagedGitignoreUpgrade;
 /** Output lines describing what an upgrade changed; empty when nothing did. */
 export declare function describeGitignoreUpgrade(upgrade: ManagedGitignoreUpgrade): string[];
+export interface MemoryIgnoreRule {
+    /** Ignore file that holds the rule, as git reports it (e.g. `.gitignore`). */
+    source: string;
+    /** 1-based line of the rule in `source`. */
+    line: number;
+    pattern: string;
+}
+/** The user's ignore rule that keeps engineering memory out of Git, or null.
+ *  A repository that ignores `.hunch/` (or `.hunch/decisions/`) silently loses every
+ *  capture: the records are written, never committed, and gone on a fresh clone.
+ *  Hunch's own private-only block ignores the same paths on purpose (memory lives
+ *  in an overlay), so a rule inside that block is not reported. Unknown git state
+ *  yields null: the caller then says nothing rather than guessing. */
+export declare function memoryIgnoreRule(root: string): MemoryIgnoreRule | null;
+/** One line telling the user their memory will not reach Git, and how to fix it. */
+export declare function describeMemoryIgnoreRule(rule: MemoryIgnoreRule): string;
 /** `.gitignore` text with both managed Hunch blocks removed (markers inclusive),
  *  every other byte kept, for `hunch uninstall --purge` (#449). `damaged` when a
  *  marker line has no matching end line: the block is never guessed at. */