clawmini 0.0.8 → 0.0.9

package/src/cli/e2e/propose-policy.test.ts

@@ -1,203 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { createE2EContext } from './utils.js';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-describe('propose-policy CLI', () => {
-  const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-propose-policy');
-  const binPath = path.resolve(__dirname, '../../../dist/cli/propose-policy.mjs');
-
-  beforeAll(async () => {
-    await setupE2E();
-    const { code, stderr } = await runCli(['init']);
-    if (code !== 0) throw new Error(`Init failed: ${stderr}`);
-  });
-
-  afterAll(async () => {
-    await teardownE2E();
-  });
-
-  function runProposePolicy(
-    args: string[]
-  ): Promise<{ stdout: string; stderr: string; code: number | null }> {
-    return new Promise((resolve) => {
-      const child = spawn('node', [binPath, ...args], {
-        cwd: e2eDir,
-        env: { ...process.env },
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout.on('data', (data) => (stdout += data.toString()));
-      child.stderr.on('data', (data) => (stderr += data.toString()));
-
-      child.on('close', (code) => {
-        resolve({ stdout, stderr, code });
-      });
-    });
-  }
-
-  it('should fail if missing required arguments', async () => {
-    const { stderr, code } = await runProposePolicy([]);
-    expect(code).toBe(1);
-    expect(stderr).toContain("error: required option '--name <policy_name>' not specified");
-  });
-
-  it('should fail if policy name is invalid', async () => {
-    const { stderr, code } = await runProposePolicy([
-      '--name',
-      'Invalid_Name!',
-      '--description',
-      'Test description',
-      '--command',
-      'echo test',
-    ]);
-    expect(code).toBe(1);
-    expect(stderr).toContain(
-      'Error: Policy name must only contain lowercase letters, numbers, and hyphens.'
-    );
-  });
-
-  it('should fail if neither command nor script-file is provided', async () => {
-    const { stderr, code } = await runProposePolicy([
-      '--name',
-      'test-policy',
-      '--description',
-      'Test description',
-    ]);
-    expect(code).toBe(1);
-    expect(stderr).toContain('Error: Must provide either --command or --script-file.');
-  });
-
-  it('should create a policy with a command', async () => {
-    const { stdout, stderr, code } = await runProposePolicy([
-      '--name',
-      'echo-test',
-      '--description',
-      'A simple echo command',
-      '--command',
-      'echo "Hello World"',
-    ]);
-
-    if (code !== 0) console.error(stderr);
-    expect(code).toBe(0);
-    expect(stdout).toContain("Successfully proposed and registered policy 'echo-test'");
-
-    const policiesPath = path.resolve(e2eDir, '.clawmini/policies.json');
-    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
-
-    expect(policies.policies['echo-test']).toBeDefined();
-    expect(policies.policies['echo-test'].description).toBe('A simple echo command');
-    expect(policies.policies['echo-test'].command).toBe('echo');
-    expect(policies.policies['echo-test'].args).toEqual(['"Hello', 'World"']);
-    expect(policies.policies['echo-test'].allowHelp).toBe(true);
-  });
-
-  it('should create a policy with a script file', async () => {
-    const scriptPath = path.resolve(e2eDir, 'test-script.sh');
-    fs.writeFileSync(scriptPath, '#!/bin/bash\necho "From script"', { mode: 0o755 });
-
-    const { stdout, code } = await runProposePolicy([
-      '--name',
-      'script-test',
-      '--description',
-      'A test script policy',
-      '--script-file',
-      scriptPath,
-    ]);
-
-    expect(code).toBe(0);
-    expect(stdout).toContain("Successfully proposed and registered policy 'script-test'");
-
-    const destScriptPath = path.resolve(e2eDir, '.clawmini/policy-scripts/script-test.sh');
-    expect(fs.existsSync(destScriptPath)).toBe(true);
-
-    const policiesPath = path.resolve(e2eDir, '.clawmini/policies.json');
-    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
-
-    expect(policies.policies['script-test']).toBeDefined();
-    expect(policies.policies['script-test'].command).toBe(
-      './.clawmini/policy-scripts/script-test.sh'
-    );
-  });
-
-  it('should overwrite an existing policy with the same name', async () => {
-    // Overwrite the 'echo-test' policy from previous test
-    const { stdout, code } = await runProposePolicy([
-      '--name',
-      'echo-test',
-      '--description',
-      'An updated echo command',
-      '--command',
-      'echo "Updated"',
-    ]);
-
-    expect(code).toBe(0);
-    expect(stdout).toContain("Successfully proposed and registered policy 'echo-test'");
-
-    const policiesPath = path.resolve(e2eDir, '.clawmini/policies.json');
-    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
-
-    expect(policies.policies['echo-test']).toBeDefined();
-    expect(policies.policies['echo-test'].description).toBe('An updated echo command');
-    expect(policies.policies['echo-test'].command).toBe('echo');
-    expect(policies.policies['echo-test'].args).toEqual(['"Updated"']);
-  });
-});
-
-describe('propose-policy CLI (uninitialized)', () => {
-  const { e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-propose-policy-uninit');
-  const binPath = path.resolve(__dirname, '../../../dist/cli/propose-policy.mjs');
-
-  beforeAll(async () => {
-    await setupE2E();
-    // Intentionally not running init
-  });
-
-  afterAll(async () => {
-    await teardownE2E();
-  });
-
-  function runProposePolicy(
-    args: string[]
-  ): Promise<{ stdout: string; stderr: string; code: number | null }> {
-    return new Promise((resolve) => {
-      const child = spawn('node', [binPath, ...args], {
-        cwd: e2eDir,
-        env: { ...process.env },
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout.on('data', (data) => (stdout += data.toString()));
-      child.stderr.on('data', (data) => (stderr += data.toString()));
-
-      child.on('close', (code) => {
-        resolve({ stdout, stderr, code });
-      });
-    });
-  }
-
-  it('should fail if .clawmini directory does not exist', async () => {
-    const { stderr, code } = await runProposePolicy([
-      '--name',
-      'echo-test',
-      '--description',
-      'A simple echo command',
-      '--command',
-      'echo "Hello World"',
-    ]);
-
-    expect(code).toBe(1);
-    expect(stderr).toContain(
-      'Error: .clawmini directory not found. Please run "clawmini init" first.'
-    );
-  });
-});

package/src/cli/e2e/requests.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs';
-import fsPromises from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-requests');
-
-describe('E2E Requests Tests (Lite)', () => {
-  let litePath = '';
-  let envUrl = '';
-  let envToken = '';
-
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
-
-    // Setup policies.json
-    const policiesPath = path.join(e2eDir, '.clawmini', 'policies.json');
-    await fsPromises.writeFile(
-      policiesPath,
-      JSON.stringify({
-        policies: {
-          'test-cmd': {
-            description: 'A test policy',
-            command: 'echo',
-            args: ['hello'],
-            allowHelp: true,
-          },
-          'no-help-cmd': {
-            description: 'A no help policy',
-            command: 'echo',
-            args: ['nohelp'],
-          },
-          'auto-cmd': {
-            description: 'An auto approve policy',
-            command: 'echo',
-            args: ['autoresult'],
-            autoApprove: true,
-          },
-        },
-      })
-    );
-
-    // Setup daemon with API enabled
-    const settingsPath = path.resolve(e2eDir, '.clawmini/settings.json');
-    let originalSettings = '{}';
-    if (fs.existsSync(settingsPath)) {
-      originalSettings = fs.readFileSync(settingsPath, 'utf8');
-    }
-    fs.writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        ...JSON.parse(originalSettings),
-        api: { host: '127.0.0.1', port: 3008 },
-      })
-    );
-    await runCli(['up']);
-
-    // Export lite script
-    litePath = path.resolve(e2eDir, 'clawmini-lite.js');
-    await runCli(['export-lite', '--out', litePath]);
-
-    // Setup env-dumper agent
-    const envDumperAgentDir = path.resolve(e2eDir, 'lite-env-dumper');
-    fs.mkdirSync(envDumperAgentDir, { recursive: true });
-    await runCli(['agents', 'add', 'lite-env-dumper', '--dir', 'lite-env-dumper']);
-
-    const dumperSettings = path.resolve(e2eDir, '.clawmini/agents/lite-env-dumper/settings.json');
-    fs.mkdirSync(path.dirname(dumperSettings), { recursive: true });
-    const dumperScript = process.platform === 'win32' ? 'set > env.txt' : 'env > env.txt';
-    fs.writeFileSync(dumperSettings, JSON.stringify({ commands: { new: dumperScript } }));
-
-    await runCli(['chats', 'add', 'lite-chat']);
-    await runCli(['messages', 'send', 'dump', '--chat', 'lite-chat', '--agent', 'lite-env-dumper']);
-
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-
-    const envTxtPath = path.resolve(envDumperAgentDir, 'env.txt');
-    if (!fs.existsSync(envTxtPath)) {
-      throw new Error('env.txt not generated by agent');
-    }
-    const envContent = fs.readFileSync(envTxtPath, 'utf8');
-    const urlMatch = envContent.match(/CLAW_API_URL=(.+)/);
-    const tokenMatch = envContent.match(/CLAW_API_TOKEN=(.+)/);
-
-    if (!urlMatch || !tokenMatch) {
-      throw new Error('Could not find API credentials');
-    }
-
-    envUrl = urlMatch[1]!.trim();
-    envToken = tokenMatch[1]!.trim();
-  }, 30000);
-
-  afterAll(teardownE2E, 30000);
-
-  function runLite(
-    args: string[]
-  ): Promise<{ stdout: string; stderr: string; code: number | null }> {
-    return new Promise((resolve) => {
-      const p = spawn('node', [litePath, ...args], {
-        env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-        cwd: e2eDir,
-      });
-      let stdout = '';
-      let stderr = '';
-      p.stdout.on('data', (d) => (stdout += d.toString()));
-      p.stderr.on('data', (d) => (stderr += d.toString()));
-      p.on('close', (code) => resolve({ stdout, stderr, code }));
-    });
-  }
-
-  it('should list policies', async () => {
-    const { stdout, code } = await runLite(['requests', 'list']);
-    expect(code).toBe(0);
-    expect(stdout).toContain('Available Policies:');
-    expect(stdout).toContain('- test-cmd');
-    expect(stdout).toContain('Description: A test policy');
-  });
-
-  it('should run --help on underlying command', async () => {
-    const { stdout, code } = await runLite(['request', 'test-cmd', '--help']);
-    expect(code).toBe(0);
-    expect(stdout).toBeTruthy();
-  });
-
-  it('should block --help if allowHelp is not true', async () => {
-    const { stderr, code } = await runLite(['request', 'no-help-cmd', '--help']);
-    expect(code).toBe(1);
-    expect(stderr).toContain('This command does not support --help');
-  });
-
-  it('should create a request and return an ID', async () => {
-    const dummyFilePath = path.join(e2eDir, 'lite-env-dumper', 'dummy.txt');
-    await fsPromises.writeFile(dummyFilePath, 'dummy content');
-
-    const { stdout, stderr, code } = await runLite([
-      'request',
-      'test-cmd',
-      '--file',
-      `target=${dummyFilePath}`,
-      '--',
-      'extra1',
-      'extra2',
-    ]);
-
-    expect(stderr).toBe('');
-    expect(code).toBe(0);
-    expect(stdout).toContain('Request created successfully.');
-    expect(stdout).toContain('Request ID:');
-
-    // Verify the request was saved
-    const requestsDir = path.join(e2eDir, '.clawmini', 'tmp', 'requests');
-    const files = await fsPromises.readdir(requestsDir);
-    const jsonFiles = files.filter((f) => f.endsWith('.json'));
-    expect(jsonFiles.length).toBe(1);
-
-    const reqData = await fsPromises.readFile(path.join(requestsDir, jsonFiles[0]!), 'utf8');
-    const req = JSON.parse(reqData);
-
-    expect(req.commandName).toBe('test-cmd');
-    expect(req.args).toEqual(['extra1', 'extra2']);
-    expect(req.fileMappings).toHaveProperty('target');
-
-    // Check snapshot exists
-    const snapshotPath = req.fileMappings.target;
-    const snapshotContent = await fsPromises.readFile(snapshotPath, 'utf8');
-    expect(snapshotContent).toBe('dummy content');
-  });
-
-  it('should synchronously output execution result for auto-approved policy', async () => {
-    const { stdout, stderr, code } = await runLite(['request', 'auto-cmd', '--', 'extra-auto']);
-
-    expect(stderr).toBe('');
-    expect(code).toBe(0);
-    // Should output the result of `echo autoresult extra-auto`
-    expect(stdout.trim()).toBe('autoresult extra-auto');
-  });
-});

