clawmini 0.0.7 → 0.0.9

package/e2e/policies/slash-policies.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type SystemMessage,
+  policyWith,
+} from '../_helpers/test-environment.js';
+
+describe('Policy Flows E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+  let secondChat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-policy-flows');
+    await env.setup();
+    await env.setupSubagentEnv({
+      policies: {
+        'test-cmd': {
+          description: 'A test policy',
+          command: 'echo',
+          args: ['policy executed'],
+        },
+      },
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  const sanitize = (content: string, reqId: string) =>
+    content.replace(new RegExp(reqId, 'g'), '<REQ_ID>');
+
+  const approvedStdout =
+    'Request <REQ_ID> approved.\n\n<stdout>\npolicy executed\n</stdout>\n\n<stderr></stderr>\n\nExit Code: 0';
+
+  type RouteCase = {
+    label: string;
+    chat: string;
+    spawn: string;
+    action: 'approve' | 'reject';
+    event: 'policy_approved' | 'policy_rejected';
+    subagentId: string | undefined;
+    expectedUserContent: string;
+    expectedActorContent: string;
+  };
+
+  const routeCases: RouteCase[] = [
+    {
+      label: 'subagent /reject',
+      chat: 'chat-reject-sub',
+      spawn:
+        'clawmini-lite.js subagents spawn --id sub-reject --async "clawmini-lite.js request test-cmd --async"',
+      action: 'reject',
+      event: 'policy_rejected',
+      subagentId: 'sub-reject',
+      expectedUserContent: 'Request <REQ_ID> (`test-cmd`) rejected. Reason: No reason provided',
+      expectedActorContent: 'Request <REQ_ID> rejected. Reason: No reason provided',
+    },
+    {
+      label: 'subagent /approve',
+      chat: 'chat-approve-sub',
+      spawn:
+        'clawmini-lite.js subagents spawn --id sub-approve --async "clawmini-lite.js request test-cmd"',
+      action: 'approve',
+      event: 'policy_approved',
+      subagentId: 'sub-approve',
+      expectedUserContent: 'Request <REQ_ID> (`test-cmd`) approved.',
+      expectedActorContent: approvedStdout,
+    },
+    {
+      label: 'main agent /reject',
+      chat: 'chat-reject-main',
+      spawn: 'clawmini-lite.js request test-cmd --async',
+      action: 'reject',
+      event: 'policy_rejected',
+      subagentId: undefined,
+      expectedUserContent: 'Request <REQ_ID> (`test-cmd`) rejected. Reason: No reason provided',
+      expectedActorContent: 'Request <REQ_ID> rejected. Reason: No reason provided',
+    },
+    {
+      label: 'main agent /approve',
+      chat: 'chat-approve-main',
+      spawn: 'clawmini-lite.js request test-cmd',
+      action: 'approve',
+      event: 'policy_approved',
+      subagentId: undefined,
+      expectedUserContent: 'Request <REQ_ID> (`test-cmd`) approved.',
+      expectedActorContent: approvedStdout,
+    },
+  ];
+
+  it.each(routeCases)(
+    'routes policy notifications ($label)',
+    async ({ chat: chatId, spawn, action, event, subagentId, expectedUserContent, expectedActorContent }) => {
+      await env.addChat(chatId);
+      chat = await env.connect(chatId);
+
+      await env.sendMessage(spawn, { chat: chatId, agent: 'debug-agent' });
+
+      const policy = await chat.waitForMessage(
+        policyWith()
+      );
+      const reqId = policy.requestId;
+
+      await env.sendMessage(`/${action} ${reqId}`, { chat: chatId });
+
+      const userNotif = await chat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' && m.event === event && m.displayRole === 'agent'
+      );
+      expect(userNotif.subagentId).toBeUndefined();
+      expect(sanitize(userNotif.content, reqId)).toBe(expectedUserContent);
+
+      const actorNotif = await chat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' &&
+          m.event === event &&
+          m.displayRole === 'user' &&
+          m.subagentId === subagentId
+      );
+      expect(sanitize(actorNotif.content, reqId)).toBe(expectedActorContent);
+
+      const reqPath = path.resolve(env.e2eDir, `.clawmini/tmp/requests/${reqId}.json`);
+      expect(fs.existsSync(reqPath)).toBe(false);
+    },
+    15000
+  );
+
+  it('should list pending requests in /pending output', async () => {
+    await env.addChat('chat-pending-list');
+    chat = await env.connect('chat-pending-list');
+
+    await env.sendMessage('clawmini-lite.js request test-cmd', {
+      chat: 'chat-pending-list',
+      agent: 'debug-agent',
+    });
+
+    const reqId = (
+      await chat.waitForMessage(policyWith())
+    ).requestId;
+
+    await env.sendMessage('/pending', { chat: 'chat-pending-list' });
+
+    const reply = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' &&
+        m.event === 'router' &&
+        typeof m.content === 'string' &&
+        m.content.includes('Pending Requests')
+    );
+
+    expect(reply.content).toContain('Pending Requests (1):');
+    expect(reply.content).toContain(`- ID: ${reqId} | Command: test-cmd`);
+  }, 15000);
+
+  it('should include a custom reason in /reject notifications and delete the request file', async () => {
+    await env.addChat('chat-reject-reason');
+    chat = await env.connect('chat-reject-reason');
+
+    await env.sendMessage('clawmini-lite.js request test-cmd', {
+      chat: 'chat-reject-reason',
+      agent: 'debug-agent',
+    });
+
+    const reqId = (
+      await chat.waitForMessage(policyWith())
+    ).requestId;
+
+    await env.sendMessage(`/reject ${reqId} command looked suspicious`, {
+      chat: 'chat-reject-reason',
+    });
+
+    const userMsg = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' && m.event === 'policy_rejected' && m.displayRole === 'agent'
+    );
+    expect(userMsg.content).toContain('command looked suspicious');
+
+    const agentMsg = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' && m.event === 'policy_rejected' && m.displayRole === 'user'
+    );
+    expect(agentMsg.content).toContain('command looked suspicious');
+
+    const reqPath = path.resolve(env.e2eDir, `.clawmini/tmp/requests/${reqId}.json`);
+    expect(fs.existsSync(reqPath)).toBe(false);
+  }, 15000);
+
+  describe('validation branches', () => {
+    it('should reply "Request not found" for /approve with an unknown id', async () => {
+      await env.addChat('chat-notfound');
+      chat = await env.connect('chat-notfound');
+
+      await env.sendMessage('/approve nonexistent-id', { chat: 'chat-notfound' });
+
+      await chat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' &&
+          m.event === 'router' &&
+          typeof m.content === 'string' &&
+          m.content.includes('Request not found: nonexistent-id')
+      );
+    }, 15000);
+
+    it('should refuse cross-chat /approve', async () => {
+      await env.addChat('chat-owner');
+      await env.addChat('chat-intruder');
+      chat = await env.connect('chat-owner');
+
+      await env.sendMessage('clawmini-lite.js request test-cmd', {
+        chat: 'chat-owner',
+        agent: 'debug-agent',
+      });
+
+      const reqId = (
+        await chat.waitForMessage(policyWith())
+      ).requestId;
+
+      secondChat = await env.connect('chat-intruder');
+
+      await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-intruder' });
+
+      await secondChat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' &&
+          m.event === 'router' &&
+          typeof m.content === 'string' &&
+          m.content.includes('Request belongs to a different chat')
+      );
+    }, 15000);
+
+    it('should refuse /approve on an already-approved request', async () => {
+      await env.addChat('chat-double-approve');
+      chat = await env.connect('chat-double-approve');
+
+      await env.sendMessage('clawmini-lite.js request test-cmd', {
+        chat: 'chat-double-approve',
+        agent: 'debug-agent',
+      });
+
+      const reqId = (
+        await chat.waitForMessage(policyWith())
+      ).requestId;
+
+      await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-double-approve' });
+
+      // Wait for the first approval to complete before sending a second one.
+      await chat.waitForMessage(
+        (m): m is SystemMessage => m.role === 'system' && m.event === 'policy_approved'
+      );
+
+      await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-double-approve' });
+
+      // Approved requests are deleted, so the second /approve sees the request as gone.
+      await chat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' &&
+          m.event === 'router' &&
+          typeof m.content === 'string' &&
+          m.content.includes(`Request not found: ${reqId}`)
+      );
+    }, 15000);
+
+    it('should reply "Policy not found" if the policy was removed after request creation', async () => {
+      const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+      const original = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+      const mutated = JSON.parse(JSON.stringify(original));
+      mutated.policies['temp-cmd'] = {
+        description: 'Temporary',
+        command: 'echo',
+        args: ['temp'],
+      };
+      fs.writeFileSync(policiesPath, JSON.stringify(mutated));
+
+      try {
+        await env.addChat('chat-policy-gone');
+        chat = await env.connect('chat-policy-gone');
+
+        await env.sendMessage('clawmini-lite.js request temp-cmd', {
+          chat: 'chat-policy-gone',
+          agent: 'debug-agent',
+        });
+
+        const reqId = (
+          await chat.waitForMessage(policyWith())
+        ).requestId;
+
+        // Remove the policy before /approve is processed
+        fs.writeFileSync(policiesPath, JSON.stringify(original));
+
+        await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-policy-gone' });
+
+        await chat.waitForMessage(
+          (m): m is SystemMessage =>
+            m.role === 'system' &&
+            m.event === 'router' &&
+            typeof m.content === 'string' &&
+            m.content.includes('Policy not found: temp-cmd')
+        );
+      } finally {
+        fs.writeFileSync(policiesPath, JSON.stringify(original));
+      }
+    }, 15000);
+  });
+});

