brainclaw 1.25.0 → 1.26.0

package/dist/core/context-diff.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { readAuditLog } from './audit.js';
 import { listCandidates } from './candidates.js';
-import { entityRecordPaths } from './io.js';
+import { sessionSnapshotRecordPaths } from './io.js';
 import { loadVersionedJsonFile } from './migration.js';
 import { buildNotificationSummary, hasEventCursor, readUnseenEvents, seedCursorToEnd } from './event-log.js';
 import { SessionSnapshotSchema } from './schema.js';
@@ -44,11 +44,25 @@ export function resolveContextDiffSince(options) {
  * Uses the shared primitive rather than a fourth hand-rolled pair of paths (io.ts).
  */
 function loadSessionSnapshot(sessionId, cwd) {
-    for (const snapshotPath of entityRecordPaths('sessions', sessionId, cwd ?? process.cwd())) {
+    // pln#670 — snapshots carry a type-suffixed name (`<id>.snapshot.json`);
+    // the helper also probes the pre-split `<id>.json` layouts.
+    for (const snapshotPath of sessionSnapshotRecordPaths(sessionId, cwd ?? process.cwd())) {
         if (!fs.existsSync(snapshotPath))
             continue;
         try {
-            return SessionSnapshotSchema.parse(loadVersionedJsonFile('session_snapshot', snapshotPath).document);
+            // Deliberately NOT type-strict (pln#649 + pln#670): this reader answers
+            // "when did session X start" to anchor the diff window, and a
+            // current_session record for the same id is an equally authoritative
+            // source of `started_at`. The suffixed probes come first, so a real
+            // snapshot (richer: context_target, git_sha) still wins when both exist.
+            // Contrast with session-start's loadSessionSnapshot, which must stay
+            // strict — its consumers treat the record as a genuine snapshot.
+            const snapshot = SessionSnapshotSchema.parse(loadVersionedJsonFile('session_snapshot', snapshotPath).document);
+            // A suffix-bearing lookup can construct another snapshot's path (codex
+            // review). Its started_at is useful only when the stored identity matches.
+            if (snapshot.session_id !== sessionId)
+                continue;
+            return snapshot;
         }
         catch {
             // An unparseable record in one layout must not mask a good one in the other.

package/dist/core/entity-operations.js

@@ -28,7 +28,7 @@ import { deleteAssignment, listAssignments, loadAssignment, saveAssignment, tran
 import { listAgentRuns } from './agentruns.js';
 import { reconcileAgentRun, reconcileDeadPidRunningAgentRunAtRead, reconcileStrandedFailureClaimAtRead, TERMINAL_STATUSES } from './agentrun-reconciler.js';
 import { isObserverMode } from './observer-mode.js';
-import { deleteRuntimeNote, listRuntimeNotes, saveRuntimeNote, } from './runtime.js';
+import { deleteRuntimeNote, listRuntimeNotes, parkRuntimeNoteBackup, saveRuntimeNote, } from './runtime.js';
 import { createSequence, deleteSequence, listSequences, updateSequence, } from './sequence.js';
 import { createConstraint, createDecision, createTrap, } from './operations/memory-write.js';
 import { deleteMemoryItem, findMemoryItemInChain, updateMemoryItem, } from './operations/memory-mutation.js';
@@ -853,10 +853,22 @@ export function removeEntity(name, id, cwd, purge = false) {
             const note = notes.find((n) => n.id === id);
             if (!note)
                 throw new EntityNotFoundError(name, id);
+            // trp_dc9ca61e — the tool contract says "archives by default", but this
+            // path hard-deleted regardless of `purge` (runtime_note has no lifecycle,
+            // so there was no soft state to land in). Default remove now parks the
+            // raw record under gc-backups — the same net the retention sweeps use —
+            // and fails CLOSED when the park is impossible: silently downgrading an
+            // archive into a hard-delete is the defect being fixed.
+            if (!purge) {
+                const backupPath = parkRuntimeNoteBackup(note, cwd);
+                if (!backupPath) {
+                    throw new Error(`runtime_note '${id}' could not be archived to gc-backups; pass purge:true to hard-delete`);
+                }
+            }
             const ok = deleteRuntimeNote(note, cwd);
             if (!ok)
                 throw new EntityNotFoundError(name, id);
-            return { entity: name, id, archived: false, purged: true };
+            return { entity: name, id, archived: !purge, purged: purge };
         }
         case 'candidate': {
             // Remove = archive to rejected. `purge` would delete the file; not exposed yet.

package/dist/core/hint-aging.js

@@ -123,7 +123,10 @@ export function ageStaleWarnings(warnings, cwd, options = {}) {
             const overflow = ids.length - shown.length;
             return `${ids.length} ${entity}${ids.length === 1 ? '' : 's'}: ${shown.join(', ')}${overflow > 0 ? ` +${overflow} more` : ''}`;
         });
-        aggregate = `${folded.length} stale item${folded.length === 1 ? '' : 's'} you've already been offered (${parts.join('; ')}) — bclaw_get each id to review, or bclaw_transition to retire.`;
+        // trp_dc9ca61e — do not recommend bclaw_transition for runtime_notes: they
+        // have no lifecycle and the call errors. bclaw_remove (archive by default)
+        // is their retirement path.
+        aggregate = `${folded.length} stale item${folded.length === 1 ? '' : 's'} you've already been offered (${parts.join('; ')}) — bclaw_get each id to review; retire with bclaw_transition, or bclaw_remove for runtime_notes (no lifecycle).`;
     }
     return { warnings: detail, aggregate, served_ids, folded_ids };
 }

package/dist/core/identity.js

@@ -6,7 +6,7 @@ import { detectAiAgent } from './ai-agent-detection.js';
 import { requireRegisteredAgentIdentity } from './agent-registry.js';
 import { loadConfig } from './config.js';
 import { resolveCurrentHostId } from './host.js';
-import { memoryDir } from './io.js';
+import { isSessionSnapshotRecordFilename, memoryDir } from './io.js';
 import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
 import { CurrentSessionStateSchema } from './schema.js';
 const SESSIONS_DIR = 'sessions';
@@ -87,7 +87,7 @@ export function loadCurrentSession(cwd) {
     // Multiple parallel agents can have the same agent name/user in one repo;
     // a live different PID is a different agent instance, not our session.
     if (fs.existsSync(dir) && currentAgent) {
-        const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+        const files = listCurrentSessionFiles(dir);
         const legacyPidlessCandidates = [];
         for (const file of files) {
             try {
@@ -133,15 +133,25 @@ export function loadCurrentSession(cwd) {
  * Load a specific session by ID.
  */
 export function loadSessionById(sessionId, cwd) {
-    const filepath = sessionFilePath(sessionId, cwd);
+    let filepath;
+    try {
+        filepath = sessionFilePath(sessionId, cwd);
+    }
+    catch {
+        // Reserved '.snapshot' alias id — such a current_session record can never exist.
+        return undefined;
+    }
     if (!fs.existsSync(filepath))
         return undefined;
     try {
         const migration = loadVersionedJsonFile('current_session', filepath);
-        return {
+        const session = {
             ...CurrentSessionStateSchema.parse(migration.document),
             schema_version: migration.metadata.currentVersion,
         };
+        // The filename is only an index, never an identity (codex review): do not
+        // adopt a record whose payload names a different session.
+        return session.session_id === sessionId ? session : undefined;
     }
     catch {
         return undefined;
@@ -154,7 +164,7 @@ export function loadAllSessions(cwd) {
     const dir = sessionsDir(cwd);
     if (!fs.existsSync(dir))
         return [];
-    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const files = listCurrentSessionFiles(dir);
     const sessions = [];
     for (const file of files) {
         try {
@@ -178,7 +188,15 @@ export function saveCurrentSession(session, cwd) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
+    // sessionFilePath throws on a '.snapshot' alias id — a write must never
+    // construct a snapshot filename (codex review P1).
     const filepath = sessionFilePath(session.session_id, cwd);
+    // A plain legacy `<id>.json` can still hold a pre-split snapshot (the old
+    // 'read'-mode write bug parked snapshots in this directory). Only overwrite
+    // a record that PROVES it is this exact current_session entry (codex review).
+    if (fs.existsSync(filepath) && !loadSessionById(session.session_id, cwd)) {
+        throw new Error(`Refusing to overwrite non-current_session record at '${filepath}'`);
+    }
     saveVersionedJsonFile('current_session', filepath, CurrentSessionStateSchema.parse(session));
 }
 /**
@@ -186,10 +204,15 @@ export function saveCurrentSession(session, cwd) {
  */
 export function clearCurrentSession(cwd, sessionId) {
     if (sessionId) {
-        // Remove specific session file
-        const filepath = sessionFilePath(sessionId, cwd);
+        // Remove specific session file. A filename is never enough authority to
+        // delete a record (codex review P1): the '.snapshot' alias id throws in
+        // sessionFilePath (caught → no-op), and an existing file is only unlinked
+        // when loadSessionById PROVES it is this exact current_session record —
+        // never a pre-split snapshot parked under a plain `<id>.json`.
         try {
-            fs.unlinkSync(filepath);
+            if (loadSessionById(sessionId, cwd)) {
+                fs.unlinkSync(sessionFilePath(sessionId, cwd));
+            }
         }
         catch { /* ignore */ }
         return;
@@ -221,26 +244,30 @@ export function gcStaleSessions(cwd, ttlOverride) {
     const ttlMs = parseDurationToMs(ttlOverride ?? loadConfigSafe(cwd)?.implicit_session_ttl ?? '4h');
     const now = Date.now();
     let removed = 0;
-    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const files = listCurrentSessionFiles(dir);
     for (const file of files) {
+        const filepath = path.join(dir, file);
         try {
-            const migration = loadVersionedJsonFile('current_session', path.join(dir, file));
+            // POSITIVE proof before deletion (codex review): a bare `<id>.json` in
+            // this directory can still be a pre-split snapshot (old 'read'-mode
+            // write bug). Only a record carrying the current_session discriminant
+            // may be collected; anything unidentifiable is preserved, never deleted.
+            const raw = JSON.parse(fs.readFileSync(filepath, 'utf-8'));
+            if (typeof raw.last_seen_at !== 'string')
+                continue;
+            const migration = loadVersionedJsonFile('current_session', filepath);
             const session = {
                 ...CurrentSessionStateSchema.parse(migration.document),
                 schema_version: migration.metadata.currentVersion,
             };
             if (now - Date.parse(session.last_seen_at) > ttlMs) {
-                fs.unlinkSync(path.join(dir, file));
+                fs.unlinkSync(filepath);
                 removed++;
             }
         }
         catch {
-            // Remove unparseable files too
-            try {
-                fs.unlinkSync(path.join(dir, file));
-                removed++;
-            }
-            catch { /* ignore */ }
+            // An unidentifiable record is not proven stale current_session state —
+            // preserving it beats risking the deletion of a legacy snapshot.
         }
     }
     return removed;
@@ -249,7 +276,32 @@ export function gcStaleSessions(cwd, ttlOverride) {
 function sessionsDir(cwd) {
     return path.join(memoryDir(cwd), SESSIONS_DIR);
 }
+/**
+ * pln#670 — current_session scanners must be type-strict: session_snapshot
+ * records use the `<id>.snapshot.json` suffix and can share a directory with
+ * current_session records. Without this exclusion, gcStaleSessions would
+ * delete a stray snapshot as "unparseable" and loadCurrentSession could adopt
+ * one as a session candidate.
+ */
+function listCurrentSessionFiles(dir) {
+    // Case-insensitive on purpose (codex review P1): Windows filesystems match
+    // names case-insensitively, so `X.SNAPSHOT.json` IS the snapshot path a
+    // lower-case probe resolves — excluding only the exact-case suffix would let
+    // gcStaleSessions delete it as an unparseable current_session.
+    return fs.readdirSync(dir).filter(f => f.toLowerCase().endsWith('.json') && !isSessionSnapshotRecordFilename(f));
+}
+/** True when `<sessionId>.json` cannot collide with a session_snapshot filename. */
+function isCurrentSessionFilename(sessionId) {
+    return !isSessionSnapshotRecordFilename(`${sessionId}.json`);
+}
 function sessionFilePath(sessionId, cwd) {
+    // pln#670 review fix (codex P1): a session id ending in ".snapshot" would
+    // produce `<base>.snapshot.json` — the snapshot filename of session <base>
+    // in a shared directory. Refuse the alias instead of silently colliding
+    // across record types; readers treat the throw as "no such record".
+    if (!isCurrentSessionFilename(sessionId)) {
+        throw new Error(`session id '${sessionId}' is reserved for session_snapshot records — the '.snapshot' suffix would collide across record types`);
+    }
     return path.join(sessionsDir(cwd), `${sessionId}.json`);
 }
 function resolveCurrentUser() {

package/dist/core/io.js

@@ -121,6 +121,33 @@ export function entityRecordDirs(subdir, cwd = process.cwd(), preferredDirName)
 export function entityRecordPaths(subdir, id, cwd, preferredDirName) {
     return entityRecordDirs(subdir, cwd ?? process.cwd(), preferredDirName).map((d) => path.join(d, `${id}.json`));
 }
+export const SESSION_SNAPSHOT_FILENAME_SUFFIX = '.snapshot.json';
+/**
+ * Filesystem type discriminator for session snapshots (codex review, pln#670).
+ * Case-fold before the suffix comparison because default Windows filesystems
+ * are case-insensitive: `X.SNAPSHOT.json` IS the path a lower-case probe
+ * resolves, and every suffix decision must agree on its type.
+ */
+export function isSessionSnapshotRecordFilename(filename) {
+    return filename.toLowerCase().endsWith(SESSION_SNAPSHOT_FILENAME_SUFFIX);
+}
+/**
+ * EVERY path a session_snapshot record for `sessionId` can occupy, canonical first.
+ *
+ * session_snapshot and current_session are two different record types that share
+ * the `sessions` directory family AND the same session_id — only the filename keeps
+ * them apart (pln#670). Snapshots are written as `<id>.snapshot.json` so a
+ * current_session `<id>.json` for the same session can never clobber them, whatever
+ * directory each resolver picks. The plain `<id>.json` probes cover records written
+ * before the split; readers must schema-validate every candidate.
+ */
+export function sessionSnapshotRecordPaths(sessionId, cwd, preferredDirName) {
+    const dirs = entityRecordDirs('sessions', cwd ?? process.cwd(), preferredDirName);
+    return [
+        ...dirs.map((d) => path.join(d, `${sessionId}.snapshot.json`)),
+        ...dirs.map((d) => path.join(d, `${sessionId}.json`)),
+    ];
+}
 export function memoryDir(cwd = process.cwd(), preferredDirName) {
     return path.join(cwd, preferredDirName ?? MEMORY_DIR);
 }

package/dist/core/project-discovery.js

@@ -222,7 +222,13 @@ function discoverFiles(cwd, files, dirs) {
     }
     return results;
 }
-function isManagedByBrainclaw(filePath) {
+/**
+ * True when an instruction file was generated by `brainclaw export` (or carries
+ * a managed section marker). Exported for the bootstrap scan (pln#671): a
+ * managed export derives FROM brainclaw memory, so proposing it as a bootstrap
+ * import would feed brainclaw its own output back as new knowledge.
+ */
+export function isManagedByBrainclaw(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf-8').slice(0, 200);
         return content.includes('brainclaw') && (content.includes('Managed by brainclaw') ||

package/dist/core/runtime.js

@@ -68,6 +68,29 @@ export function runtimeNotePath(note, cwd) {
         ? path.join(sharedAgentDir(note.agent, cwd), `${note.id}.json`)
         : path.join(hostAgentDir(visibility, hostId, note.agent, cwd), `${note.id}.json`);
 }
+/**
+ * Park one runtime note's raw record under `.brainclaw/gc-backups/` — the same
+ * park-don't-delete net the retention sweeps use (trp_dc9ca61e). Daily-bucketed
+ * JSONL so removals do not explode into one file per note. Returns the backup
+ * path, or undefined when the source record cannot be read.
+ */
+export function parkRuntimeNoteBackup(note, cwd) {
+    try {
+        const sourcePath = runtimeNotePath(note, cwd);
+        const content = fs.readFileSync(sourcePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        parsed._removed_at = new Date().toISOString();
+        parsed._removal_type = 'bclaw_remove';
+        const day = new Date().toISOString().slice(0, 10);
+        const backupPath = path.join(cwd ?? process.cwd(), '.brainclaw', 'gc-backups', `removed-runtime-notes-${day}.jsonl`);
+        fs.mkdirSync(path.dirname(backupPath), { recursive: true });
+        fs.appendFileSync(backupPath, JSON.stringify(parsed) + '\n', 'utf-8');
+        return backupPath;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function deleteRuntimeNote(note, cwd) {
     return mutate({ cwd }, () => {
         const filepath = runtimeNotePath(note, cwd);

package/dist/facts.js

@@ -1,8 +1,8 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.25.0 on 2026-08-10T23:31:26.947Z
+// Source: brainclaw v1.26.0 on 2026-08-16T20:27:49.404Z
 export const FACTS = {
-  "version": "1.25.0",
-  "generated_at": "2026-08-10T23:31:26.947Z",
+  "version": "1.26.0",
+  "generated_at": "2026-08-16T20:27:49.404Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -477,8 +477,8 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-10T23:31:25.464Z",
-    "node_version": "v24.18.0",
+    "generated_at": "2026-08-16T20:27:47.271Z",
+    "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
     "scenarios": [
@@ -486,7 +486,7 @@ export const FACTS = {
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 59,
+        "duration_ms_median": 75,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -494,17 +494,17 @@ export const FACTS = {
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 88,
-        "payload_chars_median": 2625,
-        "payload_tokens_est_median": 656
+        "duration_ms_median": 132,
+        "payload_chars_median": 2626,
+        "payload_tokens_est_median": 657
       },
       {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 10,
-        "payload_chars_median": 499,
-        "payload_tokens_est_median": 125
+        "duration_ms_median": 11,
+        "payload_chars_median": 1305,
+        "payload_tokens_est_median": 326
       }
     ]
   }

package/dist/facts.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.25.0",
-  "generated_at": "2026-08-10T23:31:26.947Z",
+  "version": "1.26.0",
+  "generated_at": "2026-08-16T20:27:49.404Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -475,8 +475,8 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-10T23:31:25.464Z",
-    "node_version": "v24.18.0",
+    "generated_at": "2026-08-16T20:27:47.271Z",
+    "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
     "scenarios": [
@@ -484,7 +484,7 @@
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 59,
+        "duration_ms_median": 75,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -492,17 +492,17 @@
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 88,
-        "payload_chars_median": 2625,
-        "payload_tokens_est_median": 656
+        "duration_ms_median": 132,
+        "payload_chars_median": 2626,
+        "payload_tokens_est_median": 657
       },
       {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 10,
-        "payload_chars_median": 499,
-        "payload_tokens_est_median": 125
+        "duration_ms_median": 11,
+        "payload_chars_median": 1305,
+        "payload_tokens_est_median": 326
       }
     ]
   }

package/docs/code-map.md

@@ -136,35 +136,44 @@ call `bclaw_code_refresh` and retry.
 
 ## Freshness badge model
 
-Every Code Map response carries a freshness badge so a stale index is always
-visible rather than silently misleading. The status is one of:
+Every Code Map response has one top-level `freshness` field:
+`fresh`, `stale`, `partial`, or `missing`. It is the synthetic index signal that
+an agent uses to decide whether to refresh, and it has the same meaning on
+`bclaw_work`, `bclaw_code_status`, `bclaw_code_find`, and `bclaw_code_brief`.
+
+```json
+{
+  "freshness": "fresh",
+  "details": {
+    "index": {
+      "status": "fresh",
+      "stale_file_count": 0,
+      "partial_reason": null,
+      "git_head_changed": null
+    },
+    "spot_check": {
+      "status": "stale",
+      "checked_files": 1,
+      "stale_changed_files": ["src/example.ts"],
+      "deleted_files": [],
+      "unchecked_files": [],
+      "budget_exhausted": false,
+      "partial_reason": null
+    }
+  }
+}
+```
 
-| Status | Meaning | Fix |
-|---|---|---|
-| `fresh` | Index matches the working tree, the extractor config, and the parser binaries. | — |
-| `stale_changed_files` | One or more indexed files have changed on disk since they were parsed. | `refresh --changed` |
-| `stale_extractor` | The extractor configuration (ignore rules, size caps, supported extensions, query budget, or active language set) changed since these shards were produced. | `refresh --changed` (heals on the cheap path) |
-| `stale_grammar` | A Tree-sitter grammar (or the engine glue) binary changed since these shards were produced. | `refresh --changed` (heals on the cheap path) |
-| `partial` | The index could not be fully read/built this pass (e.g. the project lock was held by a live writer). | retry |
-| `missing_index` | No index exists yet for this project. | `refresh --all` |
-
-Staleness reasons are kept separate on purpose: a content change
-(`stale_changed_files`) is independent from a config change (`stale_extractor`)
-which is independent from a parser-binary change (`stale_grammar`). The badge
-surfaces the dominant reason; `--json` output and the manifest carry the per-file
-counts.
-
-**Index freshness vs this call's spot-check.** `bclaw_code_status` reports the
-*index* freshness (the manifest state). `bclaw_code_find` / `bclaw_code_brief`
-additionally run a bounded, per-query *spot-check* of the files they actually
-touch — so a single call can read `stale_changed_files` (a file it looked at
-changed on disk) or `partial` (the spot-check hit its budget) even while the index
-itself is `fresh`. When the call-level status diverges from the index, the badge
-carries an `index_status` detail so the two are not confused, e.g.
-`{ status: "partial", details: { index_status: "fresh", partial_reason:
-"lazy_check_budget_exhausted" } }` reads as *"index fresh, this call's spot-check
-incomplete (budget)"* — not a contradiction with a `fresh` `status()`.
+`details.index` is the index diagnosis: its detailed `status` may be
+`stale_changed_files`, `stale_extractor`, `stale_grammar`, or
+`stale_git_head`. `details.spot_check` is a bounded, read-only observation of
+the candidates touched by `find` or `brief`; it is `not_run` on `status` and on
+a work section with no query. A stale or partial spot-check never silently
+changes the shared top-level signal. It gives the agent precise evidence for an
+explicit `bclaw_code_refresh(scope="changed")`, then a retry.
 
+No read command parses files or refreshes the index. `bclaw_work` can suggest
+that explicit refresh, but never performs it lazily.
 ## Lifecycle — pull-based, no daemon
 
 Code Map never runs in the background and never auto-reindexes. The model is lazy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "repository": {