@robota-sdk/agent-command 3.0.0-beta.86 → 3.0.0-beta.87

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

@@ -41,7 +41,7 @@ function byId(report: IDoctorReport, id: string) {
 const CLEAN_SETTINGS = {
   currentProvider: 'doctor-env',
   providers: {
-    'doctor-env': { type: 'fixture', model: 'fixture-model', apiKey: '$ENV:ROBOTA_DOCTOR_MARKER' },
+    'doctor-env': { type: 'fixture', model: 'fixture-model', apiKey: '$ENV:FIXTURE_DOCTOR_MARKER' },
     'doctor-inactive': { type: 'fixture', model: 'fixture-model', apiKey: MARKERS.profile },
   },
 };
@@ -50,8 +50,8 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   it('uses neutral provider and trust guidance unless the host supplies its own commands', async () => {
     const f = fixture({ env: {} });
     const neutral = await runDoctor(f.inputs, f.deps);
-    expect(byId(neutral, 'provider.resolution').detail?.join(' ')).not.toMatch(/robota/i);
-    expect(byId(neutral, 'workspace.trust').detail?.join(' ')).not.toMatch(/robota/i);
+    expect(byId(neutral, 'provider.resolution').detail?.join(' ')).not.toMatch(/fixture-agent/i);
+    expect(byId(neutral, 'workspace.trust').detail?.join(' ')).not.toMatch(/fixture-agent/i);
 
     const hosted = await runDoctor(
       {
@@ -70,7 +70,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   it('shows each effective settings hook source without embedding payloads in provenance', async () => {
     const f = fixture({ env: {} });
     const userPath = f.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         disabledHooks: ['project-muted'],
         hooks: {
@@ -118,18 +118,18 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   });
 
   it('TC-05/TC-02: names every failing path and cause in the broken HOME and exits 1', async () => {
-    const f = fixture({ env: { ROBOTA_DOCTOR_MARKER: MARKERS.env } });
+    const f = fixture({ env: { FIXTURE_DOCTOR_MARKER: MARKERS.env } });
     installBrokenHome(f);
     const report = await runDoctor(f.inputs, f.deps);
 
     expect(report.exitCode).toBe(1);
     expect(byId(report, 'host.fixture').status).toBe('ok');
-    const user = byId(report, 'settings.user.robota');
+    const user = byId(report, 'settings.user.fixture-product');
     expect(user).toMatchObject({
       status: 'fail',
       cause: 'empty',
-      path: join(f.home, '.robota', 'settings.json'),
-      repair: 'settings.user.robota',
+      path: join(f.home, '.fixture-product', 'settings.json'),
+      repair: 'settings.user.fixture-product',
     });
     const claude = byId(report, 'settings.user.claude');
     expect(claude.status).toBe('fail');
@@ -145,7 +145,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(broken.path).toContain(join('broken-plugin', '1.0.0', '.claude-plugin', 'plugin.json'));
     const ghost = byId(report, 'mcp.plugin.mcp-plugin@fixture-market.ghost');
     expect(ghost).toMatchObject({ status: 'warn' });
-    expect(ghost.cause).toContain('robota-doctor-missing-binary');
+    expect(ghost.cause).toContain('agent-test-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');
@@ -155,11 +155,11 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(byId(report, 'storage.user').status).toBe('ok');
     expect(byId(report, 'storage.project').status).toBe('not-configured');
     expect(byId(report, 'workspace.trust').status).toBe('warn');
-    expect(report.repairable).toEqual(['settings.user.robota']);
+    expect(report.repairable).toEqual(['settings.user.fixture-product']);
   });
 
   it('TC-03: no rendered line carries a marker secret from any input', async () => {
-    const f = fixture({ env: { ROBOTA_DOCTOR_MARKER: MARKERS.env } });
+    const f = fixture({ env: { FIXTURE_DOCTOR_MARKER: MARKERS.env } });
     installBrokenHome(f);
     // Overwrite the schema-invalid layer with a syntax error beside a secret (the parser-snippet case).
     f.write('.claude/settings.json', `{"providers":{"x":{"apiKey": ${MARKERS.adjacent}}}}`);
@@ -170,10 +170,10 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   });
 
   it('TC-03: masks the resolved credential and inactive-profile literals in a clean configuration', async () => {
-    const f = fixture({ env: { ROBOTA_DOCTOR_MARKER: MARKERS.env } });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
-    f.write('.robota/settings.json', JSON.stringify(CLEAN_SETTINGS));
+    const f = fixture({ env: { FIXTURE_DOCTOR_MARKER: MARKERS.env } });
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
+    f.write('.fixture-product/settings.json', JSON.stringify(CLEAN_SETTINGS));
     const report = await runDoctor(f.inputs, f.deps);
     const text = renderDoctorReport(report).join('\n');
     expect(report.exitCode).toBe(0);
@@ -184,15 +184,15 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
 
   it('TC-03: a parse error in a settings layer never renders the file excerpt around the fault', async () => {
     const f = fixture({ env: {} });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
     // Unquoted value: JSON.parse's message quotes the bytes around the fault, i.e. the credential.
     f.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       `{"currentProvider":"p","providers":{"p":{"apiKey": ${MARKERS.adjacent}}}}`,
     );
     const report = await runDoctor(f.inputs, f.deps);
-    const text = renderDoctorReport(report, 'robota doctor').join('\n');
+    const text = renderDoctorReport(report, 'fixture-agent doctor').join('\n');
     expect(text).not.toContain(MARKERS.adjacent);
     expect(text).not.toContain(MARKERS.adjacent.slice(0, 10));
     expect(text).not.toContain('..."');
@@ -200,14 +200,14 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
       status: 'fail',
       cause: expect.stringContaining('SettingsParseError'),
     });
-    expect(byId(report, 'settings.user.robota')).toMatchObject({ status: 'fail' });
+    expect(byId(report, 'settings.user.fixture-product')).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 }, }');
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
+    f.write('.fixture-product/settings.json', '{ "enabledPlugins": { "helper": false }, }');
 
     const report = await runDoctor(f.inputs, f.deps);
 
@@ -220,7 +220,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   it('TC-04: derives the reachability host from profile baseURL, then defaults.baseURL, then endpoint', async () => {
     const profile = fixture({ env: {} });
     profile.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'p',
         providers: {
@@ -241,7 +241,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
       ],
     });
     defaults.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'p',
         providers: { p: { type: 'fixture', model: 'm', apiKey: 'k1234' } },
@@ -252,7 +252,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
 
     const endpoint = fixture({ env: {} });
     endpoint.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'p',
         providers: { p: { type: 'fixture', model: 'm', apiKey: 'k1234' } },
@@ -267,7 +267,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
       providerDefinitions: [fixtureProviderDefinition({ endpoint: undefined })],
     });
     none.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'p',
         providers: { p: { type: 'fixture', model: 'm', apiKey: 'k1234' } },
@@ -280,10 +280,10 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
 
   it('TC-04: an unreachable host is warn, not fail, so an offline doctor still exits 0', async () => {
     const f = fixture({ env: {}, reachable: false });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
     f.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'p',
         providers: { p: { type: 'fixture', model: 'm', apiKey: 'k1234' } },
@@ -301,15 +301,15 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(byId(report, 'provider.resolution').status).toBe('fail');
 
     const win = fixture({ env: {}, guarantee: 'windows-acl' });
-    win.mkdir('.robota');
-    win.mkdir('.robota/sessions');
+    win.mkdir('.fixture-product');
+    win.mkdir('.fixture-product/sessions');
     expect(byId(await runDoctor(win.inputs, win.deps), 'storage.user').status).toBe('not-probed');
   });
 
   it('TC-05: a too-open storage directory is warn and repairable', async () => {
     const f = fixture({ env: {} });
-    f.mkdir('.robota', 0o755);
-    f.mkdir('.robota/sessions', 0o755);
+    f.mkdir('.fixture-product', 0o755);
+    f.mkdir('.fixture-product/sessions', 0o755);
     const report = await runDoctor(f.inputs, f.deps);
     expect(byId(report, 'storage.user')).toMatchObject({ status: 'warn', repair: 'storage.user' });
   });
@@ -317,13 +317,13 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
   it('TC-07: repair rewrites only an empty user settings file, re-reads before writing, and is idempotent', async () => {
     const f = fixture({ env: {} });
     installBrokenHome(f);
-    const path = join(f.home, '.robota', 'settings.json');
+    const path = join(f.home, '.fixture-product', 'settings.json');
 
     expect(planDoctorRepair('nope', f.inputs, f.deps)).toMatchObject({ ok: false });
     expect(planDoctorRepair('settings.user.claude', f.inputs, f.deps)).toMatchObject({ ok: false });
 
     const refused = await applyDoctorRepair(
-      'settings.user.robota',
+      'settings.user.fixture-product',
       f.inputs,
       f.deps,
       async () => false,
@@ -332,26 +332,26 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     expect(readFileSync(path, 'utf8')).toBe('');
 
     // The state changes between confirmation and write: refused, nothing overwritten.
-    const raced = await applyDoctorRepair('settings.user.robota', f.inputs, f.deps, async () => {
-      f.write('.robota/settings.json', '{"language":"ko"}');
+    const raced = await applyDoctorRepair('settings.user.fixture-product', f.inputs, f.deps, async () => {
+      f.write('.fixture-product/settings.json', '{"language":"ko"}');
       return true;
     });
     expect(raced).toMatchObject({ applied: false });
     expect(readFileSync(path, 'utf8')).toBe('{"language":"ko"}');
 
-    f.write('.robota/settings.json', '');
+    f.write('.fixture-product/settings.json', '');
     const applied = await applyDoctorRepair(
-      'settings.user.robota',
+      'settings.user.fixture-product',
       f.inputs,
       f.deps,
       async () => true,
     );
     expect(applied.applied).toBe(true);
     expect(JSON.parse(readFileSync(path, 'utf8'))).toEqual({});
-    expect(byId(await runDoctor(f.inputs, f.deps), 'settings.user.robota').status).toBe('ok');
+    expect(byId(await runDoctor(f.inputs, f.deps), 'settings.user.fixture-product').status).toBe('ok');
 
     const again = await applyDoctorRepair(
-      'settings.user.robota',
+      'settings.user.fixture-product',
       f.inputs,
       f.deps,
       async () => true,
@@ -363,7 +363,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     const f = fixture({ env: {} });
     const applied = await applyDoctorRepair('storage.user', f.inputs, f.deps, async () => true);
     expect(applied.applied).toBe(true);
-    expect(statSync(join(f.home, '.robota', 'sessions')).mode & 0o077).toBe(0);
+    expect(statSync(join(f.home, '.fixture-product', 'sessions')).mode & 0o077).toBe(0);
     expect(byId(await runDoctor(f.inputs, f.deps), 'storage.user').status).toBe('ok');
     expect(
       await applyDoctorRepair('storage.user', f.inputs, f.deps, async () => true),
@@ -372,14 +372,14 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
 
   it('TC-05 (skills): a skill definition session discovery throws on is a fail check, not a warning', async () => {
     const f = fixture({ env: {} });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
-    f.write('.robota/settings.json', JSON.stringify(CLEAN_SETTINGS));
-    f.write('.robota/skills/bad-effort/SKILL.md', '---\nname: bad\neffort: extreme\n---\nbody\n');
-    f.write('.robota/skills/no-frontmatter/SKILL.md', 'just text\n');
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
+    f.write('.fixture-product/settings.json', JSON.stringify(CLEAN_SETTINGS));
+    f.write('.fixture-product/skills/bad-effort/SKILL.md', '---\nname: bad\neffort: extreme\n---\nbody\n');
+    f.write('.fixture-product/skills/no-frontmatter/SKILL.md', 'just text\n');
     const report = await runDoctor(f.inputs, f.deps);
     expect(
-      byId(report, `skill.${join('.robota', 'skills', 'bad-effort', 'SKILL.md')}`),
+      byId(report, `skill.${join('.fixture-product', 'skills', 'bad-effort', 'SKILL.md')}`),
     ).toMatchObject({
       status: 'fail',
       cause: 'frontmatter-invalid',
@@ -387,7 +387,7 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
     });
     expect(JSON.stringify(report)).not.toContain('received "extreme"');
     expect(
-      byId(report, `skill.${join('.robota', 'skills', 'no-frontmatter', 'SKILL.md')}`).status,
+      byId(report, `skill.${join('.fixture-product', 'skills', 'no-frontmatter', 'SKILL.md')}`).status,
     ).toBe('warn');
     expect(report.exitCode).toBe(1);
   });
@@ -417,10 +417,10 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
 
   it('TC-05: reports the quarantined provider endpoint without printing either credential', async () => {
     const f = fixture({ env: {} });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
     f.write(
-      '.robota/settings.json',
+      '.fixture-product/settings.json',
       JSON.stringify({
         currentProvider: 'q',
         providers: {
@@ -442,16 +442,16 @@ describe('runDoctor (OBSERVABILITY-1991)', () => {
       status: 'warn',
       cause: expect.stringContaining('quarantined'),
     });
-    const text = renderDoctorReport(report, 'robota doctor').join('\n');
+    const text = renderDoctorReport(report, 'fixture-agent doctor').join('\n');
     expect(text).not.toContain(MARKERS.profile);
     expect(text).toContain('[provider.security] warn');
   });
 
   it('a throwing endpoint probe is a provider fail check, not a rejected run', async () => {
     const f = fixture({ env: {} });
-    f.mkdir('.robota');
-    f.mkdir('.robota/sessions');
-    f.write('.robota/settings.json', JSON.stringify(CLEAN_SETTINGS));
+    f.mkdir('.fixture-product');
+    f.mkdir('.fixture-product/sessions');
+    f.write('.fixture-product/settings.json', JSON.stringify(CLEAN_SETTINGS));
     const deps = {
       ...f.deps,
       probeEndpoint: () => Promise.reject(new RangeError('socket table exhausted')),

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

@@ -137,7 +137,7 @@ function trustCheck(inputs: IDoctorInputs): IDoctorCheck {
 }
 
 /**
- * The credential-quarantine report `robota diagnose` already shipped (CLI-067), over the inspection's
+ * The credential-quarantine report already shipped (CLI-067), over the inspection's
  * parsed layers instead of a private re-read: a lower-trust layer that changed a profile's `baseURL`
  * without supplying its own key had the inherited key removed. Neither key is ever shown.
  */

package/src/doctor/doctor-types.ts

@@ -1,8 +1,8 @@
 /**
  * The doctor's evidence model (OBSERVABILITY-1991).
  *
- * `fail` is the only status that raises the exit code — the CLI-067 contract `robota diagnose`
- * shipped with. `not-configured` names an absent optional capability out loud instead of treating
+ * `fail` is the only status that raises the exit code — the diagnostic command contract shipped
+ * with. `not-configured` names an absent optional capability out loud instead of treating
  * it as healthy. `not-probed` is a CLOSED list of probes the read-only doctor deliberately does not
  * run (see {@link TDoctorNotProbed}); an UNEXPECTED inability to probe is `warn` with its reason,
  * never `not-probed` — the third state `enforcement-architecture.md` says must never read as a pass.

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

@@ -39,7 +39,7 @@ function fakeHandoff(canHandoff: boolean): ITerminalHandoff {
 
 /** Write a fake `$EDITOR`: a script that writes `content` into the file it is given as $1. */
 function installFakeEditor(content: string): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'robota-fake-editor-')));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-test-fake-editor-')));
   const script = join(dir, 'fake-editor.sh');
   writeFileSync(
     script,

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

@@ -144,7 +144,7 @@ describe('/fork writes the copy and starts the job that resumes it (CLI-1994 TC-
     expect(result.success).toBe(false);
     expect(result.message).toContain('depth limit reached');
     expect(result.message).toContain(FORK_SESSION_ID);
-    expect(result.message).not.toContain('robota');
+    expect(result.message).not.toContain('fixture-agent');
   });
 
   it('renders a host-selected resume command after a fork spawn failure', async () => {

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

@@ -56,6 +56,6 @@ export function createForkCommandModule(
     systemCommands: [createForkSystemCommand(formatResumeCommand)],
     // A fork is a background agent job resuming a session record; a host with no agent runtime has
     // neither half, so the command is not offered rather than offered and refused.
-    sessionRequirements: ['agent-runtime'],
+    sessionRequirements: ['runtime'],
   };
 }

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

@@ -40,7 +40,7 @@ const providerSettingsAdapter: IProviderCommandSettingsAdapter = {
   writeTargetSettings: () => undefined,
 };
 /** User-local storage lives in a private per-run directory, never a fixed name under /tmp. */
-const USER_LOCAL_STORAGE_ROOT = mkdtempSync(join(tmpdir(), 'robota-test-'));
+const USER_LOCAL_STORAGE_ROOT = mkdtempSync(join(tmpdir(), 'agent-test-test-'));
 afterAll(() => rmSync(USER_LOCAL_STORAGE_ROOT, { recursive: true, force: true }));
 
 const BASE_OPTIONS = { cwd: '/tmp', userLocalStorageRoot: USER_LOCAL_STORAGE_ROOT, providerDefinitions, providerSettingsAdapter } as const;

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

@@ -18,7 +18,7 @@ describe('/handoff command module', () => {
     const description =
       createHandoffCommandModule().commandSources?.[0]?.getCommands()[0]?.description;
     expect(description).toContain('/handoff <session-or-device-id>');
-    expect(description).toMatch(/linked over the device mesh/);
+    expect(description).toMatch(/another linked device/);
     expect(description).toMatch(/user-only/i);
     expect(description).toContain('saved, not started');
   });

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

@@ -8,7 +8,7 @@ export function createHandoffCommandEntry(): ICommand {
     name: 'handoff',
     displayName: 'Hand off',
     description:
-      "Push this conversation to another running Robota session of the same user on this machine, or to another of the user's devices linked over the device mesh, after the operator confirms what stays behind (uncommitted changes, running processes; credentials never travel). The receiving operator must also accept; the session arrives saved, not started, and this one ends once it is saved there. With no argument it lists the sessions and devices it could go to. User-only: the model cannot run it; when the user wants to continue this work in another session or on another device, suggest they run `/handoff <session-or-device-id>`.",
+      "Push this conversation to another running session for the same user on this machine, or to another linked device, after the operator confirms what stays behind (uncommitted changes, running processes; credentials never travel). The receiving operator must also accept; the session arrives saved, not started, and this one ends once it is saved there. With no argument it lists the sessions and devices it could go to. User-only: the model cannot run it; when the user wants to continue this work in another session or on another device, suggest they run `/handoff <session-or-device-id>`.",
     source: 'handoff',
     // User-only: a hand-off moves authority over the operator's work to another place, a decision
     // about where the person is, not about the task.

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

@@ -31,7 +31,7 @@ export function createKeybindingsCommandEntry(): ICommand {
 // A host without a terminal (the desktop app's sidecar) still answers, so the command is never
 // "unknown" there — it says where key bindings live instead.
 const KEYBINDINGS_UNAVAILABLE =
-  'Key bindings belong to the robota terminal, and this surface has none. Run /keybindings in the robota terminal.';
+  'Key bindings are available in an interactive terminal. Run /keybindings there.';
 
 export async function executeKeybindingsCommand(
   file: IKeybindingsFilePort | undefined,

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

@@ -311,7 +311,7 @@ describe('/mcp and OAuth sign-in', () => {
   it('points a server that needs a sign-in at the session command and the terminal one', async () => {
     const result = await executeMCPActivationCommand(context(withServer('files')), 'status');
     expect(result.message).toContain(
-      'OAuth: sign-in required (run /mcp login files, or robota mcp login files in a terminal)',
+      'OAuth: sign-in required (run /mcp login files, or sign in from a terminal)',
     );
   });
 
@@ -322,14 +322,14 @@ describe('/mcp and OAuth sign-in', () => {
     ['a backslash-quote', "\\';touch pwned;#"],
     ['a leading dash', '-rf'],
     ['a leading equals sign', '=cmd'],
-    ['a newline', 'x\nrobota mcp login good'],
+    ['a newline', 'x\nfixture-agent mcp login good'],
     ['an escape sequence', 'x\u001b[2Kgood'],
     ['a right-to-left override', 'x‮good'],
   ])('never puts a name with %s into the sign-in command', async (_what, name) => {
     const result = await executeMCPActivationCommand(context(withServer(name)), 'status');
     const hint = /\(run \/mcp login [^)]*\)/.exec(result.message)?.[0];
     expect(hint).toBe(
-      '(run /mcp login <server>, or robota mcp login <server> in a terminal; ' +
+      '(run /mcp login <server>, or sign in from a terminal; ' +
         'its name cannot be shown safely here)',
     );
   });
@@ -529,7 +529,7 @@ describe('/mcp login', () => {
     const h = harness(async (request) => signedIn(request.serverId));
     const result = await h.run('login files --client-secret');
     expect(result.success).toBe(false);
-    expect(result.message).toContain('robota mcp login files --client-secret in a terminal');
+    expect(result.message).toContain('Sign in from a terminal configured for this product.');
     expect(h.requests).toEqual([]);
   });
 
@@ -542,7 +542,7 @@ describe('/mcp login', () => {
         tools: [],
       })).run('login files');
     expect((await failing(true)).message).toContain(
-      'run robota mcp login files --client-secret in a terminal',
+      'sign in from a terminal configured for this product',
     );
     expect((await failing(false)).message).not.toContain('--client-secret');
   });
@@ -557,7 +557,7 @@ describe('/mcp login', () => {
     expect((await h.run('login files')).message).toContain('/mcp login files --no-browser');
     expect((await h.run('login x$(id)')).message).toContain('/mcp login <server> --no-browser');
     expect((await h.run('login =cmd --client-secret')).message).toContain(
-      'robota mcp login <server> --client-secret',
+      'Sign in from a terminal configured for this product.',
     );
   });
 
@@ -880,14 +880,14 @@ describe('/mcp reload (#3282 §4 part b-2)', () => {
 });
 
 describe('/mcp command entry', () => {
-  it('opens only `status` to the model, and describes login for the user', () => {
+  it('opens status and skill metadata to the model, and describes login for the user', () => {
     const entry = createMCPActivationCommandEntry();
     // Model-invocable only through its read-only `status`; every verb that changes trust or a
     // credential is declared user-only (model-exposure.test.ts pins the refusal).
     expect(entry.modelInvocable).toBe(true);
     expect(
       (entry.subcommands ?? []).filter((sub) => sub.modelInvocable === true).map((s) => s.name),
-    ).toEqual(['status']);
+    ).toEqual(['status', 'skill-list']);
     expect(entry.description).toMatch(/sign in/);
     expect(entry.description).toMatch(/Returns/);
     expect(entry.argumentHint).toContain('login <server> [--no-browser]');

package/src/mcp-activation/__tests__/mcp-model-view.test.ts

@@ -26,7 +26,7 @@ function summary(overrides: Partial<ICommandMCPActivationSummary>): ICommandMCPA
     status: 'pending',
     allowed: false,
     reason: 'SECRET-REASON-TEXT from a definition',
-    provenanceId: 'project-settings:/home/me/repo/.robota/settings.json',
+    provenanceId: 'project-settings:/home/me/repo/.fixture-state/settings.json',
     definitionFingerprint: 'fingerprint-abc',
     securityIdentity: 'https://user:hunter2@mcp.example.com/?token=abc',
     ...overrides,
@@ -42,7 +42,7 @@ const adapter: ICommandMCPActivationAdapter = {
     summary({ serverId: 'gone', status: 'rejected' }),
   ],
   sourceProblems: () => [
-    { source: 'project', origin: '/home/me/repo/.robota/settings.json', reason: 'not json' },
+    { source: 'project', origin: '/home/me/repo/.fixture-state/settings.json', reason: 'not json' },
   ],
   approve: () => {
     throw new Error('not used');
@@ -56,11 +56,14 @@ const adapter: ICommandMCPActivationAdapter = {
   oauthStatus: async () => [{ serverId: 'github', state: 'sign-in-required' }],
 };
 
-function host(source: TCommandInvocationSource) {
+function host(source: TCommandInvocationSource, cliName = 'test-agent', terminal = false) {
   return createTestCommandHost({
     overrides: {
-      getCommandHostAdapters: () => ({ mcpActivation: adapter }),
+      getCommandHostAdapters: () => ({
+        mcpActivation: terminal ? { ...adapter, userActionSurface: 'terminal' } : adapter,
+      }),
       getCommandInvocationSource: () => source,
+      getCommandProductVocabulary: () => ({ cliName, displayName: cliName }),
     },
   });
 }
@@ -75,7 +78,7 @@ describe('/mcp status as the model sees it', () => {
         'MCP servers:',
         '  github — approved — sign-in: sign-in-required — ask the user to run `/mcp login github`',
         '  linear — pending — ask the user to run `/mcp approve linear`',
-        '  jira — untrusted — ask the user to run `robota trust`',
+        '  jira — untrusted — ask the user to run `test-agent trust`',
         '  (name not shown) — stale — ask the user to run `/mcp approve <server>`',
         '  gone — rejected',
         '1 MCP configuration source(s) could not be read; the user can see which with `/mcp status`.',
@@ -90,12 +93,13 @@ describe('/mcp status as the model sees it', () => {
         overrides: {
           getCommandHostAdapters: () => ({ mcpActivation: terminal }),
           getCommandInvocationSource: () => 'model',
+          getCommandProductVocabulary: () => ({ cliName: 'test-agent', displayName: 'Test Agent' }),
         },
       }),
       'status',
     );
     expect(result.message).toContain(
-      'github — approved — sign-in: sign-in-required — ask the user to run `robota mcp login github`',
+      'github — approved — sign-in: sign-in-required — ask the user to run `test-agent mcp login github`',
     );
     expect(result.message).not.toContain('/mcp login');
     // Approval has no terminal command; it stays the session command.
@@ -168,24 +172,51 @@ describe('MCP notices for the model', () => {
         'cannot do this yourself; ask the user to run `/mcp approve linear`.',
     );
     expect(mcpUserActionNotice('github', 'sign-in')).toContain('`/mcp login github`');
-    expect(mcpUserActionNotice('jira', 'trust-workspace')).toContain(
-      '`robota trust` in a terminal, then restart the session',
+    expect(mcpUserActionNotice('jira', 'trust-workspace', 'session', 'test-agent')).toContain(
+      '`test-agent trust` in a terminal, then restart the session',
     );
   });
 
   it('names the terminal sign-in command where no /mcp command can be typed', () => {
-    expect(mcpUserActionNotice('github', 'sign-in', 'terminal')).toBe(
+    expect(mcpUserActionNotice('github', 'sign-in', 'terminal', 'test-agent')).toBe(
       'MCP server "github" needs the user to sign in, so its tools are unavailable. You cannot do ' +
-        'this yourself; ask the user to run `robota mcp login github` in a terminal, then restart ' +
+        'this yourself; ask the user to run `test-agent mcp login github` in a terminal, then restart ' +
         'the session.',
     );
-    expect(mcpUserActionCommand('$(curl evil)', 'sign-in', 'terminal')).toBe(
-      'robota mcp login <server>',
+    expect(mcpUserActionCommand('$(curl evil)', 'sign-in', 'terminal', 'test-agent')).toBe(
+      'test-agent mcp login <server>',
     );
     // Only sign-in moves: approval has no terminal command.
     expect(mcpUserActionCommand('linear', 'approve', 'terminal')).toBe('/mcp approve linear');
   });
 
+  it('uses the command vocabulary supplied by each host and stays generic when it is absent', async () => {
+    const first = await executeMCPActivationCommand(host('model', 'alpha-agent', true), 'status');
+    const second = await executeMCPActivationCommand(host('model', 'beta-agent', true), 'status');
+    const noVocabulary = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          mcpActivation: { ...adapter, userActionSurface: 'terminal' },
+        }),
+        getCommandInvocationSource: () => 'model',
+      },
+    });
+    const generic = await executeMCPActivationCommand(noVocabulary, 'status');
+
+    expect(first.message).toContain('`alpha-agent mcp login github`');
+    expect(first.message).not.toContain('beta-agent');
+    expect(second.message).toContain('`beta-agent mcp login github`');
+    expect(second.message).not.toContain('alpha-agent');
+    expect(generic.message).not.toContain('mcp login');
+    expect(generic.message).not.toMatch(/undefined|fixture-agent/i);
+    expect(mcpUserActionNotice('jira', 'trust-workspace', 'session', 'alpha-agent')).toContain(
+      '`alpha-agent trust` in a terminal, then restart the session',
+    );
+    expect(mcpUserActionNotice('jira', 'trust-workspace')).toContain(
+      'ask the user to trust this workspace in a terminal',
+    );
+  });
+
   it('stays generic for a name that is not safe to show', () => {
     const notice = mcpUserActionNotice('$(curl evil)', 'sign-in');
     expect(notice).not.toContain('curl');