package/e2e/policies/startup-cleanup.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+import type { PolicyRequest, RequestState } from '../../src/shared/policies.js';
+
+describe('Policy Startup Cleanup E2E', () => {
+  let env: TestEnvironment;
+  let requestsDir: string;
+
+  const makeRequest = (id: string, state: RequestState): PolicyRequest => ({
+    id,
+    commandName: 'test-cmd',
+    args: [],
+    fileMappings: {},
+    state,
+    createdAt: Date.now(),
+    chatId: 'some-chat',
+    agentId: 'some-agent',
+  });
+
+  const writeRequest = (req: PolicyRequest) => {
+    fs.writeFileSync(path.join(requestsDir, `${req.id}.json`), JSON.stringify(req, null, 2));
+  };
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-upgrade-cleanup');
+    await env.setup();
+    await env.init();
+
+    requestsDir = path.resolve(env.e2eDir, '.clawmini/tmp/requests');
+    fs.mkdirSync(requestsDir, { recursive: true });
+
+    writeRequest(makeRequest('PENDING1', 'Pending'));
+    writeRequest(makeRequest('APPROVED1', 'Approved'));
+    writeRequest(makeRequest('REJECTED1', 'Rejected'));
+
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('deletes completed request files on startup and keeps pending ones', () => {
+    expect(fs.existsSync(path.join(requestsDir, 'PENDING1.json'))).toBe(true);
+    expect(fs.existsSync(path.join(requestsDir, 'APPROVED1.json'))).toBe(false);
+    expect(fs.existsSync(path.join(requestsDir, 'REJECTED1.json'))).toBe(false);
+  });
+});

