brainclaw 0.29.2 → 1.5.3

package/dist/commands/upgrade.js

@@ -1,13 +1,24 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { ensureMemoryDir, memoryDir, memoryExists } from '../core/io.js';
+import { spawnSync } from 'node:child_process';
+import { ensureMemoryDir, memoryDir, memoryExists, storeLockPath } from '../core/io.js';
 import { loadState, persistState } from '../core/state.js';
 import { scanMigrationStatus } from '../core/migration.js';
 import { commitMemoryChange, initMemoryRepo } from '../core/memory-git.js';
-import { BRAINCLAW_SECTION_END, BRAINCLAW_SECTION_START, buildBrainclawSection, buildClaudeCodeCommandText, ensureClaudeCodeCommand, hasBrainclawSection, } from '../core/agent-files.js';
+import { BRAINCLAW_SECTION_END, BRAINCLAW_SECTION_START, buildBrainclawSection, buildClaudeCodeCommandText, ensureClaudeCodeCommand, hasBrainclawSection, patchAllMcpConfigs, } from '../core/agent-files.js';
 import { loadConfig } from '../core/config.js';
+import { checkBrainclawInstallableUpdate, getInstalledBrainclawVersion } from '../core/brainclaw-version.js';
+import { resolvePrimaryStore } from '../core/store-resolution.js';
+import { BackupError, createBackup, listBackups, restoreBackup, } from '../core/upgrades/backup.js';
+import { archivePendingCandidates, } from '../core/upgrades/patches/candidate-archive.js';
+import { stripHandoffReview, } from '../core/upgrades/patches/handoff-review-strip.js';
+import { rolloutProvenance, } from '../core/upgrades/patches/provenance-rollout.js';
+import { IMPLICIT_BASELINE_VERSION, KNOWN_STORE_SCHEMA_VERSIONS, V1_TARGET_SCHEMA_VERSION, bumpSchemaVersion, readSchemaVersion, } from '../core/upgrades/schema-version.js';
+import { withLock } from '../core/lock.js';
 import { renderAgentExportForAgent, writeAgentExportForAgent } from './export.js';
 import { generateCursorHook, writeHook } from './hooks.js';
+/** Schema target versions supported by `brainclaw upgrade --to=<version>`. */
+export const SUPPORTED_SCHEMA_TARGETS = ['1.0'];
 /**
  * Entity directory layout mapping: legacy flat name → entity-aligned path.
  * Must match ENTITY_DIR_MAP in io.ts.
@@ -18,6 +29,7 @@ const ENTITY_DIRS = [
     { legacy: 'traps', entity: 'memory/traps' },
     { legacy: 'instructions', entity: 'memory/instructions' },
     { legacy: 'plans', entity: 'coordination/plans' },
+    { legacy: 'sequences', entity: 'coordination/sequences' },
     { legacy: 'claims', entity: 'coordination/claims' },
     { legacy: 'handoffs', entity: 'coordination/handoffs' },
     { legacy: 'sessions', entity: 'coordination/sessions' },
@@ -35,15 +47,137 @@ const WORKSPACE_EXPORT_REFRESH_AGENTS = [
 ];
 export function runUpgrade(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    if (!memoryExists(cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+    // Take the common store-wide mutation lock for the whole
+    // upgrade/rollback cycle so normal writers cannot race the park/swap
+    // window. The lock target lives alongside `.brainclaw/`, not inside
+    // it, so it survives rename-based swaps.
+    const lockPath = storeLockPath(cwd);
+    try {
+        withLock(lockPath, () => {
+            if (!memoryExists(cwd)) {
+                console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+                process.exit(1);
+            }
+            runUpgradeInner(cwd, options);
+        });
+    }
+    catch (error) {
+        const message = error.message;
+        if (message.startsWith('Could not acquire lock')) {
+            console.error('Error: another brainclaw store mutation or upgrade is in progress. Retry once it completes.');
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+function runUpgradeInner(cwd, options) {
+    // Rollback short-circuit: restore the most recent backup, park the
+    // current live store, and exit. Runs before any other upgrade work.
+    if (options.rollback) {
+        runRollback(cwd, options);
+        return;
+    }
+    // Validate --to target before touching anything.
+    if (options.to && !SUPPORTED_SCHEMA_TARGETS.includes(options.to)) {
+        console.error(`Error: unsupported schema target "${options.to}". Supported: ${SUPPORTED_SCHEMA_TARGETS.join(', ')}`);
         process.exit(1);
     }
+    if (options.to && options.backup === false && !options.dryRun) {
+        console.error(`Error: --to=${options.to} requires a backup. Remove --no-backup or re-run with --dry-run.`);
+        process.exit(1);
+    }
+    // Backup pass: create a timestamped backup before any modification.
+    // Explicit --backup always triggers it; schema-targeted upgrades are
+    // forced to carry a recovery point on real runs.
+    const backupRequested = options.to !== undefined || options.backup === true;
+    let backupHandle;
+    if (backupRequested && !options.dryRun) {
+        try {
+            backupHandle = createUpgradeBackup(cwd, options);
+        }
+        catch (error) {
+            const message = error instanceof BackupError ? error.message : error.message;
+            console.error(`Error: backup failed — ${message}`);
+            console.error('Aborting upgrade. No changes made.');
+            process.exit(1);
+        }
+        if (!options.json) {
+            console.log(`✔ Backup created at ${backupHandle.backupPath}`);
+        }
+    }
+    else if (backupRequested && options.dryRun && !options.json) {
+        console.log('(dry run — would create backup before upgrade)');
+    }
+    // One-shot v1.0 schema patches. Runs only when --to=<version> is set.
+    // Each patch is idempotent — re-running after success is a no-op.
+    const schemaPatchResults = {};
+    if (options.to === '1.0') {
+        schemaPatchResults.candidateArchive = runCandidateArchivePatch(cwd, options);
+        schemaPatchResults.handoffReviewStrip = runHandoffReviewStripPatch(cwd, options);
+        schemaPatchResults.provenanceRollout = runProvenanceRolloutPatch(cwd, options);
+        // Schema-version bump runs last, only after every patch succeeded.
+        // If an earlier patch threw, we never reach here — the store keeps
+        // its prior version and the backup remains the recovery path.
+        schemaPatchResults.schemaVersionBump = runSchemaVersionBump(cwd, options);
+    }
+    // Self-update: install a newer brainclaw version from npm/local-pack before upgrading memory
+    if (options.selfUpdate && !options.dryRun) {
+        const config = loadConfig(cwd);
+        const updateCheck = checkBrainclawInstallableUpdate(config, cwd, { useDefaultNpmSource: true });
+        if (updateCheck.status === 'update_available' && updateCheck.install_command) {
+            const installedVersion = getInstalledBrainclawVersion();
+            if (!options.json) {
+                console.log(`📦 New version available: ${updateCheck.latest_installable_version} (current: ${installedVersion})`);
+                console.log(`   Running: ${updateCheck.install_command}`);
+            }
+            if (!options.dryRun) {
+                const parts = updateCheck.install_command.split(' ');
+                const result = spawnSync(parts[0], parts.slice(1), { stdio: 'inherit', encoding: 'utf-8' });
+                if (result.status !== 0) {
+                    console.error('Error: install command failed. Check output above.');
+                    if (!options.json) {
+                        console.error(`  Re-run manually: ${updateCheck.install_command}`);
+                    }
+                    process.exit(1);
+                }
+                if (!options.json) {
+                    console.log(`✔ Brainclaw updated to ${updateCheck.latest_installable_version}`);
+                    console.log('  MCP servers using this installation will need a restart.');
+                    console.log('  In Claude Code: use /restart or restart the MCP session.');
+                }
+            }
+            else {
+                if (!options.json) {
+                    console.log(`  (dry run — would run: ${updateCheck.install_command})`);
+                }
+            }
+        }
+        else if (updateCheck.status === 'up_to_date') {
+            if (!options.json) {
+                console.log(`✔ Brainclaw is already up to date (${getInstalledBrainclawVersion()})`);
+            }
+        }
+        else {
+            if (!options.json) {
+                console.log(`ℹ No installable update found (${updateCheck.status})`);
+            }
+        }
+        if (!options.json)
+            console.log('');
+    }
+    else if (options.selfUpdate && options.dryRun && !options.json) {
+        console.log('(dry run — skipping self-update check)');
+        console.log('');
+    }
     const base = memoryDir(cwd);
     const actions = [];
     let movedFiles = 0;
-    // Phase 1: Ensure entity-aligned directories exist
-    ensureMemoryDir(cwd);
+    // Phase 1: Ensure entity-aligned directories exist. Skipped in
+    // dry-run so the command is truly side-effect free — without this
+    // gate, ensureMemoryDir creates entity subdirs on first pass.
+    if (!options.dryRun) {
+        ensureMemoryDir(cwd);
+    }
     // Phase 2: Detect and plan file migrations (legacy → entity)
     for (const { legacy, entity } of ENTITY_DIRS) {
         const legacyDir = path.join(base, legacy);
@@ -117,6 +251,8 @@ export function runUpgrade(options = {}) {
         persistState(state, cwd);
     }
     const refreshedAgentFiles = refreshManagedWorkspaceAgentFiles(cwd);
+    // Patch all MCP config files to use the newly resolved brainclaw binary
+    const patchedMcpConfigs = patchAllMcpConfigs(cwd);
     // Clean up empty legacy directories (recursively removes empty subdirs first)
     let removedDirs = 0;
     for (const { legacy } of ENTITY_DIRS) {
@@ -133,6 +269,8 @@ export function runUpgrade(options = {}) {
         `${outdated.length} schema(s) migrated`,
         `${refreshedAgentFiles.length} managed agent file(s) refreshed`,
     ];
+    if (patchedMcpConfigs.length > 0)
+        parts.push(`${patchedMcpConfigs.length} MCP config(s) patched`);
     if (removedDirs > 0)
         parts.push(`${removedDirs} empty legacy dir(s) removed`);
     console.log(`✔ Upgrade complete: ${parts.join(', ')}.`);
@@ -379,4 +517,173 @@ function outputJson(actions, dryRun) {
         actions,
     }, null, 2));
 }
+function runSchemaVersionBump(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        console.error(`Error: no .brainclaw/ store resolved from ${cwd}`);
+        process.exit(1);
+    }
+    const result = bumpSchemaVersion({
+        storePath: store.storePath,
+        to: V1_TARGET_SCHEMA_VERSION,
+        patches: ['candidate_archive', 'handoff_review_strip', 'provenance_rollout'],
+        reason: 'brainclaw upgrade --to=1.0 migration complete',
+        dryRun: options.dryRun ?? false,
+    });
+    if (!options.json) {
+        if (result.status === 'noop') {
+            console.log(`✔ Schema version: already at ${result.to} (no bump needed).`);
+        }
+        else if (result.status === 'planned') {
+            console.log(`(dry run — would bump schema ${result.from} → ${result.to})`);
+        }
+        else {
+            console.log(`✔ Schema version: bumped ${result.from} → ${result.to}. Marker at ${result.filePath}`);
+        }
+    }
+    return result;
+}
+function runProvenanceRolloutPatch(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        console.error(`Error: no .brainclaw/ store resolved from ${cwd}`);
+        process.exit(1);
+    }
+    const result = rolloutProvenance({
+        storePath: store.storePath,
+        dryRun: options.dryRun ?? false,
+    });
+    if (!options.json) {
+        if (result.status === 'noop') {
+            console.log(`✔ Provenance rollout (P6.3): ${result.scanned} record(s) scanned, all already carry provenance.`);
+        }
+        else if (result.status === 'planned') {
+            console.log(`(dry run — would stamp legacy provenance on ${result.stamped.length} of ${result.scanned} record(s))`);
+        }
+        else {
+            const breakdown = Object.entries(result.countsByKind)
+                .map(([k, c]) => `${k}:${c}`)
+                .join(', ');
+            console.log(`✔ Provenance rollout (P6.3): ${result.stamped.length} of ${result.scanned} record(s) stamped legacy (${breakdown}). Log at ${result.logPath}`);
+        }
+    }
+    return result;
+}
+function runHandoffReviewStripPatch(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        console.error(`Error: no .brainclaw/ store resolved from ${cwd}`);
+        process.exit(1);
+    }
+    const result = stripHandoffReview({
+        storePath: store.storePath,
+        dryRun: options.dryRun ?? false,
+    });
+    if (!options.json) {
+        if (result.status === 'noop') {
+            console.log(`✔ Handoff review-strip (P6.1): ${result.scanned} handoff(s) scanned, none carry a review block.`);
+        }
+        else if (result.status === 'planned') {
+            console.log(`(dry run — would strip review from ${result.stripped.length} handoff(s) out of ${result.scanned} scanned)`);
+        }
+        else {
+            console.log(`✔ Handoff review-strip (P6.1): ${result.stripped.length} of ${result.scanned} handoff(s) rewritten. Log at ${result.logPath}`);
+        }
+    }
+    return result;
+}
+function runCandidateArchivePatch(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        console.error(`Error: no .brainclaw/ store resolved from ${cwd}`);
+        process.exit(1);
+    }
+    const result = archivePendingCandidates({
+        storePath: store.storePath,
+        dryRun: options.dryRun ?? false,
+    });
+    if (!options.json) {
+        if (result.status === 'noop') {
+            console.log('✔ Candidate archive (P6.6): no pending candidates to archive.');
+        }
+        else if (result.status === 'planned') {
+            console.log(`(dry run — would archive ${result.moved.length} pending candidate(s) to ${result.archiveDir})`);
+        }
+        else {
+            console.log(`✔ Candidate archive (P6.6): ${result.moved.length} pending candidate(s) archived to ${result.archiveDir}`);
+        }
+    }
+    return result;
+}
+function createUpgradeBackup(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        throw new BackupError('no_store', `No .brainclaw/ store resolved from ${cwd}`);
+    }
+    const note = options.to
+        ? `brainclaw upgrade --to=${options.to}`
+        : 'brainclaw upgrade';
+    return createBackup({
+        storePath: store.storePath,
+        note,
+        storeSchemaVersion: readSchemaVersion(store.storePath).current,
+    });
+}
+function runRollback(cwd, options) {
+    const store = resolvePrimaryStore(cwd);
+    if (!store) {
+        console.error(`Error: no .brainclaw/ store resolved from ${cwd}`);
+        process.exit(1);
+    }
+    const backups = listBackups(store.storePath);
+    if (backups.length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify({ status: 'noop', reason: 'no_backups', store_path: store.storePath }, null, 2));
+        }
+        else {
+            console.error(`Error: no backups found next to ${store.storePath}. Nothing to roll back.`);
+        }
+        process.exit(1);
+    }
+    const target = backups[0];
+    if (options.dryRun) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'dry_run',
+                backup_path: target.backupPath,
+                created_at: target.manifest.created_at,
+            }, null, 2));
+        }
+        else {
+            console.log(`(dry run — would restore ${target.backupPath} created ${target.manifest.created_at})`);
+        }
+        return;
+    }
+    try {
+        const result = restoreBackup({
+            storePath: store.storePath,
+            backupPath: target.backupPath,
+            acceptSchemaVersions: [...KNOWN_STORE_SCHEMA_VERSIONS],
+        });
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'rolled_back',
+                store_path: store.storePath,
+                backup_path: target.backupPath,
+                parked_path: result.parkedPath,
+                created_at: target.manifest.created_at,
+            }, null, 2));
+        }
+        else {
+            console.log(`✔ Rolled back to ${target.backupPath} (created ${target.manifest.created_at})`);
+            console.log(`  Restored schema version ${target.manifest.store_schema_version ?? IMPLICIT_BASELINE_VERSION}`);
+            console.log(`  Previous live store parked at ${result.parkedPath}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof BackupError ? error.message : error.message;
+        console.error(`Error: rollback failed — ${message}`);
+        process.exit(1);
+    }
+}
 //# sourceMappingURL=upgrade.js.map

package/dist/commands/usage.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { memoryDir } from '../core/io.js';
+export function runUsage(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const usagePath = path.join(memoryDir(cwd), 'usage.jsonl');
+    if (!fs.existsSync(usagePath)) {
+        if (options.json) {
+            console.log(JSON.stringify({ records: 0, message: 'No usage data yet. MCP tool calls will be tracked automatically.' }));
+        }
+        else {
+            console.log('No usage data yet. MCP tool calls will be tracked automatically.');
+        }
+        return;
+    }
+    const lines = fs.readFileSync(usagePath, 'utf-8').split('\n').filter(Boolean);
+    const cutoff = options.days ? Date.now() - options.days * 86_400_000 : 0;
+    const records = [];
+    for (const line of lines) {
+        try {
+            const r = JSON.parse(line);
+            if (cutoff && Date.parse(r.ts) < cutoff)
+                continue;
+            if (options.agent && r.agent !== options.agent)
+                continue;
+            if (options.tool && r.tool !== options.tool)
+                continue;
+            records.push(r);
+        }
+        catch { /* skip malformed */ }
+    }
+    if (records.length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify({ records: 0, filters: { agent: options.agent, tool: options.tool, days: options.days } }));
+        }
+        else {
+            console.log('No matching usage records.');
+        }
+        return;
+    }
+    // Aggregate by agent → tool
+    const byAgent = {};
+    for (const r of records) {
+        const agentKey = r.agent ?? 'unknown';
+        if (!byAgent[agentKey]) {
+            byAgent[agentKey] = { calls: 0, total_chars: 0, total_tokens_est: 0, tools: {} };
+        }
+        const agent = byAgent[agentKey];
+        agent.calls++;
+        agent.total_chars += r.chars;
+        agent.total_tokens_est += r.tokens_est;
+        if (!agent.tools[r.tool]) {
+            agent.tools[r.tool] = { calls: 0, total_chars: 0, total_tokens_est: 0, errors: 0 };
+        }
+        const tool = agent.tools[r.tool];
+        tool.calls++;
+        tool.total_chars += r.chars;
+        tool.total_tokens_est += r.tokens_est;
+        if (r.is_error)
+            tool.errors++;
+    }
+    const totalChars = records.reduce((s, r) => s + r.chars, 0);
+    const totalTokens = records.reduce((s, r) => s + r.tokens_est, 0);
+    if (options.json) {
+        console.log(JSON.stringify({
+            records: records.length,
+            total_chars: totalChars,
+            total_tokens_est: totalTokens,
+            by_agent: byAgent,
+            filters: { agent: options.agent, tool: options.tool, days: options.days },
+        }, null, 2));
+        return;
+    }
+    // Render table
+    const periodLabel = options.days ? `last ${options.days} day(s)` : 'all time';
+    console.log(`Brainclaw context usage (${periodLabel}) — ${records.length} MCP call(s)\n`);
+    console.log(`  Total: ${formatChars(totalChars)} (~${formatTokens(totalTokens)} tokens)\n`);
+    for (const [agentName, stats] of Object.entries(byAgent).sort((a, b) => b[1].total_tokens_est - a[1].total_tokens_est)) {
+        console.log(`  ${agentName}: ${stats.calls} calls, ${formatChars(stats.total_chars)} (~${formatTokens(stats.total_tokens_est)} tokens)`);
+        const sortedTools = Object.entries(stats.tools).sort((a, b) => b[1].total_tokens_est - a[1].total_tokens_est);
+        for (const [toolName, toolStats] of sortedTools) {
+            const errSuffix = toolStats.errors > 0 ? ` (${toolStats.errors} errors)` : '';
+            const shortName = toolName.replace(/^bclaw_/, '');
+            console.log(`    ${shortName}: ${toolStats.calls}× ${formatChars(toolStats.total_chars)}${errSuffix}`);
+        }
+    }
+}
+function formatChars(chars) {
+    if (chars < 1000)
+        return `${chars} chars`;
+    if (chars < 1_000_000)
+        return `${(chars / 1000).toFixed(1)}K chars`;
+    return `${(chars / 1_000_000).toFixed(2)}M chars`;
+}
+function formatTokens(tokens) {
+    if (tokens < 1000)
+        return `${tokens}`;
+    if (tokens < 1_000_000)
+        return `${(tokens / 1000).toFixed(1)}K`;
+    return `${(tokens / 1_000_000).toFixed(2)}M`;
+}
+//# sourceMappingURL=usage.js.map

