@davesheffer/hunch 1.19.0 → 1.20.0-rc.2

package/dist/mcp/server.js

@@ -28,6 +28,7 @@ import { collectCorrectionStageSources } from "../extractors/correctionSources.j
 import { buildDeliveryEnvelope } from "../core/delivery.js";
 import { armExecutionObligations, loadPipelineState, savePipelineState } from "../core/pipeline.js";
 import { recordServed } from "../core/served.js";
+import { EdgeSchema, ResourceSchema } from "../core/types.js";
 import { compareCandidates } from "../core/compare.js";
 import { checkConformance } from "../core/conformance.js";
 import { ConstitutionService, policyEvaluationEnvelope } from "../constitution/service.js";
@@ -144,13 +145,45 @@ const EXECUTION_OBLIGATION_SCHEMA = z.object({
         output_excludes: z.array(z.string()).optional(),
     }),
 });
+const LANDSCAPE_SELECTION_RECEIPT_SCHEMA = z.object({
+    selectionReason: z.enum(["exact-target", "task-match", "orientation-root", "graph-neighbor", "graph-connection"]),
+    selectionRank: z.number().int().positive(),
+    rank: z.number().int().positive(),
+    deliveryReason: z.literal("ranked"),
+    required: z.literal(false),
+    blocking: z.literal(false),
+    provenanceStatus: z.literal("current"),
+    tokenCost: z.number().int().positive(),
+});
+const LANDSCAPE_FRAGMENT_SCHEMA = z.object({
+    schema: z.literal("hunch.landscape-fragment/1"),
+    authority: z.literal("human_confirmed"),
+    target: z.string(),
+    resources: z.array(LANDSCAPE_SELECTION_RECEIPT_SCHEMA.extend({ record: ResourceSchema })),
+    relationships: z.array(LANDSCAPE_SELECTION_RECEIPT_SCHEMA.extend({
+        selectionReason: z.literal("graph-connection"),
+        record: EdgeSchema,
+    })),
+    omitted: z.array(z.object({
+        kind: z.enum(["resources", "relationships"]),
+        recordId: z.string(),
+        reason: z.enum(["budget", "stale-provenance", "endpoint-not-delivered", "landscape-cap"]),
+        detail: z.string(),
+    })),
+    reviewIds: z.array(z.string()),
+    discoveryHashes: z.array(z.string()),
+    sourceRevisions: z.array(z.string()),
+    fragmentHash: z.string(),
+});
 /** 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. */
 const DELIVERY_OUTPUT_SCHEMA = z.object({
+    schema_version: z.literal("hunch.delivery-envelope/1"),
+    receipt_id: z.string().regex(/^hdr_[a-f0-9]{24}$/),
     text: z.string(),
     delivered: z.array(z.object({
-        kind: z.enum(["constraints", "decisions", "bugs", "findings"]),
+        kind: z.enum(["constraints", "decisions", "bugs", "findings", "resources", "relationships"]),
         record_id: z.string(),
         rank: z.number().int().positive(),
         delivery_reason: z.enum(["ranked", "blocking-reserved"]),
@@ -178,13 +211,15 @@ const DELIVERY_OUTPUT_SCHEMA = z.object({
         token_cost: z.number().int().nonnegative(),
     })),
     omitted: z.array(z.object({
-        kind: z.enum(["constraints", "decisions", "bugs", "findings"]),
+        kind: z.enum(["constraints", "decisions", "bugs", "findings", "resources", "relationships"]),
         record_id: z.string(),
-        reason: z.enum(["budget", "stale-provenance", "retired", "actionability-cap", "low-confidence", "insufficient-context", "low-relevance"]),
+        reason: z.enum(["budget", "stale-provenance", "retired", "actionability-cap", "endpoint-not-delivered", "landscape-cap", "low-confidence", "insufficient-context", "low-relevance"]),
         detail: z.string(),
     })),
+    landscape: LANDSCAPE_FRAGMENT_SCHEMA.nullable(),
     budget_tokens: z.number().int().nonnegative(),
     used_chars: z.number().int().nonnegative(),
+    accounted_chars: z.number().int().nonnegative(),
     blocking_overflow: z.boolean(),
     abstention: z.object({
         active: z.boolean(),
@@ -775,7 +810,13 @@ export function buildServerWithRootControl(initialRoot) {
         // Task-phrase input ("improve retrieval ranking") resolves no file/symbol and
         // used to return an empty brief while the graph held the answer — fall back to
         // FTS so the assistant always leaves with the closest matches, not a shrug.
-        const empty = !ctx.constraints.length && !ctx.decisions.length && !ctx.bugs.length && !ctx.blast_radius.length;
+        const empty = !ctx.constraints.length &&
+            !ctx.decisions.length &&
+            !ctx.bugs.length &&
+            !ctx.blast_radius.length &&
+            !ctx.findings.length &&
+            !ctx.landscape?.resources.length &&
+            !ctx.landscape?.relationships.length;
         if (empty && !asOf) {
             const hits = store.search(target, 8);
             if (hits.length) {

package/dist/store/hunchStore.js

@@ -25,6 +25,7 @@ import { edgeId } from "../core/ids.js";
 import { isStrictBlocker, isVetoBlocker } from "../core/strictgate.js";
 import { effectiveForbids, matchForbids } from "../core/constraintmatch.js";
 import { analyzeDiff } from "../extractors/diff.js";
+import { selectReviewedLandscape, } from "../core/landscapeDelivery.js";
 /** Git cannot resolve repository identity from a cwd that does not exist yet.
  * Probe the nearest real directory so a planned nested overlay cannot evade the
  * public-repository boundary merely by deferring mkdir until its first write. */
@@ -1666,6 +1667,12 @@ export class HunchStore {
             blast_radius: [...blast.values()].sort((a, b) => a.depth - b.depth).slice(0, 12),
             components: w.components,
             findings: this.liveFindingsFor(target).slice(0, 8),
+            // Landscape records do not yet carry a valid-time window. A historical
+            // query therefore withholds them instead of mixing current graph state
+            // into an as-of memory envelope.
+            landscape: opts.asOf
+                ? undefined
+                : selectReviewedLandscape(this.recs("resources"), this.recs("edges"), target),
             budget_tokens: budget,
         };
         return ctx;

package/dist/synthesis/synthesize.js

@@ -121,10 +121,15 @@ export async function syncCommit(store, root, sha, opts = {}) {
     // grounding. No-ops when no assistant CLI is available; never raises trust (dec_9a2f2fe72a).
     if (wantVerify)
         draft = await verifyDecisionSafe(await selectVerifier({ root }), input, draft);
+    // The draft's own drafter, not merely the one selected — draftDecisionSafe sets
+    // fellBackTo when the selected provider threw and it silently substituted the
+    // deterministic heuristic. Every telemetry/return below must report THIS, since
+    // backfill's LLM-vs-heuristic tally reads it directly off the return value.
+    const actualProvider = draft.fellBackTo ?? provider.name;
     // Advisory synthesis telemetry for `hunch review` — which provider ran, how many drafts
     // were reconciled, their agreement, and the verifier's grounding. Rides in `evidence`
     // (no schema change → respects forward-migration invariant con_947c578b2c).
-    const synthBits = [`provider=${provider.name}`];
+    const synthBits = [`provider=${actualProvider}`];
     if (draft.samples)
         synthBits.push(`samples=${draft.samples}`);
     if (draft.agreement != null)
@@ -215,7 +220,7 @@ export async function syncCommit(store, root, sha, opts = {}) {
         store.putPrivate("decisions", decision);
     else
         store.json.put("decisions", decision);
-    return { status: "written", decision, provider: provider.name };
+    return { status: "written", decision, provider: actualProvider };
 }
 function putBugInHome(store, bug, home) {
     return home === "private" ? store.putPrivate("bugs", bug) : store.json.put("bugs", bug);
@@ -244,6 +249,9 @@ export async function recordFailure(store, root, failure, opts = {}) {
         suspects: suspects.map((s) => `${s.name} @ ${s.file}`),
     };
     const draft = await draftBugSafe(provider, input);
+    // The draft's own drafter, not merely the one selected — see the identical
+    // comment in syncCommit above.
+    const actualProvider = draft.fellBackTo ?? provider.name;
     // Seed the id from the test id (stable), not the LLM title — one bug per test.
     const id = bugId(failure.test);
     // recurrence = a DIFFERENT prior bug with a similar symptom (not this same one).
@@ -284,7 +292,7 @@ export async function recordFailure(store, root, failure, opts = {}) {
         putBugInHome(store, bug, home);
     }
     raiseFragility(store, affectedFiles, home);
-    return { status: "written", bug, constraint, provider: provider.name, touchedHomes: [home] };
+    return { status: "written", bug, constraint, provider: actualProvider, touchedHomes: [home] };
 }
 /** Orchestrate one `hunch test` run into graph writes: capture each failing test
  *  as a Bug (recordFailure → suspects / recurrence / Constraint promotion), and
@@ -506,19 +514,26 @@ export async function draftDecisionSafe(provider, input) {
     try {
         return await provider.draftDecision(input);
     }
-    catch {
+    catch (error) {
         // A provider failure (network, bad creds, CLI crash, unparseable output) must
         // never abort the learning loop — fall back to the deterministic heuristic
         // draft, which is honestly labeled ("inferred") rather than a hollow llm_draft.
-        return new DeterministicProvider().draftDecision(input);
+        // fellBackTo/fallbackReason tell the caller what ACTUALLY drafted this, not
+        // merely what was selected — see syncCommit, which must report this instead
+        // of the originally-selected provider's name.
+        const draft = await new DeterministicProvider().draftDecision(input);
+        return { ...draft, fellBackTo: "deterministic", fallbackReason: error instanceof Error ? error.message : String(error) };
     }
 }
 export async function draftBugSafe(provider, input) {
     try {
         return await provider.draftBug(input);
     }
-    catch {
-        return new DeterministicProvider().draftBug(input);
+    catch (error) {
+        // See draftDecisionSafe above — the same fallback contract applies to bugs,
+        // and recordFailure must report the actual (fallback) provider likewise.
+        const draft = await new DeterministicProvider().draftBug(input);
+        return { ...draft, fellBackTo: "deterministic", fallbackReason: error instanceof Error ? error.message : String(error) };
     }
 }
 //# sourceMappingURL=synthesize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.19.0",
+  "version": "1.20.0-rc.2",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
@@ -58,7 +58,7 @@
     "build": "npm run clean && tsc -p tsconfig.json",
     "dev": "tsx src/cli/index.ts",
     "hunch": "tsx src/cli/index.ts",
-    "test": "tsx --test --test-concurrency=2 test/*.test.ts",
+    "test": "tsx --test --test-concurrency=4 test/*.test.ts",
     "test:e2e:md1": "tsx --test test/md1-e2e.test.ts",
     "test:e2e:team-matrix": "tsx --test test/team-matrix-e2e.test.ts",
     "verify:matrix": "node tooling/matrix-release-verification.mjs",
@@ -68,6 +68,7 @@
     "site:proof": "npm run build && node tooling/generate-public-proof.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": {

package/server.json

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