@robota-sdk/agent-command 3.0.0-beta.79 → 3.0.0-beta.81

package/src/session/session-command-module.ts

@@ -7,15 +7,18 @@ import {
 } from '@robota-sdk/agent-framework';
 
 import {
+  CD_COMMAND_DESCRIPTION,
+  executeCdCommand,
   executeClearCommand,
   executeCostCommand,
   executeRenameCommand,
   executeResumeCommand,
   executeValidateSessionCommand,
 } from './session-command.js';
+import { createSystemCommandFromEntry } from '../command-module-utils.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createClearCommandEntry(): ICommand {
   return {
@@ -23,7 +26,9 @@ export function createClearCommandEntry(): ICommand {
     displayName: 'Clear History',
     description: CLEAR_COMMAND_DESCRIPTION,
     source: 'session',
+    // User-only: wiping the conversation is the user's decision.
     modelInvocable: false,
+    userInvocable: true,
   };
 }
 
@@ -32,8 +37,24 @@ export function createRenameCommandEntry(): ICommand {
     name: 'rename',
     displayName: 'Rename Session',
     description: RENAME_COMMAND_DESCRIPTION,
+    argumentHint: '<name>',
+    source: 'session',
+    // User-only: the session's name is the user's label; UI-only.
+    modelInvocable: false,
+    userInvocable: true,
+  };
+}
+
+export function createCdCommandEntry(): ICommand {
+  return {
+    name: 'cd',
+    displayName: 'Change Directory',
+    description: CD_COMMAND_DESCRIPTION,
+    argumentHint: '<directory>',
     source: 'session',
+    // A move re-roots what every later tool call may touch; only the user decides it.
     modelInvocable: false,
+    userInvocable: true,
   };
 }
 
@@ -43,7 +64,9 @@ export function createResumeCommandEntry(): ICommand {
     displayName: 'Resume Session',
     description: RESUME_COMMAND_DESCRIPTION,
     source: 'session',
+    // User-only: switching to another session is the user's decision.
     modelInvocable: false,
+    userInvocable: true,
   };
 }
 
@@ -52,8 +75,28 @@ export function createCostCommandEntry(): ICommand {
     name: 'cost',
     displayName: 'Session Cost',
     description: COST_COMMAND_DESCRIPTION,
+    // Model-invocable for the read-only report only: the model can weigh cost before an expensive
+    // step. The monthly budget is the user's spending decision, so `budget` stays user-only.
+    modelDescription:
+      'Report this session’s token usage and estimated cost. Use it before an expensive step (a ' +
+      'large refactor, many subagents) or when the user asks what the session has cost. Returns ' +
+      'the message count, input/output token totals and the estimated USD cost, with the remaining ' +
+      'monthly budget when one is set. Setting or clearing the budget is the user’s decision: suggest `/cost budget <amount>`.',
+    argumentHint: '[budget [<amount>|clear]]',
+    // The bare `/cost` is the report, so choosing it from a menu runs it.
+    runsBare: true,
     source: 'session',
-    modelInvocable: false,
+    modelInvocable: true,
+    userInvocable: true,
+    subcommands: [
+      {
+        name: 'budget',
+        description: 'Show, set, or clear the monthly budget',
+        argumentHint: '[<amount>|clear]',
+        source: 'session',
+        modelInvocable: false,
+      },
+    ],
   };
 }
 