package/dist/commands/version.js

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { loadConfig, saveConfig } from '../core/config.js';
 import { memoryExists } from '../core/io.js';
 import { assessBrainclawVersion, checkBrainclawInstallableUpdate, DEFAULT_LOCAL_RELEASE_MANIFEST_PATH, publishLocalBrainclawRelease, } from '../core/brainclaw-version.js';
+import { AgentReleaseNotesSchema } from '../core/schema.js';
+import { generateAgentReleaseNotes } from './release-notes.js';
 export function runVersion(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const initialized = memoryExists(cwd);
@@ -13,9 +15,27 @@ export function runVersion(options = {}) {
             console.error('Error: local release publishing requires an initialized Brainclaw project.');
             process.exit(1);
         }
+        let parsedAgentNotes;
+        if (options.autoReleaseNotes && !options.agentReleaseNotes) {
+            parsedAgentNotes = generateAgentReleaseNotes(cwd);
+        }
+        if (options.agentReleaseNotes) {
+            try {
+                const raw = typeof options.agentReleaseNotes === 'string'
+                    ? JSON.parse(options.agentReleaseNotes)
+                    : options.agentReleaseNotes;
+                parsedAgentNotes = AgentReleaseNotesSchema.parse(raw);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`Error: --agent-release-notes is not valid JSON or does not match the expected schema: ${message}`);
+                process.exit(1);
+            }
+        }
         try {
             publishedLocalRelease = publishLocalBrainclawRelease(cwd, {
                 releaseNotes: options.releaseNotes,
+                agentReleaseNotes: parsedAgentNotes,
             });
             config.brainclaw_update_source = {
                 type: 'local-pack',

package/dist/commands/who.js

@@ -1,5 +1,6 @@
 import { loadAllSessions, gcStaleSessions } from '../core/identity.js';
 import { listClaims } from '../core/claims.js';
+import { resolveStoreChain } from '../core/store-resolution.js';
 export function runWho(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     if (options.gc) {
@@ -18,7 +19,29 @@ export function runWho(options = {}) {
     const sessions = options.all
         ? allSessions
         : allSessions.filter(s => (now - Date.parse(s.last_seen_at)) <= ttlMs);
-    const activeClaims = listClaims(cwd).filter(c => c.status === 'active');
+    let activeClaims;
+    if (options.localOnly) {
+        activeClaims = listClaims(cwd).filter(c => c.status === 'active');
+    }
+    else {
+        const chain = resolveStoreChain(cwd);
+        const seenIds = new Set();
+        activeClaims = [];
+        for (const store of chain) {
+            try {
+                for (const claim of listClaims(store.cwd)) {
+                    if (claim.status === 'active' && !seenIds.has(claim.id)) {
+                        seenIds.add(claim.id);
+                        activeClaims.push(claim);
+                    }
+                }
+            }
+            catch { /* skip unreadable stores */ }
+        }
+        if (activeClaims.length === 0 && chain.length === 0) {
+            activeClaims = listClaims(cwd).filter(c => c.status === 'active');
+        }
+    }
     const enriched = sessions.map(s => {
         const age = now - Date.parse(s.last_seen_at);
         const stale = age > ttlMs;
@@ -30,8 +53,11 @@ export function runWho(options = {}) {
             agent: s.agent,
             agent_id: s.agent_id,
             host_id: s.host_id,
+            model: s.model ?? null,
             project: s.active_project?.name ?? s.active_project?.path ?? null,
-            claims: activeClaims.filter(c => c.agent_id === s.agent_id).length,
+            branch: s.branch ?? null,
+            isolation_mode: s.isolation_mode ?? 'shared-checkout',
+            claims: activeClaims.filter(c => c.session_id === s.session_id || (!c.session_id && c.agent_id === s.agent_id)).length,
             started_at: s.started_at,
             last_seen_at: s.last_seen_at,
             status,
@@ -47,15 +73,17 @@ export function runWho(options = {}) {
         return;
     }
     // Table header
-    const header = ['USER', 'AGENT', 'PROJECT', 'CLAIMS', 'STATUS', 'LAST SEEN'];
+    const header = ['USER', 'AGENT', 'MODEL', 'BRANCH', 'CLAIMS', 'STATUS', 'LAST SEEN'];
     const rows = [];
     for (const s of enriched) {
         const age = now - Date.parse(s.last_seen_at);
-        const project = s.project ?? '(workspace root)';
+        const model = s.model ?? '-';
+        const branch = s.branch ?? '-';
         rows.push([
             s.user,
             s.agent,
-            project.length > 25 ? project.slice(0, 22) + '...' : project,
+            model.length > 20 ? model.slice(0, 17) + '...' : model,
+            branch.length > 20 ? branch.slice(0, 17) + '...' : branch,
             String(s.claims),
             s.status,
             formatAge(age),

package/dist/commands/worktree.js

@@ -0,0 +1,105 @@
+import { createWorktree, listWorktrees, removeWorktree, pruneWorktrees, cleanMergedWorktrees, mergeWorktreeBranch, worktreesBaseDir, } from '../core/worktree.js';
+import { memoryExists } from '../core/io.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+export function runWorktreeCreate(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    try {
+        const worktreePath = createWorktree(cwd, options.branch, {
+            sessionId: options.sessionId,
+            agent: options.agent,
+        });
+        console.log(`✔ Worktree created: ${worktreePath}`);
+        console.log(`  Branch: ${options.branch}`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+export function runWorktreeList(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const worktrees = listWorktrees(cwd);
+    if (worktrees.length === 0) {
+        console.log('No worktrees found.');
+        return;
+    }
+    const managed = worktreesBaseDir(cwd);
+    console.log(`Worktrees (managed under ${managed}):\n`);
+    for (const wt of worktrees) {
+        const tag = wt.session_id ? ` [session: ${wt.session_id}]` : '';
+        const agentTag = wt.agent ? ` [agent: ${wt.agent}]` : '';
+        console.log(`  ${wt.path}`);
+        console.log(`    branch: ${wt.branch}  commit: ${wt.commit.slice(0, 8)}${tag}${agentTag}`);
+    }
+}
+export function runWorktreeRemove(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    try {
+        removeWorktree(cwd, options.path, { force: options.force });
+        console.log(`✔ Worktree removed: ${options.path}`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+export function runWorktreePrune(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    pruneWorktrees(cwd);
+    console.log('✔ Worktree stale entries pruned.');
+}
+export function runWorktreeClean(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    const result = cleanMergedWorktrees(cwd, {
+        force: options.force,
+        dryRun: options.dryRun,
+    });
+    if (result.removed.length === 0 && result.skipped.length === 0) {
+        console.log('✔ No merged or orphan worktrees to clean.');
+        return;
+    }
+    const verb = options.dryRun ? 'Would remove' : 'Removed';
+    for (const p of result.removed) {
+        console.log(`${options.dryRun ? '  (dry-run)' : '  ✔'} ${verb}: ${p}`);
+    }
+    for (const s of result.skipped) {
+        console.log(`  ⚠ Skipped: ${s.path} (${s.reason})`);
+    }
+    console.log(`\n${verb} ${result.removed.length} worktree(s), skipped ${result.skipped.length}.`);
+}
+export function runWorktreeMerge(options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    const result = mergeWorktreeBranch(cwd, options.branch, {
+        message: options.message,
+        dryRun: options.dryRun,
+    });
+    if (!result.merged) {
+        if (options.dryRun) {
+            console.log(`(dry-run) Would merge ${options.branch}: ${result.filesChanged} files changed, ${result.filesRestored} parasitic deletions restored.`);
+        }
+        else {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.log(`✔ Merged ${options.branch} → ${result.commitHash}`);
+    console.log(`  ${result.filesChanged} files changed, ${result.filesRestored} parasitic deletion(s) auto-restored.`);
+}
+/** Returns WorktreeInfo[] for use by MCP tools. */
+export function getWorktrees(cwd) {
+    return listWorktrees(cwd);
+}
+//# sourceMappingURL=worktree.js.map