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

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

@@ -1,15 +1,73 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import {
   InteractiveSession,
   SystemCommandExecutor,
-  createCommandPendingMemoryStore,
+  WorkspaceTrustService,
+  createWorkspaceMemoryStore,
+  getWorkspaceProjectStateStorage,
 } from '@robota-sdk/agent-framework';
 import { MemoryCommandSource, createMemoryCommandModule, executeMemoryCommand } from '../index.js';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
 
-const TMP_BASE = join(tmpdir(), `robota-command-memory-${process.pid}`);
+import type {
+  IMemoryStore,
+  IWorkspaceIdentity,
+  IWorkspaceTrustStore,
+  IWorkspaceTrustStoreSnapshot,
+} from '@robota-sdk/agent-framework';
+
+// 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 memoryStores = new Map<string, Promise<IMemoryStore>>();
+
+class TrustedStore implements IWorkspaceTrustStore {
+  inspect(): Promise<IWorkspaceTrustStoreSnapshot> {
+    return Promise.resolve({ state: 'trusted', generation: 1 });
+  }
+
+  grant(): Promise<IWorkspaceTrustStoreSnapshot> {
+    return this.inspect();
+  }
+
+  revoke(): Promise<IWorkspaceTrustStoreSnapshot> {
+    return Promise.resolve({ state: 'revoked', generation: 2 });
+  }
+}
+
+function createMemoryStore(cwd: string): Promise<IMemoryStore> {
+  const existing = memoryStores.get(cwd);
+  if (existing !== undefined) return existing;
+  const created = (async () => {
+    const root = realpathSync(cwd);
+    const identity: IWorkspaceIdentity = {
+      repositoryKey: `memory-test:${root}`,
+      displayPath: root,
+      worktreeRoot: root,
+    };
+    const service = new WorkspaceTrustService({
+      identityResolver: { resolve: () => identity },
+      store: new TrustedStore(),
+      projectStateDirectories: {
+        sessions: join('.robota', 'sessions'),
+        'session-logs': join('.robota', 'logs'),
+        memory: join('.robota', 'memory'),
+        checkpoints: join('.robota', 'checkpoints'),
+      },
+    });
+    const access = await service.inspect(root);
+    if (access.status !== 'trusted') throw new Error('Expected trusted project access.');
+    return createWorkspaceMemoryStore(
+      getWorkspaceProjectStateStorage(access.authority, 'memory'),
+      () => new Date('2026-05-02T00:00:00.000Z'),
+    );
+  })();
+  memoryStores.set(cwd, created);
+  return created;
+}
 
 function makeProject(): string {
   const dir = join(TMP_BASE, Math.random().toString(36).slice(2));
@@ -43,20 +101,18 @@ function createMockRuntimeSession() {
   };
 }
 
-function createInteractiveSession(cwd = makeProject()): InteractiveSession {
+async function createInteractiveSession(cwd = makeProject()): Promise<InteractiveSession> {
   return new InteractiveSession({
     cwd,
     session: createMockRuntimeSession() as never,
+    memoryStore: await createMemoryStore(cwd),
     commandModules: [createMemoryCommandModule()],
   });
 }
 
-function seedPendingMemory(cwd: string): void {
-  const pendingStore = createCommandPendingMemoryStore(
-    cwd,
-    () => new Date('2026-05-02T00:00:00.000Z'),
-  );
-  pendingStore.upsert(
+async function seedPendingMemory(cwd: string): Promise<void> {
+  const store = await createMemoryStore(cwd);
+  await store.upsertPending(
     {
       id: 'mem_123',
       type: 'project',
@@ -73,6 +129,7 @@ function seedPendingMemory(cwd: string): void {
 }
 
 afterEach(() => {
+  memoryStores.clear();
   if (existsSync(TMP_BASE)) rmSync(TMP_BASE, { recursive: true, force: true });
 });
 
@@ -121,46 +178,73 @@ describe('createMemoryCommandModule', () => {
         kind: 'builtin-command',
         userInvocable: true,
         modelInvocable: true,
+        // The model is offered only what it may run: `approve`/`reject` are the user's review.
         argumentHint:
-          'list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | approve <id> | reject <id> | used',
+          '[list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | used]',
         safety: 'write',
       }),
     );
-    expect(descriptor?.description).toContain(
-      'inspect project memory when stored context may help',
-    );
+    expect(descriptor?.description).toContain('look up stored conventions');
+    expect(descriptor?.description).toContain('suggest `/memory approve <id>`');
+  });
+
+  it('refuses a model-issued `memory approve` before the command runs, and allows the user', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createMemoryCommandModule().systemCommands ?? []),
+    ]);
+    const command = executor.getCommand('memory');
+    const execute = vi.fn();
+    const host = createTestCommandHost();
+    const spied = { ...command!, execute };
+    const gated = new SystemCommandExecutor([spied]);
+
+    for (const args of ['approve cand-1', 'reject cand-1', 'APPROVE cand-1']) {
+      const result = await gated.executeModelInvocable('memory', host, args);
+      expect(result?.success).toBe(false);
+      expect(result?.message).toContain('only the user can');
+    }
+    expect(execute).not.toHaveBeenCalled();
+
+    await gated.executeModelInvocable('memory', host, 'list');
+    await gated.execute('memory', host, 'approve cand-1');
+    expect(execute).toHaveBeenCalledTimes(2);
   });
 });
 
 describe('executeMemoryCommand', () => {
   it('lists configured memory paths', async () => {
     const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
+    const session = await createInteractiveSession(cwd);
 
     const result = await session.executeCommand('memory', 'list');
 
     expect(result?.success).toBe(true);
-    expect(result?.message).toContain(join(cwd, '.robota', 'memory', 'MEMORY.md'));
+    expect(result?.message).toContain(join('.robota', 'memory', 'MEMORY.md'));
   });
 
-  it('persists index and topic entries through slash invocation', async () => {
-    const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
-
-    const result = await session.executeCommand(
-      'memory',
-      'add project build Use pnpm for scripts.',
-    );
-
-    expect(result?.success).toBe(true);
-    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
-      '(project/build) Use pnpm for scripts.',
-    );
-  });
+  // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
+  it.runIf(process.platform === 'linux')(
+    'persists index and topic entries through slash invocation',
+    async () => {
+      const cwd = makeProject();
+      const session = await createInteractiveSession(cwd);
+
+      const result = await session.executeCommand(
+        'memory',
+        'add project build Use pnpm for scripts.',
+      );
+
+      expect(result?.success).toBe(true);
+      expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+        '(project/build) Use pnpm for scripts.',
+      );
+    },
+  );
 
-  it('uses the same handler for model invocation', async () => {
+  // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
+  it.runIf(process.platform === 'linux')('uses the same handler for model invocation', async () => {
     const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
+    const session = await createInteractiveSession(cwd);
 
     const result = await session.executeModelCommand(
       'memory',
@@ -175,7 +259,7 @@ describe('executeMemoryCommand', () => {
 
   it('rejects sensitive content before writing files', async () => {
     const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
+    const session = await createInteractiveSession(cwd);
 
     const result = await session.executeCommand(
       'memory',
@@ -187,10 +271,11 @@ describe('executeMemoryCommand', () => {
     expect(existsSync(join(cwd, '.robota', 'memory', 'MEMORY.md'))).toBe(false);
   });
 
-  it('lists queued automatic memory candidates', async () => {
+  // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
+  it.runIf(process.platform === 'linux')('lists queued automatic memory candidates', async () => {
     const cwd = makeProject();
-    seedPendingMemory(cwd);
-    const session = createInteractiveSession(cwd);
+    await seedPendingMemory(cwd);
+    const session = await createInteractiveSession(cwd);
 
     const result = await session.executeCommand('memory', 'pending');
 
@@ -200,47 +285,55 @@ describe('executeMemoryCommand', () => {
     expect(result?.message).toContain('Use pnpm for package scripts.');
   });
 
-  it('approves and saves a pending candidate while recording audit events', async () => {
-    const cwd = makeProject();
-    seedPendingMemory(cwd);
-    const session = createInteractiveSession(cwd);
-    const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
-
-    const result = await session.executeCommand('memory', 'approve mem_123');
-
-    expect(result?.success).toBe(true);
-    expect(result?.message).toContain('Saved memory candidate mem_123');
-    expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
-      '(project/build) Use pnpm for package scripts.',
-    );
-    expect(createCommandPendingMemoryStore(cwd).get('mem_123')?.status).toBe('saved');
-    expect(recordMemoryEvent).toHaveBeenCalledWith(
-      expect.objectContaining({ type: 'memory_candidate_approved', candidateId: 'mem_123' }),
-    );
-    expect(recordMemoryEvent).toHaveBeenCalledWith(
-      expect.objectContaining({ type: 'memory_candidate_saved', candidateId: 'mem_123' }),
-    );
-  });
-
-  it('rejects a pending candidate while recording an audit event', async () => {
-    const cwd = makeProject();
-    seedPendingMemory(cwd);
-    const session = createInteractiveSession(cwd);
-    const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
-
-    const result = await session.executeCommand('memory', 'reject mem_123');
+  // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
+  it.runIf(process.platform === 'linux')(
+    'approves and saves a pending candidate while recording audit events',
+    async () => {
+      const cwd = makeProject();
+      await seedPendingMemory(cwd);
+      const session = await createInteractiveSession(cwd);
+      const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
+
+      const result = await session.executeCommand('memory', 'approve mem_123');
+
+      expect(result?.success).toBe(true);
+      expect(result?.message).toContain('Saved memory candidate mem_123');
+      expect(readFileSync(join(cwd, '.robota', 'memory', 'MEMORY.md'), 'utf8')).toContain(
+        '(project/build) Use pnpm for package scripts.',
+      );
+      expect((await (await createMemoryStore(cwd)).getPending('mem_123'))?.status).toBe('saved');
+      expect(recordMemoryEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'memory_candidate_approved', candidateId: 'mem_123' }),
+      );
+      expect(recordMemoryEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'memory_candidate_saved', candidateId: 'mem_123' }),
+      );
+    },
+  );
 
-    expect(result?.success).toBe(true);
-    expect(result?.message).toContain('Rejected memory candidate mem_123');
-    expect(createCommandPendingMemoryStore(cwd).get('mem_123')?.status).toBe('rejected');
-    expect(recordMemoryEvent).toHaveBeenCalledWith(
-      expect.objectContaining({ type: 'memory_candidate_rejected', candidateId: 'mem_123' }),
-    );
-  });
+  // ARCH-047: project mutation is Linux-only (stable root-anchored host); refused elsewhere.
+  it.runIf(process.platform === 'linux')(
+    'rejects a pending candidate while recording an audit event',
+    async () => {
+      const cwd = makeProject();
+      await seedPendingMemory(cwd);
+      const session = await createInteractiveSession(cwd);
+      const recordMemoryEvent = vi.spyOn(session, 'recordMemoryEvent');
+
+      const result = await session.executeCommand('memory', 'reject mem_123');
+
+      expect(result?.success).toBe(true);
+      expect(result?.message).toContain('Rejected memory candidate mem_123');
+      expect((await (await createMemoryStore(cwd)).getPending('mem_123'))?.status).toBe('rejected');
+      expect(recordMemoryEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'memory_candidate_rejected', candidateId: 'mem_123' }),
+      );
+    },
+  );
 
   it('reports references from the current turn', async () => {
     const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
+    const session = await createInteractiveSession(cwd);
     vi.spyOn(session, 'getUsedMemoryReferences').mockReturnValue([
       {
         topic: 'build',
@@ -259,7 +352,7 @@ describe('executeMemoryCommand', () => {
 
   it('returns usage for invalid arguments without mutating state', async () => {
     const cwd = makeProject();
-    const session = createInteractiveSession(cwd);
+    const session = await createInteractiveSession(cwd);
 
     const result = await executeMemoryCommand(session, 'add project missing-text');
     const unknownResult = await executeMemoryCommand(session, 'unknown');

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

@@ -7,13 +7,29 @@ import {
 import { executeMemoryCommand } from './memory-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+/**
+ * Model-invocable: remembering and recalling project conventions is the model's own work. The
+ * subcommand flags (in `buildMemoryCommandSubcommands`) keep `approve`/`reject` user-only, because
+ * pending candidates exist so the user reviews what the model proposed to remember.
+ */
+const MEMORY_COMMAND_MODEL_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>`.';
 
 export function createMemoryCommandEntry(): ICommand {
   return {
     name: 'memory',
     displayName: 'Memory',
     description: MEMORY_COMMAND_DESCRIPTION,
+    modelDescription: MEMORY_COMMAND_MODEL_DESCRIPTION,
     source: 'memory',
     argumentHint: MEMORY_COMMAND_ARGUMENT_HINT,
     modelInvocable: true,
@@ -28,6 +44,7 @@ function createMemorySystemCommand(): ISystemCommand {
     name: entry.name,
     displayName: entry.displayName,
     description: entry.description,
+    ...(entry.modelDescription !== undefined ? { modelDescription: entry.modelDescription } : {}),
     requiresPermission: false,
     userInvocable: true,
     modelInvocable: true,

package/src/memory/memory-command.ts

@@ -1,5 +1,6 @@
 import {
   MEMORY_COMMAND_USAGE,
+  approvePendingMemoryCandidate,
   createCommandMemoryStores,
   hasSensitiveCommandMemoryContent,
   isCommandMemoryType,
@@ -9,11 +10,12 @@ import {
 
 import type {
   IAppendMemoryInput,
-  ICommandHostContext,
-  ICommandPendingMemoryStore,
-  ICommandProjectMemoryStore,
+  ICommandHostMemory,
+  ICommandHostWorkspace,
+  IMemoryStore,
 } from '@robota-sdk/agent-framework';
-import type { ICommandResult, IMemoryEvent } from '@robota-sdk/agent-interface-transport';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { IMemoryEvent } from '@robota-sdk/agent-interface-session';
 
 const SUBCOMMAND_INDEX = 0;
 const TYPE_INDEX = 1;
@@ -34,8 +36,8 @@ function formatError(error: Error | string): ICommandResult {
   };
 }
 
-function formatList(store: ICommandProjectMemoryStore): ICommandResult {
-  const summary = store.list();
+async function formatList(store: IMemoryStore): Promise<ICommandResult> {
+  const summary = await store.list();
   const topics =
     summary.topics.length > 0
       ? summary.topics.map((topic) => `- ${topic.name}: ${topic.path}`).join('\n')
@@ -57,9 +59,9 @@ function formatList(store: ICommandProjectMemoryStore): ICommandResult {
   };
 }
 
-function formatShow(store: ICommandProjectMemoryStore, topic?: string): ICommandResult {
+async function formatShow(store: IMemoryStore, topic?: string): Promise<ICommandResult> {
   if (!topic || topic === 'index') {
-    const memory = store.loadStartupMemory();
+    const memory = await store.loadStartupMemory();
     return {
       message: memory.content || '(empty memory index)',
       success: true,
@@ -71,7 +73,7 @@ function formatShow(store: ICommandProjectMemoryStore, topic?: string): ICommand
     };
   }
 
-  const content = store.readTopic(topic);
+  const content = await store.readTopic(topic);
   return {
     message: content || `(empty memory topic: ${topic})`,
     success: true,
@@ -88,8 +90,8 @@ function parseAdd(args: readonly string[]): IAppendMemoryInput | undefined {
   return { type, topic, text };
 }
 
-function formatPending(store: ICommandPendingMemoryStore): ICommandResult {
-  const records = store.list('pending');
+async function formatPending(store: IMemoryStore): Promise<ICommandResult> {
+  const records = await store.listPending('pending');
   const lines =
     records.length > 0
       ? records.map(
@@ -105,21 +107,18 @@ function formatPending(store: ICommandPendingMemoryStore): ICommandResult {
   };
 }
 
-function recordEvent(context: ICommandHostContext, event: Omit<IMemoryEvent, 'at'>): void {
+function recordEvent(context: ICommandHostMemory, event: Omit<IMemoryEvent, 'at'>): void {
   recordCommandMemoryEvent(context, event);
 }
 
-function approvePending(
-  context: ICommandHostContext,
-  pendingStore: ICommandPendingMemoryStore,
-  memoryStore: ICommandProjectMemoryStore,
+async function approvePending(
+  context: ICommandHostMemory,
+  store: IMemoryStore,
   id: string | undefined,
-): ICommandResult {
+): Promise<ICommandResult> {
   if (!id) return usage();
   try {
-    const approved = pendingStore.mark(id, 'approved', 'approved-by-user');
-    const saved = memoryStore.append(approved);
-    const record = pendingStore.mark(id, 'saved', 'approved-and-saved');
+    const { record, saved } = await approvePendingMemoryCandidate(store, id);
     recordEvent(context, {
       type: 'memory_candidate_approved',
       candidateId: record.id,
@@ -150,14 +149,14 @@ function approvePending(
   }
 }
 
-function rejectPending(
-  context: ICommandHostContext,
-  pendingStore: ICommandPendingMemoryStore,
+async function rejectPending(
+  context: ICommandHostMemory,
+  store: IMemoryStore,
   id: string | undefined,
-): ICommandResult {
+): Promise<ICommandResult> {
   if (!id) return usage();
   try {
-    const record = pendingStore.mark(id, 'rejected', 'rejected-by-user');
+    const record = await store.markPending(id, 'rejected', 'rejected-by-user');
     recordEvent(context, {
       type: 'memory_candidate_rejected',
       candidateId: record.id,
@@ -174,7 +173,7 @@ function rejectPending(
   }
 }
 
-function formatUsed(context: ICommandHostContext): ICommandResult {
+function formatUsed(context: ICommandHostMemory): ICommandResult {
   const references = listCommandUsedMemoryReferences(context);
   const lines =
     references.length > 0
@@ -191,20 +190,21 @@ function formatUsed(context: ICommandHostContext): ICommandResult {
   };
 }
 
-export function executeMemoryCommand(
-  context: ICommandHostContext,
+export async function executeMemoryCommand(
+  context: ICommandHostMemory & ICommandHostWorkspace,
   rawArgs: string,
-): ICommandResult {
+): Promise<ICommandResult> {
   const args = rawArgs.trim().split(/\s+/).filter(Boolean);
   const subcommand = args[SUBCOMMAND_INDEX] ?? 'list';
-  const stores = createCommandMemoryStores(context);
-
-  if (subcommand === 'list') return formatList(stores.project);
-  if (subcommand === 'show') return formatShow(stores.project, args[TYPE_INDEX]);
-  if (subcommand === 'pending') return formatPending(stores.pending);
-  if (subcommand === 'approve')
-    return approvePending(context, stores.pending, stores.project, args[TYPE_INDEX]);
-  if (subcommand === 'reject') return rejectPending(context, stores.pending, args[TYPE_INDEX]);
+  // 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 store = createCommandMemoryStores(context);
+
+  if (subcommand === 'list') return formatList(store);
+  if (subcommand === 'show') return formatShow(store, args[TYPE_INDEX]);
+  if (subcommand === 'pending') return formatPending(store);
+  if (subcommand === 'approve') return approvePending(context, store, args[TYPE_INDEX]);
+  if (subcommand === 'reject') return rejectPending(context, store, args[TYPE_INDEX]);
   if (subcommand === 'used') return formatUsed(context);
   if (subcommand === 'add') {
     const input = parseAdd(args);
@@ -215,7 +215,7 @@ export function executeMemoryCommand(
         success: false,
       };
     }
-    const result = stores.project.append(input);
+    const result = await store.append(input);
     return {
       message: result.deduplicated
         ? `${input.type} memory already exists in ${result.topicPath}`