@@ -63,78 +106,64 @@ export function createValidateSessionCommandEntry(): ICommand {
     displayName: 'Validate Session',
     description: VALIDATE_SESSION_COMMAND_DESCRIPTION,
     source: 'session',
+    // User-only: a diagnostic of the replay log for the user; nothing the model acts on.
     modelInvocable: false,
+    userInvocable: true,
   };
 }
 
 function createClearSystemCommand(): ISystemCommand {
   const entry = createClearCommandEntry();
-  return {
-    name: entry.name,
-    displayName: entry.displayName,
-    description: entry.description,
+  return createSystemCommandFromEntry(entry, {
     requiresPermission: false,
-    userInvocable: true,
-    modelInvocable: false,
     lifecycle: 'inline',
     execute: executeClearCommand,
-  };
+  });
 }
 
 function createRenameSystemCommand(): ISystemCommand {
   const entry = createRenameCommandEntry();
-  return {
-    name: entry.name,
-    displayName: entry.displayName,
-    description: entry.description,
+  return createSystemCommandFromEntry(entry, {
     requiresPermission: false,
-    userInvocable: true,
-    modelInvocable: false,
     lifecycle: 'inline',
     execute: executeRenameCommand,
-  };
+  });
+}
+
+function createCdSystemCommand(): ISystemCommand {
+  const entry = createCdCommandEntry();
+  return createSystemCommandFromEntry(entry, {
+    requiresPermission: false,
+    lifecycle: 'inline',
+    execute: executeCdCommand,
+  });
 }
 
 function createResumeSystemCommand(): ISystemCommand {
   const entry = createResumeCommandEntry();
-  return {
-    name: entry.name,
-    displayName: entry.displayName,
-    description: entry.description,
+  return createSystemCommandFromEntry(entry, {
     requiresPermission: false,
-    userInvocable: true,
-    modelInvocable: false,
     lifecycle: 'inline',
     execute: executeResumeCommand,
-  };
+  });
 }
 
 function createCostSystemCommand(): ISystemCommand {
   const entry = createCostCommandEntry();
-  return {
-    name: entry.name,
-    displayName: entry.displayName,
-    description: entry.description,
+  return createSystemCommandFromEntry(entry, {
     requiresPermission: false,
-    userInvocable: true,
-    modelInvocable: false,
     lifecycle: 'inline',
     execute: executeCostCommand,
-  };
+  });
 }
 
 function createValidateSessionSystemCommand(): ISystemCommand {
   const entry = createValidateSessionCommandEntry();
-  return {
-    name: entry.name,
-    displayName: entry.displayName,
-    description: entry.description,
+  return createSystemCommandFromEntry(entry, {
     requiresPermission: false,
-    userInvocable: true,
-    modelInvocable: false,
     lifecycle: 'inline',
     execute: executeValidateSessionCommand,
-  };
+  });
 }
 
 export class SessionCommandSource implements ICommandSource {
@@ -144,6 +173,7 @@ export class SessionCommandSource implements ICommandSource {
     return [
       createClearCommandEntry(),
       createRenameCommandEntry(),
+      createCdCommandEntry(),
       createResumeCommandEntry(),
       createCostCommandEntry(),
       createValidateSessionCommandEntry(),
@@ -158,6 +188,7 @@ export function createSessionCommandModule(): ICommandModule {
     systemCommands: [
       createClearSystemCommand(),
       createRenameSystemCommand(),
+      createCdSystemCommand(),
       createResumeSystemCommand(),
       createCostSystemCommand(),
       createValidateSessionSystemCommand(),

package/src/session/session-command.ts

@@ -1,12 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
 import { confirmAction, isConfirmed } from '@robota-sdk/agent-core';
 import {
   RENAME_COMMAND_USAGE,
   clearConversationHistory,
-  createSessionPickerRequestedEffect,
-  createSessionRenamedEffect,
+  createShowSessionPickerIntent,
+  createSessionRenameHostAction,
   formatCommandSessionReplayValidationReport,
   parseSessionNameArgument,
   readCommandSessionInfo,
@@ -15,17 +12,39 @@ import {
 
 import { calculateCost, formatTokens, formatUsd } from './model-pricing.js';
 
-import type { ICommandHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type {
+  ICommandCostBudgetAdapter,
+  ICommandHostAdapterAccess,
+  ICommandHostNoCapability,
+  ICommandHostSessionAccess,
+  ICommandHostUserInteraction,
+  ICommandHostWorkspace,
+  ISessionUsageRecord,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 export const CLEAR_COMMAND_MESSAGE = 'Conversation cleared.';
 
+export const CD_COMMAND_DESCRIPTION = 'Move this session to another working directory';
+export const CD_COMMAND_USAGE = 'Usage: /cd <directory>';
+
+/**
+ * `/cd <directory>` (issue #3081) requests the host-executed move. The checks — no turn running, no
+ * live background task, the target exists, no `Cd(...)` deny rule — run where the session state is,
+ * when the host applies the action.
+ */
+export function executeCdCommand(_context: ICommandHostNoCapability, args: string): ICommandResult {
+  const path = args.trim();
+  if (path === '') return { success: false, message: CD_COMMAND_USAGE };
+  return { success: true, message: '', hostActions: [{ type: 'workspace-move', path }] };
+}
+
 export async function executeClearCommand(
-  context: ICommandHostContext,
+  context: ICommandHostSessionAccess & ICommandHostUserInteraction,
   _args: string,
 ): Promise<ICommandResult> {
   // Confirm only when an interactive renderer is attached; with no human the explicit /clear proceeds.
-  const ui = context.getUserInteraction?.();
+  const ui = context.getUserInteraction();
   if (ui) {
     const response = await ui.ask(confirmAction('clear', 'Clear conversation history?'));
     if (!isConfirmed(response)) {
@@ -33,15 +52,16 @@ export async function executeClearCommand(
     }
   }
 
+  // CMD-004 Stage E: the clear mutation runs host-side and the session broadcasts `history_cleared`
+  // to every attached surface — the result carries no separate notification.
   clearConversationHistory(context);
-  return {
-    success: true,
-    message: CLEAR_COMMAND_MESSAGE,
-    effects: [{ type: 'conversation-history-cleared' }],
-  };
+  return { success: true, message: CLEAR_COMMAND_MESSAGE };
 }
 
-export function executeRenameCommand(_context: ICommandHostContext, args: string): ICommandResult {
+export function executeRenameCommand(
+  _context: ICommandHostNoCapability,
+  args: string,
+): ICommandResult {
   const name = parseSessionNameArgument(args);
   if (name === undefined) {
     return { success: false, message: RENAME_COMMAND_USAGE };
@@ -51,64 +71,95 @@ export function executeRenameCommand(_context: ICommandHostContext, args: string
     success: true,
     message: `Session renamed to "${name}".`,
     data: { name },
-    effects: [createSessionRenamedEffect(name)],
+    hostActions: [createSessionRenameHostAction(name)],
   };
 }
 
-export function executeResumeCommand(_context: ICommandHostContext, _args: string): ICommandResult {
+export function executeResumeCommand(): ICommandResult {
   return {
     success: true,
     message: 'Opening session picker...',
     data: { triggerResumePicker: true },
-    effects: [createSessionPickerRequestedEffect()],
+    uiIntents: [createShowSessionPickerIntent()],
   };
 }
 
-const BUDGET_FILE = '.robota/budget.json';
+type TCostCommandContext = ICommandHostSessionAccess &
+  ICommandHostWorkspace &
+  ICommandHostAdapterAccess;
 
-interface IBudgetConfig {
-  monthly: number;
+/**
+ * CMD-007 (issue #2058): the budget lives behind `ICommandCostBudgetAdapter`, composed by the shell.
+ * This package owns no path literal and no filesystem call for it any more — atomic/symlink-safe
+ * writing is the adapter's policy (agent-cli's file adapter keeps the O_NOFOLLOW guard).
+ */
+function costBudgetAdapter(context: TCostCommandContext): ICommandCostBudgetAdapter | undefined {
+  return context.getCommandHostAdapters?.().costBudget;
 }
 
-function readBudget(cwd: string): IBudgetConfig | undefined {
-  const file = join(cwd, BUDGET_FILE);
-  if (!existsSync(file)) return undefined;
-  let raw: string;
-  try {
-    raw = readFileSync(file, 'utf-8');
-  } catch {
-    // allow-fallback: budget file read failure disables feature gracefully
-    return undefined;
-  }
-  try {
-    return JSON.parse(raw) as IBudgetConfig;
-  } catch {
-    // allow-fallback: malformed budget JSON treated as no budget set
-    return undefined;
-  }
+const BUDGET_UNAVAILABLE_MESSAGE =
+  'Budget persistence is not available on this host (no cost-budget adapter was composed).';
+
+/** What to tell the operator when the adapter refused the write; the adapter names the cause. */
+function describeBudgetWriteFailure(error: unknown): string {
+  return `Could not write the budget: ${error instanceof Error ? error.message : String(error)}`;
 }
 
-function writeBudget(cwd: string, config: IBudgetConfig): void {
-  const dir = join(cwd, '.robota');
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(cwd, BUDGET_FILE), JSON.stringify(config, null, 2));
+interface ICostTotals {
+  inputTokens: number;
+  outputTokens: number;
+  /** Absent when nothing could be priced. */
+  costUsd?: number;
+  /** Some usage could not be priced, so the cost is a lower bound. */
+  partial: boolean;
+  /** The models the cost was priced on. */
+  models: string[];
 }
 
-function clearBudget(cwd: string): void {
-  const file = join(cwd, BUDGET_FILE);
-  if (existsSync(file)) {
-    writeFileSync(file, '{}');
+/**
+ * Total the session's usage records. A record priced on its own model (the advisor's) keeps that
+ * price; a main-thread record without one is priced on the session's model. A consulted model whose
+ * price is unknown is left unpriced rather than priced as the main model.
+ */
+function totalSessionUsage(
+  records: readonly ISessionUsageRecord[],
+  modelId: string | undefined,
+): ICostTotals | undefined {
+  if (records.length === 0) return undefined;
+  const totals: ICostTotals = { inputTokens: 0, outputTokens: 0, partial: false, models: [] };
+  const models = new Set<string>();
+  let cost = 0;
+  let priced = false;
+  for (const record of records) {
+    totals.inputTokens += record.promptTokens;
+    totals.outputTokens += record.completionTokens;
+    const consulted = record.source?.scope === 'tool';
+    const recordCost =
+      record.costUsd ??
+      (!consulted && modelId
+        ? calculateCost(modelId, record.promptTokens, record.completionTokens)
+        : undefined);
+    if (recordCost === undefined) {
+      totals.partial = true;
+      continue;
+    }
+    cost += recordCost;
+    priced = true;
+    models.add(consulted ? (record.source?.label ?? 'another model') : (modelId ?? 'main model'));
   }
+  if (priced) totals.costUsd = cost;
+  totals.models = [...models];
+  return totals;
 }
 
-function buildCostOutput(context: ICommandHostContext): {
+function buildCostOutput(context: TCostCommandContext): {
   lines: string[];
   data: Record<string, unknown>;
 } {
   const session = context.getSession();
   const sessionInfo = readCommandSessionInfo(context);
-  const tokenUsage = session.getSessionTokenUsage?.();
-  const modelId = session.getModelId?.();
+  const modelId = session.getModelId();
+  const totals = totalSessionUsage(context.getSessionUsage(), modelId);
   const lines: string[] = [
     `Session:  ${sessionInfo.sessionId}`,
     `Messages: ${sessionInfo.messageCount}`,
@@ -118,29 +169,32 @@ function buildCostOutput(context: ICommandHostContext): {
     messageCount: sessionInfo.messageCount,
   };
 
-  if (tokenUsage) {
+  if (totals) {
     lines.push(
-      `Tokens:   ${formatTokens(tokenUsage.inputTokens)} input  /  ${formatTokens(tokenUsage.outputTokens)} output`,
+      `Tokens:   ${formatTokens(totals.inputTokens)} input  /  ${formatTokens(totals.outputTokens)} output`,
     );
-    data.inputTokens = tokenUsage.inputTokens;
-    data.outputTokens = tokenUsage.outputTokens;
-
-    if (modelId) {
-      const cost = calculateCost(modelId, tokenUsage.inputTokens, tokenUsage.outputTokens);
-      if (cost !== undefined) {
-        lines.push(`Cost:     ${formatUsd(cost)}  (${modelId})`);
-        data.estimatedCostUsd = cost;
-
-        const budget = readBudget(context.getCwd());
-        if (budget?.monthly) {
-          const remaining = budget.monthly - cost;
-          const pct = Math.min(100, Math.round((cost / budget.monthly) * 100));
-          lines.push(
-            `Budget:   ${formatUsd(remaining)} remaining of ${formatUsd(budget.monthly)}/mo  (${pct}% used)`,
-          );
-          data.budgetMonthly = budget.monthly;
-          data.budgetRemainingUsd = remaining;
-        }
+    data.inputTokens = totals.inputTokens;
+    data.outputTokens = totals.outputTokens;
+
+    const cost = totals.costUsd;
+    if (cost !== undefined) {
+      const priced =
+        totals.models.length > 1 ? `mixed: ${totals.models.join(', ')}` : (totals.models[0] ?? '');
+      const note = totals.partial ? '; some usage could not be priced' : '';
+      lines.push(`Cost:     ${formatUsd(cost)}  (${priced}${note})`);
+      data.estimatedCostUsd = cost;
+      data.costModels = totals.models;
+      if (totals.partial) data.costPartial = true;
+
+      const budget = costBudgetAdapter(context)?.read();
+      if (budget?.monthly) {
+        const remaining = budget.monthly - cost;
+        const pct = Math.min(100, Math.round((cost / budget.monthly) * 100));
+        lines.push(
+          `Budget:   ${formatUsd(remaining)} remaining of ${formatUsd(budget.monthly)}/mo  (${pct}% used)`,
+        );
+        data.budgetMonthly = budget.monthly;
+        data.budgetRemainingUsd = remaining;
       }
     }
   } else {
@@ -150,19 +204,34 @@ function buildCostOutput(context: ICommandHostContext): {
   return { lines, data };
 }
 
-export function executeCostCommand(context: ICommandHostContext, args: string): ICommandResult {
+export function executeCostCommand(context: TCostCommandContext, args: string): ICommandResult {
   const trimmed = args.trim();
 
   if (trimmed.startsWith('budget')) {
     const budgetArg = trimmed.slice('budget'.length).trim();
+    // Argument shape is judged before the host is asked for persistence: a malformed amount is a
+    // usage error on every host, not a symptom of the adapter that would have stored it.
+    const amount = budgetArg === 'clear' || budgetArg === '' ? undefined : parseFloat(budgetArg);
+    if (amount !== undefined && (!Number.isFinite(amount) || amount <= 0)) {
+      return {
+        success: false,
+        message: 'Usage: /cost budget <amount>  (e.g. /cost budget 5.00)',
+      };
+    }
+    const adapter = costBudgetAdapter(context);
+    if (adapter === undefined) return { success: false, message: BUDGET_UNAVAILABLE_MESSAGE };
 
     if (budgetArg === 'clear') {
-      clearBudget(context.getCwd());
+      try {
+        adapter.clear();
+      } catch (error) {
+        return { success: false, message: describeBudgetWriteFailure(error) };
+      }
       return { success: true, message: 'Monthly budget cleared.' };
     }
 
     if (budgetArg === '') {
-      const current = readBudget(context.getCwd());
+      const current = adapter.read();
       if (!current?.monthly) {
         return {
           success: true,
@@ -172,14 +241,12 @@ export function executeCostCommand(context: ICommandHostContext, args: string):
       return { success: true, message: `Monthly budget: ${formatUsd(current.monthly)}` };
     }
 
-    const amount = parseFloat(budgetArg);
-    if (!Number.isFinite(amount) || amount <= 0) {
-      return {
-        success: false,
-        message: 'Usage: /cost budget <amount>  (e.g. /cost budget 5.00)',
-      };
+    if (amount === undefined) return { success: false, message: BUDGET_UNAVAILABLE_MESSAGE };
+    try {
+      adapter.write({ monthly: amount });
+    } catch (error) {
+      return { success: false, message: describeBudgetWriteFailure(error) };
     }
-    writeBudget(context.getCwd(), { monthly: amount });
     return { success: true, message: `Monthly budget set to ${formatUsd(amount)}.` };
   }
 
@@ -188,7 +255,7 @@ export function executeCostCommand(context: ICommandHostContext, args: string):
 }
 
 export function executeValidateSessionCommand(
-  context: ICommandHostContext,
+  context: ICommandHostSessionAccess & ICommandHostWorkspace,
   _args: string,
 ): ICommandResult {
   const report = validateCommandSessionReplayLog(context);

package/src/settings/settings-command-module.ts

@@ -1,5 +1,5 @@
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createSettingsCommandEntry(): ICommand {
   return {
@@ -7,6 +7,7 @@ export function createSettingsCommandEntry(): ICommand {
     displayName: 'Settings',
     description: 'Open transport settings — enable/disable transports and configure options',
     source: 'settings',
+    // User-only: transport settings screen; UI-only.
     modelInvocable: false,
   };
 }
@@ -24,7 +25,7 @@ function createSettingsSystemCommand(): ISystemCommand {
     execute: async () => ({
       success: true,
       message: 'Opening settings...',
-      effects: [{ type: 'settings-tui-requested' as const }],
+      uiIntents: [{ type: 'show-settings' as const }],
     }),
   };
 }

package/src/shell/__tests__/resolve-shell-host.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveShell } from '../resolve-shell.js';
+
+describe('interactive shell host selection', () => {
+  it('keeps the executable and argument family together', () => {
+    const shell = resolveShell('C:\\Windows\\System32\\cmd.exe');
+    expect(shell.command).toBe('C:\\Windows\\System32\\cmd.exe');
+    expect(shell.commandArgs('echo ok')).toEqual(['/d', '/s', '/c', 'echo ok']);
+  });
+});

package/src/shell/__tests__/shell-command-functional.test.ts

@@ -12,7 +12,7 @@ import { scriptedSession, type ScriptedSessionHarness } from '@robota-sdk/agent-
 
 import { createShellCommandModule } from '../shell-command-module.js';
 
-import type { ITerminalHandoff } from '@robota-sdk/agent-interface-transport';
+import type { ITerminalHandoff } from '@robota-sdk/agent-interface-session';
 
 const TEST_TIMEOUT = 20_000;
 
@@ -39,6 +39,28 @@ afterEach(async () => {
 });
 
 describe('/shell command (framework functional)', () => {
+  it(
+    'uses the host-selected executable captured by its module',
+    async () => {
+      if (process.platform === 'win32') return;
+      const previousShell = process.env['SHELL'];
+      process.env['SHELL'] = '/bin/false';
+      try {
+        h = scriptedSession({
+          turns: [{ text: 'unused' }],
+          terminalHandoff: fakeHandoff(true),
+          commandModules: [createShellCommandModule('/bin/bash')],
+        });
+        const result = await h.command('shell', 'exit 0');
+        expect(result?.success).toBe(true);
+      } finally {
+        if (previousShell === undefined) delete process.env['SHELL'];
+        else process.env['SHELL'] = previousShell;
+      }
+    },
+    TEST_TIMEOUT,
+  );
+
   it(
     'runs a one-shot command through the handoff and returns exit code 0',
     async () => {

package/src/shell/resolve-shell.ts

@@ -15,8 +15,8 @@ export interface IResolvedShell {
 }
 
 /** Resolve the interactive shell for the current platform via the agent-core SSOT resolver. */
-export function resolveShell(): IResolvedShell {
-  const shell = resolvePlatformShell();
+export function resolveShell(executable?: string): IResolvedShell {
+  const shell = resolvePlatformShell({ executable });
   return {
     command: shell.command,
     interactiveArgs: shell.interactiveArgs,

package/src/shell/shell-command-module.ts

@@ -4,7 +4,7 @@
 import { executeShellCommand, SHELL_COMMAND_DESCRIPTION } from './shell-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createShellCommandEntry(): ICommand {
   return {
@@ -12,11 +12,12 @@ export function createShellCommandEntry(): ICommand {
     displayName: 'Shell',
     description: SHELL_COMMAND_DESCRIPTION,
     source: 'shell',
+    // User-only: the user's own shell passthrough; the model has its permission-gated shell tool.
     modelInvocable: false,
   };
 }
 
-function createShellSystemCommand(): ISystemCommand {
+function createShellSystemCommand(executable?: string): ISystemCommand {
   const entry = createShellCommandEntry();
   return {
     name: entry.name,
@@ -26,7 +27,7 @@ function createShellSystemCommand(): ISystemCommand {
     userInvocable: true,
     modelInvocable: false,
     lifecycle: 'inline',
-    execute: executeShellCommand,
+    execute: (context, args) => executeShellCommand(context, args, executable),
   };
 }
 
@@ -38,10 +39,10 @@ export class ShellCommandSource implements ICommandSource {
   }
 }
 
-export function createShellCommandModule(): ICommandModule {
+export function createShellCommandModule(executable?: string): ICommandModule {
   return {
     name: 'agent-command-shell',
     commandSources: [new ShellCommandSource()],
-    systemCommands: [createShellSystemCommand()],
+    systemCommands: [createShellSystemCommand(executable)],
   };
 }