@massu/core 2.5.0 → 2.5.1

package/CHANGELOG.md

@@ -10,6 +10,67 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 > redistributed under the **Apache License 2.0**. Full license + NOTICE:
 > `packages/core/assets/embedder/MODEL-LICENSE`.
 
+## [2.5.1] - 2026-08-09
+
+### Fixed
+
+- **Hooks emitted an output field that does not exist, so no hook message ever reached
+  Claude.** Eleven hooks wrote `{"message": …}` to stdout. `message` is not in Claude Code's
+  hook output schema at all — it appears only in `Notification`/`FileChanged` *input* — so
+  every advisory string those hooks produced was discarded. The failure was self-inflicted in
+  an exact way: because `{"message": …}` is valid JSON, `UserPromptSubmit` parsed it as JSON
+  instead of treating it as plain text, so the one event that would have delivered the string
+  as stdout is precisely the event that dropped it. A slightly malformed string would have
+  arrived.
+
+  Replaced by a single chokepoint emitting the documented shape,
+  `{"hookSpecificOutput": {"hookEventName", "additionalContext"}}`. `hookEventName` is
+  REQUIRED, so the helper takes the event as a typed, required argument and the old
+  one-argument form is DELETED rather than deprecated — a regression to the silent shape is
+  now a compile error, not a silent no-op. An unrecognised event emits nothing and says why
+  on stderr. Output is truncated at the spec's 10,000-char cap by us rather than by the
+  runtime.
+
+  **Blocking behaviour is unchanged.** The `PreToolUse` gates deny via `process.exit(2)` plus
+  stderr, which never depended on this path; what was lost was their *advisory* (warn-level)
+  messages, and everything `rule-enforcement-pipeline` emits, since that hook only ever
+  advises.
+
+### Added
+
+- **`scripts/ops/retag-release-to-npm-githead.sh`** — audits every release tag against the
+  commit npm actually published. A release tag is supposed to answer "which commit shipped as
+  X.Y.Z", and two things break that: the tag is created before the post-publish bookkeeping
+  commit and then moved forward, or it is never created at all. npm records `gitHead` with
+  every publish, so the answer is recoverable — this reads THAT and refuses anything else.
+
+  Dry-run by default; reports its denominator; FAILS CLOSED when the registry returns no
+  usable `gitHead` or names a commit absent from the repo, rather than guessing; never
+  force-pushes — it moves the local tag and prints the push command, so publishing a
+  rewritten ref stays deliberate.
+
+  First full audit: `50 tag(s) examined; 6 already correct, 34 drifted, 10 error(s)`. The 2.x
+  series is now 7/7 correct; 1.x is left as-is deliberately.
+
+### Fixed
+
+- **The documented Stage-D release ceremony had no legal ending.** It ordered
+  `bump -> tag -> publish -> .mcp.json pin refresh`, but the pin refresh is a COMMIT, so
+  following it always leaves commits on top of a published-and-tagged release — exactly what
+  CR-64 refuses. Measured during the 2.5.0 release: gate `[11/22]` returned
+  `versionIsPublished:true, tagSha 90c82344, headSha a74648ae`.
+
+  Corrected to **pin -> publish -> tag**, so the published tree, npm's `gitHead`, the tag and
+  HEAD are one commit by construction. Fixed at both sites that state the order. The repo's
+  own history already worked this way — `v2.3.1`, `v2.3.0` and `v2.1.0` each tag their pin
+  commit — so the prose was the outlier, not the practice.
+
+- **The same plan predicted a release does not touch `website/`.** The CHANGELOG is mirrored
+  into `website/`, so every release does; gate `[9/22]` failed on a 29h deploy lag. Replaced
+  the prediction with the measured fact and made `/massu-deploy` an explicit ceremony step.
+
+Incident: `docs/incidents/2026-08-01-release-ceremony-had-no-legal-ending.md`
+
 ## [2.5.0] - 2026-08-01
 
 ### Fixed

package/commands/massu-bearings.md

@@ -41,7 +41,7 @@ Read these in parallel where possible:
 | 10 | `.claude/metrics/command-invocations.jsonl` | Command usage frequency — top/least used in last 7 days |
 | 11 | `.claude/metrics/bearings-history.jsonl` | Previous bearings runs — show trends |
 | 12 | `.claude/commands/` (ls -d */`) | Detect folder-based skills (directories vs flat files) |
-| 13 | `bash scripts/memory-contradiction-check.sh` | Contradiction count, consolidation candidates |
+| 13 | `~/.claude/bin/memory-contradiction-check . --baseline .claude/memory-contradiction-baseline.json` | Unresolved pairs + denominator; exit 2 = could-not-look, a FINDING |
 | 14 | `massu_cost_session` + `massu_cost_trend` MCP tools | Token spend this session, cost trend over time |
 | 15 | `session-state/deferred-verifications.md` | Pending production verifications from previous deploys |
 

package/commands/massu-recap.md

@@ -104,12 +104,15 @@ If no significant work: skip this section.
 Run the memory contradiction scanner:
 
 ```bash
-bash scripts/memory-contradiction-check.sh
+~/.claude/bin/memory-contradiction-check . --baseline .claude/memory-contradiction-baseline.json
 ```
 
-Parse the output:
-- **CONTRADICTION_COUNT: 0** — Memory is clean. Proceed.
-- **CONTRADICTION_COUNT: N** — Display each contradiction to the user:
+Read the EXIT CODE, and read the denominator it prints — a
+verdict with no `memory files read` line means it aborted before reporting:
+- **exit 0** — no unresolved contradictions. Quote `unresolved pairs : 0` as the evidence.
+- **exit 1** — unresolved pairs, or a STALE baseline entry. Display each to the user:
+- **exit 2** — it COULD NOT LOOK (missing corpus, unreadable file, bad baseline). This is
+  a FINDING, never a clean run. Report it as such and do not proceed as though clean.
 
 ```
 MEMORY HEALTH
@@ -122,7 +125,15 @@ MEMORY HEALTH
 
 **Do NOT auto-resolve contradictions.** Surface them so the user can decide which memory is stale.
 
-If the script is missing or fails, note: "Memory contradiction check unavailable — run `bash scripts/memory-contradiction-check.sh` manually."
+**If the checker is missing, report that as a FAILED check — never as a benign note.**
+This step was unrunnable in this repo from the day it was written until 2026-08-02: it
+named `scripts/memory-contradiction-check.sh`, which never existed here (0 tracked
+matches, 0 commits ever touching the path — it was copied from another repo's protocol).
+The instruction to "note it as unavailable" is what let a mandatory check report nothing
+for months, because "could not look" and "looked and found nothing" read identically.
+The checker is now version-controlled at `~/.claude/bin/memory-contradiction-check`, has a
+caller in `npm test` (`memory-contradiction-check-caller.test.ts`), a fixture suite, and a
+live-fire attack — so its absence is itself a red test.
 
 ### Step 3: Update Session State
 

package/dist/cli.js

@@ -1548,6 +1548,16 @@ var init_memory_vector = __esm({
   }
 });
 
+// src/lib/timestamps.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var init_timestamps = __esm({
+  "src/lib/timestamps.ts"() {
+    "use strict";
+  }
+});
+
 // src/db-backup.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync2, unlinkSync, copyFileSync, rmSync as rmSync4 } from "fs";
 import { resolve as resolve3, join as join3, basename, dirname as dirname4 } from "path";
@@ -3972,8 +3982,8 @@ function linkSessionToTask(db, sessionId, taskId) {
 }
 function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantResponse, toolCallsJson, toolCallCount, promptTokens, responseTokens) {
   const result = db.prepare(`
-    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     sessionId,
     turnNumber,
@@ -3982,14 +3992,15 @@ function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantRes
     toolCallsJson,
     toolCallCount,
     promptTokens,
-    responseTokens
+    responseTokens,
+    nowIso()
   );
   return Number(result.lastInsertRowid);
 }
 function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, inputSize, outputSize, success, filesInvolved) {
   db.prepare(`
-    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     sessionId,
     turnNumber,
@@ -3998,7 +4009,8 @@ function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, in
     inputSize,
     outputSize,
     success ? 1 : 0,
-    filesInvolved ? JSON.stringify(filesInvolved) : null
+    filesInvolved ? JSON.stringify(filesInvolved) : null,
+    nowIso()
   );
 }
 function getLastProcessedLine(db, sessionId) {
@@ -4257,6 +4269,7 @@ var init_memory_db = __esm({
     init_db_driver();
     init_config();
     init_memory_vector();
+    init_timestamps();
     init_db_backup();
     init_rule_delivery();
     init_rule_candidate_store();
@@ -20573,7 +20586,7 @@ import { createHash as createHash8 } from "crypto";
 function renderMemoryFiles(db, candidates, opts) {
   const config = opts.config ?? resolveMemoryFilesConfig();
   if (!config.renderEnabled) {
-    return EMPTY("render_disabled");
+    return EMPTY("render_disabled", candidates.length);
   }
   const dryRun = opts.dryRun === true;
   const now = opts.now ?? Date.now();
@@ -20582,7 +20595,7 @@ function renderMemoryFiles(db, candidates, opts) {
   });
   const { memoryDir } = opts;
   if (!existsSync33(memoryDir)) {
-    return EMPTY("no_memory_dir");
+    return EMPTY("no_memory_dir", candidates.length);
   }
   try {
     return withMemoryIndexLock(
@@ -20591,10 +20604,10 @@ function renderMemoryFiles(db, candidates, opts) {
     );
   } catch (err) {
     if (err instanceof MemoryIndexLockBusy) {
-      return EMPTY("lock_busy");
+      return EMPTY("lock_busy", candidates.length);
     }
     audit("memory_file_render_refused", { reason: "unexpected_error", error: String(err) });
-    return EMPTY("error");
+    return EMPTY("error", candidates.length);
   }
 }
 function renderLocked(db, candidates, o) {
@@ -20604,11 +20617,14 @@ function renderLocked(db, candidates, o) {
   try {
     tombstones = readTombstones(memoryDir);
   } catch {
-    return EMPTY("tombstone_ledger_unreadable");
+    return EMPTY("tombstone_ledger_unreadable", candidates.length);
   }
   const ownerOf = relPathOwnerLookup(db);
   const planned = [];
-  for (const c2 of candidates) {
+  let unchanged = 0;
+  let capped = 0;
+  for (let i = 0; i < candidates.length; i++) {
+    const c2 = candidates[i];
     if (!isLocalOrigin(c2.origin)) {
       refusals.push({ name: c2.name, reason: "non_local_origin", detail: c2.origin || "unknown" });
       audit("memory_file_render_refused", { name: c2.name, reason: "non_local_origin" });
@@ -20664,7 +20680,10 @@ function renderLocked(db, candidates, o) {
         continue;
       }
       const next = composeFile(c2, home);
-      if (next !== null && next === existing) continue;
+      if (next !== null && next === existing) {
+        unchanged++;
+        continue;
+      }
     }
     const content = composeFile(c2, home);
     if (content === null) {
@@ -20672,9 +20691,24 @@ function renderLocked(db, candidates, o) {
       continue;
     }
     planned.push({ c: c2, relPath, absPath, content });
-    if (planned.length >= config.renderMaxFilesPerSession) break;
+    if (planned.length >= config.renderMaxFilesPerSession) {
+      capped = candidates.length - (i + 1);
+      break;
+    }
+  }
+  const accounted = planned.length + refusals.length + unchanged + capped;
+  if (accounted !== candidates.length) {
+    audit("memory_file_render_refused", {
+      reason: "accounting_leak",
+      considered: candidates.length,
+      accounted
+    });
+    throw new RenderAccountingLeak(
+      `render did not account for every candidate: considered=${candidates.length} but accounted=${accounted} (planned=${planned.length} refused=${refusals.length} unchanged=${unchanged} capped=${capped}). A candidate was dropped without a bucket.`
+    );
   }
   const indexLines = buildIndexLines(db, memoryDir, planned, config);
+  const books = { considered: candidates.length, unchanged, capped };
   if (dryRun) {
     return {
       enabled: true,
@@ -20682,11 +20716,20 @@ function renderLocked(db, candidates, o) {
       written: planned.map((p19) => p19.relPath),
       refusals,
       indexLines,
-      bytesWritten: 0
+      bytesWritten: 0,
+      ...books
     };
   }
   if (planned.length === 0 && indexLines.length === 0) {
-    return { enabled: true, dryRun: false, written: [], refusals, indexLines: [], bytesWritten: 0 };
+    return {
+      enabled: true,
+      dryRun: false,
+      written: [],
+      refusals,
+      indexLines: [],
+      bytesWritten: 0,
+      ...books
+    };
   }
   if (!hasFreshBackup(memoryDir, home)) {
     try {
@@ -20696,7 +20739,7 @@ function renderLocked(db, candidates, o) {
         reason: "backup_failed",
         error: err instanceof BackupError ? err.message : String(err)
       });
-      return EMPTY("backup_failed");
+      return EMPTY("backup_failed", candidates.length);
     }
   }
   const indexPath = o.indexPath ?? join19(memoryDir, "MEMORY.md");
@@ -20764,7 +20807,10 @@ function renderLocked(db, candidates, o) {
         errors: restored.errors
       });
       return {
-        ...EMPTY("rollback_incomplete"),
+        ...EMPTY("rollback_incomplete", candidates.length),
+        // The books were balanced before the write began; keep them rather than zeroing.
+        unchanged,
+        capped,
         enabled: true,
         refusals: [
           ...refusals,
@@ -20773,9 +20819,9 @@ function renderLocked(db, candidates, o) {
       };
     }
     audit("memory_file_render_refused", { reason: "write_failed", error: String(err) });
-    return { ...EMPTY("write_failed"), enabled: true, refusals };
+    return { ...EMPTY("write_failed", candidates.length), enabled: true, refusals, unchanged, capped };
   }
-  return { enabled: true, dryRun: false, written, refusals, indexLines, bytesWritten };
+  return { enabled: true, dryRun: false, written, refusals, indexLines, bytesWritten, ...books };
 }
 function sha2562(s) {
   return createHash8("sha256").update(s, "utf8").digest("hex");
@@ -20844,7 +20890,7 @@ function buildIndexLines(db, memoryDir, planned, config) {
 function oneLine(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 120);
 }
-var EMPTY;
+var RenderAccountingLeak, EMPTY;
 var init_memory_renderer = __esm({
   "src/memory-renderer.ts"() {
     "use strict";
@@ -20859,14 +20905,22 @@ var init_memory_renderer = __esm({
     init_memory_index_region();
     init_memory_files_config();
     init_memory_file_ingest();
-    EMPTY = (reason) => ({
+    RenderAccountingLeak = class extends Error {
+    };
+    EMPTY = (reason, considered = 0) => ({
       enabled: false,
       dryRun: false,
       written: [],
       refusals: [],
       indexLines: [],
       bytesWritten: 0,
-      skippedReason: reason
+      skippedReason: reason,
+      // An early gate refused, so every candidate was dropped — by that ONE named reason.
+      // Reporting `considered` here is what distinguishes "nothing to do" from "walked away
+      // from 59 rows because the lock was busy".
+      considered,
+      unchanged: 0,
+      capped: 0
     });
   }
 });
@@ -21057,25 +21111,46 @@ var init_memory_render_cli = __esm({
 function loadRenderCandidates(db) {
   const cfg = resolveMemoryFilesConfig();
   const typePlaceholders = RENDERABLE_MEMORY_TYPES.map(() => "?").join(", ");
+  const WHERE = `WHERE importance >= ?
+       AND COALESCE(expired_at_epoch, 0) = 0
+       AND type IN (${typePlaceholders})`;
+  const { population } = db.prepare(`SELECT COUNT(*) AS population FROM observations ${WHERE}`).get(cfg.renderMinImportance, ...RENDERABLE_MEMORY_TYPES);
   const rows = db.prepare(
     `SELECT id, title, detail, importance, COALESCE(origin, 'local') AS origin
          FROM observations
-        WHERE importance >= ?
-          AND COALESCE(expired_at_epoch, 0) = 0
-          AND type IN (${typePlaceholders})
+         ${WHERE}
         ORDER BY importance DESC, created_at_epoch DESC
-        LIMIT 50`
+        LIMIT ${CANDIDATE_WINDOW}`
   ).all(cfg.renderMinImportance, ...RENDERABLE_MEMORY_TYPES);
-  return rows.filter((r2) => !r2.title.startsWith("[memory-file]")).map((r2) => ({
-    observationId: r2.id,
-    name: r2.title,
-    title: r2.title,
-    body: r2.detail ?? "",
-    importance: r2.importance,
-    origin: r2.origin
-  }));
+  const reingest = rows.filter((r2) => r2.title.startsWith("[memory-file]"));
+  const kept = rows.filter((r2) => !r2.title.startsWith("[memory-file]"));
+  const excluded = reingest.length ? [{ reason: EXCLUSION_MEMORY_FILE_REINGEST, count: reingest.length }] : [];
+  const ledger = {
+    population,
+    windowed: rows.length,
+    truncatedByWindow: Math.max(0, population - rows.length),
+    excluded,
+    returned: kept.length
+  };
+  const accounted = ledger.returned + ledger.truncatedByWindow + excluded.reduce((n, e2) => n + e2.count, 0);
+  if (accounted !== population) {
+    throw new CandidateAccountingLeak(
+      `candidate ledger does not balance: population=${population} but accounted=${accounted} (returned=${ledger.returned} truncated=${ledger.truncatedByWindow} excluded=${JSON.stringify(excluded)}). A row was dropped without a bucket.`
+    );
+  }
+  return {
+    ledger,
+    candidates: kept.map((r2) => ({
+      observationId: r2.id,
+      name: r2.title,
+      title: r2.title,
+      body: r2.detail ?? "",
+      importance: r2.importance,
+      origin: r2.origin
+    }))
+  };
 }
-var RENDERABLE_MEMORY_TYPES;
+var RENDERABLE_MEMORY_TYPES, CANDIDATE_WINDOW, EXCLUSION_MEMORY_FILE_REINGEST, CandidateAccountingLeak;
 var init_memory_render_candidates = __esm({
   "src/memory-render-candidates.ts"() {
     "use strict";
@@ -21086,6 +21161,10 @@ var init_memory_render_candidates = __esm({
       "incident_near_miss",
       "cr_violation"
     ];
+    CANDIDATE_WINDOW = 50;
+    EXCLUSION_MEMORY_FILE_REINGEST = "memory_file_reingest";
+    CandidateAccountingLeak = class extends Error {
+    };
   }
 });
 
@@ -21165,13 +21244,13 @@ function pruneNoiseObservations(db, opts = {}) {
   const counts = countNoise(db);
   if (dryRun || counts.total === 0) return { counts, expired: 0, dryRun };
   const nowSec = opts.now ?? Math.floor(Date.now() / 1e3);
-  const nowIso = new Date(nowSec * 1e3).toISOString();
+  const nowIso2 = new Date(nowSec * 1e3).toISOString();
   const res = db.prepare(
     `UPDATE observations
           SET expired_at = ?, expired_at_epoch = ?, valid_to = ?, valid_to_epoch = ?
         WHERE COALESCE(expired_at_epoch, 0) = 0
           AND ((${DA_PREDICATE}) OR (${FT_DECISION_PREDICATE}) OR (${DB_PREDICATE}))`
-  ).run(nowIso, nowSec, nowIso, nowSec);
+  ).run(nowIso2, nowSec, nowIso2, nowSec);
   return { counts, expired: res.changes, dryRun: false };
 }
 var DA_PREDICATE, FT_DECISION_PREDICATE, DB_PREDICATE;
@@ -21216,7 +21295,7 @@ async function runMemoryRenderCli(sub, args2) {
           };
         }
         const cfg = resolveMemoryFilesConfig();
-        const candidates = loadRenderCandidates(db);
+        const { candidates, ledger } = loadRenderCandidates(db);
         const result = renderMemoryFiles(db, candidates, {
           memoryDir,
           dryRun: true,
@@ -21231,6 +21310,19 @@ async function runMemoryRenderCli(sub, args2) {
         }
         lines.push(`Massu would write ${result.written.length} file(s):`);
         for (const f2 of result.written) lines.push(`  ${f2}`);
+        lines.push("", "Where every row went:");
+        lines.push(`  candidate population (type+importance+expiry) : ${ledger.population}`);
+        if (ledger.truncatedByWindow > 0) {
+          lines.push(`    truncated by the row window                : ${ledger.truncatedByWindow}`);
+        }
+        for (const e2 of ledger.excluded) {
+          lines.push(`    excluded: ${e2.reason.padEnd(30)} : ${e2.count}`);
+        }
+        lines.push(`    -> reached the renderer                    : ${ledger.returned}`);
+        lines.push(
+          `  renderer: considered ${result.considered} = written ${result.written.length} + refused ${result.refusals.length} + unchanged ${result.unchanged} + capped ${result.capped}`
+        );
+        lines.push(`  skipped: ${result.skippedReason ?? "(none)"}`);
         if (result.indexLines.length > 0) {
           lines.push("", "MEMORY.md \u2014 inside the massu:learned region only:");
           for (const l2 of result.indexLines) lines.push(`  ${l2}`);
@@ -23389,7 +23481,7 @@ async function pullInstalledPackRules(db, opts = {}) {
   }
   const packs = parsePacks(envelope.packs_json);
   const result = { ...ZERO };
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const nowIso2 = (/* @__PURE__ */ new Date()).toISOString();
   for (const pack of packs) {
     if (!isValidInstalledPack(pack)) continue;
     for (const rawRule of pack.rules) {
@@ -23406,7 +23498,7 @@ async function pullInstalledPackRules(db, opts = {}) {
         result.skipped += 1;
         continue;
       }
-      materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack, signedOrgId, nowIso, opts.home ?? homedir20());
+      materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack, signedOrgId, nowIso2, opts.home ?? homedir20());
       result.materialized += 1;
     }
   }
@@ -23453,7 +23545,7 @@ function alreadyApplied(db, promptHash) {
     return false;
   }
 }
-function materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack, orgId, nowIso, home) {
+function materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack, orgId, nowIso2, home) {
   const promptText = `${rule.title}: ${rule.description}`.replace(/\n+/g, " ").slice(0, 200) || `pack rule ${promptHash}`;
   const draftText = rule.pattern ?? rule.check ?? rule.description;
   const hardened = isExecutableDestination(rule.destination);
@@ -23469,7 +23561,7 @@ function materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack
     score: 0,
     signals: [],
     prior_turn_files: [],
-    timestamp: nowIso,
+    timestamp: nowIso2,
     session_id: `pack:${pack.slug}`,
     // Provenance (P2-002/P2-003): the applier's team-origin / hardened apply-gate
     // keys on this. `origin:'pack'` rides the SAME gate as a team origin
@@ -23481,7 +23573,7 @@ function materializeCandidate(projectRoot, candidatePath, promptHash, rule, pack
       origin: "pack",
       org_id: orgId,
       promoted_by: `pack:${pack.slug}`,
-      promoted_at: nowIso,
+      promoted_at: nowIso2,
       signature_verified: true,
       ...applyMac ? { apply_mac: applyMac } : {},
       pack_slug: pack.slug,
@@ -34681,7 +34773,7 @@ function indexAllKnowledge(db) {
     files.push(...docsFiles);
   }
   const now = /* @__PURE__ */ new Date();
-  const nowIso = now.toISOString();
+  const nowIso2 = now.toISOString();
   const nowEpoch = now.getTime();
   const transaction = db.transaction(() => {
     db.exec("DROP TRIGGER IF EXISTS kc_fts_delete");
@@ -34725,7 +34817,7 @@ function indexAllKnowledge(db) {
       const category = categorizeFile(filePath);
       const title = extractTitle(content, filePath);
       const description = extractDescription2(content);
-      const result = insertDoc.run(relPath, category, title, description, hash, nowIso, nowEpoch);
+      const result = insertDoc.run(relPath, category, title, description, hash, nowIso2, nowEpoch);
       const docId = result.lastInsertRowid;
       stats.filesIndexed++;
       const sections = parseSections(content, filePath);

package/dist/hooks/auto-learning-pipeline.js

@@ -1339,6 +1339,16 @@ var init_memory_vector = __esm({
   }
 });
 
+// src/lib/timestamps.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var init_timestamps = __esm({
+  "src/lib/timestamps.ts"() {
+    "use strict";
+  }
+});
+
 // src/db-backup.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync, statSync, unlinkSync, copyFileSync, rmSync as rmSync4 } from "fs";
 import { resolve as resolve3, join as join3, basename, dirname as dirname4 } from "path";
@@ -3599,8 +3609,8 @@ function linkSessionToTask(db, sessionId, taskId) {
 }
 function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantResponse, toolCallsJson, toolCallCount, promptTokens, responseTokens) {
   const result = db.prepare(`
-    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     sessionId,
     turnNumber,
@@ -3609,14 +3619,15 @@ function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantRes
     toolCallsJson,
     toolCallCount,
     promptTokens,
-    responseTokens
+    responseTokens,
+    nowIso()
   );
   return Number(result.lastInsertRowid);
 }
 function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, inputSize, outputSize, success, filesInvolved) {
   db.prepare(`
-    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     sessionId,
     turnNumber,
@@ -3625,7 +3636,8 @@ function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, in
     inputSize,
     outputSize,
     success ? 1 : 0,
-    filesInvolved ? JSON.stringify(filesInvolved) : null
+    filesInvolved ? JSON.stringify(filesInvolved) : null,
+    nowIso()
   );
 }
 function getLastProcessedLine(db, sessionId) {
@@ -3884,6 +3896,7 @@ var init_memory_db = __esm({
     init_db_driver();
     init_config();
     init_memory_vector();
+    init_timestamps();
     init_db_backup();
     init_rule_delivery();
     init_rule_candidate_store();
@@ -3980,12 +3993,43 @@ import { tmpdir as tmpdir2 } from "os";
 import { join as join6 } from "path";
 
 // src/hooks/lib/write-hook-message.ts
-function writeHookMessage(message) {
-  process.stdout.write(JSON.stringify({ message }) + "\n");
+var HOOK_EVENTS = [
+  "UserPromptSubmit",
+  "UserPromptExpansion",
+  "SessionStart",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop",
+  "PreCompact"
+];
+var ADDITIONAL_CONTEXT_MAX_CHARS = 1e4;
+function isHookEvent(value) {
+  return typeof value === "string" && HOOK_EVENTS.includes(value);
+}
+function writeHookContext(hookEventName, message) {
+  if (!isHookEvent(hookEventName)) {
+    process.stderr.write(
+      `[massu] writeHookContext: refusing to emit \u2014 unrecognised hook event ${JSON.stringify(hookEventName)}. Known: ${HOOK_EVENTS.join(", ")}.
+`
+    );
+    return;
+  }
+  if (typeof message !== "string" || message.length === 0) return;
+  let additionalContext = message;
+  if (additionalContext.length > ADDITIONAL_CONTEXT_MAX_CHARS) {
+    const marker = `
+[massu] \u2026truncated at ${ADDITIONAL_CONTEXT_MAX_CHARS} chars (spec cap).`;
+    additionalContext = additionalContext.slice(0, ADDITIONAL_CONTEXT_MAX_CHARS - marker.length) + marker;
+  }
+  process.stdout.write(
+    JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext } }) + "\n"
+  );
 }
 
 // src/hooks/auto-learning-pipeline.ts
 init_hook_failure_signal();
+var HOOK_EVENT = "Stop";
 var MAX_FULL_DIFF_BYTES = 2 * 1024 * 1024;
 function getSessionFlagPath(sessionId) {
   return join6(tmpdir2(), "massu-auto-learning", `fixes-${sessionId.slice(0, 12)}.jsonl`);
@@ -4104,7 +4148,7 @@ async function main() {
     lines.push("");
     lines.push("============================================================================");
     lines.push("");
-    writeHookMessage(lines.join("\n"));
+    writeHookContext(HOOK_EVENT, lines.join("\n"));
     cleanup(flagPath);
   } catch (err) {
     recordHookFailure("auto-learning-pipeline", err);