bingocode 1.1.195 → 1.1.200-beta.0

package/bin/bingocode-win.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { spawn } = require('node:child_process');
 const path = require('path');

package/bin/claude

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env bash
 set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

package/bin/claude-win.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { spawn } = require('node:child_process');
 const path = require('path');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.195",
+  "version": "1.1.200-beta.0",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/cli/ProviderPanel.tsx

@@ -51,8 +51,7 @@ type Stage =
   | 'editing'
   | 'slot_config'
   | 'slot_loading'
-  | 'slot_select_model'
-  | 'slot_input_label';
+  | 'slot_select_model';
 
 export const ProviderPanel: React.FC<{
   apiUrl: string;
@@ -97,9 +96,11 @@ export const ProviderPanel: React.FC<{
   const [slotProviderModels, setSlotProviderModels] = useState<Record<string, string[]>>({});
   const [currentSlotName, setCurrentSlotName] = useState<string>('main');
   const [slotLoadingMsg, setSlotLoadingMsg] = useState<string>('');
-  const [tempSlotProviderId, setTempSlotProviderId] = useState<string>('');
-  const [tempSlotModelId, setTempSlotModelId] = useState<string>('');
-  const [slotLabelInput, setSlotLabelInput] = useState<string>('');
+
+  // VS Code link status
+  const [vscodeLinked, setVscodeLinked] = useState(false);
+  const [vscodeLinkedPaths, setVscodeLinkedPaths] = useState<string[]>([]);
+
 
   const base = apiUrl.replace(/\/+$/, '');
 
@@ -146,6 +147,16 @@ export const ProviderPanel: React.FC<{
     loadPresets();
   }, [loadProviders, loadPresets]);
 
+  // Fetch VS Code link status on mount
+  useEffect(() => {
+    axios.get(`${base}/api/providers/link-vscode`)
+      .then(r => {
+        setVscodeLinked(r.data.linked);
+        setVscodeLinkedPaths(r.data.paths || []);
+      })
+      .catch(() => {});
+  }, [base]);
+
   // Key processing for Page Up/Down and Arrow keys in scrolling lists
   useEffect(() => {
     const handler = (buf: Buffer) => {
@@ -320,6 +331,7 @@ export const ProviderPanel: React.FC<{
             { label: 'Add Provider', value: 'add' },
             { label: 'Edit Provider (Name/Key)', value: 'edit' },
             { label: 'Configure Slots', value: 'slots' },
+            { label: vscodeLinked ? `Disconnect from VS Code (${vscodeLinkedPaths.length} editor(s))` : 'Connect to VS Code', value: 'link_vscode' },
             { label: 'Connectivity Test', value: 'test' },
             { label: 'Delete Provider', value: 'delete' },
             { label: 'Refresh', value: 'refresh' },
@@ -348,6 +360,33 @@ export const ProviderPanel: React.FC<{
                 setStage('slot_config');
                 setListOffset(0);
                 break;
+              case 'link_vscode':
+                setOpMsg(null);
+                setErr(null);
+                if (vscodeLinked) {
+                  // Unlink
+                  axios.delete(`${base}/api/providers/link-vscode`)
+                    .then(() => {
+                      setVscodeLinked(false);
+                      setVscodeLinkedPaths([]);
+                      setOpMsg('Disconnected from VS Code.');
+                    })
+                    .catch(e => {
+                      setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Failed to disconnect VS Code');
+                    });
+                } else {
+                  // Link
+                  axios.post(`${base}/api/providers/link-vscode`)
+                    .then(r => {
+                      setVscodeLinked(true);
+                      setVscodeLinkedPaths(r.data.paths || []);
+                      setOpMsg(`Connected to VS Code (${(r.data.paths || []).length} editor(s)).`);
+                    })
+                    .catch(e => {
+                      setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Failed to connect VS Code');
+                    });
+                }
+                break;
               case 'test':
                 setStage('test_select');
                 setListOffset(0);
@@ -780,10 +819,25 @@ export const ProviderPanel: React.FC<{
                 const sepIdx = val.indexOf('::');
                 const providerId = val.slice(0, sepIdx);
                 const modelId = val.slice(sepIdx + 2);
-                setTempSlotProviderId(providerId);
-                setTempSlotModelId(modelId);
-                setSlotLabelInput(modelId);
-                setStage('slot_input_label');
+                axios.put(`${base}/api/providers/slots/${currentSlotName}`, {
+                  providerId,
+                  modelId,
+                  label: null,
+                })
+                .then(() => {
+                  setSlotTable(prev => ({
+                    ...prev,
+                    [currentSlotName]: { providerId, modelId, label: null }
+                  }));
+                  setOpMsg(`Configured [${currentSlotName}] -> ${modelId}`);
+                  setErr(null);
+                  setListOffset(0);
+                  setStage('slot_config');
+                })
+                .catch(e => {
+                  setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Save failed');
+                  setStage('slot_config');
+                });
               }}
             />
           </Box>
@@ -794,47 +848,6 @@ export const ProviderPanel: React.FC<{
     );
   }
 
-  if (stage === 'slot_input_label') {
-    return (
-      <Box flexDirection="column" flexGrow={1}>
-        <Title color="cyan">Configure Slot [{currentSlotName}] — Set Display Name</Title>
-        <Text>
-          Model: {providers.find(p => p.id === tempSlotProviderId)?.name || tempSlotProviderId} / {tempSlotModelId}
-        </Text>
-        <Box marginTop={1}>
-          <Text>Display Name (Label): </Text>
-          <TextInput
-            value={slotLabelInput}
-            onChange={setSlotLabelInput}
-            onSubmit={() => {
-              const label = slotLabelInput.trim() || tempSlotModelId;
-              axios.put(`${base}/api/providers/slots/${currentSlotName}`, {
-                providerId: tempSlotProviderId,
-                modelId: tempSlotModelId,
-                label,
-              })
-              .then(() => {
-                setSlotTable(prev => ({
-                  ...prev,
-                  [currentSlotName]: { providerId: tempSlotProviderId, modelId: tempSlotModelId, label }
-                }));
-                setOpMsg(`Configured [${currentSlotName}] -> ${label}`);
-                setErr(null);
-                setListOffset(0);
-                setStage('slot_config');
-              })
-              .catch(e => {
-                setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Save failed');
-                setStage('slot_config');
-              });
-            }}
-          />
-        </Box>
-        <Hint>Enter: Save (Display name in UI) · ESC: Back to Models</Hint>
-      </Box>
-    );
-  }
-
   return null;
 };
 

package/src/commands/{exec/exec.ts → brain/brain.ts}

@@ -16,22 +16,22 @@ export async function call(
     const arg = (args ?? '').trim().toLowerCase()
     const enable = arg !== 'off'
 
-    const result = updateSettingsForSource('userSettings', { execMode: enable })
+    const result = updateSettingsForSource('userSettings', { brainMode: enable })
     if (result.error) {
       logError(result.error)
-      onDone(`Failed to ${enable ? 'enable' : 'disable'} Exec Mode: ${result.error.message}`, { display: 'system' })
+      onDone(`Failed to ${enable ? 'enable' : 'disable'} Brain Mode: ${result.error.message}`, { display: 'system' })
       return null
     }
 
     if (enable) {
-      context.setAppState(prev => ({ ...prev, execMode: true }))
-      onDone('✓ Exec Mode enabled', { display: 'system' })
+      context.setAppState(prev => ({ ...prev, brainMode: true }))
+      onDone('✓ Brain Mode enabled — thinking, deciding, orchestrating.', { display: 'system' })
     } else {
-      context.setAppState(prev => ({ ...prev, execMode: false }))
-      onDone('✗ Exec Mode disabled', { display: 'system' })
+      context.setAppState(prev => ({ ...prev, brainMode: false }))
+      onDone('✗ Brain Mode disabled — back to full execution.', { display: 'system' })
     }
 
-    logEvent('tengu_exec_mode_toggled', {
+    logEvent('tengu_brain_mode_toggled', {
       enabled: enable,
       source: 'shortcut' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
     })

package/src/commands/brain/index.ts

@@ -0,0 +1,14 @@
+import type { Command } from '../../commands.js'
+
+const brain = {
+  type: 'local-jsx',
+  name: 'brain',
+  description:
+    'Brain mode — think, decide, orchestrate. Delegate execution to sub-agents.',
+  argumentHint: '[off]',
+  isEnabled: () => true,
+  immediate: true,
+  load: () => import('./brain.js'),
+} satisfies Command
+
+export default brain

package/src/commands.ts

@@ -124,7 +124,7 @@ import thinkbackPlay from './commands/thinkback-play/index.js'
 import permissions from './commands/permissions/index.js'
 import plan from './commands/plan/index.js'
 import fast from './commands/fast/index.js'
-import exec from './commands/exec/index.js'
+import brain from './commands/brain/index.js'
 import passes from './commands/passes/index.js'
 import privacySettings from './commands/privacy-settings/index.js'
 import hooks from './commands/hooks/index.js'
@@ -275,7 +275,7 @@ const COMMANDS = memoize((): Command[] => [
   effort,
   exit,
   fast,
-  exec,
+  brain,
   files,
   heapDump,
   help,

package/src/components/PromptInput/PromptInput.tsx

@@ -323,7 +323,7 @@ function PromptInput({
   const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession);
   const thinkingEnabled = useAppState(s => s.thinkingEnabled);
   const isFastMode = useAppState(s => isFastModeEnabled() ? s.fastMode : false);
-  const isExecMode = useAppState(s => s.execMode ?? false);
+  const isBrainMode = useAppState(s => s.brainMode ?? false);
   const effortValue = useAppState(s => s.effortValue);
   const viewedTeammate = getViewedTeammateTask(store.getState());
   const viewingAgentName = viewedTeammate?.identity.agentName;
@@ -2261,7 +2261,7 @@ function PromptInput({
             </Box>
           </Box>
           <Text color={swarmBanner.bgColor}>{'─'.repeat(columns)}</Text>
-        </> : <Box flexDirection="row" alignItems="flex-start" justifyContent="flex-start" borderColor={getBorderColor()} borderStyle="round" borderLeft={false} borderRight={false} borderBottom width="100%" borderText={buildBorderText(showFastIcon ?? false, showFastIconHint, fastModeCooldown, isExecMode)}>
+        </> : <Box flexDirection="row" alignItems="flex-start" justifyContent="flex-start" borderColor={getBorderColor()} borderStyle="round" borderLeft={false} borderRight={false} borderBottom width="100%" borderText={buildBorderText(showFastIcon ?? false, showFastIconHint, fastModeCooldown, isBrainMode)}>
           <PromptInputModeIndicator mode={mode} isLoading={isLoading} viewingAgentName={viewingAgentName} viewingAgentColor={viewingAgentColor} />
           <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>
             {textInputElement}
@@ -2321,13 +2321,13 @@ function getInitialPasteId(messages: Message[]): number {
   }
   return maxId + 1;
 }
-function buildBorderText(showFastIcon: boolean, showFastIconHint: boolean, fastModeCooldown: boolean, isExecMode: boolean): BorderTextOptions | undefined {
-  if (!showFastIcon && !isExecMode) return undefined
+function buildBorderText(showFastIcon: boolean, showFastIconHint: boolean, fastModeCooldown: boolean, isBrainMode: boolean): BorderTextOptions | undefined {
+  if (!showFastIcon && !isBrainMode) return undefined
   const segments: string[] = []
   if (showFastIcon) {
     segments.push(showFastIconHint ? `${getFastIconString(true, fastModeCooldown)} ${chalk.dim('/fast')}` : getFastIconString(true, fastModeCooldown))
   }
-  if (isExecMode) {
+  if (isBrainMode) {
     segments.push(chalk.yellow('» EXEC'))
   }
   return { content: ` ${segments.join(' ')} `, position: 'top', align: 'end', offset: 0 }

package/src/constants/prompts.ts

@@ -564,7 +564,7 @@ ${CYBER_RISK_INSTRUCTION}`,
     ...(feature('KAIROS') || feature('KAIROS_BRIEF')
       ? [systemPromptSection('brief', () => getBriefSection())]
       : []),
-    DANGEROUS_uncachedSystemPromptSection('exec_policy', () => getExecPolicySection(), 'toggles mid-session via /exec'),
+    DANGEROUS_uncachedSystemPromptSection('brain_policy', () => getBrainPolicySection(), 'toggles mid-session via /brain'),
   ]
 
   const resolvedDynamicSections =
@@ -926,15 +926,50 @@ The user context may include a \`terminalFocus\` field indicating whether the us
 - **Focused**: The user is watching. Be more collaborative — surface choices, ask before committing to large changes, and keep your output concise so it's easy to follow in real time.${BRIEF_PROACTIVE_SECTION && briefToolModule?.isBriefEnabled() ? `\n\n${BRIEF_PROACTIVE_SECTION}` : ''}`
 }
 
-function getExecPolicySection(): string | null {
+function getBrainPolicySection(): string | null {
   const settings = getInitialSettings()
-  if (!settings.execMode) return null
-  return `# Execution Policy (/exec)
+  if (!settings.brainMode) return null
+  return `# Brain Mode (/brain)
 
-When /exec is enabled:
+You are the coordinator — the brain, not the hands. Your context window is precious
+strategic real estate. Implementation details are delegated noise; your job is
+thinking, deciding, and orchestrating.
 
-- Dispatch first: prefer sub-agents for implementation, exploration, and research. Reserve coordinator context for decision-making and orchestration.
-- Keep coordinator context focused on decisions and task orchestration.
-- Compress reports: skip explanations and teaching. Report decisions, blockers, and results.
-- Context protection: every token of your output consumes user's context window. Output what's needed, skip what's not.`
+## Hard Constraints
+
+**You MUST NOT execute work directly.** Do NOT use Bash, Read, Grep, Glob, Write,
+Edit, or any other execution tool yourself. Your only tools are Agent (to delegate)
+and AskUserQuestion (to clarify). Everything else is forbidden.
+
+**Every task goes through sub-agents.** Even a single file read, even a one-line
+grep — delegate it. Your context must stay clean for strategic reasoning.
+
+**When in doubt, spawn an agent.** If you're about to reach for a tool, stop.
+Write a prompt for an agent instead.
+
+## Workflow
+
+1. **Analyze** — understand the user's request at the system level. What's the real
+   goal? What decisions need to be made?
+2. **Decompose** — break into independent workstreams. Each workstream becomes an
+   agent prompt with clear scope, context, and expected output.
+3. **Parallelize** — launch all independent agents simultaneously. Never serialize
+   what can run in parallel.
+4. **Integrate** — synthesize agent results. Make decisions. Report to user.
+5. **Iterate** — if results reveal new questions, spawn another round of agents.
+
+## Agent Prompt Quality
+
+Each agent prompt must include:
+- What we're trying to accomplish and why
+- What's already known / ruled out
+- Specific files, line numbers, commands — never "investigate the bug"
+- Expected output format (short report, code change, test results)
+- Whether to write code or only research
+
+## Output Style
+
+Report compressed: decisions made, blockers hit, next steps. Never narrate what
+agents are doing moment-by-moment. "Agent A found X, agent B confirmed Y. Decision:
+rollback needed." is enough.`
 }

package/src/main.tsx

@@ -2640,7 +2640,7 @@ async function run(): Promise<CommanderCommand> {
         ...(isFastModeEnabled() && {
           fastMode: getInitialFastModeSetting(effectiveModel ?? null)
         }),
-        execMode: getInitialSettings().execMode === true,
+        brainMode: getInitialSettings().brainMode === true,
         ...(isAdvisorEnabled() && advisorModel && {
           advisorModel
         }),

package/src/server/api/providers.ts

@@ -26,6 +26,9 @@ import type { SlotName } from '../types/provider.js'
 import { ApiError, errorResponse } from '../middleware/errorHandler.js'
 
 const providerService = new ProviderService()
+providerService.init().catch((err) =>
+  console.error('[ProviderService] init failed:', err),
+)
 
 function maskApiKey(key: string): string {
   if (key.length <= 8) return '****'
@@ -76,6 +79,23 @@ export async function handleProvidersApi(
       return Response.json(slots)
     }
 
+    // /api/providers/link-vscode — manage VS Code linking
+    if (id === 'link-vscode' && !action) {
+      if (req.method === 'GET') {
+        const status = await providerService.getVscodeStatus()
+        return Response.json(status)
+      }
+      if (req.method === 'POST') {
+        const result = await providerService.linkVscode()
+        return Response.json(result)
+      }
+      if (req.method === 'DELETE') {
+        const result = await providerService.unlinkVscode()
+        return Response.json(result)
+      }
+      throw methodNotAllowed(req.method)
+    }
+
     // PUT /api/providers/slots/:slotName  — set one slot
     if (id === 'slots' && action && req.method === 'PUT') {
       const parsed = SlotNameSchema.safeParse(action)

package/src/server/services/providerService.ts

@@ -41,6 +41,44 @@ const MANAGED_ENV_KEYS = [
   'ANTHROPIC_DEFAULT_OPUS_MODEL',
 ] as const
 
+const CLAUDE_DEFAULT_LABELS: Record<SlotName, string> = {
+  main: 'claude-sonnet-4-5',
+  haiku: 'claude-haiku-4-5',
+  sonnet: 'claude-sonnet-4-5',
+  opus: 'claude-opus-4-7',
+}
+
+const VSCODE_EDITOR_NAMES = ['Code', 'Code - Insiders', 'Cursor'] as const
+
+/**
+ * Return candidate VS Code settings.json paths for the current platform.
+ * These are checked for existence (editor directory must exist) before writing.
+ */
+function getVscodeSettingsPaths(): string[] {
+  const home = os.homedir()
+  const paths: string[] = []
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(appData, name, 'User', 'settings.json'))
+    }
+  } else if (process.platform === 'darwin') {
+    const lib = path.join(home, 'Library', 'Application Support')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(lib, name, 'User', 'settings.json'))
+    }
+  } else {
+    // Linux / other Unix
+    const config = path.join(home, '.config')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(config, name, 'User', 'settings.json'))
+    }
+  }
+
+  return paths
+}
+
 const DEFAULT_INDEX: ProvidersIndex = { activeId: null, providers: [] }
 
 export class ProviderService {
@@ -476,12 +514,172 @@ export class ProviderService {
     const index = await this.readIndex()
     const provider = index.providers.find((p) => p.id === entry.providerId)
     if (!provider) return null
+
+    // Auto-fill Claude model names as label when user hasn't set one.
+    // This lets closed-source clients (e.g. VS Code extension) see Claude
+    // model names while the CLI continues to show the real upstream modelId
+    // (syncSettingsForSlots reads raw entry.label, which stays null).
     return {
       baseUrl: provider.baseUrl,
       apiKey: provider.apiKey,
       apiFormat: provider.apiFormat ?? 'anthropic',
       modelId: entry.modelId,
-      label: entry.label,
+      label: entry.label || CLAUDE_DEFAULT_LABELS[slotName],
+    }
+  }
+
+  // --- VS Code linking ---
+
+  /**
+   * Build the environmentVariables array for VS Code claudeCode settings
+   * based on current slot configuration. Uses user-set labels or falls back
+   * to Claude default model names so the VS Code extension shows the right labels.
+   */
+  private async buildVscodeEnvVars(): Promise<Array<{ name: string; value: string }>> {
+    const slots = await this.readSlots()
+    const index = await this.readIndex()
+
+    function getSlotLabel(slotName: SlotName): string | null {
+      const entry = slots[slotName]
+      if (!entry) return null
+      const provider = index.providers.find((p) => p.id === entry.providerId)
+      if (!provider) return null
+      return entry.label || CLAUDE_DEFAULT_LABELS[slotName]
+    }
+
+    const envVars: Array<{ name: string; value: string }> = [
+      { name: 'ANTHROPIC_BASE_URL', value: `http://127.0.0.1:${ProviderService.serverPort}/proxy` },
+      { name: 'ANTHROPIC_AUTH_TOKEN', value: 'proxy-managed' },
+    ]
+
+    const mainLabel = getSlotLabel("main")
+    if (mainLabel) {
+      envVars.push({ name: "ANTHROPIC_MODEL", value: mainLabel })
+    }
+    const haikuLabel = getSlotLabel("haiku")
+    if (haikuLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_HAIKU_MODEL", value: haikuLabel })
+    }
+    const sonnetLabel = getSlotLabel("sonnet")
+    if (sonnetLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_SONNET_MODEL", value: sonnetLabel })
+    }
+    const opusLabel = getSlotLabel("opus")
+    if (opusLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_OPUS_MODEL", value: opusLabel })
+    }
+
+    return envVars
+  }
+
+  /**
+   * Write claudeCode settings into ALL detected VS Code editor instances
+   * (stable, Insiders, Cursor). Persists linked state in bingo settings so
+   * it survives restarts.
+   */
+  async linkVscode(): Promise<{ paths: string[]; linked: boolean }> {
+    const envVars = await this.buildVscodeEnvVars()
+    const candidatePaths = getVscodeSettingsPaths()
+    const writtenPaths: string[] = []
+
+    for (const settingsPath of candidatePaths) {
+      // Only write if the editor config directory exists (editor is installed)
+      const editorDir = path.dirname(path.dirname(settingsPath))
+      try {
+        await fs.access(editorDir)
+      } catch {
+        continue
+      }
+
+      let settings: Record<string, unknown> = {}
+      try {
+        const raw = await fs.readFile(settingsPath, "utf-8")
+        settings = JSON.parse(raw)
+      } catch {
+        // File does not exist yet — start fresh
+      }
+
+      settings.claudeCode = {
+        ...(settings.claudeCode as Record<string, unknown> || {}),
+        preferredLocation: "panel",
+        disableLoginPrompt: true,
+        environmentVariables: envVars,
+      }
+
+      await fs.mkdir(path.dirname(settingsPath), { recursive: true })
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
+      writtenPaths.push(settingsPath)
+    }
+
+    if (writtenPaths.length === 0) {
+      throw ApiError.badRequest(
+        'No VS Code installation detected. Please install VS Code (stable, Insiders, or Cursor) first.',
+      )
+    }
+
+    // Persist so re-sync on restart and unlink work correctly
+    const bingoSettings = await this.readSettings()
+    bingoSettings.vscodeLinked = true
+    bingoSettings.vscodeLinkedPaths = writtenPaths
+    await this.writeSettings(bingoSettings)
+
+    return { paths: writtenPaths, linked: true }
+  }
+
+  /**
+   * Remove claudeCode keys from all previously-linked VS Code settings files.
+   * Does NOT delete the entire file — it only removes the claudeCode key.
+   */
+  async unlinkVscode(): Promise<{ paths: string[]; linked: boolean }> {
+    const bingoSettings = await this.readSettings()
+    const linkedPaths = (bingoSettings.vscodeLinkedPaths as string[]) || []
+
+    for (const settingsPath of linkedPaths) {
+      try {
+        const raw = await fs.readFile(settingsPath, "utf-8")
+        const settings = JSON.parse(raw)
+        delete settings.claudeCode
+        await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
+      } catch {
+        // File may have been moved or deleted since linking — harmless
+      }
+    }
+
+    bingoSettings.vscodeLinked = false
+    delete bingoSettings.vscodeLinkedPaths
+    await this.writeSettings(bingoSettings)
+
+    return { paths: linkedPaths, linked: false }
+  }
+
+  /**
+   * Return current VS Code link status from persisted bingo settings.
+   */
+  async getVscodeStatus(): Promise<{ linked: boolean; paths: string[] }> {
+    const bingoSettings = await this.readSettings()
+    return {
+      linked: Boolean(bingoSettings.vscodeLinked),
+      paths: (bingoSettings.vscodeLinkedPaths as string[]) || [],
+    }
+  }
+
+  /**
+   * Initialise the service. If vscodeLinked is true in bingo settings,
+   * re-sync VS Code settings so they stay current with the slot config.
+   * Should be called once after server startup.
+   */
+  async init(): Promise<void> {
+    const status = await this.getVscodeStatus()
+    if (status.linked) {
+      try {
+        await this.linkVscode()
+      } catch {
+        // VS Code may have been uninstalled — clear stale state
+        const bingoSettings = await this.readSettings()
+        bingoSettings.vscodeLinked = false
+        delete bingoSettings.vscodeLinkedPaths
+        await this.writeSettings(bingoSettings)
+      }
     }
   }
 

package/src/state/AppStateStore.ts

@@ -421,8 +421,8 @@ export type AppState = DeepImmutable<{
   activeOverlays: ReadonlySet<string>
   // Fast mode
   fastMode?: boolean
-  // Executor mode
-  execMode?: boolean
+  // Brain mode
+  brainMode?: boolean
   // Advisor model for server-side advisor tool (undefined = disabled).
   advisorModel?: string
   // Effort value
@@ -567,6 +567,6 @@ export function getDefaultAppState(): AppState {
     effortValue: undefined,
     activeOverlays: new Set<string>(),
     fastMode: false,
-    execMode: false,
+    brainMode: false,
   }
 }

package/src/utils/attachments.ts

@@ -915,8 +915,8 @@ export async function getAttachments(
     maybe('critical_system_reminder', () =>
       Promise.resolve(getCriticalSystemReminderAttachment(toolUseContext)),
     ),
-    maybe('exec_mode_reminder', () =>
-      Promise.resolve(getExecModeReminderAttachment()),
+    maybe('brain_mode_reminder', () =>
+      Promise.resolve(getBrainModeReminderAttachment()),
     ),
     ...(feature('COMPACTION_REMINDERS')
       ? [
@@ -1593,15 +1593,15 @@ function getCriticalSystemReminderAttachment(
   return [{ type: 'critical_system_reminder', content: reminder }]
 }
 
-function getExecModeReminderAttachment(): Attachment[] {
-  if (!getInitialSettings().execMode) {
+function getBrainModeReminderAttachment(): Attachment[] {
+  if (!getInitialSettings().brainMode) {
     return []
   }
   return [
     {
       type: 'system_reminder' as const,
       content:
-        '/exec active — Dispatch first. Protect context. Report decisions, blockers, results.',
+        '/brain active — Only use Agent and AskUserQuestion. Do NOT use Bash/Read/Grep/Glob/Write/Edit directly. Delegate everything.',
     },
   ]
 }

package/src/utils/settings/types.ts

@@ -725,11 +725,11 @@ export const SettingsSchema = lazySchema(() =>
         .describe(
           'When true, fast mode does not persist across sessions. Each session starts with fast mode off.',
         ),
-      execMode: z
+      brainMode: z
         .boolean()
         .optional()
         .describe(
-          'Priority dispatch, context protection, compressed reporting.',
+          'Coordinator mode — delegates all execution to sub-agents via Agent tool, restricts direct tool use to protect context.',
         ),
       promptSuggestionEnabled: z
         .boolean()

package/src/commands/exec/index.ts

@@ -1,16 +0,0 @@
-import type { Command } from '../../commands.js'
-
-const exec = {
-  type: 'local-jsx',
-  name: 'exec',
-  description:
-    'Enable execution policy — dispatch-first, context protection, compressed output',
-  availability: ['claude-ai', 'console'],
-  aliases: ['executor'],
-  argumentHint: '[off]',
-  isEnabled: () => true,
-  immediate: true,
-  load: () => import('./exec.js'),
-} satisfies Command
-
-export default exec