package/e2e/routers/session-timeout.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { TestEnvironment, type ChatSubscription, commandMatching } from '../_helpers/test-environment.js';
+
+describe('Session Timeout E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-timeout');
+    await env.setup();
+    await env.runCli(['init', '--agent', 'test-agent', '--agent-template', 'debug']);
+
+    env.updateSettings({
+      routers: [{ use: '@clawmini/session-timeout', with: { timeout: '5s' } }],
+    });
+
+    env.updateAgentSettings('test-agent', {
+      commands: {
+        new: 'echo "[DEBUG NEW $SESSION_ID] $CLAW_CLI_MESSAGE"',
+        append: 'echo "[DEBUG APPEND $SESSION_ID] $CLAW_CLI_MESSAGE"',
+        getSessionId: "node -e 'console.log(Math.random().toString(36).slice(2, 10))'",
+      },
+    });
+
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('fires the timeout job and routes the next message to a new session', async () => {
+    // `init --agent test-agent` sets the default chat id to 'test-agent'.
+    chat = await env.connect('test-agent');
+
+    const { code } = await env.sendMessage('first message');
+    expect(code).toBe(0);
+
+    const { stdout: jobsList } = await env.runCli(['jobs', 'list']);
+    expect(jobsList).toContain('__session_timeout__');
+
+    // Wait for the automated fresh-session reply after the 5s timeout fires.
+    await chat.waitForMessage(
+      (m) =>
+        typeof m.content === 'string' &&
+        m.content.includes('[@clawmini/session-timeout] Starting a fresh session...'),
+      10000
+    );
+
+    await env.sendMessage('second message');
+
+    // The second message should use `commands.new` with an empty SESSION_ID.
+    const secondMsgLog = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('second message') && m.stdout.includes('[DEBUG'))
+    );
+    expect(secondMsgLog.stdout).toContain('[DEBUG NEW ]');
+    expect(secondMsgLog.stdout).not.toContain('[DEBUG APPEND ');
+  }, 20000);
+
+  it('/new before timeout: old session gets a background prompt, no user-facing fresh-session notice', async () => {
+    await env.addChat('test2');
+    chat = await env.connect('test2');
+
+    await env.sendMessage('msg A', { chat: 'test2', agent: 'test-agent' });
+    await env.sendMessage('/new', { chat: 'test2' });
+    await env.sendMessage('msg B', { chat: 'test2' });
+
+    // After 2s the msg A timer is at 2.5s, msg B timer is ~2s.
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    // Keep-alive resets the current session's timeout to 5s from now.
+    await env.sendMessage('msg KEEP ALIVE', { chat: 'test2' });
+
+    const keepAliveLog = await chat.waitForMessage(
+      commandMatching(
+        (m) => m.stdout.includes('msg KEEP ALIVE') && m.stdout.includes('[DEBUG APPEND')
+      )
+    );
+    const keepAliveSessionId = keepAliveLog.stdout.match(/\[DEBUG APPEND (.*?)\]/)?.[1];
+    expect(keepAliveSessionId).toBeTruthy();
+
+    // Wait another 3.5s: msg A is ~6s old (timer fired); keep-alive is ~3.5s (still fresh).
+    await new Promise((resolve) => setTimeout(resolve, 3500));
+
+    // The user should NOT be told the session was refreshed — /new already ended that session.
+    expect(
+      chat.messageBuffer.some(
+        (m) =>
+          typeof m.content === 'string' &&
+          m.content.includes('[@clawmini/session-timeout] Starting a fresh session...')
+      )
+    ).toBe(false);
+
+    // But the background prompt SHOULD have fired for msg A's (already-ended) session.
+    const backgroundPrompts = chat.messageBuffer.filter(
+      (m) => typeof m.content === 'string' && m.content.includes('This chat session has ended.')
+    );
+    expect(backgroundPrompts.length).toBeGreaterThanOrEqual(1);
+
+    // Current session wasn't blown away by msg A's timeout.
+    await env.sendMessage('msg C', { chat: 'test2' });
+    const msgCLog = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('msg C') && m.stdout.includes('[DEBUG'))
+    );
+    expect(msgCLog.stdout).toContain(`[DEBUG APPEND ${keepAliveSessionId}]`);
+  }, 20000);
+});

package/e2e/routers/slash-model.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach, beforeEach } from 'vitest';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type ChatMessage,
+} from '../_helpers/test-environment.js';
+
+// Router replies surface as `system` messages with `displayRole: 'agent'`,
+// produced by `logAutomaticReply` in chat-logger.ts.
+function routerReplyContaining(text: string) {
+  return (m: ChatMessage): boolean =>
+    m.role === 'system' && typeof m.content === 'string' && m.content.includes(text);
+}
+
+describe('/model Router E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-model');
+    await env.setup();
+    await env.runCli(['init', '--agent', 'test-agent', '--agent-template', 'debug']);
+    await env.up();
+    await env.addChat('model-chat', 'test-agent');
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  // Reset the overlay between tests so state from one test doesn't leak
+  // into the next. The daemon reads the overlay fresh on each /model call,
+  // so a direct file write is safe.
+  beforeEach(() => {
+    env.writeAgentSettings('test-agent', { extends: 'debug' });
+  });
+
+  it('lists current model and shorthands on bare /model', async () => {
+    env.writeAgentSettings('test-agent', {
+      extends: 'debug',
+      env: { MODEL: 'gemini-3-pro' },
+      modelShorthands: { flash: 'gemini-3-flash-preview', pro: 'gemini-3-pro' },
+    });
+
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model', { chat: 'model-chat' });
+
+    const msg = await chat.waitForMessage(routerReplyContaining('Current model: gemini-3-pro'));
+    expect(msg.content).toContain('- flash -> gemini-3-flash-preview');
+    expect(msg.content).toContain('- pro -> gemini-3-pro');
+  }, 15000);
+
+  it('sets env.MODEL to a literal model name and persists to overlay', async () => {
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model claude-opus-4-7', { chat: 'model-chat' });
+
+    await chat.waitForMessage(routerReplyContaining('Set MODEL to claude-opus-4-7'));
+
+    const overlay = env.getAgentSettings('test-agent') as { env?: { MODEL?: string } };
+    expect(overlay.env?.MODEL).toBe('claude-opus-4-7');
+  }, 15000);
+
+  it('resolves a shorthand and writes the full name to overlay', async () => {
+    env.writeAgentSettings('test-agent', {
+      extends: 'debug',
+      modelShorthands: { flash: 'gemini-3-flash-preview' },
+    });
+
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model flash', { chat: 'model-chat' });
+
+    const msg = await chat.waitForMessage(
+      routerReplyContaining('Set MODEL to gemini-3-flash-preview')
+    );
+    expect(msg.content).toContain("shorthand 'flash'");
+
+    const overlay = env.getAgentSettings('test-agent') as { env?: { MODEL?: string } };
+    expect(overlay.env?.MODEL).toBe('gemini-3-flash-preview');
+  }, 15000);
+
+  it('round-trips /model add then /model <shorthand>', async () => {
+    chat = await env.connect('model-chat');
+
+    await env.sendMessage('/model add lite gemini-3.1-flash-lite', { chat: 'model-chat' });
+    await chat.waitForMessage(
+      routerReplyContaining('Added shorthand: lite -> gemini-3.1-flash-lite')
+    );
+
+    const afterAdd = env.getAgentSettings('test-agent') as {
+      modelShorthands?: Record<string, string>;
+    };
+    expect(afterAdd.modelShorthands).toEqual({ lite: 'gemini-3.1-flash-lite' });
+
+    await env.sendMessage('/model lite', { chat: 'model-chat' });
+    await chat.waitForMessage(routerReplyContaining('Set MODEL to gemini-3.1-flash-lite'));
+
+    const afterUse = env.getAgentSettings('test-agent') as {
+      env?: { MODEL?: string };
+      modelShorthands?: Record<string, string>;
+    };
+    expect(afterUse.env?.MODEL).toBe('gemini-3.1-flash-lite');
+    expect(afterUse.modelShorthands).toEqual({ lite: 'gemini-3.1-flash-lite' });
+  }, 20000);
+
+  it('removes a shorthand from the overlay', async () => {
+    env.writeAgentSettings('test-agent', {
+      extends: 'debug',
+      modelShorthands: { flash: 'gemini-3-flash-preview', lite: 'gemini-3.1-flash-lite' },
+    });
+
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model rm flash', { chat: 'model-chat' });
+    await chat.waitForMessage(routerReplyContaining('Removed shorthand: flash'));
+
+    const overlay = env.getAgentSettings('test-agent') as {
+      modelShorthands?: Record<string, string>;
+    };
+    expect(overlay.modelShorthands).toEqual({ lite: 'gemini-3.1-flash-lite' });
+  }, 15000);
+
+  // Regression: `/model add foo gemini-3 pro` previously stored the literal
+  // multi-token value `gemini-3 pro` as MODEL. Now rejects with usage.
+  it('rejects /model add when the full name has whitespace', async () => {
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model add foo gemini-3 pro', { chat: 'model-chat' });
+
+    await chat.waitForMessage(routerReplyContaining('Usage: /model add <shorthand> <full-name>'));
+
+    const overlay = env.getAgentSettings('test-agent') as {
+      modelShorthands?: Record<string, string>;
+      env?: { MODEL?: string };
+    };
+    expect(overlay.modelShorthands).toBeUndefined();
+    expect(overlay.env?.MODEL).toBeUndefined();
+  }, 15000);
+
+  // Regression: `/model X` against an agent without an overlay used to
+  // silently fabricate a stub `{env: {MODEL: X}}` settings file with no
+  // `extends`, breaking subsequent agent resolution. Now it refuses.
+  it('refuses to write when the agent has no settings overlay', async () => {
+    const settingsPath = env.getAgentPath('test-agent', 'settings.json');
+    fs.rmSync(settingsPath);
+    expect(fs.existsSync(settingsPath)).toBe(false);
+
+    chat = await env.connect('model-chat');
+    await env.sendMessage('/model gemini-3-pro', { chat: 'model-chat' });
+
+    await chat.waitForMessage(routerReplyContaining('has no settings overlay'));
+
+    expect(fs.existsSync(settingsPath)).toBe(false);
+  }, 15000);
+});

