vellum 0.2.13 → 0.2.14

package/src/__tests__/qdrant-manager.test.ts

@@ -0,0 +1,267 @@
+import { describe, test, expect, beforeEach, mock, afterEach } from 'bun:test';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+
+const testDataDir = '/tmp/qdrant-manager-test-' + process.pid;
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDataDir,
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import { QdrantManager } from '../memory/qdrant-manager.js';
+
+function placeFakeBinary(script: string): string {
+  const binaryPath = join(testDataDir, 'qdrant', 'bin', 'qdrant');
+  writeFileSync(binaryPath, script);
+  chmodSync(binaryPath, 0o755);
+  return binaryPath;
+}
+
+let nextPort = 16500;
+function getTestPort(): number {
+  return nextPort++;
+}
+
+beforeEach(() => {
+  rmSync(testDataDir, { recursive: true, force: true });
+  mkdirSync(join(testDataDir, 'qdrant', 'bin'), { recursive: true });
+  delete process.env.QDRANT_URL;
+});
+
+afterEach(() => {
+  delete process.env.QDRANT_URL;
+  rmSync(testDataDir, { recursive: true, force: true });
+});
+
+describe('QdrantManager', () => {
+
+  // ── Constructor ──────────────────────────────────────────────
+
+  describe('constructor', () => {
+    test('parses URL correctly', () => {
+      const mgr = new QdrantManager({ url: 'http://127.0.0.1:6333' });
+      expect(mgr.getUrl()).toBe('http://127.0.0.1:6333');
+    });
+
+    test('defaults port to 6333 when not in URL', () => {
+      const mgr = new QdrantManager({ url: 'http://localhost' });
+      expect(mgr.getUrl()).toBe('http://localhost');
+    });
+
+    test('accepts custom storagePath', () => {
+      const mgr = new QdrantManager({
+        url: 'http://127.0.0.1:6333',
+        storagePath: '/custom/storage',
+      });
+      expect(mgr.getUrl()).toBe('http://127.0.0.1:6333');
+    });
+  });
+
+  // ── getUrl ───────────────────────────────────────────────────
+
+  describe('getUrl', () => {
+    test('returns the configured URL', () => {
+      const mgr = new QdrantManager({ url: 'http://myhost:7777' });
+      expect(mgr.getUrl()).toBe('http://myhost:7777');
+    });
+  });
+
+  // ── External Mode ────────────────────────────────────────────
+
+  describe('external mode', () => {
+    test('enters external mode when QDRANT_URL is set', async () => {
+      process.env.QDRANT_URL = 'http://external:6333';
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      // External mode goes straight to waitForReady, which will timeout
+      await expect(mgr.start()).rejects.toThrow('did not become ready');
+    }, 35_000);
+
+    test('does not enter external mode when QDRANT_URL is empty', () => {
+      process.env.QDRANT_URL = '   ';
+      const mgr = new QdrantManager({ url: 'http://127.0.0.1:6333' });
+      expect(mgr.getUrl()).toBe('http://127.0.0.1:6333');
+    });
+
+    test('does not enter external mode when QDRANT_URL is unset', () => {
+      delete process.env.QDRANT_URL;
+      const mgr = new QdrantManager({ url: 'http://127.0.0.1:6333' });
+      expect(mgr.getUrl()).toBe('http://127.0.0.1:6333');
+    });
+  });
+
+  // ── stop() without a running process ─────────────────────────
+
+  describe('stop() without running process', () => {
+    test('removes stale PID file', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+      writeFileSync(pidPath, '99999');
+
+      const mgr = new QdrantManager({ url: 'http://127.0.0.1:6333' });
+      await mgr.stop();
+
+      expect(existsSync(pidPath)).toBe(false);
+    });
+
+    test('is a no-op when no PID file exists', async () => {
+      const mgr = new QdrantManager({ url: 'http://127.0.0.1:6333' });
+      await mgr.stop();
+    });
+  });
+
+  // ── Stale PID Cleanup ────────────────────────────────────────
+
+  describe('stale PID cleanup during start()', () => {
+    test('removes PID file for non-existent process', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+      writeFileSync(pidPath, '2147483647');
+
+      placeFakeBinary('#!/bin/sh\nexit 1');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      try { await mgr.start(); } catch { /* readyz timeout */ }
+
+      expect(existsSync(pidPath)).toBe(false);
+    }, 40_000);
+
+    test('handles invalid PID file contents', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+      writeFileSync(pidPath, 'garbage');
+
+      placeFakeBinary('#!/bin/sh\nexit 1');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      try { await mgr.start(); } catch { /* expected */ }
+
+      expect(existsSync(pidPath)).toBe(false);
+    }, 40_000);
+
+    test('handles empty PID file', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+      writeFileSync(pidPath, '');
+
+      placeFakeBinary('#!/bin/sh\nexit 1');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      try { await mgr.start(); } catch { /* expected */ }
+
+      expect(existsSync(pidPath)).toBe(false);
+    }, 40_000);
+  });
+
+  // ── Process Lifecycle ────────────────────────────────────────
+
+  describe('process lifecycle', () => {
+    test('writes PID file after spawning', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+
+      // Binary that stays alive. We'll stop it before readyz times out.
+      placeFakeBinary('#!/bin/sh\nexec sleep 300');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      // Start polls readyz forever; we race it with our assertions + stop
+      const startPromise = mgr.start();
+
+      // Wait for spawn to happen
+      await Bun.sleep(500);
+
+      // PID file should be written
+      expect(existsSync(pidPath)).toBe(true);
+      const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+      expect(isNaN(pid)).toBe(false);
+      expect(pid).toBeGreaterThan(0);
+
+      // Stop kills the process and cleans up PID
+      await mgr.stop();
+      expect(existsSync(pidPath)).toBe(false);
+
+      // start() should now reject because process was killed
+      await expect(startPromise).rejects.toThrow('did not become ready');
+    }, 40_000);
+
+    test('stop() escalates to SIGKILL after grace period', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+
+      // Binary that ignores SIGTERM
+      placeFakeBinary('#!/bin/sh\ntrap "" TERM\nexec sleep 300');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      const startPromise = mgr.start();
+      await Bun.sleep(500);
+
+      expect(existsSync(pidPath)).toBe(true);
+
+      const stopStart = Date.now();
+      await mgr.stop();
+      const stopElapsed = Date.now() - stopStart;
+
+      // Grace period is 5s — should wait at least that long
+      expect(stopElapsed).toBeGreaterThanOrEqual(4500);
+      expect(existsSync(pidPath)).toBe(false);
+
+      await expect(startPromise).rejects.toThrow('did not become ready');
+    }, 45_000);
+  });
+
+  // ── Start Failure Cleanup ────────────────────────────────────
+
+  describe('start failure cleanup', () => {
+    test('cleans up process on readyz timeout', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+
+      // Binary that stays alive but never serves readyz
+      placeFakeBinary('#!/bin/sh\nexec sleep 300');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      await expect(mgr.start()).rejects.toThrow('did not become ready');
+      expect(existsSync(pidPath)).toBe(false);
+    }, 40_000);
+
+    test('cleans up when process exits immediately', async () => {
+      const pidPath = join(testDataDir, 'qdrant', 'qdrant.pid');
+
+      placeFakeBinary('#!/bin/sh\nexit 1');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      await expect(mgr.start()).rejects.toThrow('did not become ready');
+      expect(existsSync(pidPath)).toBe(false);
+    }, 40_000);
+  });
+
+  // ── Binary Detection ─────────────────────────────────────────
+
+  describe('binary detection', () => {
+    test('skips download when binary exists', async () => {
+      placeFakeBinary('#!/bin/sh\nexit 1');
+
+      const port = getTestPort();
+      const mgr = new QdrantManager({ url: `http://127.0.0.1:${port}` });
+
+      try { await mgr.start(); } catch { /* readyz timeout */ }
+
+      const binaryPath = join(testDataDir, 'qdrant', 'bin', 'qdrant');
+      expect(existsSync(binaryPath)).toBe(true);
+    }, 40_000);
+  });
+});

package/src/__tests__/recurrence-engine-rruleset.test.ts

@@ -76,3 +76,100 @@ describe('RRULE set engine support', () => {
     expect(next).toBeGreaterThan(Date.now() - 1);
   });
 });
+
+// ── EXRULE behavioral tests ──────────────────────────────────────────
+
+describe('EXRULE engine behavior', () => {
+  test('EXRULE excludes matching occurrences from daily series', () => {
+    // RRULE: every day at 09:00 starting Jan 1 2099
+    // EXRULE: every Saturday and Sunday (weekends)
+    // Expected: weekday occurrences only
+    const expr = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'EXRULE:FREQ=WEEKLY;BYDAY=SA,SU;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+
+    // Jan 1 2099 is a Thursday. Enumerate the first several occurrences
+    // and verify that no Saturday (Jan 3) or Sunday (Jan 4) appears.
+    const thu = new Date('2099-01-01T09:00:00Z').getTime(); // Thu
+    const fri = new Date('2099-01-02T09:00:00Z').getTime(); // Fri
+    const sat = new Date('2099-01-03T09:00:00Z').getTime(); // Sat
+    const sun = new Date('2099-01-04T09:00:00Z').getTime(); // Sun
+    const mon = new Date('2099-01-05T09:00:00Z').getTime(); // Mon
+
+    // After Thu -> should be Fri (not Sat/Sun)
+    const afterThu = computeNextRunAt({ syntax: 'rrule', expression: expr }, thu + 1);
+    expect(afterThu).toBe(fri);
+
+    // After Fri -> should skip Sat+Sun, land on Mon
+    const afterFri = computeNextRunAt({ syntax: 'rrule', expression: expr }, fri + 1);
+    expect(afterFri).toBe(mon);
+
+    // Explicitly confirm Sat and Sun are never returned
+    expect(afterFri).not.toBe(sat);
+    expect(afterFri).not.toBe(sun);
+  });
+
+  test('EXRULE with FREQ acts as repeating exclusion series', () => {
+    // RRULE: every day starting Jan 1 2099
+    // EXRULE: every 3rd day starting Jan 1 2099 (excludes Jan 1, Jan 4, Jan 7, ...)
+    const expr = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'EXRULE:FREQ=DAILY;INTERVAL=3;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+
+    const jan1 = new Date('2099-01-01T09:00:00Z').getTime();
+    const jan2 = new Date('2099-01-02T09:00:00Z').getTime();
+    const jan3 = new Date('2099-01-03T09:00:00Z').getTime();
+    const jan4 = new Date('2099-01-04T09:00:00Z').getTime();
+    const jan5 = new Date('2099-01-05T09:00:00Z').getTime();
+
+    // Jan 1 is excluded (EXRULE fires on DTSTART). First occurrence after
+    // DTSTART should be Jan 2.
+    const first = computeNextRunAt({ syntax: 'rrule', expression: expr }, jan1 - 1);
+    expect(first).toBe(jan2);
+
+    // After Jan 2 -> Jan 3 (Jan 3 not excluded)
+    const second = computeNextRunAt({ syntax: 'rrule', expression: expr }, jan2 + 1);
+    expect(second).toBe(jan3);
+
+    // After Jan 3 -> should skip Jan 4 (excluded, 3 days after Jan 1) -> Jan 5
+    const third = computeNextRunAt({ syntax: 'rrule', expression: expr }, jan3 + 1);
+    expect(third).toBe(jan5);
+    expect(third).not.toBe(jan4);
+  });
+
+  test('EXRULE does not affect non-matching occurrences', () => {
+    // RRULE: every weekday (Mon-Fri) at 09:00
+    // EXRULE: every Saturday at 09:00 (no overlap with weekday rule)
+    // Expected: all weekday occurrences remain intact
+    const expr = [
+      'DTSTART:20990105T090000Z',
+      'RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'EXRULE:FREQ=WEEKLY;BYDAY=SA;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+
+    // Jan 5 2099 is a Monday. Verify all five weekdays in the first week appear.
+    const mon = new Date('2099-01-05T09:00:00Z').getTime();
+    const tue = new Date('2099-01-06T09:00:00Z').getTime();
+    const wed = new Date('2099-01-07T09:00:00Z').getTime();
+    const thu = new Date('2099-01-08T09:00:00Z').getTime();
+    const fri = new Date('2099-01-09T09:00:00Z').getTime();
+    const nextMon = new Date('2099-01-12T09:00:00Z').getTime();
+
+    expect(computeNextRunAt({ syntax: 'rrule', expression: expr }, mon + 1)).toBe(tue);
+    expect(computeNextRunAt({ syntax: 'rrule', expression: expr }, tue + 1)).toBe(wed);
+    expect(computeNextRunAt({ syntax: 'rrule', expression: expr }, wed + 1)).toBe(thu);
+    expect(computeNextRunAt({ syntax: 'rrule', expression: expr }, thu + 1)).toBe(fri);
+    // After Fri -> skips weekend entirely (Sat excluded + Sun not in RRULE) -> Mon
+    expect(computeNextRunAt({ syntax: 'rrule', expression: expr }, fri + 1)).toBe(nextMon);
+  });
+});

package/src/__tests__/recurrence-engine.test.ts

@@ -59,6 +59,15 @@ describe('recurrence engine — rrule', () => {
     expect(() => computeNextRunAt({ syntax: 'rrule', expression: 'RRULE:FREQ=DAILY' })).toThrow(/DTSTART/);
   });
 
+  test('preserves TZID parameter values when normalizing lowercase prefixes', () => {
+    // TZID contains case-sensitive timezone names (e.g. America/New_York)
+    // that must not be uppercased during prefix normalization.
+    const expr = 'dtstart;TZID=America/New_York:20990601T090000\nrrule:FREQ=DAILY';
+    expect(isValidScheduleExpression({ syntax: 'rrule', expression: expr })).toBe(true);
+    const next = computeNextRunAt({ syntax: 'rrule', expression: expr });
+    expect(next).toBeGreaterThan(Date.now());
+  });
+
   test('computes next run for RRULE with EXDATE set construct', () => {
     const expr = 'DTSTART:20990101T090000Z\nRRULE:FREQ=DAILY\nEXDATE:20990101T090000Z';
     const next = computeNextRunAt({ syntax: 'rrule', expression: expr });

package/src/__tests__/recurrence-types.test.ts

@@ -56,6 +56,14 @@ describe('normalizeScheduleSyntax', () => {
     expect(result).toEqual({ syntax: 'cron', expression: '0 9 * * *' });
   });
 
+  test('honors explicit syntax hint in legacyCronExpression fallback', () => {
+    const result = normalizeScheduleSyntax({
+      syntax: 'rrule',
+      legacyCronExpression: '0 9 * * *',
+    });
+    expect(result).toEqual({ syntax: 'rrule', expression: '0 9 * * *' });
+  });
+
   test('returns null when nothing is provided', () => {
     expect(normalizeScheduleSyntax({})).toBeNull();
   });

package/src/__tests__/registry.test.ts

@@ -176,7 +176,7 @@ describe('tool manifest', () => {
   });
 
   test('eager module tool names list contains expected count', () => {
-    expect(eagerModuleToolNames.length).toBe(15);
+    expect(eagerModuleToolNames.length).toBe(16);
   });
 
   test('explicit tools list includes memory, credential, watch, catalog, and discover tools', () => {

package/src/__tests__/runtime-runs.test.ts

@@ -92,7 +92,7 @@ function makeFailingSession(errorMsg: string): Session {
 }
 
 /** Session whose agent loop emits a confirmation_request. */
-function makeConfirmationSession(toolName: string, principal?: { kind?: string; id?: string; version?: string }): Session {
+function makeConfirmationSession(toolName: string): Session {
   let clientHandler: (msg: ServerMessage) => void = () => {};
   return {
     isProcessing: () => false,
@@ -110,9 +110,6 @@ function makeConfirmationSession(toolName: string, principal?: { kind?: string;
         riskLevel: 'medium',
         allowlistOptions: [],
         scopeOptions: [],
-        principalKind: principal?.kind,
-        principalId: principal?.id,
-        principalVersion: principal?.version,
       });
       // Hang to simulate waiting for decision
       await new Promise<void>(() => {});
@@ -241,27 +238,6 @@ describe('runtime runs — swarm lifecycle', () => {
     expect(orchestrator.getRun('nonexistent-id')).toBeNull();
   });
 
-  test('principal context flows through to pending confirmation', async () => {
-    const conversation = createConversation('principal context test');
-    const orchestrator = new RunOrchestrator({
-      getOrCreateSession: async () => makeConfirmationSession('bash', {
-        kind: 'skill',
-        id: 'weather-skill',
-        version: 'sha256:abcdef1234567890',
-      }),
-      resolveAttachments: () => [],
-    });
-
-    const run = await orchestrator.startRun(conversation.id, 'Run with principal');
-    await new Promise((r) => setTimeout(r, 50));
-
-    const stored = orchestrator.getRun(run.id);
-    expect(stored?.status).toBe('needs_confirmation');
-    expect(stored?.pendingConfirmation?.principalKind).toBe('skill');
-    expect(stored?.pendingConfirmation?.principalId).toBe('weather-skill');
-    expect(stored?.pendingConfirmation?.principalVersion).toBe('sha256:abcdef1234567890');
-  });
-
   test('submitDecision returns run_not_found for unknown run', () => {
     const orchestrator = new RunOrchestrator({
       getOrCreateSession: async () => makeCompletingSession(),

package/src/__tests__/schedule-store.test.ts

@@ -435,27 +435,29 @@ describe('claimDueSchedules', () => {
   });
 
   test('claims exhausted RRULE schedule and disables it', () => {
-    // COUNT=1 means only one occurrence — the DTSTART itself
-    const rrule = 'DTSTART:20250101T000000Z\nRRULE:FREQ=DAILY;COUNT=1';
-    const job = createSchedule({
-      name: 'Finite RRULE',
-      cronExpression: rrule,
-      message: 'one-shot',
-      syntax: 'rrule',
-      expression: rrule,
-    });
-
-    // Force the schedule to be due (past the only occurrence)
-    getRawDb().run('UPDATE cron_jobs SET next_run_at = ? WHERE id = ?', [Date.now() - 1000, job.id]);
+    // COUNT=1 with a past DTSTART means the single occurrence has already
+    // passed, so computeNextRunAt returns null — triggering the exhaustion path.
+    // We insert directly via SQL because createSchedule validates that at least
+    // one future run exists, which would reject an already-exhausted schedule.
+    const yesterday = new Date(Date.now() - 86_400_000);
+    const dtstart = yesterday.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+    const rrule = `DTSTART:${dtstart}\nRRULE:FREQ=DAILY;COUNT=1`;
+    const id = 'exhausted-rrule-test';
+    const now = Date.now();
+    getRawDb().run(
+      `INSERT INTO cron_jobs (id, name, enabled, cron_expression, schedule_syntax, message, next_run_at, retry_count, created_by, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [id, 'Finite RRULE', 1, rrule, 'rrule', 'one-shot', now - 1000, 0, 'agent', now, now],
+    );
 
     const claimed = claimDueSchedules(Date.now());
     expect(claimed.length).toBe(1);
-    expect(claimed[0].id).toBe(job.id);
+    expect(claimed[0].id).toBe(id);
     expect(claimed[0].enabled).toBe(false);
     expect(claimed[0].nextRunAt).toBe(0);
 
     // Verify the schedule is disabled in the DB
-    const persisted = getSchedule(job.id);
+    const persisted = getSchedule(id);
     expect(persisted!.enabled).toBe(false);
 
     // A subsequent claim should not pick it up

package/src/__tests__/schedule-tools.test.ts

@@ -420,6 +420,41 @@ describe('schedule_update with RRULE', () => {
     expect(result.content).toContain('Syntax: rrule');
     expect(result.content).toContain('RRULE:FREQ=DAILY');
   });
+
+  test('auto-detects rrule syntax when updating expression without explicit syntax', async () => {
+    await executeScheduleCreate({
+      name: 'Auto-detect on update',
+      cron_expression: '0 9 * * *',
+      message: 'test',
+    }, ctx);
+
+    const row = getRawDb().query('SELECT id FROM cron_jobs LIMIT 1').get() as { id: string };
+    const result = await executeScheduleUpdate({
+      job_id: row.id,
+      expression: 'DTSTART:20250601T120000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Syntax: rrule');
+    expect(result.content).toContain('RRULE:FREQ=WEEKLY');
+  });
+
+  test('auto-detects cron syntax when updating expression without explicit syntax', async () => {
+    await executeScheduleCreate({
+      name: 'Cron auto-detect',
+      cron_expression: '0 9 * * *',
+      message: 'test',
+    }, ctx);
+
+    const row = getRawDb().query('SELECT id FROM cron_jobs LIMIT 1').get() as { id: string };
+    const result = await executeScheduleUpdate({
+      job_id: row.id,
+      expression: '30 17 * * 1-5',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Syntax: cron');
+  });
 });
 
 describe('schedule_list with RRULE', () => {
@@ -657,6 +692,54 @@ describe('schedule_list with RRULE set', () => {
   });
 });
 
+// ── EXRULE support in schedule tools ──────────────────────────────────
+
+describe('schedule_create with RRULE + EXRULE', () => {
+  beforeEach(() => {
+    getRawDb().run('DELETE FROM cron_runs');
+    getRawDb().run('DELETE FROM cron_jobs');
+  });
+
+  test('creates a schedule with RRULE + EXRULE', async () => {
+    const expression = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'EXRULE:FREQ=WEEKLY;BYDAY=SA,SU;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+
+    const result = await executeScheduleCreate({
+      name: 'Weekday-only via EXRULE',
+      syntax: 'rrule',
+      expression,
+      message: 'EXRULE test',
+    }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Schedule created successfully');
+    expect(result.content).toContain('Syntax: rrule');
+  });
+
+  test('list output shows [RRULE set] label for EXRULE expression', async () => {
+    const expression = [
+      'DTSTART:20990101T090000Z',
+      'RRULE:FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+      'EXRULE:FREQ=WEEKLY;BYDAY=SA,SU;BYHOUR=9;BYMINUTE=0;BYSECOND=0',
+    ].join('\n');
+
+    await executeScheduleCreate({
+      name: 'EXRULE Set Schedule',
+      syntax: 'rrule',
+      expression,
+      message: 'EXRULE set test',
+    }, ctx);
+
+    const result = await executeScheduleList({}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('[RRULE set]');
+  });
+});
+
 // ── schedule_delete ─────────────────────────────────────────────────
 
 describe('schedule_delete tool', () => {