create-agent-rig 0.9.1 → 0.10.0

package/templates/skeleton/node-service/services/api/test/list-notes.test.ts

@@ -1,48 +0,0 @@
-import { AppError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { makeListNotesHandler } from '../src/handlers/list-notes.js';
-import { listNotesUsecase } from '../src/usecases/list-notes.js';
-
-const note = {
-  id: 'n1',
-  title: 'Hello',
-  slug: 'hello',
-  tags: [],
-  createdAt: '2024-01-01T00:00:00.000Z',
-};
-
-describe('listNotesUsecase', () => {
-  it('returns what the store lists', async () => {
-    expect(await listNotesUsecase({ notes: { list: async () => [note] } })).toEqual([note]);
-  });
-});
-
-describe('GET /notes handler', () => {
-  it('returns 200 with the notes', async () => {
-    const handler = makeListNotesHandler({
-      notes: { list: async () => [note] },
-      log: createLogger({}, () => {}),
-    });
-    const result = await handler();
-    expect(result.statusCode).toBe(200);
-    expect(JSON.parse(result.body)).toEqual({ notes: [note] });
-  });
-
-  it('maps typed errors and hides unknown ones', async () => {
-    const typed = makeListNotesHandler({
-      notes: { list: () => Promise.reject(new AppError('nope', { statusCode: 503, code: 'X' })) },
-      log: createLogger({}, () => {}),
-    });
-    expect((await typed()).statusCode).toBe(503);
-
-    const logs: string[] = [];
-    const unknown = makeListNotesHandler({
-      notes: { list: () => Promise.reject(new Error('secret')) },
-      log: createLogger({}, (line) => logs.push(line)),
-    });
-    const result = await unknown();
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('secret');
-    expect(logs.join('')).toContain('secret');
-  });
-});

package/templates/skeleton/node-service/services/api/test/package-manager.test.ts

@@ -1,40 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { runPackageManager } from './package-manager.js';
-
-const literalArgs = ['space value', '&|<>^%!()', 'single "double"', ''];
-
-describe('package-manager transport for the artifact fallback', () => {
-  let work: string | undefined;
-
-  afterEach(async () => {
-    if (work !== undefined) await rm(work, { recursive: true, force: true });
-  });
-
-  it('honors the trusted current pnpm CLI on every platform with literal argv and preserves a failing child output', async () => {
-    work = await mkdtemp(path.join(tmpdir(), 'artifact-package-manager-'));
-    const cli = path.join(work, 'pnpm-cli.cjs');
-    await writeFile(
-      cli,
-      [
-        'process.stdout.write(JSON.stringify(process.argv.slice(2)));',
-        "process.stderr.write('artifact transport stderr');",
-        'process.exit(7);',
-      ].join(''),
-    );
-
-    const failure = await runPackageManager(literalArgs, {
-      cwd: work,
-      env: { ...process.env, npm_execpath: cli },
-    }).catch((error: unknown) => error);
-
-    expect(failure).toMatchObject({
-      code: 7,
-      stdout: JSON.stringify(literalArgs),
-      stderr: 'artifact transport stderr',
-    });
-  });
-});

package/templates/skeleton/node-service/services/api/test/package-manager.ts

@@ -1,51 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { promisify } from 'node:util';
-
-const exec = promisify(execFile);
-
-const currentPnpmCli = (environment: NodeJS.ProcessEnv): string | undefined => {
-  const currentCli = environment.npm_execpath;
-  if (currentCli && /^pnpm(?:-cli)?\.(?:cjs|js)$/i.test(path.basename(currentCli)) && existsSync(currentCli)) {
-    return currentCli;
-  }
-  return undefined;
-};
-
-const pnpmCli = (environment: NodeJS.ProcessEnv): string => {
-  const currentCli = currentPnpmCli(environment);
-  if (currentCli) return currentCli;
-
-  const installedCli = path.join(
-    path.dirname(process.execPath),
-    'node_modules',
-    'pnpm',
-    'bin',
-    'pnpm.cjs',
-  );
-  if (existsSync(installedCli)) return installedCli;
-
-  const corepackCli = path.join(
-    path.dirname(process.execPath),
-    'node_modules',
-    'corepack',
-    'dist',
-    'pnpm.js',
-  );
-  if (existsSync(corepackCli)) return corepackCli;
-
-  throw new Error('Cannot locate pnpm JavaScript CLI; npm_execpath must name the installed pnpm CLI');
-};
-
-/** Runs the workspace package manager without passing its arguments through a Windows shell. */
-export const runPackageManager = (
-  args: string[],
-  options: Parameters<typeof exec>[2],
-): ReturnType<typeof exec> => {
-  const environment = options?.env ?? process.env;
-  const currentCli = currentPnpmCli(environment);
-  if (currentCli) return exec(process.execPath, [currentCli, ...args], options);
-  if (process.platform !== 'win32') return exec('pnpm', args, options);
-  return exec(process.execPath, [pnpmCli(environment), ...args], options);
-};

package/templates/skeleton/node-service/services/api/test/server.test.ts

@@ -1,208 +0,0 @@
-// Integration: the real HTTP server over a real socket, with real file
-// storage and a real spool directory — the whole request path at once.
-import { chmod, mkdir, mkdtemp, readdir, rm, symlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import type { AddressInfo } from 'node:net';
-import path from 'node:path';
-import { JsonFileNoteStore } from '@app/db';
-import { createLogger } from '@app/shared';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { Server } from 'node:http';
-import { SpoolEventPublisher } from '../src/adapters/spool-publisher.js';
-import { makeServer } from '../src/server.js';
-
-let dir: string;
-let server: Server;
-let baseUrl: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(path.join(tmpdir(), 'api-int-'));
-  let n = 0;
-  server = makeServer({
-    notes: new JsonFileNoteStore(path.join(dir, 'data', 'notes.json')),
-    events: new SpoolEventPublisher(path.join(dir, 'queue'), () => `msg-${++n}`),
-    newId: () => `id-${++n}`,
-    now: () => '2024-01-01T00:00:00.000Z',
-    log: createLogger({}, () => {}),
-  });
-  await new Promise<void>((resolve) => server.listen(0, resolve));
-  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-});
-
-afterEach(async () => {
-  await new Promise((resolve) => server.close(resolve));
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('the service end to end', () => {
-  it('creates a note over HTTP, persists it, and spools the event', async () => {
-    const response = await fetch(`${baseUrl}/notes`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ title: 'Integration proof', tags: ['e2e'] }),
-    });
-    expect(response.status).toBe(201);
-    const { note } = (await response.json()) as { note: { slug: string } };
-    expect(note.slug).toBe('integration-proof');
-
-    expect(await readdir(path.join(dir, 'queue'))).toHaveLength(1);
-    expect(await readdir(path.join(dir, 'data'))).toContain('notes.json');
-  });
-
-  it('rejects invalid input with 400', async () => {
-    const response = await fetch(`${baseUrl}/notes`, {
-      method: 'POST',
-      body: JSON.stringify({ title: '' }),
-    });
-    expect(response.status).toBe(400);
-  });
-
-  it('404s unknown routes', async () => {
-    const response = await fetch(`${baseUrl}/other`);
-    expect(response.status).toBe(404);
-  });
-
-  it('lists created notes back on GET /notes (the UI read path)', async () => {
-    for (const title of ['First note', 'Second note']) {
-      await fetch(`${baseUrl}/notes`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ title }),
-      });
-    }
-    const response = await fetch(`${baseUrl}/notes`);
-    expect(response.status).toBe(200);
-    const { notes } = (await response.json()) as { notes: Array<{ title: string }> };
-    expect(notes).toHaveLength(2);
-  });
-
-  it('refuses a request body larger than the cap with 413', async () => {
-    // Well-formed JSON on purpose: what is rejected is the size, not the shape.
-    // The server must answer before it has buffered the whole upload, and must
-    // stay readable long enough for the client to see that answer.
-    const body = JSON.stringify({ title: 'x'.repeat(1024 * 1024 + 1024) });
-    const response = await fetch(`${baseUrl}/notes`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body,
-    });
-    expect(response.status).toBe(413);
-  });
-});
-
-/** A listening server serving `staticDir`, plus its base URL. */
-async function startStaticServer(staticDir: string): Promise<{ server: Server; base: string }> {
-  const server = makeServer(
-    {
-      notes: new JsonFileNoteStore(path.join(dir, 'data', 'notes.json')),
-      events: new SpoolEventPublisher(path.join(dir, 'queue'), () => 'm'),
-      newId: () => 'id',
-      now: () => '2024-01-01T00:00:00.000Z',
-      log: createLogger({}, () => {}),
-    },
-    { staticDir },
-  );
-  await new Promise<void>((resolve) => server.listen(0, resolve));
-  return { server, base: `http://127.0.0.1:${(server.address() as AddressInfo).port}` };
-}
-
-// Windows has no POSIX mode bits, and root reads a 0o000 file regardless — in
-// both cases the "unreadable file" this test needs cannot be built at all.
-const cannotMakeFileUnreadable = process.platform === 'win32' || process.getuid?.() === 0;
-// Creating a symlink on Windows needs a privilege the test runner may not hold.
-const cannotSymlink = process.platform === 'win32';
-
-describe('static serving (the built web bundle)', () => {
-  let staticServer: Server;
-  let staticBase: string;
-
-  beforeEach(async () => {
-    await mkdir(path.join(dir, 'static'), { recursive: true });
-    await writeFile(path.join(dir, 'static', 'index.html'), '<h1>web shell</h1>');
-    ({ server: staticServer, base: staticBase } = await startStaticServer(
-      path.join(dir, 'static'),
-    ));
-  });
-
-  afterEach(async () => {
-    await new Promise((resolve) => staticServer.close(resolve));
-  });
-
-  it('serves index.html at the root', async () => {
-    const response = await fetch(staticBase + '/');
-    expect(response.status).toBe(200);
-    expect(response.headers.get('content-type')).toContain('text/html');
-    expect(await response.text()).toContain('web shell');
-  });
-
-  it('refuses path traversal out of the static dir', async () => {
-    await writeFile(path.join(dir, 'secret.txt'), 'nope');
-    const response = await fetch(staticBase + '/%2e%2e/secret.txt');
-    expect(response.status).toBe(404);
-  });
-
-  it('API routes still win over static files', async () => {
-    const response = await fetch(staticBase + '/notes');
-    expect(response.status).toBe(200);
-    expect(response.headers.get('content-type')).toContain('application/json');
-  });
-
-  it('answers 400 to an undecodable URL and keeps serving afterwards', async () => {
-    // The signal is a leash, not a relaxation: a server that dies on this URL
-    // never answers at all, and the run should say so in seconds.
-    const response = await fetch(staticBase + '/%', { signal: AbortSignal.timeout(5000) });
-    expect(response.status).toBe(400);
-
-    const afterwards = await fetch(staticBase + '/');
-    expect(afterwards.status).toBe(200);
-    expect(await afterwards.text()).toContain('web shell');
-  });
-
-  it.skipIf(cannotMakeFileUnreadable)(
-    'answers a file it cannot open and keeps serving afterwards',
-    async () => {
-      // A file that passes stat() but fails open() (EACCES here; in production
-      // the stat/open race gives ENOENT). Before the headers are held back
-      // until the stream opens, that error reached no handler at all and the
-      // process paid for one unreadable file.
-      const locked = path.join(dir, 'static', 'locked.txt');
-      await writeFile(locked, 'unreadable');
-      await chmod(locked, 0o000);
-      try {
-        const response = await fetch(staticBase + '/locked.txt', {
-          signal: AbortSignal.timeout(5000),
-        });
-        expect(response.status).toBe(500);
-
-        const afterwards = await fetch(staticBase + '/');
-        expect(afterwards.status).toBe(200);
-        expect(await afterwards.text()).toContain('web shell');
-      } finally {
-        // Restore before afterEach removes the temp dir.
-        await chmod(locked, 0o600);
-      }
-    },
-  );
-
-  it.skipIf(cannotSymlink)('refuses a symlink that escapes the static dir', async () => {
-    // A lexical guard inspects only the resolved string, while stat and the
-    // read stream follow the link wherever it points — which is why the guard
-    // asks realpath as well.
-    await writeFile(path.join(dir, 'secret-target.txt'), 'nope');
-    await symlink(path.join(dir, 'secret-target.txt'), path.join(dir, 'static', 'escape.txt'));
-
-    const response = await fetch(staticBase + '/escape.txt');
-    expect(response.status).toBe(404);
-  });
-
-  it('serves the bundle when the configured static dir has a trailing separator', async () => {
-    const { server, base } = await startStaticServer(path.join(dir, 'static') + path.sep);
-    try {
-      const response = await fetch(base + '/');
-      expect(response.status).toBe(200);
-      expect(await response.text()).toContain('web shell');
-    } finally {
-      await new Promise((resolve) => server.close(resolve));
-    }
-  });
-});

