@pcircle/memesh 4.8.1 → 4.8.3

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,
@@ -36,6 +37,7 @@ import {
   writePrivateJson,
 } from './_shared.js';
 import { MemeshDatabase } from './_generated/sqlite.js';
+import { unreadDeliveryCount, unreadInboxLines } from './_generated/agent-message-inbox.js';
 
 const require = createRequire(import.meta.url);
 
@@ -785,9 +787,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
@@ -801,14 +806,36 @@ process.stdin.on('end', async () => {
       // Shared with the briefing surface via the leaf, so the two sides'
       // candidate windows cannot drift apart.
       const CANDIDATE_CAP = TOPOLOGY_CANDIDATE_CAP;
-      const projectEntities = db.prepare(projectQuery).all(projectTag, CANDIDATE_CAP)
-        .filter(entity => isTrustedForAutoContext(entity.metadata))
-        .slice(0, sessionLimit);
+      const projectOnly = db.prepare(projectQuery).all(projectTag, CANDIDATE_CAP)
+        .filter(entity => isTrustedForAutoContext(entity.metadata));
+
+      // The `global` namespace is the documented way to store something that
+      // is not tied to one project — and the injection selected purely by
+      // `project:` tag, so a global memory with no project tag was reachable
+      // 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 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}`);
+        globalEntities = db.prepare(globalQuery).all(CANDIDATE_CAP)
+          .filter(entity => isTrustedForAutoContext(entity.metadata))
+          .slice(0, GLOBAL_TOPOLOGY_LIMIT);
+      }
+      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))
@@ -828,6 +855,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));
@@ -844,9 +872,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;
@@ -893,6 +923,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)];
@@ -933,10 +964,15 @@ process.stdin.on('end', async () => {
         const taskRow = db
           .prepare('SELECT metadata FROM entities WHERE name = ?')
           .get(taskStateName(projectName));
-        const stateLines = taskStateLines(
-          parseTaskState(parseEntityMetadata(taskRow?.metadata)),
-          projectName,
-        );
+        // 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)),
+            projectName,
+          ),
+          ...unreadInboxLines(unreadDeliveryCount(db, projectName), projectName),
+        ];
 
         // The pools overlap by construction (a lesson tagged to this project
         // is in lessonEntities AND projectEntities); the shared assembler
@@ -965,6 +1001,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,
@@ -994,8 +1031,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
@@ -1027,15 +1065,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');

package/scripts/hooks/session-summary.js

@@ -87,6 +87,30 @@ async function runAutoUpdateAtStop() {
 // Handles the current Claude Code transcript format where tool_use/tool_result
 // are nested inside assistant/user message entries, not top-level entries.
 // Defensive: never throws — malformed lines are silently skipped.
+/**
+ * File paths a shell command writes in place. Recognises the shapes an
+ * agent actually uses to edit without Write/Edit: heredoc redirection
+ * (`> path <<'EOF'`, `cat > path`), `sed -i`, `tee`, and `pathlib.Path('x')
+ * .write_text(` / `fs.writeFileSync('x'` inside an inline script. Returns
+ * basenames' sources; the caller keeps basename() as the stored form.
+ */
+function bashEditedPaths(cmd) {
+  if (typeof cmd !== 'string') return [];
+  const found = new Set();
+  const add = (m) => { if (m && m[1] && !m[1].startsWith('/dev/') && !m[1].startsWith('/tmp/')) found.add(m[1]); };
+  for (const re of [
+    /(?:^|[^<])>\s*"?([^\s"'>|&;]+)"?\s*<<\s*['"]?\w+['"]?/g,   // > file <<'EOF'
+    /\bcat\s*>\s*"?([^\s"'>|&;]+)"?/g,                            // cat > file
+    /\btee\s+(?:-a\s+)?"?([^\s"'>|&;]+)"?/g,                      // tee file
+    /\bsed\s+-i(?:\s+'')?\s+(?:'[^']*'|"[^"]*")\s+"?([^\s"'>|&;]+)"?/g, // sed -i '...' file
+    /Path\(\s*['"]([^'"]+)['"]\s*\)\s*\.write_text\(/g,           // pathlib write_text
+    /writeFileSync\(\s*['"]([^'"]+)['"]/g,                        // fs.writeFileSync
+  ]) {
+    let m; while ((m = re.exec(cmd)) !== null) add(m);
+  }
+  return [...found];
+}
+
 function parseTranscript(transcriptPath) {
   const filesEdited = new Set();
   const bashCommands = [];
@@ -118,6 +142,15 @@ function parseTranscript(transcriptPath) {
             }
             if (block.name === 'Bash') {
               const cmd = block.input?.command ?? '';
+              // A session that edits through Bash — heredocs, sed -i, a
+              // short python script — never produces a Write/Edit block, so
+              // `filesEdited` stayed empty and the summary asserted "0 files
+              // edited" for a session that edited a dozen. The count also
+              // drives the re-capture guard below, so the same gap made the
+              // -summary entity re-append on every Stop (#240). Recognise the
+              // common in-place write shapes; anything not matched is simply
+              // uncounted, which is honest — it is not asserted as zero.
+              for (const fp of bashEditedPaths(cmd)) filesEdited.add(basename(fp));
               if (typeof cmd === 'string' && cmd.length > 10 && !cmd.startsWith('ls') && !cmd.startsWith('cd')) {
                 // Redact BEFORE truncating. A bash command line is the single
                 // most likely place a credential appears in a transcript
@@ -347,7 +380,13 @@ process.stdin.on('end', async () => {
       // A dedup bail is a SUCCESSFUL run — the loop executed and correctly
       // decided there was nothing to do — so it stamps the heartbeat like
       // the capture path below does. Only a throw leaves no stamp.
-      const alreadyCaptured = db.prepare("SELECT id FROM entities WHERE name = ?").get(`session-${sessionId}-files`);
+      // Guard on ANY of this session's three entities, not only `-files`.
+      // A Bash-only session created no `-files` row, so the guard never
+      // tripped and `-summary` was re-appended on every Stop — measured: 56
+      // observations, 16 unique, three commands stored fourteen times each.
+      const alreadyCaptured = db.prepare(
+        "SELECT id FROM entities WHERE name IN (?, ?, ?) LIMIT 1",
+      ).get(`session-${sessionId}-files`, `session-${sessionId}-fixes`, `session-${sessionId}-summary`);
       if (alreadyCaptured) {
         recordHookRun(db, 'session-summary');
         return exit0();