@davesheffer/hunch 1.44.0 → 1.45.1

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/hooks.d.ts

@@ -61,6 +61,11 @@ export declare const PORTABLE_HOOK_INVOCATION: string;
  *  or a trailing top-level `if … else … fi` whose every branch ends in
  *  `exec`/`exit` — the shape of the pre-commit framework's generated hook. */
 export declare function terminalExitLine(content: string): string | null;
+export declare function isInside(parent: string, child: string): boolean;
+export declare function gitRun(args: string[], cwd: string): {
+    status: number | null;
+    stdout: string;
+};
 type BlockState = "installed" | "unreachable" | "stale" | "missing";
 /** The result of inspecting the command a managed block actually runs (issue #315). */
 export type HookInvocationHealth = {
@@ -78,6 +83,21 @@ export type HookInvocationHealth = {
  *  the subcommand; env assignments and a leading `(` belong to the block's own
  *  shape and are stripped. Never spawns anything, never touches the network. */
 export declare function hookInvocationHealth(command: string, root: string): HookInvocationHealth;
+/** The repo's worktree tops as `git worktree list --porcelain` reports them:
+ *  `linked` is every entry AFTER the first (the first is always the main
+ *  worktree, or the bare repo) that is not the bare entry, and `count` is how
+ *  many non-bare worktrees the repo has — the number the shared-hooks note
+ *  quotes, which must not include a bare repo's phantom entry. `main` is the
+ *  first entry when it is a checkout, null when the common dir is bare (no
+ *  main checkout exists). Entries are
+ *  separated by blank lines and each starts with a `worktree <path>` line.
+ *  Read straight from git rather than the workspace ledger: this runs during
+ *  `hunch init`, before any ledger exists. */
+export declare function worktreeTops(root: string): {
+    linked: string[];
+    count: number;
+    main: string | null;
+};
 export declare function installPostCommitHook(root: string, invocation: string, opts?: {
     private?: boolean;
     commit?: boolean;

package/dist/integrations/hooks.js

@@ -139,12 +139,12 @@ function realish(p) {
         return resolve(p);
     }
 }
-function isInside(parent, child) {
+export function isInside(parent, child) {
     const norm = (p) => (process.platform === "win32" ? realish(p).toLowerCase() : realish(p));
     const rel = relative(norm(parent), norm(child));
     return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 }
-function gitRun(args, cwd) {
+export function gitRun(args, cwd) {
     const p = spawnSync("git", args, { cwd, encoding: "utf8", env: initiatorChildEnv(), stdio: ["ignore", "pipe", "ignore"] });
     return { status: p.status, stdout: (p.stdout ?? "").trim() };
 }
@@ -504,14 +504,16 @@ function snippetFor(t, mark, build, localInvocation) {
  *  `linked` is every entry AFTER the first (the first is always the main
  *  worktree, or the bare repo) that is not the bare entry, and `count` is how
  *  many non-bare worktrees the repo has — the number the shared-hooks note
- *  quotes, which must not include a bare repo's phantom entry. Entries are
+ *  quotes, which must not include a bare repo's phantom entry. `main` is the
+ *  first entry when it is a checkout, null when the common dir is bare (no
+ *  main checkout exists). Entries are
  *  separated by blank lines and each starts with a `worktree <path>` line.
  *  Read straight from git rather than the workspace ledger: this runs during
  *  `hunch init`, before any ledger exists. */
-function worktreeTops(root) {
+export function worktreeTops(root) {
     const out = gitRun(["worktree", "list", "--porcelain"], root).stdout;
     if (!out)
-        return { linked: [], count: 0 };
+        return { linked: [], count: 0, main: null };
     const entries = normalizeEol(out).split(/\n\s*\n/).map((e) => e.split("\n"));
     const parsed = entries
         .map((lines) => ({
@@ -519,7 +521,12 @@ function worktreeTops(root) {
         bare: lines.some((l) => l.trim() === "bare"),
     }))
         .filter((e) => e.path !== "");
-    return { linked: parsed.slice(1).filter((e) => !e.bare).map((e) => e.path), count: parsed.filter((e) => !e.bare).length };
+    const first = parsed[0];
+    return {
+        linked: parsed.slice(1).filter((e) => !e.bare).map((e) => e.path),
+        count: parsed.filter((e) => !e.bare).length,
+        main: first && !first.bare ? first.path : null,
+    };
 }
 /** The LINKED worktree an invocation is bound to — one it can only work from
  *  inside, because some token is an absolute path under it (that worktree's own

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,12 +20,13 @@
 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";
 import { parseJsonc } from "../core/jsonc.js";
 import { parse as parseToml } from "smol-toml";
+import { publishedMcpInvocation } from "../cli/invocation.js";
 /** JSONC comments are user prose. A parsed object cannot retain their position,
  * so refuse a write rather than reserialize the file without them. */
 function hasJsoncComments(raw) {
@@ -388,18 +389,52 @@ export function writeVscodeHooks(root, inv) {
         Stop: [{ type: "command", command }],
     });
 }
+const WINDSURF_EVENTS = ["pre_user_prompt", "pre_write_code", "post_write_code", "post_run_command"];
+/** The published npx pin (any version), in the current spelling and in the fully
+ * quoted one written before v1.21.1 (`"npx" "-y" "--package=…" …`). */
+const PUBLISHED_PIN = /^\s*"?npx(?:\.cmd)?"?\s+"?-y"?\s+"?--package=(?:hunch-exact@npm:)?@davesheffer\/hunch/;
+/** The events of `file` holding a Hunch hook entry, when it has at least one and
+ * every one of them runs the published pin; null otherwise. Throws, like every
+ * writer, on a file it cannot parse. */
+function publishedPinEvents(file) {
+    const hooks = objectField(readJsonObj(file), "hooks", file);
+    const events = new Set();
+    let onlyPins = true;
+    const collect = (event) => (entry) => {
+        const e = entry && typeof entry === "object" ? entry : null;
+        if (Array.isArray(e?.hooks) && typeof e.command !== "string")
+            e.hooks.forEach(collect(event));
+        else if (typeof e?.command === "string") {
+            if (PUBLISHED_PIN.test(e.command))
+                events.add(event);
+            else
+                onlyPins = false;
+        }
+    };
+    for (const [event, entries] of Object.entries(hooks)) {
+        if (Array.isArray(entries))
+            entries.filter(isHunchProviderHook).forEach(collect(event));
+    }
+    return onlyPins && events.size > 0 ? events : null;
+}
 /** Windsurf's documented workspace hooks. It only supports deterministic
  * pre-hook blocking via exit code 2, so Hunch uses rules + MCP for context and
  * reserves the hook for strict edit protection and pipeline observation. */
 export function writeWindsurfHooks(root, inv) {
     const file = join(root, ".windsurf", "hooks.json");
-    const command = hookCommand(inv, "windsurf");
-    return writeHookConfig(file, {
-        pre_user_prompt: [{ command, show_output: false }],
-        pre_write_code: [{ command, show_output: false }],
-        post_write_code: [{ command, show_output: false }],
-        post_run_command: [{ command, show_output: false }],
-    });
+    const published = hookCommand(publishedMcpInvocation(), "windsurf");
+    let command = hookCommand(inv, "windsurf");
+    // A source-checkout run (tsx / local dist) must never replace a tracked
+    // published pin with a machine-local path (#466): a complete pinned file is
+    // kept as is, and a partial one is completed with the published pin.
+    if (command !== published) {
+        const pinned = publishedPinEvents(file);
+        if (pinned && WINDSURF_EVENTS.every((event) => pinned.has(event)))
+            return file;
+        if (pinned)
+            command = published;
+    }
+    return writeHookConfig(file, Object.fromEntries(WINDSURF_EVENTS.map((event) => [event, [{ command, show_output: false }]])));
 }
 function antigravityHandler(command) {
     return { type: "command", command, timeout: 15 };
@@ -560,6 +595,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 +645,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/integrations/uninstall.d.ts

@@ -17,6 +17,8 @@ export interface UninstallPlan {
         path: string;
         reason: string;
     }>;
+    /** Consequences beyond this checkout (other worktrees, other branches); printed, never refused over. */
+    warnings?: string[];
 }
 /** Read-only: everything `hunch uninstall` would do in `root`. */
 export declare function planUninstall(root: string, opts?: {

package/dist/integrations/uninstall.js

@@ -14,15 +14,15 @@
  */
 import { existsSync, lstatSync, readFileSync, readdirSync, rmdirSync, rmSync, statSync, writeFileSync, chmodSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { basename, join, relative } from "node:path";
+import { basename, join, relative, resolve } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { writeFileAtomic } from "../core/io.js";
-import { gitCommonDir, isGitRepo, separateGitDirLink } from "../extractors/git.js";
+import { currentBranch, gitCommonDir, isGitRepo, isLinkedWorktree, separateGitDirLink } from "../extractors/git.js";
 import { HUNCH_END, HUNCH_START } from "./claudemd.js";
 import { ciWorkflowYaml } from "./ciAction.js";
 import { assertSafeTopLevelConfigFile, stripManagedGitignore } from "./gitignore.js";
 import { isHunchHookCommand } from "./hookmatch.js";
-import { planHookRemoval } from "./hooks.js";
+import { gitRun, isInside, planHookRemoval, worktreeTops } from "./hooks.js";
 import { ATTR_LINES, targetRepositoryEnv } from "./mergeDriver.js";
 import { antigravityMcpFile, isHunchProviderHook, readJsonObj, TOML_END, TOML_START, windsurfMcpFile } from "./providers.js";
 import { SLASH_COMMAND_FILES } from "./scaffold.js";
@@ -195,6 +195,31 @@ function gitConfigHasDrivers(root) {
     const r = spawnSync("git", ["config", "--local", "--get-regexp", "^merge\\.hunch(-grounding)?\\."], { cwd: root, env: targetRepositoryEnv(), encoding: "utf8" });
     return r.status === 0 && r.stdout.trim() !== "";
 }
+/** The branch the clone treats as default: origin's HEAD, else a local main, else
+ *  master; "" when none can be named. */
+function defaultBranch(root) {
+    const head = gitRun(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], root);
+    if (head.status === 0 && head.stdout)
+        return head.stdout.replace(/^origin\//, "");
+    for (const b of ["main", "master"]) {
+        if (gitRun(["show-ref", "--verify", "--quiet", `refs/heads/${b}`], root).status === 0)
+            return b;
+    }
+    return "";
+}
+/** The marker is committed per branch: off the default branch, say the rest of the clone still has Hunch. */
+function branchWarning(root) {
+    try {
+        const branch = currentBranch(root);
+        const def = branch ? defaultBranch(root) : "";
+        if (!branch || !def || branch === def)
+            return null;
+        return `the ${OPT_OUT_FILE} marker is only on branch ${branch}; other branches of this clone still have Hunch's instruction blocks and config — commit and merge it, or run uninstall there too`;
+    }
+    catch {
+        return null;
+    }
+}
 /** The overlay clone a pointer names, for the "kept" note. Never deleted: it is
  *  its own repository holding memory that may not be pushed yet. */
 function pointerOverlay(file) {
@@ -295,22 +320,49 @@ export function planUninstall(root, opts = {}) {
             p.steps.push({ path: ciRel, kind: "keep", note: "it differs from the workflow Hunch generates (edited?); delete it yourself if you no longer want the Hunch Guard check" });
         }
     }
-    // Git hooks + merge driver.
+    // Git hooks + merge driver. Both live in the clone's common git dir, so they
+    // serve every worktree and every branch (#459): a linked worktree leaves them to
+    // the main checkout, and the main checkout says which worktrees lose them too.
+    // A bare common dir has no main checkout, so any worktree removes them and warns.
+    const warnings = [];
     if (isGitRepo(root)) {
+        const commonDir = gitCommonDir(root);
+        const top = gitRun(["rev-parse", "--show-toplevel"], root).stdout;
+        const here = top || root;
+        const same = (a, b) => isInside(a, b) && isInside(b, a);
+        // The main checkout as git lists it, not the common dir's parent, which in a
+        // bare clone or a --separate-git-dir checkout is no checkout at all.
+        const tops = worktreeTops(root);
+        const mainCheckout = tops.main;
+        const linked = commonDir !== "" && mainCheckout !== null && !same(mainCheckout, here) && isLinkedWorktree(root);
+        // The same test `hunch init` uses: in the common dir, or outside this checkout.
+        const shared = (file) => (commonDir !== "" && isInside(commonDir, file)) || (top !== "" && !isInside(top, file));
+        const elsewhere = (what, it) => `${what} shared by every worktree of this clone — run \`hunch uninstall\` from the main checkout (${mainCheckout}) to remove ${it}`;
+        let removesShared = false;
         for (const h of planHookRemoval(root)) {
             const path = p.rel(h.path);
             if (h.reason)
                 p.steps.push({ path, kind: "keep", note: h.reason });
-            else if (h.next === null)
-                p.steps.push({ path, kind: "delete", note: `Hunch's ${h.hookName} git hook`, run: () => rmSync(h.path, { force: true }) });
+            else if (linked && shared(h.path))
+                p.steps.push({ path, kind: "keep", note: elsewhere(`Hunch's ${h.hookName} git hook is`, "it") });
             else {
-                const next = h.next;
-                p.steps.push({ path, kind: "edit", note: `removed Hunch's block from the ${h.hookName} git hook (your own lines are kept)`, run: () => { writeFileSync(h.path, next); chmodSync(h.path, 0o755); } });
+                if (shared(h.path))
+                    removesShared = true;
+                if (h.next === null)
+                    p.steps.push({ path, kind: "delete", note: `Hunch's ${h.hookName} git hook`, run: () => rmSync(h.path, { force: true }) });
+                else {
+                    const next = h.next;
+                    p.steps.push({ path, kind: "edit", note: `removed Hunch's block from the ${h.hookName} git hook (your own lines are kept)`, run: () => { writeFileSync(h.path, next); chmodSync(h.path, 0o755); } });
+                }
             }
         }
-        if (gitConfigHasDrivers(root)) {
+        if (gitConfigHasDrivers(root) && linked) {
+            p.steps.push({ path: p.rel(join(commonDir, "config")), kind: "keep", note: elsewhere("the merge.hunch and merge.hunch-grounding drivers are", "them") });
+        }
+        else if (gitConfigHasDrivers(root)) {
+            removesShared = true;
             p.steps.push({
-                path: ".git/config", kind: "edit", note: "unregistered the merge.hunch and merge.hunch-grounding drivers",
+                path: commonDir ? p.rel(join(commonDir, "config")) : ".git/config", kind: "edit", note: "unregistered the merge.hunch and merge.hunch-grounding drivers",
                 run: () => {
                     for (const section of ["merge.hunch", "merge.hunch-grounding"]) {
                         spawnSync("git", ["config", "--local", "--remove-section", section], { cwd: root, env: targetRepositoryEnv(), stdio: "ignore" });
@@ -318,6 +370,13 @@ export function planUninstall(root, opts = {}) {
                 },
             });
         }
+        const others = linked ? [] : tops.linked.filter((w) => !same(w, here)).map((w) => resolve(w));
+        if (removesShared && others.length) {
+            warnings.push(`the git hooks and merge drivers are shared with ${others.length === 1 ? "the linked worktree" : `${others.length} linked worktrees`} ${others.join(", ")}, so they are removed there too, though ${others.length === 1 ? "it still has" : "those still have"} Hunch and no ${OPT_OUT_FILE} marker`);
+        }
+        const onBranch = branchWarning(root);
+        if (onBranch)
+            warnings.push(onBranch);
     }
     const attrs = p.text(".gitattributes");
     if (attrs !== null) {
@@ -378,7 +437,7 @@ export function planUninstall(root, opts = {}) {
     for (const dir of overlays) {
         p.steps.push({ path: p.rel(dir), kind: "keep", note: "a private/shared overlay clone: its own repository with memory that may not be pushed; never deleted here" });
     }
-    return { root, purge, steps: p.steps, refused: p.refused };
+    return { root, purge, steps: p.steps, refused: p.refused, warnings };
 }
 /** Directories Hunch's writers create; removed only when left empty. Deepest first. */
 const PRUNE_DIRS = [
@@ -430,6 +489,8 @@ export function formatUninstallPlan(plan, dryRun) {
         out.push(`  ✗ ${r.path}: ${r.reason}`);
     for (const s of plan.steps)
         out.push(`  ${icon(s.kind)} ${verb(s.kind)} ${s.path} — ${s.note}`);
+    for (const w of plan.warnings ?? [])
+        out.push(`  ⚠ ${w}`);
     return out;
 }
 //# sourceMappingURL=uninstall.js.map

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.1",
   "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.1",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.44.0",
+      "version": "1.45.1",
       "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)), "..");