@davesheffer/hunch 1.37.0 → 1.38.0

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";
@@ -87,7 +88,8 @@ import { recordServed, servedSummary } from "../core/served.js";
 import { recordTaskDelivery, reportActivity, reportPresentationEnabled, unseenLessons } from "../core/taskReport.js";
 import { snapshotDeliveredRecords } from "../core/taskReportEvidence.js";
 import { renderRecalledLine } from "../core/taskReportRender.js";
-import { hookReportTaskId, nativeHookCwd, startHookReport, stopHookReport, observeHookDenial } from "../core/taskReportHook.js";
+import { closeHookTask, hookReportTaskId, nativeHookCwd, startHookReport, stopHookReport, observeHookDenial } from "../core/taskReportHook.js";
+import { persistTaskRecord } from "../core/taskRecord.js";
 import { recordHookObservation } from "../core/hookObservations.js";
 import { contextHookOutput, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
 import { PIPELINE_LOOP, armExecutionObligations, beforeEditProbeVerdict, compileExecutableProbes, environmentExecutableProbes, environmentExecutionObligations, executionObligationBrief, isProductPath, loadPipelineState, onCommand, onEdit, onPrompt, onSkill, pipelineEnabled, proofCheckpoint, savePipelineState, stopVerdict, unverifiedNag, } from "../core/pipeline.js";
@@ -4212,7 +4214,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) {
@@ -4547,6 +4549,16 @@ program
                     return;
                 }
             }
+            // The turn is over: close the prompt's task and keep its record, whether
+            // or not the agent called finish. Fail-open: the card below still renders.
+            try {
+                const closed = closeHookTask(root, provider, evt);
+                if (closed) {
+                    store ??= new HunchStore(paths);
+                    persistTaskRecord(root, store, closed);
+                }
+            }
+            catch { /* the ledger and the card remain authoritative; the next finish retries */ }
             const report = stopHookReport(root, provider, evt);
             if (report)
                 console.log(JSON.stringify(report));
@@ -4882,7 +4894,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 +6485,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");
@@ -89,7 +90,7 @@ export function registerTaskReportCommands(program, openStore) {
             return;
         }
         for (const s of summaries)
-            console.log(`${s.task.started_at.slice(0, 16).replace("T", " ")}  ${s.task.task_id}  ${s.task.state.padEnd(11)} ${renderTaskStatusLine(s) || "nothing observed"}${s.durable ? `  [graph: ${s.durable.home}]` : ""}`);
+            console.log(`${s.task.started_at.slice(0, 16).replace("T", " ")}  ${s.task.task_id}  ${s.task.state.padEnd(11)} ${renderTaskStatusLine(s) || "nothing observed"}${s.durable ? `  [graph: ${s.durable.home}${s.task.episode ? ` as ${s.task.episode}` : ""}]` : ""}${s.task.continues && !s.durable ? `  (continues ${s.task.continues})` : ""}`);
     });
     task.command("stats").description("Adherence over a window: how many prompts Hunch reached (delivery), checked, saved, or guarded — from the ledger, never from agent claims")
         .option("--days <days>", "window in days", "7")
@@ -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.d.ts

@@ -12,8 +12,17 @@ export declare function taskRecordFlushMode(root: string): "each" | "batch";
 /** A delivery target that names code (a path or dotted symbol), not a task
  * phrase like "fix the login redirect". Phrases never become file anchors. */
 export declare function targetLooksLikePath(target: string): boolean;
-/** The durable summary of a finished report, or null when there is nothing to keep. */
-export declare function taskRecordFromReport(report: TaskReport): TaskRecord | null;
+/** The durable summary of a finished report, or null when there is nothing to keep.
+ * `touched` adds file anchors the report itself cannot know (git-side work while
+ * the task was open); report-derived files come first under the cap. */
+export declare function taskRecordFromReport(report: TaskReport, touched?: readonly string[]): TaskRecord | null;
+/** One record for an EPISODE: a prompt's report and the reports of the prompts
+ * that continued it in the same session (oldest first). Observations are the
+ * union in order, the id and start are the head's, the title is the first
+ * non-generic one, state and finish come from the latest closed member, and
+ * the report hash covers every member so a refresh is idempotent. Members
+ * still open contribute nothing yet. Null when nothing was observed at all. */
+export declare function taskRecordFromReports(reports: readonly TaskReport[], touched?: readonly string[]): TaskRecord | null;
 /** Where the record belongs. Anything that touched the private overlay — a
  * private save, or a delivered lesson that lives only there — must not be named
  * in a public record; the store's own routing (unified/shared mode) wins first. */

package/dist/core/taskRecord.js

@@ -14,9 +14,11 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { flushCapture } from "../integrations/sync.js";
 import { hunchPaths } from "./paths.js";
