@davesheffer/hunch 1.33.0 → 1.35.0

package/dist/mcp/server.js

@@ -845,6 +845,10 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
             parts.push(`\nCOMPONENTS: ${w.components.map((c) => `${c.name} (${c.id})`).join(", ")}`);
         if (w.symbols.length)
             parts.push(`\nSYMBOLS: ${w.symbols.slice(0, WHY_CAP * 2).map((s) => `${s.name} [fan-in ${s.metrics.fan_in}, churn ${s.metrics.churn_90d}]`).join(", ")}${more(w.symbols.length, WHY_CAP * 2)}`);
+        const recentTasks = store.tasksFor(target, 5);
+        if (recentTasks.length) {
+            parts.push(`\nRECENT TASKS (agent work that touched this):\n${recentTasks.map((t) => `  • ${t.id} ${t.finished_at.slice(0, 10)} ${t.title} — ${t.lessons.length} lesson(s), ${t.applied.length} applied, ${t.saved.length} saved${t.conformance.some((c) => c.outcome === "violated") ? ", rule VIOLATED" : ""}`).join("\n")}`);
+        }
         if (parts.length === 1)
             parts.push("\n(No recorded decisions/bugs/constraints yet for this target.)");
         return ok(parts.join("\n"));
@@ -1071,7 +1075,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
                     const records = as_of ? [] : snapshotDeliveredRecords(store, envelope);
                     // First delivery of a revision in this task earns one line; repeats stay quiet.
                     const recalled = renderRecalledLine(unseenLessons(root, task_id, records));
-                    const occurrence = recordTaskDelivery(root, task_id, envelope, records);
+                    const occurrence = recordTaskDelivery(root, task_id, envelope, records, undefined, target);
                     result.content.push({ type: "text", text: `${recalled ? `${recalled}\n` : ""}Task evidence: ${task_id} · occurrence ${occurrence}.\n${records.slice(0, 20).map(r => `${r.record_id} @ ${r.content_hash}`).join("\n")}${records.length > 20 ? "\nMore record identities: hunch_report(task_id)." : ""}` });
                 }
                 catch {

package/dist/mcp/taskReportTools.d.ts

@@ -17,7 +17,7 @@ export declare function boundedTaskReport(report: ReturnType<typeof readTaskRepo
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
     };
-    coverage: "delivered" | "no-delivery-observed" | "no-relevant-memory";
+    coverage: "no-delivery-observed" | "no-relevant-memory" | "delivered";
     content_hash: string;
     unknowns: string[];
     deliveries: {
@@ -73,7 +73,7 @@ export declare function boundedTaskReport(report: ReturnType<typeof readTaskRepo
         title: string;
         home: "public" | "private";
         operation: "updated" | "created";
-        durability: "committed" | "pushed" | "local";
+        durability: "local" | "committed" | "pushed";
     }[];
     refusals: ({
         source: "native-edit-gate";
@@ -106,7 +106,7 @@ export declare function boundedTaskReportForHost(report: ReturnType<typeof readT
         finished_at: string | null;
         state: "open" | "completed" | "interrupted";
     };
-    coverage: "delivered" | "no-delivery-observed" | "no-relevant-memory";
+    coverage: "no-delivery-observed" | "no-relevant-memory" | "delivered";
     content_hash: string;
     unknowns: string[];
     deliveries: {
@@ -162,7 +162,7 @@ export declare function boundedTaskReportForHost(report: ReturnType<typeof readT
         title: string;
         home: "public" | "private";
         operation: "updated" | "created";
-        durability: "committed" | "pushed" | "local";
+        durability: "local" | "committed" | "pushed";
     }[];
     refusals: ({
         source: "native-edit-gate";

package/dist/mcp/taskReportTools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { fileURLToPath } from "node:url";
 import { TaskIdSchema, ReportClaimSchema, LessonReferenceSchema, finishReportTask, listReportTasks, readTaskReport, readLessonHistory, recordReportClaim, reportPresentationEnabled, startReportTask } from "../core/taskReport.js";
+import { persistTaskRecord } from "../core/taskRecord.js";
 import { reportSourceSnapshot, runReportConformance } from "../core/taskReportEvidence.js";
 import { renderTaskReport, writeTaskReportHtml } from "../core/taskReportRender.js";
 function applicationReferences(report) {
@@ -73,7 +74,18 @@ export function registerTaskReportTools(server, getRoot, getStore) {
             if (action === "start") {
                 if (!title || applications?.length || outcome)
                     throw new Error("start requires a short task title and no completion evidence");
-                const task = startReportTask(root, title, task_id);
+                let task;
+                try {
+                    task = startReportTask(root, title, task_id);
+                }
+                catch (error) {
+                    // A native prompt task already exists under this exact ID (opened by the
+                    // host hook). Its persisted title is authoritative; a paraphrased title
+                    // from the model must not fork a second report or fail the start.
+                    if (!task_id || !/different title/.test(error.message))
+                        throw error;
+                    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, "--"] } };
             }
@@ -90,6 +102,23 @@ export function registerTaskReportTools(server, getRoot, getStore) {
                 catch { /* unknowns disclose it */ }
             }
             finishReportTask(root, task_id, outcome ?? "completed");
+            // The finished task becomes graph memory through the normal capture path;
+            // a failed write is disclosed on the card, never a reason to lose it.
+            let graph = null;
+            let graphNote = "";
+            try {
+                const saved = persistTaskRecord(root, getStore(), task_id);
+                if (saved) {
+                    graph = { id: saved.record.id, home: saved.home, flushed: saved.flushed, changed: saved.changed };
+                    graphNote = `\nGraph     ${saved.changed ? "saved" : "already saved"} as ${saved.record.id} (${saved.home}${saved.flushed ? `, ${saved.flushed}` : ""})`;
+                }
+                else {
+                    graphNote = "\nGraph     nothing to keep (no observation, or task records disabled)";
+                }
+            }
+            catch (error) {
+                graphNote = `\nGraph     not saved: ${error.message}`;
+            }
             const report = readTaskReport(root, task_id, reportSourceSnapshot(root).hash);
             const show = reportPresentationEnabled(root);
             let file = null;
@@ -97,8 +126,8 @@ export function registerTaskReportTools(server, getRoot, getStore) {
                 file = writeTaskReportHtml(root, task_id);
             }
             catch { /* retained report remains inspectable through MCP */ }
-            const card = file ? renderTaskReport(report).replace(/^Evidence .*$/m, `Evidence  [Open local report](<${file}>)`) : renderTaskReport(report);
-            return { content: [{ type: "text", text: show ? card : "Task report retained. Automatic presentation is disabled; omit the contribution card from the final response." }], structuredContent: { ...boundedTaskReportForHost(report), presentation_enabled: show, contribution_card: show ? card : null, report_path: file } };
+            const card = (file ? renderTaskReport(report).replace(/^Evidence .*$/m, `Evidence  [Open local report](<${file}>)`) : renderTaskReport(report)) + graphNote;
+            return { content: [{ type: "text", text: show ? card : "Task report retained. Automatic presentation is disabled; omit the contribution card from the final response." }], structuredContent: { ...boundedTaskReportForHost(report), presentation_enabled: show, contribution_card: show ? card : null, report_path: file, graph_record: graph } };
         }
         catch (error) {
             const message = `Task report unavailable: ${error.message}`;

package/dist/store/hunchStore.d.ts

@@ -1,5 +1,5 @@
 import { type HunchPaths } from "../core/paths.js";
-import { type Component, type Constraint, type Bug, type Decision, type Symbol, type Edge, type Finding, type EntityKind, type EntityFor } from "../core/types.js";
+import { type Component, type Constraint, type Bug, type Decision, type Symbol, type Edge, type Finding, type EntityKind, type EntityFor, type TaskRecord } from "../core/types.js";
 import { type DB } from "./db.js";
 import { type Embedder } from "./embedder.js";
 import { JsonStore } from "./jsonStore.js";
@@ -405,6 +405,10 @@ export declare class HunchStore {
      *  glob, and the queried scope may be either too. Advisory only — findings never
      *  enter any block path. Sorted worst-first, then id for stable output. */
     liveFindingsFor(scope: string): Finding[];
+    /** Finished agent tasks that touched a file or glob (rule-checked changes and
+     *  denied edits), newest first. Graph memory, so it spans machines and survives
+     *  the local ledger's retention window. */
+    tasksFor(scope: string, limit?: number): TaskRecord[];
     /** The causal chain behind a constraint — the WHY a diff-only reviewer can't see.
      *  Deterministic graph join: constraint → source_decision (the decision that
      *  motivated the guard) → the bug whose root cause spawned it (via

package/dist/store/hunchStore.js

@@ -491,6 +491,14 @@ export class HunchStore {
                 fts(f.id, "findings", f.title, `${f.observation} ${f.evidence.join(" ")} ${f.affected_files.join(" ")} ${f.affected_symbols.join(" ")} ${f.triage}`);
             }
             counts.findings = fnds.length;
+            // Tasks (finished agent work as graph memory): same FTS-only ride. Title +
+            // the lesson/save/application record ids and touched files, so "what did
+            // an agent do around X" and a record id both hit.
+            const tasks = this.recs("tasks");
+            for (const t of tasks) {
+                fts(t.id, "tasks", t.title, `${t.lessons.map((l) => `${l.record_id} ${l.title}`).join(" ")} ${t.applied.map((a) => a.record_id).join(" ")} ${t.saved.map((s) => s.record_id).join(" ")} ${t.files.join(" ")} ${t.state} ${t.coverage}`);
+            }
+            counts.tasks = tasks.length;
             // nuryel.state/1 kinds (receipts, commitments, derived, entities, relationships):
             // advisory records on the same FTS-only ride as runbooks/findings — no dedicated
             // SQL table. kind = the store kind; title = the subject key; body = the human words
@@ -1435,6 +1443,16 @@ export class HunchStore {
             || f.affected_symbols.some((s) => s === scope))
             .sort((a, b) => (SEV_FINDING[b.severity] ?? 0) - (SEV_FINDING[a.severity] ?? 0) || a.id.localeCompare(b.id));
     }
+    /** Finished agent tasks that touched a file or glob (rule-checked changes and
+     *  denied edits), newest first. Graph memory, so it spans machines and survives
+     *  the local ledger's retention window. */
+    tasksFor(scope, limit = 8) {
+        const t = toPosixTarget(scope);
+        return this.recs("tasks")
+            .filter((r) => r.files.some((f) => pathMatchesGlob(t, f) || pathMatchesGlob(f, t) || pathsRelated(toPosixTarget(f), t)))
+            .sort((a, b) => b.finished_at.localeCompare(a.finished_at) || a.id.localeCompare(b.id))
+            .slice(0, Math.max(1, limit));
+    }
     /** The causal chain behind a constraint — the WHY a diff-only reviewer can't see.
      *  Deterministic graph join: constraint → source_decision (the decision that
      *  motivated the guard) → the bug whose root cause spawned it (via

package/dist/taskReports.d.ts

@@ -25,7 +25,7 @@ export declare function createTaskReporter(root: string): {
     /** The caller supplies the exact envelope it issued plus snapshots of the
      * included revisions. Return the occurrence with the context to the agent.
      * Issuance alone does not prove the model applied or even attended to it. */
-    delivered(taskId: string, envelope: DeliveryEnvelope, records: ReportRecord[], occurrenceId?: string): string;
+    delivered(taskId: string, envelope: DeliveryEnvelope, records: ReportRecord[], occurrenceId?: string, target?: string): string;
     applied(taskId: string, claim: ReportClaim): string;
     /** Runs locally as argv, without a shell. Only use commands authorized by
      * the task owner. This API does not accept remote claimed-success receipts. */

package/dist/taskReports.js

@@ -1,6 +1,5 @@
 /** Provider-neutral, local engine integration. The authorized harness owns
  * lifecycle and display; neither operation depends on model compliance. */
-import { realpathSync } from "node:fs";
 import { z } from "zod";
 import { finishReportTask, listReportTasks, readTaskReport, readLessonHistory, recordReportClaim, recordTaskDelivery, reportHash, reportPresentationEnabled, startReportTask } from "./core/taskReport.js";
 import { DEFAULT_CHECK_TIMEOUT_MS, reportSourceSnapshot, runReportCheck, runReportConformance } from "./core/taskReportEvidence.js";
@@ -10,12 +9,14 @@ import { hunchPaths } from "./core/paths.js";
 import { HunchStore } from "./store/hunchStore.js";
 export { TASK_REPORT_SCHEMA, TaskIdSchema } from "./core/taskReport.js";
 export { renderTaskReport, renderTaskReportHtml } from "./core/taskReportRender.js";
+import { canonicalReportRoot } from "./core/taskReportPaths.js";
+import { persistTaskRecord } from "./core/taskRecord.js";
 const IdentitySchema = z.object({ task: z.string().min(1).max(1024), attempt: z.string().min(1).max(1024) }).strict();
 /** Create this only after authorizing a local repository/worktree. A task ID is
  * a correlation reference, never an access token. Remote adapters must enforce
  * their own principal/partition boundary before reaching this local API. */
 export function createTaskReporter(root) {
-    const scope = realpathSync(root);
+    const scope = canonicalReportRoot(root);
     const report = (taskId) => readTaskReport(scope, taskId, reportSourceSnapshot(scope).hash);
     return {
         /** Omit identity for a fresh task, or supply the harness's stable task AND
@@ -28,8 +29,8 @@ export function createTaskReporter(root) {
         /** The caller supplies the exact envelope it issued plus snapshots of the
          * included revisions. Return the occurrence with the context to the agent.
          * Issuance alone does not prove the model applied or even attended to it. */
-        delivered(taskId, envelope, records, occurrenceId) {
-            return recordTaskDelivery(scope, taskId, envelope, records, occurrenceId);
+        delivered(taskId, envelope, records, occurrenceId, target) {
+            return recordTaskDelivery(scope, taskId, envelope, records, occurrenceId, target);
         },
         applied(taskId, claim) { return recordReportClaim(scope, taskId, claim); },
         /** Runs locally as argv, without a shell. Only use commands authorized by
@@ -57,6 +58,17 @@ export function createTaskReporter(root) {
                 catch { /* the report's unknowns disclose it */ }
             }
             finishReportTask(scope, taskId, outcome);
+            // Graph memory of the finished task; disclosed in the report, never blocking.
+            try {
+                const store = new HunchStore(hunchPaths(scope));
+                try {
+                    persistTaskRecord(scope, store, taskId);
+                }
+                finally {
+                    store.close();
+                }
+            }
+            catch { /* the ledger keeps the observations; the graph write is retried on the next finish */ }
             const result = report(taskId);
             return { report: result, contribution_card: reportPresentationEnabled(scope) ? renderTaskReport(result) : null };
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.33.0",
+  "version": "1.35.0",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",

package/server.json

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