@davesheffer/hunch 1.18.1 → 1.19.0

package/dist/integrations/providers.js

@@ -23,83 +23,7 @@ import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { renderHunchSection, stripManagedSection, upsertSection, updateClaudeMd } from "./claudemd.js";
 import { headFileContent, isGitCleanPath } from "../extractors/git.js";
-/** Strip // line and block comments + trailing commas (JSONC → JSON). String-aware
- *  (double-quoted, with escapes) so a // inside a value isn't mangled. VS Code's
- *  .vscode/mcp.json is JSONC, so we must tolerate comments. */
-function stripJsonc(s) {
-    let out = "";
-    let inStr = false;
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        const n = s[i + 1];
-        if (inStr) {
-            out += c;
-            if (c === "\\") {
-                out += n ?? "";
-                i++;
-                continue;
-            }
-            if (c === '"')
-                inStr = false;
-            continue;
-        }
-        if (c === '"') {
-            inStr = true;
-            out += c;
-            continue;
-        }
-        if (c === "/" && n === "/") {
-            while (i < s.length && s[i] !== "\n")
-                i++;
-            continue;
-        }
-        if (c === "/" && n === "*") {
-            i += 2;
-            while (i < s.length && !(s[i] === "*" && s[i + 1] === "/"))
-                i++;
-            i++;
-            continue;
-        }
-        out += c;
-    }
-    return dropTrailingCommas(out);
-}
-/** Remove trailing commas (`,` before `}`/`]`) — string-aware, so a comma inside
- *  a string value (e.g. "a,]") is never touched. A blanket regex would corrupt it
- *  (the same trap test/migrate.test.ts guards against). Runs on comment-free text,
- *  so lookahead need only skip whitespace. */
-function dropTrailingCommas(s) {
-    let out = "";
-    let inStr = false;
-    let esc = false;
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (inStr) {
-            out += c;
-            if (esc)
-                esc = false;
-            else if (c === "\\")
-                esc = true;
-            else if (c === '"')
-                inStr = false;
-            continue;
-        }
-        if (c === '"') {
-            inStr = true;
-            out += c;
-            continue;
-        }
-        if (c === ",") {
-            let j = i + 1;
-            while (j < s.length && /\s/.test(s[j]))
-                j++;
-            if (s[j] === "}" || s[j] === "]")
-                continue; // trailing comma → drop
-        }
-        out += c;
-    }
-    return out;
-}
+import { parseJsonc } from "../core/jsonc.js";
 /** Read a JSON/JSONC object. Returns {} only for an ABSENT or empty file. A
  *  non-empty file we cannot parse THROWS — overwriting it would silently wipe the
  *  user's other MCP servers. */
@@ -110,7 +34,7 @@ function readJsonObj(file) {
     if (!raw.trim())
         return {};
     try {
-        const v = JSON.parse(stripJsonc(raw));
+        const v = parseJsonc(raw);
         if (v && typeof v === "object" && !Array.isArray(v))
             return v;
         throw new Error("not a JSON object");

package/dist/integrations/scaffold.js

@@ -175,6 +175,12 @@ export function installClaudeHooks(root, hookCmd) {
         ...keep(json.hooks.PostToolUse),
         { matcher: "Edit|Write|MultiEdit|Bash|PowerShell|Skill", hooks: [{ type: "command", command: hookCmd }] },
     ];
+    // Modern Claude Code separates failed tools from PostToolUse. Observe that
+    // event too so a failed test cannot be mistaken for a completed proof.
+    json.hooks.PostToolUseFailure = [
+        ...keep(json.hooks.PostToolUseFailure),
+        { matcher: "Bash|PowerShell", hooks: [{ type: "command", command: hookCmd }] },
+    ];
     json.hooks.Stop = [
         ...keep(json.hooks.Stop),
         { hooks: [{ type: "command", command: hookCmd }] },

package/dist/mcp/server.js

@@ -22,7 +22,11 @@ import { revParse, asOfDate, revExists, lastChangeDate, rangeFiles, rangeDiff, c
 import { flushCapture, flushMemoryHome, pinSharedRemote } from "../integrations/sync.js";
 import { advertisedTeamRemoteContract, ensureTeamOverlay, overlayMatchesTeamRemote, readTeamConfig, teamRemoteContract, teamSharedRef } from "../integrations/team.js";
 import { formatStructure } from "../core/format.js";
+import { diagnoseIssueCorrectionStage, formatCorrectionStageDiagnostic } from "../core/correctionStage.js";
+import { compileVerifiedEvidenceMap, EvidenceExecutionSchema, EvidenceInterventionSchema, EvidenceProbeSchema, formatVerifiedEvidenceMap, VerifiedEvidenceReceiptSchema, } from "../core/evidenceMap.js";
+import { collectCorrectionStageSources } from "../extractors/correctionSources.js";
 import { buildDeliveryEnvelope } from "../core/delivery.js";
+import { armExecutionObligations, loadPipelineState, savePipelineState } from "../core/pipeline.js";
 import { recordServed } from "../core/served.js";
 import { compareCandidates } from "../core/compare.js";
 import { checkConformance } from "../core/conformance.js";
@@ -127,6 +131,19 @@ const FINDINGS_CAP = 12; // hunch_findings listing
 const SEV_CONSTRAINT = { blocking: 3, warning: 2, advisory: 1 };
 const SEV_BUG = { critical: 4, high: 3, medium: 2, low: 1 };
 const more = (total, cap, hint = "") => total > cap ? `\n  …(+${total - cap} more${hint ? ` — ${hint}` : ""})` : "";
+const EXECUTION_OBLIGATION_SCHEMA = z.object({
+    id: z.string(),
+    origin: z.enum(["memory", "episode", "manual"]),
+    category: z.enum(["evidence", "behavior", "types", "serialization", "compatibility", "other"]),
+    phase: z.enum(["session", "after-edit"]),
+    description: z.string(),
+    command_alternatives: z.array(z.array(z.string())),
+    expected: z.object({
+        success: z.boolean(),
+        output_includes: z.array(z.string()).optional(),
+        output_excludes: z.array(z.string()).optional(),
+    }),
+});
 /** Public MCP shape for the canonical delivery envelope. Keeping the schema on
  *  the tool means orchestrators can consume receipt facts without scraping the
  *  backward-compatible text block. */
@@ -140,23 +157,45 @@ const DELIVERY_OUTPUT_SCHEMA = z.object({
         provenance_status: z.enum(["current", "unverified", "stale"]),
         token_cost: z.number().int().nonnegative(),
     })),
+    hypotheses: z.array(z.object({
+        kind: z.literal("decision"),
+        record_id: z.string(),
+        rank: z.number().int().positive(),
+        why: z.string(),
+        where: z.array(z.string()),
+        historical_pattern: z.string(),
+        verify: z.string(),
+        disprove: z.string(),
+        obligations: z.array(EXECUTION_OBLIGATION_SCHEMA),
+    })),
+    obligations: z.array(EXECUTION_OBLIGATION_SCHEMA),
     supplements: z.array(z.object({
         id: z.string(),
         kind: z.string(),
         delivered: z.boolean(),
-        reason: z.enum(["supplemental", "budget", "empty"]),
+        reason: z.enum(["supplemental", "budget", "empty", "abstained"]),
         rank: z.number().int().positive(),
         token_cost: z.number().int().nonnegative(),
     })),
     omitted: z.array(z.object({
         kind: z.enum(["constraints", "decisions", "bugs", "findings"]),
         record_id: z.string(),
-        reason: z.enum(["budget", "stale-provenance", "retired"]),
+        reason: z.enum(["budget", "stale-provenance", "retired", "actionability-cap", "low-confidence", "insufficient-context", "low-relevance"]),
         detail: z.string(),
     })),
     budget_tokens: z.number().int().nonnegative(),
     used_chars: z.number().int().nonnegative(),
     blocking_overflow: z.boolean(),
+    abstention: z.object({
+        active: z.boolean(),
+        withheld: z.number().int().nonnegative(),
+        reasons: z.object({
+            "low-confidence": z.number().int().nonnegative(),
+            "insufficient-context": z.number().int().nonnegative(),
+            "low-relevance": z.number().int().nonnegative(),
+        }),
+        retry_hint: z.string().nullable(),
+    }),
 });
 /** Return the same human-readable brief older clients consume plus the exact
  *  machine-readable envelope. Receipt recording is deliberately best-effort:
@@ -166,6 +205,10 @@ function deliveredContext(root, target, envelope, sessionId) {
     // advertised MCP contract, the SDK will reject the call and the local ledger
     // must not claim that response was served.
     const structuredContent = DELIVERY_OUTPUT_SCHEMA.parse(envelope);
+    if (sessionId) {
+        const state = armExecutionObligations(loadPipelineState(sessionId), structuredContent.obligations, { replaceOrigin: "memory" });
+        savePipelineState(sessionId, state);
+    }
     recordServed(root, structuredContent.delivered.map((item) => ({
         event: "served",
         kind: item.kind,
@@ -761,6 +804,45 @@ export function buildServerWithRootControl(initialRoot) {
         const envelope = buildDeliveryEnvelope(ctx, options);
         return deliveredContext(root, as_of ? `${target} (as_of:${as_of})` : target, envelope, extra.sessionId);
     });
+    // -- hunch_shortlist (bounded correction-stage diagnostic) ----------------
+    server.registerTool("hunch_shortlist", {
+        title: "Shortlist the likely correction stage and declarations",
+        description: "Experimental, deterministic, read-only repository-adaptive diagnostic for a schema/validation issue or reproduction. Preserves a flat top five, adds a transfer-tested hierarchical inspection view, and emits an efficiency-tested advisory progressive inspection queue capped at eleven declarations with deterministic receipts. Optional authenticated same-claim evidence is annotated but cannot reorder candidates because fresh transfer rejected that mechanism. It never claims an exact implementation owner or per-case confidence and does not edit, gate, or capture memory.",
+        inputSchema: {
+            issue: z.string().min(1).max(100_000).describe("Issue report or reproduction prose, including observed and expected behavior when available."),
+            limit: z.number().int().min(1).max(5).optional().describe("Candidate count, capped at five (default 5)."),
+            evidence: VerifiedEvidenceReceiptSchema.optional().describe("Optional verified evidence for this exact issue claim. It is reported and attached to candidates but cannot change ranking."),
+            cwd: cwdHintField,
+        },
+    }, async ({ issue, limit, evidence }) => {
+        try {
+            const collection = collectCorrectionStageSources(root, issue);
+            const diagnostic = diagnoseIssueCorrectionStage(issue, collection.sources, limit ?? 5, evidence);
+            return ok(`${formatCorrectionStageDiagnostic(diagnostic)}\nScan: ${collection.files_read} source file(s), ${collection.files_skipped} skipped by safety/budget limits.`);
+        }
+        catch (error) {
+            return err(`Could not build the correction-stage shortlist: ${error.message}`);
+        }
+    });
+    // -- hunch_evidence_map (verified behavioral receipt compiler) ------------
+    server.registerTool("hunch_evidence_map", {
+        title: "Compile a verified behavioral evidence map",
+        description: "Compile supplied red-target/green-control, execution, and intervention observations into a bounded read-only evidence map. Useful for bugs, regressions, design invariants, and any other testable behavior. This tool executes no code, mutates nothing, and never converts behavioral influence into an exact correction-owner claim.",
+        inputSchema: {
+            version: z.literal(1).describe("Receipt schema version; currently 1."),
+            claim: z.string().trim().min(1).max(100_000).describe("The behavior or invariant being tested."),
+            probe: EvidenceProbeSchema,
+            execution: z.array(EvidenceExecutionSchema).max(500).optional(),
+            interventions: z.array(EvidenceInterventionSchema).max(500).optional(),
+        },
+    }, async (receipt) => {
+        try {
+            return ok(formatVerifiedEvidenceMap(compileVerifiedEvidenceMap(receipt)));
+        }
+        catch (error) {
+            return err(`Could not compile the verified evidence map: ${error.message}`);
+        }
+    });
     // -- hunch_now (the hot view: recent activity + roadmap) --------------------
     // PUBLIC store only, per dec_29eff08c69's jurisdiction rule: an assistant may
     // paste this anywhere, so it must be publishable by construction. Union view

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.18.1",
+  "version": "1.19.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.18.1",
+  "version": "1.19.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.18.1",
+      "version": "1.19.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {