@davesheffer/hunch 1.44.0 → 1.45.0

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. */

package/dist/integrations/gitignore.js

@@ -12,6 +12,7 @@
  * block written by an older release gains entries added later) and is otherwise
  * byte-identical; everything outside the markers is left untouched.
  */
+import { spawnSync } from "node:child_process";
 import { readFileSync, existsSync, lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { writeFileAtomic } from "../core/io.js";
@@ -231,6 +232,35 @@ export function describeGitignoreUpgrade(upgrade) {
     }
     return out;
 }
+/** 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 function memoryIgnoreRule(root) {
+    const probe = ".hunch/decisions/dec_0000000000.json";
+    const r = spawnSync("git", ["check-ignore", "-v", "--no-index", "--", probe], { cwd: root, encoding: "utf8", windowsHide: true });
+    if (r.error || r.status !== 0)
+        return null;
+    const m = /^(.*):(\d+):(.*)\t/.exec(r.stdout ?? "");
+    if (!m)
+        return null;
+    const rule = { source: m[1], line: Number(m[2]), pattern: m[3] };
+    if (rule.pattern.startsWith("!"))
+        return null;
+    const file = resolve(root, rule.source);
+    if (existsSync(file)) {
+        const span = findBlock(readFileSync(file, "utf8").split("\n"), MEM_MARK, MEM_END);
+        if (span && rule.line - 1 > span.start && rule.line - 1 < span.end)
+            return null;
+    }
+    return rule;
+}
+/** One line telling the user their memory will not reach Git, and how to fix it. */
+export function describeMemoryIgnoreRule(rule) {
+    return `${rule.source} line ${rule.line} (\`${rule.pattern}\`) ignores .hunch/, so captured memory is never committed or shared and is lost on a fresh clone. Remove that line, or keep memory in a private repository with \`hunch private --repo <url>\`.`;
+}
 /** `.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. */

package/dist/integrations/providers.d.ts

@@ -115,7 +115,16 @@ export interface ProviderScaffold {
  *  per-assistant summary for `hunch init` to print. Each assistant is isolated:
  *  a writer that refuses to clobber a malformed file degrades to a warning rather
  *  than aborting the rest. Claude Code is handled separately by scaffold.ts. */
+/** The assistants `scaffoldProviders` can configure, besides the always-written AGENTS.md. */
+export declare const PROVIDER_ASSISTANTS: readonly ["Cursor", "VS Code (Copilot)", "Codex CLI", "Windsurf", "Google Antigravity"];
+export type ProviderAssistant = typeof PROVIDER_ASSISTANTS[number];
+/** Assistants with a footprint here: a config already in the repository (a teammate
+ *  set it up), a settings folder in the user's home, or a command on PATH. `hunch init`
+ *  configures only these, so a repository is not filled with settings for tools nobody
+ *  on it uses; when none is found it configures every assistant, as before. */
+export declare function detectAssistants(root: string, home?: string, env?: NodeJS.ProcessEnv): Set<ProviderAssistant>;
 export declare function scaffoldProviders(root: string, inv: Invocation, store: HunchStore, options?: {
     agentHooks?: boolean;
     home?: string;
+    only?: ReadonlySet<string>;
 }): ProviderScaffold[];

package/dist/integrations/providers.js

@@ -20,7 +20,7 @@
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { writeFileAtomic } from "../core/io.js";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, delimiter } from "node:path";
 import { isHunchHookCommand } from "./hookmatch.js";
 import { renderHunchSection, stripManagedSection, upsertSection, updateClaudeMd, preserveNewerTemplate } from "./claudemd.js";
 import { headFileContent, isGitCleanPath } from "../extractors/git.js";
@@ -560,6 +560,32 @@ function runProvider(writers) {
  *  per-assistant summary for `hunch init` to print. Each assistant is isolated:
  *  a writer that refuses to clobber a malformed file degrades to a warning rather
  *  than aborting the rest. Claude Code is handled separately by scaffold.ts. */
+/** The assistants `scaffoldProviders` can configure, besides the always-written AGENTS.md. */
+export const PROVIDER_ASSISTANTS = ["Cursor", "VS Code (Copilot)", "Codex CLI", "Windsurf", "Google Antigravity"];
+function onPath(names, env) {
+    const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").concat("") : [""];
+    return dirs.some((dir) => names.some((name) => exts.some((ext) => existsSync(join(dir, name + ext)))));
+}
+/** Assistants with a footprint here: a config already in the repository (a teammate
+ *  set it up), a settings folder in the user's home, or a command on PATH. `hunch init`
+ *  configures only these, so a repository is not filled with settings for tools nobody
+ *  on it uses; when none is found it configures every assistant, as before. */
+export function detectAssistants(root, home = homedir(), env = process.env) {
+    const has = (...paths) => paths.some((p) => existsSync(p));
+    const found = new Set();
+    if (has(join(root, ".cursor"), join(home, ".cursor")) || onPath(["cursor", "cursor-agent"], env))
+        found.add("Cursor");
+    if (has(join(root, ".vscode"), join(root, ".github", "copilot-instructions.md"), join(home, ".vscode")) || onPath(["code", "code-insiders"], env))
+        found.add("VS Code (Copilot)");
+    if (has(join(root, ".codex"), join(home, ".codex")) || onPath(["codex"], env))
+        found.add("Codex CLI");
+    if (has(join(root, ".windsurf"), join(home, ".codeium", "windsurf")) || onPath(["windsurf"], env))
+        found.add("Windsurf");
+    if (has(join(root, ".agents", "mcp_config.json"), join(home, ".gemini")) || onPath(["antigravity"], env))
+        found.add("Google Antigravity");
+    return found;
+}
 export function scaffoldProviders(root, inv, store, options = {}) {
     const hooks = options.agentHooks !== false;
     const home = options.home;
@@ -584,6 +610,9 @@ export function scaffoldProviders(root, inv, store, options = {}) {
             }],
         ["Any (AGENTS.md)", () => runProvider([() => writeAgentsMd(root, store)])],
     ];
-    return tasks.map(([assistant, run]) => ({ assistant, ...run() }));
+    const only = options.only;
+    return tasks
+        .filter(([assistant]) => !only || only.has(assistant) || assistant === "Any (AGENTS.md)")
+        .map(([assistant, run]) => ({ assistant, ...run() }));
 }
 //# sourceMappingURL=providers.js.map

package/dist/integrations/scaffold.js

