brainclaw 1.20.4 → 1.22.0

package/dist/core/schema.js

@@ -775,6 +775,23 @@ export const AssignmentSchema = z.object({
     session_id: z.string().optional(),
     dispatcher_agent: z.string(),
     dispatcher_session_id: z.string().optional(),
+    /**
+     * OWNER project (pln#649 step 1, dec#153): the `project_id` of the store this
+     * assignment was created in, captured once and never re-derived. Every
+     * read/mutation of this assignment must reach THAT store — that is what makes
+     * entity-authoritative routing possible instead of ambient resolution.
+     * OPTIONAL by design: assignments written before this field existed must stay
+     * loadable — a required field would make every pre-existing record fail
+     * schema.parse and drop out of the loaded state. An absent owner means "legacy,
+     * fall back to current behaviour", never "refuse".
+     *
+     * Always derived from the store being written to (createAssignment via
+     * resolveOwnerProjectId(cwd)); there is deliberately NO caller override. An
+     * override let a record be saved in store A while declaring owner B, which the
+     * step-4 refusal would then read as a divergence and reject a correctly routed
+     * mutation (review P1-1).
+     */
+    project_id: z.string().optional(),
     // Task metadata
     scope: z.string(),
     description: z.string(),
@@ -839,6 +856,13 @@ export const AgentRunSchema = z.object({
     agent: z.string(),
     agent_id: z.string().optional(),
     session_id: z.string().optional(),
+    /**
+     * OWNER project — same contract as Assignment.project_id (pln#649 step 1,
+     * dec#153): the `project_id` of the store this run was created in, captured
+     * once at creation, always derived from the write cwd and never overridable.
+     * Optional so pre-existing records stay loadable.
+     */
+    project_id: z.string().optional(),
     transport: AgentRunTransportSchema,
     status: AgentRunStatusSchema,
     status_reason: z.string().optional(),
@@ -1151,22 +1175,6 @@ export const RemoteSyncSchema = z.object({
     ssh_key_path: z.string().optional(),
     sync_strategy: z.enum(['pull-only', 'push-pull', 'pr-based']).default('push-pull'),
 });
-export const CloudSyncConfigSchema = z.object({
-    enabled: z.boolean().default(false),
-    endpoint: z.string().default('https://app.brainclaw.dev'),
-    api_key: z.string().optional(),
-    /** Remote project this bridge federates into (scopes signed runtime writes). */
-    project_id: z.string().optional(),
-    /** Approved remote agent identity used to sign runtime writes (pln#100). */
-    agent_id: z.string().optional(),
-    agent_name: z.string().optional(),
-    /**
-     * Fail-closed toggle: when true, the bridge refuses to push a runtime write
-     * unless it can sign it with an approved agent's Ed25519 key. Absent/false
-     * keeps existing API-key-only setups working (signing is additive).
-     */
-    require_signed: z.boolean().optional(),
-});
 export const SessionSnapshotSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     session_id: z.string(),
@@ -1496,7 +1504,6 @@ export const ConfigSchema = z.object({
     target_audience: z.enum(['human', 'agent']).optional().default('human'),
     openclaw_bridge: z.boolean().optional().default(false),
     remote_sync: RemoteSyncSchema.optional(),
-    cloud_sync: CloudSyncConfigSchema.optional(),
     telemetry: z.literal(false),
     allow_network: z.literal(false),
     redaction: RedactionConfigSchema,

package/dist/core/sequence.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { JsonStore } from './json-store.js';
 import { mutate } from './mutation-pipeline.js';
 import { generateIdWithLabel, nowISO } from './ids.js';
-import { resolveEntityDir } from './io.js';
+import { entityRecordDirs, resolveEntityDir } from './io.js';
 import { SequenceItemSchema, SequenceSchema } from './schema.js';
 import { refreshLiveCompanions } from '../commands/export.js';
 import { emitRegistryPostImage, emitRegistryTombstone, registryFaultPoint } from './events/registry-post-image.js';
@@ -15,14 +16,17 @@ export function ensureSequencesDir(cwd) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
-function sequenceStore(cwd, mode = 'read') {
+function sequenceStoreForDir(dirPath) {
     return new JsonStore({
-        dirPath: sequencesDir(cwd, mode),
+        dirPath,
         documentType: 'sequence',
         getId: (sequence) => sequence.id,
         sort: (a, b) => a.updated_at.localeCompare(b.updated_at),
     });
 }
+function sequenceStore(cwd, mode = 'read') {
+    return sequenceStoreForDir(sequencesDir(cwd, mode));
+}
 function normalizeItems(items) {
     return items
         .map((item) => SequenceItemSchema.parse(item))
@@ -47,6 +51,19 @@ export function saveSequence(sequence, cwd) {
         emitRegistryPostImage('sequence', parsed, { created, agent: parsed.author, agent_id: parsed.author_id, session_id: parsed.session_id, cwd });
         registryFaultPoint('after_registry_journal');
         store.save(parsed);
+        // Converge the other layout, as claims/assignments/runs do: a legacy twin holding a
+        // stale status is how a "deleted" record comes back.
+        const writeDir = sequencesDir(cwd, 'write');
+        for (const dirPath of entityRecordDirs('sequences', cwd ?? process.cwd())) {
+            if (dirPath === writeDir)
+                continue;
+            const legacyPath = path.join(dirPath, `${parsed.id}.json`);
+            try {
+                if (fs.existsSync(legacyPath))
+                    fs.unlinkSync(legacyPath);
+            }
+            catch { /* best effort — the dual-layout list keeps it visible */ }
+        }
         // Auto-refresh live companions after sequence changes (non-fatal)
         try {
             refreshLiveCompanions(cwd);
@@ -54,8 +71,28 @@ export function saveSequence(sequence, cwd) {
         catch { /* best-effort */ }
     });
 }
+/**
+ * BOTH LAYOUTS, canonical winning a duplicate id.
+ *
+ * FIXED AT THE LIST LAYER ON PURPOSE, and this is the part a "port the by-id loader"
+ * instinct gets wrong (Fable audit): `loadSequence` resolves by id OR short_label, and
+ * `getActiveSequence` needs the whole set — both are list-mediated. Rewriting
+ * `loadSequence` with `entityRecordPaths` would build a path from a short_label, which is
+ * not a filesystem key, so it could not work for either caller. One dual-layout list fixes
+ * all three readers.
+ *
+ * Exposure is nil today: sequences postdate the partitioned layout (measured legacy=0), so
+ * this is consistency with the sibling entities, not a field fix.
+ */
 export function listSequences(cwd) {
-    return sequenceStore(cwd).list().sort((a, b) => {
+    const byId = new Map();
+    for (const dirPath of entityRecordDirs('sequences', cwd ?? process.cwd())) {
+        for (const sequence of sequenceStoreForDir(dirPath).list()) {
+            if (!byId.has(sequence.id))
+                byId.set(sequence.id, sequence);
+        }
+    }
+    return Array.from(byId.values()).sort((a, b) => {
         const activeBoost = Number(b.status === 'active') - Number(a.status === 'active');
         if (activeBoost !== 0)
             return activeBoost;
@@ -115,8 +152,12 @@ export function deleteSequence(id, cwd) {
 export function updateSequence(input, cwd) {
     return mutate({ cwd }, () => {
         ensureSequencesDir(cwd);
-        const store = sequenceStore(cwd, 'write');
-        const current = store.list().find((entry) => entry.id === input.id || entry.short_label === input.id);
+        // A FOURTH READER, found by the pin for this change rather than by the audit that
+        // prompted it: this looked the record up in the WRITE directory only, so a sequence in
+        // the legacy layout was invisible to every update — `Sequence not found` on a record
+        // `listSequences` and `loadSequence` could both see. Reads come from the dual-layout
+        // list; the write still lands canonical via saveSequence, which then converges the twin.
+        const current = listSequences(cwd).find((entry) => entry.id === input.id || entry.short_label === input.id);
         if (!current) {
             throw new Error(`Sequence not found: ${input.id}`);
         }

package/dist/core/store-resolution.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { loadActiveProject } from './active-project.js';
 import { loadConfig } from './config.js';
-import { loadCurrentSession, loadSessionById } from './identity.js';
+import { loadCurrentSession, loadSessionById, resolveExplicitSessionId } from './identity.js';
 import { MEMORY_DIR } from './io.js';
 import { summarizeWorkspaceProjects } from './workspace-projects.js';
 /**
@@ -142,8 +142,42 @@ export function resolveEffectiveCwdInfo(options = {}) {
     //    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).
+    //
+    //    pln#648 — the probe set must cover EVERY selector that could have been
+    //    effective when the session file was written, because that is what decided
+    //    its directory. Two were missing, and both are reachable:
+    //      - the cwd_child of step 5: an agent in `apps/api/src` writes its session
+    //        under `apps/api`, which is neither baseCwd nor the workspace root;
+    //      - the shared global pointer of step 6: a session created while another
+    //        agent's `switch --global` was in force lands under THAT project.
+    //    The second one was reproduced end-to-end on 2026-08-03 (/c/tmp/bclaw-mono,
+    //    v1.20.4): global pointer = web, `bclaw_switch(api)` reported
+    //    `{scope: session, name: api}` and `switch --json` read it back as api —
+    //    while the session file itself sat in `apps/web/.brainclaw/sessions/`, unseen
+    //    here, so every WRITE silently landed in web. Status green, data in the wrong
+    //    project: the worst failure mode a shared memory can have. The switch handler
+    //    finds the record (it resolves cwd first, landing on web, then reads the
+    //    session there); this resolver did not. Same file, two verdicts.
+    //    Both new candidates are lazy + memoized and are shared with steps 5/6. When
+    //    an earlier probe hits, neither helper runs and the cost is unchanged; after
+    //    all three miss, the pointer probe does add one session read before returning
+    //    the same `global` answer (review P3-5 — the claim is bounded to the hit path).
+    //
+    //    STRONG IDENTITY REQUIRED ON THE ADDED CANDIDATES (review P1-1/P1-2, both
+    //    scenarios reproduced by the reviewer). `loadCurrentSession` can return a
+    //    record this process does not own: the pidless candidate it adopts on
+    //    agent+user alone (identity.ts ~145 — agent_id and host_id are NOT compared),
+    //    and the legacy `.current-session` fallback (identity.ts ~158), returned with
+    //    no agent/user/pid/TTL check whatsoever. Honouring those from a store the
+    //    agent never named would let ANOTHER instance's stale intent outrank F1/F2
+    //    physical-child isolation — a behavioural expansion, not a bug fix. So the two
+    //    NEW candidates accept a session only on strong identity: an explicitly named
+    //    session id (argument or env — exact-file lookup), or a record whose pid is
+    //    this very process. The three original candidates keep their historical
+    //    behaviour untouched: this restriction narrows only what the fix added.
+    const explicitSessionId = options.sessionId ?? resolveExplicitSessionId();
     const probedSessionCwds = new Set();
-    const probeSessionAt = (candidate) => {
+    const probeSessionAt = (candidate, opts) => {
         if (!candidate)
             return undefined;
         const probeCwd = path.resolve(candidate);
@@ -153,19 +187,63 @@ export function resolveEffectiveCwdInfo(options = {}) {
         const session = options.sessionId
             ? loadSessionById(options.sessionId, probeCwd)
             : loadCurrentSession(probeCwd);
-        const sp = session?.active_project;
+        if (!session)
+            return undefined;
+        // A named id is an exact-file lookup, so the record IS the one asked for; the
+        // pid check covers the unnamed case. Anything else is a weak adoption.
+        if (opts?.requireStrongIdentity && !explicitSessionId && session.pid !== process.pid) {
+            return undefined;
+        }
+        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;
     };
+    // The step-5 child and the step-6 shared pointer, each resolved AT MOST ONCE
+    // and shared with the step that owns it — so adding them to the probe set costs
+    // no extra disk work, and a probe can never disagree with the step it mirrors.
+    let cwdChildResolved = false;
+    let cwdChildValue;
+    const cwdChildCandidate = () => {
+        if (!cwdChildResolved) {
+            cwdChildResolved = true;
+            // Anchored (step 5): ceiling = the anchor. Unanchored (step 5b, F2
+            // trp_71accb07): ceiling = the discovered workspace root — never homedir.
+            const ceiling = hasEnvWorkspace ? anchorCwd : resolveWorkspaceRoot(baseCwd, options.storeChainOptions);
+            if (ceiling && baseCwd !== path.resolve(ceiling) && isAtOrBelow(baseCwd, ceiling)) {
+                const child = findClosestStoreBelow(baseCwd, ceiling);
+                // findClosestStoreBelow walks up EXCLUSIVELY of the ceiling, so a
+                // single-project repo can never yield its own root store here.
+                if (child && path.resolve(child) !== path.resolve(ceiling))
+                    cwdChildValue = child;
+            }
+        }
+        return cwdChildValue;
+    };
+    let globalPointerResolved = false;
+    let globalPointerValue;
+    const globalPointerCandidate = () => {
+        if (!globalPointerResolved) {
+            globalPointerResolved = true;
+            const wsRoot = hasEnvWorkspace ? anchorCwd : resolveWorkspaceRoot(anchorCwd, options.storeChainOptions);
+            const active = wsRoot ? loadActiveProject(wsRoot) : undefined;
+            if (active && fs.existsSync(path.join(active.path, MEMORY_DIR, 'config.yaml'))) {
+                globalPointerValue = { path: active.path, name: active.name };
+            }
+        }
+        return globalPointerValue;
+    };
     // `??` 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.
+    // later probes only run when the cheap ones miss — i.e. the monorepo case where
+    // the session was stored under whichever project a PREVIOUS resolution picked
+    // (physical child, or the shared pointer — pln#648).
     const sessionHit = probeSessionAt(anchorCwd)
         ?? probeSessionAt(baseCwd)
-        ?? probeSessionAt(resolveWorkspaceRoot(baseCwd, options.storeChainOptions));
+        ?? probeSessionAt(resolveWorkspaceRoot(baseCwd, options.storeChainOptions))
+        ?? probeSessionAt(cwdChildCandidate(), { requireStrongIdentity: true })
+        ?? probeSessionAt(globalPointerCandidate()?.path, { requireStrongIdentity: true });
     if (sessionHit)
         return sessionHit;
     // 5. cwd_child — when anchored and the agent is physically inside a child store
@@ -178,11 +256,13 @@ export function resolveEffectiveCwdInfo(options = {}) {
     //    at/below it. `findClosestStoreBelow` walks UP to the ceiling but does NOT prove
     //    baseCwd sits below it — without the `isAtOrBelow` guard a baseCwd OUTSIDE the
     //    anchor could match an unrelated `.brainclaw` before hitting the filesystem root.
-    if (baseCwd !== anchorCwd && isAtOrBelow(baseCwd, anchorCwd)) {
-        const child = findClosestStoreBelow(baseCwd, anchorCwd);
-        if (child && path.resolve(child) !== path.resolve(anchorCwd)) {
-            return { cwd: child, active_source: 'cwd_child', resolved_project: projectInfo(child) };
-        }
+    //
+    //    pln#648: the candidate itself now comes from cwdChildCandidate() so this
+    //    step and the session probe above cannot drift apart. Both anchored (5) and
+    //    unanchored (5b) cases live in that one helper.
+    const cwdChild = cwdChildCandidate();
+    if (cwdChild) {
+        return { cwd: cwdChild, active_source: 'cwd_child', resolved_project: projectInfo(cwdChild) };
     }
     // 5b. cwd_child (NO anchor) — F2 [trp_71accb07]: even without a BRAINCLAW_CWD
     //     anchor, an agent physically inside a child project must resolve THAT
@@ -194,22 +274,15 @@ export function resolveEffectiveCwdInfo(options = {}) {
     //     For a single-project repo this is a strict no-op: findClosestStoreBelow
     //     walks UP to the ceiling EXCLUSIVELY, so it can never return the lone root
     //     store (Codex cadrage non-regression proof, batch 2).
-    if (!hasEnvWorkspace) {
-        const physicalRoot = resolveWorkspaceRoot(baseCwd, options.storeChainOptions);
-        if (physicalRoot && isAtOrBelow(baseCwd, physicalRoot)) {
-            const child = findClosestStoreBelow(baseCwd, physicalRoot);
-            if (child && path.resolve(child) !== path.resolve(physicalRoot)) {
-                return { cwd: child, active_source: 'cwd_child', resolved_project: projectInfo(child) };
-            }
-        }
-    }
+    //     pln#648: both cases are now the single `cwdChildCandidate()` above.
     // 6. Global active-project.json from workspace root
-    const wsRoot = hasEnvWorkspace ? anchorCwd : resolveWorkspaceRoot(anchorCwd, options.storeChainOptions);
-    if (wsRoot) {
-        const active = loadActiveProject(wsRoot);
-        if (active && fs.existsSync(path.join(active.path, MEMORY_DIR, 'config.yaml'))) {
-            return { cwd: active.path, active_source: 'global', resolved_project: { path: active.path, name: active.name } };
-        }
+    const globalPointer = globalPointerCandidate();
+    if (globalPointer) {
+        return {
+            cwd: globalPointer.path,
+            active_source: 'global',
+            resolved_project: { path: globalPointer.path, name: globalPointer.name },
+        };
     }
     // 7. Default
     return { cwd: anchorCwd, active_source: 'cwd', resolved_project: projectInfo(anchorCwd) };

package/dist/core/workspace-projects.js

@@ -68,11 +68,25 @@ export function summarizeWorkspaceProjects(cwd, config) {
         uses_folder_resolution: usesFolderResolution,
     };
 }
-export function scanNestedBrainclawProjects(rootDir, maxDepth = 6) {
+/**
+ * pln#649 step 3 review P1-1 — the scan plus whether it was TRUNCATED.
+ *
+ * A caller that turns "no project found" into a refusal must be able to tell that
+ * apart from "I stopped looking". Inferring it from the results is not enough, and
+ * that mistake was reproduced: with a store at `root/d1/…/d7` and nothing in
+ * `d1…d6`, the walk cut the branch without ever returning a project near the
+ * ceiling, so a heuristic based on the deepest RESULT reported completeness while
+ * the target sat one level below the cut. Truncation is a property of the WALK, so
+ * only the walk can report it.
+ */
+export function scanNestedBrainclawProjectsDetailed(rootDir, maxDepth = 6) {
     const resolvedRoot = path.resolve(rootDir);
     const results = new Map();
+    let truncated = false;
     function walk(dir, depth) {
         if (depth > maxDepth) {
+            // A branch we were asked to descend is being cut: anything below is unseen.
+            truncated = true;
             return;
         }
         let entries;
@@ -98,7 +112,14 @@ export function scanNestedBrainclawProjects(rootDir, maxDepth = 6) {
         }
     }
     walk(resolvedRoot, 1);
-    return [...results.values()].sort((a, b) => a.path.localeCompare(b.path));
+    return {
+        projects: [...results.values()].sort((a, b) => a.path.localeCompare(b.path)),
+        truncated,
+    };
+}
+/** Backward-compatible projection: the projects only, for every existing caller. */
+export function scanNestedBrainclawProjects(rootDir, maxDepth = 6) {
+    return scanNestedBrainclawProjectsDetailed(rootDir, maxDepth).projects;
 }
 function collectRegistryProjectsUnder(rootDir) {
     const registry = loadGlobalRegistry();

package/dist/core/worktree.js

@@ -1365,8 +1365,35 @@ export function removeWorktree(mainWorktreePath, worktreePath, options = {}) {
     if (fs.existsSync(worktreePath)) {
         detachWorktreeJunctions(worktreePath);
     }
+    // pln#647 — PROTOCOL DEBRIS MUST NOT BLOCK AN EXPLICIT REMOVE.
+    //
+    // The bulk `worktree clean` path already knows that a heartbeat, a LANE-RESULT or
+    // a copied .gitignore are brainclaw's OWN artifacts and not user work
+    // (worktreeHasOnlyBirthNoise). This path did not, so `git worktree remove` refused
+    // with "contains modified or untracked files" over a file brainclaw itself wrote
+    // and never gitignores. Observed 2026-08-04 in brainclaw's own repo: two of three
+    // worker worktrees refused removal, blocked by a lone
+    // `.brainclaw-heartbeat-<asgn>`. That is not cosmetic — a worktree surviving its
+    // lane is what makes a re-dispatch on the same loop scope collide
+    // (`spawn_no_worktree`), and the retry then wedges the scope with a claim that has
+    // no worktree (trp#72b4e9b3, whose documented recovery begins by deleting exactly
+    // this heartbeat by hand).
+    //
+    // So: consult the SAME predicate the clean path uses. Only brainclaw's own noise is
+    // forced through; a worktree holding real user work still refuses, and the caller
+    // must pass force explicitly.
     const args = ['worktree', 'remove', worktreePath];
-    if (options.force)
+    let force = options.force === true;
+    if (!force && fs.existsSync(worktreePath)) {
+        const status = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=normal'], worktreePath);
+        // `isAutoForcibleDebris`, NOT `worktreeHasOnlyBirthNoise`: the latter also
+        // forgives agent-config dirs, which is safe for gating and post-merge gc but not
+        // for a destruction with no merge gate (review of pln#647).
+        if (status.ok && status.stdout.trim().length > 0 && isAutoForcibleDebris(status.stdout)) {
+            force = true;
+        }
+    }
+    if (force)
         args.push('--force');
     const result = runGit(args, mainWorktreePath);
     if (!result.ok) {
@@ -1415,6 +1442,37 @@ export function worktreeHasOnlyBirthNoise(statusZStdout) {
             || isSystemDirtyPath(norm);
     });
 }
+/**
+ * The ONLY paths an explicit `worktree remove` may force through on its own.
+ *
+ * NARROWER THAN `worktreeHasOnlyBirthNoise` ON PURPOSE (review of pln#647).
+ * That predicate folds in `isSystemDirtyPath`, which classes agent-config dirs
+ * (`.claude/`, `.cursor/`, `.codex/`) as noise — calibrated for two jobs that destroy
+ * nothing: dispatch GATING, and the POST-MERGE gc where the content is already
+ * integrated. Reusing it for a removal with NO merge gate would let
+ * `brainclaw worktree remove`, without `--force`, silently delete an agent's
+ * uncommitted `.claude/agents/x.md` or a modified tracked `.claude/settings.json`.
+ *
+ * So this lists brainclaw's OWN protocol artifacts by name and nothing else. A
+ * worktree holding anything else — including agent config — still refuses and needs
+ * an explicit force, which is what the pln#647 commit claimed and did not deliver.
+ */
+export function isAutoForcibleDebris(statusZStdout) {
+    const paths = parsePorcelainZ(statusZStdout);
+    if (paths.length === 0)
+        return false;
+    return paths.every((p) => {
+        const norm = p.replace(/\\/g, '/');
+        return norm === '.gitignore' // copied at birth; CRLF-flipped on Windows
+            || norm === '.brainclaw-worktree.json' // sidecar metadata
+            || norm === 'LANE-RESULT.json' // worker outcome report — harvested
+            || norm === 'REVIEW-FINDINGS.md'
+            || norm === 'REVIEW_FINDINGS.md'
+            || norm === 'TRIAGE-REPORT.json'
+            || norm.startsWith('.brainclaw-heartbeat-') // worker liveness sentinel
+            || norm === '.brainclaw' || norm.startsWith('.brainclaw/'); // coordination store
+    });
+}
 /**
  * trp#926 (squash-aware GC) — True when every commit on `branch` that is not
  * an ancestor of `baseRef` has a patch-equivalent commit ALREADY on `baseRef`.

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.20.4 on 2026-08-03T17:19:03.147Z
+// Source: brainclaw v1.22.0 on 2026-08-08T16:03:19.158Z
 export const FACTS = {
-  "version": "1.20.4",
-  "generated_at": "2026-08-03T17:19:03.147Z",
+  "version": "1.22.0",
+  "generated_at": "2026-08-08T16:03:19.158Z",
   "tools": {
     "count": 67,
     "published_count": 65,
@@ -474,7 +474,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-03T17:19:00.995Z",
+    "generated_at": "2026-08-08T16:03:17.056Z",
     "node_version": "v24.18.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -483,7 +483,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": 77,
+        "duration_ms_median": 73,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -491,7 +491,7 @@ 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": 130,
+        "duration_ms_median": 128,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -499,7 +499,7 @@ export const FACTS = {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 12,
+        "duration_ms_median": 14,
         "payload_chars_median": 499,
         "payload_tokens_est_median": 125
       }

package/dist/facts.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.20.4",
-  "generated_at": "2026-08-03T17:19:03.147Z",
+  "version": "1.22.0",
+  "generated_at": "2026-08-08T16:03:19.158Z",
   "tools": {
     "count": 67,
     "published_count": 65,
@@ -472,7 +472,7 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-03T17:19:00.995Z",
+    "generated_at": "2026-08-08T16:03:17.056Z",
     "node_version": "v24.18.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -481,7 +481,7 @@
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 77,
+        "duration_ms_median": 73,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -489,7 +489,7 @@
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 130,
+        "duration_ms_median": 128,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -497,7 +497,7 @@
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 12,
+        "duration_ms_median": 14,
         "payload_chars_median": 499,
         "payload_tokens_est_median": 125
       }