@davesheffer/hunch 1.33.0 → 1.36.0

package/dist/integrations/health.js

@@ -164,14 +164,39 @@ export function inspectIntegrations(root, selected) {
             continue;
         const capabilities = Object.fromEntries(CAPABILITIES.map(c => [c, { status: "untested", detail: "No runtime evidence" }]));
         report.harnesses.push({ harness, capabilities });
+        const mcpPath = join(root, spec.mcp);
+        const hooksFileExists = Boolean(spec.hooks && existsSync(join(root, spec.hooks)));
+        let mcpEntryAbsent = false;
+        try {
+            lstatSync(mcpPath);
+        }
+        catch (e) {
+            mcpEntryAbsent = e.code === "ENOENT";
+        }
         try {
             const launcher = readLauncher(root, harness);
             recordPins(spec.mcp, [launcher.command, ...launcher.args]);
             capabilities.mcp.detail = "Configured locally; use --probe to verify a fresh server, then reconnect the host";
         }
         catch (e) {
-            report.issues.push({ file: spec.mcp, code: "mcp-config", detail: e.message });
-            capabilities.mcp.detail = "MCP configuration missing, disabled, invalid, or outside supported inspection format";
+            // A harness can be detected here via its hooks file alone —
+            // some hooks files are deliberately committed while their MCP config is
+            // a per-clone, gitignored scaffold (e.g. this repo's own
+            // .windsurf/hooks.json). On a fresh checkout that config simply doesn't
+            // exist yet, which is a "not configured on this machine" state, not a
+            // repository-level misconfiguration — it must stay `untested`
+            // (informational, matching every other not-yet-evidenced capability
+            // here), not a hard `issues` entry that fails `hunch doctor` on every
+            // clone forever. A file that EXISTS but is malformed/disabled/
+            // unreadable in some other way is still a genuine issue.
+            // lstat distinguishes a truly absent per-machine file from a dangling
+            // symlink. The latter is a broken configuration and must remain loud.
+            const notConfiguredHere = !selected && hooksFileExists && mcpEntryAbsent && e.code === "ENOENT";
+            if (!notConfiguredHere)
+                report.issues.push({ file: spec.mcp, code: "mcp-config", detail: e.message });
+            capabilities.mcp.detail = notConfiguredHere
+                ? "Not configured on this machine — a hooks file exists, but no local MCP config exists yet; run `hunch init` or set up this host"
+                : "MCP configuration disabled, invalid, or outside supported inspection format";
         }
         let events = {};
         let disabled = false;

package/dist/mcp/server.js

@@ -32,6 +32,7 @@ import { withWriteLock } from "../serve/writelock.js";
 import { advertisedTeamRemoteContract, ensureTeamOverlay, overlayMatchesTeamRemote, readTeamConfig, teamRemoteContract, teamSharedRef } from "../integrations/team.js";
 import { formatSearchHit, formatStructure } from "../core/format.js";
 import { isStateKind, stateSupplements } from "../core/stateDelivery.js";
+import { taskSupplements } from "../core/taskDelivery.js";
 import { diagnoseIssueCorrectionStage, formatCorrectionStageDiagnostic } from "../core/correctionStage.js";
 import { compileVerifiedEvidenceMap, EvidenceExecutionSchema, EvidenceInterventionSchema, EvidenceProbeSchema, formatVerifiedEvidenceMap, VerifiedEvidenceReceiptSchema, } from "../core/evidenceMap.js";
 import { collectCorrectionStageSources } from "../extractors/correctionSources.js";
@@ -845,6 +846,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 +1076,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 {
@@ -1097,6 +1102,9 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
         // latest receipts whose subject/text matches the target — bounded, ordered, sharing the
         // brief's budget as supplements. Withheld on time-travel: state records carry no as-of view.
         const stateGrounding = asOf ? [] : stateSupplements(store.stateSlice(target), target);
+        // Recent finished tasks that touched the target: what earlier agent work did
+        // here, from graph memory. Advisory history sharing the brief's budget.
+        const recentTasks = asOf ? [] : taskSupplements(store.tasksFor(target, 3), target);
         const options = {
             root,
             symbols: store.recs("symbols"),
@@ -1104,7 +1112,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
             decisionCorpus: store.recs("decisions"),
             historical: !!asOf,
             profile: profile ?? "builder",
-            supplements: [...(dnaSupplement ? [dnaSupplement] : []), ...stateGrounding, ...(asOf ? [] : conventionSupplements(store.recs("conventions")))],
+            supplements: [...(dnaSupplement ? [dnaSupplement] : []), ...stateGrounding, ...recentTasks, ...(asOf ? [] : conventionSupplements(store.recs("conventions")))],
         };
         // Task-phrase input ("improve retrieval ranking") resolves no file/symbol and
         // used to return an empty brief while the graph held the answer — fall back to
@@ -1132,6 +1140,7 @@ export function buildServerWithRootControl(initialRoot, options = {}) {
                     supplements: [
                         ...(dnaSupplement ? [dnaSupplement] : []),
                         ...stateGrounding,
+                        ...recentTasks,
                         ...hits
                             // State hits are delivered through the State section above, not as raw search lines.
                             .filter((hit) => !["constraints", "decisions", "bugs", "findings"].includes(hit.kind) && !isStateKind(hit.kind))

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,15 +102,29 @@ export function registerTaskReportTools(server, getRoot, getStore) {
                 catch { /* unknowns disclose it */ }
             }
             finishReportTask(root, task_id, outcome ?? "completed");
-            const report = readTaskReport(root, task_id, reportSourceSnapshot(root).hash);
-            const show = reportPresentationEnabled(root);
-            let file = null;
+            // 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 {
-                file = writeTaskReportHtml(root, task_id);
+                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}`;
             }
-            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 report = readTaskReport(root, task_id, reportSourceSnapshot(root).hash);
+            const show = reportPresentationEnabled(root);
+            // The HTML evidence view is rendered on demand (hunch_report(html: true),
+            // `hunch report <id> --html`, or the VS Code view); finish writes no file.
+            const card = 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: null, 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.36.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.36.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.33.0",
+      "version": "1.36.0",
       "runtimeHint": "npx",
       "packageArguments": [
         {