package/e2e/routers/slash-new.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { TestEnvironment, type ChatSubscription, commandMatching } from '../_helpers/test-environment.js';
+
+describe('/new Command E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-new');
+    await env.setup();
+    await env.runCli(['init', '--agent', 'test-agent', '--agent-template', 'debug']);
+
+    env.updateAgentSettings('test-agent', {
+      commands: {
+        new: 'echo "[DEBUG NEW $SESSION_ID] $CLAW_CLI_MESSAGE"',
+        append: 'echo "[DEBUG APPEND $SESSION_ID] $CLAW_CLI_MESSAGE"',
+        getSessionId: "node -e 'console.log(Math.random().toString(36).slice(2, 10))'",
+      },
+    });
+
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('resets the session ID when /new is sent', async () => {
+    chat = await env.connect('test-agent');
+
+    const { code } = await env.sendMessage('message 1');
+    expect(code).toBe(0);
+
+    await env.sendMessage('message 2');
+
+    const msg2Log = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('message 2') && m.stdout.includes('[DEBUG APPEND'))
+    );
+    const firstSessionId = msg2Log.stdout.match(/\[DEBUG APPEND (.*?)\]/)?.[1];
+    expect(firstSessionId).toBeTruthy();
+
+    await env.sendMessage('/new');
+    await env.sendMessage('message 3');
+
+    const msg3Log = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('message 3') && m.stdout.includes('[DEBUG'))
+    );
+    expect(msg3Log.stdout).toContain('[DEBUG NEW ]');
+    expect(msg3Log.stdout).not.toContain('[DEBUG APPEND');
+  }, 30000);
+});