clawmini 0.0.7 → 0.0.9

package/src/daemon/routers/slash-model.test.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { slashModel } from './slash-model.js';
+import {
+  getAgent,
+  getAgentOverlay,
+  updateAgentOverlay,
+  writeAgentSettings,
+  getWorkspaceRoot,
+} from '../../shared/workspace.js';
+
+vi.mock('../../shared/workspace.js');
+
+const baseState = {
+  message: '',
+  messageId: 'mock-msg-id',
+  chatId: 'chat-1',
+  agentId: 'jeeves',
+};
+
+describe('slashModel router', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(getWorkspaceRoot).mockReturnValue('/mock/workspace');
+    // Mirror the real `updateAgentOverlay`: read overlay, throw if missing,
+    // run updater, write iff updater returned non-null. Keeps existing
+    // assertions on `writeAgentSettings` working after the refactor.
+    vi.mocked(updateAgentOverlay).mockImplementation(async (agentId, updater, startDir) => {
+      const overlay = await getAgentOverlay(agentId, startDir);
+      if (!overlay) throw new Error(`Agent '${agentId}' has no settings overlay.`);
+      const updated = await updater(overlay);
+      if (updated === null) return false;
+      await writeAgentSettings(agentId, updated, startDir);
+      return true;
+    });
+  });
+
+  it('passes through unrelated messages', async () => {
+    const state = { ...baseState, message: 'hello world' };
+    const result = await slashModel(state);
+    expect(result).toEqual(state);
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('lists the current model and shorthands on bare /model', async () => {
+    vi.mocked(getAgent).mockResolvedValue({
+      env: { MODEL: 'gemini-3-pro' },
+      modelShorthands: { flash: 'gemini-3-flash-preview', pro: 'gemini-3-pro' },
+    });
+
+    const result = await slashModel({ ...baseState, message: '/model' });
+
+    expect(result.action).toBe('stop');
+    expect(result.message).toBe('');
+    expect(result.reply).toContain('Current model: gemini-3-pro');
+    expect(result.reply).toContain('- flash -> gemini-3-flash-preview');
+    expect(result.reply).toContain('- pro -> gemini-3-pro');
+  });
+
+  it('reports (unset) when no MODEL is configured', async () => {
+    vi.mocked(getAgent).mockResolvedValue({});
+    const result = await slashModel({ ...baseState, message: '/model' });
+    expect(result.reply).toContain('Current model: (unset)');
+    expect(result.reply).toContain('No shorthands defined.');
+  });
+
+  it('sets env.MODEL using a shorthand', async () => {
+    vi.mocked(getAgent).mockResolvedValue({
+      modelShorthands: { flash: 'gemini-3-flash-preview' },
+    });
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      env: { OTHER: 'keep' },
+      modelShorthands: { flash: 'gemini-3-flash-preview' },
+    });
+
+    const result = await slashModel({ ...baseState, message: '/model flash' });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      {
+        env: { OTHER: 'keep', MODEL: 'gemini-3-flash-preview' },
+        modelShorthands: { flash: 'gemini-3-flash-preview' },
+      },
+      '/mock/workspace'
+    );
+    expect(result.action).toBe('stop');
+    expect(result.reply).toContain('Set MODEL to gemini-3-flash-preview');
+    expect(result.reply).toContain("shorthand 'flash'");
+  });
+
+  it('sets env.MODEL to a full string when no shorthand matches', async () => {
+    vi.mocked(getAgent).mockResolvedValue({ modelShorthands: {} });
+    vi.mocked(getAgentOverlay).mockResolvedValue({});
+
+    const result = await slashModel({
+      ...baseState,
+      message: '/model gemini-3.1-flash-lite',
+    });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      { env: { MODEL: 'gemini-3.1-flash-lite' } },
+      '/mock/workspace'
+    );
+    expect(result.reply).toBe('Set MODEL to gemini-3.1-flash-lite.');
+  });
+
+  it('adds a shorthand on /model add', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      env: { MODEL: 'gemini-3-pro' },
+      modelShorthands: { flash: 'gemini-3-flash-preview' },
+    });
+
+    const result = await slashModel({
+      ...baseState,
+      message: '/model add lite gemini-3.1-flash-lite',
+    });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      {
+        env: { MODEL: 'gemini-3-pro' },
+        modelShorthands: {
+          flash: 'gemini-3-flash-preview',
+          lite: 'gemini-3.1-flash-lite',
+        },
+      },
+      '/mock/workspace'
+    );
+    expect(result.reply).toBe('Added shorthand: lite -> gemini-3.1-flash-lite');
+    expect(result.action).toBe('stop');
+  });
+
+  it('replaces an existing shorthand on /model add', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      modelShorthands: { flash: 'old-flash' },
+    });
+
+    await slashModel({
+      ...baseState,
+      message: '/model add flash gemini-3-flash-preview',
+    });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      { modelShorthands: { flash: 'gemini-3-flash-preview' } },
+      '/mock/workspace'
+    );
+  });
+
+  it('reports a usage error on malformed /model add', async () => {
+    const result = await slashModel({ ...baseState, message: '/model add flash' });
+    expect(result.reply).toBe('Usage: /model add <shorthand> <full-name>');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('rejects reserved shorthand names', async () => {
+    for (const name of ['help', 'add', 'remove', 'rm']) {
+      const result = await slashModel({
+        ...baseState,
+        message: `/model add ${name} some-model`,
+      });
+      expect(result.reply).toBe(`Invalid shorthand: '${name}' is reserved.`);
+    }
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('shows help on /model help', async () => {
+    const result = await slashModel({ ...baseState, message: '/model help' });
+    expect(result.action).toBe('stop');
+    expect(result.reply).toContain('/model add <shorthand> <full-name>');
+    expect(result.reply).toContain('/model remove <shorthand>');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+    expect(getAgent).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown -flags with help', async () => {
+    const result = await slashModel({ ...baseState, message: '/model -h' });
+    expect(result.reply).toContain('Unknown option: -h');
+    expect(result.reply).toContain('Usage:');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown subcommands with extra args', async () => {
+    const result = await slashModel({ ...baseState, message: '/model rmove flash' });
+    expect(result.reply).toContain('Unknown subcommand: rmove');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('removes a shorthand from the overlay', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      env: { MODEL: 'gemini-3-pro' },
+      modelShorthands: { flash: 'gemini-3-flash-preview', lite: 'gemini-3.1-flash-lite' },
+    });
+    vi.mocked(getAgent).mockResolvedValue({
+      modelShorthands: { lite: 'gemini-3.1-flash-lite' },
+    });
+
+    const result = await slashModel({ ...baseState, message: '/model remove flash' });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      {
+        env: { MODEL: 'gemini-3-pro' },
+        modelShorthands: { lite: 'gemini-3.1-flash-lite' },
+      },
+      '/mock/workspace'
+    );
+    expect(result.reply).toBe('Removed shorthand: flash.');
+  });
+
+  it('drops the modelShorthands key when removing the last entry', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      env: { MODEL: 'gemini-3-pro' },
+      modelShorthands: { flash: 'gemini-3-flash-preview' },
+    });
+    vi.mocked(getAgent).mockResolvedValue({ env: { MODEL: 'gemini-3-pro' } });
+
+    await slashModel({ ...baseState, message: '/model rm flash' });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      { env: { MODEL: 'gemini-3-pro' } },
+      '/mock/workspace'
+    );
+  });
+
+  it('notes when a removed shorthand still resolves from the template', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      modelShorthands: { flash: 'overridden-flash' },
+    });
+    vi.mocked(getAgent).mockResolvedValue({
+      modelShorthands: { flash: 'template-flash' },
+    });
+
+    const result = await slashModel({ ...baseState, message: '/model rm flash' });
+
+    expect(result.reply).toBe(
+      "Removed shorthand: flash (still resolves to 'template-flash' from template)."
+    );
+  });
+
+  it('reports template-only shorthands as unremovable', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({});
+    vi.mocked(getAgent).mockResolvedValue({
+      modelShorthands: { flash: 'template-flash' },
+    });
+
+    const result = await slashModel({ ...baseState, message: '/model remove flash' });
+
+    expect(result.reply).toContain("'flash' is defined in the template");
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('reports unknown shorthands on /model remove', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({
+      modelShorthands: { flash: 'x' },
+    });
+    vi.mocked(getAgent).mockResolvedValue({ modelShorthands: { flash: 'x' } });
+
+    const result = await slashModel({ ...baseState, message: '/model rm bogus' });
+
+    expect(result.reply).toBe("Shorthand 'bogus' not found.");
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('reports usage on /model remove with no argument', async () => {
+    const result = await slashModel({ ...baseState, message: '/model remove' });
+    expect(result.reply).toBe('Usage: /model remove <shorthand>');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+
+  it('warns when an unknown shorthand-shaped name is set', async () => {
+    vi.mocked(getAgent).mockResolvedValue({ modelShorthands: { flash: 'x' } });
+    vi.mocked(getAgentOverlay).mockResolvedValue({});
+
+    const result = await slashModel({ ...baseState, message: '/model claude' });
+
+    expect(writeAgentSettings).toHaveBeenCalledWith(
+      'jeeves',
+      { env: { MODEL: 'claude' } },
+      '/mock/workspace'
+    );
+    expect(result.reply).toContain('Set MODEL to claude.');
+    expect(result.reply).toContain('No shorthand matched');
+    expect(result.reply).toContain('/model add claude <full-name>');
+  });
+
+  it('does not warn when the literal name has separators', async () => {
+    vi.mocked(getAgent).mockResolvedValue({ modelShorthands: {} });
+    vi.mocked(getAgentOverlay).mockResolvedValue({});
+
+    const result = await slashModel({ ...baseState, message: '/model claude-opus-4-7' });
+
+    expect(result.reply).toBe('Set MODEL to claude-opus-4-7.');
+  });
+
+  it('does not match /models or other prefixes', async () => {
+    const state = { ...baseState, message: '/models gpt-5' };
+    const result = await slashModel(state);
+    expect(result).toEqual(state);
+  });
+
+  describe('refuses to write when the agent has no overlay', () => {
+    beforeEach(() => {
+      vi.mocked(getAgentOverlay).mockResolvedValue(null);
+    });
+
+    it('on /model <name>', async () => {
+      const result = await slashModel({ ...baseState, message: '/model gemini-3-pro' });
+      expect(result.reply).toBe("Agent 'jeeves' has no settings overlay; cannot configure model.");
+      expect(writeAgentSettings).not.toHaveBeenCalled();
+      expect(updateAgentOverlay).not.toHaveBeenCalled();
+    });
+
+    it('on /model add', async () => {
+      const result = await slashModel({
+        ...baseState,
+        message: '/model add flash gemini-3-flash-preview',
+      });
+      expect(result.reply).toBe("Agent 'jeeves' has no settings overlay; cannot configure model.");
+      expect(writeAgentSettings).not.toHaveBeenCalled();
+      expect(updateAgentOverlay).not.toHaveBeenCalled();
+    });
+
+    it('on /model remove', async () => {
+      const result = await slashModel({ ...baseState, message: '/model rm flash' });
+      expect(result.reply).toBe("Agent 'jeeves' has no settings overlay; cannot configure model.");
+      expect(writeAgentSettings).not.toHaveBeenCalled();
+      expect(updateAgentOverlay).not.toHaveBeenCalled();
+    });
+  });
+
+  it('rejects /model add when the full name has whitespace', async () => {
+    vi.mocked(getAgentOverlay).mockResolvedValue({});
+
+    const result = await slashModel({
+      ...baseState,
+      message: '/model add foo gemini-3 pro',
+    });
+
+    expect(result.reply).toBe('Usage: /model add <shorthand> <full-name>');
+    expect(writeAgentSettings).not.toHaveBeenCalled();
+  });
+});

package/src/daemon/routers/slash-model.ts

@@ -0,0 +1,207 @@
+import type { RouterState } from './types.js';
+import type { Agent } from '../../shared/config.js';
+import {
+  getAgent,
+  getAgentOverlay,
+  updateAgentOverlay,
+  getWorkspaceRoot,
+} from '../../shared/workspace.js';
+
+const RESERVED_SHORTHANDS = new Set(['help', 'add', 'remove', 'rm']);
+
+function stop(state: RouterState, reply: string): RouterState {
+  return { ...state, message: '', reply, action: 'stop' };
+}
+
+function formatHelp(): string {
+  return [
+    'Usage:',
+    '- /model — List current model and shorthands.',
+    '- /model <name> — Set MODEL (resolves shorthand if defined).',
+    '- /model add <shorthand> <full-name> — Add or replace a shorthand.',
+    '- /model remove <shorthand> — Remove a shorthand (alias: rm).',
+    '- /model help — Show this help.',
+  ].join('\n');
+}
+
+function formatList(agent: Agent | null): string {
+  const current = (agent?.env?.MODEL as string | undefined) ?? '(unset)';
+  const shorthands = agent?.modelShorthands ?? {};
+  const entries = Object.entries(shorthands);
+  const lines = [`Current model: ${current}`];
+  if (entries.length === 0) {
+    lines.push('No shorthands defined. Add one with /model add <shorthand> <full-name>.');
+  } else {
+    lines.push('Shorthands:');
+    for (const [short, full] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+      lines.push(`- ${short} -> ${full}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+// Heuristic: a token that looks like a short, undecorated word a user might
+// reasonably mistake for a shorthand. Real model names typically contain at
+// least one separator (e.g. `gemini-3-pro`, `claude-opus-4-7`, `gpt-4.1`).
+function looksLikeShorthand(name: string): boolean {
+  return name.length <= 16 && !/[-./:]/.test(name);
+}
+
+async function setModel(agentId: string, fullModel: string, workspaceRoot: string): Promise<void> {
+  await updateAgentOverlay(
+    agentId,
+    (overlay) => {
+      const nextEnv = { ...(overlay.env ?? {}), MODEL: fullModel };
+      return { ...overlay, env: nextEnv };
+    },
+    workspaceRoot
+  );
+}
+
+async function addShorthand(
+  agentId: string,
+  shorthand: string,
+  fullModel: string,
+  workspaceRoot: string
+): Promise<void> {
+  await updateAgentOverlay(
+    agentId,
+    (overlay) => {
+      const nextShorthands = { ...(overlay.modelShorthands ?? {}), [shorthand]: fullModel };
+      return { ...overlay, modelShorthands: nextShorthands };
+    },
+    workspaceRoot
+  );
+}
+
+async function removeOverlayShorthand(
+  agentId: string,
+  shorthand: string,
+  workspaceRoot: string
+): Promise<boolean> {
+  return await updateAgentOverlay(
+    agentId,
+    (overlay) => {
+      const overlayShorthands = overlay.modelShorthands ?? {};
+      if (!(shorthand in overlayShorthands)) return null;
+      const next = { ...overlayShorthands };
+      delete next[shorthand];
+      const updated: Agent = { ...overlay };
+      if (Object.keys(next).length === 0) {
+        delete updated.modelShorthands;
+      } else {
+        updated.modelShorthands = next;
+      }
+      return updated;
+    },
+    workspaceRoot
+  );
+}
+
+async function ensureOverlay(
+  state: RouterState,
+  agentId: string,
+  workspaceRoot: string
+): Promise<RouterState | null> {
+  const overlay = await getAgentOverlay(agentId, workspaceRoot);
+  if (overlay !== null) return null;
+  return stop(state, `Agent '${agentId}' has no settings overlay; cannot configure model.`);
+}
+
+export async function slashModel(state: RouterState): Promise<RouterState> {
+  const message = state.message.trim();
+  if (!/^\/model(\s|$)/.test(message)) return state;
+
+  const agentId = state.agentId;
+  if (!agentId) {
+    return stop(state, '/model requires an agent. Set a defaultAgent for this chat.');
+  }
+
+  const workspaceRoot = getWorkspaceRoot();
+  const rest = message.slice('/model'.length).trim();
+
+  if (rest === '') {
+    const agent = await getAgent(agentId, workspaceRoot);
+    return stop(state, formatList(agent));
+  }
+
+  const firstSpace = rest.search(/\s/);
+  const subcommand = firstSpace === -1 ? rest : rest.slice(0, firstSpace);
+  const remainder = firstSpace === -1 ? '' : rest.slice(firstSpace + 1).trim();
+
+  if (subcommand === 'help') {
+    return stop(state, formatHelp());
+  }
+
+  if (subcommand === 'add') {
+    // Require a single-token full name. Model identifiers don't contain
+    // whitespace, and accepting trailing tokens silently swallows typos
+    // (e.g. `/model add foo gemini-3 pro` storing `MODEL=gemini-3 pro`).
+    const addMatch = remainder.match(/^(\S+)\s+(\S+)\s*$/);
+    if (!addMatch) {
+      return stop(state, 'Usage: /model add <shorthand> <full-name>');
+    }
+    const shorthand = addMatch[1]!;
+    const fullModel = addMatch[2]!;
+    if (RESERVED_SHORTHANDS.has(shorthand)) {
+      return stop(state, `Invalid shorthand: '${shorthand}' is reserved.`);
+    }
+    const guard = await ensureOverlay(state, agentId, workspaceRoot);
+    if (guard) return guard;
+    await addShorthand(agentId, shorthand, fullModel, workspaceRoot);
+    return stop(state, `Added shorthand: ${shorthand} -> ${fullModel}`);
+  }
+
+  if (subcommand === 'remove' || subcommand === 'rm') {
+    if (!/^\S+$/.test(remainder)) {
+      return stop(state, 'Usage: /model remove <shorthand>');
+    }
+    const guard = await ensureOverlay(state, agentId, workspaceRoot);
+    if (guard) return guard;
+    const removed = await removeOverlayShorthand(agentId, remainder, workspaceRoot);
+    if (!removed) {
+      const merged = await getAgent(agentId, workspaceRoot);
+      if (merged?.modelShorthands?.[remainder] !== undefined) {
+        return stop(
+          state,
+          `Shorthand '${remainder}' is defined in the template, not the overlay. Edit the template to remove it.`
+        );
+      }
+      return stop(state, `Shorthand '${remainder}' not found.`);
+    }
+    const merged = await getAgent(agentId, workspaceRoot);
+    const fallback = merged?.modelShorthands?.[remainder];
+    const note = fallback !== undefined ? ` (still resolves to '${fallback}' from template)` : '';
+    return stop(state, `Removed shorthand: ${remainder}${note}.`);
+  }
+
+  if (subcommand.startsWith('-')) {
+    return stop(state, `Unknown option: ${subcommand}\n${formatHelp()}`);
+  }
+
+  // Bare model name / shorthand. Reject extra args so a typoed subcommand like
+  // `/model rmove flash` doesn't get stored as MODEL=rmove.
+  if (remainder !== '') {
+    return stop(state, `Unknown subcommand: ${subcommand}\n${formatHelp()}`);
+  }
+
+  const guard = await ensureOverlay(state, agentId, workspaceRoot);
+  if (guard) return guard;
+
+  const agent = await getAgent(agentId, workspaceRoot);
+  const shorthands = agent?.modelShorthands ?? {};
+  const matched = Object.prototype.hasOwnProperty.call(shorthands, subcommand);
+  const fullModel = matched ? shorthands[subcommand]! : subcommand;
+  await setModel(agentId, fullModel, workspaceRoot);
+
+  if (matched) {
+    return stop(state, `Set MODEL to ${fullModel} (shorthand '${subcommand}').`);
+  }
+  if (looksLikeShorthand(subcommand)) {
+    return stop(
+      state,
+      `Set MODEL to ${fullModel}. (No shorthand matched — was that the literal model name? Run /model add ${subcommand} <full-name> if not.)`
+    );
+  }
+  return stop(state, `Set MODEL to ${fullModel}.`);
+}

package/src/daemon/routers/slash-policies.test.ts

@@ -2,18 +2,30 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { slashPolicies } from './slash-policies.js';
 import { RequestStore } from '../request-store.js';
-import { readPolicies } from '../../shared/workspace.js';
-import { executeRequest } from '../policy-utils.js';
+import { readPoliciesForPath, getWorkspaceRoot } from '../../shared/workspace.js';
+import { resolveAgentDir } from '../api/router-utils.js';
+import { executeRequest, truncateLargeOutput } from '../policy-utils.js';
 import { appendMessage } from '../chats.js';
+import { executeDirectMessage } from '../message.js';
 import type { PolicyRequest } from '../../shared/policies.js';
 
 vi.mock('../request-store.js');
 vi.mock('../../shared/workspace.js');
+vi.mock('../api/router-utils.js');
 vi.mock('../policy-utils.js');
 vi.mock('../chats.js');
-vi.mock('node:crypto', () => ({
-  randomUUID: vi.fn(() => 'mock-uuid'),
-}));
+vi.mock('../message.js');
+vi.mock('node:crypto', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:crypto')>();
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      randomUUID: vi.fn(() => 'mock-uuid'),
+    },
+    randomUUID: vi.fn(() => 'mock-uuid'),
+  };
+});
 
 describe('slashPolicies', () => {
   let mockStore: any;
@@ -23,16 +35,20 @@ describe('slashPolicies', () => {
       list: vi.fn(),
       load: vi.fn(),
       save: vi.fn(),
+      delete: vi.fn(),
     };
     vi.mocked(RequestStore).mockImplementation(function (this: any) {
       this.list = mockStore.list;
       this.load = mockStore.load;
       this.save = mockStore.save;
+      this.delete = mockStore.delete;
       return this;
     } as any);
 
     vi.mocked(appendMessage).mockResolvedValue(undefined);
-    vi.mocked(readPolicies).mockResolvedValue({
+    vi.mocked(getWorkspaceRoot).mockReturnValue('/mock/workspace');
+    vi.mocked(resolveAgentDir).mockResolvedValue('/mock/workspace/agent-1');
+    vi.mocked(readPoliciesForPath).mockResolvedValue({
       policies: {
         'test-cmd': {
           command: 'echo',
@@ -46,6 +62,10 @@ describe('slashPolicies', () => {
       exitCode: 0,
       commandStr: 'echo hello world',
     });
+    vi.mocked(truncateLargeOutput).mockImplementation(async (stdout, stderr) => ({
+      stdout,
+      stderr,
+    }));
   });
 
   afterEach(() => {
@@ -97,24 +117,21 @@ describe('slashPolicies', () => {
     const state = { message: '/approve req-1', messageId: 'mock-msg-id', chatId: 'chat-1' };
     const result = await slashPolicies(state);
 
-    expect(mockStore.save).toHaveBeenCalledWith({
-      ...pendingReq,
-      state: 'Approved',
-      executionResult: { stdout: 'hello world', stderr: '', exitCode: 0 },
-    });
+    expect(mockStore.save).not.toHaveBeenCalled();
+    expect(mockStore.delete).toHaveBeenCalledWith('req-1');
     expect(executeRequest).toHaveBeenCalledWith(pendingReq, expect.any(Object), undefined);
     expect(appendMessage).toHaveBeenCalledWith(
       'chat-1',
       expect.objectContaining({
         role: 'system',
         event: 'policy_approved',
-        displayRole: 'user',
-        content: expect.stringContaining('Request req-1 approved.'),
+        displayRole: 'agent',
+        content: expect.stringContaining('Request req-1 (`test-cmd`) approved.'),
       })
     );
+    expect(executeDirectMessage).toHaveBeenCalled();
     expect(result.action).toBeUndefined();
-    expect(result.message).toContain('Request req-1 approved.');
-    expect(result.message).toContain('<stdout>\nhello world\n</stdout>');
+    expect(result.message).toBe('');
   });
 
   it('should reject a pending request on /reject with reason and inject feedback', async () => {
@@ -137,32 +154,21 @@ describe('slashPolicies', () => {
     };
     const result = await slashPolicies(state);
 
-    expect(mockStore.save).toHaveBeenCalledWith({
-      ...pendingReq,
-      state: 'Rejected',
-      rejectionReason: 'Not allowed',
-    });
-    expect(appendMessage).toHaveBeenCalledTimes(2);
-    expect(appendMessage).toHaveBeenCalledWith(
-      'chat-1',
-      expect.objectContaining({
-        role: 'system',
-        event: 'policy_rejected',
-        displayRole: 'user',
-        content: 'Request req-1 rejected. Reason: Not allowed',
-      })
-    );
+    expect(mockStore.save).not.toHaveBeenCalled();
+    expect(mockStore.delete).toHaveBeenCalledWith('req-1');
+    expect(appendMessage).toHaveBeenCalledTimes(1);
     expect(appendMessage).toHaveBeenCalledWith(
       'chat-1',
       expect.objectContaining({
         role: 'system',
         event: 'policy_rejected',
         displayRole: 'agent',
-        content: 'Request req-1 rejected. Reason: Not allowed',
+        content: 'Request req-1 (`test-cmd`) rejected. Reason: Not allowed',
       })
     );
+    expect(executeDirectMessage).toHaveBeenCalled();
     expect(result.action).toBeUndefined();
-    expect(result.message).toBe('Request req-1 rejected. Reason: Not allowed');
+    expect(result.message).toBe('');
   });
 
   it('should not act if request is not found', async () => {