@causyne/agent 1.10.5 → 1.10.11

package/README.md

@@ -12,11 +12,29 @@ documentation is intentionally concise while the project is evolving.
 
 Learn more at [causyne.com](https://causyne.com/).
 
+## Install
+
+On macOS, Linux, or WSL:
+
+```sh
+curl -fsSL https://causyne.com/install.sh | bash
+```
+
+On Windows PowerShell:
+
+```powershell
+irm https://causyne.com/install.ps1 | iex
+```
+
+Open a project directory and run `causyne`. Managed installations check the
+official npm release channel for updates. Run `causyne doctor` to inspect the
+runtime and update channel.
+
 ## Contact
 
 - General inquiries and business communication: [contact@causyne.com](mailto:contact@causyne.com)
 - Product support and troubleshooting: [help@causyne.com](mailto:help@causyne.com)
-- Partnerships and direct founder communication: [ikbal@causyne.com](mailto:ikbal@causyne.com)
+- Partnerships and direct communication: [ikbal@causyne.com](mailto:ikbal@causyne.com)
 
 ## Development
 

package/bin/causyne.js

@@ -5,6 +5,11 @@ if (Number(process.versions.node.split('.')[0]) < 24) {
   process.exit(1);
 }
 try {
+  const { startUpdateChecker } = await import('../src/autoUpdate.js');
+  const update = await startUpdateChecker();
+  if (update && update.updated) {
+    process.stderr.write(`Causyne updated to ${update.latest}. Starting the new version.\n`);
+  }
   await import('../src/entrypoint.js');
 } catch (error) {
   if (process.stdout.isTTY) process.stdout.write('\x1b[?1006l\x1b[?1000l\x1b[?2004l\x1b[?25h');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causyne/agent",
-  "version": "1.10.5",
+  "version": "1.10.11",
   "description": "Agentic AI for software, tools, and computer workflows",
   "main": "bin/causyne.js",
   "type": "module",

package/src/autoUpdate.js

@@ -1,12 +1,226 @@
+// Causyne package updates.
+//
+// Updates are intentionally limited to installations managed by npm or by the
+// causyne.com installer. A source checkout is never rewritten. Commands are
+// passed as argv arrays with shell disabled, and the only accepted package is
+// the public @causyne/agent package from the npm registry.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
 import { UI } from './utils/cli_ui.js';
+import { causyneHome } from './utils/paths.js';
+import { getPackageVersion } from './version.js';
+
+const PACKAGE_NAME = '@causyne/agent';
+const REGISTRY_LATEST = 'https://registry.npmjs.org/@causyne%2fagent/latest';
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function updateStateFile(options = {}) {
+  if (options.stateFile) return path.resolve(options.stateFile);
+  const env = options.env || process.env;
+  const root = env.CAUSYNE_HOME && String(env.CAUSYNE_HOME).trim()
+    ? path.resolve(String(env.CAUSYNE_HOME).trim())
+    : causyneHome();
+  return path.join(root, 'update-state.json');
+}
+
+function versionParts(version) {
+  const match = String(version || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!match) return null;
+  return { numbers: match.slice(1, 4).map(Number), prerelease: match[4] || '' };
+}
+
+export function compareVersions(left, right) {
+  const a = versionParts(left);
+  const b = versionParts(right);
+  if (!a || !b) return 0;
+  for (let index = 0; index < 3; index++) {
+    if (a.numbers[index] !== b.numbers[index]) return a.numbers[index] > b.numbers[index] ? 1 : -1;
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  const aParts = a.prerelease.split('.');
+  const bParts = b.prerelease.split('.');
+  const length = Math.max(aParts.length, bParts.length);
+  for (let index = 0; index < length; index++) {
+    if (aParts[index] === undefined) return -1;
+    if (bParts[index] === undefined) return 1;
+    if (aParts[index] === bParts[index]) continue;
+    const aNumeric = /^\d+$/.test(aParts[index]);
+    const bNumeric = /^\d+$/.test(bParts[index]);
+    if (aNumeric && bNumeric) return Number(aParts[index]) > Number(bParts[index]) ? 1 : -1;
+    if (aNumeric !== bNumeric) return aNumeric ? -1 : 1;
+    return aParts[index].localeCompare(bParts[index]);
+  }
+  return 0;
+}
+
+function managedPrefix(packageRoot = PACKAGE_ROOT, env = process.env) {
+  if (env.CAUSYNE_INSTALL_ROOT) return path.resolve(env.CAUSYNE_INSTALL_ROOT);
+
+  const markers = [
+    path.join('lib', 'node_modules', '@causyne', 'agent'),
+    path.join('node_modules', '@causyne', 'agent')
+  ];
+  for (const marker of markers) {
+    const index = packageRoot.lastIndexOf(marker);
+    if (index >= 0 && index + marker.length === packageRoot.length) {
+      return packageRoot.slice(0, index).replace(/[\\/]$/, '');
+    }
+  }
+  return null;
+}
+
+export function installationInfo(options = {}) {
+  const env = options.env || process.env;
+  const packageRoot = options.packageRoot || PACKAGE_ROOT;
+  const prefix = managedPrefix(packageRoot, env);
+  return {
+    managed: Boolean(prefix),
+    type: env.CAUSYNE_INSTALL_ROOT ? 'causyne.com installer' : (prefix ? 'global npm' : 'source checkout'),
+    prefix,
+    packageRoot,
+    npmCommand: env.CAUSYNE_NPM_COMMAND || (process.platform === 'win32' ? 'npm.cmd' : 'npm')
+  };
+}
+
+function readState(options = {}) {
+  try {
+    return JSON.parse(fs.readFileSync(updateStateFile(options), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeState(state, options = {}) {
+  try {
+    const stateFile = updateStateFile(options);
+    fs.mkdirSync(path.dirname(stateFile), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), { mode: 0o600 });
+  } catch {
+    // Update state is an optimisation. Failure must never stop the CLI.
+  }
+}
+
+export async function latestPackageVersion(options = {}) {
+  const fetchImpl = options.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') throw new Error('This Node.js runtime has no fetch implementation.');
+  const timeoutMs = options.timeoutMs || 3500;
+  const signal = options.signal || AbortSignal.timeout(timeoutMs);
+  const response = await fetchImpl(REGISTRY_LATEST, {
+    headers: { accept: 'application/json', 'user-agent': `causyne/${getPackageVersion()}` },
+    signal
+  });
+  if (!response.ok) throw new Error(`npm registry returned HTTP ${response.status}`);
+  const metadata = await response.json();
+  if (metadata.name !== PACKAGE_NAME || !versionParts(metadata.version)) {
+    throw new Error('npm registry returned invalid package metadata');
+  }
+  return metadata.version;
+}
+
+function installLatest(info, options = {}) {
+  const runner = options.spawnSyncImpl || spawnSync;
+  const args = [
+    'install', '--global', '--prefix', info.prefix,
+    `${PACKAGE_NAME}@${options.version}`, '--ignore-scripts', '--no-audit', '--no-fund'
+  ];
+  const result = runner(info.npmCommand, args, {
+    shell: false,
+    stdio: options.verbose ? 'inherit' : 'pipe',
+    encoding: 'utf8',
+    env: options.env || process.env
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const detail = String(result.stderr || result.stdout || '').trim();
+    throw new Error(detail || `npm exited with status ${result.status}`);
+  }
+}
+
+export async function checkForUpdate(options = {}) {
+  const current = options.currentVersion || getPackageVersion();
+  const latest = await latestPackageVersion(options);
+  return { current, latest, available: compareVersions(latest, current) > 0 };
+}
+
+export async function runSelfUpdate(verbose = false, options = {}) {
+  const info = installationInfo(options);
+  if (!info.managed) {
+    if (verbose) UI.printInfo('This is a source checkout. Update it with Git; Causyne will not rewrite developer source.');
+    return { updated: false, reason: 'source-checkout', ...info };
+  }
+
+  try {
+    const status = await checkForUpdate(options);
+    if (!status.available) {
+      writeState({ checkedAt: Date.now(), latest: status.latest }, options);
+      if (verbose) UI.printSuccess(`Causyne ${status.current} is up to date.`);
+      return { updated: false, reason: 'current', ...status, ...info };
+    }
+
+    if (verbose) UI.printInfo(`Updating Causyne ${status.current} → ${status.latest}...`);
+    installLatest(info, { ...options, version: status.latest, verbose });
+    writeState({ checkedAt: Date.now(), latest: status.latest, installedAt: Date.now() }, options);
+    if (verbose) UI.printSuccess(`Updated to Causyne ${status.latest}.`);
+    return { updated: true, ...status, ...info };
+  } catch (error) {
+    writeState({ checkedAt: Date.now(), error: error.message }, options);
+    if (verbose) UI.printError(`Update failed: ${error.message}`);
+    return { updated: false, reason: 'failed', error: error.message, ...info };
+  }
+}
+
+/** Check on launch, at most once every six hours. */
+export async function startUpdateChecker(options = {}) {
+  const env = options.env || process.env;
+  if (env.CAUSYNE_DISABLE_AUTOUPDATE === '1' || env.CAUSYNE_DISABLE_AUTOUPDATE === 'true') {
+    return { updated: false, reason: 'disabled' };
+  }
+
+  const info = installationInfo(options);
+  if (!info.managed) return { updated: false, reason: 'source-checkout', ...info };
+
+  const state = readState(options);
+  if (!options.force && Number.isFinite(state.checkedAt)
+      && Date.now() - state.checkedAt < CHECK_INTERVAL_MS) {
+    return { updated: false, reason: 'recently-checked', latest: state.latest, ...info };
+  }
+
+  return runSelfUpdate(false, options);
+}
 
-// No registry polling or self-modifying installation. A release channel has
-// not been selected or published for the independent Causyne project yet.
-export async function runSelfUpdate(verbose = false) {
-  if (verbose) UI.printInfo('Automatic updates are disabled. Review and update your Causyne source checkout explicitly. No public package is configured yet.');
-  return false;
+export async function diagnoseInstallation(options = {}) {
+  const info = installationInfo(options);
+  let update;
+  try {
+    update = await checkForUpdate(options);
+  } catch (error) {
+    update = { current: getPackageVersion(), latest: null, available: false, error: error.message };
+  }
+  return {
+    ...info,
+    ...update,
+    autoUpdates: !['1', 'true'].includes(String((options.env || process.env).CAUSYNE_DISABLE_AUTOUPDATE || '').toLowerCase())
+  };
 }
 
-export function startUpdateChecker() {
-  // Compatibility with the local CLI caller; deliberately no timer or I/O.
+export function formatDoctorReport(status, runtime = process) {
+  const rows = [
+    `Version       : ${status.current}`,
+    `Latest        : ${status.latest || `unavailable (${status.error || 'unknown error'})`}`,
+    `Installation  : ${status.type}`,
+    `Package root  : ${status.packageRoot}`,
+    `Node.js       : ${runtime.version}`,
+    `Platform      : ${runtime.platform} ${runtime.arch}`,
+    `Auto updates  : ${status.autoUpdates ? 'enabled' : 'disabled'}`,
+    `Workspace     : ${runtime.cwd()}`
+  ];
+  if (status.available) rows.push('Update         : available — run `causyne update`');
+  return rows.join('\n');
 }

package/src/cliMode.js

@@ -11,6 +11,7 @@ import { wrapBlock } from './tui/text.js';
 import { getPackageVersion } from './version.js';
 import { resolveCharPool } from './contextManager.js';
 import { PRIMARY_ACTIONS, homeStatusLine, homeHint, moreLayer, configureInPrompt, mcpPicker, PROVIDERS } from './tui/home.js';
+import { SelectLayer } from './tui/dialogs.js';
 import { askSelect, askText, askConfirm } from './tui/ask.js';
 import { renderReport } from './reporting.js';
 import { grantAlways } from './approvalGrants.js';
@@ -352,8 +353,8 @@ export async function chatMode({ home = false } = {}) {
         root: process.cwd(),
         commands: listCommands('terminal'),
         // The rule for "is this a command" lives in commands.js and is handed
-        // down rather than reimplemented, so the prompt draws a `/usage` as an
-        // invocation instead of as a sentence the user supposedly said.
+        // down rather than reimplemented, so the prompt keeps `/usage` out of
+        // the conversation instead of drawing it as something the user said.
         isCommand: isCommandInput,
         surface,
         onInterrupt: () => loop.abort(),
@@ -458,6 +459,38 @@ export async function chatMode({ home = false } = {}) {
         continue;
       }
 
+      if (commandResult.effect === 'pick-session' && prompt) {
+        const active = commandResult.active;
+        prompt.openLayer(new SelectLayer({
+          title: 'Sessions',
+          emptyText: 'No sessions yet',
+          items: (commandResult.items || []).map((session) => ({
+            id: session.id,
+            label: `${session.id === active ? `${GLYPHS.bullet} ` : ''}${session.title}`,
+            description: `${session.messageCount} messages ${GLYPHS.dot} ${session.workspace || 'no workspace'}`,
+            value: session
+          })),
+          onPick: (item) => {
+            if (item) prompt.deliver(`/sessions switch ${item.value.id}`);
+          }
+        }));
+        continue;
+      }
+
+      if (commandResult.effect === 'pick-mcp' && prompt) {
+        const { empty } = await mcpPicker(prompt, (server) => {
+          const verb = server.granted ? 'revoke' : 'grant';
+          prompt.deliver(`/mcp ${verb} ${server.name}`);
+        });
+        if (empty) prompt.showText('MCP servers', commandResult.output);
+        continue;
+      }
+
+      if (commandResult.effect === 'dialog' && prompt) {
+        prompt.showText(commandResult.title, commandResult.output, { danger: !commandResult.ok });
+        continue;
+      }
+
       // A skill was invoked: it becomes part of the REQUEST, not terminal output.
       //
       // This is the whole point. `/skills <id>` used to print the file and call

package/src/commands.js

@@ -47,6 +47,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/help [command]',
     description: 'List the available commands',
+    dialogTitle: 'Commands',
     run: (argv, ctx) => {
       const [wanted] = argv;
       if (wanted) {
@@ -335,6 +336,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/checkpoints [count]',
     description: 'List recent undo checkpoints',
+    dialogTitle: 'Checkpoints',
     run: (argv) => ok(buildCheckpointsText(parseInt(argv[0], 10) || 15))
   },
 
@@ -344,6 +346,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/context',
     description: 'Show what fills the context window',
+    dialogTitle: 'Context',
     run: () => ok(buildContextText())
   },
 
@@ -353,6 +356,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/usage',
     description: 'Show token usage and estimated cost',
+    dialogTitle: 'Usage',
     run: async () => ok(await buildUsageText())
   },
 
@@ -362,6 +366,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/cortex [list | forget <id> | forget-here]',
     description: 'Inspect what the agent has learned, and forget any of it',
+    dialogTitle: 'Cortex',
     // A memory store you cannot read is not a memory, it is a black box that
     // occasionally changes the agent's behaviour. Section 4 asks for intelligent
     // safety rather than opacity, and section 10 layer 5 asks for a trail a
@@ -426,6 +431,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/sessions [switch <id> | delete <id>]',
     description: 'List chat sessions, or switch to one',
+    dialogTitle: 'Sessions',
     // Sessions replaced ONE global chat_history.json that every directory read.
     // A session you cannot list or switch to is not a session, so this ships
     // with the store rather than after it.
@@ -462,7 +468,8 @@ export const COMMANDS = [
       return ok(
         `${rows.length} session${rows.length === 1 ? '' : 's'} (* = active):\n`
         + lines.join('\n')
-        + '\n\nSwitch with /sessions switch <id>. A new directory always starts a new session.'
+        + '\n\nSwitch with /sessions switch <id>. A new directory always starts a new session.',
+        { effect: 'pick-session', items: rows, active }
       );
     }
   },
@@ -472,6 +479,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/approvals [clear]',
     description: 'List tools granted "Allow always", or revoke them',
+    dialogTitle: 'Approvals',
     // A standing grant with no way to see or revoke it is a trap, not a
     // convenience. This is the way out, and the confirm dialog that grants one
     // names this command so the user is told about it at the moment it matters.
@@ -541,6 +549,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/model [provider/model | model]',
     description: 'Show or change the model in use',
+    dialogTitle: 'Model',
     run: (argv) => {
       const config = loadConfig();
       if (argv.length === 0) {
@@ -567,6 +576,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke <name>]',
     description: 'Manage MCP servers: list, add, remove, grant, revoke',
+    dialogTitle: 'MCP servers',
     run: (argv) => {
       const [action, serverName, ...rest] = argv;
 
@@ -622,7 +632,7 @@ export const COMMANDS = [
 
       const servers = serverStatus();
       if (servers.length === 0) {
-        return ok('No MCP servers are configured.\n\nAdd one with:\n  mcp add <name> <command> [args…]\n  mcp add <name> --url <https://…>\n\n(prefix with / in chat, or `causyne-agent mcp …` in a terminal)');
+        return ok('No MCP servers are configured.\n\nAdd one with:\n  mcp add <name> <command> [args…]\n  mcp add <name> --url <https://…>\n\n(prefix with / in chat, or `causyne-agent mcp …` in a terminal)', { effect: 'pick-mcp' });
       }
       const lines = ['MCP servers', ''];
       for (const server of servers) {
@@ -632,7 +642,7 @@ export const COMMANDS = [
       }
       lines.push('');
       lines.push('  mcp grant <name> to enable, mcp remove <name> to delete.');
-      return ok(lines.join('\n'));
+      return ok(lines.join('\n'), { effect: 'pick-mcp' });
     }
   },
 
@@ -703,6 +713,7 @@ export const COMMANDS = [
     scope: 'local',
     usage: '/status',
     description: 'Show the current provider, autonomy mode and workspace scope',
+    dialogTitle: 'Status',
     // One builder, shared with `causyne status`, so status output cannot drift.
     run: (argv, ctx) => ok(buildStatusText({ loop: ctx.loop || null }))
   },
@@ -791,7 +802,11 @@ export async function runCommand(name, argv = [], ctx = {}) {
   }
 
   try {
-    return await command.run(argv, { ...ctx, surface });
+    const result = await command.run(argv, { ...ctx, surface });
+    if (command.dialogTitle && result && !result.effect) {
+      return { ...result, effect: 'dialog', title: command.dialogTitle };
+    }
+    return result;
   } catch (e) {
     return fail(`/${command.name} failed: ${e.message}`);
   }

package/src/entrypoint.js

@@ -1,7 +1,7 @@
 import { program } from 'commander';
 
 import { runTask, chatMode, execCommand, interactiveConfig } from './cliMode.js';
-import { runSelfUpdate } from './autoUpdate.js';
+import { runSelfUpdate, diagnoseInstallation, formatDoctorReport } from './autoUpdate.js';
 import { printContextReport, printUsageReport, printCheckpoints, printUndo, buildStatusText, printReport } from './reporting.js';
 import { runCommand } from './commands.js';
 import { resolveInvocation } from './tui/invocation.js';
@@ -70,11 +70,19 @@ program
 
 program
   .command('update')
-  .description('Show source update guidance (no automatic installation)')
+  .description('Check for and install the latest Causyne Agent release')
   .action(async () => {
     await runSelfUpdate(true);
   });
 
+program
+  .command('doctor')
+  .description('Inspect the installation, runtime and update channel')
+  .action(async () => {
+    const status = await diagnoseInstallation();
+    printReport(formatDoctorReport(status), { title: 'Doctor' });
+  });
+
 program
   .command('status')
   .description('Show local provider, workspace and runtime status')

package/src/gitSnapshot.js

@@ -164,6 +164,13 @@ export function initShadow(worktree) {
     }
   }
 
+  // A checkpoint promises the exact bytes that were present when it was
+  // captured. Git for Windows commonly inherits core.autocrlf=true from the
+  // host, which would turn an LF blob into CRLF during restore. This shadow
+  // repository is a byte store, so text conversion must stay disabled even
+  // when an existing shadow is reused after an upgrade.
+  runGit(['--git-dir', gitDir, 'config', 'core.autocrlf', 'false']);
+
   // Point at the user's object database so blobs are never re-hashed, and adopt
   // their index so already-hashed entries are reused. Both are best-effort: a
   // missing or incompatible source just means a full, slower add.

package/src/tui/home.js

@@ -42,17 +42,19 @@ export const PRIMARY_ACTIONS = [
     run: async () => (await import('../reporting.js')).buildUsageText()
   },
   { id: 'config', label: 'config', hint: 'provider, model, API key', kind: 'config' },
-  { id: 'more', label: 'more…', hint: 'context · checkpoints · undo · mcp · update', kind: 'more' }
+  { id: 'more', label: 'more…', hint: 'sessions · model · approvals · tools', kind: 'more' }
 ];
 
 /**
  * The second page.
  *
- * These are real, and several of them are destructive, which is why they are
- * one level down rather than absent: hiding `unpair` would not make it safer,
- * it would make it undiscoverable.
+ * These are real local capabilities kept one level down so the first screen
+ * stays readable while the complete command surface remains discoverable.
  */
 export const MORE_ACTIONS = [
+  { id: 'sessions', label: 'sessions', category: 'workspace', hint: 'browse saved local sessions', kind: 'command', command: '/sessions' },
+  { id: 'model', label: 'model', category: 'workspace', hint: 'show the active provider and model', kind: 'command', command: '/model' },
+  { id: 'approvals', label: 'approvals', category: 'workspace', hint: 'review standing session approvals', kind: 'command', command: '/approvals' },
   {
     id: 'context', label: 'context', category: 'reports', hint: 'what fills the context window', kind: 'stay',
     run: async () => (await import('../reporting.js')).buildContextText()
@@ -69,14 +71,21 @@ export const MORE_ACTIONS = [
     command: '/undo'
   },
   { id: 'mcp', label: 'mcp', category: 'tools', hint: 'manage MCP servers', kind: 'mcp' },
+  { id: 'help', label: 'commands', category: 'tools', hint: 'show every slash command', kind: 'command', command: '/help' },
+  {
+    id: 'doctor', label: 'doctor', category: 'tools', hint: 'installation, runtime and update channel', kind: 'stay',
+    run: async () => {
+      const { diagnoseInstallation, formatDoctorReport } = await import('../autoUpdate.js');
+      return formatDoctorReport(await diagnoseInstallation());
+    }
+  },
   {
     id: 'update', label: 'update', category: 'tools', hint: 'update to the latest version', kind: 'takeover',
     run: async () => {
       const { runSelfUpdate } = await import('../autoUpdate.js');
       await runSelfUpdate(true);
     }
-  },
-
+  }
 ];
 
 /** Items in the shape SelectList wants, for the `more…` page. */
@@ -207,7 +216,7 @@ export async function mcpPicker(prompt, onAction) {
     items: rows.map((server) => ({
       id: server.name,
       label: server.name,
-      description: `${server.granted ? 'granted' : 'not granted'}${server.command ? ` ${GLYPHS.dot} ${server.command}` : ''}`,
+      description: `${server.granted ? 'granted' : 'not granted'}${server.target ? ` ${GLYPHS.dot} ${server.target}` : ''}`,
       category: server.granted ? 'granted' : 'available',
       value: server
     })),

package/src/tui/prompt.js

@@ -23,10 +23,10 @@ import { PromptHistory } from './history.js';
 import { FileIndex, suggest, applyCompletion, renderPicker, MAX_VISIBLE } from './completion.js';
 import { paint, dim, bold, GLYPHS, terminalWidth, HAS_COLOR } from './theme.js';
 import { barBlock, GUTTER } from './block.js';
-import { visibleWidth, truncate, wrapBlock, shortenHome } from './text.js';
+import { visibleWidth, truncate, wrapBlock, shortenHome, safeDisplay } from './text.js';
 import { pickExample, fitHints } from './banner.js';
 import { panelRows } from './overlay.js';
-import { commandPalette, skillPicker, ApprovalLayer, ConfirmLayer, HomeLayer } from './dialogs.js';
+import { commandPalette, skillPicker, ApprovalLayer, ConfirmLayer, HomeLayer, TextLayer } from './dialogs.js';
 import { describeTool } from './toolDisplay.js';
 
 const CTRL_C_WINDOW_MS = 2000;
@@ -419,6 +419,19 @@ export class ChatPrompt {
     }));
   }
 
+  /** Show local command output inside the live region, never in chat scrollback. */
+  showText(title, text, options = {}) {
+    const panelWidth = Math.max(28, Math.min(this.width() - 2, options.width || 76));
+    const contentWidth = Math.max(12, panelWidth - 4);
+    const lines = wrapBlock(safeDisplay(String(text == null ? '' : text)), contentWidth);
+    return this.openLayer(new TextLayer({
+      title: String(title || 'Details'),
+      lines: options.danger ? lines.map((line) => paint('danger', line)) : lines,
+      width: panelWidth,
+      height: options.height || 20
+    }));
+  }
+
   /**
    * Ask for approval of a tool call: risk, arguments and a scrollable diff.
    *
@@ -549,19 +562,11 @@ export class ChatPrompt {
       return;
     }
 
-    // A COMMAND IS NOT A MESSAGE, so it must not be drawn as one.
-    //
-    // This echoed every submitted line as a filled user block BEFORE the caller
-    // had any chance to decide what the line was. Typing `/usage` therefore
-    // rendered exactly like a sentence you had sent to the model — the command
-    // did run, and its output appeared underneath, but the transcript showed a
-    // conversation turn that never happened. opencode draws an invocation here,
-    // not a message, and the difference is the whole reason a command line
-    // exists.
+    // A command is control input, not conversation. Its handler decides whether
+    // to open a picker, show a text dialog, or perform an action. Keeping the
+    // invocation out of the transcript preserves the boundary between local UI
+    // and messages that were actually sent to the model.
     if (this.isCommand(text)) {
-      this.commit('command', (width) => [
-        `${paint('accent', GLYPHS.arrow)} ${bold(truncate(text, Math.max(8, width - 3), GLYPHS.ellipsis))}`
-      ]);
       const settle = this.waiter;
       this.waiter = null;
       if (settle) settle(text);

package/src/version.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
 function getDir() {
   if (typeof __dirname !== 'undefined') {
@@ -10,7 +11,7 @@ function getDir() {
     if (metaUrl && typeof metaUrl === 'string') {
       const url = new URL(metaUrl);
       if (url.protocol === 'file:') {
-        return path.dirname(url.pathname);
+        return path.dirname(fileURLToPath(url));
       }
     }
   } catch (e) {}
@@ -35,4 +36,3 @@ export function getPackageVersion() {
 
   return '1.3.14';
 }
-