@davesheffer/hunch 1.11.0 → 1.12.0

package/dist/cli/index.js

@@ -57,7 +57,7 @@ import { blockingInScope, vetoInScope, proposedEditLines } from "../core/hookpol
 import { isHumanConfirmed } from "../core/strictgate.js";
 import { appendEvent, readEvents } from "../core/events.js";
 import { computeStats, formatStats } from "../core/stats.js";
-import { injectionMode } from "../core/hookcache.js";
+import { injectionMode, resetSessionInjections } from "../core/hookcache.js";
 import { contextHookOutput, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
 import { PIPELINE_LOOP, UNVERIFIED_NAG, loadPipelineState, onCommand, onEdit, onPrompt, onSkill, pipelineEnabled, savePipelineState, stopVerdict, } from "../core/pipeline.js";
 import { draftDuplicateOf, isAcceptedDuplicateAnchor } from "../core/dupdetect.js";
@@ -3797,7 +3797,53 @@ program
             emitContext(provider, "UserPromptSubmit", text);
             return;
         }
+        if (evt.hook_event_name === "PreCompact") {
+            // Compaction is about to summarize injected grounding out of the agent's
+            // context while the dedup map still says "delivered". Reset it so every
+            // post-compact injection is full again. Emit nothing — this event has no
+            // context channel worth spending.
+            resetSessionInjections(evt.session_id);
+            return;
+        }
+        if (evt.hook_event_name === "SubagentStart") {
+            // A delegated agent starts with NONE of the parent session's grounding:
+            // session orientation never fired inside it and only per-edit PreToolUse
+            // follows it in — so read-only agents (Explore/Plan) could work fully
+            // blind. Give it the invariants that must survive delegation. Public
+            // store only; once per agent type per session.
+            const s = new HunchStore(paths);
+            try {
+                const sevRank = { blocking: 0, warning: 1, advisory: 2 };
+                const constraints = s.advisoryRecs("constraints")
+                    .filter((c) => c.status === "active")
+                    .sort((a, b) => sevRank[a.severity] - sevRank[b.severity]);
+                if (!constraints.length)
+                    return;
+                const L = [`🧠 Hunch — delegated agent grounding: ${constraints.length} invariant(s) in force in this repo.`];
+                for (const c of constraints.slice(0, 8)) {
+                    const flat = c.statement.replace(/\s+/g, " ").trim();
+                    const claim = flat.length > 140 ? `${flat.slice(0, 139).trimEnd()}…` : flat;
+                    L.push(`- [${c.severity}] ${claim}${c.scope.length ? ` (scope: ${c.scope.slice(0, 3).join(", ")})` : ""}`);
+                }
+                if (constraints.length > 8)
+                    L.push(`…and ${constraints.length - 8} more — hunch_check_constraints(scope) for your files.`);
+                L.push("Before editing: hunch_check_constraints(scope) · hunch_why(target). Orient: hunch_context(task).");
+                // No dedup here: the hook event carries the PARENT session id, but each
+                // spawned agent is a fresh empty context — deduping would ground the
+                // first Explore and silently starve every later one.
+                emitContext(provider, "SubagentStart", L.join("\n"));
+            }
+            finally {
+                s.close();
+            }
+            return;
+        }
         if (evt.hook_event_name === "SessionStart") {
+            // A compact-resume means everything injected so far was just summarized
+            // away — the dedup map must forget it delivered anything, or the rest of
+            // the session gets delta one-liners against grounding that is gone.
+            if (evt.source === "compact")
+                resetSessionInjections(evt.session_id);
             // Orientation at the moment it matters: what just happened + what's next,
             // straight from the graph — the agent sits down already knowing where it
             // is instead of pulling (or worse, grepping) for it. Cheap reads only

package/dist/core/agenthook.js

@@ -77,6 +77,8 @@ function eventName(value, provider) {
         posttooluse: "PostToolUse",
         userpromptsubmit: "UserPromptSubmit",
         sessionstart: "SessionStart",
+        subagentstart: "SubagentStart",
+        precompact: "PreCompact",
         stop: "Stop",
     };
     if (map[name])
@@ -155,6 +157,8 @@ export function normalizeHookEvent(raw, provider) {
         tool_name: hunchToolName(stringAt(input, "tool_name", "toolName"), toolInput ?? {}),
         tool_input: toolInput,
         prompt: stringAt(input, "prompt", "user_prompt", "userPrompt"),
+        source: stringAt(input, "source"),
+        agent_type: stringAt(input, "agent_type", "agentType", "subagent_type", "subagentType"),
     };
 }
 /** Provider-aware hook output. Context output is intentionally omitted for

package/dist/core/hookcache.js

@@ -55,6 +55,22 @@ export function injectionMode(sessionId, key, content) {
         return "full"; // grounded beats deduped, always
     }
 }
+/** Forget everything injected into a session. Compaction summarizes injected
+ *  grounding out of the agent's context while the dedup map still says
+ *  "delivered" — so on PreCompact / SessionStart[source=compact] the map must
+ *  reset, or post-compact edits get delta one-liners against grounding the
+ *  agent no longer has. Never throws (same posture as injectionMode). */
+export function resetSessionInjections(sessionId) {
+    try {
+        if (!sessionId)
+            return;
+        const file = join(tmpdir(), "hunch-hookcache", `${sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80)}.json`);
+        rmSync(file, { force: true });
+    }
+    catch {
+        /* unwritable tmpdir — next injectionMode call falls back to "full" anyway */
+    }
+}
 /** Drop session caches from long-gone sessions (best effort, bounded dir). */
 function sweep(dir) {
     try {

package/dist/integrations/scaffold.js

@@ -156,6 +156,18 @@ export function installClaudeHooks(root, hookCmd) {
         ...keep(json.hooks.SessionStart),
         { hooks: [{ type: "command", command: hookCmd }] },
     ];
+    // Delegated agents start with no session grounding (orientation never fired
+    // inside them); compaction summarizes injected grounding away while the dedup
+    // map still says "delivered". These two events keep delivery alive across the
+    // whole session lifecycle, not just its first context window.
+    json.hooks.SubagentStart = [
+        ...keep(json.hooks.SubagentStart),
+        { hooks: [{ type: "command", command: hookCmd }] },
+    ];
+    json.hooks.PreCompact = [
+        ...keep(json.hooks.PreCompact),
+        { hooks: [{ type: "command", command: hookCmd }] },
+    ];
     // Verification pipeline (core/pipeline.ts): PostToolUse records observable
     // facts (edits, verify commands); Stop refuses to end a turn with unverified
     // product edits at firm/strict firmness. Delivery is enforced, not hoped for.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://hunch-pi.vercel.app",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.11.0",
+      "version": "1.12.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {