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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robota-sdk/agent-command",
-  "version": "3.0.0-beta.84",
+  "version": "3.0.0-beta.85",
   "description": "Slash-command modules for Robota SDK sessions (/help, /permissions, /mcp, /rewind, …)",
   "type": "module",
   "main": "dist/node/index.js",
@@ -40,12 +40,12 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@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"
+    "@robota-sdk/agent-interface-command": "3.0.0-beta.85",
+    "@robota-sdk/agent-framework": "3.0.0-beta.85",
+    "@robota-sdk/agent-core": "3.0.0-beta.85",
+    "@robota-sdk/agent-interface-execution": "3.0.0-beta.85",
+    "@robota-sdk/agent-interface-session": "3.0.0-beta.85",
+    "@robota-sdk/agent-preset": "3.0.0-beta.85"
   },
   "devDependencies": {
     "@types/node": "^22.19.21",

package/src/doctor/__tests__/doctor-fixture.ts

@@ -139,6 +139,7 @@ export function installBrokenHome(fixture: IDoctorFixture): void {
     JSON.stringify({
       mcpServers: {
         ghost: { command: 'robota-doctor-missing-binary', env: { GHOST_TOKEN: MARKERS.mcp } },
+        ready: { type: 'http', url: 'https://mcp.example.test' },
       },
     }),
   );

package/src/doctor/__tests__/doctor-runner.test.ts

@@ -53,13 +53,16 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(byId(neutral, 'provider.resolution').detail?.join(' ')).not.toMatch(/robota/i);
     expect(byId(neutral, 'workspace.trust').detail?.join(' ')).not.toMatch(/robota/i);
 
-    const hosted = await runDoctor({
-      ...f.inputs,
-      diagnosticGuidance: {
-        providerResolution: 'Run atlas configure.',
-        projectTrust: 'Run atlas trust.',
+    const hosted = await runDoctor(
+      {
+        ...f.inputs,
+        diagnosticGuidance: {
+          providerResolution: 'Run atlas configure.',
+          projectTrust: 'Run atlas trust.',
+        },
       },
-    }, f.deps);
+      f.deps,
+    );
     expect(byId(hosted, 'provider.resolution').detail).toEqual(['Run atlas configure.']);
     expect(byId(hosted, 'workspace.trust').detail).toEqual(['Run atlas trust.']);
   });
@@ -143,6 +146,9 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     const ghost = byId(report, 'mcp.plugin.mcp-plugin@fixture-market.ghost');
     expect(ghost).toMatchObject({ status: 'warn' });
     expect(ghost.cause).toContain('robota-doctor-missing-binary');
+    const declaration = byId(report, 'mcp.plugin.mcp-plugin@fixture-market.ready');
+    expect(declaration.status).toBe('warn');
+    expect(declaration.detail?.join(' ')).toContain('not a runtime source');
     expect(byId(report, 'mcp.activation').status).toBe('not-configured');
     expect(byId(report, 'mcp.connection').status).toBe('not-probed');
     expect(byId(report, 'hooks.execution').status).toBe('not-probed');
@@ -197,6 +203,20 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(byId(report, 'settings.user.robota')).toMatchObject({ status: 'fail' });
   });
 
+  it('an unparseable user settings file is a failed plugin check, not a crash', async () => {
+    const f = fixture({ env: {} });
+    f.mkdir('.robota');
+    f.mkdir('.robota/sessions');
+    f.write('.robota/settings.json', '{ "enabledPlugins": { "helper": false }, }');
+
+    const report = await runDoctor(f.inputs, f.deps);
+
+    expect(byId(report, 'plugins')).toMatchObject({
+      status: 'fail',
+      cause: expect.stringContaining('not valid JSON'),
+    });
+  });
+
   it('TC-04: derives the reachability host from profile baseURL, then defaults.baseURL, then endpoint', async () => {
     const profile = fixture({ env: {} });
     profile.write(

package/src/doctor/doctor-extensions-probe.ts

@@ -179,22 +179,29 @@ function hookChecks(
 
 function mcpServerCheck(server: IBundlePluginMcpServer, deps: IDoctorDeps): IDoctorCheck {
   const id = `mcp.plugin.${server.pluginId}.${server.name}`;
+  const detail = [
+    'Declaration only: plugin .mcp.json is not a runtime source. Copy a supported definition to mcpServers in settings, then use /mcp approve <name>.',
+  ];
   if (server.transport === 'stdio' && server.command !== undefined) {
     return deps.resolveCommand(server.command)
       ? {
           id,
-          label: 'MCP server (plugin)',
-          status: 'ok',
+          label: 'MCP declaration (plugin)',
+          status: 'warn',
           path: server.mcpPath,
           cause: `stdio command ${server.command} resolves`,
+          detail,
         }
       : {
           id,
-          label: 'MCP server (plugin)',
+          label: 'MCP declaration (plugin)',
           status: 'warn',
           path: server.mcpPath,
           cause: `stdio command ${server.command} not found on PATH`,
-          detail: server.envKeys.length === 0 ? [] : [`env keys: ${server.envKeys.join(', ')}`],
+          detail: [
+            ...detail,
+            ...(server.envKeys.length === 0 ? [] : [`env keys: ${server.envKeys.join(', ')}`]),
+          ],
         };
   }
   if (server.transport === 'http' && server.url !== undefined) {
@@ -202,28 +209,31 @@ function mcpServerCheck(server: IBundlePluginMcpServer, deps: IDoctorDeps): IDoc
       new URL(server.url);
       return {
         id,
-        label: 'MCP server (plugin)',
-        status: 'ok',
+        label: 'MCP declaration (plugin)',
+        status: 'warn',
         path: server.mcpPath,
         cause: `url ${server.url}`,
+        detail,
       };
     } catch {
       // allow-fallback: an unparseable url is the finding
       return {
         id,
-        label: 'MCP server (plugin)',
+        label: 'MCP declaration (plugin)',
         status: 'warn',
         path: server.mcpPath,
         cause: 'url is not parseable',
+        detail,
       };
     }
   }
   return {
     id,
-    label: 'MCP server (plugin)',
+    label: 'MCP declaration (plugin)',
     status: 'warn',
     path: server.mcpPath,
     cause: 'neither command nor url declared',
+    detail,
   };
 }
 
@@ -287,11 +297,25 @@ export function probeExtensions(
   // Enablement is read the way the session loader reads it — from the user settings file through the
   // plugin settings store — so the doctor and the session agree even where that store's own policy is
   // a separate open item (recorded on #2670).
-  const plugins = loadHostBundlePluginInspectionFromScopes(inputs.pluginsDirs, {
-    settingsPath: inputs.userSettingsPath,
-  });
+  let plugins: IBundlePluginInspection[];
+  let settingsProblem: string | undefined;
+  try {
+    plugins = loadHostBundlePluginInspectionFromScopes(inputs.pluginsDirs, {
+      settingsPath: inputs.userSettingsPath,
+    });
+  } catch (error) {
+    // Unreadable plugin settings load no plugin in a session. The doctor says so, and still
+    // inspects every installed plugin so its other problems are not hidden behind this one.
+    settingsProblem = error instanceof Error ? error.message : String(error);
+    plugins = loadHostBundlePluginInspectionFromScopes(inputs.pluginsDirs, { enabledPlugins: {} });
+  }
+  const pluginSummary = pluginChecks(plugins).map((check) =>
+    settingsProblem !== undefined && check.id === 'plugins'
+      ? { ...check, status: 'fail' as const, cause: `no plugin loads: ${settingsProblem}` }
+      : check,
+  );
   return [
-    ...pluginChecks(plugins),
+    ...pluginSummary,
     ...skillChecks(inputs),
     ...hookChecks(settings, plugins, deps),
     ...mcpChecks(inputs, plugins, deps),

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

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
@@ -659,13 +659,14 @@ describe('/mcp reload (#3282 §4 part b-2)', () => {
   function harness(
     reload: ICommandMCPActivationAdapter['reload'],
     taken: (names: string[]) => string[] = (names) => names,
+    approve: ICommandMCPActivationAdapter['approve'] = async () => summary(),
   ) {
     const added: IToolWithEventService[][] = [];
     const reloadToolsAddedCalls: { token: string; added: readonly string[] }[] = [];
     const port: ICommandMCPActivationAdapter = {
       list: () => [],
-      approve: async () => summary(),
-      reject: async () => summary(),
+      approve,
+      reject: async () => summary({ status: 'rejected', allowed: false }),
       revoke: async () => summary(),
       reload,
       reloadToolsAdded: (token, names) => reloadToolsAddedCalls.push({ token, added: names }),
@@ -689,7 +690,11 @@ describe('/mcp reload (#3282 §4 part b-2)', () => {
   }
 
   const forecast = new FunctionTool(
-    { name: 'weather__forecast', description: 'Forecast', parameters: { type: 'object', properties: {} } },
+    {
+      name: 'weather__forecast',
+      description: 'Forecast',
+      parameters: { type: 'object', properties: {} },
+    },
     async () => 'sunny',
   );
 
@@ -721,6 +726,94 @@ describe('/mcp reload (#3282 §4 part b-2)', () => {
     expect(result.message).toContain('No server newly connected.');
   });
 
+  it('an approval connects the server in the running session', async () => {
+    const reload = vi.fn(async () => ({
+      tools: [forecast],
+      connectedServerIds: ['weather'],
+      failedServerIds: [],
+      reloadToken: 'token-1',
+    }));
+    const h = harness(reload, undefined, async () =>
+      summary({ serverId: 'weather', status: 'approved', allowed: true, reason: 'Approved.' }),
+    );
+
+    const result = await h.run('approve weather');
+
+    expect(reload).toHaveBeenCalledOnce();
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('is now approved');
+    expect(result.message).toContain('Connected: weather.');
+    expect(h.added).toEqual([[forecast]]);
+  });
+
+  it('acknowledges an empty-tool connection before approving another server', async () => {
+    let released = false;
+    const h = harness(
+      async () =>
+        released
+          ? {
+              tools: [forecast],
+              connectedServerIds: ['weather'],
+              failedServerIds: [],
+              reloadToken: 'second',
+            }
+          : { tools: [], connectedServerIds: ['empty'], failedServerIds: [], reloadToken: 'first' },
+      undefined,
+      async (id) => summary({ serverId: id, status: 'approved', allowed: true }),
+    );
+    await h.run('approve empty');
+    released = h.reloadToolsAddedCalls.some((call) => call.token === 'first');
+    const result = await h.run('approve weather');
+    expect(result.message).toContain('Connected: weather.');
+    expect(h.reloadToolsAddedCalls).toEqual([
+      { token: 'first', added: [] },
+      { token: 'second', added: ['weather__forecast'] },
+    ]);
+  });
+
+  it('preserves a saved approval when connecting fails, and suggests reload', async () => {
+    const h = harness(
+      async () => {
+        throw new Error('connection failed');
+      },
+      undefined,
+      async () => summary({ status: 'approved', allowed: true }),
+    );
+    const result = await h.run('approve weather');
+    expect(result.success).toBe(true);
+    expect(result.data).toMatchObject({ status: 'approved', allowed: true });
+    expect(result.message).toContain('connection failed');
+    expect(result.message).toContain('/mcp reload');
+  });
+
+  it('releases a staged reload even when adding tools throws', async () => {
+    const h = harness(
+      async () => ({
+        tools: [forecast],
+        connectedServerIds: ['weather'],
+        failedServerIds: [],
+        reloadToken: 'token-failed',
+      }),
+      () => {
+        throw new Error('cannot add tools');
+      },
+      async () => summary({ status: 'approved', allowed: true }),
+    );
+    const result = await h.run('approve weather');
+    expect(result.success).toBe(true);
+    expect(h.reloadToolsAddedCalls).toEqual([{ token: 'token-failed', added: [] }]);
+  });
+
+  it('a decision that is not an approval connects nothing', async () => {
+    const reload = vi.fn(async () => ({ tools: [], connectedServerIds: [], failedServerIds: [] }));
+    const h = harness(reload);
+
+    await h.run('reject weather');
+    await h.run('approve weather');
+
+    expect(reload).not.toHaveBeenCalled();
+  });
+
   it('is refused when the host offers no reload', async () => {
     const h = harness(undefined);
     const result = await h.run('reload');

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

@@ -213,7 +213,7 @@ export async function executeMCPActivationCommand(
 
   try {
     const result = await mcp[verb](serverId);
-    return {
+    const decided = {
       message: `MCP server ${serverId} is now ${result.status}. ${result.reason}`,
       success:
         result.status === 'approved' || result.status === 'rejected' || result.status === 'revoked',
@@ -227,6 +227,24 @@ export async function executeMCPActivationCommand(
         securityIdentity: result.securityIdentity,
       },
     };
+    // An approval takes effect now: the session connects the server as `/mcp reload` would.
+    if (verb !== 'approve' || result.status !== 'approved' || mcp.reload === undefined) {
+      return decided;
+    }
+    try {
+      const reloaded = await reloadResult(context);
+      return {
+        ...decided,
+        message: `${decided.message} ${reloaded.message}`,
+        data: { ...decided.data, reload: reloaded.data ?? {} },
+      };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return {
+        ...decided,
+        message: `${decided.message} Could not connect now: ${reason}. Run /mcp reload to retry.`,
+      };
+    }
   } catch (error) {
     return {
       message: error instanceof Error ? error.message : String(error),
@@ -272,13 +290,17 @@ async function reloadResult(context: TMCPActivationCommandContext): Promise<ICom
     };
   }
   if (mcp.reload === undefined) {
-    return { message: 'Reloading MCP servers is not available in this environment.', success: false };
+    return {
+      message: 'Reloading MCP servers is not available in this environment.',
+      success: false,
+    };
   }
   const result = await mcp.reload();
-  const added =
-    result.tools.length === 0 ? [] : await context.getSession().addTools(result.tools);
-  if (result.tools.length > 0 && result.reloadToken !== undefined) {
-    mcp.reloadToolsAdded?.(result.reloadToken, added);
+  let added: readonly string[] = [];
+  try {
+    added = result.tools.length === 0 ? [] : await context.getSession().addTools(result.tools);
+  } finally {
+    if (result.reloadToken !== undefined) mcp.reloadToolsAdded?.(result.reloadToken, added);
   }
   const dropped = result.tools.length - added.length;
   const parts = [

package/src/plugin/__tests__/plugin-command-module.test.ts

@@ -46,10 +46,7 @@ function createCommandSessionRuntime() {
   });
 }
 
-function createCommandHostContext(
-  adapter?: ICommandPluginAdapter,
-  locality?: 'local' | 'remote',
-) {
+function createCommandHostContext(adapter?: ICommandPluginAdapter, locality?: 'local' | 'remote') {
   const checkpoint = {
     id: 'checkpoint_1',
     sessionId: 'session_1',
@@ -111,7 +108,9 @@ describe('createPluginCommandModule', () => {
       }),
       expect.objectContaining({
         name: 'reload-plugins',
-        description: 'Reload all plugin resources',
+        description: expect.stringContaining(
+          'refresh the command list, skill routing and model skill catalogue',
+        ),
         source: 'plugin-manager',
         modelInvocable: false,
       }),
@@ -278,7 +277,8 @@ describe('executeReloadPluginsCommand', () => {
       executeReloadPluginsCommand(createCommandHostContext(adapter), ''),
     ).resolves.toEqual({
       success: true,
-      message: 'Reloaded 3 plugin resources.',
+      message:
+        'Reloaded 3 plugin resources. Plugin commands and skills are active now; hook changes apply to new sessions.',
       data: { pluginRegistryReloaded: true },
     });
     expect(adapter.reloadPlugins).toHaveBeenCalled();
@@ -294,6 +294,7 @@ describe('executeReloadPluginsCommand', () => {
     ).resolves.toEqual({
       success: false,
       message: 'Plugin error: manifest failed',
+      data: { pluginRegistryReloaded: true },
     });
   });
 });

package/src/plugin/plugin-command.ts

@@ -259,11 +259,10 @@ export async function executeReloadPluginsCommand(
       result.loadedPluginCount === 1
         ? '1 plugin resource'
         : `${result.loadedPluginCount} plugin resources`;
-    return `Reloaded ${suffix}.`;
+    return `Reloaded ${suffix}. Plugin commands and skills are active now; hook changes apply to new sessions.`;
   }).then((result) => {
-    if (!result.success) return result;
-    // CMD-004 Stage E: the semantic reload already ran HOST-side above (`adapter.reloadPlugins()`);
-    // the requester-local registry/autocomplete refresh rides the result as a data hint.
+    // A failed reload must also refresh the admitted snapshot: malformed settings must not leave
+    // previously loaded code executable. Preserve the error while requesting the same refresh.
     return {
       ...result,
       data: { ...result.data, pluginRegistryReloaded: true },