brainclaw 0.19.11 → 0.19.14

package/README.md

@@ -21,6 +21,8 @@ The best setup is to tell your agent, in natural language, to install and initia
 
 It sits alongside Copilot, Claude Code, Cursor, Codex, Windsurf, OpenCode, Antigravity/Gemini CLI and other coding agents. It does not replace them. It gives them a shared state layer they can resume from reliably across sessions.
 
+brainclaw is also starting to model other local AI work surfaces on the same machine, such as ChatGPT Desktop, Claude Desktop, Claude Cowork, and Gemini web or CLI. That makes it possible to keep a project-level queue of non-code work for those surfaces, instead of treating every task as something the active coding agent must do itself.
+
 ---
 
 ## Why brainclaw exists
@@ -40,6 +42,8 @@ brainclaw solves this by making the repo itself agent-readable and agent-writeab
 | **Coordination state** | shared plans, file claims, runtime notes, and board views for active work |
 | **Agent-ready context** | compact, prompt-sized context built from real workspace state instead of stale instructions |
 | **Native agent files** | auto-writes `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `.cursor/rules/`, `.windsurfrules`, and similar local guidance |
+| **Machine AI surface discovery** | detects local coding agents plus desktop AI work surfaces such as ChatGPT Desktop and Gemini CLI |
+| **Queued surface tasks** | stores project-scoped requests for other local AI surfaces, such as visual generation, drafting, summaries, or research |
 | **Local-first storage** | plain text + JSON, Git-friendly, no mandatory cloud, no telemetry by default |
 
 ---
@@ -129,6 +133,7 @@ After that, the agent should stay on Brainclaw's MCP path for live state:
 
 ```text
 bclaw_session_start      -> open session + return board/context
+bclaw_get_execution_context -> inspect local tooling + notice Brainclaw package updates
 bclaw_get_context        -> fetch fresh prompt-ready context for a path
 bclaw_list_plans         -> inspect shared work
 bclaw_claim              -> claim scope before editing
@@ -145,6 +150,18 @@ brainclaw context --for src/auth/routes.ts --digest
 brainclaw status
 ```
 
+And if the current coding agent wants to hand off a non-code task to another local AI surface for later:
+
+```bash
+brainclaw surface-task create "Generate homepage hero visual" \
+  --target chatgpt \
+  --kind visual_asset \
+  --instructions "Create a lightweight product hero visual for the landing page." \
+  --output assets/hero-home.png
+
+brainclaw surface-task list
+```
+
 ---
 
 ## Installation
@@ -177,6 +194,8 @@ If you want a machine-level CLI for operator workflows, debugging, or repeated l
 npm install -g brainclaw
 ```
 
