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

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

@@ -14,6 +14,7 @@ import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
 import type {
   IMemoryStore,
+  IRemoteCommandPolicy,
   IWorkspaceIdentity,
   IWorkspaceTrustStore,
   IWorkspaceTrustStoreSnapshot,
@@ -21,7 +22,7 @@ import type {
 
 // SEC-003 (js/insecure-temporary-file): `mkdtempSync` yields a 0700 directory with an unpredictable
 // name, so no other user can pre-create or read the paths this suite writes under it.
-const TMP_BASE = realpathSync(mkdtempSync(join(tmpdir(), 'robota-command-memory-')));
+const TMP_BASE = realpathSync(mkdtempSync(join(tmpdir(), 'agent-test-command-memory-')));
 const memoryStores = new Map<string, Promise<IMemoryStore>>();
 
 class TrustedStore implements IWorkspaceTrustStore {
@@ -52,10 +53,10 @@ function createMemoryStore(cwd: string): Promise<IMemoryStore> {
       identityResolver: { resolve: () => identity },
       store: new TrustedStore(),
       projectStateDirectories: {
-        sessions: join('.robota', 'sessions'),
-        'session-logs': join('.robota', 'logs'),
-        memory: join('.robota', 'memory'),
-        checkpoints: join('.robota', 'checkpoints'),
+        sessions: join('.fixture-state', 'sessions'),
+        'session-logs': join('.fixture-state', 'logs'),
+        memory: join('.fixture-state', 'memory'),
+        checkpoints: join('.fixture-state', 'checkpoints'),
       },
     });
     const access = await service.inspect(root);
@@ -104,6 +105,7 @@ function createMockRuntimeSession() {
 async function createInteractiveSession(
   cwd = makeProject(),
   permissionMode: 'default' | 'plan' = 'default',
+  remoteCommandPolicy?: IRemoteCommandPolicy,
 ): Promise<InteractiveSession> {
   const runtime = createMockRuntimeSession();
   runtime.getPermissionMode.mockReturnValue(permissionMode);
@@ -112,6 +114,7 @@ async function createInteractiveSession(
     session: runtime as never,
     memoryStore: await createMemoryStore(cwd),
     commandModules: [createMemoryCommandModule()],
+    ...(remoteCommandPolicy ? { remoteCommandPolicy } : {}),
   });
 }
 
@@ -152,6 +155,8 @@ describe('createMemoryCommandModule', () => {
       'list',
       'show',
       'add',
+      'correct',
+      'forget',
       'pending',
       'approve',
       'reject',
@@ -203,7 +208,14 @@ describe('createMemoryCommandModule', () => {
     const spied = { ...command!, execute };
     const gated = new SystemCommandExecutor([spied]);
 
-    for (const args of ['approve cand-1', 'reject cand-1', 'APPROVE cand-1']) {
+    for (const args of [
+      'approve cand-1',
+      'reject cand-1',
+      'APPROVE cand-1',
+      'correct project build Use pnpm.',
+      'forget build',
+      'FORGET build',
+    ]) {
       const result = await gated.executeModelInvocable('memory', host, args);
       expect(result?.success).toBe(false);
       expect(result?.message).toContain('only the user can');
@@ -217,6 +229,67 @@ describe('createMemoryCommandModule', () => {
 });
 
 describe('executeMemoryCommand', () => {
+  it.runIf(process.platform === 'linux').each(['user', 'remote'] as const)(
+    'lets an authenticated %s command replace and forget a topic through the shared slash handler',
+    async (source) => {
+      const cwd = makeProject();
+      const session = await createInteractiveSession(cwd);
+      await session.executeCommand('memory', 'add project build Use npm for builds.');
+      const corrected = await session.executeCommand(
+        'memory',
+        'correct project build Use pnpm for builds.',
+        source,
+      );
+      expect(corrected?.success).toBe(true);
+      expect((await session.readProjectMemory()).kind).toBe('memory');
+      expect((await session.executeCommand('memory', 'show build'))?.message).toContain('Use pnpm');
+      expect((await session.executeCommand('memory', 'show build'))?.message).not.toContain(
+        'Use npm',
+      );
+      const forgotten = await session.executeCommand('memory', 'forget build', source);
+      expect(forgotten?.success).toBe(true);
+      expect((await session.executeCommand('memory', 'show'))?.message).not.toContain('Use pnpm');
+      expect(forgotten?.message).toContain('transcripts');
+    },
+  );
+
+  it.runIf(process.platform === 'linux')(
+    'keeps attached memory curation subject to the host remote command policy',
+    async () => {
+      const cwd = makeProject();
+      const session = await createInteractiveSession(cwd, 'default', { isAllowed: () => false });
+      const store = session.getMemoryStore();
+      await store.append({ type: 'project', topic: 'build', text: 'Use pnpm for builds.' });
+      for (const args of ['correct project build Use npm.', 'forget build']) {
+        const result = await session.executeCommand('memory', args, 'remote');
+        expect(result?.success).toBe(false);
+        expect(result?.message).toContain('configured remote-command policy');
+        expect(await store.readTopic('build')).toContain('Use pnpm');
+      }
+    },
+  );
+
+  it.runIf(process.platform === 'linux')(
+    'refuses direct model calls to destructive memory operations',
+    async () => {
+      const cwd = makeProject();
+      const session = await createInteractiveSession(cwd);
+      await session.executeCommand('memory', 'add project build Use pnpm for builds.');
+      const corrected = await executeMemoryCommand(
+        {
+          ...createTestCommandHost(),
+          getCwd: () => cwd,
+          getMemoryStore: () => session.getMemoryStore(),
+          getCommandInvocationSource: () => 'model',
+        },
+        'correct project build Use npm for builds.',
+      );
+      expect(corrected.success).toBe(false);
+      expect(corrected.message).toContain('only the user');
+      expect(await session.getMemoryStore().readTopic('build')).toContain('Use pnpm');
+    },
+  );
+
   it('lists configured memory paths', async () => {
     const cwd = makeProject();
     const session = await createInteractiveSession(cwd);
@@ -224,7 +297,7 @@ describe('executeMemoryCommand', () => {
     const result = await session.executeCommand('memory', 'list');
 
     expect(result?.success).toBe(true);
-    expect(result?.message).toContain(join('.robota', 'memory', 'MEMORY.md'));
+    expect(result?.message).toContain(join('.fixture-state', 'memory', 'MEMORY.md'));
   });
 
   // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
@@ -240,7 +313,7 @@ describe('executeMemoryCommand', () => {
       );
 
       expect(result?.success).toBe(true);
-      expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+      expect(readFileSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'), 'utf8')).toContain(
         '(project/build) Use pnpm for scripts.',
       );
     },
@@ -257,7 +330,7 @@ describe('executeMemoryCommand', () => {
     );
 
     expect(result?.success).toBe(true);
-    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+    expect(readFileSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'), 'utf8')).toContain(
       '(project/build) Use pnpm for package scripts.',
     );
   });
@@ -273,7 +346,7 @@ describe('executeMemoryCommand', () => {
 
     expect(result?.success).toBe(false);
     expect(result?.message).toContain('sensitive');
-    expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
+    expect(existsSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'))).toBe(false);
   });
 
   // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
@@ -303,7 +376,7 @@ describe('executeMemoryCommand', () => {
 
       expect(result?.success).toBe(true);
       expect(result?.message).toContain('Saved memory candidate mem_123');
-      expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+      expect(readFileSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'), 'utf8')).toContain(
         '(project/build) Use pnpm for package scripts.',
       );
       expect((await (await createMemoryStore(cwd)).getPending('mem_123'))?.status).toBe('saved');
@@ -342,7 +415,7 @@ describe('executeMemoryCommand', () => {
     vi.spyOn(session, 'getUsedMemoryReferences').mockReturnValue([
       {
         topic: 'build',
-        path: join(cwd, '.robota', 'memory', 'topics', 'build.md'),
+        path: join(cwd, '.fixture-state', 'memory', 'topics', 'build.md'),
         score: 5,
         truncated: false,
       },
@@ -352,7 +425,7 @@ describe('executeMemoryCommand', () => {
 
     expect(result?.success).toBe(true);
     expect(result?.message).toContain('build');
-    expect(result?.message).toContain(join(cwd, '.robota', 'memory', 'topics', 'build.md'));
+    expect(result?.message).toContain(join(cwd, '.fixture-state', 'memory', 'topics', 'build.md'));
   });
 
   it('returns usage for invalid arguments without mutating state', async () => {
@@ -365,7 +438,7 @@ describe('executeMemoryCommand', () => {
     expect(result.success).toBe(false);
     expect(result.message).toContain('Usage: memory');
     expect(unknownResult.success).toBe(false);
-    expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
+    expect(existsSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'))).toBe(false);
   });
 
   describe('in plan mode', () => {
@@ -377,7 +450,7 @@ describe('executeMemoryCommand', () => {
 
       expect(result?.success).toBe(false);
       expect(result?.message).toContain('Plan mode saves no memory');
-      expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
+      expect(existsSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'))).toBe(false);
     });
 
     // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
@@ -390,7 +463,7 @@ describe('executeMemoryCommand', () => {
         const result = await session.executeCommand('memory', 'add project build Use pnpm.');
 
         expect(result?.success).toBe(true);
-        expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(true);
+        expect(existsSync(join(cwd, '.fixture-state', 'memory', 'MEMORY.md'))).toBe(true);
       },
     );
 

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

@@ -24,7 +24,10 @@ const MEMORY_COMMAND_MODEL_DESCRIPTION =
   '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>`.';
+  '`/memory reject <id>`. Correcting or forgetting saved knowledge is also user-only: ' +
+  'suggest `/memory correct <type> <topic> <text>` to replace every entry in a topic or ' +
+  '`/memory forget <topic>` to remove it from active recall. These operations block automatic ' +
+  'restoration of that topic; historical transcripts and backups remain.';
 
 export function createMemoryCommandEntry(): ICommand {
   return {

package/src/memory/memory-command.ts

@@ -226,12 +226,59 @@ export async function executeMemoryCommand(
 ): Promise<ICommandResult> {
   const args = rawArgs.trim().split(/\s+/).filter(Boolean);
   const subcommand = args[SUBCOMMAND_INDEX] ?? 'list';
+  const source = context.getCommandInvocationSource();
+  if (
+    (subcommand === 'correct' || subcommand === 'forget') &&
+    source !== 'user' && source !== 'remote'
+  ) {
+    return {
+      success: false,
+      message:
+        'Memory correction and forgetting: only the user can run /memory correct or /memory forget.',
+    };
+  }
   // SELFHOST-008 P1R: the single injected durable-memory port (or fs default) — authoritative for all
   // `/memory` operations, so a surface that swaps the store is honored here too (no split-brain).
   const resolved = getMemoryStoreOrError(context);
   if (!resolved.ok) return resolved.result;
   const store = resolved.store;
 
+  if (subcommand === 'correct' || subcommand === 'forget') {
+    try {
+      if (subcommand === 'correct') {
+        const input = parseAdd(args);
+        if (!input) return usage();
+        if (hasSensitiveCommandMemoryContent(input.text))
+          return { success: false, message: 'Refusing to save sensitive memory content.' };
+        if (!store.replaceTopic)
+          return {
+            success: false,
+            message: 'This memory backend does not support topic correction.',
+          };
+        const result = await store.replaceTopic(input);
+        return {
+          success: true,
+          message: `Replaced all active memory in ${result.topicPath}. Automatic additions to this topic now require user correction. Historical transcripts and backups remain.`,
+          data: { ...result },
+        };
+      }
+      if (!args[TYPE_INDEX] || args.length !== 2) return usage();
+      if (!store.forgetTopic)
+        return {
+          success: false,
+          message: 'This memory backend does not support forgetting topics.',
+        };
+      const result = await store.forgetTopic(args[TYPE_INDEX]);
+      return {
+        success: true,
+        message: `Forgot active memory topic ${result.topic}. Source topic removed; automatic restoration is blocked. Historical transcripts and backups remain.`,
+        data: { ...result },
+      };
+    } catch (error) {
+      return formatError(error instanceof Error ? error : String(error));
+    }
+  }
+
   if (subcommand === 'list') return formatList(store);
   if (subcommand === 'show') return formatShow(store, args[TYPE_INDEX]);
   if (subcommand === 'pending') return formatPending(store);
@@ -255,7 +302,12 @@ export async function executeMemoryCommand(
         success: false,
       };
     }
-    const result = await store.append(input);
+    let result;
+    try {
+      result = await store.append(input);
+    } catch (error) {
+      return formatError(error instanceof Error ? error : String(error));
+    }
     return {
       message: result.deduplicated
         ? `${input.type} memory already exists in ${result.topicPath}`

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

@@ -16,7 +16,7 @@ describe('/peers command module', () => {
   it('tells the model it covers linked devices, what it returns, and what to suggest', () => {
     const description =
       createPeersCommandModule().commandSources?.[0]?.getCommands()[0]?.description;
-    expect(description).toMatch(/linked over the device mesh/);
+    expect(description).toMatch(/linked devices/);
     expect(description).toMatch(/returns/i);
     expect(description).toMatch(/user-only/i);
     expect(description).toContain('`/peers`');

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

@@ -8,7 +8,7 @@ export function createPeersCommandEntry(): ICommand {
     name: 'peers',
     displayName: 'Peers',
     description:
-      "List the other live Robota sessions on this host and the user's other devices linked over the device mesh, send one a message, or send one a copy of a file. Returns the sessions and devices with the ids to address them by (linked devices even when local discovery is off and sessions on this host cannot be listed), or how a send ended. User-only: the model cannot run it; it answers a peer's message with its reply tool, and when the user wants to reach another session or device, suggest they run `/peers`.",
+      "List the other live sessions for this user on this host and the user's linked devices, send one a message, or send one a copy of a file. Returns the sessions and devices with the ids to address them by (linked devices even when local discovery is off and sessions on this host cannot be listed), or how a send ended. User-only: the model cannot run it; it answers a peer's message with its reply tool, and when the user wants to reach another session or device, suggest they run `/peers`.",
     source: 'peers',
     // The model does not enumerate the operator's other sessions. Discovery is an operator-facing
     // view of who is at the machine, which is a fact about the person and not about the task.

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

@@ -160,14 +160,14 @@ describe('createPermissionsCommandModule', () => {
         rules: { allow: ['Read', 'mcp__docs__*'], deny: ['Bash(rm *)'], ask: ['Bash(git push*)'] },
         layers: [
           {
-            source: '~/.robota/settings.json',
+            source: '~/.fixture-state/settings.json',
             scope: 'user',
             allow: ['Read'],
             deny: ['Bash(rm *)'],
             ask: [],
           },
           {
-            source: '.robota/settings.json',
+            source: '.fixture-state/settings.json',
             scope: 'project',
             allow: ['Read', 'Stale'],
             deny: [],
@@ -181,10 +181,10 @@ describe('createPermissionsCommandModule', () => {
     expect(result?.message).toContain(
       [
         'Rules (checked deny, then ask, then allow):',
-        '  ~/.robota/settings.json [user]',
+        '  ~/.fixture-state/settings.json [user]',
         '    deny: Bash(rm *)',
         '    allow: Read',
-        '  .robota/settings.json [project]',
+        '  .fixture-state/settings.json [project]',
         '    ask: Bash(git push*)',
         '    allow: Read',
         '  this session (CLI flags, preset, commands)',

package/src/plugin/__tests__/plugin-active-turn.test.ts

@@ -0,0 +1,100 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { InteractiveSession } from '@robota-sdk/agent-framework';
+import type { IAIProvider, TUniversalMessage } from '@robota-sdk/agent-core';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-command';
+import { createPluginCommandModule } from '../plugin-command-module.js';
+
+async function heldTurn(denyRemote = false, commandModules = [createPluginCommandModule()]) {
+  const root = mkdtempSync(join(tmpdir(), 'plugin-active-turn-'));
+  let release!: (value: TUniversalMessage) => void;
+  const pending = new Promise<TUniversalMessage>((resolve) => { release = resolve; });
+  const run = vi.fn(() => pending);
+  const adapter: ICommandPluginAdapter = {
+    listInstalled: async () => [], listAvailablePlugins: async () => [],
+    install: vi.fn(async () => {}), uninstall: vi.fn(async () => {}),
+    enable: vi.fn(async () => {}), disable: vi.fn(async () => {}),
+    marketplaceAdd: async () => 'fixture', marketplaceRemove: async () => {},
+    marketplaceUpdate: async () => {}, marketplaceList: async () => [],
+    reloadPlugins: async () => ({ loadedPluginCount: 0 }),
+  };
+  const session = new InteractiveSession({
+    cwd: root, bare: true, environment: { HOME: root },
+    provider: { name: 'held-provider', version: '1', chat: run } as unknown as IAIProvider,
+    config: {
+      provider: { name: 'held-provider', model: 'fixture-model', apiKey: undefined },
+      defaultTrustLevel: 'safe', permissions: { allow: [], deny: [] }, env: {},
+    },
+    commandModules,
+    commandHostAdapters: { plugin: adapter },
+    ...(denyRemote ? { remoteCommandPolicy: { isAllowed: () => false } } : {}),
+  });
+  const submission = session.submit('Hold this fixture turn until its owner releases it.');
+  await vi.waitFor(() => expect(run).toHaveBeenCalledOnce());
+  return {
+    session, adapter,
+    close: async () => {
+      release({ id: 'held-response', role: 'assistant', state: 'complete', content: 'Finished', timestamp: new Date() });
+      try { await (await submission).completed; } finally {
+        await session.shutdown();
+        rmSync(root, { recursive: true, force: true });
+      }
+    },
+  };
+}
+
+describe.each(['user', 'remote'] as const)('plugin withdrawal during a %s command', (source) => {
+  it.each(['disable', 'uninstall'] as const)('allows %s while an admitted turn remains active', async (operation) => {
+    const owned = await heldTurn();
+    try {
+      const result = await owned.session.executeCommand('plugin', `${operation} fixture@market`, source);
+      expect(result?.success).toBe(true);
+      expect(owned.adapter[operation]).toHaveBeenCalledExactlyOnceWith('fixture@market');
+      expect(owned.session.isExecuting()).toBe(true);
+    } finally { await owned.close(); }
+  });
+
+  it.each(['enable', 'install'] as const)('keeps %s behind the active-turn gate', async (operation) => {
+    const owned = await heldTurn();
+    try {
+      const result = await owned.session.executeCommand('plugin', `${operation} fixture@market`, source);
+      expect(result?.success).toBe(false);
+      expect(result?.message).toContain('already running');
+      expect(owned.adapter[operation]).not.toHaveBeenCalled();
+    } finally { await owned.close(); }
+  });
+});
+
+it('preserves remote policy and model refusal for active-turn withdrawal', async () => {
+  const owned = await heldTurn(true);
+  try {
+    const result = await owned.session.executeCommand('plugin', 'disable fixture@market', 'remote');
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain('configured remote-command policy');
+    for (const operation of ['disable', 'uninstall'] as const) {
+      expect(await owned.session.executeModelCommand('plugin', `${operation} fixture@market`)).toBeNull();
+      expect(owned.adapter[operation]).not.toHaveBeenCalled();
+    }
+  } finally { await owned.close(); }
+});
+
+it.each(['inline', 'blocking'] as const)('honors generic host control metadata only for %s lifecycle', async (lifecycle) => {
+  const execute = vi.fn(() => ({ success: true, message: 'Control applied' }));
+  const owned = await heldTurn(false, [{
+    name: 'fixture-control', systemCommands: [{
+      name: 'withdraw-fixture', description: 'Owner fixture control', lifecycle,
+      canRunDuringTurn: (args) => args === 'stop', modelInvocable: false, execute,
+    }],
+  }]);
+  try {
+    const refused = await owned.session.executeCommand('withdraw-fixture', 'start');
+    expect(refused?.success).toBe(false);
+    expect(execute).not.toHaveBeenCalled();
+    const result = await owned.session.executeCommand('withdraw-fixture', 'stop');
+    expect(result?.success).toBe(lifecycle === 'inline');
+    expect(execute).toHaveBeenCalledTimes(lifecycle === 'inline' ? 1 : 0);
+    expect(owned.session.isExecuting()).toBe(true);
+  } finally { await owned.close(); }
+});

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

@@ -101,7 +101,7 @@ describe('createPluginCommandModule', () => {
     expect(module.commandSources?.[0]?.getCommands()).toEqual([
       expect.objectContaining({
         name: 'plugin',
-        description: 'Manage plugins',
+        description: expect.stringContaining('returns operation status'),
         source: 'plugin-manager',
         modelInvocable: false,
         argumentHint: expect.stringContaining('install'),
@@ -193,8 +193,8 @@ describe('executePluginCommand', () => {
   it('lists installed plugins through the adapter, for the Settings screen (#3282 §4 part b-2)', async () => {
     const adapter = createPluginAdapter({
       listInstalled: vi.fn().mockResolvedValue([
-        { name: 'formatter@robota', description: 'Formats code.', enabled: true },
-        { name: 'linter@robota', description: 'Lints code.', enabled: false },
+        { name: 'formatter@fixture-agent', description: 'Formats code.', enabled: true },
+        { name: 'linter@fixture-agent', description: 'Lints code.', enabled: false },
       ]),
     });
 
@@ -203,12 +203,12 @@ describe('executePluginCommand', () => {
     expect(result.success).toBe(true);
     expect(result.data).toEqual({
       plugins: [
-        { name: 'formatter@robota', description: 'Formats code.', enabled: true },
-        { name: 'linter@robota', description: 'Lints code.', enabled: false },
+        { name: 'formatter@fixture-agent', description: 'Formats code.', enabled: true },
+        { name: 'linter@fixture-agent', description: 'Lints code.', enabled: false },
       ],
     });
-    expect(result.message).toContain('formatter@robota');
-    expect(result.message).toContain('linter@robota (disabled)');
+    expect(result.message).toContain('formatter@fixture-agent');
+    expect(result.message).toContain('linter@fixture-agent (disabled)');
   });
 
   it('no plugins installed reports a plain empty list', async () => {

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

@@ -45,6 +45,10 @@ function createPluginSystemCommand(): ISystemCommand {
     modelInvocable: false,
     argumentHint: entry.argumentHint,
     lifecycle: 'inline',
+    canRunDuringTurn: (args) => {
+      const parts = args.trim().split(/\s+/);
+      return parts.length === 2 && ['disable', 'uninstall'].includes(parts[0]!);
+    },
     subcommands: entry.subcommands,
     execute: executePluginCommand,
   };

package/src/provider/provider-startup.ts

@@ -29,6 +29,8 @@ export interface IProviderStartupContext {
   settingsScope?: TSettingsScope;
   settingsSources: readonly TSettingsSource[];
   settingsStores: readonly ISettingsDocumentStore[];
+  /** Selected host snapshot for configure-time credential reference checks. */
+  env?: Record<string, string | undefined>;
 }
 
 export interface IEnsureProviderConfigOptions {
@@ -65,7 +67,7 @@ export async function runProviderStartupSetup(
   const input = await runProviderSetupPromptFlow(type, promptInput, providerDefinitions, {
     existingProfileNames,
   });
-  applyProviderConfiguration(settingsStore, input, { providerDefinitions });
+  applyProviderConfiguration(settingsStore, input, { providerDefinitions, env: ctx.env });
   const language = await promptInput('  Response language (ko/en/ja/zh, default: en): ');
   if (language) {
     const settings = settingsStore.read();
@@ -104,7 +106,7 @@ export async function ensureProviderConfig(
   }
   await runProviderStartupSetup(
     cwd,
-    selectStartupContext(ctx, access.stores),
+    selectStartupContext({ ...ctx, env: ctx.env ?? options.env }, access.stores),
     promptInput,
     terminal,
     providerDefinitions,

package/src/remote-control/__tests__/remote-control-command.test.ts

@@ -138,12 +138,12 @@ describe('executeRemoteControlCommand (REMOTE-008)', () => {
     const result = executeRemoteControlCommand(
       e3ctx({
         describeKeyStorage: () =>
-          'owner-only file in /h/.robota/credentials (OS keychain unavailable: absent)',
+          'owner-only file in /h/.fixture-state/credentials (OS keychain unavailable: absent)',
       }),
       'status',
     );
     expect(result.message).toContain(
-      'Host key storage: owner-only file in /h/.robota/credentials (OS keychain unavailable: absent)',
+      'Host key storage: owner-only file in /h/.fixture-state/credentials (OS keychain unavailable: absent)',
     );
   });
 

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

@@ -70,10 +70,11 @@ function createMockRuntimeSession() {
   };
 }
 
-function createInteractiveSession(): InteractiveSession {
+function createInteractiveSession(commandProductVocabulary?: { cliName: string; displayName: string }): InteractiveSession {
   return new InteractiveSession({
     session: createMockRuntimeSession() as never,
     commandModules: [createRewindCommandModule()],
+    commandProductVocabulary,
   });
 }
 
@@ -260,13 +261,13 @@ describe('executeRewindCommand', () => {
 
     it('tells a restricted workspace to trust it, for every subcommand', async () => {
       vi.spyOn(process, 'platform', 'get').mockReturnValue('linux');
-      const session = createInteractiveSession();
+      const session = createInteractiveSession({ cliName: 'test-agent', displayName: 'Test Agent' });
 
       for (const args of ['', 'list', 'inspect turn-0001', 'restore turn-0001', 'branches']) {
         const result = await session.executeCommand('rewind', args);
         expect(result?.success).toBe(false);
         expect(result?.message).toBe(
-          'Edit checkpoints need a trusted workspace: run robota trust --yes, then restart robota.',
+          'Edit checkpoints need a trusted workspace: run test-agent trust --yes, then restart test-agent.',
         );
       }
     });