@davesheffer/hunch 1.38.0 → 1.39.0

package/dist/constitution/sourceMutation.js

@@ -93,16 +93,21 @@ function parsedSymbolFor(graphSymbol, parsed) {
     const base = symbolId(graphSymbol.file, graphSymbol.name, graphSymbol.kind);
     return matches.find((_symbol, index) => (index === 0 ? base : `${base}_${index}`) === graphSymbol.id) ?? null;
 }
-function spliceBytes(source, replacements) {
-    let bytes = Buffer.from(source, "utf8");
+/** `start`/`end` are JS string (UTF-16 code unit) indices. Despite their
+ *  names, parse.ts's startByte/endByte/atByte carry the same units — native
+ *  tree-sitter indexes the JS string it was handed, not its UTF-8 encoding —
+ *  so every scan and splice against them must be string-based, never Buffer-
+ *  based. */
+function spliceChars(source, replacements) {
+    let result = source;
     for (const replacement of [...replacements].sort((a, b) => b.start - a.start)) {
-        bytes = Buffer.concat([
-            bytes.subarray(0, replacement.start),
-            Buffer.from(replacement.text, "utf8"),
-            bytes.subarray(replacement.end),
-        ]);
+        result = result.slice(0, replacement.start) + replacement.text + result.slice(replacement.end);
     }
-    return bytes.toString("utf8");
+    return result;
+}
+/** Where a new top-level statement (an import) can be inserted without splitting a shebang line. */
+function insertionPoint(source) {
+    return source.startsWith("#!") ? Math.max(0, source.indexOf("\n") + 1) : 0;
 }
 function mutateSource(policy, base, sourceFile, source) {
     const assertion = policy.assertion;
@@ -145,10 +150,10 @@ function mutateSource(policy, base, sourceFile, source) {
         const specifier = relativeSpecifier(sourceFile, targetFile);
         if (parsed.imports.some((candidate) => candidate === specifier))
             return { error: "mutation-component-import-already-present" };
-        const insertion = source.startsWith("#!") ? Math.max(0, source.indexOf("\n") + 1) : 0;
+        const insertion = insertionPoint(source);
         return {
             file: sourceFile,
-            source: spliceBytes(source, [{ start: insertion, end: insertion, text: `import ${JSON.stringify(specifier)}; // hunch deterministic component mutation\n` }]),
+            source: spliceChars(source, [{ start: insertion, end: insertion, text: `import ${JSON.stringify(specifier)}; // hunch deterministic component mutation\n` }]),
         };
     }
     const subject = symbolForSelector(base, assertion.subject);
@@ -161,7 +166,7 @@ function mutateSource(policy, base, sourceFile, source) {
     if (!definition)
         return { error: "mutation-subject-definition-unresolved" };
     if (assertion.kind === "exists") {
-        return { file: subject.file, source: spliceBytes(source, [{ start: definition.startByte, end: definition.endByte, text: "" }]) };
+        return { file: subject.file, source: spliceChars(source, [{ start: definition.startByte, end: definition.endByte, text: "" }]) };
     }
     if (assertion.kind === "not-reaches"
         && assertion.relation.edges.length === 1
@@ -173,10 +178,10 @@ function mutateSource(policy, base, sourceFile, source) {
         if (parsed.imports.some((specifier) => externalPackage(specifier) === dependency)) {
             return { error: "mutation-forbidden-import-already-present" };
         }
-        const insertion = source.startsWith("#!") ? Math.max(0, source.indexOf("\n") + 1) : 0;
+        const insertion = insertionPoint(source);
         return {
             file: subject.file,
-            source: spliceBytes(source, [{ start: insertion, end: insertion, text: `import ${JSON.stringify(dependency)}; // hunch deterministic source mutation\n` }]),
+            source: spliceChars(source, [{ start: insertion, end: insertion, text: `import ${JSON.stringify(dependency)}; // hunch deterministic source mutation\n` }]),
         };
     }
     const object = symbolForSelector(base, assertion.object);
@@ -193,19 +198,19 @@ function mutateSource(policy, base, sourceFile, source) {
             .map((call) => ({ start: call.atByte, end: call.endByte, text: "hunchMutationRemovedCall" }));
         if (!replacements.length)
             return { error: "mutation-required-call-unresolved" };
-        return { file: subject.file, source: spliceBytes(source, replacements) };
+        return { file: subject.file, source: spliceChars(source, replacements) };
     }
     if (!assertion.relation.edges.includes("calls"))
         return { error: "mutation-call-edge-not-supported" };
-    const bytes = Buffer.from(source, "utf8");
-    const open = bytes.indexOf("{".charCodeAt(0), definition.startByte);
+    // String search, matching definition.startByte/endByte's actual units -- see spliceChars' doc comment.
+    const open = source.indexOf("{", definition.startByte);
     if (open < 0 || open >= definition.endByte)
         return { error: "mutation-subject-body-unsupported" };
     const replacements = [{ start: open + 1, end: open + 1, text: `\n  ${object.name}(); // hunch deterministic source mutation\n` }];
     if (object.file !== subject.file) {
         const specifier = relativeSpecifier(subject.file, object.file);
         if (!parsed.imports.includes(specifier)) {
-            const insertion = source.startsWith("#!") ? Math.max(0, source.indexOf("\n") + 1) : 0;
+            const insertion = insertionPoint(source);
             replacements.push({
                 start: insertion,
                 end: insertion,
@@ -215,7 +220,7 @@ function mutateSource(policy, base, sourceFile, source) {
     }
     return {
         file: subject.file,
-        source: spliceBytes(source, replacements),
+        source: spliceChars(source, replacements),
     };
 }
 function removeWorktree(root, hooks, env, checkout) {

package/dist/core/config.d.ts

@@ -9,12 +9,28 @@ import type { HunchPaths } from "./paths.js";
 export type Firmness = "off" | "advisory" | "firm" | "strict";
 export declare const FIRMNESS_LEVELS: readonly Firmness[];
 export declare const DEFAULT_FIRMNESS: Firmness;
+/** Workspace-ledger knobs (docs/workspace-ledger.md). `publish` decides what a snapshot
+ *  carries: `branches` (default — label, branches, verdicts, dirty/locked flags, no paths),
+ *  `full` (worktree paths too), `off` (no record). `publish_public` lets a repo WITHOUT an
+ *  overlay commit the record into its tracked .hunch/ — off by default: per-machine facts
+ *  churning the code repo is rarely wanted. */
+export type WorkspacePublish = "full" | "branches" | "off";
+export declare const WORKSPACE_PUBLISH_MODES: readonly WorkspacePublish[];
+export declare const DEFAULT_WORKSPACE_PUBLISH: WorkspacePublish;
+export interface WorkspacesConfig {
+    publish: WorkspacePublish;
+    stale_after_days: number;
+    publish_public: boolean;
+}
 export interface HunchConfig {
     firmness: Firmness;
     /** MCP tool groups beyond the everyday set: `all`, `core`, or `core,nuryel`
      *  (see src/mcp/toolset.ts). Undefined = decide from the root's contents. */
     mcp_tools?: string;
+    workspaces?: Partial<WorkspacesConfig>;
 }
+/** The effective workspace config: every field present, unknown values ignored. */
+export declare function workspacesConfig(config: HunchConfig): WorkspacesConfig;
 export declare function isFirmness(v: unknown): v is Firmness;
 /** Read `.hunch/config.json`. A missing/unparseable file, or an unknown firmness
  *  value, falls back to defaults — the hook must NEVER crash an edit over config. */

package/dist/core/config.js

@@ -6,6 +6,18 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 export const FIRMNESS_LEVELS = ["off", "advisory", "firm", "strict"];
 export const DEFAULT_FIRMNESS = "advisory";
+export const WORKSPACE_PUBLISH_MODES = ["full", "branches", "off"];
+export const DEFAULT_WORKSPACE_PUBLISH = "branches";
+/** The effective workspace config: every field present, unknown values ignored. */
+export function workspacesConfig(config) {
+    const raw = config.workspaces ?? {};
+    const days = Number(raw.stale_after_days);
+    return {
+        publish: WORKSPACE_PUBLISH_MODES.includes(raw.publish) ? raw.publish : DEFAULT_WORKSPACE_PUBLISH,
+        stale_after_days: Number.isInteger(days) && days >= 1 && days <= 3650 ? days : 7,
+        publish_public: raw.publish_public === true,
+    };
+}
 function defaults() {
     return { firmness: DEFAULT_FIRMNESS };
 }
@@ -22,6 +34,7 @@ export function readConfig(paths) {
         return {
             firmness: isFirmness(raw.firmness) ? raw.firmness : DEFAULT_FIRMNESS,
             ...(typeof raw.mcp_tools === "string" && raw.mcp_tools.trim() ? { mcp_tools: raw.mcp_tools.trim() } : {}),
+            ...(raw.workspaces && typeof raw.workspaces === "object" && !Array.isArray(raw.workspaces) ? { workspaces: raw.workspaces } : {}),
         };
     }
     catch {

package/dist/core/machine.d.ts

@@ -0,0 +1,20 @@
+export interface MachineIdentity {
+    id: string;
+    label: string;
+    created_at: string;
+}
+export interface MachinePathOptions {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    platform?: NodeJS.Platform;
+}
+export declare function machineFile(opts?: MachinePathOptions): string;
+export declare function defaultMachineLabel(id: string): string;
+/** The machine's identity, minted on first use. An unreadable or invalid file is
+ *  replaced (a machine that lost its id simply becomes a new machine; the old record
+ *  ages out as unverified and `hunch workspaces forget` removes it). */
+export declare function loadOrCreateMachine(opts?: MachinePathOptions): MachineIdentity;
+export declare function setMachineLabel(label: string, opts?: MachinePathOptions): MachineIdentity;
+/** A label that equals the hostname or the OS username publishes personal data into a
+ *  shared store; `doctor` and `label` warn, they do not refuse — the user chose it. */
+export declare function labelLeaksIdentity(label: string): string | null;

package/dist/core/machine.js

@@ -0,0 +1,101 @@
+/**
+ * Machine identity for the workspace ledger (docs/workspace-ledger.md): a random id
+ * generated ONCE per machine and stored at the user level, so every clone on the
+ * machine reports as the same machine. Deliberately NOT derived from the hostname,
+ * a MAC address or a hardware serial — it identifies nothing outside Hunch. The
+ * label is user-chosen; the default embeds nothing personal.
+ *
+ * Lives under the platform's per-user config root (XDG_CONFIG_HOME / %APPDATA% /
+ * ~/.config) and, like updatecheck.ts, never creates a `.hunch` path segment: that
+ * is findRoot()'s repository marker.
+ */
+import { lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir, hostname, userInfo } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { randomBytes, randomUUID } from "node:crypto";
+import { MACHINE_ID, MACHINE_LABEL } from "./workspace.js";
+const MAX_MACHINE_FILE_BYTES = 4096;
+function configuredRoot(value, platform) {
+    if (!value)
+        return null;
+    const absolute = platform === "win32" ? /^(?:[A-Za-z]:[\\/]|\\\\)/.test(value) : value.startsWith("/");
+    const marker = value.replace(/\\/g, "/").split("/").some((part) => part.toLowerCase().replace(/[ .]+$/g, "") === ".hunch");
+    return absolute && !marker ? value : null;
+}
+export function machineFile(opts = {}) {
+    const env = opts.env ?? process.env;
+    const home = opts.home ?? homedir();
+    const platform = opts.platform ?? process.platform;
+    const configHome = configuredRoot(env.XDG_CONFIG_HOME, platform)
+        || (platform === "win32" && configuredRoot(env.APPDATA, platform))
+        || join(home, ".config");
+    return join(configHome, "hunch", "machine.json");
+}
+export function defaultMachineLabel(id) {
+    return `machine-${id.replace(/^mac_/, "").slice(0, 4)}`;
+}
+function readMachine(file) {
+    try {
+        const stat = lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_MACHINE_FILE_BYTES)
+            return null;
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        if (typeof raw.id !== "string" || !MACHINE_ID.test(raw.id))
+            return null;
+        const label = typeof raw.label === "string" && MACHINE_LABEL.test(raw.label) ? raw.label : defaultMachineLabel(raw.id);
+        const created = typeof raw.created_at === "string" && Number.isFinite(Date.parse(raw.created_at)) ? raw.created_at : new Date(0).toISOString();
+        return { id: raw.id, label, created_at: created };
+    }
+    catch {
+        return null;
+    }
+}
+/** Atomic, owner-only write: a half-written id file would mint a second machine. */
+function writeMachine(file, identity) {
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    const temp = join(dirname(file), `.${basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+    writeFileSync(temp, JSON.stringify(identity, null, 2) + "\n", { mode: 0o600 });
+    renameSync(temp, file);
+}
+/** The machine's identity, minted on first use. An unreadable or invalid file is
+ *  replaced (a machine that lost its id simply becomes a new machine; the old record
+ *  ages out as unverified and `hunch workspaces forget` removes it). */
+export function loadOrCreateMachine(opts = {}) {
+    const file = machineFile(opts);
+    const existing = readMachine(file);
+    if (existing)
+        return existing;
+    const id = `mac_${randomBytes(16).toString("hex")}`;
+    const fresh = { id, label: defaultMachineLabel(id), created_at: new Date().toISOString() };
+    writeMachine(file, fresh);
+    return fresh;
+}
+export function setMachineLabel(label, opts = {}) {
+    if (!MACHINE_LABEL.test(label)) {
+        throw new Error("machine label must be 1-64 characters of letters, digits, '.', '_' or '-' and start with a letter or digit");
+    }
+    const next = { ...loadOrCreateMachine(opts), label };
+    writeMachine(machineFile(opts), next);
+    return next;
+}
+/** A label that equals the hostname or the OS username publishes personal data into a
+ *  shared store; `doctor` and `label` warn, they do not refuse — the user chose it. */
+export function labelLeaksIdentity(label) {
+    const lower = label.toLowerCase();
+    let host = "";
+    let user = "";
+    try {
+        host = hostname().toLowerCase();
+    }
+    catch { /* unavailable */ }
+    try {
+        user = userInfo().username.toLowerCase();
+    }
+    catch { /* unavailable */ }
+    if (host && (lower === host || lower === host.split(".")[0]))
+        return "hostname";
+    if (user && lower === user)
+        return "OS username";
+    return null;
+}
+//# sourceMappingURL=machine.js.map

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