@pcircle/memesh 4.8.2 → 4.8.5

package/scripts/hooks/_generated/work-topology.js

@@ -82,10 +82,15 @@ export function groupTopology(entities, projectName) {
     const lessons = [];
     const knowledge = [];
     const evidence = [];
+    const global = [];
     const foreign = [];
     for (const e of entities) {
         if (e.type === 'task-state')
             continue;
+        if (e.global) {
+            global.push(e);
+            continue;
+        }
         if (e.foreign) {
             foreign.push(e);
             continue;
@@ -104,7 +109,7 @@ export function groupTopology(entities, projectName) {
         else
             decisions.push(e);
     }
-    for (const list of [decisions, lessons, knowledge, evidence, foreign])
+    for (const list of [decisions, lessons, knowledge, evidence, global, foreign])
         list.sort(bySignal);
     const sections = [];
     if (decisions.length)
@@ -115,6 +120,8 @@ export function groupTopology(entities, projectName) {
         sections.push({ heading: `What is known about "${projectName}":`, entities: knowledge });
     if (evidence.length)
         sections.push({ heading: `Recent activity in "${projectName}":`, entities: evidence });
+    if (global.length)
+        sections.push({ heading: 'Global memory — applies across projects:', entities: global });
     if (foreign.length)
         sections.push({ heading: 'From your other projects (may or may not apply here):', entities: foreign });
     return sections;
@@ -124,6 +131,11 @@ export const DEFAULT_TOPOLOGY_BUDGET = {
     maxChars: 4000,
     maxLineChars: 160,
 };
+export const GLOBAL_TOPOLOGY_LIMIT = 3;
+const GLOBAL_TOPOLOGY_BUDGET = {
+    maxChars: 640,
+    maxLineChars: DEFAULT_TOPOLOGY_BUDGET.maxLineChars,
+};
 export const TOPOLOGY_CANDIDATE_CAP = 400;
 export const SNIPPET_FETCH_CHARS = DEFAULT_TOPOLOGY_BUDGET.maxLineChars * 4;
 export function buildTopologyLines(entities, projectName, budget) {
@@ -155,12 +167,18 @@ export function buildTopologyLines(entities, projectName, budget) {
 export function assembleTopologyBlock(stateLines, pools, projectName, budget = DEFAULT_TOPOLOGY_BUDGET) {
     const seen = new Set();
     const candidates = [];
+    const globalCandidates = [];
     for (const pool of pools) {
         for (const e of pool.entities) {
             if (seen.has(e.name))
                 continue;
             seen.add(e.name);
-            candidates.push(pool.foreign && !e.foreign ? { ...e, foreign: true } : e);
+            if (pool.global) {
+                globalCandidates.push(e.global ? e : { ...e, global: true });
+            }
+            else {
+                candidates.push(pool.foreign && !e.foreign ? { ...e, foreign: true } : e);
+            }
         }
     }
     const lines = [];
@@ -173,9 +191,13 @@ export function assembleTopologyBlock(stateLines, pools, projectName, budget = D
     const topologyLines = remaining > 0
         ? buildTopologyLines(candidates, projectName, { ...budget, maxChars: remaining })
         : [];
+    const globalLines = buildTopologyLines(globalCandidates, projectName, GLOBAL_TOPOLOGY_BUDGET);
     if (lines.length > 0 && topologyLines.length > 0)
         lines.push('');
     lines.push(...topologyLines);
+    if (lines.length > 0 && globalLines.length > 0)
+        lines.push('');
+    lines.push(...globalLines);
     return lines;
 }
 export function buildReferenceContext(memoryLines) {

package/scripts/hooks/_shared.js

@@ -34,7 +34,7 @@ import {
   slugFromRemoteUrl,
 } from './_generated/core-paths.js';
 import { autoCaptureDecision } from './_generated/capture-flag.js';
-export { assembleTopologyBlock, buildReferenceContext, extractCitedMemoryIds, DEFAULT_TOPOLOGY_BUDGET, SNIPPET_FETCH_CHARS, TOPOLOGY_CANDIDATE_CAP } from './_generated/work-topology.js';
+export { assembleTopologyBlock, buildReferenceContext, extractCitedMemoryIds, DEFAULT_TOPOLOGY_BUDGET, GLOBAL_TOPOLOGY_LIMIT, SNIPPET_FETCH_CHARS, TOPOLOGY_CANDIDATE_CAP } from './_generated/work-topology.js';
 export { readRepoState, repoStateLines } from './_generated/repo-state.js';
 export { matchingGuards, guardFromMetadata } from './_generated/guards.js';
 export { writeCitationRule, citationRulePath, CITATION_RULE_BODY } from './_generated/citation-rule.js';
@@ -585,6 +585,11 @@ export function captureEntity(db, { name, type, observations = [], tags = [], ti
   // retried, because the callers dedupe on the entity NAME existing —
   // `INSERT OR IGNORE` reports "already there" on the next run and the
   // half-written state is permanent.
+  //
+  // Returns `{ id, isNew, observationsWritten }`, or null when the entity row
+  // could not be resolved. `observationsWritten` may be lower than
+  // `observations.length`: an observation whose exact content is already on
+  // the entity is not stored again (see the dedupe in captureEntityInner).
   return db.transaction(() => captureEntityInner(db, { name, type, observations, tags, title, metadata }))();
 }
 
@@ -655,8 +660,47 @@ function captureEntityInner(db, { name, type, observations, tags, title, metadat
   // BY + the one join rule), via the generated fts-index copy.
   const prevObsText = isNew ? undefined : indexedObservationText(db, id);
 
+  // Never store the same sentence twice on one entity (#240, widened).
+  //
+  // #240 was fixed in session-summary.js alone, with an EXISTENCE guard: "if
+  // this session already has an entity, bail". Its two siblings never got one
+  // and wrote 2,202 duplicate rows on the maintainer's graph —
+  // `pre-compact-<sessionId>` 2,188 of them (worst entity: 220 observations,
+  // 2 distinct), `commit-<sha>` 14.
+  //
+  // The guard belongs HERE, on CONTENT, not there, on existence, because a
+  // pre-compact entity is per-session and a session legitimately compacts
+  // more than once: entity 1947's 110 captures span four days. An existence
+  // guard would have dropped a second, genuinely different compaction
+  // ("Tool calls: 47", "Files edited: …") along with the identical ones. A
+  // content guard drops only rows that add nothing — a re-write of a sentence
+  // already stored carries no information, whatever produced it.
+  //
+  // Unconditional rather than opt-in: every caller of this function is an
+  // auto-capture hook writing machine-derived facts, and none of them has a
+  // case where re-storing an identical string means something. A flag two of
+  // three callers pass would be one more proxy for the question.
+  //
+  // Filtered ONCE, up front, because `allObsText` below composes the FTS text
+  // from this list rather than re-reading the rows. Filtering only at the
+  // insert loop would index text for rows that do not exist, and
+  // `entities_fts` is contentless: the next delete would not match, which is
+  // the "database disk image is malformed" failure this file warns about
+  // above. The `seen` set also collapses repeats WITHIN one call.
+  const seen = new Set(
+    isNew
+      ? []
+      : db.prepare('SELECT content FROM observations WHERE entity_id = ?').all(id).map((r) => r.content),
+  );
+  const freshObservations = [];
+  for (const obs of observations) {
+    if (seen.has(obs)) continue;
+    seen.add(obs);
+    freshObservations.push(obs);
+  }
+
   const insertObs = db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)');
-  for (const obs of observations) insertObs.run(id, obs);
+  for (const obs of freshObservations) insertObs.run(id, obs);
   const insertTag = db.prepare('INSERT OR IGNORE INTO tags (entity_id, tag) VALUES (?, ?)');
   for (const tag of tags) insertTag.run(id, tag);
 
@@ -673,7 +717,7 @@ function captureEntityInner(db, { name, type, observations, tags, title, metadat
   // upserted entity's accumulated observation count.
   const obsParts = [];
   if (prevObsText) obsParts.push(prevObsText);
-  if (observations.length) obsParts.push(joinIndexedObservations(observations));
+  if (freshObservations.length) obsParts.push(joinIndexedObservations(freshObservations));
   const allObsText = joinIndexedObservations(obsParts);
   // Current title is fully determined by the branches above — no re-read.
   const currentTitle = isNew
@@ -681,7 +725,11 @@ function captureEntityInner(db, { name, type, observations, tags, title, metadat
     : ((title !== undefined && title !== previousTitle) ? title : previousTitle);
   insertFtsRow(db, id, name, allObsText, currentTitle);
 
-  return { id, isNew };
+  // `observationsWritten` is what actually landed, which is no longer the same
+  // as `observations.length` once the dedupe above can drop rows. A caller
+  // that reports a count to the user must read this one — pre-compact.js
+  // printed "Saved 2 observations" on a run that stored none.
+  return { id, isNew, observationsWritten: freshObservations.length };
 }
 
 const PRIVATE_DIR_MODE = 0o700;

package/scripts/hooks/decision-nudge.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// Decision Nudge — PostToolUse hook for ExitPlanMode and AskUserQuestion (#277).
+//
+// MeMesh's read side is automatic (SessionStart, PreToolUse Edit/Write inject
+// memories), but the write side had no in-flow trigger: an agent could make
+// several decisions in a session and store none of them until the user said
+// "remember this". `ExitPlanMode` (a plan just got approved) and
+// `AskUserQuestion` (the user just chose between options) are the two tool
+// calls where a decision is most likely to have just been made, so this hook
+// fires there and reminds the model — once per tool per session — to use
+// `remember` if the decision is worth keeping.
+//
+// Contract, in order of importance:
+//   1. NEVER block or slow the tool call: every failure path is a silent
+//      pass (with a stderr trace for anything that looks like schema
+//      drift), and this hook only ever emits additionalContext — exit code
+//      stays 0 no matter what.
+//   2. NEVER open the database. Unlike the capture hooks (post-commit,
+//      session-summary, pre-compact), this hook writes nothing to MeMesh
+//      itself — it only reminds the model to. Nothing here needs a
+//      knowledge-graph handle, so nothing opens one; that keeps the hook
+//      fast (well under its 5s budget) and removes an entire class of
+//      failure (lock contention, migration, corrupt schema) from a hook
+//      whose only job is a one-line reminder.
+//   3. Rate-limited to at most once per tool per session, or a plan-heavy
+//      session would see the same line after every ExitPlanMode call. A
+//      per-(session, tool) flag file under MEMESH_DIR is the mechanism —
+//      see claimNudge() for why, and why it is a NEW mechanism rather than
+//      a revived one.
+
+import { openSync, closeSync, writeSync, constants as fsConstants } from 'fs';
+import { join } from 'path';
+import { ensurePrivateDir, getMemeshDirFromDbPath } from './_shared.js';
+
+// The only two tools this hook is wired to in hooks/hooks.json — kept as an
+// explicit allowlist (not "any PostToolUse call") so a future matcher typo
+// or a Claude Code tool rename fails closed (no nudge) rather than nudging
+// on every tool call.
+const TARGET_TOOLS = new Set(['ExitPlanMode', 'AskUserQuestion']);
+
+// Real Claude Code session ids are UUIDs; test fixtures use short slugs like
+// `contract-8`. Restricting to this set is what makes the id safe to embed
+// directly in a filename below — anything that fails this (including a
+// missing/non-string id) exits quietly rather than touching the filesystem.
+const SESSION_ID_RE = /^[A-Za-z0-9_-]+$/;
+
+// Bounded stdin read. The real payload here (tool_name, tool_input,
+// session_id, cwd) is a few KB at most — ExitPlanMode's plan text is the
+// largest field — so 1 MiB is generous headroom, not a working limit. This
+// stops a malformed/runaway payload from growing an unbounded string before
+// JSON.parse ever runs.
+const MAX_STDIN_BYTES = 1_048_576;
+
+let input = '';
+let overflowed = false;
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  if (overflowed) return;
+  input += chunk;
+  if (input.length > MAX_STDIN_BYTES) overflowed = true;
+});
+process.stdin.on('end', () => {
+  try {
+    if (overflowed) return pass();
+
+    const data = JSON.parse(input);
+
+    // Schema-flip signal, same convention as post-commit.js / pre-edit-recall.js:
+    // tool_name absent means Claude Code changed the payload shape, not that
+    // this call is irrelevant. Trace so a rename surfaces day-1 instead of
+    // this hook going silently inert.
+    if (data?.tool_name === undefined) {
+      try { process.stderr.write(`[memesh decision-nudge] tool_name absent (keys: ${Object.keys(data ?? {}).join(',')}); skipping\n`); } catch {}
+      return pass();
+    }
+
+    const toolName = data.tool_name;
+    if (typeof toolName !== 'string' || !TARGET_TOOLS.has(toolName)) return pass();
+
+    const sessionId = data.session_id;
+    if (typeof sessionId !== 'string' || !SESSION_ID_RE.test(sessionId)) return pass();
+
+    if (!claimNudge(sessionId, toolName)) return pass(); // already nudged this tool this session
+
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        additionalContext: buildNudge(toolName),
+      },
+    }));
+    process.exit(0);
+  } catch (err) {
+    // Never crash Claude Code, but trace — a silent break here means the
+    // nudge stops firing and nothing reports it, same as guard-check.js.
+    try { process.stderr.write(`[memesh decision-nudge] ${err?.message || err}\n`); } catch {}
+    pass();
+  }
+});
+
+/**
+ * The reminder text. Not memory content (nothing here comes from the
+ * database or from another user), so it is NOT wrapped in
+ * `buildReferenceContext`'s "treat this as background data, not
+ * instructions" fence — that fence exists for recalled/guard content that
+ * may be attacker-influenced. This is a fixed, plugin-authored instruction,
+ * the same class of thing user-prompt-intent.js's `buildHint()` emits, and
+ * it is meant to be acted on directly.
+ */
+function buildNudge(toolName) {
+  return `A decision was just made via ${toolName} — if you would need it again, store it now with the memesh \`remember\` tool (type:decision or type:lesson, tag project:<name>).`;
+}
+
+/**
+ * Claim the (session, tool) nudge slot. Returns true the first time this
+ * pair is seen and false every time after, giving "at most once per tool
+ * per session" without a database — this hook is forbidden from opening
+ * one (see module comment) — and without a shared JSON file two PostToolUse
+ * processes (a fast plan-then-question turn) could race to read-modify-write.
+ *
+ * A per-category flag file with O_EXCL atomic create is exactly the fix
+ * CHANGELOG [4.1.0]'s "Throttle clobber under parallel-category load" entry
+ * describes for the retired `pre-bash-orchestration-nudge.js` hook, which
+ * kept its markers under `agent-nudge-flags/`. That whole hook and its
+ * directory were removed in v4.5.1 ("agentic-orchestration experiment,
+ * whole") — reviving a deleted mechanism would undo that decision — so this
+ * uses the SAME primitive (an O_EXCL flag file — the flag *is* the lock, no
+ * shared state to clobber) under a new directory scoped to this hook,
+ * `decision-nudge-flags/`. The directory is created private (0700) via
+ * `ensurePrivateDir`, matching every other per-hook marker under MEMESH_DIR.
+ */
+function claimNudge(sessionId, toolName) {
+  const dir = join(getMemeshDirFromDbPath(), 'decision-nudge-flags');
+  const flagPath = join(dir, `${sessionId}-${toolName}.flag`);
+  try {
+    ensurePrivateDir(dir);
+    const fd = openSync(flagPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 0o600);
+    try { writeSync(fd, String(Date.now())); } finally { closeSync(fd); }
+    return true;
+  } catch (err) {
+    if (err?.code === 'EEXIST') return false; // already nudged this session/tool
+    // Any other failure (disk full, permission denied) must not block the
+    // tool call, and the safe default for a hint is silence rather than a
+    // duplicate-nudge storm — so this counts as "already claimed".
+    try { process.stderr.write(`[memesh decision-nudge] could not claim ${flagPath}: ${err?.message || err}\n`); } catch {}
+    return false;
+  }
+}
+
+function pass() {
+  process.exit(0);
+}

package/scripts/hooks/post-commit.js

@@ -168,6 +168,17 @@ process.stdin.on('end', () => {
       // TYPE, which a hand-typed `memesh learn` satisfied all by itself.
       // The commit subject IS the title — git authors already wrote a
       // one-line human summary; nothing to synthesize.
+      //
+      // Re-capture of an already-stored commit is expected and harmless: this
+      // hook runs on PostToolUse, so any later Bash call while HEAD is
+      // unchanged rebuilds the same `commit-<sha>` payload. It used to APPEND
+      // it — three commit entities on the maintainer's graph reached 6
+      // observations / 3 distinct, one triple re-written 107 seconds after the
+      // first. captureEntity now refuses to store an observation whose exact
+      // content is already on the entity (#240, widened), which is the right
+      // guard here rather than "skip if the entity exists": a sha is immutable,
+      // so any line that DOES differ on a later run (diff stats that failed the
+      // first time and succeeded now) is new information and must still land.
       const written = captureEntity(db, {
         name: entityName,
         type: 'commit',

package/scripts/hooks/pre-compact.js

@@ -159,12 +159,20 @@ process.stdin.on('end', () => {
     // it announced a save that may not have happened, with a number that never
     // matched the one entity and handful of observations actually written.
     //
-    // `obsLines.length` is the honest count on the success branch:
-    // `captureEntity` inserts every observation or throws, so a non-null return
-    // means all of them landed.
+    // `written.observationsWritten` is the honest count, NOT `obsLines.length`:
+    // a session compacts more than once, and the second compaction's lines are
+    // usually word-for-word the first's ("Compaction reason: auto", "Tool
+    // calls: 0"), which captureEntity now declines to store twice. Reporting
+    // the built count would announce "Saved 2 observations" on a run that
+    // stored none — the same success-shaped lie this comment block exists to
+    // stop. Zero written is still a successful run: the memory is already
+    // there.
+    const stored = written ? written.observationsWritten : 0;
     const hookOutput = {
       systemMessage: written
-        ? `Saved ${obsLines.length} observations to MeMesh before compaction`
+        ? (stored > 0
+          ? `Saved ${stored} observations to MeMesh before compaction`
+          : 'MeMesh: this compaction added nothing new (already captured)')
         : 'MeMesh: could not save pre-compaction insights (see stderr)',
     };
     console.log(JSON.stringify(hookOutput));

package/scripts/hooks/session-start.js

@@ -15,6 +15,7 @@ import {
   importFromPluginRoot,
   assembleTopologyBlock,
   DEFAULT_TOPOLOGY_BUDGET,
+  GLOBAL_TOPOLOGY_LIMIT,
   SNIPPET_FETCH_CHARS,
   TOPOLOGY_CANDIDATE_CAP,
   isTrustedForAutoContext,
@@ -333,11 +334,24 @@ function detectInstallChannelHook(pluginRoot) {
  * Claude Code wording rather than suppressing the hint entirely — the
  * banner is more useful naming the majority host than naming none.
  */
+/**
+ * Which plugin host is this install under — or `'unknown'` when we could not
+ * ask.
+ *
+ * `null` is a real answer from `detectPluginHost`: "this path is not under any
+ * plugin cache". So `detectPluginHost?.(root) ?? null` inside a bare catch,
+ * which is what this was, gave a module that failed to load and a detector
+ * that threw the SAME value as a confident "not Codex" — and
+ * `pluginUpgradeLine` then handed every Codex user the Claude Code command.
+ * `getCurrentInstallChannel` above already returns `'unknown'` for exactly
+ * this state; this now matches it.
+ */
 function pluginHostOf(pluginRoot) {
+  if (typeof _installChannelMod?.detectPluginHost !== 'function') return 'unknown';
   try {
-    return _installChannelMod?.detectPluginHost?.(pluginRoot) ?? null;
+    return _installChannelMod.detectPluginHost(pluginRoot);
   } catch {
-    return null;
+    return 'unknown';
   }
 }
 
@@ -353,9 +367,17 @@ function pluginHostOf(pluginRoot) {
  * happened. One owner, so it cannot happen again.
  */
 function pluginUpgradeLine(pluginRoot) {
-  if (pluginHostOf(pluginRoot) === 'codex') {
+  const host = pluginHostOf(pluginRoot);
+  if (host === 'codex') {
     return `    Run: codex plugin marketplace upgrade pcircle-memesh && codex plugin add memesh@pcircle-memesh`;
   }
+  if (host === 'unknown') {
+    // Naming one host's command here would be a guess presented as an
+    // instruction. Rare — it needs `dist/core/install-channel.js` to be
+    // missing or unloadable — but that is a broken install, which is exactly
+    // when wrong upgrade advice costs the most.
+    return `    Run: memesh upgrade-plugin   (on Codex: codex plugin marketplace upgrade pcircle-memesh && codex plugin add memesh@pcircle-memesh)`;
+  }
   return `    Run: memesh upgrade-plugin   (no CLI? npx @pcircle/memesh upgrade-plugin — or reinstall from /plugin UI)`;
 }
 
@@ -786,9 +808,12 @@ process.stdin.on('end', async () => {
       };
 
       const projectTag = `project:${projectName}`;
+      const notGlobal = colNames.has('namespace')
+        ? "AND (e.namespace IS NULL OR e.namespace <> 'global')"
+        : '';
       const projectQuery = buildScoringQuery(
         `JOIN tags t ON t.entity_id = e.id`,
-        `WHERE t.tag = ? ${statusFilter}`,
+        `WHERE t.tag = ? ${notGlobal} ${statusFilter}`,
       );
       // Over-fetch WIDE, then filter. The window used to be `sessionLimit * 3`
       // and the trust filter ran after it — so a class of entity that ranks
@@ -811,26 +836,27 @@ process.stdin.on('end', async () => {
       // by nobody (#242): 1814 entities, 2 global, one of them structurally
       // uninjectable. A standing behaviour rule sat in that state for months.
       //
-      // Global rows ride in a SEPARATE, small window so they cannot displace
-      // the project's own memories: the project keeps `sessionLimit` slots and
-      // global adds at most GLOBAL_SLOTS after them. Same trust filter, same
-      // scoring. The column is absent on pre-namespace schemas; then this
-      // branch is simply empty, which is the old behaviour.
-      const GLOBAL_SLOTS = 3;
+      // Global rows ride in a SEPARATE, small window and the shared assembler
+      // gives them a separate render budget. The project keeps `sessionLimit`
+      // slots and its full character budget. The column is absent on
+      // pre-namespace schemas; then this branch is simply empty.
       let globalEntities = [];
       if (colNames.has('namespace')) {
         const globalQuery = buildScoringQuery('', `WHERE e.namespace = 'global' ${statusFilter}`);
-        const projectIds = new Set(projectOnly.map(e => e.id));
         globalEntities = db.prepare(globalQuery).all(CANDIDATE_CAP)
-          .filter(entity => isTrustedForAutoContext(entity.metadata) && !projectIds.has(entity.id))
-          .slice(0, GLOBAL_SLOTS);
+          .filter(entity => isTrustedForAutoContext(entity.metadata))
+          .slice(0, GLOBAL_TOPOLOGY_LIMIT);
       }
-      const projectEntities = [...projectOnly.slice(0, sessionLimit), ...globalEntities];
+      const projectEntities = projectOnly.slice(0, sessionLimit);
 
       // recentStatusFilter is "WHERE status = 'active'" or "" — the bare-column
       // form is fine when there's no JOIN, but we now alias the table as `e`,
       // so rewrite to e.status for consistency.
-      const recentWhere = hasStatus ? "WHERE e.status = 'active'" : '';
+      const recentConditions = [
+        hasStatus ? "e.status = 'active'" : '',
+        colNames.has('namespace') ? "(e.namespace IS NULL OR e.namespace <> 'global')" : '',
+      ].filter(Boolean);
+      const recentWhere = recentConditions.length > 0 ? `WHERE ${recentConditions.join(' AND ')}` : '';
       const recentQuery = buildScoringQuery('', recentWhere);
       const recentEntities = db.prepare(recentQuery).all(CANDIDATE_CAP)
         .filter(entity => isTrustedForAutoContext(entity.metadata))
@@ -850,6 +876,7 @@ process.stdin.on('end', async () => {
           JOIN tags t ON t.entity_id = e.id
           WHERE e.type = 'lesson_learned'
             ${hasStatus ? "AND e.status = 'active'" : ''}
+            ${colNames.has('namespace') ? "AND (e.namespace IS NULL OR e.namespace <> 'global')" : ''}
             AND t.tag = ?
           LIMIT 50
         `).all(projectTag).filter(entity => isTrustedForAutoContext(entity.metadata));
@@ -866,9 +893,11 @@ process.stdin.on('end', async () => {
       // SessionStart system message takes one row in the Claude Code
       // log instead of four. Counts are count-only — no entity bullets.
       const projectCount = projectEntities.length;
+      const globalCount = globalEntities.length;
       const recentCount = recentEntities.length;
       const memoryFragments = [];
       if (projectCount > 0) memoryFragments.push(`${projectCount} project`);
+      if (globalCount > 0) memoryFragments.push(`${globalCount} global`);
       if (recentCount > 0) memoryFragments.push(`${recentCount} recent`);
 
       let summary;
@@ -915,6 +944,7 @@ process.stdin.on('end', async () => {
         const rankedIds = [
           ...topLessons.map(e => e.id),
           ...projectEntities.map(e => e.id),
+          ...globalEntities.map(e => e.id),
           ...recentEntities.map(e => e.id),
         ];
         const uniqueIds = [...new Set(rankedIds)];
@@ -955,8 +985,8 @@ process.stdin.on('end', async () => {
         const taskRow = db
           .prepare('SELECT metadata FROM entities WHERE name = ?')
           .get(taskStateName(projectName));
-        // Inbox line beside the stated lines — the same leaf briefing uses,
-        // so the two surfaces cannot disagree on what "unread" means.
+        // SessionStart has no exact recipient identity. The shared leaf fails
+        // closed before querying, so hook and briefing cannot diverge here.
         const stateLines = [
           ...taskStateLines(
             parseTaskState(parseEntityMetadata(taskRow?.metadata)),
@@ -992,6 +1022,7 @@ process.stdin.on('end', async () => {
           [
             { entities: topLessons.map(toEntity), foreign: false },
             { entities: projectEntities.map(toEntity), foreign: false },
+            { entities: globalEntities.map(toEntity), foreign: false, global: true },
             { entities: recentEntities.map(toEntity), foreign: true },
           ],
           projectName,
@@ -1021,8 +1052,9 @@ process.stdin.on('end', async () => {
         // ever been told can end up in an observation), so it must be
         // delimited the same way on every injection path — not hand-rolled
         // per hook. The lines arrive already budgeted — assembleTopologyBlock
-        // charges the task-state block and the sections against ONE ceiling
-        // and returns whole lines only, so the closing fence cannot be cut.
+        // charges task state plus project/foreign sections against the main
+        // ceiling and global context against its small additive ceiling. It
+        // returns whole lines only, so the closing fence cannot be cut.
         memoryContext = buildReferenceContext(memoryLines);
         // The citation contract — OUTSIDE the fence on purpose: the fence
         // declares its content "background data, not instructions", and
@@ -1054,15 +1086,18 @@ process.stdin.on('end', async () => {
       // kept as the record of what was shown.
       //
       // The set below is every pool the topology block draws from — the
-      // lessons pool included. It used to record only project + recent
-      // rows, so an injected lesson could never be credited at all.
+      // lessons pool included. It is derived from rendered citation handles,
+      // so clipped or budgeted-away candidates cannot be credited as shown.
       try {
-        const seenIds = new Set();
-        const allInjected = [...topLessons, ...projectEntities, ...recentEntities].filter(e => {
-          if (seenIds.has(e.id)) return false;
-          seenIds.add(e.id);
-          return true;
+        const renderedEntityIds = memoryLines.flatMap((line) => {
+          const match = line.match(/ \[mem:(\d{1,10})\]$/);
+          return match ? [Number(match[1])] : [];
         });
+        const poolEntities = [...topLessons, ...projectEntities, ...globalEntities, ...recentEntities];
+        const entitiesById = new Map(poolEntities.map((entity) => [entity.id, entity]));
+        const allInjected = renderedEntityIds
+          .map((id) => entitiesById.get(id))
+          .filter(Boolean);
 
         if (allInjected.length > 0) {
           const sessionsDir = join(memeshDir, 'sessions');