-import { isEmptyTaskReport, readTaskReport, reportHash } from "./taskReport.js";
+import { episodeTasks, isEmptyTaskReport, readTaskReport, reportHash } from "./taskReport.js";
 import { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { ENTITY_KINDS, TaskRecordSchema } from "./types.js";
+import { refreshRankEval } from "./taskRankingMode.js";
+import { gitTouchedFiles } from "./taskTouched.js";
 function localConfig(root) {
     try {
         return JSON.parse(readFileSync(join(root, ".hunch", "local.json"), "utf8"));
@@ -46,50 +48,76 @@ export function targetLooksLikePath(target) {
         return false;
     return /[./\\]/.test(t) && !/^\.+$/.test(t);
 }
-/** The durable summary of a finished report, or null when there is nothing to keep. */
-export function taskRecordFromReport(report) {
-    const { task } = report;
-    if (task.state === "open" || !task.finished_at)
-        return null;
-    if (isEmptyTaskReport(report))
+/** The durable summary of a finished report, or null when there is nothing to keep.
+ * `touched` adds file anchors the report itself cannot know (git-side work while
+ * the task was open); report-derived files come first under the cap. */
+export function taskRecordFromReport(report, touched = []) {
+    return taskRecordFromReports([report], touched);
+}
+const GENERIC_TASK_TITLES = new Set(["Assistant task", "Claude task"]);
+const COVERAGE_RANK = { "no-delivery-observed": 0, "no-relevant-memory": 1, delivered: 2 };
+/** One record for an EPISODE: a prompt's report and the reports of the prompts
+ * that continued it in the same session (oldest first). Observations are the
+ * union in order, the id and start are the head's, the title is the first
+ * non-generic one, state and finish come from the latest closed member, and
+ * the report hash covers every member so a refresh is idempotent. Members
+ * still open contribute nothing yet. Null when nothing was observed at all. */
+export function taskRecordFromReports(reports, touched = []) {
+    const closed = reports.filter((r) => r.task.state !== "open" && r.task.finished_at);
+    if (!closed.length || closed.every((r) => isEmptyTaskReport(r)))
         return null;
+    const head = reports[0].task;
+    const last = closed.reduce((a, b) => (b.task.finished_at >= a.task.finished_at ? b : a));
+    const title = reports.map((r) => r.task.title).find((t) => !GENERIC_TASK_TITLES.has(t)) ?? head.title;
     const lessons = new Map();
-    for (const delivery of report.deliveries) {
-        for (const r of delivery.records) {
-            lessons.set(`${r.kind}:${r.record_id}:${r.content_hash}`, { kind: r.kind, record_id: r.record_id, content_hash: r.content_hash, title: r.title.slice(0, 200) });
-        }
-    }
     const files = new Set();
-    for (const d of report.deliveries)
-        if (d.target && targetLooksLikePath(d.target))
-            files.add(d.target.trim().replace(/\\/g, "/"));
-    for (const c of report.conformance)
-        for (const f of c.files)
-            files.add(f);
-    for (const r of report.refusals)
-        files.add(r.target);
     const latestRule = new Map();
-    for (const c of report.conformance) {
-        latestRule.set(`${c.kind}:${c.record_id}:${c.content_hash}`, { kind: c.kind, record_id: c.record_id, content_hash: c.content_hash, outcome: c.outcome });
+    const applied = [], saved = [], checks = [];
+    let refusals = 0, coverage = "no-delivery-observed", sourceSnapshot = null;
+    for (const report of closed) {
+        for (const delivery of report.deliveries) {
+            if (delivery.target && targetLooksLikePath(delivery.target))
+                files.add(delivery.target.trim().replace(/\\/g, "/"));
+            for (const r of delivery.records)
+                lessons.set(`${r.kind}:${r.record_id}:${r.content_hash}`, { kind: r.kind, record_id: r.record_id, content_hash: r.content_hash, title: r.title.slice(0, 200) });
+        }
+        for (const c of report.conformance) {
+            for (const f of c.files)
+                files.add(f);
+            latestRule.set(`${c.kind}:${c.record_id}:${c.content_hash}`, { kind: c.kind, record_id: c.record_id, content_hash: c.content_hash, outcome: c.outcome });
+        }
+        for (const r of report.refusals)
+            files.add(r.target);
+        applied.push(...report.claims.map((c) => ({ record_id: c.record_id, content_hash: c.content_hash, action: c.action.slice(0, 300), supported_by: c.supported_by })));
+        saved.push(...report.saves.map((s) => ({ kind: s.record.kind, record_id: s.record.record_id, content_hash: s.record.content_hash, home: s.home, operation: s.operation, durability: s.durability })));
+        checks.push(...report.checks.map((c) => ({ label: c.label, state: (c.cancelled ? "cancelled" : c.timed_out ? "timed out" : c.exit_code === 0 ? "passed" : "failed"), exit_code: c.exit_code })));
+        refusals += report.refusals.length;
+        if (COVERAGE_RANK[report.coverage] > COVERAGE_RANK[coverage])
+            coverage = report.coverage;
+        const lastCheck = report.checks.at(-1);
+        if (lastCheck)
+            sourceSnapshot = lastCheck.after_snapshot ?? null;
     }
-    const lastCheck = report.checks.at(-1);
+    const fromReport = [...files].sort();
+    const extra = [...new Set(touched.map((f) => f.trim().replace(/\\/g, "/")).filter((f) => f && !files.has(f)))].sort();
     return TaskRecordSchema.parse({
-        id: task.task_id,
-        title: task.title,
-        state: task.state,
-        started_at: task.started_at,
-        finished_at: task.finished_at,
-        coverage: report.coverage,
+        id: head.task_id,
+        title,
+        state: last.task.state,
+        started_at: head.started_at,
+        finished_at: last.task.finished_at,
+        coverage,
         lessons: [...lessons.values()],
-        applied: report.claims.map((c) => ({ record_id: c.record_id, content_hash: c.content_hash, action: c.action.slice(0, 300), supported_by: c.supported_by })),
-        saved: report.saves.map((s) => ({ kind: s.record.kind, record_id: s.record.record_id, content_hash: s.record.content_hash, home: s.home, operation: s.operation, durability: s.durability })),
-        checks: report.checks.map((c) => ({ label: c.label, state: c.cancelled ? "cancelled" : c.timed_out ? "timed out" : c.exit_code === 0 ? "passed" : "failed", exit_code: c.exit_code })),
+        applied,
+        saved,
+        checks: checks.slice(-64),
         conformance: [...latestRule.values()],
-        refusals: report.refusals.length,
-        files: [...files].sort().slice(0, 64),
-        source_snapshot: lastCheck?.after_snapshot ?? null,
-        report_hash: report.content_hash,
-        provenance: { source: "task_report", confidence: 1, evidence: [`hunch report ${task.task_id}`], last_verified: task.finished_at },
+        refusals,
+        files: [...fromReport, ...extra].slice(0, 64),
+        source_snapshot: sourceSnapshot,
+        // One member: its own hash, so records written before episodes existed do not all refresh.
+        report_hash: closed.length === 1 ? closed[0].content_hash : reportHash(closed.map((r) => r.content_hash)),
+        provenance: { source: "task_report", confidence: 1, evidence: closed.slice(0, 20).map((r) => `hunch report ${r.task.task_id}`), last_verified: last.task.finished_at },
     });
 }
 /** Where the record belongs. Anything that touched the private overlay — a
@@ -144,13 +172,35 @@ export function computeSupersedes(record, others, limit = 20) {
 export function persistTaskRecord(root, store, taskId, options = {}) {
     if (!taskRecordsEnabled(root))
         return null;
-    const report = readTaskReport(root, taskId, reportSourceSnapshot(root).hash);
-    const built = taskRecordFromReport(report);
+    const snapshot = reportSourceSnapshot(root).hash;
+    const own = readTaskReport(root, taskId, snapshot);
+    if (own.task.state === "open")
+        return null;
+    // The record covers the whole episode: this prompt and the prompts of the
+    // same session it continued. Work done outside an instrumented editor (shell
+    // edits, rebases, release commits) still anchors it: git says what changed
+    // while the episode was open.
+    const headId = own.task.episode ?? own.task.task_id;
+    const members = headId === own.task.task_id && !own.task.episode ? [own.task] : episodeTasks(root, headId);
+    const reports = (members.length ? members : [own.task]).map((t) => (t.task_id === taskId ? own : readTaskReport(root, t.task_id, snapshot)));
+    const window = { from: reports[0].task.started_at, to: reports.reduce((max, r) => (r.task.finished_at && (!max || r.task.finished_at > max) ? r.task.finished_at : max), null) };
+    let built = taskRecordFromReports(reports, gitTouchedFiles(root, window.from, window.to));
     if (!built)
         return null;
+    let inPrivate = store.hasPrivate ? store.getPrivateRec("tasks", built.id) : undefined;
+    let inPublic = store.json.get("tasks", built.id);
+    // A record never changes home. If the episode's record already lives in the
+    // public store and this prompt brought private-only memory into it, the
+    // episode splits here: this prompt keeps its own record instead of naming
+    // private memory in a public one.
+    if (inPublic && !inPrivate && taskRecordHome(store, built) === "private" && built.id !== taskId) {
+        built = taskRecordFromReports([own], gitTouchedFiles(root, own.task.started_at, own.task.finished_at));
+        if (!built)
+            return null;
+        inPrivate = store.hasPrivate ? store.getPrivateRec("tasks", built.id) : undefined;
+        inPublic = store.json.get("tasks", built.id);
+    }
     const record = { ...built, supersedes: computeSupersedes(built, store.recs("tasks")) };
-    const inPrivate = store.hasPrivate ? store.getPrivateRec("tasks", record.id) : undefined;
-    const inPublic = store.json.get("tasks", record.id);
     const home = inPrivate ? "private" : inPublic ? "public" : taskRecordHome(store, record);
     const existing = home === "private" ? inPrivate : inPublic;
     if (existing && existing.report_hash === record.report_hash)
@@ -159,6 +209,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");
@@ -199,7 +251,10 @@ export function mergeDurableTaskSummaries(store, summaries, limit = 30) {
     const seen = new Set();
     const merged = summaries.map((s) => {
         seen.add(s.task.task_id);
-        const home = homes.get(s.task.task_id);
+        // A continued prompt's record lives under its episode head.
+        const home = homes.get(s.task.task_id) ?? homes.get(s.task.episode ?? "");
+        if (s.task.episode)
+            seen.add(s.task.episode);
         return { ...s, durable: home ? { home } : null };
     });
     for (const r of records.values()) {

package/dist/core/taskReport.d.ts

@@ -123,6 +123,13 @@ declare const TaskSchema: z.ZodObject<{
         completed: "completed";
         interrupted: "interrupted";
     }>;
+    closed_by: z.ZodOptional<z.ZodEnum<{
+        host: "host";
+        agent: "agent";
+    }>>;
+    session_key: z.ZodOptional<z.ZodString>;
+    continues: z.ZodOptional<z.ZodString>;
+    episode: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ReportTask = z.infer<typeof TaskSchema>;
 export interface TaskDelivery {
@@ -200,7 +207,26 @@ export declare function readLessonHistory(root: string, reference: LessonReferen
     limit?: number;
     before?: number;
 }): LessonHistory;
-export declare function startReportTask(root: string, title: string, taskId?: string): ReportTask;
+export interface TaskLinks {
+    session_key?: string;
+    continues?: string;
+    episode?: string;
+}
+export declare function startReportTask(root: string, title: string, taskId?: string, links?: TaskLinks): ReportTask;
+/** A prompt that follows another in the same session within this window is the
+ * same work: its task continues the previous one and shares its episode. */
+export declare const CONTINUATION_WINDOW_MS: number;
+/** The links a new prompt's task takes from the latest task of its session, or
+ * null when that task is too old (measured from its close, or its start when it
+ * was never closed) to be the same work. */
+export declare function continuationLinks(previous: ReportTask | null, nowMs?: number): {
+    continues: string;
+    episode: string;
+} | null;
+/** The most recent task of a session in this worktree, or null. */
+export declare function latestSessionTask(root: string, sessionKey: string): ReportTask | null;
+/** Every task of an episode, oldest first: the head and the prompts that continued it. */
+export declare function episodeTasks(root: string, headId: string): ReportTask[];
 /** The record revisions among `records` that this task has not received before.
  * Powers the one-line "Hunch recalled …" indication on a lesson's FIRST delivery
  * in a task; repeats of the same revision stay silent (deduplicated per task and
@@ -223,8 +249,21 @@ export declare function recordReportRefusal(root: string, taskId: string, refusa
 export declare function recordReportConformance(root: string, taskId: string, conformance: ReportConformance): string;
 /** Only the local runner calls this. MCP never accepts a claimed successful check. */
 export declare function recordReportCheck(root: string, taskId: string, check: ReportCheck): string;
-export declare function beginReportCheck(root: string, taskId: string, label: string): string;
-export declare function finishReportTask(root: string, taskId: string, state?: "completed" | "interrupted"): ReportTask;
+/** A start without a result blocks completion only while the runner could still
+ * deliver one: its own timeout plus a minute of grace. After that the runner is
+ * gone (a killed process, a closed laptop) and the report's unknowns already say
+ * the result was not retained; freezing the task forever would add nothing.
+ * Starts recorded before the timeout was retained use the verification ceiling. */
+export declare const CHECK_RESULT_GRACE_MS = 60000;
+export declare const MAX_PENDING_CHECK_MS: number;
+export declare function beginReportCheck(root: string, taskId: string, label: string, timeoutMs?: number): string;
+/** `by: "host"` is the lifecycle hook closing the prompt's task at Stop. It is
+ * provisional: a later observation reopens the task (see appendEvent) and an
+ * explicit agent finish, with any outcome, replaces it. Pending verification
+ * keeps the task open for either closer. */
+export declare function finishReportTask(root: string, taskId: string, state?: "completed" | "interrupted", options?: {
+    by?: "agent" | "host";
+}): ReportTask;
 /** A report with no observation of any kind. Presentation surfaces may stay
  * silent for it; the task row itself is retained so "never touched Hunch" is
  * still countable (hunch report / the VS Code view / task list). */

package/dist/core/taskReport.js

@@ -82,6 +82,19 @@ const TaskSchema = z.object({
     task_id: TaskIdSchema, scope: hashSchema, title: safeText(200),
     started_at: z.string().datetime(), finished_at: z.string().datetime().nullable(),
     state: z.enum(["open", "completed", "interrupted"]),
+    /** Who closed the task. "host": the lifecycle hook at Stop, a provisional
+     * close that a continuation reopens and an explicit agent finish overrides.
+     * Absent on rows written before this field existed (agent closes). */
+    closed_by: z.enum(["agent", "host"]).optional(),
+    /** Continuity across the prompts of one host session. `session_key` is a hash
+     * of (root, provider, session, agent), never the identifier itself; `continues`
+     * names the previous prompt's task when this prompt followed it within the
+     * continuation window; `episode` names the first task of that chain, the id
+     * the chain's graph record is written under. Absent on older rows and on
+     * tasks started without a host session (one task, one episode). */
+    session_key: hashSchema.optional(),
+    continues: TaskIdSchema.optional(),
+    episode: TaskIdSchema.optional(),
 }).strict();
 export const LessonReferenceSchema = z.object({
     kind: safeText(64), record_id: safeText(512), content_hash: hashSchema.optional(),
@@ -227,9 +240,9 @@ function transaction(db, run, readOnly = false) {
         throw error;
     }
 }
-export function startReportTask(root, title, taskId) {
+export function startReportTask(root, title, taskId, links = {}) {
     const task = TaskSchema.parse({ task_id: taskId ?? `htask_${randomBytes(12).toString("hex")}`,
-        scope: scopeOf(root), title, started_at: new Date().toISOString(), finished_at: null, state: "open" });
+        scope: scopeOf(root), title, started_at: new Date().toISOString(), finished_at: null, state: "open", ...links });
     // Local observations have a bounded lifetime; durable project memory is untouched.
     pruneReportHistory(root);
     return taskDb(root, db => transaction(db, () => {
@@ -244,6 +257,31 @@ export function startReportTask(root, title, taskId) {
         return task;
     }));
 }
+/** A prompt that follows another in the same session within this window is the
+ * same work: its task continues the previous one and shares its episode. */
+export const CONTINUATION_WINDOW_MS = 30 * 60_000;
+/** The links a new prompt's task takes from the latest task of its session, or
+ * null when that task is too old (measured from its close, or its start when it
+ * was never closed) to be the same work. */
+export function continuationLinks(previous, nowMs = Date.now()) {
+    if (!previous)
+        return null;
+    const reference = Date.parse(previous.finished_at ?? previous.started_at);
+    if (!Number.isFinite(reference) || nowMs - reference > CONTINUATION_WINDOW_MS)
+        return null;
+    return { continues: previous.task_id, episode: previous.episode ?? previous.task_id };
+}
+/** The most recent task of a session in this worktree, or null. */
+export function latestSessionTask(root, sessionKey) {
+    return taskDb(root, db => {
+        const row = db.prepare("SELECT body FROM report_tasks WHERE scope IN (?, ?, ?) AND json_extract(body, '$.session_key') = ? ORDER BY rowid DESC LIMIT 1").get(...scopePair(root), sessionKey);
+        return row ? TaskSchema.parse(JSON.parse(row.body)) : null;
+    });
+}
+/** Every task of an episode, oldest first: the head and the prompts that continued it. */
+export function episodeTasks(root, headId) {
+    return taskDb(root, db => db.prepare("SELECT body FROM report_tasks WHERE task_id = ? OR json_extract(body, '$.episode') = ? ORDER BY rowid").all(headId, headId).map(r => TaskSchema.parse(JSON.parse(r.body))));
+}
 function appendEvent(root, taskId, kind, body, eventId) {
     const encoded = JSON.stringify(body);
     if (Buffer.byteLength(encoded) > MAX_EVENT_BYTES)
@@ -260,8 +298,14 @@ function appendEvent(root, taskId, kind, body, eventId) {
                 throw new Error("report event identity conflicts with existing evidence");
             return id;
         }
-        if (task.state !== "open" && !(kind === "check" && task.state === "interrupted"))
-            throw new Error("task is already closed; start a new task for new work");
+        if (task.state !== "open" && !(kind === "check" && task.state === "interrupted")) {
+            if (task.closed_by !== "host")
+                throw new Error("task is already closed; start a new task for new work");
+            // The host closed this task at Stop, but the turn went on (another hook's
+            // block, a resumed prompt). Reopen it for the new observation; the next
+            // Stop closes it again and the graph record is refreshed from the report.
+            db.prepare("UPDATE report_tasks SET body = ? WHERE task_id = ?").run(JSON.stringify(TaskSchema.parse({ ...task, state: "open", finished_at: null, closed_by: undefined })), taskId);
+        }
         if (kind === "check") {
             const check = ReportCheckSchema.parse(body);
             if (!check.check_id || !db.prepare("SELECT event_id FROM report_events WHERE event_id = ? AND task_id = ? AND kind = 'check-start'").get(check.check_id, taskId))
@@ -269,7 +313,7 @@ function appendEvent(root, taskId, kind, body, eventId) {
         }
         const { total, bytes, pending } = db.prepare(`SELECT COUNT(*) AS total,
       COALESCE(SUM(length(CAST(body AS BLOB))), 0) AS bytes,
-      SUM(CASE WHEN kind = 'check-start' THEN 1 WHEN kind = 'check' AND json_extract(body, '$.check_id') IS NOT NULL THEN -1 ELSE 0 END) AS pending
+      SUM(CASE WHEN kind = 'check-start' AND (julianday('now') - julianday(at)) * 86400000 < COALESCE(json_extract(body, '$.timeout_ms'), ${MAX_PENDING_CHECK_MS}) + ${CHECK_RESULT_GRACE_MS} THEN 1 WHEN kind = 'check' AND json_extract(body, '$.check_id') IS NOT NULL THEN -1 ELSE 0 END) AS pending
       FROM report_events WHERE task_id = ?`).get(taskId);
         const reserved = Math.max(0, (pending ?? 0) + (kind === "check-start" ? 1 : kind === "check" ? -1 : 0));
         if (total + 1 + reserved > MAX_EVENTS || bytes + Buffer.byteLength(encoded) + reserved * MAX_EVENT_BYTES > MAX_TASK_BYTES)
@@ -361,23 +405,41 @@ export function recordReportCheck(root, taskId, check) {
         throw new Error("verification result requires a reserved check identity");
     return appendEvent(root, taskId, "check", value, `hev_${reportHash({ taskId, check: value.check_id }).slice(7, 31)}`);
 }
-export function beginReportCheck(root, taskId, label) {
-    return appendEvent(root, taskId, "check-start", { label: safeText(200).parse(label) });
+/** A start without a result blocks completion only while the runner could still
+ * deliver one: its own timeout plus a minute of grace. After that the runner is
+ * gone (a killed process, a closed laptop) and the report's unknowns already say
+ * the result was not retained; freezing the task forever would add nothing.
+ * Starts recorded before the timeout was retained use the verification ceiling. */
+export const CHECK_RESULT_GRACE_MS = 60_000;
+export const MAX_PENDING_CHECK_MS = 6 * 60 * 60_000;
+export function beginReportCheck(root, taskId, label, timeoutMs) {
+    const timeout = Number.isInteger(timeoutMs) && timeoutMs > 0 ? { timeout_ms: timeoutMs } : {};
+    return appendEvent(root, taskId, "check-start", { label: safeText(200).parse(label), ...timeout });
 }
-export function finishReportTask(root, taskId, state = "completed") {
+/** `by: "host"` is the lifecycle hook closing the prompt's task at Stop. It is
+ * provisional: a later observation reopens the task (see appendEvent) and an
+ * explicit agent finish, with any outcome, replaces it. Pending verification
+ * keeps the task open for either closer. */
+export function finishReportTask(root, taskId, state = "completed", options = {}) {
+    const by = options.by ?? "agent";
     return taskDb(root, db => transaction(db, () => {
         const task = readTask(db, root, taskId);
         if (task.state !== "open") {
+            if (task.closed_by === "host" && by === "agent") {
+                const confirmed = TaskSchema.parse({ ...task, state, finished_at: task.state === state ? task.finished_at : new Date().toISOString(), closed_by: "agent" });
+                db.prepare("UPDATE report_tasks SET body = ? WHERE task_id = ?").run(JSON.stringify(confirmed), taskId);
+                return confirmed;
+            }
             if (task.state !== state)
                 throw new Error("task already closed with a different outcome");
             return task;
         }
         if (state === "completed") {
-            const { pending } = db.prepare(`SELECT SUM(CASE WHEN kind = 'check-start' THEN 1 WHEN kind = 'check' AND json_extract(body, '$.check_id') IS NOT NULL THEN -1 ELSE 0 END) AS pending FROM report_events WHERE task_id = ?`).get(taskId);
+            const { pending } = db.prepare(`SELECT SUM(CASE WHEN kind = 'check-start' AND (julianday('now') - julianday(at)) * 86400000 < COALESCE(json_extract(body, '$.timeout_ms'), ${MAX_PENDING_CHECK_MS}) + ${CHECK_RESULT_GRACE_MS} THEN 1 WHEN kind = 'check' AND json_extract(body, '$.check_id') IS NOT NULL THEN -1 ELSE 0 END) AS pending FROM report_events WHERE task_id = ?`).get(taskId);
             if ((pending ?? 0) > 0)
                 throw new Error("verification is still running or was interrupted; wait for its result or close the task as interrupted");
         }
-        const finished = TaskSchema.parse({ ...task, state, finished_at: new Date().toISOString() });
+        const finished = TaskSchema.parse({ ...task, state, finished_at: new Date().toISOString(), closed_by: by });
         db.prepare("UPDATE report_tasks SET body = ? WHERE task_id = ?").run(JSON.stringify(finished), taskId);
         return finished;
     }));

package/dist/core/taskReportEvidence.js

@@ -96,7 +96,7 @@ export function reportSourceSnapshot(root) {
  * `not-exercised` or `unavailable` — never "satisfied" by file overlap. */
 export function runReportConformance(root, store, taskId) {
     const report = readTaskReport(root, taskId);
-    if (report.task.state !== "open")
+    if (report.task.state !== "open" && report.task.closed_by !== "host")
         throw new Error("cannot evaluate rules for a closed task");
     const delivered = [...new Map(report.deliveries.flatMap(d => d.records).filter(r => r.kind === "constraints" || r.kind === "decisions").map(r => [`${r.kind}:${r.record_id}:${r.content_hash}`, r])).values()];
     if (!delivered.length)
@@ -203,12 +203,12 @@ export async function runReportCheck(root, taskId, command, label, timeoutMs = 1
         throw new Error(`verification timeout must be between 1 and ${MAX_CHECK_TIMEOUT_MS} ms`);
     options.signal?.throwIfAborted();
     const task = readTaskReport(root, taskId).task;
-    if (task.state !== "open")
+    if (task.state !== "open" && task.closed_by !== "host")
         throw new Error("cannot verify a closed task");
     const before = reportSourceSnapshot(root);
     // Validate sensitive arguments before executing or writing anything.
     ReportCheckSchema.parse({ label, command, exit_code: null, output_hash: reportHash(""), before_snapshot: before.hash, after_snapshot: null, snapshot_limitations: before.limitations, timed_out: false, source: "local-command-runner" });
-    const checkId = beginReportCheck(root, taskId, label);
+    const checkId = beginReportCheck(root, taskId, label, timeoutMs);
     const result = await new Promise((resolveResult) => {
         // Windows launchers (npx.cmd, npm.cmd, other .cmd/.bat shims) cannot be spawned
         // without a shell; resolve them first so a check actually runs instead of

package/dist/core/taskReportHook.d.ts

@@ -21,8 +21,17 @@ export declare function hookReportTaskId(root: string, provider: HookProvider, e
  * No raw prompt, host session identifier, or transcript is retained; a repository
  * that opts in (`taskTitles: "prompt"`) keeps only a bounded first-line title. */
 export declare function startHookReport(root: string, provider: HookProvider, event: HunchHookInput): string | null;
-/** A presentation notice never denies Stop or injects another model turn. Stop
- * can precede another hook's continuation, so it does not close an open task.
+/** Stop ends the turn, so the prompt's task closes here as a HOST close: the
+ * ledger says the task completed even when the agent never called finish, and
+ * a task with observations becomes a graph record without anyone's cooperation.
+ * The close is provisional because Stop can precede another hook's
+ * continuation: the next observation reopens the task and the following Stop
+ * closes it again (the record is refreshed from the report). An explicit agent
+ * finish with any outcome overrides a host close. Pending verification keeps
+ * the task open. Returns the task id when the task is closed after this call,
+ * so the caller can persist its record; null when nothing is closed. */
+export declare function closeHookTask(root: string, provider: HookProvider, event: HunchHookInput): string | null;
+/** A presentation notice never denies Stop or injects another model turn.
  * A prompt with no observation at all prints nothing: the empty task row stays
  * in the ledger (hunch task list, the VS Code Contribution view) so "never
  * touched Hunch" remains countable without a five-line notice per prompt. */

package/dist/core/taskReportHook.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { findRoot } from "./paths.js";
 import { canonicalReportRoot } from "./taskReportPaths.js";
 import { isCredentialFreeText } from "./types.js";
-import { isEmptyTaskReport, readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, startReportTask } from "./taskReport.js";
+import { continuationLinks, finishReportTask, isEmptyTaskReport, latestSessionTask, readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, startReportTask } from "./taskReport.js";
 import { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { renderTaskReport } from "./taskReportRender.js";
 /** The exact task identity a native host prompt maps to. */
@@ -98,9 +98,25 @@ export function startHookReport(root, provider, event) {
         return null;
     const cwdLiteral = JSON.stringify(cwd);
     const title = (promptTitlesEnabled(root) ? promptTaskTitle(event.prompt) : null) ?? NATIVE_TASK_TITLE;
+    // Continuity: a prompt that follows another of the same session within the
+    // window continues its task ("status", "next", "go" are the same work), and
+    // the episode's graph record is written under the first task's id. The key
+    // is a hash; the host session identifier itself is still never retained.
+    let links = {};
+    if (event.session_id) {
+        const sessionKey = reportHash([cwd, provider, event.session_id, event.agent_id ?? null]);
+        links = { session_key: sessionKey };
+        try {
+            const previous = latestSessionTask(root, sessionKey);
+            const continued = previous && previous.task_id !== id ? continuationLinks(previous) : null;
+            if (continued)
+                links = { ...links, ...continued };
+        }
+        catch { /* no continuity; still a task */ }
+    }
     let task;
     try {
-        task = startReportTask(root, title, id);
+        task = startReportTask(root, title, id, links);
     }
     catch (error) {
         // The same prompt identity may already be open: a release that called every
@@ -113,8 +129,39 @@ export function startHookReport(root, provider, event) {
     }
     return `Hunch has opened this prompt's report: ${task.task_id}. Reuse this exact ID for this prompt. Call hunch_task(action: "start", task_id: "${task.task_id}", title: ${JSON.stringify(task.title)}, cwd: ${cwdLiteral}) to obtain verification_argv; do not create another report. Pass this task_id and cwd: ${cwdLiteral} to hunch_context and decision/correction/finding captures, and pass the same cwd when finishing with hunch_task before responding. A host Stop notice will show the evidence even if no task-linked memory was observed.`;
 }
-/** A presentation notice never denies Stop or injects another model turn. Stop
- * can precede another hook's continuation, so it does not close an open task.
+/** Stop ends the turn, so the prompt's task closes here as a HOST close: the
+ * ledger says the task completed even when the agent never called finish, and
+ * a task with observations becomes a graph record without anyone's cooperation.
+ * The close is provisional because Stop can precede another hook's
+ * continuation: the next observation reopens the task and the following Stop
+ * closes it again (the record is refreshed from the report). An explicit agent
+ * finish with any outcome overrides a host close. Pending verification keeps
+ * the task open. Returns the task id when the task is closed after this call,
+ * so the caller can persist its record; null when nothing is closed. */
+export function closeHookTask(root, provider, event) {
+    let id;
+    try {
+        id = identity(root, provider, event);
+    }
+    catch {
+        return null;
+    }
+    if (!id || id === "legacy")
+        return null;
+    try {
+        const task = readTaskReport(root, id).task;
+        if (task.state === "interrupted")
+            return null;
+        if (task.state === "open")
+            finishReportTask(root, id, "completed", { by: "host" });
+        return id;
+    }
+    catch {
+        // No task for this prompt, or verification still running: leave it as it is.
+        return null;
+    }
+}
+/** A presentation notice never denies Stop or injects another model turn.
  * A prompt with no observation at all prints nothing: the empty task row stays
  * in the ledger (hunch task list, the VS Code Contribution view) so "never
  * touched Hunch" remains countable without a five-line notice per prompt. */

package/dist/core/taskTouched.d.ts

@@ -0,0 +1,5 @@
+export declare function gitTouchedFiles(root: string, startedAt: string, finishedAt: string | null, options?: {
+    limit?: number;
+    timeoutMs?: number;
+    now?: number;
+}): string[];

package/dist/core/taskTouched.js

@@ -0,0 +1,77 @@
+/** Files the repository shows as worked on while a task was open.
+ *
+ * The pre-edit hook only sees edits made through an instrumented editor tool.
+ * Work done from a shell (patch scripts, rebases, release commits) never
+ * produced a delivery, so the task record had no file anchor for it and the
+ * ranking could not relate the task to later work on the same files. Two
+ * sources fill that gap, both bounded and fail-open (an error yields nothing,
+ * never a failed finish):
+ *  - commits authored by the configured git user whose commit time falls in
+ *    the task window (merges excluded);
+ *  - working-tree changes (modified, added, untracked) whose mtime falls in it.
+ * Hunch's own memory and cache paths are excluded, so a capture commit made
+ * during the task does not count as work on a file. Deleted paths are skipped:
+ * nothing dates the deletion. Commit dates get one second of slack (git keeps
+ * seconds); working-tree mtimes get none before the start. */
+import { execFileSync } from "node:child_process";
+import { statSync } from "node:fs";
+import { join } from "node:path";
+const EXCLUDED_SEGMENTS = new Set([".hunch", ".hunch-cache", ".git"]);
+function gitDate(ms) {
+    // Second resolution, a format every git accepts.
+    return `${new Date(ms).toISOString().slice(0, 19).replace("T", " ")} +0000`;
+}
+export function gitTouchedFiles(root, startedAt, finishedAt, options = {}) {
+    const limit = Math.max(1, options.limit ?? 64);
+    const timeout = options.timeoutMs ?? 3_000;
+    const since = Date.parse(startedAt);
+    if (!Number.isFinite(since))
+        return [];
+    const until = finishedAt ? Date.parse(finishedAt) : (options.now ?? Date.now());
+    if (!Number.isFinite(until) || until < since)
+        return [];
+    // One second of slack on each side: git dates and some filesystems are second-granular.
+    const from = since - 1_000, to = until + 1_000;
+    const env = { ...process.env, GIT_OPTIONAL_LOCKS: "0" };
+    for (const key of Object.keys(env))
+        if (key.startsWith("GIT_") && key !== "GIT_OPTIONAL_LOCKS")
+            delete env[key];
+    const run = (args) => execFileSync("git", ["-C", root, "-c", "core.quotePath=false", ...args], { env, encoding: "utf8", timeout, maxBuffer: 4_000_000, stdio: ["ignore", "pipe", "ignore"] });
+    const out = new Set();
+    const keep = (raw) => {
+        const path = raw.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+        if (!path || path.split("/").some((segment) => EXCLUDED_SEGMENTS.has(segment)))
+            return;
+        out.add(path);
+    };
+    try {
+        const email = run(["config", "--get", "user.email"]).trim();
+        if (email) {
+            const log = run(["log", "--no-merges", "-n", "50", `--since=${gitDate(from)}`, `--until=${gitDate(to)}`, `--author=${email}`, "--format=", "--name-only"]);
+            for (const line of log.split("\n"))
+                keep(line);
+        }
+    }
+    catch { /* no commits, no git user, or no git: the working tree may still say something */ }
+    try {
+        const entries = run(["status", "--porcelain=v1", "-z", "--untracked-files=all"]).split("\0").filter(Boolean);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const code = entry.slice(0, 2), path = entry.slice(3);
+            // A rename or copy is followed by its original path as a separate entry.
+            if (code[0] === "R" || code[0] === "C")
+                i++;
+            if (code.includes("D") || !path)
+                continue;
+            try {
+                const mtime = statSync(join(root, path)).mtimeMs;
+                if (mtime >= since && mtime <= to)
+                    keep(path);
+            }
+            catch { /* vanished between status and stat */ }
+        }
+    }
+    catch { /* not a git worktree or status failed: nothing to add */ }
+    return [...out].sort().slice(0, limit);
+}
+//# sourceMappingURL=taskTouched.js.map

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.d.ts

@@ -16,6 +16,10 @@ export declare function boundedTaskReport(report: ReturnType<typeof readTaskRepo
         started_at: string;
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
+        closed_by?: "host" | "agent" | undefined;
+        session_key?: string | undefined;
+        continues?: string | undefined;
+        episode?: string | undefined;
     };
     coverage: "no-delivery-observed" | "no-relevant-memory" | "delivered";
     content_hash: string;
@@ -105,6 +109,10 @@ export declare function boundedTaskReportForHost(report: ReturnType<typeof readT
         started_at: string;
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
+        closed_by?: "host" | "agent" | undefined;
+        session_key?: string | undefined;
+        continues?: string | undefined;
+        episode?: string | undefined;
     };
     coverage: "no-delivery-observed" | "no-relevant-memory" | "delivered";
     content_hash: string;

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/dist/taskReports.d.ts

@@ -21,6 +21,10 @@ export declare function createTaskReporter(root: string): {
         started_at: string;
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
+        closed_by?: "host" | "agent" | undefined;
+        session_key?: string | undefined;
+        continues?: string | undefined;
+        episode?: string | undefined;
     };
     /** The caller supplies the exact envelope it issued plus snapshots of the
      * included revisions. Return the occurrence with the context to the agent.
@@ -69,6 +73,10 @@ export declare function createTaskReporter(root: string): {
         started_at: string;
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
+        closed_by?: "host" | "agent" | undefined;
+        session_key?: string | undefined;
+        continues?: string | undefined;
+        episode?: string | undefined;
     }[];
     lesson: (reference: LessonReference, options?: {
         limit?: number;

package/package.json

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