vellum 0.2.1 → 0.2.2

package/src/__tests__/skill-script-runner.test.ts

@@ -0,0 +1,159 @@
+import { describe, test, expect, afterAll } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runSkillToolScript } from '../tools/skills/skill-script-runner.js';
+import type { ToolContext } from '../tools/types.js';
+
+const testDir = mkdtempSync(join(tmpdir(), 'skill-runner-test-'));
+
+afterAll(() => {
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+const ctx: ToolContext = {
+  workingDir: '/tmp',
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+};
+
+function makeSkillDir(name: string): string {
+  const dir = join(testDir, name);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ── Host execution ──────────────────────────────────────────────────
+
+describe('runSkillToolScript (host)', () => {
+  test('runs a valid skill script and returns result', async () => {
+    const skillDir = makeSkillDir('valid-skill');
+    writeFileSync(join(skillDir, 'tool.ts'), `
+      export async function run(input, context) {
+        return { content: 'Hello from skill! Input: ' + JSON.stringify(input), isError: false };
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'tool.ts', { foo: 'bar' }, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Hello from skill!');
+    expect(result.content).toContain('"foo":"bar"');
+  });
+
+  test('blocks path traversal escape', async () => {
+    const skillDir = makeSkillDir('escape-skill');
+
+    const result = await runSkillToolScript(skillDir, '../../../etc/passwd', {}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('escapes the skill directory');
+  });
+
+  test('returns error when script does not export run()', async () => {
+    const skillDir = makeSkillDir('no-run-skill');
+    writeFileSync(join(skillDir, 'bad.ts'), `
+      export const name = 'not a runner';
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'bad.ts', {}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('does not export a "run" function');
+  });
+
+  test('returns error when script throws', async () => {
+    const skillDir = makeSkillDir('throw-skill');
+    writeFileSync(join(skillDir, 'throw.ts'), `
+      export async function run() {
+        throw new Error('Intentional test error');
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'throw.ts', {}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Intentional test error');
+  });
+
+  test('returns error when script file does not exist', async () => {
+    const skillDir = makeSkillDir('missing-skill');
+
+    const result = await runSkillToolScript(skillDir, 'nonexistent.ts', {}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Failed to load skill tool script');
+  });
+});
+
+// ── Version hash checking ───────────────────────────────────────────
+
+describe('runSkillToolScript version hash', () => {
+  test('blocks execution when hash mismatches', async () => {
+    const skillDir = makeSkillDir('hash-mismatch');
+    writeFileSync(join(skillDir, 'tool.ts'), `
+      export async function run() {
+        return { content: 'should not run', isError: false };
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'tool.ts', {}, ctx, {
+      expectedSkillVersionHash: 'expected-hash-123',
+      skillDirHashResolver: () => 'different-hash-456',
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Skill version mismatch');
+    expect(result.content).toContain('expected-hash-123');
+    expect(result.content).toContain('different-hash-456');
+  });
+
+  test('allows execution when hash matches', async () => {
+    const skillDir = makeSkillDir('hash-match');
+    writeFileSync(join(skillDir, 'tool.ts'), `
+      export async function run() {
+        return { content: 'hash matched', isError: false };
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'tool.ts', {}, ctx, {
+      expectedSkillVersionHash: 'matching-hash',
+      skillDirHashResolver: () => 'matching-hash',
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe('hash matched');
+  });
+
+  test('returns error when hash resolver throws', async () => {
+    const skillDir = makeSkillDir('hash-error');
+    writeFileSync(join(skillDir, 'tool.ts'), `
+      export async function run() {
+        return { content: 'should not run', isError: false };
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'tool.ts', {}, ctx, {
+      expectedSkillVersionHash: 'some-hash',
+      skillDirHashResolver: () => { throw new Error('hash computation failed'); },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Failed to compute skill version hash');
+    expect(result.content).toContain('hash computation failed');
+  });
+
+  test('skips hash check when no expected hash provided', async () => {
+    const skillDir = makeSkillDir('no-hash');
+    writeFileSync(join(skillDir, 'tool.ts'), `
+      export async function run() {
+        return { content: 'no hash check', isError: false };
+      }
+    `);
+
+    const result = await runSkillToolScript(skillDir, 'tool.ts', {}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe('no hash check');
+  });
+});

package/src/__tests__/speaker-identification.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'bun:test';
+import { extractPromptSpeakerMetadata, SpeakerIdentityTracker } from '../calls/speaker-identification.js';
+
+describe('speaker-identification', () => {
+  test('extractPromptSpeakerMetadata: reads top-level and nested fields', () => {
+    const metadata = extractPromptSpeakerMetadata({
+      speaker_id: 'spk-7',
+      speaker_label: 'Conference room mic',
+      speaker_confidence: '0.88',
+      metadata: {
+        participantId: 'participant-22',
+      },
+    });
+
+    expect(metadata.speakerId).toBe('spk-7');
+    expect(metadata.speakerLabel).toBe('Conference room mic');
+    expect(metadata.speakerConfidence).toBe(0.88);
+    expect(metadata.participantId).toBe('participant-22');
+  });
+
+  test('SpeakerIdentityTracker: keeps stable identity for provider speaker id', () => {
+    const tracker = new SpeakerIdentityTracker();
+
+    const first = tracker.identifySpeaker({
+      speakerId: 'speaker-a',
+      speakerName: 'Aaron',
+      speakerConfidence: 0.93,
+    });
+    const second = tracker.identifySpeaker({
+      speakerId: 'speaker-a',
+      speakerName: 'Aaron',
+      speakerConfidence: 0.81,
+    });
+
+    expect(first.speakerId).toBe('speaker-a');
+    expect(first.speakerLabel).toBe('Aaron');
+    expect(first.source).toBe('provider');
+    expect(second.speakerId).toBe('speaker-a');
+    expect(second.speakerLabel).toBe('Aaron');
+    expect(second.speakerConfidence).toBe(0.81);
+    expect(tracker.listProfiles()).toHaveLength(1);
+  });
+
+  test('SpeakerIdentityTracker: falls back to inferred primary speaker without provider ids', () => {
+    const tracker = new SpeakerIdentityTracker();
+    const speaker = tracker.identifySpeaker({});
+
+    expect(speaker.speakerId).toBe('primary-speaker');
+    expect(speaker.speakerLabel).toBe('Speaker 1');
+    expect(speaker.source).toBe('inferred');
+  });
+});

package/src/__tests__/subagent-manager-notify.test.ts

@@ -9,13 +9,14 @@ interface FakeManagedSubagent {
     abort: () => void;
     dispose: () => void;
     messages: Array<{ role: string; content: Array<{ type: string; text: string }> }>;
-    sendToClient: () => void;
+    sendToClient: (msg: ServerMessage) => void;
     loadFromDb?: () => Promise<void>;
     persistUserMessage?: (msg: string) => string;
     runAgentLoop?: () => Promise<void>;
+    usageStats: { inputTokens: number; outputTokens: number; estimatedCost: number };
   };
   state: SubagentState;
-  parentSendToClient: () => void;
+  parentSendToClient: (msg: ServerMessage) => void;
 }
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
@@ -37,19 +38,21 @@ function injectFakeSubagent(
   manager: SubagentManager,
   subagentId: string,
   state: SubagentState,
+  parentSendToClient?: (msg: ServerMessage) => void,
 ): void {
   const fakeSession: FakeManagedSubagent['session'] = {
     abort: () => {},
     dispose: () => {},
     messages: [],
     sendToClient: () => {},
+    usageStats: { inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 },
   };
 
   const internals = asInternals(manager);
   const subagents = internals.subagents;
   const parentToChildren = internals.parentToChildren;
 
-  subagents.set(subagentId, { session: fakeSession, state, parentSendToClient: () => {} });
+  subagents.set(subagentId, { session: fakeSession, state, parentSendToClient: parentSendToClient ?? (() => {}) });
 
   const parentId = state.config.parentSessionId;
   if (!parentToChildren.has(parentId)) {
@@ -78,7 +81,7 @@ function makeState(
 }
 
 describe('SubagentManager abort notification', () => {
-  test('abort notifies parent with abort message', () => {
+  test('abort notifies parent with do-not-respawn message', () => {
     const manager = new SubagentManager();
     const subagentId = 'sub-1';
     const state = makeState(subagentId);
@@ -97,18 +100,45 @@ describe('SubagentManager abort notification', () => {
     expect(result).toBe(true);
     expect(state.status).toBe('aborted');
     expect(notifications).toHaveLength(1);
-    expect(notifications[0].parentSessionId).toBe('parent-sess-1');
-    expect(notifications[0].message).toContain('[Subagent "Test subagent" was aborted]');
+    expect(notifications[0].message).toContain('explicitly aborted');
+    expect(notifications[0].message).toContain('Do NOT re-spawn');
+  });
+
+  test('abort notification routes to parent sender, not aborting sender', () => {
+    const manager = new SubagentManager();
+    const subagentId = 'sub-1';
+    const state = makeState(subagentId);
+
+    // Track which sender onSubagentFinished receives.
+    let notificationSender: unknown = null;
+    manager.onSubagentFinished = (_pid, _message, sender) => {
+      notificationSender = sender;
+    };
+
+    // The parent's stored sender (set at spawn time).
+    const parentSender = () => {};
+    injectFakeSubagent(manager, subagentId, state, parentSender);
+
+    // A different sender (simulating abort from a different thread's socket).
+    const abortingSender = ((_msg: ServerMessage) => {}) as (msg: ServerMessage) => void;
+
+    manager.abort(subagentId, abortingSender);
+
+    // onSubagentFinished should receive the parent's sender, not the aborting one.
+    expect(notificationSender).toBe(parentSender);
+    expect(notificationSender).not.toBe(abortingSender);
   });
 
   test('abort sends subagent_status_changed to client', () => {
     const manager = new SubagentManager();
     const subagentId = 'sub-1';
-    injectFakeSubagent(manager, subagentId, makeState(subagentId));
 
     const clientMessages: ServerMessage[] = [];
     const sendToClient = (msg: ServerMessage) => clientMessages.push(msg);
 
+    // Pass the sender as parentSendToClient so the stored sender receives the status update.
+    injectFakeSubagent(manager, subagentId, makeState(subagentId), sendToClient);
+
     manager.abort(subagentId, sendToClient);
 
     const statusMsg = clientMessages.find((m) => m.type === 'subagent_status_changed');
@@ -222,13 +252,14 @@ describe('SubagentManager notifyParent (via runSubagent)', () => {
     await asInternals(manager).runSubagent(subagentId, 'Do something');
 
     expect(state.status).toBe('completed');
+    expect(state.usage).toEqual({ inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 });
     expect(notifications).toHaveLength(1);
     expect(notifications[0].parentSessionId).toBe('parent-sess-1');
     expect(notifications[0].message).toContain('[Subagent "Test subagent" completed]');
     expect(notifications[0].message).toContain('subagent_read');
   });
 
-  test('failed subagent notifies parent with error', async () => {
+  test('failed subagent notifies parent with error and asks user before retry', async () => {
     const manager = new SubagentManager();
     const subagentId = 'sub-1';
     const state = makeState(subagentId);
@@ -251,10 +282,11 @@ describe('SubagentManager notifyParent (via runSubagent)', () => {
 
     expect(state.status).toBe('failed');
     expect(state.error).toBe('API rate limit exceeded');
+    expect(state.usage).toEqual({ inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 });
     expect(notifications).toHaveLength(1);
-    expect(notifications[0].parentSessionId).toBe('parent-sess-1');
-    expect(notifications[0].message).toContain('[Subagent "Test subagent" failed]');
+    expect(notifications[0].message).toContain('failed');
     expect(notifications[0].message).toContain('API rate limit exceeded');
+    expect(notifications[0].message).toContain('Do NOT re-spawn');
   });
 
   test('failed subagent does not notify if already aborted', async () => {

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

@@ -1,51 +1,49 @@
 import { describe, expect, test } from 'bun:test';
-import { subagentSpawnTool } from '../tools/subagent/spawn.js';
-import { subagentStatusTool } from '../tools/subagent/status.js';
-import { subagentAbortTool } from '../tools/subagent/abort.js';
-import { subagentMessageTool } from '../tools/subagent/message.js';
-import { subagentReadTool } from '../tools/subagent/read.js';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { executeSubagentSpawn } from '../tools/subagent/spawn.js';
+import { executeSubagentStatus } from '../tools/subagent/status.js';
+import { executeSubagentAbort } from '../tools/subagent/abort.js';
+import { executeSubagentMessage } from '../tools/subagent/message.js';
+import { executeSubagentRead } from '../tools/subagent/read.js';
+import { SubagentManager } from '../subagent/manager.js';
+import type { SubagentState } from '../subagent/types.js';
 
-describe('Subagent tool shapes', () => {
-  test('spawn tool has correct shape', () => {
-    expect(subagentSpawnTool.name).toBe('subagent_spawn');
-    expect(subagentSpawnTool.category).toBe('orchestration');
-    expect(typeof subagentSpawnTool.execute).toBe('function');
-    expect(typeof subagentSpawnTool.getDefinition).toBe('function');
-    const def = subagentSpawnTool.getDefinition!();
-    expect((def.input_schema as Record<string, unknown>).required).toEqual(['label', 'objective']);
-  });
+// Load tool definitions from the bundled skill TOOLS.json
+const toolsJson = JSON.parse(
+  readFileSync(join(import.meta.dirname, '../config/bundled-skills/subagent/TOOLS.json'), 'utf-8'),
+);
+const findTool = (name: string) => toolsJson.tools.find((t: { name: string }) => t.name === name);
 
-  test('status tool has correct shape', () => {
-    expect(subagentStatusTool.name).toBe('subagent_status');
-    expect(subagentStatusTool.category).toBe('orchestration');
-    expect(typeof subagentStatusTool.execute).toBe('function');
+describe('Subagent tool definitions', () => {
+  test('spawn tool has correct definition', () => {
+    const def = findTool('subagent_spawn');
+    expect(def).toBeDefined();
+    expect(def.input_schema.required).toEqual(['label', 'objective']);
   });
 
-  test('abort tool has correct shape', () => {
-    expect(subagentAbortTool.name).toBe('subagent_abort');
-    expect(typeof subagentAbortTool.execute).toBe('function');
-    const def = subagentAbortTool.getDefinition!();
-    expect((def.input_schema as Record<string, unknown>).required).toEqual(['subagent_id']);
+  test('abort tool has correct definition', () => {
+    const def = findTool('subagent_abort');
+    expect(def).toBeDefined();
+    expect(def.input_schema.required).toEqual(['subagent_id']);
   });
 
-  test('message tool has correct shape', () => {
-    expect(subagentMessageTool.name).toBe('subagent_message');
-    expect(typeof subagentMessageTool.execute).toBe('function');
-    const def = subagentMessageTool.getDefinition!();
-    expect((def.input_schema as Record<string, unknown>).required).toEqual(['subagent_id', 'content']);
+  test('message tool has correct definition', () => {
+    const def = findTool('subagent_message');
+    expect(def).toBeDefined();
+    expect(def.input_schema.required).toEqual(['subagent_id', 'content']);
   });
 
-  test('read tool has correct shape', () => {
-    expect(subagentReadTool.name).toBe('subagent_read');
-    expect(typeof subagentReadTool.execute).toBe('function');
-    const def = subagentReadTool.getDefinition!();
-    expect((def.input_schema as Record<string, unknown>).required).toEqual(['subagent_id']);
+  test('read tool has correct definition', () => {
+    const def = findTool('subagent_read');
+    expect(def).toBeDefined();
+    expect(def.input_schema.required).toEqual(['subagent_id']);
   });
 });
 
 describe('Subagent tool execute validation', () => {
   test('spawn returns error when no sendToClient', async () => {
-    const result = await subagentSpawnTool.execute(
+    const result = await executeSubagentSpawn(
       { label: 'test', objective: 'do something' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -54,7 +52,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('spawn returns error when missing label', async () => {
-    const result = await subagentSpawnTool.execute(
+    const result = await executeSubagentSpawn(
       { objective: 'do something' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1', sendToClient: () => {} },
     );
@@ -63,7 +61,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('status returns empty when no subagents', async () => {
-    const result = await subagentStatusTool.execute(
+    const result = await executeSubagentStatus(
       {},
       { workingDir: '/tmp', sessionId: 'nonexistent-session', conversationId: 'conv-1' },
     );
@@ -72,7 +70,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('status returns error for unknown subagent_id', async () => {
-    const result = await subagentStatusTool.execute(
+    const result = await executeSubagentStatus(
       { subagent_id: 'nonexistent-id' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -81,7 +79,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('abort returns error for unknown subagent_id', async () => {
-    const result = await subagentAbortTool.execute(
+    const result = await executeSubagentAbort(
       { subagent_id: 'nonexistent-id' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -90,7 +88,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('abort returns error when missing subagent_id', async () => {
-    const result = await subagentAbortTool.execute(
+    const result = await executeSubagentAbort(
       {},
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -99,7 +97,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('message returns error for unknown subagent_id', async () => {
-    const result = await subagentMessageTool.execute(
+    const result = await executeSubagentMessage(
       { subagent_id: 'nonexistent-id', content: 'hello' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -108,7 +106,7 @@ describe('Subagent tool execute validation', () => {
   });
 
   test('message returns error when missing required fields', async () => {
-    const result = await subagentMessageTool.execute(
+    const result = await executeSubagentMessage(
       { subagent_id: 'some-id' },
       { workingDir: '/tmp', sessionId: 'sess-1', conversationId: 'conv-1' },
     );
@@ -116,3 +114,105 @@ describe('Subagent tool execute validation', () => {
     expect(result.content).toContain('required');
   });
 });
+
+// ── Ownership validation tests ──────────────────────────────────────
+
+/**
+ * Inject a fake subagent into the singleton manager so tool executors
+ * can find it. Uses the same private-internals trick as the notify tests.
+ */
+function injectSubagent(
+  manager: SubagentManager,
+  subagentId: string,
+  parentSessionId: string,
+  status: SubagentState['status'] = 'running',
+): void {
+  const internals = manager as unknown as {
+    subagents: Map<string, { session: unknown; state: SubagentState; parentSendToClient: () => void }>;
+    parentToChildren: Map<string, Set<string>>;
+  };
+  const state: SubagentState = {
+    config: { id: subagentId, parentSessionId, label: 'Test', objective: 'test' },
+    status,
+    conversationId: `conv-${subagentId}`,
+    createdAt: Date.now(),
+    usage: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+  };
+  const fakeSession = {
+    abort: () => {},
+    dispose: () => {},
+    messages: [],
+    sendToClient: () => {},
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+  };
+  internals.subagents.set(subagentId, { session: fakeSession, state, parentSendToClient: () => {} });
+  if (!internals.parentToChildren.has(parentSessionId)) {
+    internals.parentToChildren.set(parentSessionId, new Set());
+  }
+  internals.parentToChildren.get(parentSessionId)!.add(subagentId);
+}
+
+import { getSubagentManager } from '../subagent/index.js';
+
+describe('Subagent tool ownership validation', () => {
+  const ownerSession = 'owner-sess';
+  const otherSession = 'other-sess';
+  const subagentId = 'owned-sub-1';
+
+  // Inject once — all tests share this subagent.
+  const manager = getSubagentManager();
+  injectSubagent(manager, subagentId, ownerSession);
+
+  test('status rejects non-owner session', async () => {
+    const result = await executeSubagentStatus(
+      { subagent_id: subagentId },
+      { workingDir: '/tmp', sessionId: otherSession, conversationId: 'conv-1' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No subagent found');
+  });
+
+  test('status succeeds for owner session', async () => {
+    const result = await executeSubagentStatus(
+      { subagent_id: subagentId },
+      { workingDir: '/tmp', sessionId: ownerSession, conversationId: 'conv-1' },
+    );
+    expect(result.isError).toBe(false);
+  });
+
+  test('message rejects non-owner session', async () => {
+    const result = await executeSubagentMessage(
+      { subagent_id: subagentId, content: 'hello' },
+      { workingDir: '/tmp', sessionId: otherSession, conversationId: 'conv-1' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Could not send');
+  });
+
+  test('read rejects non-owner session', async () => {
+    const result = await executeSubagentRead(
+      { subagent_id: subagentId },
+      { workingDir: '/tmp', sessionId: otherSession, conversationId: 'conv-1' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No subagent found');
+  });
+
+  test('abort rejects non-owner session', async () => {
+    const result = await executeSubagentAbort(
+      { subagent_id: subagentId },
+      { workingDir: '/tmp', sessionId: otherSession, conversationId: 'conv-1' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Could not abort');
+  });
+
+  test('abort succeeds for owner session', async () => {
+    const result = await executeSubagentAbort(
+      { subagent_id: subagentId },
+      { workingDir: '/tmp', sessionId: ownerSession, conversationId: 'conv-1' },
+    );
+    // Abort succeeds (subagent was running)
+    expect(result.isError).toBe(false);
+  });
+});

package/src/__tests__/task-compiler.test.ts

@@ -35,7 +35,7 @@ mock.module('./indexer.js', () => ({
 }));
 
 import type { Database } from 'bun:sqlite';
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { renderTemplate } from '../tasks/task-runner.js';
 import { compileTaskFromConversation, saveCompiledTask } from '../tasks/task-compiler.js';
 import { getTask } from '../tasks/task-store.js';
@@ -43,6 +43,7 @@ import { getTask } from '../tasks/task-store.js';
 initializeDb();
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });
 

package/src/__tests__/task-runner.test.ts

@@ -25,7 +25,7 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { createTask } from '../tasks/task-store.js';
 import { getTaskRunRules } from '../tasks/ephemeral-permissions.js';
 import { renderTemplate, runTask } from '../tasks/task-runner.js';
@@ -33,6 +33,7 @@ import { renderTemplate, runTask } from '../tasks/task-runner.js';
 initializeDb();
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });
 

package/src/__tests__/task-scheduler.test.ts

@@ -25,7 +25,7 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { createTask } from '../tasks/task-store.js';
 import { scheduleTask } from '../tasks/task-scheduler.js';
 import {
@@ -48,6 +48,7 @@ function forceScheduleDue(scheduleId: string): void {
 }
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });