brainclaw 1.8.0 → 1.9.1

package/dist/commands/setup.js

@@ -9,9 +9,8 @@ import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-s
 import { buildMachineProfile, saveMachineProfile, loadMachineProfile } from '../core/machine-profile.js';
 import { buildAgentInventory, saveAgentInventory, loadAgentInventory } from '../core/agent-inventory.js';
 import { ensureClaudeCodeUserSettings, ensureClaudeCodeUserCommand, ensureCursorMcpConfig, ensureWindsurfMcpConfig, ensureAntigravityMcpConfig, ensureContinueUserMcpConfig, ensureContinueUserPermissions, ensureCodexMcpConfig, ensureHermesMcpConfig, writeDetectedAgentAutoConfig, describeAutoConfigWrite, ensureGitignoreEntries, collectWorkspaceGitignoreEntries, BRAINCLAW_EXCLUSIVE_DIRECTORIES, } from '../core/agent-files.js';
-import { MEMORY_DIR, memoryExists, ensureMemoryDir } from '../core/io.js';
-import { saveConfig, defaultConfig } from '../core/config.js';
-import { readSetupState, resolveHomeDir, writeSetupState } from '../core/setup-state.js';
+import { MEMORY_DIR, memoryExists } from '../core/io.js';
+import { ensureUserStore, readSetupState, resolveHomeDir, writeSetupState } from '../core/setup-state.js';
 import { writeDetectedAgentHooks } from './hooks.js';
 export { readSetupState } from '../core/setup-state.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -184,28 +183,11 @@ export function parseAgentSelection(choice, detected, installedAgents = []) {
 export function initUserStore(home, env = process.env) {
     if (!home)
         return [];
-    const written = [];
-    // Ensure ~/.brainclaw/ directory and subdirs exist
-    const userStorePath = path.join(home, '.brainclaw');
-    ensureMemoryDir(home);
-    // Check if config.yaml already exists (idempotent)
-    const configPath = path.join(userStorePath, 'config.yaml');
+    const configPath = path.join(home, '.brainclaw', 'config.yaml');
     if (fs.existsSync(configPath)) {
         return [];
     }
-    try {
-        // Write a minimal config.yaml for the user store
-        const defaultCfg = defaultConfig('user-global');
-        saveConfig(defaultCfg, home);
-        // Append store_type: user to the config.yaml (pattern already used in tests)
-        fs.appendFileSync(configPath, 'store_type: user\n');
-        written.push(configPath);
-    }
-    catch (err) {
-        // Non-fatal: if user store init fails, continue with agent setup
-        console.warn(`Warning: failed to initialize user store at ${configPath}:`, err instanceof Error ? err.message : String(err));
-    }
-    return written;
+    return ensureUserStore(env) ? [configPath] : [];
 }
 export function runGlobalInstall(selectedAgents, env = process.env) {
     const home = resolveHomeDir(env);
@@ -507,11 +489,16 @@ export async function runSetup(options = {}) {
     });
     // Step 3: Repo selection
     let repoChoice;
+    let nonInteractiveDefault = false;
     if (options.repos) {
         repoChoice = options.repos;
     }
     else if (options.yes || !process.stdin.isTTY) {
-        repoChoice = 'all';
+        // Blast-radius guard: never initialise every repo under the roots just
+        // because nobody could be asked. Non-interactive runs default to the
+        // current repo; widening to all requires an explicit --repos all.
+        repoChoice = 'current';
+        nonInteractiveDefault = true;
     }
     else {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -525,6 +512,9 @@ export async function runSetup(options = {}) {
     const selectedRepos = parseRepoSelection(repoChoice, repos);
     if (selectedRepos.length === 0) {
         console.log('No repositories selected. Aborting.');
+        if (nonInteractiveDefault) {
+            console.log('Non-interactive setup defaults to the current directory\'s repo. Pass --repos all to initialise every repo under the roots.');
+        }
         return;
     }
     console.log(`\nSelected ${selectedRepos.length} repository(s).`);
@@ -585,10 +575,19 @@ function resolveVsixPath() {
     const distVsix = path.join(thisDir, '..', 'brainclaw-vscode.vsix');
     if (fs.existsSync(distVsix))
         return distVsix;
-    // 2. Dev mode: vscode-extension/ directory
-    const devVsix = path.join(thisDir, '..', '..', 'vscode-extension', 'brainclaw-vscode-0.1.0.vsix');
-    if (fs.existsSync(devVsix))
-        return devVsix;
+    // 2. Dev mode: pick the newest locally packaged extension.
+    const devDir = path.join(thisDir, '..', '..', 'vscode-extension');
+    if (fs.existsSync(devDir)) {
+        const candidates = fs.readdirSync(devDir)
+            .filter((name) => /^brainclaw-vscode-\d+\.\d+\.\d+\.vsix$/.test(name))
+            .map((name) => {
+            const filePath = path.join(devDir, name);
+            return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        if (candidates[0])
+            return candidates[0].filePath;
+    }
     return undefined;
 }
 //# sourceMappingURL=setup.js.map

package/dist/commands/stale.js

@@ -19,7 +19,12 @@ import { removeEntity, transitionEntity, } from '../core/entity-operations.js';
 import { listRuntimeNotes } from '../core/runtime.js';
 import { loadState } from '../core/state.js';
 import { detectStaleness, staleSummary, } from '../core/staleness.js';
-/** Resolve the canonical transition target (or removal) per entity kind. */
+/**
+ * Resolve the canonical transition target (or removal) per entity kind.
+ * decision/constraint are intentionally absent: they are only flagged for
+ * dead related_paths (pln#557 step 2), and the fix is updating the paths via
+ * bclaw_update — not a lifecycle transition.
+ */
 const RESOLVE_ACTIONS = {
     plan: { kind: 'transition', entity: 'plan', to: 'dropped' },
     handoff: { kind: 'transition', entity: 'handoff', to: 'closed' },
@@ -31,7 +36,11 @@ function buildReport(cwd) {
     const state = loadState(cwd);
     const pending = listCandidates('pending', cwd);
     const notes = listRuntimeNotes(undefined, cwd);
-    return detectStaleness(state.plan_items, state.known_traps, state.open_handoffs, pending, Date.now(), notes);
+    return detectStaleness(state.plan_items, state.known_traps, state.open_handoffs, pending, Date.now(), notes, {
+        decisions: state.recent_decisions,
+        constraints: state.active_constraints,
+        projectRoot: cwd ?? process.cwd(),
+    });
 }
 export function runStaleList(options = {}) {
     const report = buildReport(options.cwd);
@@ -60,6 +69,11 @@ export function runStaleResolve(id, options = {}) {
         process.exit(1);
     }
     const action = RESOLVE_ACTIONS[warning.entity];
+    if (!action) {
+        console.error(`Error: ${warning.entity} ${id} has no canonical stale-resolve action.`);
+        console.error(`Fix it directly instead: ${warning.suggested_action}`);
+        process.exit(1);
+    }
     try {
         if (action.kind === 'transition') {
             const result = transitionEntity(action.entity, id, action.to, cwd, 'resolved via brainclaw stale resolve');

package/dist/commands/switch.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { loadActiveProject, saveActiveProject, clearActiveProject } from '../core/active-project.js';
-import { buildOperationalIdentity, loadCurrentSession, saveCurrentSession } from '../core/identity.js';
+import { buildOperationalIdentity, loadCurrentSession, loadSessionById, saveCurrentSession } from '../core/identity.js';
 import { memoryExists } from '../core/io.js';
 import { resolveProjectRef } from '../core/store-resolution.js';
 import { resolveCrossProjectLinks, resolveProjectCwd } from '../core/cross-project.js';
@@ -44,10 +44,28 @@ export function switchProject(projectRef, options = {}) {
     catch { /* name is optional */ }
     const now = new Date().toISOString();
     const sessionOnly = options.sessionOnly ?? true;
-    let session = loadCurrentSession(cwd);
+    let session = options.sessionId ? loadSessionById(options.sessionId, cwd) : loadCurrentSession(cwd);
     if (!session && sessionOnly) {
-        buildOperationalIdentity(undefined, cwd, { persistImplicitSession: true });
-        session = loadCurrentSession(cwd);
+        if (options.sessionId) {
+            const identity = buildOperationalIdentity(undefined, cwd, {
+                sessionId: options.sessionId,
+                persistImplicitSession: false,
+            });
+            saveCurrentSession({
+                session_id: options.sessionId,
+                started_at: now,
+                last_seen_at: now,
+                agent: identity.agent,
+                agent_id: identity.agent_id,
+                host_id: identity.host_id,
+                user: process.env.USER || process.env.USERNAME || undefined,
+                pid: process.pid,
+            }, cwd);
+        }
+        else {
+            buildOperationalIdentity(undefined, cwd, { persistImplicitSession: true });
+        }
+        session = options.sessionId ? loadSessionById(options.sessionId, cwd) : loadCurrentSession(cwd);
     }
     if (session && sessionOnly) {
         saveCurrentSession({
@@ -78,11 +96,14 @@ export function switchProject(projectRef, options = {}) {
  * List available projects in the workspace.
  */
 export function listAvailableProjects(cwd) {
+    return listAvailableProjectsForSession(cwd);
+}
+export function listAvailableProjectsForSession(cwd, sessionId) {
     const wsRoot = findOutermostWorkspaceRoot(cwd ?? process.cwd());
     if (!wsRoot) {
         throw new Error('No brainclaw workspace found.');
     }
-    const sessionActive = loadCurrentSession(cwd)?.active_project;
+    const sessionActive = (sessionId ? loadSessionById(sessionId, cwd) : loadCurrentSession(cwd))?.active_project;
     const globalActive = loadActiveProject(wsRoot);
     const active = sessionActive ?? globalActive;
     const activeSource = sessionActive ? 'session' : globalActive ? 'global' : 'none';

package/dist/commands/uninstall.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import readline from 'node:readline/promises';
 import { MEMORY_DIR, memoryExists } from '../core/io.js';
 import { BRAINCLAW_SECTION_START, BRAINCLAW_SECTION_END, AGENT_EXPORT_REGISTRY, } from '../core/agent-files.js';
 import { resolveHomeDir } from '../core/setup-state.js';
+import { confirmAction } from './confirm.js';
 /**
  * Remove brainclaw from a project and/or machine.
  *
@@ -29,19 +29,7 @@ async function uninstallProject(cwd, skipConfirm) {
         console.log('No .brainclaw/ found in this project. Nothing to uninstall.');
         return;
     }
-    if (!skipConfirm && process.stdin.isTTY) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-            const answer = (await rl.question('Remove brainclaw from this project? This deletes .brainclaw/ and all generated agent files. [y/N]: ')).trim().toLowerCase();
-            if (answer !== 'y' && answer !== 'yes') {
-                console.log('Aborted.');
-                return;
-            }
-        }
-        finally {
-            rl.close();
-        }
-    }
+    await confirmAction('Remove brainclaw from this project? This deletes .brainclaw/ and all generated agent files.', skipConfirm);
     // Remove .brainclaw/ directory
     const brainclawDir = path.join(cwd, MEMORY_DIR);
     if (fs.existsSync(brainclawDir)) {
@@ -88,17 +76,12 @@ async function uninstallProject(cwd, skipConfirm) {
             }
         }
     }
-    // Remove companion config files
+    // Remove companion files dedicated to brainclaw. Shared JSON configs are
+    // stripped below so uninstall does not delete user-owned settings.
     const companionFiles = [
-        '.mcp.json',
         '.claude/commands/brainclaw.md',
-        '.claude/settings.local.json',
         '.claude/.bclaw-session',
         '.cursor/rules/brainclaw-mcp-shim.mdc',
-        '.vscode/cline_mcp_settings.json',
-        '.roo/mcp.json',
-        '.continue/config.json',
-        'opencode.json',
         '.github/skills/brainclaw-context/SKILL.md',
     ];
     for (const relativePath of companionFiles) {
@@ -108,6 +91,7 @@ async function uninstallProject(cwd, skipConfirm) {
             console.log(`✔ Removed ${relativePath}`);
         }
     }
+    stripProjectCompanionConfigs(cwd);
     console.log('✔ Project uninstall complete.');
 }
 async function uninstallMachine(skipConfirm) {
@@ -121,19 +105,7 @@ async function uninstallMachine(skipConfirm) {
         console.log('No ~/.brainclaw/ found. Nothing to uninstall.');
         return;
     }
-    if (!skipConfirm && process.stdin.isTTY) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-            const answer = (await rl.question('Remove brainclaw global config (~/.brainclaw/)? [y/N]: ')).trim().toLowerCase();
-            if (answer !== 'y' && answer !== 'yes') {
-                console.log('Aborted.');
-                return;
-            }
-        }
-        finally {
-            rl.close();
-        }
-    }
+    await confirmAction('Remove brainclaw global config (~/.brainclaw/)?', skipConfirm);
     fs.rmSync(userStore, { recursive: true, force: true });
     console.log('✔ Removed ~/.brainclaw/');
     // Note: global MCP configs in ~/.claude/settings.json, ~/.cursor/mcp.json etc.
@@ -142,4 +114,124 @@ async function uninstallMachine(skipConfirm) {
     console.log('Remove brainclaw entries manually if needed.');
     console.log('✔ Machine uninstall complete.');
 }
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stripBrainclawKeyedMcp(config) {
+    const servers = isJsonObject(config.mcpServers) ? { ...config.mcpServers } : undefined;
+    if (!servers || !Object.prototype.hasOwnProperty.call(servers, 'brainclaw'))
+        return false;
+    delete servers.brainclaw;
+    if (Object.keys(servers).length === 0) {
+        delete config.mcpServers;
+    }
+    else {
+        config.mcpServers = servers;
+    }
+    return true;
+}
+function stripBrainclawContinueMcp(config) {
+    if (!Array.isArray(config.mcpServers))
+        return false;
+    const next = config.mcpServers.filter((entry) => !(isJsonObject(entry) && entry.name === 'brainclaw'));
+    if (next.length === config.mcpServers.length)
+        return false;
+    if (next.length === 0) {
+        delete config.mcpServers;
+    }
+    else {
+        config.mcpServers = next;
+    }
+    return true;
+}
+function stripBrainclawOpenCodeMcp(config) {
+    const mcp = isJsonObject(config.mcp) ? { ...config.mcp } : undefined;
+    if (!mcp || !Object.prototype.hasOwnProperty.call(mcp, 'brainclaw'))
+        return false;
+    delete mcp.brainclaw;
+    if (Object.keys(mcp).length === 0) {
+        delete config.mcp;
+    }
+    else {
+        config.mcp = mcp;
+    }
+    return true;
+}
+function stripBrainclawClaudePermissions(config, cwd) {
+    const permissions = isJsonObject(config.permissions) ? { ...config.permissions } : undefined;
+    if (!permissions)
+        return false;
+    let changed = false;
+    if (Array.isArray(permissions.allow)) {
+        const next = permissions.allow.filter((entry) => entry !== 'Bash(npx brainclaw:*)' && entry !== 'mcp__brainclaw__*');
+        changed = changed || next.length !== permissions.allow.length;
+        if (next.length === 0) {
+            delete permissions.allow;
+        }
+        else {
+            permissions.allow = next;
+        }
+    }
+    if (Array.isArray(permissions.additionalDirectories)) {
+        const brainclawDirs = new Set([
+            path.join(cwd, '.claude', 'worktrees'),
+            path.join(resolveHomeDir() ?? '', '.brainclaw', 'worktrees'),
+        ].filter(Boolean).map((entry) => path.resolve(entry).replace(/\\/g, '/').toLowerCase()));
+        const next = permissions.additionalDirectories.filter((entry) => {
+            if (typeof entry !== 'string')
+                return true;
+            return !brainclawDirs.has(path.resolve(entry).replace(/\\/g, '/').toLowerCase());
+        });
+        changed = changed || next.length !== permissions.additionalDirectories.length;
+        if (next.length === 0) {
+            delete permissions.additionalDirectories;
+        }
+        else {
+            permissions.additionalDirectories = next;
+        }
+    }
+    if (!changed)
+        return false;
+    if (Object.keys(permissions).length === 0) {
+        delete config.permissions;
+    }
+    else {
+        config.permissions = permissions;
+    }
+    return true;
+}
+function rewriteJsonConfig(relativePath, cwd, strip) {
+    const fullPath = path.join(cwd, relativePath);
+    if (!fs.existsSync(fullPath))
+        return;
+    let config;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+        if (!isJsonObject(parsed))
+            return;
+        config = { ...parsed };
+    }
+    catch {
+        console.log(`! Skipped ${relativePath} (not valid JSON)`);
+        return;
+    }
+    if (!strip(config))
+        return;
+    if (Object.keys(config).length === 0) {
+        fs.unlinkSync(fullPath);
+        console.log(`✔ Removed ${relativePath} (was brainclaw-only)`);
+    }
+    else {
+        fs.writeFileSync(fullPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+        console.log(`✔ Removed brainclaw entries from ${relativePath}`);
+    }
+}
+function stripProjectCompanionConfigs(cwd) {
+    rewriteJsonConfig('.mcp.json', cwd, stripBrainclawKeyedMcp);
+    rewriteJsonConfig('.vscode/cline_mcp_settings.json', cwd, stripBrainclawKeyedMcp);
+    rewriteJsonConfig('.roo/mcp.json', cwd, stripBrainclawKeyedMcp);
+    rewriteJsonConfig('.continue/config.json', cwd, stripBrainclawContinueMcp);
+    rewriteJsonConfig('opencode.json', cwd, stripBrainclawOpenCodeMcp);
+    rewriteJsonConfig('.claude/settings.local.json', cwd, (config) => stripBrainclawClaudePermissions(config, cwd));
+}
 //# sourceMappingURL=uninstall.js.map

package/dist/commands/update-step.js

@@ -14,6 +14,8 @@ export function runUpdateStep(planId, stepId, options) {
             status: options.status,
             text: options.text,
             assignee: options.assign,
+            estimatedEffort: options.estimate,
+            actualEffort: options.actualEffort,
         });
         const changes = [];
         if (options.status)
@@ -22,6 +24,10 @@ export function runUpdateStep(planId, stepId, options) {
             changes.push('text updated');
         if (options.assign !== undefined)
             changes.push(`assignee=${options.assign || 'unassigned'}`);
+        if (options.estimate !== undefined)
+            changes.push(`estimate=${options.estimate}`);
+        if (options.actualEffort !== undefined)
+            changes.push(`actual=${options.actualEffort}`);
         console.log(`✔ Step updated: [${result.stepId}] ${changes.join(', ')}`);
         console.log(`  Plan [${result.planId}] progress: ${result.doneSteps}/${result.totalSteps} steps done`);
         if (result.planAutoCompleted) {

package/dist/commands/version.js

@@ -8,7 +8,7 @@ import { generateAgentReleaseNotes } from './release-notes.js';
 export function runVersion(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const initialized = memoryExists(cwd);
-    let config = initialized ? loadConfig(cwd) : undefined;
+    const config = initialized ? loadConfig(cwd) : undefined;
     let publishedLocalRelease;
     if (options.publishLocal) {
         if (!initialized || !config) {

package/dist/commands/worktree.js

@@ -1,4 +1,5 @@
 import { createWorktree, listWorktrees, removeWorktree, pruneWorktrees, cleanMergedWorktrees, mergeWorktreeBranch, worktreesBaseDir, } from '../core/worktree.js';
+import { analyzeMergeRisk } from '../core/merge-risk.js';
 import { memoryExists } from '../core/io.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
 export function runWorktreeCreate(options) {
@@ -81,6 +82,20 @@ export function runWorktreeClean(options) {
 }
 export function runWorktreeMerge(options) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    // Pre-merge conflict reflex (pln#396): warn if another live lane overlaps
+    // the files this branch would land. Advisory — never blocks the merge.
+    try {
+        const risk = analyzeMergeRisk(cwd, { branches: undefined });
+        const conflicting = risk.overlaps.filter(o => o.branches.includes(options.branch));
+        if (conflicting.length > 0) {
+            console.warn(`⚠ Pre-merge risk: ${options.branch} overlaps ${conflicting.length} file(s) with other live lane(s):`);
+            for (const o of conflicting.slice(0, 10)) {
+                console.warn(`    ${o.file} — also in ${o.branches.filter(b => b !== options.branch).join(', ')}`);
+            }
+            console.warn('  Run `brainclaw worktree check` for the full picture. Proceeding with merge.');
+        }
+    }
+    catch { /* advisory only — never block the merge on the risk probe */ }
     const result = mergeWorktreeBranch(cwd, options.branch, {
         message: options.message,
         dryRun: options.dryRun,
@@ -98,6 +113,51 @@ export function runWorktreeMerge(options) {
     console.log(`✔ Merged ${options.branch} → ${result.commitHash}`);
     console.log(`  ${result.filesChanged} files changed, ${result.filesRestored} parasitic deletion(s) auto-restored.`);
 }
+/**
+ * `brainclaw worktree check` (pln#396) — pre-merge conflict detection across
+ * the parallel lanes. Exit 0 when lanes are disjoint, 3 when overlaps exist
+ * (a distinct non-error code so a supervisor script can gate a batch merge
+ * without treating "risk found" as a crash).
+ */
+export function runWorktreeCheck(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    const report = analyzeMergeRisk(cwd, { baseRef: options.baseRef });
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        if (report.has_risk)
+            process.exitCode = 3;
+        return;
+    }
+    printMergeRiskReport(report);
+    if (report.has_risk)
+        process.exitCode = 3;
+}
+function printMergeRiskReport(report) {
+    console.log(`Pre-merge conflict check (base: ${report.base_ref})`);
+    console.log(`  ${report.summary}`);
+    if (report.lanes.length === 0)
+        return;
+    console.log('\nLanes:');
+    for (const lane of report.lanes) {
+        const who = lane.claim_id
+            ? `${lane.agent ?? 'unknown'} · claim ${lane.claim_id}`
+            : (lane.agent ?? lane.session_id ?? 'unclaimed');
+        const dirtyNote = lane.dirty_files.length ? ` (+${lane.dirty_files.length} uncommitted)` : '';
+        console.log(`  • ${lane.branch} [${who}] — ${lane.changed_files.length} file(s)${dirtyNote}`);
+    }
+    if (report.overlaps.length > 0) {
+        console.log('\n⚠ Overlapping files (potential conflicts on merge):');
+        for (const o of report.overlaps) {
+            console.log(`  ${o.file}`);
+            console.log(`      lanes: ${o.branches.join(', ')}`);
+            if (o.claims.length)
+                console.log(`      claims: ${o.claims.join(', ')}`);
+        }
+        console.log('\nMerge protocol: merge one overlapping lane, then rebase/re-check the others');
+        console.log('before merging them. Disjoint lanes can merge in any order. See');
+        console.log('docs/concepts/parallel-merge-protocol.md.');
+    }
+}
 /** Returns WorktreeInfo[] for use by MCP tools. */
 export function getWorktrees(cwd) {
     return listWorktrees(cwd);

package/dist/core/actions.js

@@ -7,6 +7,7 @@ import { nowISO, generateIdWithLabel } from './ids.js';
 import { ActionRequiredSchema, } from './schema.js';
 import { saveVersionedJsonFile } from './migration.js';
 import { appendAuditEntry } from './audit.js';
+import { emitRegistryPostImage, registryFaultPoint } from './events/registry-post-image.js';
 import { createRuntimeEvent } from './events.js';
 import { loadAssignment, transitionAssignment } from './assignments.js';
 import { loadAgentRun, transitionAgentRun } from './agentruns.js';
@@ -119,10 +120,12 @@ function expireStaleActions(actions, cwd) {
     }
     return actions;
 }
-export function listActionRequired(cwd, filter = {}) {
+export function listActionRequired(cwd, filter = {}, options = {}) {
     let actions = actionStore(cwd).list();
     // Sweep-on-read: expire stale pending actions
-    actions = expireStaleActions(actions, cwd);
+    if (options.expireStale !== false) {
+        actions = expireStaleActions(actions, cwd);
+    }
     if (filter.status)
         actions = actions.filter((action) => action.status === filter.status);
     if (filter.kind)
@@ -145,7 +148,13 @@ function saveActionRequired(action, cwd) {
     mutate({ cwd }, () => {
         ensureActionsDir(cwd);
         const filepath = path.join(actionsDir(cwd, 'write'), `${action.id}.json`);
-        saveVersionedJsonFile('action_required', filepath, ActionRequiredSchema.parse(action));
+        const parsed = ActionRequiredSchema.parse(action);
+        // pln#568 (I2): journal the post-image BEFORE the projection write. The
+        // action family journals under item_type 'state' (the observer's slot).
+        const created = !fs.existsSync(filepath);
+        emitRegistryPostImage('action', parsed, { created, agent: parsed.agent, agent_id: parsed.agent_id, session_id: parsed.session_id, cwd });
+        registryFaultPoint('after_registry_journal');
+        saveVersionedJsonFile('action_required', filepath, parsed);
     });
 }
 export function createActionRequired(options, cwd) {

package/dist/core/agent-capability.js

@@ -4,14 +4,12 @@
  * integration depth, and pressure level accordingly.
  *
  * Three profile tiers drive instruction file templates:
- *   A (full)    — MCP + hooks → lightweight instructions (context via hooks/MCP)
- *   B (standard) — MCP, no hooks → working rules + architecture + top traps
- *   C (limited) — no MCP → rich static content (plans, traps, decisions)
+ *   A (full)      — managed MCP/native surfaces → lightweight instructions
+ *   B (standard)  — MCP with fewer automation surfaces → more directive rules
+ *   C (limited)   — no MCP → rich static content (plans, traps, decisions)
  *
- * Tier A agents (as of 2026-04): Claude Code, Copilot, Codex, Cursor,
- * Windsurf (12 hooks!), Cline (macOS/Linux only).
- * Note: Cline hooks don't work on Windows — but templateTier stays A
- * because brainclaw generates hooks that gracefully degrade.
+ * Hook support is declared separately through `hasHooks` and `runtime.hooks`.
+ * Do not infer hooks from `templateTier`.
  */
 import os from 'node:os';
 import path from 'node:path';
@@ -25,9 +23,21 @@ const AGENT_ALIASES = {
     'vibe': 'mistral-vibe',
     'hermes-agent': 'hermes',
 };
-/** Resolve an alias to its canonical agent name, or return the input unchanged. */
+/**
+ * Resolve an alias to its canonical agent name (case-insensitive).
+ *
+ * Agent names are case-insensitive: every canonical profile key and every alias
+ * is lowercase, so we trim + lowercase the input before resolving. This is the
+ * single normalization point — registry, messaging, spawn-check and the
+ * coordinate/dispatch pre-flight all route through here, so a target like
+ * "Codex" or "Gemini" resolves identically to "codex" / "gemini". Without it the
+ * dispatch pre-flight collapsed an unresolved name into "no CLI spawn template
+ * (IDE-only?)" and silently dropped the reviewer (github-copilot/Gemini hit this
+ * passing targetAgents=["Codex"]).
+ */
 export function resolveAgentAlias(name) {
-    return AGENT_ALIASES[name] ?? name;
+    const key = name.trim().toLowerCase();
+    return AGENT_ALIASES[key] ?? key;
 }
 const PROFILES = {
     // --- Code agents (interactive, IDE-driven) ---
@@ -77,20 +87,20 @@ const PROFILES = {
     },
     windsurf: {
         name: 'windsurf', category: 'code-agent', workflowModel: 'interactive',
-        hasMcp: true, hasHooks: true, hasAutoApprove: false, hasSkills: true, hasRules: true,
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: false, hasRules: true,
         instructionFile: '.windsurfrules', sharedInstructionFile: true, mcpConfigScope: 'machine', templateTier: 'A',
         role_capabilities: ['execute', 'review'],
-        runtime: { mcp_direct: true, hooks: true, canBeSpawnedCli: false, canSpawnOtherCli: false, inbox: false },
+        runtime: { mcp_direct: true, hooks: false, canBeSpawnedCli: false, canSpawnOtherCli: false, inbox: false },
         max_concurrent_tasks: 1,
         prompt_delivery: { methods: ['inbox_structured'], preferred: 'inbox_structured' },
         execution_env: { surface: 'ide' },
     },
     cline: {
         name: 'cline', category: 'code-agent', workflowModel: 'interactive',
-        hasMcp: true, hasHooks: true, hasAutoApprove: true, hasSkills: true, hasRules: true,
+        hasMcp: true, hasHooks: false, hasAutoApprove: true, hasSkills: false, hasRules: true,
         instructionFile: '.clinerules/brainclaw.md', sharedInstructionFile: false, mcpConfigScope: 'project', templateTier: 'A',
         role_capabilities: ['execute', 'review'],
-        runtime: { mcp_direct: true, hooks: true, canBeSpawnedCli: true, canSpawnOtherCli: false, inbox: true },
+        runtime: { mcp_direct: true, hooks: false, canBeSpawnedCli: true, canSpawnOtherCli: false, inbox: true },
         max_concurrent_tasks: 3,
         prompt_delivery: { methods: ['inline_arg', 'inbox_structured'], preferred: 'inline_arg', max_inline_length: 8000 },
         execution_env: { surface: 'extension' },
@@ -143,10 +153,10 @@ const PROFILES = {
     // worktree. The coordinator then syncs them via bclaw_harvest_candidates.
     codex: {
         name: 'codex', category: 'code-agent', workflowModel: 'task-based',
-        hasMcp: true, hasHooks: true, hasAutoApprove: false, hasSkills: true, hasRules: true,
+        hasMcp: true, hasHooks: false, hasAutoApprove: false, hasSkills: true, hasRules: true,
         instructionFile: 'AGENTS.md', sharedInstructionFile: true, mcpConfigScope: 'machine', templateTier: 'A',
         role_capabilities: ['execute', 'review'],
-        runtime: { mcp_direct: true, hooks: true, canBeSpawnedCli: true, canSpawnOtherCli: false, inbox: true },
+        runtime: { mcp_direct: true, hooks: false, canBeSpawnedCli: true, canSpawnOtherCli: false, inbox: true },
         max_concurrent_tasks: 5,
         // pln#475: prefer stdin_pipe to avoid Windows cmd.exe arg-parsing breaking
         // long prompts. codex.cmd resolves through cmd shell, where embedded
@@ -316,7 +326,10 @@ const _customProfiles = new Map();
  * Custom profiles take precedence over DEFAULT_CAPABILITY_PROFILES on lookup.
  */
 export function registerCapabilityProfile(profile) {
-    _customProfiles.set(profile.name, profile);
+    // Key by the normalized (lowercased) name so lookups through the
+    // case-insensitive resolveAgentAlias match regardless of the casing the
+    // registrant used.
+    _customProfiles.set(profile.name.trim().toLowerCase(), profile);
 }
 /**
  * Get the capability profile for an agent by name.
@@ -669,7 +682,7 @@ export function resolveBriefMode(agentName) {
  * pln#528 — capability matrix DERIVED from the spawn template, so it stays in
  * sync with how each agent is actually invoked (no per-profile duplication).
  *
- * The motivating reality (debrief LeaseUp): codex is spawned with
+ * The motivating reality (a cross-project field debrief): codex is spawned with
  * `--sandbox workspace-write`, which (a) does NOT wire the brainclaw MCP server
  * and (b) puts `.git` outside the sandbox root — so a sandboxed worker can
  * neither call `bclaw_*` nor `git commit`, regardless of the profile's nominal