package/templates/skeleton/node-service/services/api/test/spool-publisher.test.ts

@@ -1,32 +0,0 @@
-import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { createNote, makeNoteCreatedEvent } from '@app/core';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { SpoolEventPublisher } from '../src/adapters/spool-publisher.js';
-
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(path.join(tmpdir(), 'spool-'));
-});
-
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('SpoolEventPublisher', () => {
-  it('writes one complete JSON message file per event', async () => {
-    const queueDir = path.join(dir, 'queue');
-    let n = 0;
-    const publisher = new SpoolEventPublisher(queueDir, () => `msg-${++n}`);
-    const note = createNote({ title: 'Hi' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-    const event = makeNoteCreatedEvent(note);
-    await publisher.publish(event);
-    await publisher.publish(event);
-
-    const files = (await readdir(queueDir)).sort();
-    expect(files).toEqual(['msg-1.json', 'msg-2.json']);
-    expect(JSON.parse(await readFile(path.join(queueDir, 'msg-1.json'), 'utf8'))).toEqual(event);
-  });
-});

package/templates/skeleton/node-service/services/api/test/static-dir.test.ts

@@ -1,29 +0,0 @@
-// The composition root resolves the built web bundle relative to itself; the
-// resolution is a pure function so it can be tested without importing main.ts.
-//
-// This native absolute fixture exercises the platform root spelling and
-// percent-decoding without injecting a path flavor into the production helper.
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { describe, expect, it } from 'vitest';
-import { defaultStaticDirFor } from '../src/static-dir.js';
-
-const moduleUrl = pathToFileURL(
-  path.join(path.parse(process.cwd()).root, 'a b', 'proj', 'services', 'api', 'src', 'main.ts'),
-).href;
-
-describe('resolving the default static dir from the module url', () => {
-  it('decodes percent-escapes in the path (a directory may contain a space)', () => {
-    const resolved = defaultStaticDirFor(moduleUrl);
-
-    expect(resolved).toContain('a b');
-    expect(resolved).not.toContain('%20');
-  });
-
-  it('points three levels up from services/api/src at apps/web/out', () => {
-    const resolved = defaultStaticDirFor(moduleUrl);
-
-    expect(resolved.endsWith(path.join('a b', 'proj', 'apps', 'web', 'out'))).toBe(true);
-    expect(path.isAbsolute(resolved)).toBe(true);
-  });
-});

package/templates/skeleton/node-service/services/worker/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "@app/worker",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/main.ts",
-  "types": "src/main.ts",
-  "scripts": {
-    "start": "tsx src/main.ts"
-  },
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/shared": "workspace:*",
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/node-service/services/worker/src/main.ts

@@ -1,28 +0,0 @@
-// Composition root — the worker as a long-running process polling the spool.
-import { z } from 'zod';
-import { createLogger, loadEnv } from '@app/shared';
-import { processNoteCreated } from './usecases/process-note-created.js';
-import { processSpoolOnce } from './spool.js';
-
-const env = loadEnv(
-  z.object({
-    QUEUE_DIR: z.string().min(1).default('var/queue'),
-    DLQ_DIR: z.string().min(1).default('var/dlq'),
-    POLL_INTERVAL_MS: z.coerce.number().int().positive().default(1000),
-  }),
-  process.env,
-);
-
-const log = createLogger({ service: 'worker' });
-const config = { queueDir: env.QUEUE_DIR, dlqDir: env.DLQ_DIR, maxAttempts: 3 };
-const deps = { log, process: (raw: string) => processNoteCreated(raw, { log }) };
-
-log.info('worker polling', { queueDir: env.QUEUE_DIR, intervalMs: env.POLL_INTERVAL_MS });
-
-const tick = async () => {
-  const processed = await processSpoolOnce(config, deps);
-  if (processed > 0) log.info('spool pass complete', { processed });
-  setTimeout(() => void tick(), env.POLL_INTERVAL_MS);
-};
-
-void tick();

package/templates/skeleton/node-service/services/worker/src/spool.ts

@@ -1,60 +0,0 @@
-// A directory is the queue: one JSON file per message. Retries are encoded in
-// the filename (msg.json → msg.retry1.json → …); after maxAttempts the file
-// moves to the DLQ directory and an alarm line is logged. Same discipline as
-// any managed queue — visible failure, bounded retries, no silent loss.
-import { mkdir, readFile, readdir, rename, rm } from 'node:fs/promises';
-import path from 'node:path';
-import type { Logger } from '@app/shared';
-
-export interface SpoolConfig {
-  queueDir: string;
-  dlqDir: string;
-  /** Total attempts a message gets before it is dead-lettered. */
-  maxAttempts: number;
-}
-
-export interface SpoolDeps {
-  log: Logger;
-  process(raw: string): Promise<void>;
-}
-
-const RETRY_PATTERN = /\.retry(\d+)\.json$/;
-
-const attemptOf = (name: string): number => {
-  const match = RETRY_PATTERN.exec(name);
-  return match ? Number.parseInt(match[1]!, 10) + 1 : 1;
-};
-
-const withRetrySuffix = (name: string, attempt: number): string =>
-  name.replace(/(\.retry\d+)?\.json$/, `.retry${attempt}.json`);
-
-/** One pass over the queue. Returns how many messages were processed successfully. */
-export async function processSpoolOnce(config: SpoolConfig, deps: SpoolDeps): Promise<number> {
-  await mkdir(config.queueDir, { recursive: true });
-  await mkdir(config.dlqDir, { recursive: true });
-  let processed = 0;
-
-  const entries = (await readdir(config.queueDir)).filter((name) => name.endsWith('.json')).sort();
-  for (const name of entries) {
-    const file = path.join(config.queueDir, name);
-    try {
-      await deps.process(await readFile(file, 'utf8'));
-      await rm(file);
-      processed += 1;
-    } catch (error) {
-      const attempt = attemptOf(name);
-      if (attempt >= config.maxAttempts) {
-        await rename(file, path.join(config.dlqDir, name));
-        deps.log.error('ALARM: message dead-lettered', {
-          file: name,
-          attempts: attempt,
-          error: String(error),
-        });
-      } else {
-        await rename(file, path.join(config.queueDir, withRetrySuffix(name, attempt)));
-        deps.log.warn('message failed, will retry', { file: name, attempt });
-      }
-    }
-  }
-  return processed;
-}

package/templates/skeleton/node-service/services/worker/src/usecases/process-note-created.ts

@@ -1,38 +0,0 @@
-// Queue discipline: validate the message against the shared event schema; a
-// message that does not parse is poison — throw, let the spool retry it, and
-// after the retry budget the DLQ directory (watched by the alarm log line)
-// catches it. Never swallow poison.
-import { NoteCreatedEventSchema, type NoteCreatedEvent } from '@app/core';
-import { ValidationError, type Logger } from '@app/shared';
-
-export interface ProcessDeps {
-  log: Logger;
-}
-
-export function parseNoteCreatedEvent(raw: string): NoteCreatedEvent {
-  let candidate: unknown;
-  try {
-    candidate = JSON.parse(raw);
-  } catch {
-    throw new ValidationError('message body is not JSON');
-  }
-  const parsed = NoteCreatedEventSchema.safeParse(candidate);
-  if (!parsed.success) {
-    throw new ValidationError(
-      'message is not a note.created event',
-      parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`),
-    );
-  }
-  return parsed.data;
-}
-
-export async function processNoteCreated(raw: string, deps: ProcessDeps): Promise<void> {
-  const event = parseNoteCreatedEvent(raw);
-  // The skeleton's "processing" is deliberately small: acknowledge the note.
-  // Replace this with real downstream work; keep the validate-first shape.
-  deps.log.info('note.created processed', {
-    noteId: event.note.id,
-    slug: event.note.slug,
-    tagCount: event.note.tags.length,
-  });
-}

package/templates/skeleton/node-service/services/worker/test/process-note-created.test.ts

@@ -1,34 +0,0 @@
-import { createNote, makeNoteCreatedEvent } from '@app/core';
-import { ValidationError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { parseNoteCreatedEvent, processNoteCreated } from '../src/usecases/process-note-created.js';
-
-const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-const validBody = JSON.stringify(makeNoteCreatedEvent(note));
-
-describe('parseNoteCreatedEvent', () => {
-  it('parses a valid event', () => {
-    expect(parseNoteCreatedEvent(validBody).note.id).toBe('n1');
-  });
-
-  it('throws ValidationError for non-JSON bodies', () => {
-    expect(() => parseNoteCreatedEvent('not json')).toThrow(ValidationError);
-  });
-
-  it('throws ValidationError for JSON that is not a note.created event', () => {
-    expect(() => parseNoteCreatedEvent(JSON.stringify({ type: 'other' }))).toThrow(ValidationError);
-  });
-});
-
-describe('processNoteCreated', () => {
-  it('logs the processed note', async () => {
-    const lines: string[] = [];
-    await processNoteCreated(validBody, { log: createLogger({}, (line) => lines.push(line)) });
-    expect(lines.join('\n')).toContain('n1');
-  });
-
-  it('lets poison messages throw — the DLQ is the safety net, not a catch block', async () => {
-    const log = createLogger({}, () => {});
-    await expect(processNoteCreated('poison', { log })).rejects.toThrow(ValidationError);
-  });
-});

package/templates/skeleton/node-service/services/worker/test/spool.test.ts

@@ -1,76 +0,0 @@
-import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { createNote, makeNoteCreatedEvent } from '@app/core';
-import { createLogger } from '@app/shared';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { processNoteCreated } from '../src/usecases/process-note-created.js';
-import { processSpoolOnce, type SpoolConfig } from '../src/spool.js';
-
-const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-const validBody = JSON.stringify(makeNoteCreatedEvent(note));
-
-let dir: string;
-let config: SpoolConfig;
-
-beforeEach(async () => {
-  dir = await mkdtemp(path.join(tmpdir(), 'spool-worker-'));
-  config = {
-    queueDir: path.join(dir, 'queue'),
-    dlqDir: path.join(dir, 'dlq'),
-    maxAttempts: 3,
-  };
-});
-
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-function makeDeps() {
-  const lines: string[] = [];
-  const log = createLogger({}, (line) => lines.push(line));
-  return { deps: { log, process: (raw: string) => processNoteCreated(raw, { log }) }, lines };
-}
-
-async function spool(name: string, content: string) {
-  await writeFile(path.join(config.queueDir, name), content);
-}
-
-describe('processSpoolOnce', () => {
-  it('processes valid messages and removes them', async () => {
-    const { deps, lines } = makeDeps();
-    await processSpoolOnce(config, deps); // creates the dirs
-    await spool('m1.json', validBody);
-    await spool('m2.json', validBody);
-
-    expect(await processSpoolOnce(config, deps)).toBe(2);
-    expect(await readdir(config.queueDir)).toEqual([]);
-    expect(await readdir(config.dlqDir)).toEqual([]);
-    expect(lines.filter((l) => l.includes('note.created processed'))).toHaveLength(2);
-  });
-
-  it('retries poison, then dead-letters it with an ALARM after maxAttempts', async () => {
-    const { deps, lines } = makeDeps();
-    await processSpoolOnce(config, deps);
-    await spool('poison.json', 'not json');
-
-    expect(await processSpoolOnce(config, deps)).toBe(0); // attempt 1 → retry1
-    expect(await readdir(config.queueDir)).toEqual(['poison.retry1.json']);
-    expect(await processSpoolOnce(config, deps)).toBe(0); // attempt 2 → retry2
-    expect(await readdir(config.queueDir)).toEqual(['poison.retry2.json']);
-    expect(await processSpoolOnce(config, deps)).toBe(0); // attempt 3 → DLQ
-    expect(await readdir(config.queueDir)).toEqual([]);
-    expect(await readdir(config.dlqDir)).toEqual(['poison.retry2.json']);
-    expect(lines.some((line) => line.includes('ALARM'))).toBe(true);
-  });
-
-  it('keeps processing good messages when one is poison', async () => {
-    const { deps } = makeDeps();
-    await processSpoolOnce(config, deps);
-    await spool('a-poison.json', '{broken');
-    await spool('b-good.json', validBody);
-
-    expect(await processSpoolOnce(config, deps)).toBe(1);
-    expect(await readdir(config.queueDir)).toEqual(['a-poison.retry1.json']);
-  });
-});