+By default, Brainclaw's update checks for end-user installs follow the public npm `latest` channel. Projects that need a different track can override `brainclaw_update_source`, for example to use `prelaunch` or a local tarball channel.
+
 If you are working from source while developing Brainclaw itself:
 
 ```bash

package/dist/cli.js

@@ -3,6 +3,7 @@ import { Command } from 'commander';
 import { runInit } from './commands/init.js';
 import { runSetup } from './commands/setup.js';
 import { runUpgrade } from './commands/upgrade.js';
+import { runReconcile } from './commands/reconcile.js';
 import { getMemoryLog, rollbackMemory, hasMemoryRepo } from './core/memory-git.js';
 import { buildMachineProfile, saveMachineProfile, loadMachineProfile, renderMachineProfileSummary } from './core/machine-profile.js';
 import { buildAgentInventory, saveAgentInventory, loadAgentInventory, renderAgentInventorySummary } from './core/agent-inventory.js';
@@ -22,6 +23,7 @@ import { runCompleteStep } from './commands/complete-step.js';
 import { runUpdateHandoff } from './commands/update-handoff.js';
 import { runInstruction } from './commands/instruction.js';
 import { runListAgents } from './commands/list-agents.js';
+import { runSurfaceTaskResource } from './commands/surface-task-resource.js';
 import { runListInstructions } from './commands/list-instructions.js';
 import { runDoctor } from './commands/doctor.js';
 import { runRebuild } from './commands/rebuild.js';
@@ -169,7 +171,7 @@ program
 // --- machine-profile ---
 program
     .command('machine-profile')
-    .description('Detect and persist machine capabilities (OS, shells, git users, SSH keys, toolchains, WSL)')
+    .description('Detect and persist machine capabilities (OS, shells, git users, SSH keys, toolchains, WSL, AI surfaces)')
     .option('--refresh', 'Force regeneration even if profile exists')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
@@ -402,6 +404,28 @@ program
     .action((id, options) => {
     runUpdatePlan(id, { ...options, actualEffort: options.actualEffort });
 });
+// --- surface-task ---
+program
+    .command('surface-task <subcommand> [args...]')
+    .description('Manage queued tasks for desktop AI surfaces such as ChatGPT Desktop or Claude Desktop')
+    .option('--json', 'Output as JSON for list')
+    .option('--all', 'Include completed, cancelled, and failed tasks in list')
+    .option('--status <status>', 'Status filter/update: queued, in_progress, completed, cancelled, failed')
+    .option('--target <surface>', 'Target surface, e.g. chatgpt, claude, gemini')
+    .option('--kind <kind>', 'Task kind: visual_asset, draft, summary, analysis, research, custom')
+    .option('--instructions <text>', 'Detailed instructions for the target surface')
+    .option('--output <paths...>', 'Expected output paths')
+    .option('--result <text>', 'Optional result note when updating a task')
+    .option('--tag <tags...>', 'Tags for this task')
+    .option('--path <paths...>', 'Related file paths')
+    .option('--agent <agent>', 'Author agent name')
+    .option('--agent-id <agentId>', 'Author agent id')
+    .action((subcommand, args, options) => {
+    runSurfaceTaskResource(subcommand, args, {
+        ...options,
+        agentId: options.agentId,
+    });
+});
 // --- delete-plan ---
 program
     .command('delete-plan <id>')
@@ -915,6 +939,25 @@ program
     .action((options) => {
     runExport(options);
 });
+program
+    .command('reconcile')
+    .description('Refresh machine and workspace bootstrap state after updates or onboarding on complex installs')
+    .option('--json', 'Output as JSON')
+    .option('--dry-run', 'Preview the reconciliation plan without writing machine or bootstrap state')
+    .option('--apply-bootstrap', 'Apply bootstrap suggestions across all selected stores after refresh')
+    .option('-y, --yes', 'Skip confirmation prompts for multi-store bootstrap apply')
+    .option('--skip-machine-profile', 'Skip machine-profile refresh')
+    .option('--skip-agent-inventory', 'Skip agent-inventory refresh')
+    .action(async (options) => {
+    await runReconcile({
+        json: options.json,
+        dryRun: options.dryRun,
+        applyBootstrap: options.applyBootstrap,
+        yes: options.yes,
+        skipMachineProfile: options.skipMachineProfile,
+        skipAgentInventory: options.skipAgentInventory,
+    });
+});
 // --- hooks ---
 program
     .command('hooks')

package/dist/commands/claude-desktop-extension.js

@@ -0,0 +1,18 @@
+import path from 'node:path';
+import { buildClaudeDesktopExtension, renderClaudeDesktopExtensionSummary, } from '../core/claude-desktop-extension.js';
+export function runClaudeDesktopExtension(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const result = buildClaudeDesktopExtension({
+        cwd,
+        workspaceDir: options.workspace ? path.resolve(cwd, options.workspace) : undefined,
+        outputFile: options.output ? path.resolve(cwd, options.output) : undefined,
+        projectRoot: options.projectRoot ? path.resolve(cwd, options.projectRoot) : undefined,
+        pack: options.pack,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(renderClaudeDesktopExtensionSummary(result));
+}
+//# sourceMappingURL=claude-desktop-extension.js.map

package/dist/commands/doctor.js

@@ -25,6 +25,7 @@ import { assessBrainclawVersion } from '../core/brainclaw-version.js';
 import { resolveStoreChain } from '../core/store-resolution.js';
 import { resolveCrossProjectLinks, detectCrossProjectCycles } from '../core/cross-project.js';
 import { auditLocalAgentWorkspaceFiles, ensureGitignoreEntries } from '../core/agent-files.js';
+import { summarizeWorkspaceProjects } from '../core/workspace-projects.js';
 const BACKLOG_KEYWORDS = /\b(TODO|NEXT|backlog|next[\s-]step|action[\s-]item|prochaine?s?\s+étapes?|à\s+faire)\b/i;
 function hasBacklogPatterns(text) {
     const lines = text.split(/\r?\n/);
@@ -138,14 +139,19 @@ export function runDoctor(options = {}) {
             });
         }
     }
-    if (config.project_mode === 'multi-project' && (config.projects?.known.length ?? 0) === 0) {
+    const workspaceProjects = summarizeWorkspaceProjects(options.cwd ?? process.cwd(), config);
+    if (config.project_mode === 'multi-project' && workspaceProjects.effective_project_count === 0) {
         checks.push({
             name: 'project_mode',
             status: 'warn',
-            message: 'project_mode is multi-project but no project namespaces are configured yet.',
+            message: config.projects?.strategy === 'folder'
+                ? 'project_mode is multi-project with folder strategy but no child projects were resolved from config, registry, or nested stores yet.'
+                : 'project_mode is multi-project but no project namespaces are configured yet.',
         });
         if (!options.json) {
-            console.warn('⚠ project_mode is multi-project but no project namespaces are configured yet.');
+            console.warn(config.projects?.strategy === 'folder'
+                ? '⚠ project_mode is multi-project with folder strategy but no child projects were resolved from config, registry, or nested stores yet.'
+                : '⚠ project_mode is multi-project but no project namespaces are configured yet.');
         }
         hasIssues = true;
     }
@@ -153,10 +159,11 @@ export function runDoctor(options = {}) {
         checks.push({
             name: 'project_mode',
             status: 'ok',
-            message: `project_mode=${config.project_mode}, strategy=${config.projects?.strategy ?? 'manual'}, known_projects=${config.projects?.known.length ?? 0}`,
+            message: `project_mode=${config.project_mode}, strategy=${config.projects?.strategy ?? 'manual'}, configured_projects=${workspaceProjects.configured_projects.length}, effective_projects=${workspaceProjects.effective_project_count}`,
+            details: workspaceProjects,
         });
         if (!options.json) {
-            console.log(`✔ project mode: ${config.project_mode} (${config.projects?.strategy ?? 'manual'})`);
+            console.log(`✔ project mode: ${config.project_mode} (${config.projects?.strategy ?? 'manual'}), effective projects=${workspaceProjects.effective_project_count}`);
         }
     }
     try {

package/dist/commands/env.js

@@ -1,7 +1,7 @@
 import { memoryExists } from '../core/io.js';
 import { loadConfig } from '../core/config.js';
 import { assessAgentIntegrationReadiness } from '../core/agent-integrations.js';
-import { assessBrainclawVersion } from '../core/brainclaw-version.js';
+import { assessBrainclawVersion, checkBrainclawInstallableUpdate, renderBrainclawInstallableUpdateNotice, } from '../core/brainclaw-version.js';
 import { buildExecutionContext, compactExecutionContext, renderExecutionContextSummary } from '../core/execution-context.js';
 import { buildAgentToolingContext, renderAgentToolingSummary } from '../core/agent-context.js';
 export function runEnv(options = {}) {
@@ -14,11 +14,14 @@ export function runEnv(options = {}) {
     const config = loadConfig(cwd);
     const integrationReadiness = assessAgentIntegrationReadiness(config, cwd);
     const brainclawVersion = assessBrainclawVersion(config);
+    const installableUpdate = checkBrainclawInstallableUpdate(config, cwd, { useDefaultNpmSource: true });
+    const installableUpdateNotice = renderBrainclawInstallableUpdateNotice(installableUpdate);
     const agentTooling = options.agentTooling ? buildAgentToolingContext({ cwd }) : undefined;
     if (options.json) {
         console.log(JSON.stringify({
             execution_context: executionContext,
             brainclaw_version: brainclawVersion,
+            installable_update: installableUpdate,
             declared_agent_integrations: config.agent_integrations,
             integration_readiness: integrationReadiness,
             ...(agentTooling ? { agent_tooling: agentTooling } : {}),
@@ -33,6 +36,9 @@ export function runEnv(options = {}) {
             console.log(`Upgrade benefits: ${brainclawVersion.upgrade_message}`);
         }
     }
+    if (installableUpdateNotice) {
+        console.log(installableUpdateNotice);
+    }
     console.log(`Declared agent integrations: ${config.agent_integrations.declarations.length}`);
     const missingDeclarations = integrationReadiness.filter((entry) => !entry.ready);
     if (missingDeclarations.length > 0) {

package/dist/commands/init.js

@@ -14,6 +14,7 @@ import { renderBootstrapSummary, runBootstrapProfile } from '../core/bootstrap.j
 import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
 import { describeAutoConfigWrite, ensureAgentFiles, ensureGitignoreEntries, writeDetectedAgentAutoConfig } from '../core/agent-files.js';
 import { detectAiAgent, detectWslEnvironment } from '../core/ai-agent-detection.js';
+import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-surface-inventory.js';
 import { hasCompletedSetup } from '../core/setup-state.js';
 import { writeDetectedAgentExport } from './export.js';
 import { writeDetectedAgentHooks } from './hooks.js';
@@ -178,6 +179,20 @@ export async function runInit(options = {}) {
     if (detectedExport) {
         console.log(`\u2714 Agent instructions written to ${detectedExport.relativePath} (${detectedExport.created ? 'created' : 'updated'})`);
     }
+    const visibleSurfaces = buildAiSurfaceInventory().filter((surface) => surface.status !== 'not_detected');
+    if (visibleSurfaces.length > 0) {
+        console.log('✔ Other AI work surfaces detected on this machine:');
+        for (const surface of visibleSurfaces) {
+            console.log(`  - ${surface.display_name} [${surface.surface_kind}, ${surface.status}]`);
+        }
+        const usageHints = renderAiSurfaceUsageHints(visibleSurfaces);
+        if (usageHints.length > 0) {
+            console.log('  Suggested uses:');
+            for (const line of usageHints) {
+                console.log(`    ${line}`);
+            }
+        }
+    }
     for (const hook of detectedHooks) {
         console.log(`\u2714 Session hook written to ${hook.relativePath} (${hook.created ? 'created' : 'updated'})`);
     }

package/dist/commands/list-surface-tasks.js

@@ -0,0 +1,39 @@
+import { memoryExists } from '../core/io.js';
+import { listAiSurfaceTasks } from '../core/ai-surface-tasks.js';
+export function runListSurfaceTasks(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    let tasks = listAiSurfaceTasks(options.cwd);
+    if (!options.all) {
+        tasks = tasks.filter((task) => task.status === 'queued' || task.status === 'in_progress');
+    }
+    if (options.status) {
+        tasks = tasks.filter((task) => task.status === options.status);
+    }
+    if (options.target) {
+        const target = options.target.toLowerCase();
+        tasks = tasks.filter((task) => task.target_surface.toLowerCase() === target);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(tasks, null, 2));
+        return;
+    }
+    if (tasks.length === 0) {
+        console.log('No surface tasks.');
+        return;
+    }
+    console.log(`${tasks.length} surface task(s):`);
+    console.log('');
+    for (const task of tasks) {
+        console.log(`  [${task.id}] ${task.title} (${task.status}, target ${task.target_surface}, kind ${task.kind})`);
+        if (task.requested_outputs.length > 0) {
+            console.log(`    outputs: ${task.requested_outputs.join(', ')}`);
+        }
+        if (task.result_note) {
+            console.log(`    result: ${task.result_note}`);
+        }
+    }
+}
+//# sourceMappingURL=list-surface-tasks.js.map

package/dist/commands/mcp.js

@@ -7,6 +7,7 @@ import { buildAgentToolingContext, renderAgentToolingSummary } from '../core/age
 import { buildCoordinationSnapshot } from '../core/coordination.js';
 import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from '../core/context.js';
 import { buildExecutionContext, renderExecutionContextSummary } from '../core/execution-context.js';
+import { checkBrainclawInstallableUpdate, renderBrainclawInstallableUpdateNotice } from '../core/brainclaw-version.js';
 import { loadConfig } from '../core/config.js';
 import { loadState, persistState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
@@ -82,7 +83,7 @@ export const MCP_READ_TOOLS = [
     },
     {
         name: 'bclaw_get_execution_context',
-        description: 'Inspect the local execution environment and optionally agent tooling signals.',
+        description: 'Inspect the local execution environment, installable Brainclaw update channel, and optionally agent tooling signals.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1133,15 +1134,20 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     }
     if (name === 'bclaw_get_execution_context') {
         const executionContext = buildExecutionContext({ cwd });
+        const config = loadConfig(cwd);
+        const installableUpdate = checkBrainclawInstallableUpdate(config, cwd, { useDefaultNpmSource: true });
+        const installableUpdateNotice = renderBrainclawInstallableUpdateNotice(installableUpdate);
         const agentTooling = args.includeAgentTooling ? buildAgentToolingContext({ cwd }) : undefined;
         const text = [
             renderExecutionContextSummary(executionContext, true),
+            ...(installableUpdateNotice ? ['', installableUpdateNotice] : []),
             ...(agentTooling ? ['', renderAgentToolingSummary(agentTooling)] : []),
         ].join('\n');
         return {
             content: [{ type: 'text', text }],
             structuredContent: {
                 execution_context: executionContext,
+                installable_update: installableUpdate,
                 ...(agentTooling ? { agent_tooling: agentTooling } : {}),
             },
         };

package/dist/commands/reconcile.js

@@ -0,0 +1,138 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import path from 'node:path';
+import { buildMachineProfile, saveMachineProfile } from '../core/machine-profile.js';
+import { buildAgentInventory, saveAgentInventory } from '../core/agent-inventory.js';
+import { applyBootstrapImport, runBootstrapProfile } from '../core/bootstrap.js';
+import { loadConfig } from '../core/config.js';
+import { memoryExists } from '../core/io.js';
+import { summarizeWorkspaceProjects } from '../core/workspace-projects.js';
+export async function runReconcile(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found in the current directory. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const rootConfig = loadConfig(cwd);
+    const workspaceSummary = summarizeWorkspaceProjects(cwd, rootConfig);
+    const storeTargets = [
+        cwd,
+        ...workspaceSummary.uses_folder_resolution
+            ? workspaceSummary.discovered_projects
+                .filter((project) => project.source !== 'config')
+                .map((project) => project.path)
+            : [],
+    ];
+    const uniqueTargets = [...new Set(storeTargets.map((store) => path.resolve(store)))];
+    if (options.json && options.dryRun) {
+        console.log(JSON.stringify({
+            cwd,
+            mode: 'dry_run',
+            workspace_summary: workspaceSummary,
+            planned_actions: {
+                machine_profile_refresh: !options.skipMachineProfile,
+                agent_inventory_refresh: !options.skipAgentInventory,
+                bootstrap_refresh: uniqueTargets.map((store) => ({
+                    cwd: store,
+                    relative_path: path.relative(cwd, store) || '.',
+                    apply_bootstrap: Boolean(options.applyBootstrap),
+                })),
+            },
+        }, null, 2));
+        return;
+    }
+    if (options.applyBootstrap) {
+        await confirmBootstrapApply(options.yes);
+    }
+    const machineProfilePath = !options.skipMachineProfile
+        ? saveMachineProfile(buildMachineProfile())
+        : null;
+    const agentInventoryPath = !options.skipAgentInventory
+        ? saveAgentInventory(buildAgentInventory())
+        : null;
+    const stores = [];
+    for (const store of uniqueTargets) {
+        const config = loadConfig(store);
+        if (options.applyBootstrap) {
+            const result = applyBootstrapImport({ cwd: store, refresh: true });
+            stores.push({
+                cwd: store,
+                relative_path: path.relative(cwd, store) || '.',
+                project_name: config.project_name,
+                project_mode: config.project_mode,
+                project_strategy: config.projects.strategy,
+                bootstrap_refreshed: true,
+                bootstrap_applied: true,
+                workspace_kind: result.proposal.workspace_kind,
+                onboarding_mode: result.proposal.onboarding_mode,
+                confidence: result.proposal.confidence,
+                suggestion_count: result.proposal.suggestion_count,
+                created_count: result.createdCount,
+                skipped_count: result.skippedCount,
+            });
+            continue;
+        }
+        const result = runBootstrapProfile({ cwd: store, refresh: true });
+        stores.push({
+            cwd: store,
+            relative_path: path.relative(cwd, store) || '.',
+            project_name: config.project_name,
+            project_mode: config.project_mode,
+            project_strategy: config.projects.strategy,
+            bootstrap_refreshed: true,
+            bootstrap_applied: false,
+            workspace_kind: result.profile.workspace_kind,
+            onboarding_mode: result.profile.onboarding_mode,
+            confidence: result.profile.confidence,
+            suggestion_count: result.importPlan.suggestion_count,
+        });
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            cwd,
+            mode: options.applyBootstrap ? 'apply' : 'refresh',
+            workspace_summary: workspaceSummary,
+            machine_profile_refreshed: !options.skipMachineProfile,
+            machine_profile_path: machineProfilePath,
+            agent_inventory_refreshed: !options.skipAgentInventory,
+            agent_inventory_path: agentInventoryPath,
+            stores,
+        }, null, 2));
+        return;
+    }
+    if (!options.skipMachineProfile) {
+        console.log(`✔ Machine profile refreshed: ${machineProfilePath}`);
+    }
+    if (!options.skipAgentInventory) {
+        console.log(`✔ Agent inventory refreshed: ${agentInventoryPath}`);
+    }
+    console.log('');
+    console.log(`Reconciled ${stores.length} store(s):`);
+    for (const store of stores) {
+        const suffix = store.bootstrap_applied
+            ? `${store.created_count ?? 0} created, ${store.skipped_count ?? 0} skipped`
+            : `${store.suggestion_count ?? 0} bootstrap suggestion(s) available`;
+        console.log(`  - ${store.relative_path} (${store.project_name}) — ${store.onboarding_mode ?? 'unknown'}, confidence=${store.confidence ?? 'unknown'}, ${suffix}`);
+    }
+}
+async function confirmBootstrapApply(yes) {
+    if (yes) {
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error('Error: bootstrap apply across multiple stores requires --yes in non-interactive mode.');
+        process.exit(1);
+    }
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question('Apply bootstrap suggestions across all selected stores? [y/N] ');
+        if (answer.trim().toLowerCase() !== 'y') {
+            console.error('Cancelled.');
+            process.exit(1);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/commands/setup.js

@@ -4,6 +4,7 @@ import readline from 'node:readline/promises';
 import { spawnSync } from 'node:child_process';
 import { runInit } from './init.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
+import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-surface-inventory.js';
 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, ensureCodexMcpConfig, writeDetectedAgentAutoConfig, describeAutoConfigWrite, ensureGitignoreEntries, collectWorkspaceGitignoreEntries, } from '../core/agent-files.js';
@@ -388,6 +389,7 @@ export async function runSetup(options = {}) {
     // Step 4: Agent detection & selection
     const detectedAi = detectAiAgent(env);
     const detectedName = detectedAi?.name;
+    const detectedSurfaces = buildAiSurfaceInventory();
     console.log('');
     if (detectedName) {
         console.log(`Detected AI agent: ${detectedName}`);
@@ -395,6 +397,23 @@ export async function runSetup(options = {}) {
     else {
         console.log('No AI agent detected automatically.');
     }
+    const visibleSurfaces = detectedSurfaces.filter((surface) => surface.status !== 'not_detected');
+    if (visibleSurfaces.length > 0) {
+        console.log('Other AI work surfaces on this machine:');
+        for (const surface of visibleSurfaces) {
+            console.log(`  - ${surface.display_name} [${surface.surface_kind}, ${surface.status}]`);
+        }
+        const usageHints = renderAiSurfaceUsageHints(visibleSurfaces);
+        if (usageHints.length > 0) {
+            console.log('');
+            console.log('Suggested uses:');
+            for (const line of usageHints) {
+                console.log(`  ${line}`);
+            }
+        }
+        console.log('');
+        console.log('These surfaces are tracked separately from coding agents and will use tailored onboarding flows.');
+    }
     console.log('Supported agents:');
     ALL_KNOWN_AGENTS.forEach((a, i) => {
         const tag = a === detectedName ? ' ← detected' : '';

package/dist/commands/status.js

@@ -9,7 +9,8 @@ import { loadState } from '../core/state.js';
 import { isTrapActive, listOperationalTraps } from '../core/traps.js';
 import { generateMarkdown } from '../core/markdown.js';
 import { memoryExists } from '../core/io.js';
-function printHumanStatus(state, config) {
+import { summarizeWorkspaceProjects } from '../core/workspace-projects.js';
+function printHumanStatus(state, config, cwd) {
     const activePlans = state.plan_items.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
     const activeInstructions = loadInstructions().filter((entry) => entry.active);
     const activeClaims = listClaims().filter((claim) => claim.status === 'active');
@@ -21,6 +22,7 @@ function printHumanStatus(state, config) {
     const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
     const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
     const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
+    const workspaceProjects = summarizeWorkspaceProjects(cwd, config);
     const counts = {
         instructions: activeInstructions.length,
         claims: activeClaims.length,
@@ -50,7 +52,7 @@ function printHumanStatus(state, config) {
     console.log(`  Traps       : ${activeSharedTraps.length} active shared, ${resolvedSharedTraps.length} resolved shared, ${activeMachineTraps.length} active machine-local (${currentHost})`);
     console.log(`  Handoffs    : ${counts.handoffs}`);
     if (config.project_mode === 'multi-project') {
-        console.log(`  Projects    : ${config.projects.known.length}`);
+        console.log(`  Projects    : ${workspaceProjects.effective_project_count} effective (${workspaceProjects.strategy})`);
     }
     // Show recent items (last 3 per section)
     const sections = [
@@ -84,24 +86,27 @@ function printHumanStatus(state, config) {
     }
 }
 export function runStatus(options = {}) {
-    if (!memoryExists()) {
+    const cwd = process.cwd();
+    if (!memoryExists(cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
-    const config = loadConfig();
-    const state = loadState();
+    const config = loadConfig(cwd);
+    const state = loadState(cwd);
     const currentHost = resolveCurrentHostId();
-    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' });
-    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' });
-    const machineTraps = listOperationalTraps({ visibility: 'machine' });
+    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' }, cwd);
+    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' }, cwd);
+    const machineTraps = listOperationalTraps({ visibility: 'machine' }, cwd);
     const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
     const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
     const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
-    const registeredAgents = listAgentIdentities();
-    const reputation = buildReputationSnapshot();
+    const registeredAgents = listAgentIdentities(cwd);
+    const reputation = buildReputationSnapshot(cwd);
+    const workspaceProjects = summarizeWorkspaceProjects(cwd, config);
     if (options.json) {
         console.log(JSON.stringify({
             config,
+            workspace_projects: workspaceProjects,
             agents: {
                 current_name: config.current_agent,
                 current_id: config.current_agent_id,
@@ -125,9 +130,9 @@ export function runStatus(options = {}) {
         return;
     }
     if (options.markdown) {
-        console.log(generateMarkdown(state));
+        console.log(generateMarkdown(state, cwd));
         return;
     }
-    printHumanStatus(state, config);
+    printHumanStatus(state, config, cwd);
 }
 //# sourceMappingURL=status.js.map

package/dist/commands/surface-task-resource.js

@@ -0,0 +1,35 @@
+import { runSurfaceTask } from './surface-task.js';
+import { runListSurfaceTasks } from './list-surface-tasks.js';
+import { runUpdateSurfaceTask } from './update-surface-task.js';
+export function runSurfaceTaskResource(subcommand, args, options = {}) {
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'create') {
+        const title = args.join(' ').trim();
+        if (!title) {
+            console.error('Error: surface-task create requires <title>.');
+            process.exit(1);
+        }
+        runSurfaceTask(title, options);
+        return;
+    }
+    if (normalized === 'list' || normalized === 'ls') {
+        runListSurfaceTasks(options);
+        return;
+    }
+    if (normalized === 'update') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: surface-task update requires <id>.');
+            process.exit(1);
+        }
+        runUpdateSurfaceTask(id, options);
+        return;
+    }
+    const legacyTitle = [subcommand, ...args].join(' ').trim();
+    if (!legacyTitle) {
+        console.error('Error: missing surface-task subcommand or title.');
+        process.exit(1);
+    }
+    runSurfaceTask(legacyTitle, options);
+}
+//# sourceMappingURL=surface-task-resource.js.map