@davesheffer/hunch 1.33.0 → 1.35.0

package/dist/core/taskRecord.js

@@ -0,0 +1,185 @@
+/** Finished tasks as graph memory: `.hunch/tasks/htask_*.json`.
+ *
+ * The observation ledger (`.hunch-cache/served.db`) is machine-local and expires;
+ * the graph is what Hunch knows. When a task finishes with at least one
+ * observation, a bounded summary of it is written through the SAME capture path
+ * as decisions and findings (`HunchStore.putCapture`), so public/private homing,
+ * the one-home-per-record rule, auto-commit and team routing apply unchanged.
+ *
+ * Empty tasks (nothing delivered, saved, checked, claimed or denied) stay
+ * ledger-only: a record per bare prompt would be commit noise, not memory.
+ * The record carries titles and record references only — never prompt text,
+ * transcript, private context payloads or denial reasons. */
+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 { reportSourceSnapshot } from "./taskReportEvidence.js";
+import { ENTITY_KINDS, TaskRecordSchema } from "./types.js";
+function localConfig(root) {
+    try {
+        return JSON.parse(readFileSync(join(root, ".hunch", "local.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/** `taskRecords: false` in `.hunch/local.json` keeps tasks ledger-only. */
+export function taskRecordsEnabled(root) {
+    return localConfig(root).taskRecords !== false;
+}
+/** `taskRecordsFlush: "batch"` writes the record but leaves the commit to the
+ * next capture flush (decision, finding, correction), so a busy repository
+ * gets one memory commit per real capture instead of one per prompt. Default
+ * "each": every finished task commits like any other capture. */
+export function taskRecordFlushMode(root) {
+    return localConfig(root).taskRecordsFlush === "batch" ? "batch" : "each";
+}
+/** 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 function targetLooksLikePath(target) {
+    const t = target.trim();
+    if (!t || t.length > 512 || /\s/.test(t))
+        return false;
+    if (!/^[A-Za-z0-9_@$./\\:-]+$/.test(t))
+        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))
+        return null;
+    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 lastCheck = report.checks.at(-1);
+    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,
+        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 })),
+        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 },
+    });
+}
+/** 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. */
+export function taskRecordHome(store, record) {
+    if (store.captureHome(false) === "private")
+        return "private";
+    if (!store.hasPrivate)
+        return "public";
+    if (record.saved.some((s) => s.home === "private"))
+        return "private";
+    for (const lesson of record.lessons) {
+        if (!ENTITY_KINDS.includes(lesson.kind))
+            continue;
+        const kind = lesson.kind;
+        if (store.getPrivateRec(kind, lesson.record_id) && !store.json.get(kind, lesson.record_id))
+            return "private";
+    }
+    return "public";
+}
+/** Write (or refresh) the graph record for a finished task. Idempotent on the
+ * report hash. A record never changes home once written. Returns null for an
+ * open task, an empty report, or when task records are disabled locally. */
+export function persistTaskRecord(root, store, taskId, options = {}) {
+    if (!taskRecordsEnabled(root))
+        return null;
+    const report = readTaskReport(root, taskId, reportSourceSnapshot(root).hash);
+    const record = taskRecordFromReport(report);
+    if (!record)
+        return null;
+    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)
+        return { record: existing, home, flushed: null, changed: false };
+    const stored = store.putCapture("tasks", record, home === "private");
+    store.reindex();
+    const flushNow = options.flush ?? taskRecordFlushMode(root) === "each";
+    const flushed = flushNow ? flushCapture(store, hunchPaths(root).hunch, home === "private", `hunch: task ${record.id}`) : null;
+    return { record: stored, home, flushed, changed: true };
+}
+const GRAPH_SCOPE = reportHash("graph-record");
+/** A ledger-shaped summary for a task known only from the graph (another
+ * machine, a teammate, or a pruned local ledger). */
+export function summaryFromTaskRecord(record, home) {
+    const last = record.checks.at(-1);
+    return {
+        task: { task_id: record.id, scope: GRAPH_SCOPE, title: record.title, started_at: record.started_at, finished_at: record.finished_at, state: record.state },
+        deliveries: record.lessons.length ? 1 : 0,
+        lessons: new Set(record.lessons.map((l) => `${l.kind}:${l.record_id}`)).size,
+        claims: record.applied.length,
+        saves: record.saved.length,
+        refusals: record.refusals,
+        check: last ? { label: last.label, state: last.state, current: false } : null,
+        violated: record.conformance.some((c) => c.outcome === "violated"),
+        coverage: record.coverage,
+        empty: false,
+        report_html: null,
+        error: null,
+        durable: { home },
+    };
+}
+/** Ledger summaries annotated with their graph home, plus graph-only tasks the
+ * local ledger never saw. Newest first, bounded. */
+export function mergeDurableTaskSummaries(store, summaries, limit = 30) {
+    const homes = new Map();
+    const records = new Map();
+    for (const r of store.recsInHome("tasks", "public")) {
+        homes.set(r.id, "public");
+        records.set(r.id, r);
+    }
+    if (store.hasPrivate)
+        for (const r of store.recsInHome("tasks", "private")) {
+            homes.set(r.id, "private");
+            records.set(r.id, r);
+        }
+    const seen = new Set();
+    const merged = summaries.map((s) => {
+        seen.add(s.task.task_id);
+        const home = homes.get(s.task.task_id);
+        return { ...s, durable: home ? { home } : null };
+    });
+    for (const r of records.values()) {
+        if (seen.has(r.id))
+            continue;
+        merged.push(summaryFromTaskRecord(r, homes.get(r.id) ?? "public"));
+    }
+    merged.sort((a, b) => b.task.started_at.localeCompare(a.task.started_at));
+    return merged.slice(0, Math.max(1, limit));
+}
+//# sourceMappingURL=taskRecord.js.map

package/dist/core/taskReport.d.ts

@@ -132,6 +132,9 @@ export interface TaskDelivery {
     envelope_hash: string;
     envelope: DeliveryEnvelope;
     records: ReportRecord[];
+    /** What the caller asked context for (a file, symbol or task phrase); null for
+     * deliveries recorded by releases that did not retain it. */
+    target: string | null;
 }
 export interface TaskReport {
     schema: typeof TASK_REPORT_SCHEMA;
@@ -206,7 +209,7 @@ export declare function startReportTask(root: string, title: string, taskId?: st
 export declare function unseenLessons(root: string, taskId: string, records: readonly ReportRecord[]): ReportRecord[];
 /** Strict operation for explicit callers. Passive integrations catch failure
  * and disclose it without blocking context delivery. Empty envelopes count. */
-export declare function recordTaskDelivery(root: string, taskId: string, envelope: DeliveryEnvelope, records: ReportRecord[], occurrenceId?: string): string;
+export declare function recordTaskDelivery(root: string, taskId: string, envelope: DeliveryEnvelope, records: ReportRecord[], occurrenceId?: string, target?: string): string;
 export declare function recordReportClaim(root: string, taskId: string, claim: ReportClaim): string;
 /** Internal write-path observers; no MCP endpoint accepts fabricated saves or
  * publication claims. Retained observations never authorize memory mutations. */
@@ -247,6 +250,10 @@ export interface TaskSummary {
     report_html: string | null;
     /** Set when the observation ledger could not be read for this task. */
     error: string | null;
+    /** Set when the task has a graph record (.hunch/tasks/), and where it lives. */
+    durable?: {
+        home: "public" | "private";
+    } | null;
 }
 /** One bounded summary per recent task for status lines and host views; the
  * card and evidence view remain the authoritative renderings. */

package/dist/core/taskReport.js

@@ -7,7 +7,7 @@ import { z } from "zod";
 import { assertDeliveryEnvelope } from "./delivery.js";
 import { isCredentialFreeText } from "./types.js";
 import { withServedDatabase } from "./served.js";
-import { assertReportPath } from "./taskReportPaths.js";
+import { assertReportPath, canonicalReportRoot } from "./taskReportPaths.js";
 export const TASK_REPORT_SCHEMA = "hunch.task-report/1";
 export const TaskIdSchema = z.string().regex(/^htask_[a-f0-9]{24}$/);
 const hashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
@@ -175,9 +175,9 @@ export function readLessonHistory(root, reference, options = {}) {
             const rows = db.prepare(`SELECT e.rowid AS seq, e.event_id, e.kind, e.at, e.body, e.content_hash, t.body AS task
         FROM report_record_links l JOIN report_events e ON e.event_id = l.event_id
         JOIN report_tasks t ON t.task_id = e.task_id
-        WHERE t.scope = ? AND l.kind = ? AND l.record_id = ?
+        WHERE t.scope IN (?, ?, ?) AND l.kind = ? AND l.record_id = ?
           AND (? IS NULL OR l.content_hash = ?) AND e.rowid < ?
-        ORDER BY e.rowid DESC LIMIT ?`).all(scopeOf(root), ref.kind, ref.record_id, ref.content_hash ?? null, ref.content_hash ?? null, before ?? Number.MAX_SAFE_INTEGER, limit + 1);
+        ORDER BY e.rowid DESC LIMIT ?`).all(...scopePair(root), ref.kind, ref.record_id, ref.content_hash ?? null, ref.content_hash ?? null, before ?? Number.MAX_SAFE_INTEGER, limit + 1);
             return { more, rows };
         }, true);
         const entries = rows.slice(0, limit).map(row => {
@@ -196,10 +196,21 @@ export function readLessonHistory(root, reference, options = {}) {
         return { schema: "hunch.lesson-history/1", reference: ref, entries, index_complete: !more, truncated: rows.length > limit, next_before: !more && rows.length > limit ? rows[limit - 1].seq : null };
     });
 }
-function scopeOf(root) { return reportHash(realpathSync(root)); }
+/** Task scope = the physical repository root. Rows written by releases that hashed
+ * the caller-cased realpath stay readable until they expire: the caller's own
+ * spelling plus, on Windows, the other drive-letter case (a hook and an MCP
+ * server spawned by the same host commonly disagree on exactly that). */
+function scopeOf(root) { return reportHash(canonicalReportRoot(root)); }
+function scopePair(root) {
+    const legacy = realpathSync(root);
+    const swapped = /^[A-Za-z]:/.test(legacy)
+        ? (legacy.charAt(0) === legacy.charAt(0).toLowerCase() ? legacy.charAt(0).toUpperCase() : legacy.charAt(0).toLowerCase()) + legacy.slice(1)
+        : legacy;
+    return [scopeOf(root), reportHash(legacy), reportHash(swapped)];
+}
 function readTask(db, root, id) {
     TaskIdSchema.parse(id);
-    const row = db.prepare("SELECT body FROM report_tasks WHERE task_id = ? AND scope = ?").get(id, scopeOf(root));
+    const row = db.prepare("SELECT body FROM report_tasks WHERE task_id = ? AND scope IN (?, ?, ?)").get(id, ...scopePair(root));
     if (!row)
         throw new Error("task not found in this repository/worktree; use its exact task ID and working directory");
     return TaskSchema.parse(JSON.parse(row.body));
@@ -298,7 +309,7 @@ export function unseenLessons(root, taskId, records) {
 }
 /** Strict operation for explicit callers. Passive integrations catch failure
  * and disclose it without blocking context delivery. Empty envelopes count. */
-export function recordTaskDelivery(root, taskId, envelope, records, occurrenceId = `hocc_${randomBytes(12).toString("hex")}`) {
+export function recordTaskDelivery(root, taskId, envelope, records, occurrenceId = `hocc_${randomBytes(12).toString("hex")}`, target) {
     assertDeliveryEnvelope(envelope);
     const snapshots = z.array(ReportRecordSchema).max(512).parse(records);
     const seen = new Set();
@@ -308,7 +319,10 @@ export function recordTaskDelivery(root, taskId, envelope, records, occurrenceId
             throw new Error("snapshot is duplicated or was not delivered");
         seen.add(key);
     }
-    return appendEvent(root, taskId, "delivery", { envelope, records: snapshots }, occurrenceId);
+    // The target is optional so envelopes recorded without one keep their exact
+    // event hash; it is bounded like any other retained text.
+    const retainedTarget = typeof target === "string" && target.trim() && target.length <= 1024 && isCredentialFreeText(target) ? target : undefined;
+    return appendEvent(root, taskId, "delivery", { envelope, records: snapshots, ...(retainedTarget ? { target: retainedTarget } : {}) }, occurrenceId);
 }
 export function recordReportClaim(root, taskId, claim) {
     const value = ReportClaimSchema.parse(claim);
@@ -440,7 +454,7 @@ export function taskReportStats(root, days = 7) {
     if (!existsSync(join(root, ".hunch-cache", "served.db")))
         return empty;
     return taskDb(root, db => {
-        const tasks = db.prepare("SELECT body FROM report_tasks WHERE scope = ? AND json_extract(body, '$.started_at') >= ?").all(scopeOf(root), since)
+        const tasks = db.prepare("SELECT body FROM report_tasks WHERE scope IN (?, ?, ?) AND json_extract(body, '$.started_at') >= ?").all(...scopePair(root), since)
             .map(r => TaskSchema.parse(JSON.parse(r.body)));
         if (!tasks.length)
             return empty;
@@ -468,15 +482,15 @@ export function taskReportStats(root, days = 7) {
     });
 }
 export function listReportTasks(root) {
-    return taskDb(root, db => db.prepare("SELECT body FROM report_tasks WHERE scope = ? ORDER BY rowid DESC LIMIT 30").all(scopeOf(root)).map(r => TaskSchema.parse(JSON.parse(r.body))));
+    return taskDb(root, db => db.prepare("SELECT body FROM report_tasks WHERE scope IN (?, ?, ?) ORDER BY rowid DESC LIMIT 30").all(...scopePair(root)).map(r => TaskSchema.parse(JSON.parse(r.body))));
 }
 export function reportActivity(root) {
     if (!existsSync(join(root, ".hunch-cache", "served.db")))
         return "Task reporting: no task activity observed yet. Reconnect the agent after updating; inspect with `hunch report`.";
     try {
         return taskDb(root, db => {
-            const row = db.prepare(`SELECT COUNT(*) AS total, SUM(CASE WHEN json_extract(body, '$.state') = 'completed' THEN 1 ELSE 0 END) AS completed FROM report_tasks WHERE scope = ?`).get(scopeOf(root));
-            const { deliveries } = db.prepare("SELECT COUNT(*) AS deliveries FROM report_events WHERE kind = 'delivery' AND task_id IN (SELECT task_id FROM report_tasks WHERE scope = ?)").get(scopeOf(root));
+            const row = db.prepare(`SELECT COUNT(*) AS total, SUM(CASE WHEN json_extract(body, '$.state') = 'completed' THEN 1 ELSE 0 END) AS completed FROM report_tasks WHERE scope IN (?, ?, ?)`).get(...scopePair(root));
+            const { deliveries } = db.prepare("SELECT COUNT(*) AS deliveries FROM report_events WHERE kind = 'delivery' AND task_id IN (SELECT task_id FROM report_tasks WHERE scope IN (?, ?, ?))").get(...scopePair(root));
             return `Task reporting: ${row.total} observed task(s), ${row.completed ?? 0} completed report(s), ${deliveries} linked context delivery(s). Activity alone does not prove contribution; inspect with \`hunch report\`.`;
         });
     }
@@ -505,9 +519,9 @@ export function pruneReportHistory(root, olderThanDays = 90) {
     const cutoff = new Date(Date.now() - olderThanDays * 86_400_000).toISOString();
     return taskDb(root, db => transaction(db, () => {
         const expired = db.prepare(`SELECT task_id FROM report_tasks
-      WHERE scope = ? AND ((json_extract(body, '$.state') != 'open' AND json_extract(body, '$.finished_at') < ?)
+      WHERE scope IN (?, ?, ?) AND ((json_extract(body, '$.state') != 'open' AND json_extract(body, '$.finished_at') < ?)
         OR (json_extract(body, '$.state') = 'open' AND json_extract(body, '$.started_at') < ?)) LIMIT 1000`)
-            .all(scopeOf(root), cutoff, cutoff);
+            .all(...scopePair(root), cutoff, cutoff);
         for (const task of expired) {
             // Serialize expiry with concurrent starts/results. Discard abandoned
             // evidence without inventing a completion or interruption observation.
@@ -552,7 +566,7 @@ export function readTaskReport(root, taskId, currentSnapshot = null) {
             throw new Error("report evidence hash mismatch");
         if (event.kind === "delivery") {
             assertDeliveryEnvelope(value.envelope);
-            deliveries.push({ occurrence_id: event.event_id, at: event.at, receipt_id: value.envelope.receipt_id, envelope_hash: reportHash(value.envelope), envelope: value.envelope, records: z.array(ReportRecordSchema).parse(value.records) });
+            deliveries.push({ occurrence_id: event.event_id, at: event.at, receipt_id: value.envelope.receipt_id, envelope_hash: reportHash(value.envelope), envelope: value.envelope, records: z.array(ReportRecordSchema).parse(value.records), target: typeof value.target === "string" ? value.target : null });
         }
         else if (event.kind === "claim")
             claims.push({ ...ReportClaimSchema.parse(value), at: event.at, attribution: "agent-reported", supported_by: null });

package/dist/core/taskReportEvidence.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { lstatSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
+import { canonicalReportRoot } from "./taskReportPaths.js";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { analyzeDiff } from "../extractors/diff.js";
 import { workingDiff, workingFiles } from "../extractors/git.js";
@@ -32,7 +33,7 @@ export function snapshotDeliveredRecords(store, envelope) {
 export function reportSourceSnapshot(root) {
     const limitations = ["Git-ignored files, Hunch memory/cache, and external dependencies are outside this source snapshot."];
     try {
-        const base = realpathSync(root);
+        const base = canonicalReportRoot(root);
         const env = { ...process.env, GIT_OPTIONAL_LOCKS: "0" };
         for (const key of Object.keys(env))
             if (key.startsWith("GIT_") && key !== "GIT_OPTIONAL_LOCKS")

package/dist/core/taskReportHook.d.ts

@@ -1,10 +1,25 @@
 import type { HookProvider, HunchHookInput } from "./agenthook.js";
-/** The exact task identity a Claude Code prompt maps to. The status line receives
- * the same session_id/prompt_id on stdin, so it can name the prompt's task too. */
+/** The exact task identity a native host prompt maps to. */
 export declare function promptTaskId(root: string, sessionId: string, promptId: string, agentId?: string | null, provider?: HookProvider): string;
+/** Prompt-derived titles are OPT-IN (`"taskTitles": "prompt"` in .hunch/local.json).
+ * The default keeps the documented guarantee that no prompt text is retained
+ * anywhere: not in the ledger, the Stop card, the Contribution view, nor a graph
+ * record that may be committed to a public repository. */
+export declare function promptTitlesEnabled(root: string): boolean;
+/** A short, safe task title from the prompt's first line: control characters
+ * and runs of whitespace collapse, credential-looking text is refused, and the
+ * result is cut at a word boundary. Null means "use the generic title". The
+ * title is the only prompt-derived prose that reaches the ledger and, on
+ * finish, the graph record. */
+export declare function promptTaskTitle(prompt: string | undefined): string | null;
+/** Carry a hook-observed working directory into MCP only after proving it names
+ * the same physical repository as the hook process. The canonical repository
+ * root is stable across cwd subdirectories and safe to copy into a tool call. */
+export declare function nativeHookCwd(root: string, provider: HookProvider, event: HunchHookInput): string | null;
 export declare function hookReportTaskId(root: string, provider: HookProvider, event: HunchHookInput): string | null;
 /** Every prompt receives its exact ID, even when ambient reminders were deduped.
- * No raw prompt, host session identifier, or transcript is retained. */
+ * 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.

package/dist/core/taskReportHook.js

@@ -1,21 +1,70 @@
 /** Native lifecycle coverage is independent of whether a model follows reporting
  * instructions. Only an authoritative prompt identity may join its evidence. */
-import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
+import { readFileSync } from "node:fs";
+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 { reportSourceSnapshot } from "./taskReportEvidence.js";
 import { renderTaskReport, writeTaskReportHtml } from "./taskReportRender.js";
-/** The exact task identity a Claude Code prompt maps to. The status line receives
- * the same session_id/prompt_id on stdin, so it can name the prompt's task too. */
+/** The exact task identity a native host prompt maps to. */
 export function promptTaskId(root, sessionId, promptId, agentId = null, provider = "claude") {
-    return `htask_${reportHash([realpathSync(root), provider, sessionId, promptId, agentId]).slice(7, 31)}`;
+    return `htask_${reportHash([canonicalReportRoot(root), provider, sessionId, promptId, agentId]).slice(7, 31)}`;
 }
 /** Hosts whose hooks deliver a native per-prompt identity (Claude Code's
  * prompt_id, Codex's turn_id). Others get no task from a hook. */
 const NATIVE_PROMPT_HOSTS = new Set(["claude", "codex"]);
+const NATIVE_TASK_TITLE = "Assistant task";
+const GENERIC_TASK_TITLES = new Set(["Assistant task", "Claude task"]);
+const TASK_TITLE_MAX = 72;
+/** Prompt-derived titles are OPT-IN (`"taskTitles": "prompt"` in .hunch/local.json).
+ * The default keeps the documented guarantee that no prompt text is retained
+ * anywhere: not in the ledger, the Stop card, the Contribution view, nor a graph
+ * record that may be committed to a public repository. */
+export function promptTitlesEnabled(root) {
+    try {
+        return JSON.parse(readFileSync(join(root, ".hunch", "local.json"), "utf8")).taskTitles === "prompt";
+    }
+    catch {
+        return false;
+    }
+}
+/** A short, safe task title from the prompt's first line: control characters
+ * and runs of whitespace collapse, credential-looking text is refused, and the
+ * result is cut at a word boundary. Null means "use the generic title". The
+ * title is the only prompt-derived prose that reaches the ledger and, on
+ * finish, the graph record. */
+export function promptTaskTitle(prompt) {
+    if (typeof prompt !== "string")
+        return null;
+    const firstLine = prompt.split(/\r?\n/).map(l => l.trim()).find(l => l.length > 0) ?? "";
+    const clean = firstLine.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+    if (clean.length < 3 || !isCredentialFreeText(clean) || !isCredentialFreeText(prompt.slice(0, 4096)))
+        return null;
+    if (clean.length <= TASK_TITLE_MAX)
+        return clean;
+    const cut = clean.slice(0, TASK_TITLE_MAX);
+    const atWord = cut.lastIndexOf(" ");
+    return `${(atWord > TASK_TITLE_MAX / 2 ? cut.slice(0, atWord) : cut).trimEnd()}…`;
+}
+/** Carry a hook-observed working directory into MCP only after proving it names
+ * the same physical repository as the hook process. The canonical repository
+ * root is stable across cwd subdirectories and safe to copy into a tool call. */
+export function nativeHookCwd(root, provider, event) {
+    if (!NATIVE_PROMPT_HOSTS.has(provider) || !event.cwd)
+        return null;
+    try {
+        const physicalRoot = canonicalReportRoot(root);
+        return canonicalReportRoot(findRoot(event.cwd)) === physicalRoot ? physicalRoot : null;
+    }
+    catch {
+        return null;
+    }
+}
 function identity(root, provider, event) {
-    if (!NATIVE_PROMPT_HOSTS.has(provider) || !event.cwd || realpathSync(findRoot(event.cwd)) !== realpathSync(root))
+    if (!nativeHookCwd(root, provider, event))
         return null;
     for (const value of [event.session_id, event.prompt_id, event.agent_id]) {
         if (value !== undefined && (!value.length || value.length > 1024 || /[\u0000-\u001f\u007f]/.test(value)))
@@ -37,13 +86,33 @@ export function hookReportTaskId(root, provider, event) {
     }
 }
 /** Every prompt receives its exact ID, even when ambient reminders were deduped.
- * No raw prompt, host session identifier, or transcript is retained. */
+ * 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 function startHookReport(root, provider, event) {
     const id = identity(root, provider, event);
     if (!id || id === "legacy")
         return null;
-    const task = startReportTask(root, "Claude task", id);
-    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: "Claude task") to obtain verification_argv; do not create another report. Pass this task_id to hunch_context and decision/correction/finding captures, and finish with hunch_task before responding. A host Stop notice will show the evidence even if no task-linked memory was observed.`;
+    // Re-resolve after identity validation and fail closed if the filesystem
+    // changed between the two reads; never emit a task instruction with cwd:null.
+    const cwd = nativeHookCwd(root, provider, event);
+    if (!cwd)
+        return null;
+    const cwdLiteral = JSON.stringify(cwd);
+    const title = (promptTitlesEnabled(root) ? promptTaskTitle(event.prompt) : null) ?? NATIVE_TASK_TITLE;
+    let task;
+    try {
+        task = startReportTask(root, title, id);
+    }
+    catch (error) {
+        // The same prompt identity may already be open: a release that called every
+        // native task "Claude task"/"Assistant task", or a second hook registration
+        // for the same host. The persisted identity and title win; never a second task.
+        const existing = readTaskReport(root, id).task;
+        if (existing.title !== title && !GENERIC_TASK_TITLES.has(existing.title) && !GENERIC_TASK_TITLES.has(title))
+            throw error;
+        task = existing;
+    }
+    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.

package/dist/core/taskReportPaths.d.ts

@@ -1,3 +1,9 @@
+/** The ONE physical identity of a repository root for task scoping. Node's
+ * realpathSync keeps whatever drive-letter/segment casing the caller passed
+ * (a lowercase vs uppercase drive letter), so a hook spawned with one spelling and an MCP
+ * server spawned with the other hashed to two scopes for the same checkout and
+ * every task lookup failed. The native resolver returns on-disk casing. */
+export declare function canonicalReportRoot(root: string): string;
 /** Report paths are local to this physical worktree. Existing symlinks and
  * hard-linked files are refused; never follow a cache pointer into another scope. */
 export declare function assertReportPath(root: string, ...parts: string[]): string;

package/dist/core/taskReportPaths.js

@@ -1,5 +1,18 @@
 import { lstatSync, realpathSync } from "node:fs";
 import { join } from "node:path";
+/** The ONE physical identity of a repository root for task scoping. Node's
+ * realpathSync keeps whatever drive-letter/segment casing the caller passed
+ * (a lowercase vs uppercase drive letter), so a hook spawned with one spelling and an MCP
+ * server spawned with the other hashed to two scopes for the same checkout and
+ * every task lookup failed. The native resolver returns on-disk casing. */
+export function canonicalReportRoot(root) {
+    try {
+        return realpathSync.native(root);
+    }
+    catch {
+        return realpathSync(root);
+    }
+}
 /** Report paths are local to this physical worktree. Existing symlinks and
  * hard-linked files are refused; never follow a cache pointer into another scope. */
 export function assertReportPath(root, ...parts) {