@robota-sdk/agent-command 3.0.0-beta.83 → 3.0.0-beta.84

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@robota-sdk/agent-command",
-  "version": "3.0.0-beta.83",
-  "description": "Consolidated command module implementations for Robota SDK CLI",
+  "version": "3.0.0-beta.84",
+  "description": "Slash-command modules for Robota SDK sessions (/help, /permissions, /mcp, /rewind, …)",
   "type": "module",
   "main": "dist/node/index.js",
   "types": "dist/node/index.d.ts",
@@ -40,12 +40,12 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@robota-sdk/agent-core": "3.0.0-beta.83",
-    "@robota-sdk/agent-framework": "3.0.0-beta.83",
-    "@robota-sdk/agent-interface-command": "3.0.0-beta.83",
-    "@robota-sdk/agent-interface-execution": "3.0.0-beta.83",
-    "@robota-sdk/agent-interface-session": "3.0.0-beta.83",
-    "@robota-sdk/agent-preset": "3.0.0-beta.83"
+    "@robota-sdk/agent-core": "3.0.0-beta.84",
+    "@robota-sdk/agent-framework": "3.0.0-beta.84",
+    "@robota-sdk/agent-interface-command": "3.0.0-beta.84",
+    "@robota-sdk/agent-interface-execution": "3.0.0-beta.84",
+    "@robota-sdk/agent-interface-session": "3.0.0-beta.84",
+    "@robota-sdk/agent-preset": "3.0.0-beta.84"
   },
   "devDependencies": {
     "@types/node": "^22.19.21",
@@ -60,6 +60,7 @@
     "url": "https://github.com/woojubb/robota.git",
     "directory": "packages/agent-command"
   },
+  "homepage": "https://docs.robota.io/en/packages/agent-command/",
   "publishConfig": {
     "access": "public"
   },

package/src/agent/__tests__/agent-command.test.ts

@@ -15,6 +15,7 @@ function createMockSession(overrides?: Record<string, unknown>) {
       { name: 'general-purpose', description: 'General-purpose task execution agent.' },
       { name: 'Plan', description: 'Read-only planning agent.' },
     ]),
