@davesheffer/hunch 1.37.1 → 1.38.0

package/dist/cli/index.js

@@ -88,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";
@@ -4548,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));

package/dist/cli/taskReport.js

@@ -90,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")

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,10 +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"));
@@ -47,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
@@ -145,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)
@@ -202,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/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/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.1",
+  "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.1",
+  "version": "1.38.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.37.1",
+      "version": "1.38.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {