@davesheffer/hunch 1.40.0 → 1.40.1

package/dist/cli/index.js

@@ -36,7 +36,7 @@ import { publishedStatus } from "../integrations/registry.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { JsonStore } from "../store/jsonStore.js";
 import { selectEmbedder } from "../store/embedder.js";
-import { assertCompleteRepoScan, indexRepo, mergeScannedEdges, scanRepo } from "../extractors/indexer.js";
+import { assertCompleteRepoScan, assertNoTotalParseFailure, indexRepo, mergeScannedEdges, scanRepo } from "../extractors/indexer.js";
 // Importing this module is free (the addon load is a function call, not a
 // top-level side effect); only `doctor` below actually calls the loader.
 import { isParserLoadError, loadNativeTreeSitter } from "../extractors/nativeTreeSitter.js";
@@ -7227,11 +7227,12 @@ program
     // past the isolation guard) is invisible until an index run refuses.
     try {
         loadNativeTreeSitter();
+        assertNoTotalParseFailure(scanRepo(store, root, { churn: false }));
         console.log(`parser:     native tree-sitter addons load`);
     }
     catch (e) {
         console.log(`parser:     ⛔ ${e.message}`);
-        console.log(dim(`            no file can be parsed — \`hunch index\` refuses rather than emptying the graph`));
+        console.log(dim(`            \`hunch index\` refuses rather than replacing the graph after a parser failure`));
         process.exitCode = 1;
     }
     const c = store.reindex().counts;

package/dist/core/taskReportRender.d.ts

@@ -1,5 +1,8 @@
 import { type LessonHistory, type TaskReport } from "./taskReport.js";
 export declare function writeTaskReportHtml(root: string, taskId: string, publicOnly?: boolean): string;
+/** Delivered lessons are named on the card up to this many; beyond it the
+ * count of the rest is stated, never a silent cut. */
+export declare const CARD_RECALLED_LIMIT = 8;
 /** One short line for the first time a lesson reaches a task; null when every
  * delivered revision was already seen in this task. Never a banner per delivery. */
 export declare function renderRecalledLine(fresh: readonly {

package/dist/core/taskReportRender.js

@@ -21,8 +21,15 @@ export function writeTaskReportHtml(root, taskId, publicOnly = false) {
     writeFileAtomic(file, publicOnly ? renderPublicTaskReportHtml(publicTaskReport(root, taskId)) : renderTaskReportHtml(report, undefined, histories));
     return file;
 }
+/** Card text is copied verbatim into an agent's final response, so every
+ * field is shown whole: a title cut mid-word with an ellipsis reads as a
+ * truncated tool result and the agent refuses to reproduce the card. Every
+ * rendered field is schema-bounded (task title and check label ≤ 200
+ * characters, record titles ≤ 500), so whole never means unbounded. */
 function plain(value) { return value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim(); }
-function clip(value, size = 66) { const chars = [...plain(value)]; return chars.length > size ? chars.slice(0, size - 1).join("") + "…" : chars.join(""); }
+/** Delivered lessons are named on the card up to this many; beyond it the
+ * count of the rest is stated, never a silent cut. */
+export const CARD_RECALLED_LIMIT = 8;
 function uniqueRecords(report) {
     return [...new Map(report.deliveries.flatMap(d => d.records).map(r => [`${r.kind}:${r.record_id}:${r.content_hash}`, r])).values()];
 }
@@ -42,41 +49,44 @@ export function renderRecalledLine(fresh) {
     if (!fresh.length)
         return null;
     const rest = fresh.length - 1;
-    return `Hunch recalled: ${clip(fresh[0].title, 90)}${rest ? ` (+${rest} more lesson${rest === 1 ? "" : "s"})` : ""}`;
+    return `Hunch recalled: ${plain(fresh[0].title)}${rest ? ` (+${rest} more lesson${rest === 1 ? "" : "s"})` : ""}`;
 }
 export function renderTaskReport(report) {
     const records = uniqueRecords(report);
-    const lines = [`Hunch · ${clip(report.task.title)}`, `Task ${report.task.task_id} · ${report.task.state}`];
+    const lines = [`Hunch · ${plain(report.task.title)}`, `Task ${report.task.task_id} · ${report.task.state}`];
     if (!report.deliveries.length)
         lines.push("No task-linked delivery observed; connection/use is unverified.");
     else if (!records.length)
         lines.push(report.coverage === "no-relevant-memory" ? "No relevant memory returned for this task." : "Memory delivered; exact record snapshots unavailable.");
     else {
-        lines.push(`Recalled  ${clip(records[0].title, 65)}`);
-        if (records.length > 1)
-            lines.push(`          ${records.length - 1} more lesson(s) in the evidence view`);
+        const named = records.slice(0, CARD_RECALLED_LIMIT);
+        lines.push(`Recalled  ${plain(named[0].title)}`);
+        for (const record of named.slice(1))
+            lines.push(`          ${plain(record.title)}`);
+        if (records.length > named.length)
+            lines.push(`          ${records.length - named.length} more lesson(s) in the evidence view`);
     }
     const standing = ruleStanding(report);
     const violated = standing.find(r => r.outcome === "violated");
     const held = standing.find(r => r.outcome === "satisfied" && r.current);
     if (report.claims.length) {
         const claim = report.claims.find(c => c.supported_by) ?? report.claims[0];
-        lines.push(`Applied   ${clip(claim.action, 42)} · ${claim.supported_by ? "rule-supported" : "agent-reported"}`);
+        lines.push(`Applied   ${plain(claim.action)} · ${claim.supported_by ? "rule-supported" : "agent-reported"}`);
     }
     else if (held)
-        lines.push(`Conformed ${clip(recordTitle(report, held), 34)} · rule held on ${held.files.length} changed file(s)`);
+        lines.push(`Conformed ${plain(recordTitle(report, held))} · rule held on ${held.files.length} changed file(s)`);
     else if (records.length)
         lines.push("Impact    Memory delivered; contribution unverified.");
     if (violated)
-        lines.push(`Violated  ${clip(recordTitle(report, violated), 34)} · rule broken on changed files`);
+        lines.push(`Violated  ${plain(recordTitle(report, violated))} · rule broken on changed files`);
     if (report.saves.length)
-        lines.push(`Saved     ${clip(report.saves[0].record.title, 38)} · ${report.saves[0].durability}`);
+        lines.push(`Saved     ${plain(report.saves[0].record.title)} · ${report.saves[0].durability}`);
     if (report.refusals.length)
-        lines.push(`Guarded   Denial emitted · ${clip(report.refusals[0].record_id, 40)}`);
+        lines.push(`Guarded   Denial emitted · ${plain(report.refusals[0].record_id)}`);
     const check = report.checks.at(-1);
     if (check) {
         const state = check.cancelled ? "cancelled" : check.timed_out ? "timed out" : check.exit_code === 0 ? "passed" : "failed";
-        lines.push(`Checked   ${clip(check.label, 28)} · ${state}${check.current ? " · current source snapshot" : " · current source unverified"}`);
+        lines.push(`Checked   ${plain(check.label)} · ${state}${check.current ? " · current source snapshot" : " · current source unverified"}`);
     }
     else
         lines.push("Checked   No independent command result recorded.");

package/dist/extractors/indexer.d.ts

@@ -46,6 +46,11 @@ export interface IndexRepoOptions {
  * false satisfied receipt. Call this after scanRepo when the consumer cannot
  * represent partial-graph uncertainty directly. */
 export declare function assertCompleteRepoScan(scan: RepoScan): void;
+/** A whole-language failure can be a broken grammar, not a set of bad files.
+ * Refuse the entire publication so cross-language edges and curated components
+ * remain consistent with the previous symbols. Read-only scans retain coverage
+ * and issues for diagnostics; a valid empty scan is still publishable. */
+export declare function assertNoTotalParseFailure(scan: RepoScan): void;
 /** Derive the current repository graph without writing JSON or rebuilding SQLite.
  * Read-only gates use this so checking changed code can never rewrite or publish
  * the durable graph merely by inspecting it. Existing public graph records remain

package/dist/extractors/indexer.js

@@ -35,6 +35,20 @@ export function assertCompleteRepoScan(scan) {
     const more = scan.issues.length > 5 ? ` (+${scan.issues.length - 5} more)` : "";
     throw new Error(`incomplete semantic source scan rejected ${scan.issues.length} file(s): ${sample}${more}`);
 }
+/** A whole-language failure can be a broken grammar, not a set of bad files.
+ * Refuse the entire publication so cross-language edges and curated components
+ * remain consistent with the previous symbols. Read-only scans retain coverage
+ * and issues for diagnostics; a valid empty scan is still publishable. */
+export function assertNoTotalParseFailure(scan) {
+    const failed = scan.result.coverage.filter((item) => item.eligible > 0 && item.reasons.parse_failed === item.eligible);
+    if (!failed.length)
+        return;
+    const details = failed.map((item) => {
+        const first = scan.issues.find((issue) => issue.code === "parse_failed" && languageFor(issue.path)?.id === item.language);
+        return `${item.language}: all ${item.eligible} eligible file(s) failed to parse; ${first?.detail ?? "unknown parse failure"}`;
+    });
+    throw new Error(`index refused — ${details.join("; ")}. Previous graph preserved.`);
+}
 /** Derive the current repository graph without writing JSON or rebuilding SQLite.
  * Read-only gates use this so checking changed code can never rewrite or publish
  * the durable graph merely by inspecting it. Existing public graph records remain
@@ -150,7 +164,7 @@ export function scanRepo(store, root, opts = {}) {
         // one bad/oversized file must never abort the whole index run
         let parsed;
         try {
-            parsed = parseSource(rel, src);
+            parsed = parseSource(rel, src, { throwOnParseError: true });
         }
         catch (error) {
             // …but a dead PARSER is not a bad file. The native addons load on first
@@ -163,7 +177,7 @@ export function scanRepo(store, root, opts = {}) {
             if (isParserLoadError(error))
                 throw error;
             skipped++;
-            issues.push({ path: rel, code: "parse_failed", detail: `${rel} could not be parsed` });
+            issues.push({ path: rel, code: "parse_failed", detail: `${rel} could not be parsed: ${error instanceof Error ? error.message : String(error)}` });
             noteSkip(rel, "parse_failed");
             continue;
         }
@@ -619,6 +633,7 @@ export function indexRepo(store, root, opts = {}) {
         ? { kind: "commit", ref: "HEAD" }
         : opts.source;
     const scan = scanRepo(store, root, { churn: opts.churn, source });
+    assertNoTotalParseFailure(scan);
     if (opts.requireComplete)
         assertCompleteRepoScan(scan);
     store.json.replaceAll("symbols", scan.symbols);

package/dist/extractors/parse.d.ts

@@ -34,7 +34,9 @@ export interface ParsedFile {
 /** Cap on a stored symbol's bodyText — large enough for review context, small
  *  enough that a huge function/file doesn't bloat every JSON symbol record. */
 export declare const MAX_BODY_TEXT_CHARS = 4000;
-export declare function parseSource(file: string, source: string): ParsedFile | null;
+export declare function parseSource(file: string, source: string, opts?: {
+    throwOnParseError?: boolean;
+}): ParsedFile | null;
 /** Map each call site to the innermost symbol whose byte-range contains it.
  *  Keyed by the symbol's position (index) in `parsed.symbols` — NOT its
  *  startByte, which is not a reliable per-symbol identity: a language whose

package/dist/extractors/parse.js

@@ -23,7 +23,7 @@ const STR_QUOTES = /^['"`]|['"`]$/g;
 /** Cap on a stored symbol's bodyText — large enough for review context, small
  *  enough that a huge function/file doesn't bloat every JSON symbol record. */
 export const MAX_BODY_TEXT_CHARS = 4000;
-export function parseSource(file, source) {
+export function parseSource(file, source, opts = {}) {
     const spec = languageFor(file);
     if (!spec)
         return null;
@@ -49,7 +49,11 @@ export function parseSource(file, source) {
     try {
         tree = parser.parse(source, undefined, { bufferSize: Math.max(32 * 1024, source.length * 2 + 1024) });
     }
-    catch {
+    catch (error) {
+        // Index scans need the underlying diagnostic for whole-language failures.
+        // Other callers retain the historical best-effort null result.
+        if (opts.throwOnParseError)
+            throw error;
         return null;
     }
     const symbols = [];

package/dist/store/stateBinding.js

@@ -1036,7 +1036,7 @@ export function subscribeState(store, input, options = {}) {
     const access = createStateAccess(store, request.principal, options);
     const visibilityFiltered = ledger.events.some(e => e.visibility !== undefined) || access.restricted;
     const filtered = !!(facets || subjects || visibilityFiltered);
-    const resync = request.after_seq < ledger.floor_seq;
+    const resync = request.after_seq < ledger.floor_seq || request.after_seq > ledger.head_seq;
     const after = resync ? ledger.floor_seq : request.after_seq;
     const events = ledger.events.filter((e) => e.seq > after
         && (!visibilityFiltered || (visibilityAllows(e, request.principal.id) && access.canRead(findRecord(store, e.record_id)?.record) && access.referencesVisible(e)))

package/package.json

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

package/server.json

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