+    setDefaultAgentType: vi.fn(),
     listAgentJobs: vi.fn().mockReturnValue([]),
     readBackgroundTaskLog: vi.fn().mockResolvedValue({ taskId: 'agent_1', lines: [] }),
     spawnAgentJob: vi.fn().mockResolvedValue({
@@ -518,6 +519,67 @@ describe('agent command module', () => {
     expect(result?.uiIntents).toEqual([{ type: 'show-agent-switcher' }]);
   });
 
+  it('#3282 §4: /agent <name> with nothing after it selects a default agent instead of failing', async () => {
+    const module = createAgentCommandModule();
+    const executor = new SystemCommandExecutor([
+      ...createSystemCommands(),
+      ...(module.systemCommands ?? []),
+    ]);
+    const session = createMockSession();
+
+    const result = await executor.execute('agent', session, 'Plan');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe('Default agent: Plan');
+    expect(result?.data).toEqual({ agentType: 'Plan' });
+    expect(
+      (session as unknown as { setDefaultAgentType: ReturnType<typeof vi.fn> }).setDefaultAgentType,
+    ).toHaveBeenCalledWith('Plan');
+    expect(
+      (session as unknown as { spawnAgentJob: ReturnType<typeof vi.fn> }).spawnAgentJob,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('#3282 §4: a single unrecognized word is still a prompt for the default agent, not a selection', async () => {
+    const module = createAgentCommandModule();
+    const executor = new SystemCommandExecutor([
+      ...createSystemCommands(),
+      ...(module.systemCommands ?? []),
+    ]);
+    const session = createMockSession();
+
+    const result = await executor.execute('agent', session, 'NotARealAgent');
+
+    expect(result?.success).toBe(true);
+    expect(
+      (session as unknown as { spawnAgentJob: ReturnType<typeof vi.fn> }).spawnAgentJob,
+    ).toHaveBeenCalledWith({
+      agentType: 'general-purpose',
+      label: 'general-purpose',
+      mode: 'background',
+      prompt: 'NotARealAgent',
+    });
+    expect(
+      (session as unknown as { setDefaultAgentType: ReturnType<typeof vi.fn> }).setDefaultAgentType,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('#3282 §4: a known agent name followed by a prompt still runs a job, not a selection', async () => {
+    const module = createAgentCommandModule();
+    const executor = new SystemCommandExecutor([
+      ...createSystemCommands(),
+      ...(module.systemCommands ?? []),
+    ]);
+    const session = createMockSession();
+
+    const result = await executor.execute('agent', session, 'Plan "draft architecture"');
+
+    expect(result?.success).toBe(true);
+    expect(
+      (session as unknown as { setDefaultAgentType: ReturnType<typeof vi.fn> }).setDefaultAgentType,
+    ).not.toHaveBeenCalled();
+  });
+
   it('shows text list when agent list subcommand is used explicitly', async () => {
     const module = createAgentCommandModule();
     const executor = new SystemCommandExecutor([

package/src/agent/agent-command-parser.ts

@@ -1,6 +1,6 @@
-import type { TBackgroundTaskIsolation } from '@robota-sdk/agent-interface-execution';
+import { DEFAULT_AGENT_TYPE } from '@robota-sdk/agent-framework';
 
-const DEFAULT_AGENT_TYPE = 'general-purpose';
+import type { TBackgroundTaskIsolation } from '@robota-sdk/agent-interface-execution';
 
 export type TAgentMode = 'background';
 

package/src/agent/agent-command.ts

@@ -44,6 +44,21 @@ function executeOpenSwitcher(): ICommandResult {
   return { message: '', uiIntents: [{ type: 'show-agent-switcher' }], success: true };
 }
 
+/**
+ * #3282 §4: `/agent <name>` with nothing after the name sets the session's default agent type —
+ * the one `/agent <prompt>` falls back to, and the one the agent switcher shows checked. Distinct
+ * from `executeRun`, which a name FOLLOWED by a prompt still reaches (a prompt makes it a run, not
+ * a selection).
+ */
+function executeSelectDefaultAgent(session: IAgentJobHostContext, agentType: string): ICommandResult {
+  session.setDefaultAgentType(agentType);
+  return {
+    message: `Default agent: ${agentType}`,
+    success: true,
+    data: { agentType },
+  };
+}
+
 async function executeList(session: IAgentJobHostContext): Promise<ICommandResult> {
   const agents = session.listAgentDefinitions();
   const jobs = session.listAgentJobs();
@@ -223,6 +238,11 @@ export async function executeAgentCommand(
     if (action === 'send') return executeSend(session, tokens);
     if (action === 'stop' || action === 'cancel') return executeStop(session, tokens);
     if (action === 'close') return executeClose(session, tokens);
+    // `/agent <name>` alone (a known agent, nothing after it) selects a default rather than failing
+    // the "run" parse for want of a prompt — the same one-token shape the switcher sends.
+    if (tokens.length === 0 && getAvailableAgentNames(session).has(action)) {
+      return executeSelectDefaultAgent(session, action);
+    }
     return executeRun(session, [action, ...tokens]);
   } catch (error) {
     return { message: formatError(error), success: false };

package/src/default/__tests__/__snapshots__/model-exposure.test.ts.snap

@@ -44,7 +44,7 @@ Run it with no arguments.",
   },
   "loop": {
     "argumentHint": "[prompt] | <N><s|m|h|d> [prompt] | <prompt> every <N> <unit> | list | stop <id>",
-    "description": "Repeat a prompt on a fixed cadence (\`<N><s|m|h|d> [prompt]\`) or self-paced (bare or prompt only: each iteration chooses its next delay or stops). Use it when the user asks for recurring work in this session. \`list\` shows active loops; \`stop <id>\` ends one. Returns the loop id and its next fire time, or the loop list.",
+    "description": "Repeat a prompt on a fixed cadence (\`<N><s|m|h|d> <prompt>\`) or self-paced (\`<prompt>\`: each iteration chooses its next delay or stops). Use it when the user asks for recurring work in this session, and always give your own prompt: any form that would fall back to the host's default maintenance prompt — bare \`/loop\` or an interval alone (\`<N><s|m|h|d>\`) — needs a person to confirm it and is always refused for you, whether or not one is attached. \`list\` shows active loops; \`stop <id>\` ends one, even mid-turn. Returns the loop id and its next fire time, the loop list, or a refusal naming the command to suggest.",
     "kind": "builtin-command",
     "modelInvocable": true,
     "name": "loop",
@@ -64,7 +64,7 @@ Subcommands you may run (bare \`mcp\` is also allowed):
   },
   "memory": {
     "argumentHint": "[list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | used]",
-    "description": "Read and write this project’s durable memory. Use \`list\` or \`show [topic]\` to look up stored conventions, preferences or references before asking the user again; \`add <type> <topic> <text>\` to save a durable preference, project convention, feedback item or reference worth reusing across sessions (never secrets, credentials or transient facts); \`pending\` to see candidates awaiting the user’s review; \`used\` to report which memory items informed this turn. Bare lists topics. Returns the requested topics or entries, or a confirmation of what was saved. Approving or rejecting a pending candidate is the user’s review: suggest \`/memory approve <id>\` or \`/memory reject <id>\`.
+    "description": "Read and write this project’s durable memory. Use \`list\` or \`show [topic]\` to look up stored conventions, preferences or references before asking the user again; \`add <type> <topic> <text>\` to save a durable preference, project convention, feedback item or reference worth reusing across sessions (never secrets, credentials or transient facts); \`pending\` to see candidates awaiting the user’s review; \`used\` to report which memory items informed this turn. Bare lists topics. In plan mode \`add\` is refused: save after plan mode ends. Returns the requested topics or entries, or a confirmation of what was saved. Approving or rejecting a pending candidate is the user’s review: suggest \`/memory approve <id>\` or \`/memory reject <id>\`.
 Subcommands you may run (bare \`memory\` is also allowed):
 - list: List project memory topics
 - show: Show project memory index or a topic

package/src/default/__tests__/default-command-modules.test.ts

@@ -50,10 +50,10 @@ describe('createDefaultCommandModules — PRESET-004 module-selection delta', ()
     const names = moduleNames(baseOptions);
     // No-regression: the default set length is the documented 32 modules (SELFHOST-002 added
     // `/plan`; PEER-004 added `/peers`; CLI-1994 added `/fork`; MCP-2520 added `/mcp`; CLI-1988 added
-    // `/output-style`; FLOW-008 added `/effort`; `/advisor` joined beside it). The list below is the
-    // assertion that matters — a length on its own can be restored by any substitution, and the count
-    // exists only to catch an addition that also removed something.
-    expect(names).toHaveLength(38);
+    // `/output-style`; FLOW-008 added `/effort`; `/advisor` joined beside it; #3282 §2 added `/model`).
+    // The list below is the assertion that matters — a length on its own can be restored by any
+    // substitution, and the count exists only to catch an addition that also removed something.
+    expect(names).toHaveLength(39);
     expect(names).toEqual([
       'agent-command-skills',
       'agent-command-help',
@@ -94,6 +94,7 @@ describe('createDefaultCommandModules — PRESET-004 module-selection delta', ()
       'agent-command-handoff',
       'agent-command-remote-control',
       'agent-command-provider',
+      'agent-command-model',
     ]);
   });
 

package/src/default/__tests__/model-exposure.test.ts

@@ -109,6 +109,8 @@ const USER_ONLY_COMMANDS = [
   'events',
   // Account and credential actions.
   'provider',
+  // Cost and capability decisions: the person chooses, never the model on its own (#3282 §2).
+  'model',
   // Permission widening or permission-mode changes.
   'mode',
   'permissions',

package/src/default/default-command-modules.ts

@@ -20,6 +20,7 @@ import { createLanguageCommandModule } from '../language/index.js';
 import { createMCPActivationCommandModule } from '../mcp-activation/index.js';
 import { createMemoryCommandModule } from '../memory/index.js';
 import { createModeCommandModule } from '../mode/index.js';
+import { createModelCommandModule } from '../model/index.js';
 import { createSandboxCommandModule } from '../sandbox/index.js';
 import { createOutputStyleCommandModule } from '../output-style/index.js';
 import { createEventsCommandModule } from '../events/index.js';
@@ -204,6 +205,13 @@ export function createDefaultCommandModules({
       settings: providerSettingsAdapter,
       ...(orgPolicy === undefined ? {} : { orgPolicy }),
     }),
+    // #3282 §2: shares the provider command's settings adapter and definitions — one settings write
+    // owner, never a second copy that could drift from what `/provider switch` reads and writes.
+    createModelCommandModule({
+      providerDefinitions,
+      settings: providerSettingsAdapter,
+      ...(orgPolicy === undefined ? {} : { orgPolicy }),
+    }),
   ];
   const builtModuleNames = modules.map((module) => module.name);
   return {

package/src/effort/effort-command.test.ts

@@ -5,6 +5,37 @@ import { executeEffortCommand } from './effort-command.js';
 import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
 describe('/effort', () => {
+  it('#3282 §2: reports plainly when the model has no matching effort control at all', async () => {
+    const host = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({}), write: vi.fn() },
+          effort: {
+            getResolution: () => ({
+              requested: 'low',
+              effective: 'low',
+              source: 'command',
+              disposition: 'not-applied',
+              modelDefault: 'high',
+            }),
+            apply: async () => ({
+              requested: 'low',
+              effective: 'low',
+              source: 'command',
+              disposition: 'not-applied',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, 'low');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("This model doesn't support effort levels, so it will use its default.");
+  });
+
   it('applies a requested level and returns the complete resolution', async () => {
     const applyModelOptions = vi.fn();
     const writeSettings = vi.fn();
@@ -36,6 +67,7 @@ describe('/effort', () => {
     const result = await executeEffortCommand(host, 'low');
 
     expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: Low');
     expect(result.data).toMatchObject({
       effort: { requested: 'low', effective: 'low', source: 'command', disposition: 'applied' },
     });
@@ -50,7 +82,7 @@ describe('/effort', () => {
     const result = await executeEffortCommand(host, '');
 
     expect(result.success).toBe(true);
-    expect(result.message).toContain('high');
+    expect(result.message).toBe('Effort: High');
     expect(applyModelOptions).not.toHaveBeenCalled();
   });
 
@@ -133,8 +165,39 @@ describe('/effort', () => {
     const result = await executeEffortCommand(host, '');
 
     expect(result.success).toBe(true);
-    expect(result.message).toContain('effective=medium');
+    expect(result.message).toBe('Effort: Medium');
     expect(applyModelOptions).not.toHaveBeenCalled();
     expect(writeSettings).not.toHaveBeenCalled();
   });
+
+  it('#3282 §2: uses the full plain word for xhigh, not the internal id', async () => {
+    const host = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({}), write: vi.fn() },
+          effort: {
+            getResolution: () => ({
+              requested: 'auto',
+              effective: 'high',
+              source: 'model-default',
+              disposition: 'model-default',
+              modelDefault: 'high',
+            }),
+            apply: async (selection) => ({
+              requested: selection,
+              effective: selection === 'auto' ? 'high' : selection,
+              source: 'command',
+              disposition: 'applied',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, 'xhigh');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: Extra high');
+  });
 });

package/src/effort/effort-command.ts

@@ -1,5 +1,5 @@
 import { MODEL_EFFORT_VALUES, selectAction } from '@robota-sdk/agent-core';
-import { parseModelEffort, resolveModelEffort } from '@robota-sdk/agent-framework';
+import { EFFORT_LEVEL_LABELS, parseModelEffort, resolveModelEffort } from '@robota-sdk/agent-framework';
 
 import type {
   ICommandHostAdapterAccess,
@@ -14,13 +14,27 @@ import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 const EFFORT_SELECTIONS: readonly TEffortSelection[] = ['auto', ...MODEL_EFFORT_VALUES];
 
+/**
+ * #3282 §2 — re-exported for callers already importing it from here; the canonical definition moved
+ * to `agent-framework` (`effort/effort-resolution.ts`) so headless `/goal` output (in that same
+ * package) can use the same labels without a circular dependency on `agent-command`.
+ */
+export { EFFORT_LEVEL_LABELS };
+
+/**
+ * Plain outcome text (#3282 §2), replacing the earlier `Model effort: requested=…, effective=…,
+ * source=…, disposition=…` internal-field dump. `not-applied` means the model has no matching native
+ * control at all — the earlier fields carried no information a person could act on for that case, so
+ * it gets its own plain sentence instead of a label.
+ */
 function formatEffortMessage(resolution: {
   requested: TEffortSelection;
-  effective: string;
-  source: string;
   disposition: string;
 }): string {
-  return `Model effort: requested=${resolution.requested}, effective=${resolution.effective}, source=${resolution.source}, disposition=${resolution.disposition}.`;
+  if (resolution.disposition === 'not-applied') {
+    return "This model doesn't support effort levels, so it will use its default.";
+  }
+  return `Effort: ${EFFORT_LEVEL_LABELS[resolution.requested]}`;
 }
 
 async function askForEffort(
@@ -32,7 +46,7 @@ async function askForEffort(
     selectAction(
       'effort',
       'Select model effort',
-      EFFORT_SELECTIONS.map((value) => ({ value, label: value })),
+      EFFORT_SELECTIONS.map((value) => ({ value, label: EFFORT_LEVEL_LABELS[value] })),
     ),
   );
   const selected = response.type === 'answer' ? response.values[0] : undefined;

package/src/git/__tests__/fake-git-port.ts

@@ -1,5 +1,12 @@
-/** A scripted `IGitProcessPort`: answers by argv, records every call, throws on an unscripted one. */
-import type { IGitProcessPort, TGitProcessOutcome } from '../git-process.js';
+/**
+ * A scripted `IGitProcessPort`: answers by argv, records every call, throws on an unscripted one.
+ *
+ * The port and outcome types moved to `@robota-sdk/agent-framework` with the git process module
+ * (#3282 §4c); this double stays here (duplicated, not imported cross-package) because it is a tiny,
+ * self-contained test fixture, the same call `agent-framework`'s own `git/__tests__/fake-git-port.ts`
+ * makes for its side.
+ */
+import type { IGitProcessPort, TGitProcessOutcome } from '@robota-sdk/agent-framework';
 
 export interface IFakeGitPort extends IGitProcessPort {
   readonly calls: readonly (readonly string[])[];

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

@@ -5,15 +5,14 @@
  * on the user path (`SystemCommandExecutor.executeCommand` calls `execute` directly).
  */
 import { executeGitCommit } from './git-commit.js';
-import { executeGitDiff } from './git-diff.js';
-import { createGitProcess } from './git-process.js';
-import { executeGitStatus } from './git-status.js';
 
-import type { IGitProcessPort } from './git-process.js';
+import { createGitProcess, executeGitDiff, executeGitStatus } from '@robota-sdk/agent-framework';
+
 import type {
   ICommandHostUserInteraction,
   ICommandHostWorkspace,
   ICommandModule,
+  IGitProcessPort,
   ISystemCommand,
 } from '@robota-sdk/agent-framework';
 import type { ICommand, ICommandResult, ICommandSource } from '@robota-sdk/agent-interface-command';

package/src/git/git-commit.ts

@@ -9,10 +9,13 @@
  */
 import { confirmAction, isConfirmed, textAction } from '@robota-sdk/agent-core';
 
-import { gitFailureMessage } from './git-process.js';
-import { parseStatusPorcelainV2, GIT_STATUS_ARGS } from './git-status.js';
+import {
+  gitFailureMessage,
+  parseStatusPorcelainV2,
+  GIT_STATUS_ARGS,
+} from '@robota-sdk/agent-framework';
 
-import type { IGitProcessPort } from './git-process.js';
+import type { IGitProcessPort } from '@robota-sdk/agent-framework';
 import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 

package/src/git/index.ts

@@ -1,3 +1,6 @@
+// The git process port and the status/diff readers moved to `@robota-sdk/agent-framework` (#3282
+// §4c) so the Project panel's session-level reads and this command run through the exact same
+// functions; re-exported here so an existing `from '@robota-sdk/agent-command'` import keeps working.
 export {
   createGitProcess,
   gitEnvironment,
@@ -6,7 +9,7 @@ export {
   type IGitProcessRunOptions,
   type TGitProcessFailureReason,
   type TGitProcessOutcome,
-} from './git-process.js';
+} from '@robota-sdk/agent-framework';
 export {
   createGitCommandEntry,
   createGitCommandModule,

package/src/goal/goal-command.ts

@@ -4,6 +4,8 @@
  * command host context; all loop logic lives in agent-framework.
  */
 
+import { isGoalCancelVerb } from '@robota-sdk/agent-framework';
+
 import type { ICommandHostGoal } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 import type { IGoalState } from '@robota-sdk/agent-interface-session';
@@ -45,7 +47,7 @@ export async function executeGoalCommand(
       : { message: 'No goal is set.', success: true };
   }
 
-  if (verb === 'cancel' || verb === 'stop') {
+  if (isGoalCancelVerb(trimmed)) {
     const stopped = context.cancelGoal();
     return stopped
       ? { message: `Goal cancelled: ${stopped.objective}`, success: true }

package/src/index.ts

@@ -123,6 +123,12 @@ export {
 } from './mcp-activation/mcp-model-notice.js';
 export type { TMCPUserAction, TMCPUserActionSurface } from './mcp-activation/mcp-model-notice.js';
 export * from './mode/index.js';
+export {
+  createModelCommandEntry,
+  createModelCommandModule,
+  ModelCommandSource,
+} from './model/model-command-module.js';
+export { executeModelCommand } from './model/model-command.js';
 export {
   createSandboxCommandModule,
   executeSandboxCommand,

package/src/mcp-activation/__tests__/mcp-activation-command.test.ts

@@ -655,6 +655,137 @@ describe('/mcp login', () => {
   });
 });
 
+describe('/mcp reload (#3282 §4 part b-2)', () => {
+  function harness(
+    reload: ICommandMCPActivationAdapter['reload'],
+    taken: (names: string[]) => string[] = (names) => names,
+  ) {
+    const added: IToolWithEventService[][] = [];
+    const reloadToolsAddedCalls: { token: string; added: readonly string[] }[] = [];
+    const port: ICommandMCPActivationAdapter = {
+      list: () => [],
+      approve: async () => summary(),
+      reject: async () => summary(),
+      revoke: async () => summary(),
+      reload,
+      reloadToolsAdded: (token, names) => reloadToolsAddedCalls.push({ token, added: names }),
+    };
+    const host = createTestCommandHost({
+      overrides: { getCommandHostAdapters: () => ({ mcpActivation: port }) },
+    });
+    const session = host.getSession();
+    host.getSession = () => ({
+      ...session,
+      addTools: async (tools) => {
+        added.push([...tools]);
+        return taken(tools.map((tool) => tool.schema.name));
+      },
+    });
+    return {
+      added,
+      reloadToolsAddedCalls,
+      run: (args: string) => executeMCPActivationCommand(host, args),
+    };
+  }
+
+  const forecast = new FunctionTool(
+    { name: 'weather__forecast', description: 'Forecast', parameters: { type: 'object', properties: {} } },
+    async () => 'sunny',
+  );
+
+  it('retries not-connected servers, adds the new tools to the session, and names what changed', async () => {
+    const h = harness(async () => ({
+      tools: [forecast],
+      connectedServerIds: ['weather'],
+      failedServerIds: ['flaky'],
+      reloadToken: 'token-1',
+    }));
+
+    const result = await h.run('reload');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Connected: weather.');
+    expect(result.message).toContain('Still not connected: flaky');
+    expect(h.added).toEqual([[forecast]]);
+    expect(result.data).toEqual({
+      connectedServerIds: ['weather'],
+      failedServerIds: ['flaky'],
+      tools: ['weather__forecast'],
+    });
+  });
+
+  it('says plainly when nothing newly connected', async () => {
+    const h = harness(async () => ({ tools: [], connectedServerIds: [], failedServerIds: [] }));
+    const result = await h.run('reload');
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('No server newly connected.');
+  });
+
+  it('is refused when the host offers no reload', async () => {
+    const h = harness(undefined);
+    const result = await h.run('reload');
+    expect(result.success).toBe(false);
+    expect(result.message).toBe('Reloading MCP servers is not available in this environment.');
+  });
+
+  it('tells the port which reloaded tools the session actually took, keyed to the reload it came from', async () => {
+    const h = harness(
+      async () => ({
+        tools: [forecast],
+        connectedServerIds: ['weather'],
+        failedServerIds: [],
+        reloadToken: 'token-1',
+      }),
+      (names) => names,
+    );
+
+    const result = await h.run('reload');
+
+    expect(result.success).toBe(true);
+    expect(h.reloadToolsAddedCalls).toEqual([{ token: 'token-1', added: ['weather__forecast'] }]);
+  });
+
+  it('tells the port when a reloaded tool collided and was dropped', async () => {
+    const h = harness(
+      async () => ({
+        tools: [forecast],
+        connectedServerIds: ['weather'],
+        failedServerIds: [],
+        reloadToken: 'token-1',
+      }),
+      () => [],
+    );
+
+    const result = await h.run('reload');
+
+    expect(result.success).toBe(true);
+    expect(h.reloadToolsAddedCalls).toEqual([{ token: 'token-1', added: [] }]);
+  });
+
+  it('never calls it when the reload has no token to acknowledge (nothing staged)', async () => {
+    // A defensive case: a host that returned tools without a token (should not happen in practice,
+    // since the composition only omits one when there is nothing to stage) must not be acknowledged
+    // — there would be nothing for the token to correlate to.
+    const h = harness(async () => ({
+      tools: [forecast],
+      connectedServerIds: ['weather'],
+      failedServerIds: [],
+    }));
+
+    await h.run('reload');
+
+    expect(h.reloadToolsAddedCalls).toEqual([]);
+  });
+
+  it('never calls it when nothing newly connected', async () => {
+    const h = harness(async () => ({ tools: [], connectedServerIds: [], failedServerIds: [] }));
+
+    await h.run('reload');
+
+    expect(h.reloadToolsAddedCalls).toEqual([]);
+  });
+});
+
 describe('/mcp command entry', () => {
   it('opens only `status` to the model, and describes login for the user', () => {
     const entry = createMCPActivationCommandEntry();

package/src/mcp-activation/mcp-activation-command-module.ts

@@ -35,6 +35,12 @@ export function createMCPActivationCommandEntry(): ICommand {
         source: 'mcp-activation',
         modelInvocable: true,
       },
+      {
+        name: 'reload',
+        description: 'Retry connecting every MCP server that is not currently connected',
+        source: 'mcp-activation',
+        modelInvocable: false,
+      },
       ...(['approve', 'reject', 'revoke', 'login', 'logout'] as const).map((verb) => ({
         name: verb,
         description: USER_ONLY_VERB_DESCRIPTION[verb],