brainclaw 1.10.2 → 1.11.1

package/dist/core/store-resolution.js

@@ -130,16 +130,44 @@ export function resolveEffectiveCwdInfo(options = {}) {
         if (resolved)
             return { cwd: resolved, active_source: 'env_project', resolved_project: projectInfo(resolved) };
     }
-    // 4. Session-scoped active project (per-agent, no cross-agent interference)
-    const session = options.sessionId
-        ? loadSessionById(options.sessionId, anchorCwd)
-        : loadCurrentSession(anchorCwd);
-    if (session?.active_project) {
-        const sp = session.active_project;
-        if (fs.existsSync(path.join(sp.path, MEMORY_DIR, 'config.yaml'))) {
+    // 4. Session-scoped active project (per-agent, no cross-agent interference).
+    //    A session can be persisted under a DIFFERENT store than the anchor we read
+    //    from: an agent physically inside a child project gets its session created
+    //    AND switched under that child (cwd_child / the switch handler use the
+    //    physical cwd), while resolution here anchors at the workspace
+    //    (BRAINCLAW_CWD). Sessions are stored per-cwd (sessionsDir(cwd)) with no
+    //    chain search, so reading only the anchor makes a successful bclaw_switch
+    //    invisible — resolution then silently falls through to cwd_child and pins
+    //    the agent to the wrong project (DGX Finding 1, 2026-06-22). Probe the
+    //    anchor, the physical baseCwd, and the workspace root for each; the first
+    //    session carrying a still-valid active_project wins (anchor first preserves
+    //    prior precedence when the session lives where we expect).
+    const probedSessionCwds = new Set();
+    const probeSessionAt = (candidate) => {
+        if (!candidate)
+            return undefined;
+        const probeCwd = path.resolve(candidate);
+        if (probedSessionCwds.has(probeCwd))
+            return undefined; // dedup — no double read
+        probedSessionCwds.add(probeCwd);
+        const session = options.sessionId
+            ? loadSessionById(options.sessionId, probeCwd)
+            : loadCurrentSession(probeCwd);
+        const sp = session?.active_project;
+        if (sp && fs.existsSync(path.join(sp.path, MEMORY_DIR, 'config.yaml'))) {
             return { cwd: sp.path, active_source: 'session', resolved_project: { path: sp.path, name: sp.name } };
         }
-    }
+        return undefined;
+    };
+    // `??` short-circuits: the common case (agent at the anchor, session there)
+    // costs exactly one session load and never walks for the workspace root. The
+    // baseCwd / workspace-root probes only run when the cheap ones miss — i.e. the
+    // monorepo case where the session was stored under the physical child.
+    const sessionHit = probeSessionAt(anchorCwd)
+        ?? probeSessionAt(baseCwd)
+        ?? probeSessionAt(resolveWorkspaceRoot(baseCwd, options.storeChainOptions));
+    if (sessionHit)
+        return sessionHit;
     // 5. cwd_child — when anchored and the agent is physically inside a child store
     //    STRICTLY under the anchor, resolve THAT child rather than the shared global
     //    pointer or the anchor root. This is the independence rule: physical location
@@ -243,6 +271,22 @@ export function resolveProjectRef(ref, cwd = process.cwd(), storeChainOptions) {
     if (fs.existsSync(path.join(asPath, MEMORY_DIR, 'config.yaml'))) {
         return asPath;
     }
+    // The workspace root itself is a legal target — it is the "umbrella" project
+    // of a monorepo. The chain scan below deliberately skips wsRoot (so a child
+    // can never be shadowed by the root), but an agent must still be able to
+    // target the root by its own project_name/project_id. Without this, an agent
+    // working inside a child cannot switch UP to the monorepo root: bclaw_switch
+    // (and project="<root-name>" routing) failed with "Cannot resolve project"
+    // (DGX dogfood 2026-06-22, Finding 1). Matching by name/id — not by arbitrary
+    // path — preserves the path-injection trust boundary enforced above.
+    try {
+        const rootConfig = loadConfig(wsRoot);
+        if (rootConfig.project_name === ref || rootConfig.project_id === ref)
+            return wsRoot;
+    }
+    catch {
+        // unreadable workspace-root config — fall through to the child scan
+    }
     // Try by project name or project ID: scan child stores
     const chain = resolveStoreChain(wsRoot, storeChainOptions);
     for (const store of chain) {

package/dist/core/worktree.js

@@ -985,6 +985,92 @@ export function cleanMergedWorktrees(mainWorktreePath, options = {}) {
     cleanOrphanWorktreeDirs(mainWorktreePath, worktrees, result, options.dryRun);
     return result;
 }
+/** A worker whose heartbeat file was touched within this window looks alive. */
+const WORKTREE_GC_LIVENESS_WINDOW_MS = 120_000;
+/**
+ * A worker still looks alive when a `.brainclaw-heartbeat-*` sentinel in its
+ * worktree was modified within `windowMs`. Cheap liveness signal that needs no
+ * agent_run lookup — the spawn wrapper touches the heartbeat periodically.
+ */
+function workerLooksAlive(worktreePath, windowMs) {
+    try {
+        const now = Date.now();
+        for (const name of fs.readdirSync(worktreePath)) {
+            if (!name.startsWith('.brainclaw-heartbeat-'))
+                continue;
+            try {
+                if (now - fs.statSync(path.join(worktreePath, name)).mtimeMs < windowMs)
+                    return true;
+            }
+            catch { /* ignore unreadable sentinel */ }
+        }
+    }
+    catch { /* worktree dir unreadable — treat as not-alive */ }
+    return false;
+}
+/**
+ * Garbage-collect a single dispatched sub-agent worktree once its work is safely
+ * harvested (pln#594). Used by the loop-close cascade so review/dispatch
+ * worktrees stop accumulating under ~/.brainclaw/worktrees/.
+ *
+ * SAFE BY DEFAULT — returns { removed: false, reason } instead of removing when:
+ *   - a worker still looks alive (recent heartbeat) — never bypassed, even by force;
+ *   - the worktree has un-harvested edits (anything beyond brainclaw birth-noise /
+ *     LANE-RESULT.json / heartbeat — i.e. real uncommitted work);
+ *   - the lane branch has commits NOT reachable from the main repo HEAD
+ *     (un-integrated work that `branch -D` would drop).
+ * `force` bypasses the dirty + unmerged guards (NOT the liveness guard).
+ * Removal is junction-safe (delegates to removeWorktree → detachWorktreeJunctions).
+ */
+export function gcWorktreeIfHarvested(mainWorktreePath, worktreePath, options = {}) {
+    const out = (removed, reason, branch) => ({
+        path: worktreePath, branch, removed, reason,
+    });
+    if (!worktreePath || !fs.existsSync(worktreePath))
+        return out(false, 'already gone');
+    if (workerLooksAlive(worktreePath, options.livenessWindowMs ?? WORKTREE_GC_LIVENESS_WINDOW_MS)) {
+        return out(false, 'worker still active (recent heartbeat)');
+    }
+    const branchRes = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+    const branch = branchRes.ok ? branchRes.stdout.trim() : undefined;
+    if (!options.force) {
+        // FAIL CLOSED (codex review): every safety probe that cannot be read must
+        // KEEP the worktree, never fall through to removal. A transient `git status`
+        // timeout on a real, dirty worktree previously skipped the dirty check and
+        // force-removed it — losing un-harvested edits. Same for the HEAD reads.
+        const status = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=normal'], worktreePath);
+        if (!status.ok) {
+            return out(false, 'could not read worktree status — keeping (fail-closed)', branch);
+        }
+        if (!worktreeHasOnlyBirthNoise(status.stdout)) {
+            return out(false, 'un-harvested changes in worktree', branch);
+        }
+        // The lane HEAD must be reachable from the main repo HEAD, else the branch
+        // carries un-integrated commits that `branch -D` would silently drop.
+        const laneHead = runGit(['rev-parse', 'HEAD'], worktreePath);
+        const mainHead = runGit(['rev-parse', 'HEAD'], mainWorktreePath);
+        if (!laneHead.ok || !mainHead.ok) {
+            return out(false, 'could not verify merge status — keeping (fail-closed)', branch);
+        }
+        const ancestor = runGit(['merge-base', '--is-ancestor', laneHead.stdout.trim(), mainHead.stdout.trim()], mainWorktreePath);
+        // exit 0 = ancestor (safe). Non-zero = not an ancestor OR a git error — both
+        // mean "cannot prove integrated", so keep.
+        if (!ancestor.ok)
+            return out(false, 'lane branch has un-integrated commits (or unverifiable)', branch);
+    }
+    try {
+        removeWorktree(mainWorktreePath, worktreePath, { force: true });
+    }
+    catch (err) {
+        return out(false, `removal failed: ${err.message}`, branch);
+    }
+    // Delete the now-redundant dispatch branch (force: it may be a squash-merge
+    // descendant that `-d` would refuse). Best-effort — a kept branch is harmless.
+    if (branch && branch !== 'HEAD' && branch !== '(detached)') {
+        runGit(['branch', '-D', branch], mainWorktreePath);
+    }
+    return out(true, options.force ? 'force-removed' : 'harvested + merged', branch);
+}
 /**
  * Removes brainclaw-managed worktree directories under ~/.brainclaw/worktrees/
  * that no longer have a corresponding git worktree entry.

package/dist/facts.js

@@ -1,11 +1,11 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.10.2 on 2026-06-21T23:44:46.631Z
+// Source: brainclaw v1.11.1 on 2026-06-24T13:31:04.040Z
 export const FACTS = {
-  "version": "1.10.2",
-  "generated_at": "2026-06-21T23:44:46.631Z",
+  "version": "1.11.1",
+  "generated_at": "2026-06-24T13:31:04.040Z",
   "tools": {
-    "count": 66,
-    "published_count": 65,
+    "count": 67,
+    "published_count": 66,
     "names": [
       "bclaw_bootstrap",
       "bclaw_release_notes",
@@ -72,7 +72,8 @@ export const FACTS = {
       "bclaw_create",
       "bclaw_update",
       "bclaw_remove",
-      "bclaw_transition"
+      "bclaw_transition",
+      "bclaw_move"
     ]
   },
   "entities": {

package/dist/facts.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.10.2",
-  "generated_at": "2026-06-21T23:44:46.631Z",
+  "version": "1.11.1",
+  "generated_at": "2026-06-24T13:31:04.040Z",
   "tools": {
-    "count": 66,
-    "published_count": 65,
+    "count": 67,
+    "published_count": 66,
     "names": [
       "bclaw_bootstrap",
       "bclaw_release_notes",
@@ -70,7 +70,8 @@
       "bclaw_create",
       "bclaw_update",
       "bclaw_remove",
-      "bclaw_transition"
+      "bclaw_transition",
+      "bclaw_move"
     ]
   },
   "entities": {

package/docs/cli.md

@@ -65,6 +65,24 @@ brainclaw --cwd /other/path status   # one-off override without switching
 
 **MCP usage:** The active project also affects MCP tools. When `bclaw_context(kind="memory")` is called without an explicit path, it resolves context from the active project's store. Agents can also use the `BRAINCLAW_PROJECT=<name>` environment variable for the same effect.
 
+### `brainclaw move <entity> <id> --to <project>`
+
+Relocate a brainclaw item to another project in a multi-project workspace, **preserving its id** — so `pln#`/`dec#` references stay stable. Useful when an item was created in the wrong store (e.g. before a project switch took effect). MCP equivalent: `bclaw_move(entity, id, to_project, …)`.
+
+| Option | Description |
+|---|---|
+| `--to <project>` | Target project (name, path, or basename) — required |
+| `--from <project>` | Source project (defaults to the current project) |
+| `--force` | Move even if an active claim references the item |
+| `--json` | Output as JSON |
+
+Relocatable entities: `plan`, `decision`, `constraint`, `trap`, `handoff`, `sequence`. **Execution-local entities** (`claim`, `assignment`, `agent_run`, `session`) are rejected — they belong to the project where the work ran. The move refuses an id collision in the target or a plan under an active claim (unless `--force`), audits both stores, and warns about sequences that still reference a moved plan.
+
+```bash
+brainclaw move plan pln_a1b2c3d4 --to global          # move a misplaced plan to the root project
+brainclaw move decision dec_99 --from app_a --to app_b
+```
+
 ---
 
 ## Initialize and Inspect
@@ -246,14 +264,18 @@ Run health checks on config, state, and generated views.
 | `--json` | Output as JSON |
 | `--migration-check` | Check for pending migrations |
 | `--fix-agent-ignore` | Add missing `.gitignore` entries for generated local Brainclaw agent files |
+| `--fix-hooks` | Purge stale/broken/duplicate brainclaw session hooks across all Claude Code settings scopes (user + cwd) and rewrite the canonical ones |
 
 ```bash
 brainclaw doctor
 brainclaw doctor --json
 brainclaw doctor --migration-check
 brainclaw doctor --fix-agent-ignore
+brainclaw doctor --fix-hooks
 ```
 
+`--fix-hooks` collapses every recognized brainclaw session hook (across `UserPromptSubmit` / `Stop` / `PostToolUse`) in `~/.claude/settings.json`, `~/.claude/settings.local.json`, `<cwd>/.claude/settings.json`, and `<cwd>/.claude/settings.local.json` down to a single canonical entry, repairing legacy/broken forms. It only touches files (and events) that already contain a brainclaw hook, so user-authored hooks and hook-less scopes are left untouched. Use it when you see repeated `UserPromptSubmit hook error` warnings.
+
 When Brainclaw detects generated local agent files such as `.mcp.json` or `.claude/settings.local.json` inside a Git repo, `doctor` warns if they are not ignored or are still tracked. `--fix-agent-ignore` only updates `.gitignore`; if a file is already tracked you still need to untrack it with `git rm --cached <path>`.
 
 In `multi-project` mode with `projects.strategy: folder`, `doctor` now checks the effective workspace project set, not just `config.projects.known`. That avoids false positives on workspaces that resolve child stores from the filesystem or global project registry.
@@ -613,13 +635,13 @@ can ask "where is X / what should I read first" before editing. The MCP equivale
 are `bclaw_code_status` / `bclaw_code_find` / `bclaw_code_brief` / `bclaw_code_refresh`.
 Full reference (freshness model, supported languages, WASM bundling): [docs/code-map.md](code-map.md).
 
-### `brainclaw code-map status`
+### `brainclaw code-map status [--cascade]`
 
-Store presence, freshness badge (`fresh` / `stale_changed_files` / `stale_extractor` / `stale_grammar` / `partial` / `missing_index`), and index stats (files, nodes, edges). Read-only.
+Store presence, freshness badge (`fresh` / `stale_changed_files` / `stale_extractor` / `stale_grammar` / `partial` / `missing_index`), and index stats (files, nodes, edges). Read-only. In a multi-project workspace, `--cascade` adds a per-child recap (which nested projects have a built index vs `missing_index`, plus an aggregate count).
 
-### `brainclaw code-map refresh [--all|--changed]`
+### `brainclaw code-map refresh [--all|--changed] [--cascade]`
 
-Build or update the index. `--changed` (default) re-parses only touched files; `--all` does a full re-index. Run this when status shows `missing_index` or a stale badge. Fails fast (never blocks) if another writer holds the project lock.
+Build or update the index. `--changed` (default) re-parses only touched files; `--all` does a full re-index. Run this when status shows `missing_index` or a stale badge. Fails fast (never blocks) if another writer holds the project lock. In a multi-project workspace, `--cascade` refreshes **every nested project** into its own store plus a root store scoped to the files no child owns (zero double-indexing) — one command at the root indexes the whole monorepo per-project. See [docs/code-map.md](code-map.md#cascading-a-multi-project-workspace---cascade).
 
 ### `brainclaw code-map find <query> [--limit <n>]`
 

package/docs/code-map.md

@@ -165,11 +165,12 @@ Code Map is **per project**: the index lives at `<project>/.brainclaw/code/`, an
 into subdirectories but skipping `node_modules`, `dist`, `.git`, `.brainclaw`,
 `vendor`, `target`, … at any depth.
 
-There is no nested-project *boundary*, so the scope follows **where you run it**:
+By default there is no nested-project *boundary*, so a plain (non-cascade) scope
+follows **where you run it**:
 
 | You run refresh / find / brief … | … against |
 |---|---|
-| at the monorepo root | one index covering the whole tree (every child project's source) |
+| at the monorepo root (plain) | one index covering the whole tree (every child project's source) |
 | inside a child project (e.g. `apps/api`) | that child's own index, at `apps/api/.brainclaw/code/` |
 
 When an agent works inside a child project, brainclaw's project resolution routes
@@ -178,10 +179,33 @@ Code Map to **that child** — the same per-project scoping that powers `bclaw_w
 juggling. A submodule that is itself an application (under e.g. `apps/`) is indexed
 like any other directory.
 
+### Cascading a multi-project workspace (`--cascade`)
+
+In a `project_mode: multi-project` workspace, one refresh at the root can index
+the whole monorepo **per project** instead of building one monolithic root index:
+
+```bash
+brainclaw code-map refresh --all --cascade     # CLI
+# bclaw_code_refresh(scope="all", cascade=true) # MCP
+```
+
+This refreshes **every nested brainclaw project** into its own
+`<child>/.brainclaw/code/` store, and refreshes the **root** store *scoped to the
+files no child owns*. The rule is "each file is indexed by exactly the most
+specific brainclaw project that contains it" — so there is **zero
+double-indexing**, even when projects nest inside one another. `--cascade` is
+opt-in; without it, the root refresh keeps its single-tree behaviour (above), and
+single-project repos ignore the flag entirely.
+
+`status --cascade` (or `bclaw_code_status(cascade=true)`) adds a per-child recap —
+which nested projects have a built index vs `missing_index`, plus an aggregate
+count — so you can see workspace-wide freshness from the root.
+
 **Not yet supported** (roadmap):
 
-- A single aggregated view that keeps **separate per-child indexes and federates
-  them** at the root (a query spanning services without double-indexing).
+- A single **federated query** at the root that fans out across the per-child
+  indexes and merges the results (today, `--cascade` builds the per-child indexes;
+  `find` / `brief` still run against one store at a time).
 - **Cross-service edges** — e.g. linking an API call to the route that defines it in
   another service. Code Map indexes language *symbols* and *module imports*, not
   framework routes or runtime HTTP calls, so it does not (today) map "service A calls

package/docs/concepts/dispatch-lifecycle.md

@@ -165,6 +165,32 @@ The on-behalf commit is guarded by the linked-worktree check (`isLinkedWorktree`
 
 Integration is strictly additive and opt-in. Plain `brainclaw harvest <assignment_id>` remains report-only; it reads and reports the lane result without committing or mutating assignment / claim state. The on-behalf commit and lifecycle completion happen only when the coordinator passes `--integrate`.
 
+### Worktree garbage collection on loop close (pln#594)
+
+Closing a loop as **`completed`** garbage-collects the worktrees of its slot
+assignments, so review/dispatch worktrees stop accumulating under
+`~/.brainclaw/worktrees/`. The cascade runs inside `closeLoop` (so it covers MCP,
+CLI, and reconciler-driven closes) and is **safe by default** — each worktree is
+removed only when all of these hold:
+
+- the worker no longer looks alive (no `.brainclaw-heartbeat-*` touched within the
+  liveness window) — this guard is never bypassed, even with force;
+- the worktree has no un-harvested edits — anything beyond brainclaw birth-noise
+  (`.gitignore`, the sidecar), `LANE-RESULT.json`, and the heartbeat counts as
+  real work and is preserved;
+- the lane branch carries no commits unreachable from the main repo HEAD (so
+  deleting the branch can't drop un-integrated work).
+
+A worktree that fails a guard is **kept** (with a debug-log reason) so you can
+harvest or inspect it. A **`cancelled`/`blocked`** close keeps the worktree and
+its run logs for forensics. Removal is junction-safe (`removeWorktree` detaches
+`node_modules`/`dist` junctions first), then the redundant dispatch branch is
+deleted. The whole step is best-effort — it never blocks the close — and can be
+disabled with `BRAINCLAW_NO_WORKTREE_GC=1`. The reusable primitive is
+`gcWorktreeIfHarvested(mainWorktreePath, worktreePath, { force? })` in
+`core/worktree.ts`; `brainclaw worktree clean` remains the manual/TTL backstop
+for anything the cascade keeps.
+
 ---
 
 ## Diagnostic playbook

package/docs/integrations/mcp.md

@@ -107,6 +107,7 @@ Each tool also has an `annotations.category` field: `session`, `context`, `memor
 | `bclaw_update` | memory | Partially update mutable fields on a canonical entity |
 | `bclaw_remove` | memory | Archive or purge a canonical entity |
 | `bclaw_transition` | memory | Move an entity through its validated state machine |
+| `bclaw_move` | memory | Relocate an item to another project, id-preserving (multi-project) |
 | `bclaw_code_status` | discovery | Code Map freshness badge + index stats (store presence, files/nodes/edges) |
 | `bclaw_code_find` | discovery | Search the Code Map symbol index by name (function/class/component/hook/type) |
 | `bclaw_code_brief` | discovery | Ranked reading list + related decisions/traps before editing a symbol or path |
@@ -162,6 +163,7 @@ for the full 1.0.0 changelog.
 | `bclaw_update(entity, id, patch)` | Partial merge (updatable fields only) | `bclaw_update_plan`, `bclaw_update_memory` |
 | `bclaw_remove(entity, id, purge?)` | Archive (default) or hard-delete | `bclaw_delete_memory`, `bclaw_delete_plan` |
 | `bclaw_transition(entity, id, to, reason?)` | State machine transition with side-effect tags | `bclaw_accept`, `bclaw_reject`, status-update flows |
+| `bclaw_move(entity, id, to_project, from_project?, force?)` | Id-preserving cross-project relocation (plan/decision/constraint/trap/handoff/sequence; execution entities rejected) | — (new in 1.11.0) |
 
 Supported entities: plan, decision, constraint, trap, handoff,
 runtime_note, candidate, sequence, claim, action, assignment, agent_run

package/docs/mcp-schema-changelog.md

@@ -10,6 +10,24 @@ guarantees this changelog follows.
 
 ## Unreleased
 
+**Added — `bclaw_move` cross-project relocation (pln#595)**
+- New canonical-grammar verb `bclaw_move(entity, id, to_project, from_project?, force?)`:
+  relocates a brainclaw item to another project in a multi-project workspace,
+  PRESERVING its id. Relocatable: plan, decision, constraint, trap, handoff,
+  sequence. Execution-local entities (claim, assignment, agent_run, session) are
+  rejected. Refuses id collisions / active-claim moves (unless force); audits both
+  stores. Additive — no tool removed or renamed.
+
+**Changed — Code Map monorepo cascade (DGX Finding 2)**
+- `bclaw_code_refresh` gains an optional `cascade: boolean`. In a
+  `project_mode: multi-project` workspace it refreshes every nested
+  brainclaw project into its own store + a child-scoped root store
+  (zero double-indexing). No-op outside a multi-project workspace.
+- `bclaw_code_status` gains an optional `cascade: boolean` that adds a
+  per-child store-presence / freshness recap.
+- No tool was removed or renamed; no required argument changed.
+- Surface fingerprint bumped in the `(current)` section below.
+
 **Changed — agent-UX read-path surface (pln#542)**
 - `bclaw_work`, `bclaw_context`, `bclaw_find`, `bclaw_get`, `bclaw_search`
   gain an optional `budget_tokens` argument (relevance-ranked fill).
@@ -104,10 +122,16 @@ will still succeed. A follow-up PR will strip the dead handler code.
   changelog records the published MCP surface fingerprint. When a tool
   name, tier, category, or input schema changes, the test fails until
   this section is updated.
-- MCP public surface fingerprint: `sha256:35fd83b0d124df94`
-  (updated 2026-06-20 for 1.10.0: Code Map tools added to the published surface —
+- MCP public surface fingerprint: `sha256:188d2eba8828e4fe`
+  (updated 2026-06-24 for 1.11.0: `bclaw_move` added (pln#595) AND a `cascade`
+  boolean added to `bclaw_code_refresh` / `bclaw_code_status` (DGX Finding 2).
+  Additive: one new tool; nothing removed or renamed; no required argument changed.
+  Supersedes the per-branch interim hashes sha256:dffcc868ae90e013 and
+  sha256:41eb6d55010cdfb5.)
+  Previous: `sha256:35fd83b0d124df94`,
+  updated 2026-06-20 for 1.10.0: Code Map tools added to the published surface —
   `bclaw_code_find`, `bclaw_code_brief`, `bclaw_code_refresh`, `bclaw_code_status`.
-  Additive: no tool removed or renamed.)
+  Additive: no tool removed or renamed.
   Previous: `sha256:70cf80b9615f631f`,
   updated 2026-06-18 for 1.9.1: monorepo project-scoping fix — session-aware
   effective-cwd resolution and read-path project scoping shift the published

package/package.json

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