@davesheffer/hunch 1.38.0 → 1.38.1

package/dist/cli/index.js

@@ -88,7 +88,7 @@ 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 { closeHookTask, 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";
@@ -4553,9 +4553,10 @@ program
             // or not the agent called finish. Fail-open: the card below still renders.
             try {
                 const closed = closeHookTask(root, provider, evt);
-                if (closed) {
+                if (closed.length) {
                     store ??= new HunchStore(paths);
-                    persistTaskRecord(root, store, closed);
+                    for (const id of closed)
+                        persistTaskRecord(root, store, id);
                 }
             }
             catch { /* the ledger and the card remain authoritative; the next finish retries */ }
@@ -4586,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/core/taskRecord.js

@@ -14,7 +14,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { flushCapture } from "../integrations/sync.js";
 import { hunchPaths } from "./paths.js";
-import { episodeTasks, 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";
@@ -184,7 +184,10 @@ export function persistTaskRecord(root, store, taskId, options = {}) {
     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));
+    // 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;
@@ -194,7 +197,7 @@ export function persistTaskRecord(root, store, taskId, options = {}) {
     // 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));
+        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;

package/dist/core/taskReport.d.ts

@@ -200,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. */
@@ -217,14 +223,31 @@ export declare function startReportTask(root: string, title: string, taskId?: st
  * 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. */
+ * 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.

package/dist/core/taskReport.js

@@ -115,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];
@@ -261,21 +276,69 @@ export function startReportTask(root, title, taskId, links = {}) {
  * 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. */
+ * 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 { continues: previous.task_id, episode: previous.episode ?? previous.task_id };
+    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 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;
+        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. */
@@ -298,36 +361,47 @@ function appendEvent(root, taskId, kind, body, eventId) {
                 throw new Error("report event identity conflicts with existing evidence");
             return id;
         }
+        // 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, 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);
+            // 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' 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));
+        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.

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

@@ -192,11 +192,14 @@ 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)

package/dist/core/taskReportHook.d.ts

@@ -21,6 +21,18 @@ 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 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.
@@ -28,9 +40,10 @@ export declare function startHookReport(root: string, provider: HookProvider, ev
  * 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;
+ * 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

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 { continuationLinks, finishReportTask, isEmptyTaskReport, latestSessionTask, 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 {
@@ -103,11 +110,19 @@ export function startHookReport(root, provider, event) {
     // 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]);
+    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 };
@@ -127,8 +142,41 @@ 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.`;
 }
+/** 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.
@@ -136,30 +184,34 @@ export function startHookReport(root, provider, event) {
  * 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. */
+ * 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 null;
+        return [];
     }
     if (!id || id === "legacy")
-        return null;
+        return [];
+    const closed = [];
     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;
+        if (task.state !== "interrupted")
+            closed.push(id);
     }
     catch {
-        // No task for this prompt, or verification still running: leave it as it is.
-        return null;
+        // 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

package/dist/core/taskTouched.d.ts

@@ -1,5 +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

@@ -8,15 +8,26 @@
  * 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. */
+ *  - 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`;
@@ -38,8 +49,9 @@ export function gitTouchedFiles(root, startedAt, finishedAt, options = {}) {
             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 = raw.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+        const path = normalize(raw);
         if (!path || path.split("/").some((segment) => EXCLUDED_SEGMENTS.has(segment)))
             return;
         out.add(path);
@@ -47,12 +59,20 @@ export function gitTouchedFiles(root, startedAt, finishedAt, options = {}) {
     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);
+            // 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++) {
@@ -61,7 +81,7 @@ export function gitTouchedFiles(root, startedAt, finishedAt, options = {}) {
             // 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)
+            if (code.includes("D") || !path || HUNCH_MANAGED_FILES.has(normalize(path)))
                 continue;
             try {
                 const mtime = statSync(join(root, path)).mtimeMs;

package/dist/mcp/taskReportTools.d.ts

@@ -193,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/package.json

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