@davesheffer/hunch 1.36.0 → 1.37.0

package/dist/mcp/server.js

@@ -32,7 +32,8 @@ import { withWriteLock } from "../serve/writelock.js";
 import { advertisedTeamRemoteContract, ensureTeamOverlay, overlayMatchesTeamRemote, readTeamConfig, teamRemoteContract, teamSharedRef } from "../integrations/team.js";
 import { formatSearchHit, formatStructure } from "../core/format.js";
 import { isStateKind, stateSupplements } from "../core/stateDelivery.js";
-import { taskSupplements } from "../core/taskDelivery.js";
+import { taskSelectionSupplements } from "../core/taskDelivery.js";
+import { buildTaskRankingQuery } from "../core/taskQuery.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";
@@ -360,19 +361,27 @@ function deliveredContext(root, target, envelope, sessionId) {
         const state = armExecutionObligations(loadPipelineState(sessionId), structuredContent.obligations, { replaceOrigin: "memory" });
         savePipelineState(sessionId, state);
     }
-    recordServed(root, structuredContent.delivered.map((item) => ({
-        event: "served",
-        kind: item.kind,
-        record_id: item.record_id,
-        target,
-        session_id: sessionId,
-        rank: item.rank,
-        delivery_reason: item.delivery_reason,
-        provenance_status: item.provenance_status,
-        token_cost: item.token_cost,
-        delivery_profile: structuredContent.profile,
-        ranking_policy: structuredContent.ranking_policy,
-    })));
+    recordServed(root, [
+        ...structuredContent.delivered.map((item) => ({
+            event: "served",
+            kind: item.kind,
+            record_id: item.record_id,
+            target,
+            session_id: sessionId,
+            rank: item.rank,
+            delivery_reason: item.delivery_reason,
+            provenance_status: item.provenance_status,
+            token_cost: item.token_cost,
+            delivery_profile: structuredContent.profile,
+            ranking_policy: structuredContent.ranking_policy,
+        })),
+        // Delivered task lines are receipts too: they feed access-based recency.
+        ...envelope.supplements.filter((s) => s.kind === "recent-task" && s.delivered).map((s) => ({
+            event: "served", kind: "tasks", record_id: s.id, target, session_id: sessionId,
+            rank: s.rank, delivery_reason: "supplemental", token_cost: s.token_cost,
+            delivery_profile: structuredContent.profile, ranking_policy: structuredContent.ranking_policy,
+        })),
+    ]);
     return {
         content: [{ type: "text", text: structuredContent.text }],
         structuredContent,
@@ -1104,7 +1113,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
         const stateGrounding = asOf ? [] : stateSupplements(store.stateSlice(target), target);
         // Recent finished tasks that touched the target: what earlier agent work did
         // here, from graph memory. Advisory history sharing the brief's budget.
-        const recentTasks = asOf ? [] : taskSupplements(store.tasksFor(target, 3), target);
+        const recentTasks = asOf ? [] : taskSelectionSupplements(store.selectTasksFor(target, buildTaskRankingQuery(root, task_id ?? null, target)), target);
         const options = {
             root,
             symbols: store.recs("symbols"),

package/dist/store/hunchStore.d.ts

@@ -3,6 +3,7 @@ import { type Component, type Constraint, type Bug, type Decision, type Symbol,
 import { type DB } from "./db.js";
 import { type Embedder } from "./embedder.js";
 import { JsonStore } from "./jsonStore.js";
+import { type RankingContext, type RankingQuery, type RankingWeights, type SlotOptions, type TaskSelection } from "../core/taskRanking.js";
 import { type VetoTier } from "../core/strictgate.js";
 import { type DiffAnalysis } from "../extractors/diff.js";
 import type { CheckReport, CausalWhy, ImpactReport } from "../core/checkreport.js";
@@ -409,6 +410,25 @@ export declare class HunchStore {
      *  denied edits), newest first. Graph memory, so it spans machines and survives
      *  the local ledger's retention window. */
     tasksFor(scope: string, limit?: number): TaskRecord[];
+    /** Every task record that could matter for `target` under the ranking gate:
+     *  same file (exact or glob), a dependent's file, a co-changed file, or a
+     *  record sharing one of the current task's own record ids. Bounded; the
+     *  ranker does the gating and scoring. */
+    taskCandidates(target: string, query: RankingQuery, ctx: RankingContext): TaskRecord[];
+    /** Every task id some later record verified over. */
+    supersededTaskIds(): Set<string>;
+    /** Last delivery time per task record from the local receipt ledger, if any. */
+    taskLastDelivered(): Map<string, number>;
+    /** bm25 of a phrase over task titles and lesson titles, normalized to the top hit. */
+    taskLexicalScores(phrase: string | null, limit?: number): Map<string, number>;
+    /** Corpus inputs for ranking: dependents' files via the symbol graph, co-change
+     *  from git history (bounded, cached), record-id document frequencies across
+     *  task records, lexical scores, and which anchors still exist. */
+    taskRankingContext(target: string, query: RankingQuery): RankingContext;
+    /** Gate → score → slots for one target and the current task's query (dec_66925aa0ee). */
+    selectTasksFor(target: string, query: RankingQuery, options?: SlotOptions & {
+        weights?: Readonly<RankingWeights>;
+    }): TaskSelection;
     /** The causal chain behind a constraint — the WHY a diff-only reviewer can't see.
      *  Deterministic graph join: constraint → source_decision (the decision that
      *  motivated the guard) → the bug whose root cause spawned it (via

package/dist/store/hunchStore.js

@@ -20,6 +20,9 @@ import { selectEmbedder } from "./embedder.js";
 import { JsonStore } from "./jsonStore.js";
 import { gitCommonDir, gitWorktreeRoot, isolatedHeadSha, sameGitPublication, scopedLastChangeDates, } from "../extractors/git.js";
 import { pathMatchesGlob, pathsRelated } from "../core/glob.js";
+import { cochangeFor } from "../core/cochange.js";
+import { withServedDatabase } from "../core/served.js";
+import { normalizePath, rankTaskRecords, recordIdsOf, selectTaskSlots } from "../core/taskRanking.js";
 import { currentForTopic, isInForce } from "../core/topics.js";
 import { edgeId } from "../core/ids.js";
 import { isStrictBlocker, isVetoBlocker } from "../core/strictgate.js";
@@ -1453,6 +1456,113 @@ export class HunchStore {
             .sort((a, b) => b.finished_at.localeCompare(a.finished_at) || a.id.localeCompare(b.id))
             .slice(0, Math.max(1, limit));
     }
+    /** Every task record that could matter for `target` under the ranking gate:
+     *  same file (exact or glob), a dependent's file, a co-changed file, or a
+     *  record sharing one of the current task's own record ids. Bounded; the
+     *  ranker does the gating and scoring. */
+    taskCandidates(target, query, ctx) {
+        const t = normalizePath(toPosixTarget(target));
+        const out = new Map();
+        for (const r of this.tasksFor(t, 200))
+            out.set(r.id, r);
+        if (ctx.dependents.size || ctx.cochange.size || query.recordIds.size) {
+            for (const r of this.recs("tasks")) {
+                if (out.has(r.id))
+                    continue;
+                const files = r.files.map(normalizePath);
+                if (files.some((f) => ctx.dependents.has(f) || ctx.cochange.has(f))) {
+                    out.set(r.id, r);
+                    continue;
+                }
+                if (query.recordIds.size) {
+                    const ids = recordIdsOf(r);
+                    for (const id of query.recordIds)
+                        if (ids.has(id)) {
+                            out.set(r.id, r);
+                            break;
+                        }
+                }
+            }
+        }
+        return [...out.values()];
+    }
+    /** Every task id some later record verified over. */
+    supersededTaskIds() {
+        const out = new Set();
+        for (const r of this.recs("tasks"))
+            for (const id of r.supersedes)
+                out.add(id);
+        return out;
+    }
+    /** Last delivery time per task record from the local receipt ledger, if any. */
+    taskLastDelivered() {
+        const out = new Map();
+        try {
+            withServedDatabase(this.paths.root, (db) => {
+                const rows = db.prepare("SELECT record_id, MAX(at) AS at FROM served WHERE kind = 'tasks' GROUP BY record_id").all();
+                for (const row of rows) {
+                    const t = Date.parse(row.at);
+                    if (Number.isFinite(t))
+                        out.set(row.record_id, t);
+                }
+            });
+        }
+        catch { /* no ledger on this machine: recency falls back to finished_at */ }
+        return out;
+    }
+    /** bm25 of a phrase over task titles and lesson titles, normalized to the top hit. */
+    taskLexicalScores(phrase, limit = 50) {
+        const scores = new Map();
+        if (!phrase || !phrase.trim())
+            return scores;
+        const hits = this.scopedFts(phrase, "tasks", limit).filter((h) => Number.isFinite(h.score));
+        if (!hits.length)
+            return scores;
+        // bm25 from FTS5 is negative, lower is better; normalize magnitude to the best hit.
+        const best = Math.max(...hits.map((h) => Math.abs(h.score)));
+        if (!(best > 0))
+            return scores;
+        for (const h of hits)
+            scores.set(h.ref, Math.max(0, Math.min(1, Math.abs(h.score) / best)));
+        return scores;
+    }
+    /** Corpus inputs for ranking: dependents' files via the symbol graph, co-change
+     *  from git history (bounded, cached), record-id document frequencies across
+     *  task records, lexical scores, and which anchors still exist. */
+    taskRankingContext(target, query) {
+        const t = normalizePath(toPosixTarget(target));
+        const dependents = new Set();
+        try {
+            const symbolFile = new Map(this.recs("symbols").map((s) => [s.id, normalizePath(s.file)]));
+            for (const sym of this.why(t).symbols) {
+                for (const d of this.getDependents(sym.id)) {
+                    const f = symbolFile.get(d.id);
+                    if (f && f !== t)
+                        dependents.add(f);
+                }
+            }
+        }
+        catch { /* no symbol graph: the dependents term is simply absent */ }
+        const cochange = /[./]/.test(t) && !/\s/.test(t) ? cochangeFor(this.paths.root, t) : new Map();
+        const tasks = this.recs("tasks");
+        const df = new Map();
+        for (const r of tasks)
+            for (const id of recordIdsOf(r))
+                df.set(id, (df.get(id) ?? 0) + 1);
+        const n = Math.max(1, tasks.length);
+        const ruleStats = (id) => { const d = df.get(id) ?? 0; return { df: d, idf: Math.log((n + 1) / (d + 1)) + 1e-6 }; };
+        const lexical = this.taskLexicalScores(query.phrase);
+        const anchorsAlive = (r) => r.files.length ? r.files.filter((f) => existsSync(join(this.paths.root, normalizePath(f)))).length / r.files.length : 1;
+        const superseded = this.supersededTaskIds();
+        const delivered = this.taskLastDelivered();
+        return { dependents, cochange, ruleStats, lexical, anchorsAlive, superseded, lastDelivered: (id) => delivered.get(id) ?? null };
+    }
+    /** Gate → score → slots for one target and the current task's query (dec_66925aa0ee). */
+    selectTasksFor(target, query, options = {}) {
+        const ctx = this.taskRankingContext(target, query);
+        const ranked = rankTaskRecords(this.taskCandidates(target, query, ctx), query, ctx, options.weights);
+        return selectTaskSlots(ranked, options);
+    }
     /** The causal chain behind a constraint — the WHY a diff-only reviewer can't see.
      *  Deterministic graph join: constraint → source_decision (the decision that
      *  motivated the guard) → the bug whose root cause spawned it (via

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.36.0",
+  "version": "1.37.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://www.hunchmemory.com",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.36.0",
+      "version": "1.37.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {