clawmini 0.0.7 → 0.0.9

package/e2e/cli/serve.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+async function waitUntil(
+  cond: () => boolean,
+  timeoutMs: number,
+  intervalMs = 100
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return cond();
+}
+
+describe('clawmini serve (detached) + down', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-serve');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('starts the supervisor in the background and writes a pid file', async () => {
+    const { code, stdout } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('Started clawmini supervisor in background');
+
+    const pidPath = env.getClawminiPath('supervisor.pid');
+    expect(await waitUntil(() => fs.existsSync(pidPath), 5000)).toBe(true);
+
+    const socketPath = env.getClawminiPath('daemon.sock');
+    expect(await waitUntil(() => fs.existsSync(socketPath), 10000)).toBe(true);
+  }, 30000);
+
+  it('refuses to start a second supervisor while one is running', async () => {
+    const { code, stderr } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('already running');
+  }, 15000);
+
+  it('clawmini down stops the supervisor and clears the socket + pid file', async () => {
+    const { code } = await env.runCli(['down']);
+    expect(code).toBe(0);
+
+    const pidPath = env.getClawminiPath('supervisor.pid');
+    const socketPath = env.getClawminiPath('daemon.sock');
+    expect(await waitUntil(() => !fs.existsSync(pidPath), 10000)).toBe(true);
+    expect(await waitUntil(() => !fs.existsSync(socketPath), 10000)).toBe(true);
+  }, 30000);
+
+  it('writes daemon output to .clawmini/logs/daemon.log', () => {
+    const logPath = env.getClawminiPath('logs', 'daemon.log');
+    expect(fs.existsSync(logPath)).toBe(true);
+    const content = fs.readFileSync(logPath, 'utf-8');
+    expect(content).toContain('Daemon initialized and listening');
+  });
+
+  it('clawmini logs --service daemon prints prefixed output', async () => {
+    const { code, stdout } = await env.runCli(['logs', '--service', 'daemon']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('[daemon]');
+    expect(stdout).toContain('Daemon initialized and listening');
+  });
+
+  it('clawmini down is a no-op when nothing is running', async () => {
+    const { stdout, code } = await env.runCli(['down']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('Daemon is not running');
+  });
+});

package/{src/cli/e2e → e2e/cli}/skills.test.ts

@@ -1,18 +1,19 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { createE2EContext } from './utils.js';
-
-const { runCli, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-skills');
+import { TestEnvironment } from '../_helpers/test-environment.js';
 
 describe('E2E Skills Tests', () => {
+  let env: TestEnvironment;
+
   beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init', '--agent', 'test-agent']);
+    env = new TestEnvironment('e2e-tmp-skills');
+    await env.setup();
+    await env.runCli(['init', '--agent', 'test-agent']);
   }, 30000);
 
-  afterAll(teardownE2E, 30000);
+  afterAll(() => env.teardown(), 30000);
 
   it('should list available template skills', async () => {
-    const { stdout, code, stderr } = await runCli(['skills', 'list']);
+    const { stdout, code, stderr } = await env.runCli(['skills', 'list']);
     expect(code).toBe(0);
     // As it reads from the internal templates/skills directory,
     // it should at least output one of the default template skills, or "No skills found."
@@ -22,7 +23,7 @@ describe('E2E Skills Tests', () => {
   });
 
   it('should add a specific skill', async () => {
-    const { stdout, code, stderr } = await runCli([
+    const { stdout, code, stderr } = await env.runCli([
       'skills',
       'add',
       'skill-creator',
@@ -35,14 +36,14 @@ describe('E2E Skills Tests', () => {
   });
 
   it('should add all skills when no skill name is provided', async () => {
-    const { stdout, code, stderr } = await runCli(['skills', 'add', '--agent', 'test-agent']);
+    const { stdout, code, stderr } = await env.runCli(['skills', 'add', '--agent', 'test-agent']);
     expect(stderr).toBe('');
     expect(code).toBe(0);
     expect(stdout).toContain('Successfully added all skills to agent');
   });
 
   it('should handle adding an invalid skill gracefully', async () => {
-    const { code, stderr } = await runCli([
+    const { code, stderr } = await env.runCli([
       'skills',
       'add',
       'invalid-skill-name-123',

package/{src/cli/e2e → e2e/daemon}/daemon.test.ts

@@ -1,22 +1,30 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
-import { getSocketPath } from '../../shared/workspace.js';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, binPath, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-daemon');
+import { getSocketPath } from '../../src/shared/workspace.js';
+import {
+  TestEnvironment,
+  findFreePort,
+  type ChatSubscription,
+} from '../_helpers/test-environment.js';
+import { commandWith } from '../_helpers/test-environment.js';
 
 describe('E2E Daemon and Web Tests', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
   beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
+    env = new TestEnvironment('e2e-daemon');
+    await env.setup();
+    await env.init();
   }, 30000);
 
-  afterAll(teardownE2E, 30000);
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
 
   it('should explicitly start the daemon via up command', async () => {
-    const { stdout, code } = await runCli(['up']);
+    const { stdout, code } = await env.runCli(['up']);
     expect(code).toBe(0);
     // Since the daemon is likely running from previous tests or init, it should say so
     // or it will start successfully.
@@ -24,29 +32,29 @@ describe('E2E Daemon and Web Tests', () => {
   });
 
   it('should successfully shut down the daemon', async () => {
-    const { stdout, code } = await runCli(['down']);
+    const { stdout, code } = await env.runCli(['down']);
 
     expect(code).toBe(0);
     expect(stdout).toContain('Successfully shut down clawmini daemon.');
 
     await new Promise((resolve) => setTimeout(resolve, 500));
 
-    const socketPath = getSocketPath(e2eDir);
+    const socketPath = getSocketPath(env.e2eDir);
     expect(fs.existsSync(socketPath)).toBe(false);
 
-    const { stdout: stdoutAgain, code: codeAgain } = await runCli(['down']);
+    const { stdout: stdoutAgain, code: codeAgain } = await env.runCli(['down']);
     expect(codeAgain).toBe(0);
     expect(stdoutAgain).toContain('Daemon is not running.');
 
-    const { stdout: stdoutUp, code: codeUp } = await runCli(['up']);
+    const { stdout: stdoutUp, code: codeUp } = await env.runCli(['up']);
     expect(codeUp).toBe(0);
     expect(stdoutUp).toContain('Successfully started clawmini daemon.');
   }, 15000);
 
   it('should run web command and serve static files', async () => {
-    const webPort = 8081;
-    const child = spawn('node', [binPath, 'web', '--port', webPort.toString()], {
-      cwd: e2eDir,
+    const webPort = await findFreePort();
+    const child = spawn('node', [env.binPath, 'web', '--port', webPort.toString()], {
+      cwd: env.e2eDir,
       env: { ...process.env },
     });
 
@@ -83,7 +91,7 @@ describe('E2E Daemon and Web Tests', () => {
     const html404 = await res404.text();
     expect(html404.toLowerCase()).toContain('<!doctype html>');
 
-    await runCli(['chats', 'add', 'api-test-chat']);
+    await env.addChat('api-test-chat');
 
     const resChats = await fetch(`http://127.0.0.1:${webPort}/api/chats`);
     expect(resChats.status).toBe(200);
@@ -144,7 +152,7 @@ describe('E2E Daemon and Web Tests', () => {
     const reader = sseResponse.body.getReader();
     const decoder = new TextDecoder();
 
-    const chatLogPath = path.resolve(e2eDir, '.clawmini/chats/api-test-chat/chat.jsonl');
+    const chatLogPath = path.resolve(env.e2eDir, '.clawmini/chats/api-test-chat/chat.jsonl');
     const mockMessage = {
       id: 'mock-1',
       role: 'user',
@@ -220,203 +228,57 @@ describe('E2E Daemon and Web Tests', () => {
   }, 30000);
 
   it('should optionally start an HTTP API server for the daemon when configured', async () => {
-    await runCli(['down']);
-
-    const settingsPath = path.resolve(e2eDir, '.clawmini/settings.json');
-    let originalSettings = '{}';
-    if (fs.existsSync(settingsPath)) {
-      originalSettings = fs.readFileSync(settingsPath, 'utf8');
-    }
+    await env.runCli(['down']);
+    const originalSettings = env.getSettings();
 
-    fs.writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        ...JSON.parse(originalSettings),
-        api: { host: '127.0.0.1', port: 3005 },
-      })
-    );
+    const apiPort = await findFreePort();
+    env.writeSettings({ ...originalSettings, api: { host: '127.0.0.1', port: apiPort } });
 
-    const { stdout, code } = await runCli(['up']);
+    const { stdout, code } = await env.runCli(['up']);
     expect(code).toBe(0);
     expect(stdout).toContain('Successfully started clawmini daemon.');
 
     await new Promise((resolve) => setTimeout(resolve, 500));
 
-    const res = await fetch('http://127.0.0.1:3005/ping');
+    const res = await fetch(`http://127.0.0.1:${apiPort}/ping`);
     expect(res.status).toBe(200);
     const data = (await res.json()) as { result: { data: { status: string } } };
     expect(data.result.data.status).toBe('ok');
 
-    await runCli(['down']);
-    fs.writeFileSync(settingsPath, originalSettings);
-    await runCli(['up']);
+    await env.runCli(['down']);
+    env.writeSettings(originalSettings);
+    await env.runCli(['up']);
   }, 15000);
 
   it('should inject CLAW_API_URL and CLAW_API_TOKEN into spawned agents when API is enabled', async () => {
-    await runCli(['down']);
-    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: 3006 },
-      })
-    );
-    await runCli(['up']);
-
-    await runCli(['agents', 'add', 'env-dumper', '--dir', 'env-dumper']);
-    const envDumperSettingsPath = path.resolve(e2eDir, '.clawmini/agents/env-dumper/settings.json');
-    fs.mkdirSync(path.dirname(envDumperSettingsPath), { recursive: true });
+    await env.runCli(['down']);
+    const originalSettings = env.getSettings();
 
-    // Create the actual agent working directory so spawn doesn't fail with ENOENT
-    const agentWorkingDir = path.resolve(e2eDir, 'env-dumper');
-    fs.mkdirSync(agentWorkingDir, { recursive: true });
-
-    fs.writeFileSync(
-      envDumperSettingsPath,
-      JSON.stringify({
-        commands: {
-          new: process.platform === 'win32' ? 'set' : 'env',
-        },
-      })
-    );
-
-    await runCli(['chats', 'add', 'env-chat']);
-    const { stdout, stderr, code } = await runCli([
-      'messages',
-      'send',
-      'dump it',
-      '--chat',
-      'env-chat',
-      '--agent',
-      'env-dumper',
-    ]);
-    if (code !== 0) {
-      console.error('send failed:', stdout, stderr);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    const chatLogPath = path.resolve(e2eDir, '.clawmini/chats/env-chat/chat.jsonl');
-    expect(fs.existsSync(chatLogPath)).toBe(true);
-    const chatLogContent = fs.readFileSync(chatLogPath, 'utf8');
-
-    if (!chatLogContent.includes('CLAW_API_URL')) {
-      console.error('CHAT LOG:', chatLogContent);
-    }
-
-    expect(chatLogContent).toContain('CLAW_API_URL=http://127.0.0.1:3006');
-    expect(chatLogContent).toContain('CLAW_API_TOKEN=');
-
-    await runCli(['down']);
-    fs.writeFileSync(settingsPath, originalSettings);
-    await runCli(['up']);
-  }, 15000);
-
-  it('should inject custom env vars and pointers when configured, and lite should work', async () => {
-    await runCli(['down']);
-    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: 3006 },
-      })
-    );
-    await runCli(['up']);
-
-    await runCli(['agents', 'add', 'custom-env-dumper', '--dir', 'custom-env-dumper']);
-    const agentSettingsPath = path.resolve(
-      e2eDir,
-      '.clawmini/agents/custom-env-dumper/settings.json'
-    );
-    fs.mkdirSync(path.dirname(agentSettingsPath), { recursive: true });
+    const apiPort = await findFreePort();
+    env.writeSettings({ ...originalSettings, api: { host: '127.0.0.1', port: apiPort } });
+    await env.runCli(['up']);
 
+    await env.runCli(['agents', 'add', 'env-dumper', '--dir', 'env-dumper']);
     // Create the actual agent working directory so spawn doesn't fail with ENOENT
-    const agentWorkingDir = path.resolve(e2eDir, 'custom-env-dumper');
-    fs.mkdirSync(agentWorkingDir, { recursive: true });
-
-    const dumperScript = process.platform === 'win32' ? 'set > env.txt' : 'env > env.txt';
-
-    fs.writeFileSync(
-      agentSettingsPath,
-      JSON.stringify({
-        apiTokenEnvVar: 'MY_CUSTOM_TOKEN',
-        apiUrlEnvVar: 'MY_CUSTOM_URL',
-        commands: {
-          new: dumperScript,
-        },
-      })
-    );
-
-    await runCli(['chats', 'add', 'custom-env-chat']);
-    const { stdout, stderr, code } = await runCli([
-      'messages',
-      'send',
-      'dump custom',
-      '--chat',
-      'custom-env-chat',
-      '--agent',
-      'custom-env-dumper',
-    ]);
-    if (code !== 0) {
-      console.error('send failed:', stdout, stderr);
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    const chatLogPath = path.resolve(e2eDir, '.clawmini/chats/custom-env-chat/chat.jsonl');
-    expect(fs.existsSync(chatLogPath)).toBe(true);
-
-    const envTxtPath = path.resolve(agentWorkingDir, 'env.txt');
-    expect(fs.existsSync(envTxtPath)).toBe(true);
-    const envContent = fs.readFileSync(envTxtPath, 'utf8');
-
-    expect(envContent).toContain('CLAW_LITE_API_VAR=MY_CUSTOM_TOKEN');
-    expect(envContent).toContain('CLAW_LITE_URL_VAR=MY_CUSTOM_URL');
-    expect(envContent).toContain('MY_CUSTOM_URL=http://127.0.0.1:3006');
-    expect(envContent).toContain('MY_CUSTOM_TOKEN=');
+    fs.mkdirSync(path.resolve(env.e2eDir, 'env-dumper'), { recursive: true });
+    env.writeAgentSettings('env-dumper', {
+      commands: {
+        new: process.platform === 'win32' ? 'set' : 'env',
+      },
+    });
 
-    // Verify lite works with the dynamically configured vars
-    const urlMatch = envContent.match(/MY_CUSTOM_URL=(.+)/);
-    const tokenMatch = envContent.match(/MY_CUSTOM_TOKEN=(.+)/);
+    await env.addChat('env-chat');
+    chat = await env.connect('env-chat');
+    await env.sendMessage('dump it', { chat: 'env-chat', agent: 'env-dumper' });
 
-    expect(urlMatch).toBeTruthy();
-    expect(tokenMatch).toBeTruthy();
+    const log = await chat.waitForMessage(commandWith('CLAW_API_URL='));
+    expect(log.stdout).toContain(`CLAW_API_URL=http://127.0.0.1:${apiPort}`);
+    expect(log.stdout).toMatch(/CLAW_API_TOKEN=.+/);
 
-    const envUrl = urlMatch![1]!.trim();
-    const envToken = tokenMatch![1]!.trim();
+    await env.disconnectAll();
 
-    const litePath = path.resolve(__dirname, '../../../dist/cli/lite.mjs');
-    const replyProcess = spawn('node', [litePath, 'reply', 'hello from custom env'], {
-      env: {
-        ...process.env,
-        MY_CUSTOM_URL: envUrl,
-        MY_CUSTOM_TOKEN: envToken,
-        CLAW_LITE_URL_VAR: 'MY_CUSTOM_URL',
-        CLAW_LITE_API_VAR: 'MY_CUSTOM_TOKEN',
-      },
-      cwd: agentWorkingDir,
-    });
-    let replyStdout = '';
-    replyProcess.stdout.on('data', (d) => (replyStdout += d.toString()));
-    replyProcess.stderr.on('data', (d) => (replyStdout += d.toString()));
-    await new Promise((resolve) => replyProcess.on('close', resolve));
-    expect(replyStdout).toContain('Reply message appended');
-
-    const chatLogContentReply = fs.readFileSync(chatLogPath, 'utf8');
-    expect(chatLogContentReply).toContain('hello from custom env');
-
-    await runCli(['down']);
-    fs.writeFileSync(settingsPath, originalSettings);
-    await runCli(['up']);
+    await env.runCli(['down']);
+    env.writeSettings(originalSettings);
+    await env.runCli(['up']);
   }, 15000);
 });

package/e2e/jobs/agent-jobs.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { TestEnvironment, commandWith } from '../_helpers/test-environment.js';
+
+describe('E2E Agent Jobs (Lite)', () => {
+  let env: TestEnvironment;
+  let envUrl = '';
+  let envToken = '';
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-agent-jobs');
+    await env.setup();
+    await env.setupSubagentEnv();
+    ({ url: envUrl, token: envToken } = await env.getAgentCredentials());
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  // Filter out the session-timeout fixture job scheduled automatically by the
+  // debug-agent's router pipeline so assertions focus on user-added jobs.
+  async function listUserJobs(): Promise<Array<Record<string, unknown>>> {
+    const { stdout, code } = await env.runLite(['jobs', 'list']);
+    expect(code).toBe(0);
+    const all = JSON.parse(stdout) as Array<Record<string, unknown>>;
+    return all.filter(
+      (j) => !(typeof j.id === 'string' && j.id.startsWith('__session_timeout__'))
+    );
+  }
+
+  it('should return a parseable JSON array from list', async () => {
+    const { stdout, code } = await env.runLite(['jobs', 'list']);
+    expect(code).toBe(0);
+    expect(Array.isArray(JSON.parse(stdout))).toBe(true);
+  });
+
+  it('should add a job with the allowed flags and stamp agentId from the token', async () => {
+    const { stdout, code } = await env.runLite([
+      'jobs', 'add', 'agent-job-1',
+      '--every', '999h',
+      '--message', 'hello from agent',
+      '--reply', 'queued',
+      '--session', 'new',
+    ]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("Job 'agent-job-1' created successfully.");
+
+    const jobs = await listUserJobs();
+    const job = jobs.find((j) => j.id === 'agent-job-1');
+    expect(job).toMatchObject({
+      id: 'agent-job-1',
+      message: 'hello from agent',
+      reply: 'queued',
+      // Server stamps agentId from the token rather than accepting it as input.
+      agentId: 'debug-agent',
+      session: { type: 'new' },
+      schedule: { every: '999h' },
+    });
+    // Internal-only fields must never leak in from agent input.
+    expect(job).not.toHaveProperty('env');
+    expect(job).not.toHaveProperty('action');
+    expect(job).not.toHaveProperty('nextSessionId');
+  });
+
+  it('should reject job input containing internal-only fields', async () => {
+    const attempts = [
+      { id: 'bad-env', schedule: { every: '999h' }, env: { FOO: 'BAR' } },
+      { id: 'bad-action', schedule: { every: '999h' }, action: 'stop' },
+      { id: 'bad-agent', schedule: { every: '999h' }, agentId: 'someone-else' },
+      { id: 'bad-next', schedule: { every: '999h' }, nextSessionId: 'abc' },
+    ];
+
+    for (const job of attempts) {
+      const res = await fetch(`${envUrl}/addCronJob`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${envToken}`,
+        },
+        body: JSON.stringify({ job }),
+      });
+      expect(res.status).toBe(400);
+      const body = (await res.json()) as { error?: { message?: string } };
+      expect(body.error?.message ?? '').toMatch(/unrecognized|invalid/i);
+    }
+
+    const jobs = await listUserJobs();
+    for (const attempt of attempts) {
+      expect(jobs.find((j) => j.id === attempt.id)).toBeUndefined();
+    }
+  });
+
+  it('should add a job with --cron schedule', async () => {
+    const { code } = await env.runLite([
+      'jobs', 'add', 'agent-job-cron',
+      '--cron', '0 0 * * *',
+      '--message', 'nightly',
+    ]);
+    expect(code).toBe(0);
+
+    const jobs = await listUserJobs();
+    const job = jobs.find((j) => j.id === 'agent-job-cron');
+    expect(job).toMatchObject({ schedule: { cron: '0 0 * * *' }, message: 'nightly' });
+  });
+
+  it('should add a job with --at schedule (interval), execute it, and auto-delete it', async () => {
+    // Jobs created via agent credentials run in the __creds__ chat (the chat
+    // the agent token is bound to); subscribe there to observe execution.
+    const chat = await env.connect('__creds__');
+    try {
+      const { code, stdout } = await env.runLite([
+        'jobs', 'add', 'agent-job-at-interval',
+        '--at', '2s',
+        '--message', 'echo job-ran-interval',
+        '--reply', 'queued',
+        '--session', 'new',
+      ]);
+      expect(code).toBe(0);
+      expect(stdout).toContain("Job 'agent-job-at-interval' created successfully.");
+
+      const jobsBefore = await listUserJobs();
+      const jobBefore = jobsBefore.find((j) => j.id === 'agent-job-at-interval');
+      expect(jobBefore).toMatchObject({
+        schedule: { at: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/) },
+        message: 'echo job-ran-interval',
+      });
+
+      // Wait for the debug agent to echo the job message — proves the job
+      // actually fired end-to-end, not just that it was scheduled.
+      await chat.waitForMessage(commandWith('[DEBUG] echo job-ran-interval'), 8000);
+
+      const jobsAfter = await listUserJobs();
+      expect(jobsAfter.find((j) => j.id === 'agent-job-at-interval')).toBeUndefined();
+    } finally {
+      await chat.disconnect();
+    }
+  }, 15000);
+
+  it('should add a job with --at schedule (timestamp), execute it, and auto-delete it', async () => {
+    const chat = await env.connect('__creds__');
+    try {
+      const futureTime = new Date(Date.now() + 2000).toISOString();
+      const { code, stdout } = await env.runLite([
+        'jobs', 'add', 'agent-job-at-timestamp',
+        '--at', futureTime,
+        '--message', 'echo job-ran-timestamp',
+        '--reply', 'queued',
+        '--session', 'new',
+      ]);
+      expect(code).toBe(0);
+      expect(stdout).toContain("Job 'agent-job-at-timestamp' created successfully.");
+
+      const jobsBefore = await listUserJobs();
+      const jobBefore = jobsBefore.find((j) => j.id === 'agent-job-at-timestamp');
+      expect(jobBefore).toMatchObject({
+        schedule: { at: futureTime },
+        message: 'echo job-ran-timestamp',
+      });
+
+      await chat.waitForMessage(commandWith('[DEBUG] echo job-ran-timestamp'), 8000);
+
+      const jobsAfter = await listUserJobs();
+      expect(jobsAfter.find((j) => j.id === 'agent-job-at-timestamp')).toBeUndefined();
+    } finally {
+      await chat.disconnect();
+    }
+  }, 15000);
+
+  it('should reject jobs with no schedule flag', async () => {
+    const { stderr, code } = await env.runLite(['jobs', 'add', 'no-sched', '--message', 'x']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('A schedule must be specified');
+  });
+
+  it('should reject --session values other than "new"', async () => {
+    const { stderr, code } = await env.runLite([
+      'jobs', 'add', 'bad-session',
+      '--every', '999h',
+      '--session', 'bogus',
+    ]);
+    expect(code).toBe(1);
+    expect(stderr).toContain('Only "new" session type is supported');
+  });
+
+  it('should replace a job when adding the same id twice', async () => {
+    await env.runLite(['jobs', 'add', 'dup-job', '--every', '999h', '--message', 'first']);
+    const { code } = await env.runLite([
+      'jobs', 'add', 'dup-job',
+      '--every', '888h',
+      '--message', 'second',
+    ]);
+    expect(code).toBe(0);
+
+    const jobs = await listUserJobs();
+    const matches = jobs.filter((j) => j.id === 'dup-job');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]).toMatchObject({
+      message: 'second',
+      schedule: { every: '888h' },
+    });
+  });
+
+  it('should delete an existing job', async () => {
+    await env.runLite(['jobs', 'add', 'del-me', '--every', '999h']);
+    const { stdout, code } = await env.runLite(['jobs', 'delete', 'del-me']);
+    expect(code).toBe(0);
+    expect(stdout).toContain("Job 'del-me' deleted successfully.");
+
+    const jobs = await listUserJobs();
+    expect(jobs.find((j) => j.id === 'del-me')).toBeUndefined();
+  });
+
+  it('should report "not found" when deleting a missing job', async () => {
+    const { stdout, code } = await env.runLite(['jobs', 'delete', 'does-not-exist']);
+    expect(code).toBe(0);
+    expect(stdout).toContain("Job 'does-not-exist' not found.");
+  });
+});