@empirical-gauzza/cli 1.0.14 → 1.0.16

package/lib/constants.js

@@ -202,7 +202,7 @@ Invite commands operate on the active team workspace. Create prints a shareable
     empirical workspace delete <number|name|id>
     empirical workspace delete <number|name|id> --confirm
 
-Deletion dry-runs by default. \`--confirm\` calls the existing soft-delete endpoint; the Default Brain cannot be deleted. If the active workspace is deleted, the CLI selects the Default Brain.
+Deletion dry-runs by default. \`--confirm\` calls the existing soft-delete endpoint; the Default Workspace cannot be deleted. If the active workspace is deleted, the CLI selects the Default Workspace.
 `,
 
   doctor: `# Empirical Doctor

package/lib/help.js

@@ -19,26 +19,32 @@ function showHelp() {
   log('  empirical plugin check [--force]');
   log('  empirical policy show [--refresh]');
   log('  empirical policy set --json <policy>');
-  log('  empirical auth login');
-  log('  empirical auth logout');
+  log('  empirical auth login                         Interactive browser login');
+  log('  empirical auth logout                        Clear the locally stored session');
   log('  empirical oauth bootstrap headless [--print-access-token]');
+  log('                                                First-time token setup for CI/headless/API-key use');
   log('  empirical oauth bootstrap headless --write-env [--env-output <path>]');
   log('  empirical oauth refresh headless [--print-access-token]');
+  log('                                                Renew an existing headless token before/after it expires');
   log('  empirical oauth refresh headless --write-env [--env-output <path>]');
   log('  empirical oauth bootstrap docker [--print-access-token]');
+  log('                                                Same as bootstrap headless, tuned for container startup');
   log('  empirical oauth refresh docker [--print-access-token]');
   log('  empirical oauth client set [--client-id <id>] [--client-secret <secret>]');
   log('  empirical oauth client show');
   log('  empirical oauth client clear');
-  log('  empirical workspace list');
-  log('  empirical workspace current');
-  log('  empirical workspace select [<number|name>]');
-  log('  empirical workspace use <number|name|id>');
+  log('  empirical workspace list                     List workspaces you can select, and which one is active');
+  log('  empirical workspace current                  Show the currently active workspace');
+  log('  empirical workspace select [<number|name>]   Set the active workspace (prompts if omitted)');
+  log('  empirical workspace use <number|name|id>     Alias for `workspace select`');
   log('  empirical workspace create <name> [--description <text>]');
+  log('                                                Create a new shared team workspace');
   log('  empirical workspace invite create [--role reader|writer|manager] [--expires-in-days <n>] [--max-uses <n>]');
-  log('  empirical workspace invite list');
-  log('  empirical workspace invite revoke <token>');
+  log('                                                Create a shareable invite link for the active team workspace');
+  log('  empirical workspace invite list              List active invites for the active team workspace');
+  log('  empirical workspace invite revoke <token>    Revoke a previously created invite');
   log('  empirical workspace delete <number|name|id> [--confirm]');
+  log('                                                Soft-delete a team workspace (dry-run without --confirm)');
   log('  empirical oauth bootstrap openclaw [--print-access-token]   (legacy alias)');
   log('  empirical oauth refresh openclaw [--print-access-token]     (legacy alias)');
   log('  empirical --oauth-bootstrap-headless [--print-access-token]');

package/lib/installers/hooks.js

@@ -292,21 +292,148 @@ try {
 }
 `;
 