package/src/cli/e2e/session-timeout.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { createE2EContext } from './utils.js';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-timeout');
-
-describe('Session Timeout E2E', () => {
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init', '--agent', 'test-agent', '--agent-template', 'debug']);
-
-    // Override settings to configure the router with a 3-second timeout
-    const settingsPath = path.join(e2eDir, '.clawmini', 'settings.json');
-    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-
-    // Explicitly add the custom configured router
-    settings.routers = [
-      {
-        use: '@clawmini/session-timeout',
-        with: { timeout: '5s' },
-      },
-    ];
-
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-
-    // Force the test agent to succeed so that sessions actually get created!
-    const agentSettingsPath = path.join(
-      e2eDir,
-      '.clawmini',
-      'agents',
-      'test-agent',
-      'settings.json'
-    );
-    const agentSettings = JSON.parse(fs.readFileSync(agentSettingsPath, 'utf8'));
-    agentSettings.commands.new = 'echo "[DEBUG NEW $SESSION_ID] $CLAW_CLI_MESSAGE"';
-    agentSettings.commands.append = 'echo "[DEBUG APPEND $SESSION_ID] $CLAW_CLI_MESSAGE"';
-    fs.writeFileSync(agentSettingsPath, JSON.stringify(agentSettings, null, 2));
-  }, 30000);
-
-  afterAll(async () => {
-    await teardownE2E();
-  }, 30000);
-
-  function getMessages(stdout: string) {
-    return stdout
-      .trim()
-      .split('\n')
-      .filter((l) => l.trim().startsWith('{') && l.trim().endsWith('}'))
-      .map((l) => {
-        try {
-          return JSON.parse(l);
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
-  }
-
-  function getAgentResponse(messages: any[], userMessage: string) {
-    return messages.find(
-      (m) => m.content && m.content.includes(userMessage) && m.content.includes('[DEBUG')
-    );
-  }
-
-  it('(1) sending a message and waiting for timeout, ensuring that the old session has the timeout message sent to it and new messages go to a different session. The user should be sent a system message saying that a new session has started.', async () => {
-    // Send an initial message to trigger the router pipeline
-    const { code } = await runCli(['messages', 'send', 'first message']);
-    expect(code).toBe(0);
-
-    // Verify the timeout job was scheduled
-    const { stdout: jobsList } = await runCli(['jobs', 'list']);
-    expect(jobsList).toContain('__session_timeout__');
-
-    // Wait for the 5-second timeout job to execute
-    await new Promise((resolve) => setTimeout(resolve, 5500));
-
-    // Tail the chat history to verify the timeout message was automatically appended
-    const { stdout: history1 } = await runCli(['messages', 'tail', '-n', '30', '--json']);
-
-    // Validate the automated reply was sent
-    expect(history1).toContain('[@clawmini/session-timeout] Starting a fresh session...');
-
-    // Send another message
-    await runCli(['messages', 'send', 'second message']);
-
-    const { stdout: history2, stderr: err2 } = await runCli([
-      'messages',
-      'tail',
-      '-n',
-      '30',
-      '--json',
-    ]);
-    const messages = getMessages(history2);
-    if (messages.length === 0) console.error('RAW STDOUT:', history2, 'STDERR:', err2);
-
-    // Check that we see the first message, the fresh session reply, and the second message as a NEW session
-    const firstMsgLog = getAgentResponse(messages, 'first message');
-    if (!firstMsgLog) console.error('FAILED TO FIND FIRST MSG LOG in:', messages);
-    expect(firstMsgLog).toBeDefined();
-
-    const timeoutOutput = messages.find(
-      (m: any) =>
-        m.content && m.content.includes('[@clawmini/session-timeout] Starting a fresh session...')
-    );
-    expect(timeoutOutput).toBeDefined();
-
-    // The second message should use `commands.new`, which prints `[DEBUG NEW ] second message` because $SESSION_ID is empty
-    const secondMsgLog = getAgentResponse(messages, 'second message');
-    expect(secondMsgLog).toBeDefined();
-    expect(secondMsgLog.content).toContain('[DEBUG NEW ]');
-
-    // It should NOT be appended.
-    const secondMsgAppended = messages.find(
-      (m: any) =>
-        m.content && m.content.includes('second message') && m.content.includes('[DEBUG APPEND ')
-    );
-    expect(secondMsgAppended).toBeUndefined();
-  }, 20000);
-
-  it('(2) sending a message, then sending /new, then sending another message. after the timeout for the first message, that session should be told to save; but the current session should still be saved. the user should NOT be sent a system message saying that a new session has started.', async () => {
-    // Send an initial message
-    await runCli(['messages', 'send', '--chat', 'test2', '--agent', 'test-agent', 'msg A']);
-
-    // Send /new
-    await runCli(['messages', 'send', '--chat', 'test2', '/new']);
-
-    // Send second message immediately
-    await runCli(['messages', 'send', '--chat', 'test2', 'msg B']);
-
-    // Wait 2 seconds (so we are at 2.5s since msg A, but 2s since msg B)
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    // Send a keep-alive message so the new session's timeout is reset to 5s from now!
-    await runCli(['messages', 'send', '--chat', 'test2', 'msg KEEP ALIVE']);
-
-    // Wait another 3.5 seconds.
-    // Now we are at ~6s since msg A (timeout FIRED).
-    // We are at ~3.5s since msg KEEP ALIVE (timeout NOT FIRED).
-    await new Promise((resolve) => setTimeout(resolve, 3500));
-    const { stdout: history, stderr: err } = await runCli([
-      'messages',
-      'tail',
-      '--chat',
-      'test2',
-      '-n',
-      '30',
-      '--json',
-    ]);
-    if (history.trim() === '') console.error('TEST 2 RAW STDOUT EMPTY', err);
-
-    // The user should NOT be sent a system message saying that a new session has started.
-    expect(history).not.toContain('[@clawmini/session-timeout] Starting a fresh session...');
-
-    // But the background timeout prompt SHOULD have been sent for msg A!
-    const messages = getMessages(history);
-    if (messages.length === 0) console.error('TEST 2 NO PARSED MESSAGES. RAW:', history);
-
-    // Find msg KEEP ALIVE and get its session ID
-    const keepAliveLog = getAgentResponse(messages, 'msg KEEP ALIVE');
-    expect(keepAliveLog).toBeDefined();
-    const keepAliveSessionId = keepAliveLog.content.match(/\[DEBUG APPEND (.*?)\]/)?.[1];
-    expect(keepAliveSessionId).toBeTruthy();
-
-    const backgroundPrompts = messages.filter(
-      (m: any) => m.content && m.content.includes('This chat session has ended.')
-    );
-    // We expect exactly ONE background prompt (for the old session)
-    if (backgroundPrompts.length === 0)
-      console.error('FAILED TO FIND BACKGROUND PROMPT in:', messages);
-    expect(backgroundPrompts.length).toBeGreaterThanOrEqual(1);
-
-    // Send a third message to check that the current session wasn't blown away by the timeout from msg A.
-    await runCli(['messages', 'send', '--chat', 'test2', 'msg C']);
-    const { stdout: history2 } = await runCli([
-      'messages',
-      'tail',
-      '--chat',
-      'test2',
-      '-n',
-      '20',
-      '--json',
-    ]);
-
-    const messages2 = getMessages(history2);
-
-    const appendedMsgLog = getAgentResponse(messages2, 'msg C');
-    if (!appendedMsgLog) console.error('FAILED TO FIND APPENDED MSG LOG in:', messages2);
-    expect(appendedMsgLog).toBeDefined();
-    expect(appendedMsgLog.content).toContain(`[DEBUG APPEND ${keepAliveSessionId}]`);
-  }, 20000);
-});

package/src/cli/e2e/slash-new.test.ts

@@ -1,93 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-slash-new');
-
-describe('/new Command E2E', () => {
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init', '--agent', 'test-agent', '--agent-template', 'debug']);
-
-    const agentSettingsPath = path.join(
-      e2eDir,
-      '.clawmini',
-      'agents',
-      'test-agent',
-      'settings.json'
-    );
-    const agentSettings = JSON.parse(fs.readFileSync(agentSettingsPath, 'utf8'));
-    agentSettings.commands.new = 'echo "[DEBUG NEW $SESSION_ID] $CLAW_CLI_MESSAGE"';
-    agentSettings.commands.append = 'echo "[DEBUG APPEND $SESSION_ID] $CLAW_CLI_MESSAGE"';
-    fs.writeFileSync(agentSettingsPath, JSON.stringify(agentSettings, null, 2));
-  }, 30000);
-
-  afterAll(async () => {
-    await teardownE2E();
-  }, 30000);
-
-  function getMessages(stdout: string) {
-    return stdout
-      .trim()
-      .split('\n')
-      .filter((l) => l.trim().startsWith('{') && l.trim().endsWith('}'))
-      .map((l) => {
-        try {
-          return JSON.parse(l);
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
-  }
-
-  function getAgentResponse(messages: any[], userMessage: string) {
-    return messages.find(
-      (m) => m.content && m.content.includes(userMessage) && m.content.includes('[DEBUG')
-    );
-  }
-
-  it('should reset the session ID when /new is sent', async () => {
-    // 1. Send an initial message
-    const { code } = await runCli(['messages', 'send', 'message 1']);
-    expect(code).toBe(0);
-
-    // 2. Send another message to get an append
-    await runCli(['messages', 'send', 'message 2']);
-
-    // Get the first session ID
-    const { stdout: history } = await runCli(['messages', 'tail', '-n', '30', '--json']);
-    let messages = getMessages(history);
-
-    const msg1Log = getAgentResponse(messages, 'message 1');
-    expect(msg1Log).toBeDefined();
-    const msg2Log = getAgentResponse(messages, 'message 2');
-    expect(msg2Log).toBeDefined();
-
-    // message 2 should be appended to the first session
-    const firstSessionMatch = msg2Log.content.match(/\[DEBUG APPEND (.*?)\]/);
-    expect(firstSessionMatch).toBeTruthy();
-    const firstSessionId = firstSessionMatch[1];
-    expect(firstSessionId).toBeTruthy();
-
-    // 3. Send /new
-    await runCli(['messages', 'send', '/new']);
-
-    // 4. Send a third message
-    await runCli(['messages', 'send', 'message 3']);
-
-    // 5. Check the session ID of the third message
-    const { stdout: history2 } = await runCli(['messages', 'tail', '-n', '30', '--json']);
-    messages = getMessages(history2);
-
-    const msg3Log = getAgentResponse(messages, 'message 3');
-    expect(msg3Log).toBeDefined();
-
-    // Because it's a new session, it should use the 'new' command
-    expect(msg3Log.content).toContain('[DEBUG NEW ]');
-
-    // It should NOT be appended
-    expect(msg3Log.content).not.toContain('[DEBUG APPEND');
-  }, 30000);
-});