vellum 0.2.14 → 0.3.2

package/src/__tests__/date-context.test.ts

@@ -1,373 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { buildTemporalContext } from '../daemon/date-context.js';
-
-// Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
-
-/** Wednesday 2026-02-18 12:00 UTC */
-const WED_FEB_18 = Date.UTC(2026, 1, 18, 12, 0, 0);
-
-/** Saturday 2026-02-21 12:00 UTC */
-const SAT_FEB_21 = Date.UTC(2026, 1, 21, 12, 0, 0);
-
-/** Sunday 2026-02-22 12:00 UTC */
-const SUN_FEB_22 = Date.UTC(2026, 1, 22, 12, 0, 0);
-
-/** Tuesday 2026-12-29 12:00 UTC — year boundary */
-const TUE_DEC_29 = Date.UTC(2026, 11, 29, 12, 0, 0);
-
-/** Friday 2026-02-27 12:00 UTC */
-const FRI_FEB_27 = Date.UTC(2026, 1, 27, 12, 0, 0);
-
-// ---------------------------------------------------------------------------
-// Basic structure
-// ---------------------------------------------------------------------------
-
-describe('buildTemporalContext', () => {
-  test('returns output wrapped in <temporal_context> tags', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toStartWith('<temporal_context>');
-    expect(result).toEndWith('</temporal_context>');
-  });
-
-  test('includes today date and weekday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Today: 2026-02-18 (Wednesday)');
-  });
-
-  test('includes timezone', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
-    expect(result).toContain('Timezone: America/New_York');
-  });
-
-  test('includes week definitions', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('work week = Monday–Friday');
-    expect(result).toContain('weekend = Saturday–Sunday');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Weekday baseline — today is Wednesday
-// ---------------------------------------------------------------------------
-
-describe('weekday baseline (Wednesday)', () => {
-  test('next weekend is the upcoming Saturday-Sunday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    // Wednesday Feb 18 → next Saturday is Feb 21, Sunday is Feb 22
-    expect(result).toContain('Next weekend: 2026-02-21 – 2026-02-22');
-  });
-
-  test('next work week is the following Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    // Wednesday Feb 18 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Weekend baseline — today is Saturday
-// ---------------------------------------------------------------------------
-
-describe('weekend baseline (Saturday)', () => {
-  test('next weekend is the *following* Saturday-Sunday, not today', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
-    // Saturday Feb 21 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('next work week is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
-    // Saturday Feb 21 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Weekend baseline — today is Sunday
-// ---------------------------------------------------------------------------
-
-describe('weekend baseline (Sunday)', () => {
-  test('next weekend is the following Saturday-Sunday', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
-    // Sunday Feb 22 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('next work week is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
-    // Sunday Feb 22 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Friday baseline
-// ---------------------------------------------------------------------------
-
-describe('Friday baseline', () => {
-  test('next weekend is tomorrow (Saturday) and Sunday', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    // Friday Feb 27 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('next work week is the following Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    // Friday Feb 27 → next Monday is Mar 2, Friday is Mar 6
-    expect(result).toContain('Next work week: 2026-03-02 – 2026-03-06');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Month / year boundary
-// ---------------------------------------------------------------------------
-
-describe('month/year boundary', () => {
-  test('handles year boundary correctly', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC' });
-    expect(result).toContain('Today: 2026-12-29 (Tuesday)');
-    // Tuesday Dec 29 → next Saturday is Jan 2 2027
-    expect(result).toContain('Next weekend: 2027-01-02 – 2027-01-03');
-    // Next Monday is Jan 4 2027 (skips current work week)
-    // Wait — Dec 29 is Tuesday, so next Monday = Jan 4? Let me think:
-    // Dec 29 Tue → Mon is (1-2+7)%7 = 6 days → Jan 4 Mon
-    expect(result).toContain('Next work week: 2027-01-04 – 2027-01-08');
-  });
-
-  test('horizon entries cross year boundary', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC', horizonDays: 5 });
-    expect(result).toContain('2026-12-30 Wednesday');
-    expect(result).toContain('2026-12-31 Thursday');
-    expect(result).toContain('2027-01-01 Friday');
-    expect(result).toContain('2027-01-02 Saturday');
-    expect(result).toContain('2027-01-03 Sunday');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Output size caps
-// ---------------------------------------------------------------------------
-
-describe('output size caps', () => {
-  test('output is at most 1500 characters', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 14 });
-    expect(result.length).toBeLessThanOrEqual(1500);
-  });
-
-  test('horizon entries are capped at 14 even if more requested', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 30 });
-    const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
-    expect(horizonMatches).not.toBeNull();
-    expect(horizonMatches!.length).toBeLessThanOrEqual(14);
-  });
-
-  test('default horizon is 14 days', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
-    expect(horizonMatches).not.toBeNull();
-    expect(horizonMatches!.length).toBe(14);
-  });
-
-  test('respects smaller horizonDays', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 3 });
-    const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
-    expect(horizonMatches).not.toBeNull();
-    expect(horizonMatches!.length).toBe(3);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// DST-safe timezone behavior
-// ---------------------------------------------------------------------------
-
-describe('DST-safe timezone behavior', () => {
-  test('date labels are correct in US Eastern timezone', () => {
-    // Feb 18 12:00 UTC = Feb 18 07:00 EST (same calendar date)
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
-    expect(result).toContain('Today: 2026-02-18 (Wednesday)');
-  });
-
-  test('date labels are correct in timezone ahead of UTC', () => {
-    // Use a timestamp near midnight UTC so the local date differs
-    // Feb 18 23:00 UTC = Feb 19 08:00 JST
-    const nearMidnight = Date.UTC(2026, 1, 18, 23, 0, 0);
-    const result = buildTemporalContext({ nowMs: nearMidnight, timeZone: 'Asia/Tokyo' });
-    expect(result).toContain('Today: 2026-02-19 (Thursday)');
-  });
-
-  test('addDays is correct across DST spring-forward boundary', () => {
-    // 2026-03-08 is spring-forward day in America/New_York (clocks jump 2:00→3:00 AM).
-    // Use a timestamp at local 23:30 on Friday March 6 (04:30 UTC March 7).
-    const preDST = Date.UTC(2026, 2, 7, 4, 30, 0); // local: Fri Mar 6 23:30 EST
-    const result = buildTemporalContext({ nowMs: preDST, timeZone: 'America/New_York', horizonDays: 5 });
-    // Today should be Friday March 6
-    expect(result).toContain('Today: 2026-03-06 (Friday)');
-    // Horizon should have 5 consecutive days with no duplicates/skips
-    expect(result).toContain('2026-03-07 Saturday');
-    expect(result).toContain('2026-03-08 Sunday');
-    expect(result).toContain('2026-03-09 Monday');
-    expect(result).toContain('2026-03-10 Tuesday');
-    expect(result).toContain('2026-03-11 Wednesday');
-  });
-
-  test('addDays is correct across DST fall-back boundary', () => {
-    // 2026-11-01 is fall-back day in America/New_York (clocks jump 2:00→1:00 AM).
-    // Use a timestamp at local 00:30 on Sunday Nov 1 (04:30 UTC Nov 1).
-    const preFallback = Date.UTC(2026, 10, 1, 4, 30, 0); // local: Sun Nov 1 00:30 EDT
-    const result = buildTemporalContext({ nowMs: preFallback, timeZone: 'America/New_York', horizonDays: 3 });
-    // Today should be Sunday Nov 1
-    expect(result).toContain('Today: 2026-11-01 (Sunday)');
-    // Horizon should have 3 consecutive days
-    expect(result).toContain('2026-11-02 Monday');
-    expect(result).toContain('2026-11-03 Tuesday');
-    expect(result).toContain('2026-11-04 Wednesday');
-  });
-
-  test('dates are correct in far-east UTC+13 timezone (Pacific/Auckland NZDT)', () => {
-    // Feb 18 12:00 UTC = Feb 19 01:00 NZDT (UTC+13 during daylight saving)
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'Pacific/Auckland', horizonDays: 3 });
-    // In Auckland, Feb 18 12:00 UTC is already Feb 19 (Thursday)
-    expect(result).toContain('Today: 2026-02-19 (Thursday)');
-    // Horizon should show consecutive days without +1 shift
-    expect(result).toContain('2026-02-20 Friday');
-    expect(result).toContain('2026-02-21 Saturday');
-    expect(result).toContain('2026-02-22 Sunday');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Trip-planning regression: "next weekend" resolution
-// ---------------------------------------------------------------------------
-
-describe('trip-planning: next weekend resolution', () => {
-  test('Wednesday → "next weekend" anchors resolve to upcoming Sat-Sun', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    // A user asking "plan a trip for next weekend" on Wednesday Feb 18
-    // expects Sat Feb 21 – Sun Feb 22.
-    expect(result).toContain('Next weekend: 2026-02-21 – 2026-02-22');
-    // Both dates must appear in the horizon so the model can reference them.
-    expect(result).toContain('2026-02-21 Saturday');
-    expect(result).toContain('2026-02-22 Sunday');
-  });
-
-  test('Saturday → "next weekend" skips current weekend', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
-    // Already on Saturday → "next weekend" means the *following* weekend.
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('Sunday → "next weekend" skips current weekend', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('Friday → "next weekend" is tomorrow', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Trip-planning regression: "next work week" resolution
-// ---------------------------------------------------------------------------
-
-describe('trip-planning: next work week resolution', () => {
-  test('Wednesday → "next work week" skips remainder of current week', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
-  });
-
-  test('Monday → "next work week" is the following Monday-Friday', () => {
-    /** Monday 2026-02-23 12:00 UTC */
-    const MON_FEB_23 = Date.UTC(2026, 1, 23, 12, 0, 0);
-    const result = buildTemporalContext({ nowMs: MON_FEB_23, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-03-02 – 2026-03-06');
-  });
-
-  test('Saturday → "next work week" is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Trip-planning regression: month-without-year disambiguation
-// ---------------------------------------------------------------------------
-
-describe('trip-planning: month-without-year disambiguation via temporal anchors', () => {
-  test('Today line includes full YYYY-MM-DD format with year for month disambiguation', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    // The Today line must include the full year so the model can resolve bare
-    // month names (e.g. "May" → May 2026 because today is Feb 2026).
-    // Regex ensures YYYY-MM-DD format is present (regression if year is dropped).
-    expect(result).toMatch(/Today: \d{4}-\d{2}-\d{2} \(\w+\)/);
-    expect(result).toContain('2026-02-18');
-  });
-
-  test('future-month anchors: horizon dates are all in the future relative to today', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 14 });
-    // Extract all horizon dates (indented YYYY-MM-DD lines)
-    const horizonDates = result.match(/^\s+(\d{4}-\d{2}-\d{2}) \w+$/gm);
-    expect(horizonDates).not.toBeNull();
-    // All horizon dates must be after today (2026-02-18)
-    for (const line of horizonDates!) {
-      const dateStr = line.trim().split(' ')[0];
-      expect(dateStr > '2026-02-18').toBe(true);
-    }
-  });
-
-  test('year-end context: horizon spans into next year for Dec disambiguation', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC', horizonDays: 14 });
-    // Today is Dec 29 2026 — horizon must include 2027 dates so the model can
-    // distinguish "January" (Jan 2027) from past January (Jan 2026).
-    expect(result).toContain('Today: 2026-12-29');
-    expect(result).toMatch(/2027-01-\d{2} \w+/); // At least one January 2027 date
-  });
-
-  test('timezone is always present for correct local-month resolution', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
-    // Timezone must be present so the model resolves months in the user's
-    // local calendar, not UTC.
-    expect(result).toMatch(/Timezone: .+/);
-    expect(result).toContain('America/New_York');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Trip-planning regression: cross-month weekend resolution
-// ---------------------------------------------------------------------------
-
-describe('trip-planning: cross-month weekend resolution', () => {
-  test('weekend that spans a month boundary (Feb → Mar)', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-
-  test('year-boundary weekend (Dec 2026 → Jan 2027)', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2027-01-02 – 2027-01-03');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Trip-planning regression: timezone-shifted weekend anchors
-// ---------------------------------------------------------------------------
-
-describe('trip-planning: timezone-shifted weekend anchors', () => {
-  test('late Friday UTC is already Saturday in Auckland → skips to next weekend', () => {
-    // Friday Feb 27 23:00 UTC = Saturday Feb 28 12:00 NZDT
-    const lateFriUTC = Date.UTC(2026, 1, 27, 23, 0, 0);
-    const result = buildTemporalContext({ nowMs: lateFriUTC, timeZone: 'Pacific/Auckland' });
-    expect(result).toContain('Today: 2026-02-28 (Saturday)');
-    // "Next weekend" skips current weekend → Mar 7-8.
-    expect(result).toContain('Next weekend: 2026-03-07 – 2026-03-08');
-  });
-
-  test('early Saturday UTC is still Friday in US Pacific → next weekend is tomorrow', () => {
-    // Saturday Feb 28 02:00 UTC = Friday Feb 27 18:00 PST
-    const earlySatUTC = Date.UTC(2026, 1, 28, 2, 0, 0);
-    const result = buildTemporalContext({ nowMs: earlySatUTC, timeZone: 'America/Los_Angeles' });
-    expect(result).toContain('Today: 2026-02-27 (Friday)');
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
-  });
-});

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -1,129 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { Database } from 'bun:sqlite';
-import { drizzle } from 'drizzle-orm/bun-sqlite';
-import * as schema from '../memory/schema.js';
-import { scheduleJobs } from '../memory/schema.js';
-import { eq } from 'drizzle-orm';
-
-function createTestDb() {
-  const sqlite = new Database(':memory:');
-  sqlite.exec('PRAGMA journal_mode=WAL');
-  sqlite.exec('PRAGMA foreign_keys = ON');
-  return drizzle(sqlite, { schema });
-}
-
-function getRawSqlite(db: ReturnType<typeof drizzle<typeof schema>>): Database {
-  return (db as unknown as { $client: Database }).$client;
-}
-
-describe('schedule_syntax column migration', () => {
-  test('fresh DB includes schedule_syntax with default cron', () => {
-    const db = createTestDb();
-    const raw = getRawSqlite(db);
-
-    raw.exec(/*sql*/ `
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
-        schedule_syntax TEXT NOT NULL DEFAULT 'cron',
-        timezone TEXT,
-        message TEXT NOT NULL,
-        next_run_at INTEGER NOT NULL,
-        last_run_at INTEGER,
-        last_status TEXT,
-        retry_count INTEGER NOT NULL DEFAULT 0,
-        created_by TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-
-    const now = Date.now();
-    db.insert(scheduleJobs).values({
-      id: 'test-1',
-      name: 'Test Job',
-      enabled: true,
-      cronExpression: '0 9 * * *',
-      timezone: null,
-      message: 'hello',
-      nextRunAt: now + 60000,
-      lastRunAt: null,
-      lastStatus: null,
-      retryCount: 0,
-      createdBy: 'agent',
-      createdAt: now,
-      updatedAt: now,
-    }).run();
-
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'test-1')).get();
-    expect(row).toBeTruthy();
-    expect(row!.scheduleSyntax).toBe('cron');
-  });
-
-  test('upgraded DB gains schedule_syntax column via ALTER TABLE', () => {
-    const db = createTestDb();
-    const raw = getRawSqlite(db);
-
-    // Old schema without schedule_syntax
-    raw.exec(/*sql*/ `
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
-        timezone TEXT,
-        message TEXT NOT NULL,
-        next_run_at INTEGER NOT NULL,
-        last_run_at INTEGER,
-        last_status TEXT,
-        retry_count INTEGER NOT NULL DEFAULT 0,
-        created_by TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-
-    const now = Date.now();
-    raw.exec(`INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, last_run_at, last_status, retry_count, created_by, created_at, updated_at) VALUES ('old-1', 'Old Job', 1, '0 9 * * *', NULL, 'hello', ${now + 60000}, NULL, NULL, 0, 'agent', ${now}, ${now})`);
-
-    // Run the migration
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* already exists */ }
-
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'old-1')).get();
-    expect(row).toBeTruthy();
-    expect(row!.scheduleSyntax).toBe('cron');
-  });
-
-  test('migration is idempotent', () => {
-    const db = createTestDb();
-    const raw = getRawSqlite(db);
-
-    raw.exec(/*sql*/ `
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
-        timezone TEXT,
-        message TEXT NOT NULL,
-        next_run_at INTEGER NOT NULL,
-        last_run_at INTEGER,
-        last_status TEXT,
-        retry_count INTEGER NOT NULL DEFAULT 0,
-        created_by TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* ok */ }
-    try { raw.exec(`ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* ok */ }
-
-    const now = Date.now();
-    raw.exec(`INSERT INTO cron_jobs (id, name, enabled, cron_expression, timezone, message, next_run_at, retry_count, created_by, created_at, updated_at) VALUES ('idem-1', 'Test', 1, '0 9 * * *', NULL, 'hi', ${now + 60000}, 0, 'agent', ${now}, ${now})`);
-    const row = db.select().from(scheduleJobs).where(eq(scheduleJobs.id, 'idem-1')).get();
-    expect(row!.scheduleSyntax).toBe('cron');
-  });
-});

package/src/__tests__/delete-managed-skill-tool.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-
-let TEST_DIR = '';
-
-mock.module('../util/platform.js', () => ({
-  getRootDir: () => TEST_DIR,
-  getWorkspaceSkillsDir: () => join(TEST_DIR, 'skills'),
-}));
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
-}));
-
-import { DeleteManagedSkillTool } from '../tools/skills/delete-managed.js';
-import type { ToolContext } from '../tools/types.js';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- bypass private constructor for testing
-const tool = new (DeleteManagedSkillTool as any)() as InstanceType<typeof DeleteManagedSkillTool>;
-
-function makeContext(): ToolContext {
-  return {
-    workingDir: '/tmp',
-    sessionId: 'test-session',
-    conversationId: 'test-conversation',
-  };
-}
-
-function createSkill(id: string): void {
-  const skillDir = join(TEST_DIR, 'skills', id);
-  mkdirSync(skillDir, { recursive: true });
-  writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: "Test"\ndescription: "Test"\n---\n\nBody.\n');
-  // Update SKILLS.md
-  const indexPath = join(TEST_DIR, 'skills', 'SKILLS.md');
-  const existing = existsSync(indexPath) ? readFileSync(indexPath, 'utf-8') : '';
-  writeFileSync(indexPath, existing + `- ${id}\n`);
-}
-
-beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), 'delete-tool-test-'));
-  mkdirSync(join(TEST_DIR, 'skills'), { recursive: true });
-});
-
-afterEach(() => {
-  rmSync(TEST_DIR, { recursive: true, force: true });
-});
-
-describe('delete_managed_skill tool', () => {
-  test('deletes existing skill and updates index', async () => {
-    createSkill('doomed');
-    createSkill('survivor');
-
-    const result = await tool.execute({
-      skill_id: 'doomed',
-    }, makeContext());
-
-    expect(result.isError).toBe(false);
-    const parsed = JSON.parse(result.content);
-    expect(parsed.deleted).toBe(true);
-    expect(parsed.skill_id).toBe('doomed');
-    expect(parsed.index_updated).toBe(true);
-
-    expect(existsSync(join(TEST_DIR, 'skills', 'doomed'))).toBe(false);
-
-    const indexContent = readFileSync(join(TEST_DIR, 'skills', 'SKILLS.md'), 'utf-8');
-    expect(indexContent).not.toContain('doomed');
-    expect(indexContent).toContain('survivor');
-  });
-
-  test('returns error for non-existent skill', async () => {
-    const result = await tool.execute({
-      skill_id: 'ghost',
-    }, makeContext());
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('not found');
-  });
-
-  test('rejects missing skill_id', async () => {
-    const result = await tool.execute({}, makeContext());
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('skill_id is required');
-  });
-
-  test('rejects invalid skill_id', async () => {
-    const result = await tool.execute({
-      skill_id: '../escape',
-    }, makeContext());
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('traversal');
-  });
-});