@davesheffer/hunch 1.37.1 → 1.38.1

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, settleHookSession, 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,17 @@ 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.length) {
+                    store ??= new HunchStore(paths);
+                    for (const id of closed)
+                        persistTaskRecord(root, store, id);
+                }
+            }
+            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));
@@ -4575,6 +4587,17 @@ program
                 }
             }
             catch { /* passive reporting remains fail-open */ }
+            // A task an earlier prompt of this session left open (interrupted before
+            // its Stop) is over now: close it and keep its record.
+            try {
+                const settled = settleHookSession(root, provider, evt, { keepId: hookReportTaskId(root, provider, evt), keepNewest: true });
+                if (settled.length) {
+                    store ??= new HunchStore(paths);
+                    for (const id of settled)
+                        persistTaskRecord(root, store, id);
+                }
+            }
+            catch { /* the next Stop or prompt retries */ }
             // Pipeline turn bookkeeping (fresh block budget) + the one nag that must
             // repeat: edits from an earlier turn still unverified.
             if (evt.session_id && pipelineEnabled()) {

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, sessionsOverlap } 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,38 @@ 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) };
+    // Another session working in the same checkout at the same time leaves the
+    // same mtimes: then only commits (attributable by author and time) count.
+    const workingTree = !sessionsOverlap(root, reports[0].task.session_key, window.from, window.to, reports.map((r) => r.task.task_id));
+    let built = taskRecordFromReports(reports, gitTouchedFiles(root, window.from, window.to, { workingTree }));
     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, { workingTree }));
+        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 +254,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 {
@@ -193,6 +200,12 @@ export interface LessonHistory {
     truncated: boolean;
     next_before: number | null;
 }
+/** A prompt identity that reports to another prompt's task: a host notification
+ * turn continues the session's latest task instead of opening a row. Explicit,
+ * so Stop never selects a task by recency for a prompt it does not know. */
+export declare function aliasReportTask(root: string, aliasId: string, taskId: string): void;
+/** The task an aliased prompt identity reports to, or the identity itself. */
+export declare function resolveReportTask(root: string, id: string): string;
 /** The lookup is derived, never evidence. Backfill at most 64 events and
  * 512 KB per read. Parse outside the writer transaction so a history view cannot
  * hold the writer lock while validating a large legacy ledger. */
@@ -200,7 +213,43 @@ 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) to be the same work.
+ * A task still open is the session's current work however long ago it started:
+ * the prompt was interrupted before Stop, or a late observation reopened it. */
+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;
+/** Tasks of a session that an earlier prompt left open are over once the
+ * session moves on: the prompt was interrupted before its Stop, a notification
+ * turn reused the task, or a late observation reopened it. Close them as host
+ * closes, except `keepId` (the prompt now running), the session's newest task
+ * when `keepNewest` (a notification turn continues it), and any task whose
+ * verification may still deliver a result. Returns the ids closed here so the
+ * caller can persist their records. */
+export declare function settleSessionTasks(root: string, sessionKey: string, options?: {
+    keepId?: string | null;
+    keepNewest?: boolean;
+}): string[];
+/** Whether a task of ANOTHER session (or of no session) was open in this
+ * worktree during the window: working-tree edits made then cannot be told apart
+ * by mtime, so the caller attributes only commits. `ownIds` are the episode's
+ * own tasks; any other task without a session key counts as foreign. */
+export declare function sessionsOverlap(root: string, sessionKey: string | undefined, from: string, to: string | null, ownIds?: readonly string[]): boolean;
+/** 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 +272,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(),
@@ -102,10 +115,25 @@ function taskDb(root, run) {
     );
     CREATE INDEX IF NOT EXISTS report_record_lookup ON report_record_links(kind, record_id, content_hash);
     CREATE TABLE IF NOT EXISTS report_history_progress (id INTEGER PRIMARY KEY CHECK(id = 1), through_rowid INTEGER NOT NULL);
-    INSERT OR IGNORE INTO report_history_progress VALUES (1, 0);`);
+    INSERT OR IGNORE INTO report_history_progress VALUES (1, 0);
+    CREATE TABLE IF NOT EXISTS report_task_aliases (alias_id TEXT PRIMARY KEY, task_id TEXT NOT NULL);`);
         return run(db);
     });
 }
+/** A prompt identity that reports to another prompt's task: a host notification
+ * turn continues the session's latest task instead of opening a row. Explicit,
+ * so Stop never selects a task by recency for a prompt it does not know. */
+export function aliasReportTask(root, aliasId, taskId) {
+    TaskIdSchema.parse(aliasId);
+    taskDb(root, db => transaction(db, () => {
+        readTask(db, root, taskId);
+        db.prepare("INSERT OR REPLACE INTO report_task_aliases VALUES (?, ?)").run(aliasId, taskId);
+    }));
+}
+/** The task an aliased prompt identity reports to, or the identity itself. */
+export function resolveReportTask(root, id) {
+    return taskDb(root, db => db.prepare("SELECT task_id FROM report_task_aliases WHERE alias_id = ?").get(id)?.task_id ?? id);
+}
 function deliveryRecords(kind, body) {
     if (kind === "save")
         return [ReportSaveSchema.parse(body).record];
@@ -227,9 +255,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 +272,79 @@ 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) to be the same work.
+ * A task still open is the session's current work however long ago it started:
+ * the prompt was interrupted before Stop, or a late observation reopened it. */
+export function continuationLinks(previous, nowMs = Date.now()) {
+    if (!previous)
+        return null;
+    const links = { continues: previous.task_id, episode: previous.episode ?? previous.task_id };
+    if (previous.state === "open")
+        return links;
+    const reference = Date.parse(previous.finished_at ?? previous.started_at);
+    if (!Number.isFinite(reference) || nowMs - reference > CONTINUATION_WINDOW_MS)
+        return null;
+    return links;
+}
+function newestSessionTask(db, root, sessionKey) {
+    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;
+}
+/** The most recent task of a session in this worktree, or null. */
+export function latestSessionTask(root, sessionKey) {
+    return taskDb(root, db => newestSessionTask(db, root, sessionKey));
+}
+/** Check-starts still inside their own timeout plus the grace window, minus the
+ * results that arrived: while positive, a runner may still deliver a result. */
+function pendingChecks(db, 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);
+    return pending ?? 0;
+}
+/** Tasks of a session that an earlier prompt left open are over once the
+ * session moves on: the prompt was interrupted before its Stop, a notification
+ * turn reused the task, or a late observation reopened it. Close them as host
+ * closes, except `keepId` (the prompt now running), the session's newest task
+ * when `keepNewest` (a notification turn continues it), and any task whose
+ * verification may still deliver a result. Returns the ids closed here so the
+ * caller can persist their records. */
+export function settleSessionTasks(root, sessionKey, options = {}) {
+    return taskDb(root, db => transaction(db, () => {
+        const rows = db.prepare("SELECT body FROM report_tasks WHERE scope IN (?, ?, ?) AND json_extract(body, '$.session_key') = ? AND json_extract(body, '$.state') = 'open' ORDER BY rowid").all(...scopePair(root), sessionKey);
+        const newest = options.keepNewest ? newestSessionTask(db, root, sessionKey)?.task_id : undefined;
+        const closed = [];
+        for (const row of rows) {
+            const task = TaskSchema.parse(JSON.parse(row.body));
+            if (task.task_id === options.keepId || task.task_id === newest || pendingChecks(db, task.task_id) > 0)
+                continue;
+            db.prepare("UPDATE report_tasks SET body = ? WHERE task_id = ?").run(JSON.stringify(TaskSchema.parse({ ...task, state: "completed", finished_at: new Date().toISOString(), closed_by: "host" })), task.task_id);
+            closed.push(task.task_id);
+        }
+        return closed;
+    }));
+}
+/** Whether a task of ANOTHER session (or of no session) was open in this
+ * worktree during the window: working-tree edits made then cannot be told apart
+ * by mtime, so the caller attributes only commits. `ownIds` are the episode's
+ * own tasks; any other task without a session key counts as foreign. */
+export function sessionsOverlap(root, sessionKey, from, to, ownIds = []) {
+    return taskDb(root, db => {
+        const rows = db.prepare("SELECT body FROM report_tasks WHERE scope IN (?, ?, ?) AND json_extract(body, '$.started_at') <= ? AND (json_extract(body, '$.finished_at') IS NULL OR json_extract(body, '$.finished_at') >= ?)").all(...scopePair(root), to ?? new Date().toISOString(), from);
+        return rows.some(r => {
+            const task = TaskSchema.parse(JSON.parse(r.body));
+            if (ownIds.includes(task.task_id))
+                return false;
+            return !sessionKey || !task.session_key || task.session_key !== sessionKey;
+        });
+    });
+}
+/** 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,30 +361,47 @@ 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");
+        // The task the observation lands on: the named one, unless the host closed
+        // it and the session has since moved on.
+        let target = task;
+        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. When a later prompt of the session
+            // exists, this is that prompt's work named by an old id (the grounding
+            // says to reuse ids): it lands on the session's newest task, which the
+            // next Stop closes, instead of reopening one no Stop would close again.
+            // Verification stays on its own task (a result must match its start), and
+            // a task the agent closed is final. Otherwise the turn went on (another
+            // hook's block, a resumed prompt): reopen; the next Stop closes it again.
+            const newest = kind === "check" || kind === "check-start" || !task.session_key ? null : newestSessionTask(db, root, task.session_key);
+            if (newest && newest.task_id !== task.task_id && (newest.state === "open" || newest.closed_by === "host"))
+                target = newest;
+            if (target.state !== "open") {
+                target = TaskSchema.parse({ ...target, state: "open", finished_at: null, closed_by: undefined });
+                db.prepare("UPDATE report_tasks SET body = ? WHERE task_id = ?").run(JSON.stringify(target), target.task_id);
+            }
+        }
+        const tid = target.task_id;
         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))
+            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, tid))
                 throw new Error("verification result has no matching start in this task");
         }
-        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
-      FROM report_events WHERE task_id = ?`).get(taskId);
-        const reserved = Math.max(0, (pending ?? 0) + (kind === "check-start" ? 1 : kind === "check" ? -1 : 0));
+        const { total, bytes } = db.prepare("SELECT COUNT(*) AS total, COALESCE(SUM(length(CAST(body AS BLOB))), 0) AS bytes FROM report_events WHERE task_id = ?").get(tid);
+        const reserved = Math.max(0, pendingChecks(db, tid) + (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)
             throw new Error("task observation limit reached; start a new task");
         if (kind === "claim") {
             const claim = ReportClaimSchema.parse(body);
-            const row = db.prepare("SELECT body FROM report_events WHERE event_id = ? AND task_id = ? AND kind = 'delivery'").get(claim.occurrence_id, taskId);
+            const row = db.prepare("SELECT body FROM report_events WHERE event_id = ? AND task_id = ? AND kind = 'delivery'").get(claim.occurrence_id, tid);
             if (!row)
                 throw new Error("claim does not refer to a delivery in this task");
             const delivery = JSON.parse(row.body);
             if (!delivery.records.some(r => r.record_id === claim.record_id && r.content_hash === claim.content_hash))
                 throw new Error("claim record revision was not delivered in this task");
         }
-        const inserted = db.prepare("INSERT INTO report_events VALUES (?, ?, ?, ?, ?, ?)").run(id, taskId, kind, new Date().toISOString(), encoded, contentHash);
+        const inserted = db.prepare("INSERT INTO report_events VALUES (?, ?, ?, ?, ?, ?)").run(id, tid, kind, new Date().toISOString(), encoded, contentHash);
         indexDeliveryRecords(db, id, kind, body);
         // Advance only over contiguous observed inserts; an older writer may have
         // left unindexed events. Historical gaps are filled by bounded reads above.
@@ -361,23 +479,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.d.ts

@@ -17,7 +17,10 @@ export declare function reportSourceSnapshot(root: string): ReportSnapshot;
  * predicate's subject lives in a changed file. Everything else stays
  * `not-exercised` or `unavailable` — never "satisfied" by file overlap. */
 export declare function runReportConformance(root: string, store: HunchStore, taskId: string): ReportConformance[];
-export declare const DEFAULT_CHECK_TIMEOUT_MS = 120000;
+/** A full suite is the usual check; two minutes turned passing suites into
+ * recorded timeouts (#268). The bound is a safety net for an abandoned runner,
+ * not a verdict. */
+export declare const DEFAULT_CHECK_TIMEOUT_MS: number;
 export declare const MAX_CHECK_TIMEOUT_MS: number;
 /** A deliberately explicit command wrapper. The caller chooses the command;
  * reports never execute commands automatically to validate submitted claims. */

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)
@@ -192,23 +192,26 @@ export function runReportConformance(root, store, taskId) {
         return value;
     });
 }
-export const DEFAULT_CHECK_TIMEOUT_MS = 120_000;
+/** A full suite is the usual check; two minutes turned passing suites into
+ * recorded timeouts (#268). The bound is a safety net for an abandoned runner,
+ * not a verdict. */
+export const DEFAULT_CHECK_TIMEOUT_MS = 15 * 60_000;
 export const MAX_CHECK_TIMEOUT_MS = 6 * 60 * 60_000;
 /** A deliberately explicit command wrapper. The caller chooses the command;
  * reports never execute commands automatically to validate submitted claims. */
-export async function runReportCheck(root, taskId, command, label, timeoutMs = 120_000, options = {}) {
+export async function runReportCheck(root, taskId, command, label, timeoutMs = DEFAULT_CHECK_TIMEOUT_MS, options = {}) {
     // A full suite can legitimately run for half an hour (fnd_70dd5c4034); the
     // bound exists so an abandoned runner cannot hold a task open indefinitely.
     if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_CHECK_TIMEOUT_MS)
         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,30 @@ 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.
+/** A prompt the host generated to report a background command's completion,
+ * not something the user typed. */
+export declare function isNotificationPrompt(prompt: string | undefined): boolean;
+/** Close, as host closes, the tasks of this session that an earlier prompt left
+ * open: the prompt was interrupted before its Stop, or a late observation
+ * reopened its task. Called when a new prompt starts (`keepNewest`: the new
+ * task, or the task a notification turn continues, stays open) and when the
+ * current prompt stops. Returns the ids closed here for the caller to persist. */
+export declare function settleHookSession(root: string, provider: HookProvider, event: HunchHookInput, options?: {
+    keepId?: string | null;
+    keepNewest?: boolean;
+}): string[];
+/** 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. Tasks an earlier prompt of the session left open close here
+ * too. Returns the ids of the tasks closed after this call, so the caller can
+ * persist their records; empty when nothing is closed. */
+export declare function closeHookTask(root: string, provider: HookProvider, event: HunchHookInput): string[];
+/** 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 { aliasReportTask, continuationLinks, finishReportTask, isEmptyTaskReport, latestSessionTask, readTaskReport, recordReportRefusal, reportHash, reportPresentationEnabled, resolveReportTask, settleSessionTasks, startReportTask } from "./taskReport.js";
 import { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { renderTaskReport } from "./taskReportRender.js";
 /** The exact task identity a native host prompt maps to. */
@@ -73,7 +73,14 @@ function identity(root, provider, event) {
         return null;
     if (!event.prompt_id)
         return "legacy";
-    return promptTaskId(root, event.session_id, event.prompt_id, event.agent_id ?? null, provider);
+    const id = promptTaskId(root, event.session_id, event.prompt_id, event.agent_id ?? null, provider);
+    // A notification turn reports to the task it continued (an explicit alias).
+    try {
+        return resolveReportTask(root, id);
+    }
+    catch {
+        return id;
+    }
 }
 export function hookReportTaskId(root, provider, event) {
     try {
@@ -98,9 +105,33 @@ 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 = {};
+    const sessionKey = hookSessionKey(cwd, provider, event);
+    if (sessionKey) {
+        links = { session_key: sessionKey };
+        try {
+            const previous = latestSessionTask(root, sessionKey);
+            // A host notification (a background command finished) is not new work:
+            // it continues the session's latest task instead of opening an empty row,
+            // unless the agent already closed that task for good. The alias makes
+            // this prompt's Stop and hook observations report to that task.
+            if (previous && previous.task_id !== id && isNotificationPrompt(event.prompt) && previous.closed_by !== "agent") {
+                aliasReportTask(root, id, previous.task_id);
+                return taskInstruction(previous, cwdLiteral);
+            }
+            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
@@ -111,10 +142,78 @@ export function startHookReport(root, provider, event) {
             throw error;
         task = existing;
     }
+    return taskInstruction(task, cwdLiteral);
+}
+function taskInstruction(task, cwdLiteral) {
     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.
+/** The session key a hook event maps to: a hash of (root, provider, session,
+ * agent), never the identifier itself. Null without a host session. */
+function hookSessionKey(cwd, provider, event) {
+    return event.session_id ? reportHash([cwd, provider, event.session_id, event.agent_id ?? null]) : null;
+}
+/** A prompt the host generated to report a background command's completion,
+ * not something the user typed. */
+export function isNotificationPrompt(prompt) {
+    if (typeof prompt !== "string")
+        return false;
+    const firstLine = prompt.split(/\r?\n/).map(l => l.trim()).find(l => l.length > 0) ?? "";
+    return /^<task-notification>/i.test(firstLine);
+}
+/** Close, as host closes, the tasks of this session that an earlier prompt left
+ * open: the prompt was interrupted before its Stop, or a late observation
+ * reopened its task. Called when a new prompt starts (`keepNewest`: the new
+ * task, or the task a notification turn continues, stays open) and when the
+ * current prompt stops. Returns the ids closed here for the caller to persist. */
+export function settleHookSession(root, provider, event, options = {}) {
+    const cwd = nativeHookCwd(root, provider, event);
+    const key = cwd ? hookSessionKey(cwd, provider, event) : null;
+    if (!key)
+        return [];
+    try {
+        return settleSessionTasks(root, key, options);
+    }
+    catch {
+        return [];
+    }
+}
+/** 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. Tasks an earlier prompt of the session left open close here
+ * too. Returns the ids of the tasks closed after this call, so the caller can
+ * persist their records; empty when nothing is closed. */
+export function closeHookTask(root, provider, event) {
+    let id;
+    try {
+        id = identity(root, provider, event);
+    }
+    catch {
+        return [];
+    }
+    if (!id || id === "legacy")
+        return [];
+    const closed = [];
+    try {
+        const task = readTaskReport(root, id).task;
+        if (task.state === "open")
+            finishReportTask(root, id, "completed", { by: "host" });
+        if (task.state !== "interrupted")
+            closed.push(id);
+    }
+    catch {
+        // No task for this prompt (a notification turn), or verification still running: leave it as it is.
+    }
+    for (const other of settleHookSession(root, provider, event, { keepId: id }))
+        if (!closed.includes(other))
+            closed.push(other);
+    return closed;
+}
+/** 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,9 @@
+/** Files Hunch regenerates on every capture (src/integrations/providers.ts,
+ * claudemd.ts): a fresh mtime on them is the capture, not the task's work. */
+export declare const HUNCH_MANAGED_FILES: ReadonlySet<string>;
+export declare function gitTouchedFiles(root: string, startedAt: string, finishedAt: string | null, options?: {
+    limit?: number;
+    timeoutMs?: number;
+    now?: number;
+    workingTree?: boolean;
+}): string[];

package/dist/core/taskTouched.js

@@ -0,0 +1,97 @@
+/** 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,
+ *    unless the caller knows another session shared the checkout (`workingTree:
+ *    false`): mtimes cannot say whose edit it was, commits can.
+ * Hunch's own work never counts as the task's: memory and cache paths, commits
+ * Hunch makes (`hunch:` subjects — captures, task records, repairs), and the
+ * grounding files a capture rewrites (CLAUDE.md, AGENTS.md, the host rule
+ * files) when they merely changed in the working tree; a user commit that
+ * edits one of those files still counts, as does a delivery that named it.
+ * 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"]);
+/** Files Hunch regenerates on every capture (src/integrations/providers.ts,
+ * claudemd.ts): a fresh mtime on them is the capture, not the task's work. */
+export const HUNCH_MANAGED_FILES = new Set(["CLAUDE.md", "AGENTS.md", ".cursor/rules/hunch.mdc", ".github/copilot-instructions.md", ".windsurf/rules/hunch.md"]);
+/** Commit subjects Hunch writes itself. */
+const HUNCH_COMMIT_SUBJECT = /^hunch:/i;
+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 normalize = (raw) => raw.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+    const keep = (raw) => {
+        const path = normalize(raw);
+        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) {
+            // One record per commit: a separator, the subject, then the paths.
+            const log = run(["log", "--no-merges", "-n", "50", `--since=${gitDate(from)}`, `--until=${gitDate(to)}`, `--author=${email}`, "--format=%x1e%s", "--name-only"]);
+            for (const block of log.split("\x1e")) {
+                const [subject = "", ...paths] = block.split("\n");
+                if (HUNCH_COMMIT_SUBJECT.test(subject.trim()))
+                    continue;
+                for (const line of paths)
+                    keep(line);
+            }
+        }
+    }
+    catch { /* no commits, no git user, or no git: the working tree may still say something */ }
+    if (options.workingTree === false)
+        return [...out].sort().slice(0, limit);
+    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 || HUNCH_MANAGED_FILES.has(normalize(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;
@@ -185,4 +193,13 @@ export declare function boundedTaskReportForHost(report: ReturnType<typeof readT
     };
     full_report: string;
 };
+/** `metaUrl` is the module running (a `.ts` source checkout needs the tsx
+ * loader; a published `.js` build needs nothing) and `resolve` is that
+ * module's `import.meta.resolve`. The loader is resolved ONLY on the source
+ * path: `import.meta.resolve` throws for a package that is not installed, and
+ * `tsx` is a devDependency absent from every published install (#261). */
+export declare function verificationLauncherFor(metaUrl: string, resolve: (specifier: string) => string): {
+    argv: string[];
+    shell: string;
+};
 export declare function registerTaskReportTools(server: McpServer, getRoot: () => string, getStore: () => HunchStore): void;

package/dist/mcp/taskReportTools.js

@@ -51,13 +51,21 @@ export function boundedTaskReportForHost(report) {
 /** Reuse the MCP server's installation, not a potentially stale global binary.
  * Structured argv is authoritative; the shell hint uses literal quoting. */
 function verificationLauncher() {
-    const dev = import.meta.url.endsWith(".ts");
-    const entry = fileURLToPath(new URL(`../cli/index.${dev ? "ts" : "js"}`, import.meta.url));
+    return verificationLauncherFor(import.meta.url, (specifier) => import.meta.resolve(specifier));
+}
+/** `metaUrl` is the module running (a `.ts` source checkout needs the tsx
+ * loader; a published `.js` build needs nothing) and `resolve` is that
+ * module's `import.meta.resolve`. The loader is resolved ONLY on the source
+ * path: `import.meta.resolve` throws for a package that is not installed, and
+ * `tsx` is a devDependency absent from every published install (#261). */
+export function verificationLauncherFor(metaUrl, resolve) {
+    const dev = metaUrl.endsWith(".ts");
+    const entry = fileURLToPath(new URL(`../cli/index.${dev ? "ts" : "js"}`, metaUrl));
     // `--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 loader = dev ? resolve("tsx") : null;
+    const argv = [process.execPath, ...(loader ? ["--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(" ")}` };
 }
@@ -91,7 +99,7 @@ export function registerTaskReportTools(server, getRoot, getStore) {
                     task = readTaskReport(root, task_id, reportSourceSnapshot(root).hash).task;
                 }
                 const launcher = verificationLauncher();
-                return { content: [{ type: "text", text: `Task ${task.task_id} · ${task.state}. Pass task_id to every hunch_context and decision/correction/finding capture call. Before the final response, finish with hunch_task and include its contribution card. For checks use this exact installation (the global hunch binary may be stale): ${launcher.shell} task verify ${task.task_id} -- <command> [arguments]. The default budget is 2 minutes; add --timeout <seconds> before -- for a long suite.` }], structuredContent: { task, verification_argv: [...launcher.argv, "task", "verify", task.task_id, "--"] } };
+                return { content: [{ type: "text", text: `Task ${task.task_id} · ${task.state}. Pass task_id to every hunch_context and decision/correction/finding capture call. Before the final response, finish with hunch_task and include its contribution card. For checks use this exact installation (the global hunch binary may be stale): ${launcher.shell} task verify ${task.task_id} -- <command> [arguments]. The default budget is 15 minutes; add --timeout <seconds> before -- for a longer suite.` }], structuredContent: { task, verification_argv: [...launcher.argv, "task", "verify", task.task_id, "--"] } };
             }
             if (!task_id)
                 throw new Error("finish requires the exact task_id");

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.1",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://www.hunchmemory.com",
-  "version": "1.37.1",
+  "version": "1.38.1",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.37.1",
+      "version": "1.38.1",
       "runtimeHint": "npx",
       "packageArguments": [
         {