@@ -62,7 +62,7 @@ Follow the Hunch-grounded workflow (DESIGN §5) — do NOT skip the memory looku
 2. Identify the suspect symbol/file, then \`hunch_get_dependents(<symbol>)\` to learn the blast radius.
 3. \`hunch_check_constraints(<scope>)\` — list invariants you must preserve.
 4. Propose a fix that honors past root causes AND constraints. Apply it and run the tests.
-5. If the fix encodes a non-trivial choice, \`hunch_record_decision(...)\` so the next session is grounded in it.
+5. If the human decided or corrected something during the fix, record it (\`hunch_record_decision\` / \`hunch_record_correction\`); the commit itself is captured automatically.
 `;
 const FRAGILE_CMD = `---
 description: Report the most fragile parts of this codebase, with evidence

package/dist/mcp/leanToolList.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+type JsonObject = Record<string, unknown>;
+/** One tool definition as the host should see it. */
+export declare function leanTool(tool: JsonObject): JsonObject;
+/** Route the SDK's tools/list result through leanTool. Call right after
+ *  constructing the server: McpServer installs its tools/list handler on the
+ *  first registerTool, through this public setRequestHandler. */
+export declare function installLeanToolList(server: McpServer): void;
+export {};

package/dist/mcp/leanToolList.js

@@ -0,0 +1,89 @@
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+// Keywords whose meaning differs between draft-07 and 2020-12 — the dialect MCP
+// assumes when `$schema` is absent. A schema that uses any keeps its marker.
+// A property merely NAMED like one also keeps it: conservative, never wrong.
+const DIALECT_SENSITIVE = new Set(["definitions", "dependencies", "additionalItems", "$ref", "$id", "$recursiveRef"]);
+function dialectNeutral(node) {
+    if (Array.isArray(node))
+        return node.every(dialectNeutral);
+    if (!isObject(node))
+        return true;
+    for (const [key, value] of Object.entries(node)) {
+        if (DIALECT_SENSITIVE.has(key) || (key === "items" && Array.isArray(value)))
+            return false;
+        if (!dialectNeutral(value))
+            return false;
+    }
+    return true;
+}
+// Keywords whose value is data, not a subschema: copied as-is.
+const VALUE_KEYWORDS = new Set(["default", "const", "enum", "examples"]);
+/** A copy without zod's safe-integer bounds, which only restate what JSON numbers can hold. */
+function withoutSafeIntegerBounds(node) {
+    if (Array.isArray(node))
+        return node.map(withoutSafeIntegerBounds);
+    if (!isObject(node))
+        return node;
+    const integer = node.type === "integer";
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (integer && ((key === "maximum" && value === Number.MAX_SAFE_INTEGER) || (key === "minimum" && value === Number.MIN_SAFE_INTEGER)))
+            continue;
+        out[key] = VALUE_KEYWORDS.has(key) ? value : withoutSafeIntegerBounds(value);
+    }
+    return out;
+}
+// Only these markers are safe to drop on a dialect-neutral schema; any other
+// dialect (draft-04's boolean exclusiveMinimum, say) keeps its marker.
+const DROPPABLE_MARKERS = new Set([
+    "http://json-schema.org/draft-07/schema#",
+    "https://json-schema.org/draft/2020-12/schema",
+]);
+function leanSchema(schema) {
+    const lean = withoutSafeIntegerBounds(schema);
+    if (DROPPABLE_MARKERS.has(schema.$schema) && dialectNeutral(schema))
+        delete lean.$schema;
+    return lean;
+}
+const isDefaultExecution = (v) => isObject(v) && Object.entries(v).every(([key, value]) => key === "taskSupport" && (value === undefined || value === "forbidden"));
+/** One tool definition as the host should see it. */
+export function leanTool(tool) {
+    const out = {};
+    for (const [key, value] of Object.entries(tool)) {
+        if (key === "execution" && isDefaultExecution(value))
+            continue;
+        out[key] = (key === "inputSchema" || key === "outputSchema") && isObject(value) ? leanSchema(value) : value;
+    }
+    return out;
+}
+/** The request method a schema handles — by identity, or by its method literal
+ *  when a second SDK copy supplied a different schema object. */
+function handlesToolsList(schema) {
+    if (schema === ListToolsRequestSchema)
+        return true;
+    try {
+        return schema.shape?.method?.value === "tools/list";
+    }
+    catch {
+        return false;
+    }
+}
+/** Route the SDK's tools/list result through leanTool. Call right after
+ *  constructing the server: McpServer installs its tools/list handler on the
+ *  first registerTool, through this public setRequestHandler. */
+export function installLeanToolList(server) {
+    const protocol = server.server;
+    const setRequestHandler = protocol.setRequestHandler.bind(protocol);
+    protocol.setRequestHandler = ((schema, handler) => {
+        if (!handlesToolsList(schema))
+            return setRequestHandler(schema, handler);
+        setRequestHandler(schema, async (...args) => {
+            const result = await handler(...args);
+            if (!isObject(result) || !Array.isArray(result.tools))
+                return result;
+            return { ...result, tools: result.tools.map((t) => (isObject(t) ? leanTool(t) : t)) };
+        });
+    });
+}
+//# sourceMappingURL=leanToolList.js.map

package/dist/mcp/server.js

@@ -16,6 +16,7 @@ import { z } from "zod";
 import { hunchPaths, findRoot, toPosixTarget, repoRelativeTarget } from "../core/paths.js";
 import { matchSymbolsTiered } from "../core/glob.js";
 import { resolveMcpToolset } from "./toolset.js";
+import { installLeanToolList } from "./leanToolList.js";
 import { PolicyRepository } from "../constitution/repository.js";
 import { readConfig } from "../core/config.js";
 import { canonicalRootPath, resolveActiveRoot } from "./roots.js";
@@ -1129,7 +1130,7 @@ function prepareRoot(root, explicitOverlay, requireIndex) {
 export const MCP_INSTRUCTIONS = [
     "Hunch is this repository's engineering memory: decisions, bug history, invariants, components, with provenance.",
     "Per user task: (1) hunch_task(action:\"start\", title) once — skip it when the host's prompt hook already opened the task and printed its verify command, and reuse that task_id; (2) hunch_context(target, task_id) FIRST, before reading or editing, for the file, symbol, or task phrase; (3) hunch_check_constraints(scope) before editing shared code; (4) hunch_task(action:\"finish\", task_id) before the final response, showing its contribution card — required, with one exception: the host's prompt hook opened the task AND its instruction said that host closes the task AND the task used no Hunch (no hunch_* call on this task_id, no task verify check, no hook context you acted on, nothing to claim). A task you started with hunch_task is always finished by you.",
-    "Then by moment: hunch_why(target) for rationale and rejected alternatives, hunch_bug_lineage before fixing a failure, hunch_record_decision after a non-trivial choice, hunch_record_correction when a human corrects you.",
+    "Then by moment: hunch_why(target) for rationale and rejected alternatives, hunch_bug_lineage before fixing a failure, hunch_record_correction when a human corrects you, hunch_record_decision for a decision the human makes; record only what the human decides or corrects.",
     "Hosts without lifecycle hooks (Windsurf, Cursor, or Codex before its hooks are trusted) receive no automatic grounding: call these tools yourself.",
 ].join("\n");
 export function buildServerWithRootControl(initialRoot, options = {}) {
@@ -1207,6 +1208,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
     if (toolset.hidden.length)
         process.stderr.write(`[hunch-mcp] tool groups: ${toolset.groups.length ? toolset.groups.join(", ") : "core only"} (${toolset.source}); ${toolset.hidden.length} specialist tool(s) hidden — HUNCH_MCP_TOOLS=all or .hunch/config.json mcp_tools to expose\n`);
     const server = new McpServer({ name: "hunch", version: HUNCH_VERSION }, { instructions: MCP_INSTRUCTIONS });
+    installLeanToolList(server);
     let activeRequests = 0;
     let pendingRoot = null;
     let pendingScheduled = false;
@@ -2103,7 +2105,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
     // -- hunch_record_decision (write-back) -----------------------------------
     server.registerTool("hunch_record_decision", {
         title: "Record a decision (write-back)",
-        description: "Persist a Decision (ADR) with provenance after a non-trivial design choice. private:true keeps it in the HUNCH_PRIVATE_DIR overlay, never committed here. Returns id, home, status. Not for an agent-obeyed rule (hunch_record_correction) or an observation (hunch_record_finding). Errors: 'Refused:' a gate held (don't retry); 'Invalid:' fix arguments; 'Failed to' internal.",
+        description: "Persist a Decision (ADR) with provenance when the human makes or confirms one in conversation; routine choices are captured from commits. private:true keeps it in the HUNCH_PRIVATE_DIR overlay, never committed here. Returns id, home, status. Not for an agent-obeyed rule (hunch_record_correction) or an observation (hunch_record_finding). Errors: 'Refused:' a gate held (don't retry); 'Invalid:' fix arguments; 'Failed to' internal.",
         inputSchema: {
             decision: z.object({
                 title: z.string(),

package/dist/serve/mcpHttp.js

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { installLeanToolList } from "../mcp/leanToolList.js";
 // The web-standard transport, not the Node one: the Node wrapper imports @hono/node-server,
 // which the production dependency audit keeps unreachable (tooling/production-dependency-audit.mjs).
 // Bridging IncomingMessage → Request → ServerResponse here is a few lines and keeps that boundary.
@@ -51,6 +52,7 @@ const TOOLS = [
 ];
 function buildServer(dispatch, problemOf, version) {
     const server = new McpServer({ name: "hunch-serve", version });
+    installLeanToolList(server);
     for (const tool of TOOLS) {
         server.registerTool(tool.name, { title: tool.title, description: tool.description, inputSchema: tool.input }, async (input) => {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
@@ -44,7 +44,6 @@
     "contracts/change-proof/*.json",
     "server.json",
     "bench/constitution-exp03-v1.json",
-    "tooling/competitive-watch.mjs",
     "tooling/md1-benchmark.mjs",
     "LICENSE",
     "NOTICE"
@@ -91,12 +90,10 @@
     "site:proof": "npm run build && node tooling/generate-public-proof.mjs",
     "site:sitemap": "node tooling/generate-sitemap.mjs",
     "bench:md1": "node tooling/md1-benchmark.mjs",
-    "research:competitors": "node tooling/competitive-watch.mjs",
-    "outreach": "node tooling/outreach-pipeline.mjs",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "@tree-sitter-grammars/tree-sitter-yaml": "^0.6.1",
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://www.hunchmemory.com",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.44.0",
+      "version": "1.45.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/tooling/md1-benchmark.mjs

@@ -18,7 +18,7 @@ import { dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
-export const BENCHMARK_BASELINE_REF = "610cd2e5673bf3c69ac984b4737e2d4a749ed374";
+export const BENCHMARK_BASELINE_REF = "a1ad6d89631cce7c194f3f679abf7ed4e56d13e3";
 export const BENCHMARK_SCHEMA = "hunch.md1a.performance.v1";
 
 const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");

package/tooling/competitive-watch.mjs

@@ -1,142 +0,0 @@
-#!/usr/bin/env node
-
-const repos = [
-  "davesheffer/hunch",
-  "gitmem-dev/gitmem",
-  "ismaelkedir/knowit",
-  "weigibbor/mnemo",
-  "oldskultxo/aictx",
-  "riponcm/projectmem",
-  "Cranot/roam-code",
-  "blackwell-systems/knowing",
-  "markmhendrickson/neotoma",
-];
-
-const distinctivePhrases = [
-  "Causal Merge Verdict",
-  "corrections become enforced",
-  "content-matched constraints",
-  "deterministic Change Gate for AI-assisted codebases",
-];
-
-let token = process.env.GITHUB_TOKEN?.trim();
-// A rejected token must DEGRADE the run, never kill it: ambient CI/proxy tokens
-// are often invalid for api.github.com, and the metadata half of this watch
-// works unauthenticated. Flipped on the first 401 so every later call skips
-// the bad credential instead of failing eight times.
-let tokenRejected = false;
-
-function headers() {
-  return {
-    Accept: "application/vnd.github+json",
-    "User-Agent": "hunch-competitive-watch",
-    "X-GitHub-Api-Version": "2022-11-28",
-    ...(token && !tokenRejected ? { Authorization: `Bearer ${token}` } : {}),
-  };
-}
-
-async function github(path) {
-  let response = await fetch(`https://api.github.com${path}`, { headers: headers() });
-  if (response.status === 401 && token && !tokenRejected) {
-    tokenRejected = true;
-    process.stderr.write("competitive-watch: GITHUB_TOKEN rejected (401) — continuing unauthenticated; phrase search will be skipped.\n");
-    response = await fetch(`https://api.github.com${path}`, { headers: headers() });
-  }
-  if (!response.ok) {
-    const detail = (await response.text()).slice(0, 300).replaceAll("\n", " ");
-    throw new Error(`GitHub ${response.status} for ${path}: ${detail}`);
-  }
-  return response.json();
-}
-
-async function repoSnapshot(repo) {
-  // One vanished/renamed repo is itself a signal worth a row — never a reason
-  // to lose the other seven.
-  try {
-    const data = await github(`/repos/${repo}`);
-    return {
-      repo,
-      created: data.created_at,
-      pushed: data.pushed_at,
-      stars: data.stargazers_count,
-      forks: data.forks_count,
-      issues: data.open_issues_count,
-      url: data.html_url,
-    };
-  } catch (error) {
-    return { repo, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-async function phraseSnapshot(phrase) {
-  const query = encodeURIComponent(`"${phrase}"`);
-  const data = await github(`/search/code?q=${query}&per_page=100`);
-  const external = data.items
-    .filter((item) => !item.repository.full_name.startsWith("davesheffer/"))
-    .map((item) => ({
-      repo: item.repository.full_name,
-      path: item.path,
-      url: item.html_url,
-    }));
-  return { phrase, total: data.total_count, external };
-}
-
-function render(snapshot, phrases) {
-  const lines = [
-    `# Competitive watch — ${new Date().toISOString()}`,
-    "",
-    "## Public repository signals",
-    "",
-    "| Repository | Created | Last push | Stars | Forks | Open issues |",
-    "| --- | --- | --- | ---: | ---: | ---: |",
-  ];
-
-  for (const item of snapshot) {
-    if (item.error) {
-      lines.push(`| ${item.repo} | — | — | — | — | — |`);
-      continue;
-    }
-    lines.push(
-      `| [${item.repo}](${item.url}) | ${item.created.slice(0, 10)} | ${item.pushed.slice(0, 10)} | ${item.stars} | ${item.forks} | ${item.issues} |`,
-    );
-  }
-  const failed = snapshot.filter((item) => item.error);
-  if (failed.length) {
-    lines.push("");
-    for (const item of failed) lines.push(`- ⚠ ${item.repo}: ${item.error}`);
-  }
-
-  lines.push("", "## Distinctive phrase search", "");
-  if (!token) {
-    lines.push("Skipped: set `GITHUB_TOKEN` to enable authenticated GitHub code search.");
-  } else if (tokenRejected) {
-    lines.push("Skipped: `GITHUB_TOKEN` was rejected by api.github.com (401) — repo metadata above was collected unauthenticated. Provide a valid token (e.g. `GITHUB_TOKEN=\"$(gh auth token)\"`) to run the phrase-copy check.");
-  } else {
-    for (const result of phrases) {
-      lines.push(`- **${result.phrase}** — ${result.external.length} external indexed match(es)`);
-      for (const match of result.external) {
-        lines.push(`  - [${match.repo} · ${match.path}](${match.url})`);
-      }
-    }
-  }
-
-  lines.push(
-    "",
-    "> Signals are leads, not copying findings. Re-check chronology and substantial similarity before drawing a conclusion.",
-  );
-  return `${lines.join("\n")}\n`;
-}
-
-try {
-  const snapshot = [];
-  // Sequential on purpose: the first call settles token validity before the
-  // rest, and unauthenticated rate limits are too small to burst against.
-  for (const repo of repos) snapshot.push(await repoSnapshot(repo));
-  const phrases = token && !tokenRejected
-    ? await Promise.all(distinctivePhrases.map(phraseSnapshot))
-    : [];
-  process.stdout.write(render(snapshot, phrases));
-} catch (error) {
-  process.stderr.write(`competitive-watch: ${error instanceof Error ? error.message : String(error)}\n`);
-  process.exitCode = 1;
-}