-// EMPIRICAL_HOOK_STOP_SOURCE: fires once per assistant turn (Claude: Stop; Codex: Stop, turn-
-// scoped per codex-rs/hooks/src/engine/dispatcher.rs; Copilot: agentStop, "the main agent
-// finishes a turn" per GitHub's own hooks reference). This is the write-side counterpart to the
-// SessionStart hook above (which only covers recall, once per session boundary) - deliberately
-// simple: it does NOT parse the transcript to detect whether memory-worthy activity happened
-// this turn (transcript formats differ across all three platforms and getting that heuristic
-// wrong silently - the exact class of bug this session spent hours finding - is worse than an
-// unconditional reminder). It never calls the empirical CLI and makes no network call, so the
-// "wasteful per-turn hook" concern that killed the old per-turn UserPromptSubmit hook (see
-// installClaudeHooks below) does not apply here - this is a single static stdout write.
-// ALWAYS exits 0: per Claude Code's documented Stop hook contract, exit 2 forces the agent to
-// keep responding (a blocking decision) - a bug in a hook that's supposed to be an informational
-// nudge must never be able to trap a session in a forced-continuation loop, so this is
-// unconditional regardless of any error encountered.
-const EMPIRICAL_HOOK_STOP_SOURCE = `#!/usr/bin/env node
+// Copilot-only variant of the SessionStart hook. Per GitHub's own hooks reference (fetched
+// 2026-08-08): unlike Claude/Codex, Copilot's sessionStart event has NO output mechanism at all
+// - there is no additionalContext-equivalent field, so a hook cannot inject memory context into
+// the session this way, full stop (this is a genuine platform limitation, not a bug to work
+// around). Separately, Copilot requires ALL hook stdout to be valid JSON parsed via a single
+// JSON.parse call - plain text (fine for Claude, and previously assumed fine here too) is
+// invalid and makes Copilot log a hook execution failure. So this variant still runs the memory
+// query and logs the result for diagnostic/audit purposes, but emits {} (empty, valid JSON,
+// explicitly documented as "use defaults") instead of attempting to inject anything.
+const COPILOT_HOOK_SESSION_START_SOURCE = `#!/usr/bin/env node
+'use strict';
+
+var spawnSync = require('child_process').spawnSync;
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+
+var LOG_PATH = path.join(os.homedir(), '.empirical', 'hooks', 'session-start.log');
+var MAX_LOG_BYTES = 200 * 1024;
+
+function appendLog(line) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    fs.appendFileSync(LOG_PATH, '[' + new Date().toISOString() + '] ' + line + '\\n');
+    var stat = fs.statSync(LOG_PATH);
+    if (stat.size > MAX_LOG_BYTES) {
+      var tail = fs.readFileSync(LOG_PATH, 'utf8').slice(-MAX_LOG_BYTES / 2);
+      fs.writeFileSync(LOG_PATH, tail);
+    }
+  } catch (e) {
+    // Diagnostics must never break session start.
+  }
+}
+
+function resolveEmpiricalEntryPoint() {
+  if (process.platform !== 'win32') {
+    return null;
+  }
+  try {
+    var where = spawnSync('where', ['empirical.cmd'], { encoding: 'utf8', timeout: 5000, shell: true });
+    if (where.status !== 0 || !where.stdout) return null;
+    var cmdPath = where.stdout.split(/\\r?\\n/).map(function (s) { return s.trim(); }).filter(Boolean)[0];
+    if (!cmdPath || !fs.existsSync(cmdPath)) return null;
+    var cmdContent = fs.readFileSync(cmdPath, 'utf8');
+    var match = cmdContent.match(/"%dp0%\\\\(node_modules\\\\.+?\\.js)"/);
+    if (!match) return null;
+    var candidate = path.join(path.dirname(cmdPath), match[1]);
+    return fs.existsSync(candidate) ? candidate : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function commandExists(cmd) {
+  var probe = process.platform === 'win32'
+    ? spawnSync('where', [cmd], { stdio: 'ignore', shell: true })
+    : spawnSync('which', [cmd], { stdio: 'ignore' });
+  return probe.status === 0;
+}
+
+function runMemoryQuery(args) {
+  var entryPoint = resolveEmpiricalEntryPoint();
+  if (entryPoint) {
+    appendLog('resolved direct entry point: ' + entryPoint);
+    return spawnSync(process.execPath, [entryPoint].concat(args), {
+      encoding: 'utf8',
+      timeout: 10000,
+      shell: false
+    });
+  }
+
+  appendLog('direct entry point not resolved, falling back to shell invocation (shell=' + (process.platform === 'win32') + ')');
+  return spawnSync('empirical', args, {
+    encoding: 'utf8',
+    timeout: 10000,
+    shell: process.platform === 'win32'
+  });
+}
+
+function main() {
+  appendLog('hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
+
+  if (!commandExists('empirical')) {
+    appendLog('empirical CLI not found on PATH, exiting');
+    console.log('{}');
+    process.exit(0);
+  }
+
+  var result = runMemoryQuery([
+    'memory', 'query',
+    '--match', 'project context, conventions, recent decisions, user preferences',
+    '--top-k', '8'
+  ]);
+
+  if (!result || result.status !== 0 || !result.stdout) {
+    appendLog('memory query failed or returned no stdout (status=' + (result && result.status) + ', stderr=' + (result && result.stderr ? String(result.stderr).slice(0, 300) : '') + ')');
+    console.log('{}');
+    process.exit(0);
+  }
+
+  var results;
+  try {
+    results = JSON.parse(result.stdout);
+  } catch (e) {
+    appendLog('failed to parse memory query stdout as JSON: ' + e.message);
+    console.log('{}');
+    process.exit(0);
+  }
+
+  if (!Array.isArray(results) || results.length === 0) {
+    appendLog('memory query returned zero results');
+    console.log('{}');
+    process.exit(0);
+  }
+
+  var lines = results.slice(0, 8).map(function (r) {
+    var category = r && r.category ? r.category : 'memory';
+    var summary = r && r.summary ? r.summary : '';
+    return '- [' + category + '] ' + summary;
+  });
+
+  // Logged only - Copilot's sessionStart event has no field that surfaces this to the model.
+  appendLog('memory query returned ' + results.length + ' result(s) (session-start has no output channel to inject them, logged only): ' + lines.join(' | '));
+  console.log('{}');
+  process.exit(0);
+}
+
+try {
+  main();
+} catch (e) {
+  try { appendLog('uncaught error in main(): ' + (e && e.message)); } catch (_e) { /* best effort */ }
+  console.log('{}');
+  process.exit(0);
+}
+`;
+
+// Codex-only variant of the Stop reminder. Confirmed live (2026-08-08, via a real `codex
+// exec` run) that Codex's Stop hook specifically requires a { systemMessage: "..." } JSON shape
+// on stdout - plain text makes Codex report the hook as failed. Distinct from Claude's own JSON
+// shape (hookSpecificOutput.additionalContext, see CLAUDE_HOOK_STOP_SOURCE below) and Copilot's
+// (decision/reason, see COPILOT_HOOK_STOP_SOURCE) - each host has its own schema here.
+const CODEX_HOOK_STOP_SOURCE = `#!/usr/bin/env node
 'use strict';
 
 var fs = require('fs');
@@ -342,10 +469,6 @@ function readStdinPayload() {
 function main() {
   var payload = readStdinPayload();
 
-  // Defensive loop guard: if a Stop hook's own forced-continuation output somehow triggers
-  // another Stop event before the agent produces new output, stop_hook_active (Claude's documented
-  // field name for this) prevents a reminder-print-loop. This hook never sets decision:block
-  // itself, but checking costs nothing and protects against any future change that does.
   if (payload && payload.stop_hook_active === true) {
     appendLog('stop_hook_active=true, skipping reminder');
     process.exit(0);
@@ -353,12 +476,12 @@ function main() {
 
   appendLog('stop hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
 
-  console.log('[Empirical reminder] Before finishing: if this turn included a completed decision, a corrected mistake, or meaningful work worth remembering, record it now via the empirical-memory skill or \`empirical memory record\` - do not wait to be asked.');
+  console.log(JSON.stringify({
+    systemMessage: '[Empirical reminder] Before finishing: if this turn included a completed decision, a corrected mistake, or meaningful work worth remembering, record it now via the empirical-memory skill or \`empirical memory record\` - do not wait to be asked.'
+  }));
   process.exit(0);
 }
 
-// See EMPIRICAL_HOOK_SESSION_START_SOURCE's identical guard above: a crash here must degrade to a
-// silent no-op, never a visible "hook failed" error in the host CLI.
 try {
   main();
 } catch (e) {
@@ -367,12 +490,16 @@ try {
 }
 `;
 
-// Codex-only variant of the Stop reminder above. Confirmed live (2026-08-08, via a real `codex
-// exec` run) that Codex's Stop hook specifically requires a { systemMessage: "..." } JSON shape
-// on stdout - plain text (what EMPIRICAL_HOOK_STOP_SOURCE emits, used by Copilot) makes Codex
-// report the hook as failed. Distinct from Claude's own JSON shape (hookSpecificOutput.
-// additionalContext, see CLAUDE_HOOK_STOP_SOURCE below) - each host has its own schema here.
-const CODEX_HOOK_STOP_SOURCE = `#!/usr/bin/env node
+// Copilot-only variant of the Stop reminder above. Per GitHub's own hooks reference (fetched
+// 2026-08-08): agentStop's output schema is { decision: "block"|"allow", reason, modifiedResponse }
+// - there is no plain message field, so surfacing a reminder means returning decision:"block"
+// with reason as the forced-continuation prompt text. Confirmed this has the same loop-prevention
+// contract Claude Code uses: the input payload includes stop_hook_active ("true when this turn
+// was already forced to continue by a prior 'block' decision" - same semantics, same field name
+// as Claude's), and Copilot has its own hard backstop besides ("After 8 consecutive block
+// continuations, the CLI overrides the hook and ends the turn anyway"). Checking stop_hook_active
+// here means this hook only ever forces one continuation, never chains into that backstop.
+const COPILOT_HOOK_STOP_SOURCE = `#!/usr/bin/env node
 'use strict';
 
 var fs = require('fs');
@@ -409,14 +536,16 @@ function main() {
   var payload = readStdinPayload();
 
   if (payload && payload.stop_hook_active === true) {
-    appendLog('stop_hook_active=true, skipping reminder');
+    appendLog('stop_hook_active=true, skipping reminder (already forced one continuation this turn)');
+    console.log('{}');
     process.exit(0);
   }
 
-  appendLog('stop hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
+  appendLog('stop hook fired (pid=' + process.pid + ', platform=' + process.platform + '), forcing one continuation to surface reminder');
 
   console.log(JSON.stringify({
-    systemMessage: '[Empirical reminder] Before finishing: if this turn included a completed decision, a corrected mistake, or meaningful work worth remembering, record it now via the empirical-memory skill or \`empirical memory record\` - do not wait to be asked.'
+    decision: 'block',
+    reason: '[Empirical reminder] Before finishing: if this turn included a completed decision, a corrected mistake, or meaningful work worth remembering, record it now via the empirical-memory skill or \`empirical memory record\` - do not wait to be asked.'
   }));
   process.exit(0);
 }
@@ -425,6 +554,7 @@ try {
   main();
 } catch (e) {
   try { appendLog('uncaught error in main(): ' + (e && e.message)); } catch (_e) { /* best effort */ }
+  console.log('{}');
   process.exit(0);
 }
 `;
@@ -433,9 +563,9 @@ try {
 // exit 0) is Claude Code's non-blocking Stop-hook feedback channel: the text is fed into context
 // and the conversation continues, same outcome the earlier exit-2 approach achieved, but the
 // transcript UI renders it as a plain system reminder instead of a red "Stop hook error" line.
-// EMPIRICAL_HOOK_STOP_SOURCE above still uses plain console.log + exit 0, which Claude Code treats
-// as non-blocking output that's logged but never reaches the model - that was this hook's original
-// bug (fixed for Claude here, unconfirmed/unfixed for Codex/Copilot's own Stop/agentStop semantics).
+// Codex needs its own systemMessage shape (CODEX_HOOK_STOP_SOURCE) and Copilot its own
+// decision/reason shape (COPILOT_HOOK_STOP_SOURCE) - plain console.log output (what this hook
+// used before the additionalContext fix) never reaches the model on any of the three hosts.
 const CLAUDE_HOOK_STOP_SOURCE = `#!/usr/bin/env node
 'use strict';
 
@@ -534,20 +664,56 @@ function buildPromptReminderMessage(pluginNames) {
 // generation time (via JSON.stringify, so the message is embedded as a single already-escaped
 // string literal - substituted through `${}`, not written as raw template-literal source text,
 // which is what caused the earlier comment-escaping bug in this same file. Never do the latter).
-// `platform`: 'codex' emits Codex's required hookSpecificOutput.additionalContext JSON shape
-// (confirmed live 2026-08-08 via a real `codex exec` run - plain text made Codex report the hook
-// as failed); any other value (default) keeps the original plain console.log for Claude/Copilot,
-// which is confirmed working for both.
+// `platform`:
+//  - 'codex': Codex's required hookSpecificOutput.additionalContext JSON shape (confirmed live
+//    2026-08-08 via a real `codex exec` run - plain text made Codex report the hook as failed).
+//  - 'copilot': Copilot's userPromptSubmitted event has NO additionalContext-equivalent field at
+//    all (confirmed via GitHub's own hooks reference, fetched 2026-08-08) - the only output field
+//    is modifiedPrompt, which REPLACES the prompt for the rest of the turn. So this reads the
+//    real prompt text from stdin's `prompt` field and returns it with the reminder appended -
+//    more invasive than Claude/Codex's side-channel injection (it's now part of the visible
+//    prompt), but it's the only mechanism this event actually has. Falls back to {} (leave
+//    unchanged) if stdin can't be read/parsed or has no prompt field, so a parsing edge case can
+//    never corrupt or blank out the user's actual prompt.
+//  - default (Claude/Copilot's plain console.log was the old assumption for both - WRONG for
+//    Copilot, which requires valid JSON on stdout for every event, confirmed via the same fetch
+//    above): plain console.log, confirmed correct for Claude only.
 function buildUserPromptSubmitHookSource(pluginNames, platform) {
   const messageLiteral = JSON.stringify(buildPromptReminderMessage(pluginNames));
-  const outputStatement = platform === 'codex'
-    ? `console.log(JSON.stringify({
+
+  let stdinHelper = '';
+  let outputStatement;
+  if (platform === 'codex') {
+    outputStatement = `console.log(JSON.stringify({
     hookSpecificOutput: {
       hookEventName: 'UserPromptSubmit',
       additionalContext: ${messageLiteral}
     }
-  }));`
-    : `console.log(${messageLiteral});`;
+  }));`;
+  } else if (platform === 'copilot') {
+    stdinHelper = `
+function readStdinPayload() {
+  try {
+    var raw = fs.readFileSync(0, 'utf8');
+    return raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    return {};
+  }
+}
+`;
+    outputStatement = `var payload = readStdinPayload();
+  if (payload && typeof payload.prompt === 'string' && payload.prompt.length > 0) {
+    console.log(JSON.stringify({
+      modifiedPrompt: payload.prompt + '\\n\\n' + ${messageLiteral}
+    }));
+  } else {
+    appendLog('no usable prompt field on stdin payload, leaving prompt unchanged');
+    console.log('{}');
+  }`;
+  } else {
+    outputStatement = `console.log(${messageLiteral});`;
+  }
+
   return `#!/usr/bin/env node
 'use strict';
 
@@ -571,7 +737,7 @@ function appendLog(line) {
     // Diagnostics must never break the hook.
   }
 }
-
+${stdinHelper}
 // A crash here must degrade to a silent no-op, never a visible "hook failed" error in the host CLI.
 try {
   appendLog('user-prompt-submit hook fired (pid=' + process.pid + ', platform=' + process.platform + ')');
@@ -591,6 +757,18 @@ function buildHookCommand(scriptPath) {
   return `"${process.execPath}" "${scriptPath}"`;
 }
 
+// Confirmed live (2026-08-08, via a real `copilot -p` run with debug logging): Copilot runs a
+// hook's "command"/"powershell" field through powershell.exe on Windows, and a bare
+// `"path" "arg"` string is not valid PowerShell syntax without the call operator (&) - two
+// adjacent quoted string literals with nothing between them is a ParserError
+// ("Unexpected token '...' in expression or statement"), not a "file not found"-style failure.
+// This is a completely different bug from Codex's (which needed 8.3 short paths to avoid
+// quoting) - no short-path workaround is needed here, just the operator PowerShell requires
+// before an executable path.
+function buildPowershellHookCommand(scriptPath) {
+  return `& "${process.execPath}" "${scriptPath}"`;
+}
+
 function removeEmpiricalHookEntries(entries, scriptPath) {
   if (!Array.isArray(entries)) return [];
   return entries
@@ -807,9 +985,9 @@ function installCopilotHooks(pluginNames) {
   const sessionStartScriptPath = path.join(hooksDir, 'copilot-session-start.js');
   const stopScriptPath = path.join(hooksDir, 'copilot-stop.js');
   const userPromptScriptPath = path.join(hooksDir, 'copilot-user-prompt-submit.js');
-  writeFile(sessionStartScriptPath, CLAUDE_HOOK_SESSION_START_SOURCE);
-  writeFile(stopScriptPath, EMPIRICAL_HOOK_STOP_SOURCE);
-  writeFile(userPromptScriptPath, buildUserPromptSubmitHookSource(pluginNames));
+  writeFile(sessionStartScriptPath, COPILOT_HOOK_SESSION_START_SOURCE);
+  writeFile(stopScriptPath, COPILOT_HOOK_STOP_SOURCE);
+  writeFile(userPromptScriptPath, buildUserPromptSubmitHookSource(pluginNames, 'copilot'));
 
   const copilotHooksDir = path.join(os.homedir(), '.copilot', 'hooks');
   ensureDir(copilotHooksDir);
@@ -826,19 +1004,38 @@ function installCopilotHooks(pluginNames) {
   }
 
   const hookFilePath = path.join(copilotHooksDir, 'empirical-hooks.json');
+  // Both `command` (POSIX fallback) and `powershell` (Windows-explicit, with the & call operator
+  // PowerShell requires - see buildPowershellHookCommand) are always set: per GitHub's hooks
+  // reference, an explicit `powershell` entry takes precedence over `command` on Windows, so this
+  // is correct on both platforms without needing to detect the install-time OS here.
   const hookFileContent = {
     version: 1,
     hooks: {
       sessionStart: [
-        { type: 'command', command: buildHookCommand(sessionStartScriptPath), timeoutSec: 15 }
+        {
+          type: 'command',
+          command: buildHookCommand(sessionStartScriptPath),
+          powershell: buildPowershellHookCommand(sessionStartScriptPath),
+          timeoutSec: 15
+        }
       ],
       // "userPromptSubmitted" per GitHub's hooks reference ("The user submits a prompt") - not
       // "userPromptSubmit" (that camelCase spelling is Claude/Codex's convention, not Copilot's).
       userPromptSubmitted: [
-        { type: 'command', command: buildHookCommand(userPromptScriptPath), timeoutSec: 10 }
+        {
+          type: 'command',
+          command: buildHookCommand(userPromptScriptPath),
+          powershell: buildPowershellHookCommand(userPromptScriptPath),
+          timeoutSec: 10
+        }
       ],
       agentStop: [
-        { type: 'command', command: buildHookCommand(stopScriptPath), timeoutSec: 10 }
+        {
+          type: 'command',
+          command: buildHookCommand(stopScriptPath),
+          powershell: buildPowershellHookCommand(stopScriptPath),
+          timeoutSec: 10
+        }
       ]
     }
   };
@@ -850,13 +1047,15 @@ function installCopilotHooks(pluginNames) {
 module.exports = {
   CLAUDE_HOOK_SESSION_START_SOURCE,
   CODEX_HOOK_SESSION_START_SOURCE,
-  EMPIRICAL_HOOK_STOP_SOURCE,
+  COPILOT_HOOK_SESSION_START_SOURCE,
   CODEX_HOOK_STOP_SOURCE,
+  COPILOT_HOOK_STOP_SOURCE,
   CLAUDE_HOOK_STOP_SOURCE,
   buildPromptReminderMessage,
   buildUserPromptSubmitHookSource,
   getEmpiricalHooksDir,
   buildHookCommand,
+  buildPowershellHookCommand,
   removeEmpiricalHookEntries,
   installClaudeHooks,
   getCodexHomeDir,

package/lib/workspaceCommands.js

@@ -174,11 +174,11 @@ async function runWorkspaceCommand(args) {
           const selected = payload.defaultOption.selected
             ? payload.defaultOption
             : (payload.workspaces || []).find((ws) => ws.selected) || payload.defaultOption;
-          log(`Current workspace: ${selected.label || 'Default Brain'}`);
+          log(`Current workspace: ${selected.label || 'Default Workspace'}`);
           return;
         }
         const payload = await httpJson(currentUrl, 'GET', null, authHeaders);
-        log(`Current workspace: ${payload?.current?.label || 'Default Brain'}`);
+        log(`Current workspace: ${payload?.current?.label || 'Default Workspace'}`);
         if (payload?.locked) {
           log('This OAuth client is admin-locked to a workspace.');
         }
@@ -206,7 +206,7 @@ async function runWorkspaceCommand(args) {
         }
 
         if (!requested) {
-          throw new Error('Please provide a workspace selection, e.g. `empirical workspace use 1` or `empirical workspace use "Default Brain"`.');
+          throw new Error('Please provide a workspace selection, e.g. `empirical workspace use 1` or `empirical workspace use "Default Workspace"`.');
         }
 
         const target = resolveWorkspaceTarget(requested, payload, teamPayload);
@@ -250,7 +250,7 @@ async function runWorkspaceCommand(args) {
         if (target?.ambiguous) throw new Error(`Ambiguous workspace: ${requested}. Use its list number or workspace ID.`);
         if (!target) throw new Error(`Workspace not found: ${requested}`);
         if (target.isDefault || target.key === 'default_brain') {
-          throw new Error('The Default Brain cannot be deleted.');
+          throw new Error('The Default Workspace cannot be deleted.');
         }
         if (!target.workspaceId) throw new Error(`Workspace is not a deletable team brain: ${target.label}`);
 
@@ -265,7 +265,7 @@ async function runWorkspaceCommand(args) {
         if (target.selected && clientId) {
           const updateUrl = new URL(`/oauth/clients/${encodedClientId}/workspace-selection`, baseUrl).toString();
           const updated = await httpJson(updateUrl, 'POST', { key: 'default_brain' }, authHeaders);
-          log(uiSuccess(`Soft-deleted workspace ${targetDescription}. Active workspace reset to ${updated?.current?.label || 'Default Brain'}.`));
+          log(uiSuccess(`Soft-deleted workspace ${targetDescription}. Active workspace reset to ${updated?.current?.label || 'Default Workspace'}.`));
           clearSelectedWorkspace();
         } else {
           log(uiSuccess(`Soft-deleted workspace ${targetDescription}.`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empirical-gauzza/cli",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Empirical CLI installer and local MCP wiring helper",
   "type": "commonjs",
   "license": "MIT",