clawmini 0.0.8 → 0.0.9

package/e2e/cli/basic.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+describe('E2E Basic Tests', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-basic');
+    await env.setup();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('should run init and initialize settings', async () => {
+    const { stdout, code } = await env.init();
+
+    expect(code).toBe(0);
+    expect(stdout).toContain('Initialized .clawmini/settings.json');
+
+    expect(fs.existsSync(env.getClawminiPath('settings.json'))).toBe(true);
+  });
+
+  it('should create, list, set-default and delete chats', async () => {
+    const { stdout: stdoutAdd, code: codeAdd } = await env.runCli(['chats', 'add', 'test-chat']);
+    expect(codeAdd).toBe(0);
+    expect(stdoutAdd).toContain('Chat test-chat created successfully.');
+
+    expect(fs.existsSync(env.getChatPath('test-chat', 'chat.jsonl'))).toBe(true);
+
+    const { stdout: stdoutList1 } = await env.runCli(['chats', 'list']);
+    expect(stdoutList1).toContain('- test-chat');
+
+    const { stdout: stdoutSetDefault } = await env.runCli(['chats', 'set-default', 'test-chat']);
+    expect(stdoutSetDefault).toContain('Default chat set to test-chat.');
+
+    const { stdout: stdoutList2 } = await env.runCli(['chats', 'list']);
+    expect(stdoutList2).toContain('- test-chat *');
+
+    const { stdout: stdoutDelete } = await env.runCli(['chats', 'delete', 'test-chat']);
+    expect(stdoutDelete).toContain('Chat test-chat deleted successfully.');
+    expect(fs.existsSync(env.getChatPath('test-chat'))).toBe(false);
+  }, 15000);
+});

package/{src/cli/e2e → e2e/cli}/export-lite.test.ts

@@ -1,21 +1,25 @@
 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-export-lite');
+import { TestEnvironment } from '../_helpers/test-environment.js';
 
 describe('E2E Export Lite Tests', () => {
-  beforeAll(setupE2E, 30000);
-  afterAll(teardownE2E, 30000);
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-export-lite');
+    await env.setup();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
 
   it('should export clawmini-lite script to current directory', async () => {
     // Current directory context in runCli is e2eDir
-    const { stdout, code } = await runCli(['export-lite']);
+    const { stdout, code } = await env.runCli(['export-lite']);
     expect(code).toBe(0);
     expect(stdout).toContain('Successfully exported clawmini-lite to');
 
-    const expectedPath = path.join(e2eDir, 'clawmini-lite.js');
+    const expectedPath = path.join(env.e2eDir, 'clawmini-lite.js');
     expect(fs.existsSync(expectedPath)).toBe(true);
 
     const content = fs.readFileSync(expectedPath, 'utf8');
@@ -23,25 +27,25 @@ describe('E2E Export Lite Tests', () => {
   });
 
   it('should export clawmini-lite script to stdout', async () => {
-    const { stdout, code } = await runCli(['export-lite', '--stdout']);
+    const { stdout, code } = await env.runCli(['export-lite', '--stdout']);
     expect(code).toBe(0);
     expect(stdout).toContain('clawmini-lite - A standalone client');
     expect(stdout).not.toContain('Successfully exported clawmini-lite to');
   });
 
   it('should export clawmini-lite script to specified file path', async () => {
-    const customPath = path.join(e2eDir, 'custom-lite.js');
-    const { stdout, code } = await runCli(['export-lite', '--out', customPath]);
+    const customPath = path.join(env.e2eDir, 'custom-lite.js');
+    const { stdout, code } = await env.runCli(['export-lite', '--out', customPath]);
     expect(code).toBe(0);
     expect(stdout).toContain(`Successfully exported clawmini-lite to ${customPath}`);
     expect(fs.existsSync(customPath)).toBe(true);
   });
 
   it('should export clawmini-lite script to specified directory path', async () => {
-    const customDir = path.join(e2eDir, 'custom-dir');
+    const customDir = path.join(env.e2eDir, 'custom-dir');
     fs.mkdirSync(customDir);
 
-    const { stdout, code } = await runCli(['export-lite', '--out', customDir]);
+    const { stdout, code } = await env.runCli(['export-lite', '--out', customDir]);
     expect(code).toBe(0);
 
     const expectedPath = path.join(customDir, 'clawmini-lite.js');

package/e2e/cli/init-gitignore.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execFileSync, spawnSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const TEMPLATE_PATH = path.join(REPO_ROOT, 'docs', 'backups', 'clawmini.gitignore');
+
+// (path relative to .clawmini/, expected to be ignored by the allow-list)
+const cases: Array<[string, boolean]> = [
+  // Safe — must NOT be ignored
+  ['settings.json', false],
+  ['policies.json', false],
+  ['policy-scripts/run-host.js', false],
+  ['commands/foo.md', false],
+  ['templates/my-agent/settings.json', false],
+  ['chats/default/settings.json', false],
+  ['agents/bob/settings.json', false],
+  ['agents/bob/installed-files.json', false],
+  ['environments/macos/env.json', false],
+  ['adapters/discord/state.json', false],
+
+  // Sensitive — MUST be ignored
+  ['chats/default/chat.jsonl', true],
+  ['adapters/discord/config.json', true],
+  ['adapters/google-chat/config.json', true],
+  ['adapters/google-chat/state.json', true],
+  ['agents/bob/sessions/abc/settings.json', true],
+  ['agents/bob/tmp/stdout-x.txt', true],
+  ['daemon.log', true],
+  ['daemon.sock', true],
+  ['supervisor.pid', true],
+  ['logs/web.log', true],
+  ['tmp/requests/r.json', true],
+  ['tmp/snapshots/x.txt', true],
+  ['settings.json.1234.deadbeef.tmp', true],
+];
+
+describe('clawmini init installs backup .gitignore', () => {
+  let env: TestEnvironment;
+  let clawminiDir: string;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-init-gitignore');
+    await env.setup();
+
+    const { code, stdout } = await env.init();
+    expect(code).toBe(0);
+    expect(stdout).toContain('Initialized .clawmini/.gitignore');
+
+    clawminiDir = env.getClawminiPath();
+    execFileSync('git', ['init', '--quiet'], { cwd: clawminiDir });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('writes .clawmini/.gitignore matching the docs template', () => {
+    const installed = fs.readFileSync(env.getClawminiPath('.gitignore'), 'utf8');
+    const template = fs.readFileSync(TEMPLATE_PATH, 'utf8');
+    expect(installed).toBe(template);
+  });
+
+  for (const [relPath, expectIgnored] of cases) {
+    it(`${expectIgnored ? 'ignores' : 'tracks'} ${relPath}`, () => {
+      // Materialize the file so git's directory-traversal rules see it the
+      // same way they would in a real workspace. (Allow-list `.gitignore`
+      // patterns can otherwise behave differently for non-existent paths.)
+      const fullPath = path.join(clawminiDir, relPath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      if (!fs.existsSync(fullPath)) fs.writeFileSync(fullPath, '');
+
+      const result = spawnSync('git', ['check-ignore', '-q', '--', relPath], {
+        cwd: clawminiDir,
+      });
+
+      // git check-ignore exit codes:
+      //   0 = path is ignored
+      //   1 = path is NOT ignored
+      // Anything else is an error.
+      expect([0, 1]).toContain(result.status);
+      const actuallyIgnored = result.status === 0;
+      expect(actuallyIgnored).toBe(expectIgnored);
+    });
+  }
+});

package/e2e/cli/init.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+describe('initCmd with flags', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-init');
+    await env.setup();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('should fail if --agent-template is provided without --agent', async () => {
+    const { stderr, code } = await env.runCli(['init', '--agent-template', 'bob']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('--agent-template cannot be used without --agent');
+  });
+
+  it('should fail with invalid agent id', async () => {
+    const { stderr, code } = await env.runCli(['init', '--agent', 'invalid/id']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('Invalid agent ID');
+  });
+
+  it('should run init, create agent, and set default chat', async () => {
+    const { stdout, stderr, code } = await env.runCli(['init', '--agent', 'test-agent']);
+
+    expect(stderr).toBe('');
+    expect(code).toBe(0);
+    expect(stdout).toContain('Initialized .clawmini/settings.json');
+    expect(stdout).toContain('Agent test-agent created successfully');
+    expect(stdout).toContain('Default chat set to test-agent');
+
+    expect(fs.existsSync(env.getClawminiPath('settings.json'))).toBe(true);
+
+    const settings = env.getSettings();
+    expect((settings.chats as Record<string, unknown> | undefined)?.defaultId).toBe('test-agent');
+
+    expect(fs.existsSync(env.getAgentPath('test-agent', 'settings.json'))).toBe(true);
+    expect(fs.existsSync(env.getChatPath('test-agent', 'settings.json'))).toBe(true);
+
+    // Verify skills were copied to the agent's default skills directory (.agents/skills)
+    const skillsDir = path.join(env.e2eDir, 'test-agent', '.agents', 'skills');
+    expect(fs.existsSync(skillsDir)).toBe(true);
+    // Check for at least one skill inside
+    const skillsList = fs.readdirSync(skillsDir);
+    expect(skillsList.length).toBeGreaterThan(0);
+  });
+
+  it.skip('should run init and enable an environment', async () => {
+    const clawminiDir = env.getClawminiPath();
+    if (fs.existsSync(clawminiDir)) {
+      fs.rmSync(clawminiDir, { recursive: true, force: true });
+    }
+
+    const { stdout, stderr, code } = await env.runCli(['init', '--environment', 'macos']);
+
+    expect(stderr).toBe('');
+    expect(code).toBe(0);
+    expect(stdout).toContain('Initialized .clawmini/settings.json');
+    expect(stdout).toContain("Copied environment template 'macos'");
+    expect(stdout).toContain("Enabled environment 'macos' for path './'");
+
+    expect(fs.existsSync(env.getClawminiPath('settings.json'))).toBe(true);
+
+    const settings = env.getSettings();
+    expect(
+      (settings.environments as Record<string, unknown> | undefined)?.['./']
+    ).toBe('macos');
+
+    expect(fs.existsSync(env.getClawminiPath('environments', 'macos'))).toBe(true);
+  });
+});

package/e2e/cli/messages.test.ts

@@ -0,0 +1,363 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  commandMatching,
+  type SystemMessage,
+  type ToolMessage,
+} from '../_helpers/test-environment.js';
+
+describe('E2E Messages Tests', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-messages');
+    await env.setup();
+    await env.init();
+    await env.up();
+  }, 30000);
+
+  afterAll(async () => {
+    await env.teardown();
+  }, 30000);
+
+  afterEach(() => env.disconnectAll());
+
+  it('should send a message via the daemon', async () => {
+    chat = await env.connect('default');
+
+    const { stdout, code } = await env.runCli(['messages', 'send', 'e2e test message']);
+
+    expect(code).toBe(0);
+    expect(stdout).toContain('Message sent successfully.');
+
+    await chat.waitForMessage((m) => m.content === 'e2e test message');
+  });
+
+  it('should send a message to a specific chat', async () => {
+    await env.addChat('specific-chat', 'default');
+    chat = await env.connect('specific-chat');
+
+    const { stdout, code } = await env.runCli([
+      'messages',
+      'send',
+      'specific chat message',
+      '--chat',
+      'specific-chat',
+    ]);
+
+    expect(code).toBe(0);
+    expect(stdout).toContain('Message sent successfully.');
+
+    await chat.waitForMessage((m) => m.content === 'specific chat message');
+  });
+
+  it('should send a message with a specific agent and persist it', async () => {
+    await env.runCli(['agents', 'add', 'custom-agent', '--env', 'CUSTOM_VAR=HELLO']);
+    await env.addChat('agent-chat', 'default'); // default agent initially
+    chat = await env.connect('agent-chat');
+
+    const { stdout, code } = await env.runCli([
+      'messages',
+      'send',
+      'hello custom agent',
+      '--chat',
+      'agent-chat',
+      '--agent',
+      'custom-agent',
+    ]);
+
+    expect(code).toBe(0);
+    expect(stdout).toContain('Message sent successfully.');
+
+    const chatSettings = env.getChatSettings('agent-chat');
+    expect(chatSettings.defaultAgent).toBe('custom-agent');
+
+    const { stderr: stderrFail, code: codeFail } = await env.runCli([
+      'messages',
+      'send',
+      'fail msg',
+      '--chat',
+      'agent-chat',
+      '--agent',
+      'non-existent-agent',
+    ]);
+
+    expect(codeFail).toBe(1);
+    expect(stderrFail).toContain("Error: Agent 'non-existent-agent' not found.");
+  });
+
+  it('should send a message with a file attachment', async () => {
+    await env.addChat('file-chat', 'default');
+    chat = await env.connect('file-chat');
+
+    const testFilePath = path.resolve(env.e2eDir, 'test-attach.txt');
+    fs.writeFileSync(testFilePath, 'file content');
+
+    const { stdout, code } = await env.runCli([
+      'messages',
+      'send',
+      'here is a file',
+      '--chat',
+      'file-chat',
+      '--file',
+      testFilePath,
+    ]);
+
+    expect(code).toBe(0);
+    expect(stdout).toContain('Message sent successfully.');
+
+    await chat.waitForMessage(
+      (m) =>
+        !!(m.content && m.content.includes('here is a file') && m.content.includes('test-attach'))
+    );
+  });
+
+  it('should view history with tail and --json flag', async () => {
+    await env.addChat('tail-chat', 'default');
+    chat = await env.connect('tail-chat');
+
+    const { code: sendCode } = await env.runCli([
+      'messages',
+      'send',
+      'tail chat message',
+      '--chat',
+      'tail-chat',
+    ]);
+    expect(sendCode).toBe(0);
+
+    await chat.waitForMessage((m) => m.content === 'tail chat message');
+
+    const { stdout, code } = await env.runCli(['messages', 'tail', '--chat', 'tail-chat']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('[USER]');
+    expect(stdout).toContain('tail chat message');
+
+    const { stdout: jsonStdout, code: jsonCode } = await env.runCli([
+      'messages',
+      'tail',
+      '--json',
+      '--chat',
+      'tail-chat',
+    ]);
+    expect(jsonCode).toBe(0);
+    expect(jsonStdout).toContain('"role":"user"');
+    expect(jsonStdout).toContain('"content":"tail chat message"');
+  });
+
+  it('should maintain atomic ordering of user and log messages with --no-wait', async () => {
+    await env.addAgent('order-agent');
+    env.writeAgentSettings('order-agent', {
+      commands: { new: 'sleep 1 && echo $CLAW_CLI_MESSAGE' },
+    });
+
+    await env.addChat('order-chat', 'order-agent');
+    chat = await env.connect('order-chat');
+
+    await env.runCli(['messages', 'send', 'first', '--chat', 'order-chat', '--no-wait']);
+    await env.runCli(['messages', 'send', 'second', '--chat', 'order-chat', '--no-wait']);
+
+    // We wait for the second command log to arrive.
+    // The messages buffer will collect all messages as they arrive via SSE.
+    await chat.waitForMessage(
+      (m) => !!(m.role === 'command' && m.content && m.content.trim() === 'second')
+    );
+
+    // Retrieve the stored messages via trpcClient to ensure final ordering on disk
+    const storedMessages = await env.trpcClient!.getMessages.query({ chatId: 'order-chat' });
+
+    const commandLogs = storedMessages.filter((m) => m.role === 'command');
+    expect(commandLogs).toHaveLength(2);
+    expect(storedMessages[0]!.role).toBe('user');
+    expect(storedMessages[0]!.content).toBe('first');
+    expect(storedMessages[1]!.role).toBe('user');
+    expect(storedMessages[1]!.content).toBe('second');
+    expect(commandLogs[0]!.content.trim()).toBe('first');
+    expect(commandLogs[1]!.content.trim()).toBe('second');
+  }, 10000);
+
+  it('should no-op (no command log, no agent reply) when the message is whitespace-only', async () => {
+    await env.addAgent('empty-msg-agent');
+    env.writeAgentSettings('empty-msg-agent', {
+      commands: { new: 'echo should-not-run' },
+    });
+    await env.addChat('empty-msg-chat', 'empty-msg-agent');
+    chat = await env.connect('empty-msg-chat');
+
+    const { code } = await env.runCli([
+      'messages',
+      'send',
+      '   ',
+      '--chat',
+      'empty-msg-chat',
+    ]);
+    expect(code).toBe(0);
+
+    // The user message is still persisted before the short-circuit,
+    await chat.waitForMessage((m) => m.role === 'user' && m.content.trim() === '');
+    // but handleMessage bails before the agent runs: no command log, no reply.
+    await new Promise((r) => setTimeout(r, 500));
+    expect(chat.messageBuffer.some((m) => m.role === 'command' || m.role === 'agent')).toBe(
+      false
+    );
+  });
+
+  it('should handle full multi-message session workflow (extraction & append)', async () => {
+    await env.addAgent('workflow-agent');
+    env.writeAgentSettings('workflow-agent', {
+      commands: {
+        new: 'echo "NEW $CLAW_CLI_MESSAGE" && echo "ERR NEW" >&2',
+        append: 'echo "APPEND $CLAW_CLI_MESSAGE" && echo "ERR APPEND" >&2',
+        getSessionId: 'echo "session-123"',
+        getMessageContent: 'sed "s/^/EXTRACTED-/"',
+      },
+    });
+
+    await env.addChat('workflow-chat', 'workflow-agent');
+    chat = await env.connect('workflow-chat');
+
+    await env.runCli(['messages', 'send', 'msg-1', '--chat', 'workflow-chat']);
+
+    const log1 = await chat.waitForMessage(
+      commandMatching((m) => m.command.includes('ERR NEW'))
+    );
+    expect(log1.command).toBe('echo "NEW $CLAW_CLI_MESSAGE" && echo "ERR NEW" >&2');
+    expect(log1.content).toContain('EXTRACTED-NEW msg-1');
+    expect(log1.stderr).toContain('ERR NEW');
+    expect(log1.stdout).toContain('NEW msg-1');
+
+    const sessionSettings = env.getSessionSettings('workflow-agent', 'default');
+    expect(
+      (sessionSettings.env as Record<string, unknown> | undefined)?.SESSION_ID
+    ).toBe('session-123');
+
+    await env.runCli(['messages', 'send', 'msg-2', '--chat', 'workflow-chat']);
+
+    const log2 = await chat.waitForMessage(
+      commandMatching((m) => m.command.includes('ERR APPEND'))
+    );
+    expect(log2.command).toBe('echo "APPEND $CLAW_CLI_MESSAGE" && echo "ERR APPEND" >&2');
+    expect(log2.content).toContain('EXTRACTED-APPEND msg-2');
+    expect(log2.stderr).toContain('ERR APPEND');
+    expect(log2.stdout).toContain('APPEND msg-2');
+
+    // Break the extraction command and verify the failure is reported
+    env.updateAgentSettings('workflow-agent', {
+      commands: { getMessageContent: 'echo "EXTRACTION_FAIL" >&2 && exit 1' },
+    });
+
+    await env.runCli(['messages', 'send', 'msg-3', '--chat', 'workflow-chat']);
+
+    const log3 = await chat.waitForMessage(
+      commandMatching((m) => m.stderr.includes('EXTRACTION_FAIL'))
+    );
+    expect(log3.stdout).toContain('APPEND msg-3');
+    expect(log3.stderr).toContain('ERR APPEND');
+    expect(log3.stderr).toContain('getMessageContent failed: EXTRACTION_FAIL');
+  }, 15000);
+
+  it('should tail legacy chat entries that predate the sessionId field', async () => {
+    await env.addChat('legacy-chat', 'default');
+
+    const ts = new Date().toISOString();
+    const legacyLines = [
+      { id: 'u1', role: 'user', content: 'legacy user message', timestamp: ts },
+      {
+        id: 'c1',
+        role: 'command',
+        content: 'legacy cmd output',
+        messageId: 'u1',
+        command: 'echo legacy',
+        cwd: '/tmp',
+        stdout: 'legacy',
+        stderr: '',
+        exitCode: 0,
+        timestamp: ts,
+      },
+      { id: 'a1', role: 'agent', content: 'legacy agent reply', timestamp: ts },
+    ];
+    const chatFile = env.getChatPath('legacy-chat', 'chat.jsonl');
+    fs.writeFileSync(chatFile, legacyLines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+
+    const { stdout, code } = await env.runCli(['messages', 'tail', '--chat', 'legacy-chat']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('legacy user message');
+    expect(stdout).toContain('legacy agent reply');
+
+    const { stdout: jsonStdout, code: jsonCode } = await env.runCli([
+      'messages',
+      'tail',
+      '--json',
+      '--chat',
+      'legacy-chat',
+    ]);
+    expect(jsonCode).toBe(0);
+    expect(jsonStdout).toContain('"content":"legacy user message"');
+    expect(jsonStdout).toContain('"content":"legacy cmd output"');
+    expect(jsonStdout).toContain('"content":"legacy agent reply"');
+  });
+});
+
+describe('E2E Messages sessionId Persistence', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-msg-sid');
+    await env.setup();
+    await env.setupSubagentEnv();
+    await env.getAgentCredentials();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('stamps sessionId on user, command, agent, tool, and cron system messages', async () => {
+    chat = await env.connect('__creds__');
+
+    await env.sendMessage('echo hello-session', {
+      chat: '__creds__',
+      agent: 'debug-agent',
+    });
+
+    const userMsg = await chat.waitForMessage(
+      (m) => m.role === 'user' && m.content === 'echo hello-session'
+    );
+    const cmdMsg = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('echo hello-session'))
+    );
+    const replyMsg = await chat.waitForMessage((m) => m.role === 'agent');
+
+    expect(userMsg.sessionId).toBeTruthy();
+    expect(cmdMsg.sessionId).toBe(userMsg.sessionId);
+    expect(replyMsg.sessionId).toBe(userMsg.sessionId);
+
+    await env.runLite(['tool', 'session-tool', JSON.stringify({ probe: 1 })]);
+    const toolMsg = await chat.waitForMessage(
+      (m): m is ToolMessage => m.role === 'tool' && m.name === 'session-tool'
+    );
+    expect(toolMsg.sessionId).toBe(userMsg.sessionId);
+
+    await env.runLite([
+      'jobs', 'add', 'session-id-cron',
+      '--at', '1s',
+      '--message', 'echo session-cron-fired',
+      '--session', 'new',
+    ]);
+    const sysMsg = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' && (m as SystemMessage).event === 'cron',
+      10000
+    );
+    expect(sysMsg.sessionId).toBeTruthy();
+
+    const cronCmd = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('echo session-cron-fired')),
+      10000
+    );
+    expect(cronCmd.sessionId).toBe(sysMsg.sessionId);
+  }, 45000);
+});