@davesheffer/hunch 1.37.0 → 1.37.1

package/dist/cli/index.js

@@ -68,6 +68,7 @@ import { formatSearchHit, formatStructure } from "../core/format.js";
 import { isStateKind, renderStateLine, stateSupplements } from "../core/stateDelivery.js";
 import { taskSelectionSupplements } from "../core/taskDelivery.js";
 import { buildTaskRankingQuery } from "../core/taskQuery.js";
+import { rankingStatusLine, resolveTaskRankingMode } from "../core/taskRankingMode.js";
 import { diagnoseIssueCorrectionStage, formatCorrectionStageDiagnostic } from "../core/correctionStage.js";
 import { compileVerifiedEvidenceMap, formatVerifiedEvidenceMap } from "../core/evidenceMap.js";
 import { collectCorrectionStageSources } from "../extractors/correctionSources.js";
@@ -4212,7 +4213,7 @@ program
         decisionCorpus: store.recs("decisions"),
         historical: !!asOf,
         profile: opts.profile,
-        supplements: [...stateGrounding, ...(asOf ? [] : taskSelectionSupplements(store.selectTasksFor(target, buildTaskRankingQuery(root, opts.task ?? null, target)), target))],
+        supplements: [...stateGrounding, ...(asOf ? [] : taskSelectionSupplements(store.selectTasksAuto(target, buildTaskRankingQuery(root, opts.task ?? null, target)), target))],
     });
     process.stdout.write(envelope.text);
     if (opts.task) {
@@ -4882,7 +4883,7 @@ program
         // from this file. No diff exists yet, so this is context — "don't re-add X" —
         // not a block; the commit-time `hunch check` does the actual gating.
         const retired = store.retiredForFile(target).filter((r) => r.symbols.length || r.deps.length);
-        const recentTasks = taskSelectionSupplements(store.selectTasksFor(target, buildTaskRankingQuery(root, hookReportTaskId(root, provider, evt), target)), target);
+        const recentTasks = taskSelectionSupplements(store.selectTasksAuto(target, buildTaskRankingQuery(root, hookReportTaskId(root, provider, evt), target)), target);
         const hasContent = ctx.constraints.length ||
             ctx.decisions.length ||
             ctx.bugs.length ||
@@ -6473,6 +6474,11 @@ program
             console.log(`  • ${r.title}  (${r.id}${r.topic ? `, ${r.topic}` : ""}, since ${r.date})\n      ${r.note}`);
         if (pendingReview > 0)
             console.log(`\n  (${pendingReview} legacy un-vouched draft(s) — \`hunch adopt-drafts\` to auto-trust them as advisory)`);
+        // Task-record ranking: evaluated automatically on every task write; the kill rule applies itself.
+        try {
+            console.log(`\n📊 ${rankingStatusLine(resolveTaskRankingMode(store.publicRoot, store))}`);
+        }
+        catch { /* no task records or no cache dir: nothing to say */ }
     }
     finally {
         store.close();

package/dist/cli/taskReport.js

@@ -9,6 +9,7 @@ import { assertReportPath } from "../core/taskReportPaths.js";
 import { publicTaskReport } from "../core/taskReportPublic.js";
 import { mergeDurableTaskSummaries, persistTaskRecord } from "../core/taskRecord.js";
 import { evaluateTaskRanking, renderRankEval } from "../core/taskRankEval.js";
+import { rankingStatusLine, refreshRankEval, resolveTaskRankingMode } from "../core/taskRankingMode.js";
 import { taskRecordStats } from "../core/taskRecordStats.js";
 export function registerTaskReportCommands(program, openStore) {
     const task = program.command("task").description("Record an explicit task lifecycle for Hunch contribution reports");
@@ -117,6 +118,7 @@ export function registerTaskReportCommands(program, openStore) {
                 console.log(`Graph task records: ${rs.records}`);
                 console.log(`  re-verified an earlier check (24h)  ${rate(rs.reverification_rate, rs.reverify_candidates)}`);
                 console.log(`  repeated an earlier violation       ${rate(rs.repeat_violation_rate, rs.violation_candidates)}`);
+                console.log(`  ${rankingStatusLine(resolveTaskRankingMode(opened.root, opened.store))}`);
             }
             finally {
                 opened.store.close();
@@ -134,6 +136,8 @@ export function registerTaskReportCommands(program, openStore) {
             const cutoff = Date.now() - (Number(opts.since) || 365) * 86_400_000;
             const records = store.recs("tasks").filter((r) => (Date.parse(r.finished_at) || 0) >= cutoff);
             const report = evaluateTaskRanking(records, { split: Math.min(1, Math.max(0.05, Number(opts.split) || 0.3)) });
+            // Keep the automatic cache current too, so delivery and `hunch now` agree with what was just printed.
+            refreshRankEval(findRoot(), store, { force: true });
             console.log(opts.json ? JSON.stringify(report, null, 2) : renderRankEval(report));
         }
         finally {

package/dist/constitution/schema.d.ts

@@ -275,11 +275,11 @@ export declare const EvidenceEventSchema: z.ZodObject<{
     }, z.core.$strict>>;
     compiler: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            conflicted: "conflicted";
-            eligible: "eligible";
             compiled: "compiled";
+            eligible: "eligible";
             covered: "covered";
             uncompilable: "uncompilable";
+            conflicted: "conflicted";
         }>;
         policy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         reason: z.ZodDefault<z.ZodString>;

package/dist/constitution/scorecard.d.ts

@@ -10,9 +10,9 @@ export declare const CompilerCaseBankSchema: z.ZodObject<{
         evidence: z.ZodString;
         expected: z.ZodObject<{
             outcome: z.ZodEnum<{
-                conflicted: "conflicted";
                 covered: "covered";
                 uncompilable: "uncompilable";
+                conflicted: "conflicted";
                 assertion: "assertion";
             }>;
             assertion: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -97,9 +97,9 @@ export declare const CompilerCaseBankSchema: z.ZodObject<{
         }, z.core.$strict>;
         actual: z.ZodObject<{
             outcome: z.ZodEnum<{
-                conflicted: "conflicted";
                 covered: "covered";
                 uncompilable: "uncompilable";
+                conflicted: "conflicted";
                 assertion: "assertion";
             }>;
             assertion: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/core/outcomeExperience.d.ts

@@ -59,8 +59,8 @@ export declare const UsefulnessObservationSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             observation: "observation";
             artifact: "artifact";
-            receipt: "receipt";
             event: "event";
+            receipt: "receipt";
             verification: "verification";
         }>;
         ref: z.ZodString;

package/dist/core/stateContract.d.ts

@@ -92,8 +92,8 @@ export declare const CaptureRequestSchema: z.ZodObject<{
     relevance: z.ZodObject<{
         use: z.ZodEnum<{
             decision: "decision";
-            constraint: "constraint";
             preference: "preference";
+            constraint: "constraint";
             operational_fact: "operational_fact";
             ongoing_issue: "ongoing_issue";
         }>;
@@ -160,8 +160,8 @@ export declare const CaptureBatchRequestSchema: z.ZodObject<{
         relevance: z.ZodObject<{
             use: z.ZodEnum<{
                 decision: "decision";
-                constraint: "constraint";
                 preference: "preference";
+                constraint: "constraint";
                 operational_fact: "operational_fact";
                 ongoing_issue: "ongoing_issue";
             }>;
@@ -255,8 +255,8 @@ export declare const ReadRequestSchema: z.ZodObject<{
     subject: z.ZodOptional<z.ZodString>;
     task: z.ZodOptional<z.ZodString>;
     profile: z.ZodOptional<z.ZodEnum<{
-        builder: "builder";
         reviewer: "reviewer";
+        builder: "builder";
         architect: "architect";
     }>>;
     budget_tokens: z.ZodOptional<z.ZodNumber>;

package/dist/core/taskDelivery.js

@@ -36,7 +36,9 @@ export function taskSelectionSupplements(selection, target) {
     const counts = { latest: 0, violation: 0, relevant: 0 };
     for (const p of selection.picks)
         counts[p.slot]++;
-    const parts = [counts.latest ? "latest" : null, counts.violation ? "problem" : null, counts.relevant ? `relevant ${counts.relevant}` : null].filter(Boolean).join(" · ");
+    const parts = selection.mode === "latest"
+        ? `latest ${counts.latest} (ranking off: it lost its evaluation; hunch task rank-eval)`
+        : [counts.latest ? "latest" : null, counts.violation ? "problem" : null, counts.relevant ? `relevant ${counts.relevant}` : null].filter(Boolean).join(" · ");
     return [
         {
             id: "recent-tasks", kind: "recent-tasks", priority: 415,

package/dist/core/taskRanking.d.ts

@@ -90,7 +90,12 @@ export interface TaskSelection {
     /** Ranked candidates not shown. */
     more: number;
     candidates: number;
+    /** How the picks were chosen: the ranker, or the "latest 3" fallback the kill rule imposes. */
+    mode?: "ranked" | "latest";
 }
+/** The pre-ranking behaviour, kept as the baseline and the fallback: the three
+ * most recent records on the exact file, no scoring. */
+export declare function selectLatestTasks(records: readonly TaskRecord[], query: RankingQuery, ctx: RankingContext, limit?: number): TaskSelection;
 export interface SlotOptions {
     limit?: number;
     relevant?: number;

package/dist/core/taskRanking.js

@@ -9,6 +9,18 @@ export const COCHANGE_MIN_COUNT = 2;
  * at most half of all task records (idf ≥ ln 2). A rule every task receives
  * says nothing about relatedness; it still contributes to the score, weakly. */
 export const RULE_GATE_MIN_IDF = Math.log(2);
+/** The pre-ranking behaviour, kept as the baseline and the fallback: the three
+ * most recent records on the exact file, no scoring. */
+export function selectLatestTasks(records, query, ctx, limit = 3) {
+    const target = normalizePath(query.target);
+    const ranked = records
+        .filter((r) => !ctx.superseded?.has(r.id) && recordFiles(r).includes(target))
+        .map((r) => rankTaskRecord(r, query, ctx))
+        .filter((r) => r !== null)
+        .sort(newestFirst);
+    const picks = ranked.slice(0, Math.max(1, limit)).map((r) => ({ slot: "latest", ranked: r }));
+    return { picks, more: ranked.length - picks.length, candidates: ranked.length, mode: "latest" };
+}
 const DAY_MS = 86_400_000;
 export function normalizePath(path) {
     return path.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -197,6 +209,6 @@ export function selectTaskSlots(ranked, options = {}) {
         take("relevant", best);
         remaining = remaining.filter((r) => r !== best);
     }
-    return { picks, more: ranked.length - picks.length, candidates: ranked.length };
+    return { picks, more: ranked.length - picks.length, candidates: ranked.length, mode: "ranked" };
 }
 //# sourceMappingURL=taskRanking.js.map

package/dist/core/taskRankingMode.d.ts

@@ -0,0 +1,36 @@
+import type { HunchStore } from "../store/hunchStore.js";
+import { type RankEvalReport } from "./taskRankEval.js";
+export declare const RANK_EVAL_CACHE_SCHEMA: "hunch.task-rank-eval-cache/1";
+/** The decision's threshold: the kill rule needs at least this many task records. */
+export declare const KILL_MIN_TASKS = 200;
+export type TaskRankingMode = "ranked" | "latest";
+export interface RankEvalCache {
+    schema: typeof RANK_EVAL_CACHE_SCHEMA;
+    computed_at: string;
+    /** Task-record count the report was computed over; a different count triggers a recompute. */
+    records: number;
+    /** Content hash of the record ids + report hashes, so an edit without a count change also refreshes. */
+    corpus_hash: string;
+    report: RankEvalReport;
+}
+export declare function readRankEvalCache(root: string): RankEvalCache | null;
+/** Recompute when the corpus changed; otherwise return the cached report. Never throws. */
+export declare function refreshRankEval(root: string, store: HunchStore, options?: {
+    force?: boolean;
+    now?: () => string;
+}): RankEvalCache | null;
+/** The rule from the decision, applied to a report. */
+export declare function modeFromReport(report: RankEvalReport | null | undefined): {
+    mode: TaskRankingMode;
+    reason: string;
+};
+export interface ResolvedRankingMode {
+    mode: TaskRankingMode;
+    reason: string;
+    source: "override" | "auto";
+    cache: RankEvalCache | null;
+}
+/** What delivery should do right now for this repository. */
+export declare function resolveTaskRankingMode(root: string, store: HunchStore): ResolvedRankingMode;
+/** One line for `hunch now` and the task stats. */
+export declare function rankingStatusLine(resolved: ResolvedRankingMode): string;

package/dist/core/taskRankingMode.js

@@ -0,0 +1,122 @@
+/** Automatic evaluation and the automatic kill rule for task-record ranking
+ * (dec_66925aa0ee). Nobody has to run anything:
+ *
+ *  - every time a task record is written, the leave-one-out evaluation is
+ *    recomputed over the graph's task records (pure, a few hundred records)
+ *    and cached under .hunch-cache — derived state, safe to delete;
+ *  - delivery reads the cache to pick its mode: `ranked` until the
+ *    pre-registered rule says otherwise, `latest` (three most recent on the
+ *    file) once the ranked selection has LOST to the baseline with a
+ *    confidence interval excluding zero over at least KILL_MIN_TASKS records;
+ *  - `hunch now` prints the current line; a verdict change becomes a finding.
+ *
+ * `.hunch/local.json` `taskRanking: "ranked" | "latest"` overrides the automatic
+ * choice for a repository that wants to pin it. */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { flushCapture } from "../integrations/sync.js";
+import { writeFileAtomic } from "./io.js";
+import { hunchPaths } from "./paths.js";
+import { evaluateTaskRanking } from "./taskRankEval.js";
+import { reportHash } from "./taskReport.js";
+import { FindingSchema } from "./types.js";
+export const RANK_EVAL_CACHE_SCHEMA = "hunch.task-rank-eval-cache/1";
+/** The decision's threshold: the kill rule needs at least this many task records. */
+export const KILL_MIN_TASKS = 200;
+function cachePath(root) {
+    return join(root, ".hunch-cache", "task-rank-eval.json");
+}
+export function readRankEvalCache(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath(root), "utf8"));
+        return parsed && parsed.schema === RANK_EVAL_CACHE_SCHEMA && parsed.report ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function corpusHash(store) {
+    const records = store.recs("tasks");
+    const ids = records.map((r) => `${r.id}:${r.report_hash}`).sort();
+    return { hash: reportHash(ids), count: records.length };
+}
+/** Recompute when the corpus changed; otherwise return the cached report. Never throws. */
+export function refreshRankEval(root, store, options = {}) {
+    try {
+        const { hash, count } = corpusHash(store);
+        const cached = readRankEvalCache(root);
+        if (!options.force && cached && cached.corpus_hash === hash)
+            return cached;
+        const report = evaluateTaskRanking(store.recs("tasks"));
+        const next = { schema: RANK_EVAL_CACHE_SCHEMA, computed_at: (options.now ?? (() => new Date().toISOString()))(), records: count, corpus_hash: hash, report };
+        try {
+            const dir = join(root, ".hunch-cache");
+            if (!existsSync(dir))
+                return next; // no cache dir: still return the fresh report, just do not persist
+            writeFileAtomic(cachePath(root), JSON.stringify(next, null, 2));
+        }
+        catch { /* cache is a convenience */ }
+        if (cached && cached.report.verdict !== report.verdict)
+            noteVerdictChange(root, store, cached, next);
+        return next;
+    }
+    catch {
+        return readRankEvalCache(root);
+    }
+}
+/** The rule from the decision, applied to a report. */
+export function modeFromReport(report) {
+    if (!report)
+        return { mode: "ranked", reason: "no evaluation yet" };
+    if (report.verdict === "baseline-better" && report.tasks >= KILL_MIN_TASKS) {
+        return { mode: "latest", reason: `ranked selection lost to latest3 on ${report.split.evaluated} cases (Hit@5 ${pct(report.rankers[0]?.hit5)} vs ${pct(report.rankers[1]?.hit5)}, CI [${pts(report.delta_hit5.ci95[0])}, ${pts(report.delta_hit5.ci95[1])}])` };
+    }
+    return { mode: "ranked", reason: report.verdict === "ranked-better" ? "ranked selection beats latest3" : report.verdict === "baseline-better" ? `latest3 ahead but only ${report.tasks} of ${KILL_MIN_TASKS} task records; not yet decisive` : `evaluation ${report.verdict} (${report.split.evaluated} cases)` };
+}
+/** What delivery should do right now for this repository. */
+export function resolveTaskRankingMode(root, store) {
+    let override;
+    try {
+        override = JSON.parse(readFileSync(join(root, ".hunch", "local.json"), "utf8")).taskRanking;
+    }
+    catch { /* none */ }
+    const cache = refreshRankEval(root, store);
+    if (override === "ranked" || override === "latest")
+        return { mode: override, reason: `pinned by .hunch/local.json taskRanking`, source: "override", cache };
+    const { mode, reason } = modeFromReport(cache?.report);
+    return { mode, reason, source: "auto", cache };
+}
+function pct(x) { return x === undefined ? "–" : `${Math.round(x * 100)}%`; }
+function pts(x) { return `${x >= 0 ? "+" : ""}${Math.round(x * 100)}`; }
+/** One line for `hunch now` and the task stats. */
+export function rankingStatusLine(resolved) {
+    const r = resolved.cache?.report;
+    if (!r)
+        return `task ranking: ${resolved.mode} · no evaluation yet (no finished task records)`;
+    const ranked = r.rankers.find((x) => x.name === "ranked"), base = r.rankers.find((x) => x.name === "latest3");
+    return `task ranking: ${resolved.mode}${resolved.source === "override" ? " (pinned)" : ""} · Hit@5 ranked ${pct(ranked?.hit5)} vs latest3 ${pct(base?.hit5)}, CI [${pts(r.delta_hit5.ci95[0])}, ${pts(r.delta_hit5.ci95[1])}], n=${r.split.evaluated} of ${r.tasks} records · ${r.verdict}${r.tasks < KILL_MIN_TASKS ? ` · kill rule armed at ${KILL_MIN_TASKS} records` : ""}`;
+}
+/** A verdict change is memory: record it once, through the normal capture path. */
+function noteVerdictChange(root, store, prev, next) {
+    try {
+        const title = `Task ranking evaluation verdict changed: ${prev.report.verdict} → ${next.report.verdict} at ${next.records} task records`;
+        const id = `fnd_${reportHash(title).slice(7, 17)}`;
+        if (store.getRec("findings", id))
+            return;
+        const r = next.report;
+        const finding = FindingSchema.parse({
+            id, title,
+            observation: `Automatic leave-one-out evaluation of task-record ranking (dec_66925aa0ee) recomputed after a task record was written. Ranked Hit@5 ${pct(r.rankers[0]?.hit5)} vs latest3 ${pct(r.rankers[1]?.hit5)}, MRR ${r.rankers[0]?.mrr.toFixed(2)} vs ${r.rankers[1]?.mrr.toFixed(2)}, paired bootstrap CI on Hit@5 [${pts(r.delta_hit5.ci95[0])}, ${pts(r.delta_hit5.ci95[1])}] over ${r.split.evaluated} cases (${r.evaluable} evaluable of ${r.tasks}). Delivery mode now: ${modeFromReport(r).mode} — ${modeFromReport(r).reason}.`,
+            evidence: [`hunch task rank-eval --json (computed ${next.computed_at})`, `.hunch-cache/task-rank-eval.json corpus ${next.corpus_hash}`],
+            severity: next.report.verdict === "baseline-better" ? "high" : "low",
+            triage: "open",
+            affected_files: ["src/core/taskRanking.ts", "src/core/taskRankingMode.ts"],
+            observed_at: next.computed_at,
+            provenance: { source: "task_rank_eval", confidence: 0.9, evidence: ["hunch task rank-eval"], last_verified: next.computed_at },
+        });
+        store.putCapture("findings", finding, false);
+        flushCapture(store, hunchPaths(root).hunch, false, `hunch: capture ${id}`);
+    }
+    catch { /* the cache still carries the verdict; memory of the change is best-effort */ }
+}
+//# sourceMappingURL=taskRankingMode.js.map

package/dist/core/taskRecord.js

@@ -17,6 +17,7 @@ import { hunchPaths } from "./paths.js";
 import { isEmptyTaskReport, readTaskReport, reportHash } from "./taskReport.js";
 import { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { ENTITY_KINDS, TaskRecordSchema } from "./types.js";
+import { refreshRankEval } from "./taskRankingMode.js";
 function localConfig(root) {
     try {
         return JSON.parse(readFileSync(join(root, ".hunch", "local.json"), "utf8"));
@@ -159,6 +160,8 @@ export function persistTaskRecord(root, store, taskId, options = {}) {
     store.reindex();
     const flushNow = options.flush ?? taskRecordFlushMode(root) === "each";
     const flushed = flushNow ? flushCapture(store, hunchPaths(root).hunch, home === "private", `hunch: task ${record.id}`) : null;
+    // The ranking evaluation follows the corpus: recomputed here, read at delivery. Never blocks a finish.
+    refreshRankEval(root, store);
     return { record: stored, home, flushed, changed: true };
 }
 const GRAPH_SCOPE = reportHash("graph-record");

package/dist/mcp/server.js

@@ -1113,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 ? [] : taskSelectionSupplements(store.selectTasksFor(target, buildTaskRankingQuery(root, task_id ?? null, target)), target);
+        const recentTasks = asOf ? [] : taskSelectionSupplements(store.selectTasksAuto(target, buildTaskRankingQuery(root, task_id ?? null, target)), target);
         const options = {
             root,
             symbols: store.recs("symbols"),

package/dist/mcp/taskReportTools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { TaskIdSchema, ReportClaimSchema, LessonReferenceSchema, finishReportTask, listReportTasks, readTaskReport, readLessonHistory, recordReportClaim, reportPresentationEnabled, startReportTask } from "../core/taskReport.js";
 import { persistTaskRecord } from "../core/taskRecord.js";
 import { reportSourceSnapshot, runReportConformance } from "../core/taskReportEvidence.js";
@@ -53,7 +53,11 @@ export function boundedTaskReportForHost(report) {
 function verificationLauncher() {
     const dev = import.meta.url.endsWith(".ts");
     const entry = fileURLToPath(new URL(`../cli/index.${dev ? "ts" : "js"}`, import.meta.url));
-    const argv = [process.execPath, ...(dev ? ["--import", fileURLToPath(import.meta.resolve("tsx"))] : []), entry];
+    // `--import` takes a URL. Converting the resolved loader to a path made Node on
+    // Windows reject it ("Received protocol 'c:'"), so every verification launched
+    // from a source checkout there failed before running and cards showed no check.
+    const loader = import.meta.resolve("tsx");
+    const argv = [process.execPath, ...(dev ? ["--import", loader.startsWith("file:") ? loader : pathToFileURL(loader).href] : []), entry];
     const quote = (s) => process.platform === "win32" ? `'${s.replace(/'/g, "''")}'` : `'${s.replace(/'/g, "'\\''")}'`;
     return { argv, shell: `${process.platform === "win32" ? "& " : ""}${argv.map(quote).join(" ")}` };
 }

package/dist/store/hunchStore.d.ts

@@ -428,7 +428,11 @@ export declare class HunchStore {
     /** Gate → score → slots for one target and the current task's query (dec_66925aa0ee). */
     selectTasksFor(target: string, query: RankingQuery, options?: SlotOptions & {
         weights?: Readonly<RankingWeights>;
+        mode?: "ranked" | "latest";
     }): TaskSelection;
+    /** What delivery uses: the mode comes from the automatic evaluation (or a
+     *  local pin), never from a flag the caller has to remember. */
+    selectTasksAuto(target: string, query: RankingQuery): 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

@@ -22,7 +22,8 @@ import { gitCommonDir, gitWorktreeRoot, isolatedHeadSha, sameGitPublication, sco
 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 { normalizePath, rankTaskRecords, recordIdsOf, selectLatestTasks, selectTaskSlots } from "../core/taskRanking.js";
+import { resolveTaskRankingMode } from "../core/taskRankingMode.js";
 import { currentForTopic, isInForce } from "../core/topics.js";
 import { edgeId } from "../core/ids.js";
 import { isStrictBlocker, isVetoBlocker } from "../core/strictgate.js";
@@ -1560,9 +1561,18 @@ export class HunchStore {
     /** 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);
+        const candidates = this.taskCandidates(target, query, ctx);
+        if (options.mode === "latest")
+            return selectLatestTasks(candidates, query, ctx);
+        const ranked = rankTaskRecords(candidates, query, ctx, options.weights);
         return selectTaskSlots(ranked, options);
     }
+    /** What delivery uses: the mode comes from the automatic evaluation (or a
+     *  local pin), never from a flag the caller has to remember. */
+    selectTasksAuto(target, query) {
+        const resolved = resolveTaskRankingMode(this.paths.root, this);
+        return this.selectTasksFor(target, query, { mode: resolved.mode });
+    }
     /** 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.37.0",
+  "version": "1.37.1",
   "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.37.0",
+  "version": "1.37.1",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.37.0",
+      "version": "1.37.1",
       "runtimeHint": "npx",
       "packageArguments": [
         {