nfo-cli 0.0.4-improve-prompting → 0.0.5

package/tests/musicians/message.test.ts

@@ -1,159 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { messageMusician } from '../../src/musicians/message.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState, readState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { addMusician } from '../../src/state-updaters.js';
-import {
-  createDetachedSession,
-  sessionName,
-  killSession,
-  capturePane,
-} from '../../src/tmux.js';
-import { execa } from 'execa';
-import { messageLogsDir } from '../../src/config.js';
-
-describe('messageMusician', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('throws when musician is unknown', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const id = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(id);
-    await writeState(id, makeInitialState({
-      orchestraId: id, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    await expect(
-      messageMusician({ orchestraId: id, musicianId: 'mus-999', message: 'hi' }),
-    ).rejects.toThrow(/Unknown musician/);
-  });
-
-  it("sends keys + Enter immediately when the musician is idle", async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    const sess = sessionName(orchId);
-    sessionsToKill.push(sess);
-    await createDetachedSession(sess, repo.path, 220, 50);
-    const { stdout: winId } = await execa('tmux', [
-      'new-window', '-t', sess, '-n', 'mus-001-tester', '-c', repo.path, '-d',
-      '-P', '-F', '#{window_id}',
-    ]);
-
-    await addMusician(orchId, {
-      id: 'mus-001',
-      name: 'tester',
-      task_summary: 't',
-      status: 'idle',
-      tmux_window_id: winId.trim(),
-      claude_session_id: null,
-      worktree_path: null,
-      branch: null,
-      spawned_at: '2026-05-29T10:00:00Z',
-      last_activity: '2026-05-29T10:00:00Z',
-    });
-
-    const result = await messageMusician({
-      orchestraId: orchId,
-      musicianId: 'mus-001',
-      message: 'echo nfo-message-test',
-    });
-    await new Promise(r => setTimeout(r, 250));
-    const out = await capturePane(`${sess}:${winId.trim()}`, 20);
-    expect(out).toContain('nfo-message-test');
-    expect(result.delivery).toBe('immediate');
-    expect(result.pending_messages).toBe(0);
-
-    const state = await readState(orchId);
-    expect(state!.musicians[0].last_activity).not.toBe('2026-05-29T10:00:00Z');
-    expect(state!.musicians[0].status).toBe('working');
-
-    const log = await readFile(join(messageLogsDir(orchId), 'mus-001.jsonl'), 'utf8');
-    expect(log).toContain('"type":"message_queued"');
-    expect(log).toContain('"type":"message_delivered"');
-  });
-
-  it('queues follow-up work when the musician is still working', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    const sess = sessionName(orchId);
-    sessionsToKill.push(sess);
-    await createDetachedSession(sess, repo.path, 220, 50);
-    const { stdout: winId } = await execa('tmux', [
-      'new-window', '-t', sess, '-n', 'mus-001-tester', '-c', repo.path, '-d',
-      '-P', '-F', '#{window_id}',
-    ]);
-
-    await addMusician(orchId, {
-      id: 'mus-001',
-      name: 'tester',
-      task_summary: 't',
-      status: 'working',
-      tmux_window_id: winId.trim(),
-      claude_session_id: null,
-      worktree_path: null,
-      branch: null,
-      spawned_at: '2026-05-29T10:00:00Z',
-      last_activity: '2026-05-29T10:00:00Z',
-    });
-
-    const result = await messageMusician({
-      orchestraId: orchId,
-      musicianId: 'mus-001',
-      message: 'echo should-not-run-yet',
-    });
-    await new Promise(r => setTimeout(r, 250));
-    const out = await capturePane(`${sess}:${winId.trim()}`, 20);
-    expect(out).not.toContain('should-not-run-yet');
-    expect(result.delivery).toBe('queued');
-    expect(result.pending_messages).toBe(1);
-
-    const state = await readState(orchId);
-    expect(state!.musicians[0].last_activity).toBe('2026-05-29T10:00:00Z');
-
-    const log = await readFile(join(messageLogsDir(orchId), 'mus-001.jsonl'), 'utf8');
-    expect(log).toContain('"type":"message_queued"');
-    expect(log).not.toContain('"type":"message_delivered"');
-  });
-});

package/tests/musicians/query.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { queryMusician } from '../../src/musicians/query.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { addMusician } from '../../src/state-updaters.js';
-import { createDetachedSession, sessionName, killSession, sendKeys } from '../../src/tmux.js';
-import { execa } from 'execa';
-
-describe('queryMusician', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('returns the visible content of the musician pane', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    const sess = sessionName(orchId);
-    sessionsToKill.push(sess);
-    await createDetachedSession(sess, repo.path, 220, 50);
-    const { stdout: winId } = await execa('tmux', [
-      'new-window', '-t', sess, '-n', 'mus-001-q', '-c', repo.path, '-d',
-      '-P', '-F', '#{window_id}',
-    ]);
-    await addMusician(orchId, baseMus('mus-001', winId.trim()));
-
-    await sendKeys(`${sess}:${winId.trim()}`, 'echo nfo-query-marker', true);
-    await new Promise(r => setTimeout(r, 250));
-
-    const out = await queryMusician({ orchestraId: orchId, musicianId: 'mus-001' });
-    expect(out).toContain('nfo-query-marker');
-  });
-});
-
-function baseMus(id: string, winId: string) {
-  return {
-    id, name: 'q', task_summary: 't', status: 'working' as const,
-    tmux_window_id: winId, claude_session_id: null, worktree_path: null,
-    branch: null,
-    spawned_at: '2026-05-29T10:00:00Z', last_activity: '2026-05-29T10:00:00Z',
-  };
-}

package/tests/musicians/spawn.test.ts

@@ -1,125 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { createMusician } from '../../src/musicians/spawn.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { readState, ensureOrchestraDir, writeState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import {
-  createDetachedSession,
-  sessionName,
-  killSession,
-  sessionExists,
-} from '../../src/tmux.js';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { orchestraDir } from '../../src/config.js';
-import { MUSICIAN_ROLE_PROMPT_V1 } from '../../src/prompts/musician-role.js';
-import { musicianMcpConfigPath } from '../../src/mcp/config.js';
-
-describe('createMusician', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('creates a worktree, a tmux window, and a state.json entry', async () => {
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-
-    const orchestraId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchestraId);
-    await writeState(orchestraId, makeInitialState({
-      orchestraId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    const name = sessionName(orchestraId);
-    sessionsToKill.push(name);
-    await createDetachedSession(name, repo.path, 220, 50);
-
-    const result = await createMusician({
-      orchestraId,
-      name: 'tester',
-      task: 'run the test suite',
-      model: 'haiku',
-      dryRun: true,
-    });
-
-    expect(result.musician_id).toMatch(/^mus-\d{3}$/);
-    expect(result.worktree_path).not.toBeNull();
-    if (result.worktree_path) {
-      expect(existsSync(result.worktree_path)).toBe(true);
-    }
-
-    const state = await readState(orchestraId);
-    expect(state!.musicians).toHaveLength(1);
-    expect(state!.musicians[0].name).toBe('tester');
-    expect(state!.musicians[0].task_summary).toBe('run the test suite');
-    expect(state!.musicians[0].status).toBe('working');
-    expect(state!.musicians[0].model).toBe('haiku');
-
-    const promptFile = await readFile(
-      `${orchestraDir(orchestraId)}/musician-${result.musician_id}-prompt.md`,
-      'utf8',
-    );
-    expect(promptFile).toBe(MUSICIAN_ROLE_PROMPT_V1);
-
-    const mcpConfig = JSON.parse(await readFile(
-      musicianMcpConfigPath(orchestraId, result.musician_id),
-      'utf8',
-    ));
-    expect(mcpConfig.mcpServers.nfo.args).toEqual([
-      'mcp-server',
-      '--orchestra-id',
-      orchestraId,
-      '--caller-musician-id',
-      result.musician_id,
-    ]);
-  });
-
-  it('honours worktree=false (no worktree, runs in repo root)', async () => {
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-
-    const orchestraId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchestraId);
-    await writeState(orchestraId, makeInitialState({
-      orchestraId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-
-    const name = sessionName(orchestraId);
-    sessionsToKill.push(name);
-    await createDetachedSession(name, repo.path, 220, 50);
-
-    const result = await createMusician({
-      orchestraId,
-      name: 'doc-writer',
-      task: 'update README',
-      worktree: false,
-      model: 'sonnet',
-      dryRun: true,
-    });
-
-    expect(result.worktree_path).toBeNull();
-    const state = await readState(orchestraId);
-    expect(state!.musicians[0].worktree_path).toBeNull();
-    expect(state!.musicians[0].branch).toBeNull();
-    expect(state!.musicians[0].model).toBe('sonnet');
-  });
-});

package/tests/notes.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { noteRead, noteWrite, noteList } from '../src/notes.js';
-import { ensureOrchestraDir } from '../src/state.js';
-import { makeTmpConfig } from './helpers/tmp-config.js';
-
-describe('notes', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-  afterEach(async () => {
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('noteWrite then noteRead returns the written content', async () => {
-    const tmp = await makeTmpConfig();
-    cleanups.push(tmp.cleanup);
-    process.env.NFO_HOME = tmp.path;
-    await ensureOrchestraDir('orch-a');
-
-    await noteWrite('orch-a', 'overview.md', '# Project overview\n');
-    const back = await noteRead('orch-a', 'overview.md');
-    expect(back).toBe('# Project overview\n');
-  });
-
-  it('noteRead returns empty string for missing notes', async () => {
-    const tmp = await makeTmpConfig();
-    cleanups.push(tmp.cleanup);
-    process.env.NFO_HOME = tmp.path;
-    await ensureOrchestraDir('orch-b');
-
-    expect(await noteRead('orch-b', 'nope.md')).toBe('');
-  });
-
-  it('noteList returns all markdown filenames in notes/', async () => {
-    const tmp = await makeTmpConfig();
-    cleanups.push(tmp.cleanup);
-    process.env.NFO_HOME = tmp.path;
-    await ensureOrchestraDir('orch-c');
-    await noteWrite('orch-c', 'overview.md', 'a');
-    await noteWrite('orch-c', 'decisions.md', 'b');
-
-    const list = await noteList('orch-c');
-    expect(list.sort()).toEqual(['decisions.md', 'overview.md']);
-  });
-
-  it('rejects filenames containing path separators', async () => {
-    const tmp = await makeTmpConfig();
-    cleanups.push(tmp.cleanup);
-    process.env.NFO_HOME = tmp.path;
-    await ensureOrchestraDir('orch-d');
-    await expect(noteWrite('orch-d', '../escape.md', 'pwn')).rejects.toThrow(/invalid filename/i);
-    await expect(noteRead('orch-d', '../escape.md')).rejects.toThrow(/invalid filename/i);
-  });
-});

package/tests/notify.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { notifyAwaitingPermission } from '../src/notify.js';
-
-describe('notifyAwaitingPermission', () => {
-  it('writes a BEL character to the bell sink', async () => {
-    const bell = vi.fn();
-    const spawn = vi.fn().mockResolvedValue(undefined);
-    await notifyAwaitingPermission({
-      pendingCount: 1,
-      platform: 'linux',
-      bell,
-      spawn,
-    });
-    expect(bell).toHaveBeenCalledTimes(1);
-    expect(bell).toHaveBeenCalledWith('\x07');
-  });
-
-  it('on linux, spawns notify-send with NFO title and count message', async () => {
-    const spawn = vi.fn().mockResolvedValue(undefined);
-    await notifyAwaitingPermission({
-      pendingCount: 2,
-      platform: 'linux',
-      bell: vi.fn(),
-      spawn,
-    });
-    expect(spawn).toHaveBeenCalledTimes(1);
-    const [bin, args] = spawn.mock.calls[0];
-    expect(bin).toBe('notify-send');
-    expect(args).toEqual(['NFO', '2 musicians awaiting permission']);
-  });
-
-  it('on darwin, spawns osascript with display notification AppleScript', async () => {
-    const spawn = vi.fn().mockResolvedValue(undefined);
-    await notifyAwaitingPermission({
-      pendingCount: 1,
-      platform: 'darwin',
-      bell: vi.fn(),
-      spawn,
-    });
-    expect(spawn).toHaveBeenCalledTimes(1);
-    const [bin, args] = spawn.mock.calls[0];
-    expect(bin).toBe('osascript');
-    expect(args.length).toBe(2);
-    expect(args[0]).toBe('-e');
-    expect(args[1]).toContain('display notification');
-    expect(args[1]).toContain('1 musician awaiting permission');
-    expect(args[1]).toContain('NFO');
-  });
-
-  it('on unknown platform, fires bell only (no spawn)', async () => {
-    const spawn = vi.fn();
-    await notifyAwaitingPermission({
-      pendingCount: 1,
-      platform: 'win32',
-      bell: vi.fn(),
-      spawn,
-    });
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('swallows spawn errors silently', async () => {
-    const spawn = vi.fn().mockRejectedValue(new Error('notify-send not installed'));
-    await expect(notifyAwaitingPermission({
-      pendingCount: 1,
-      platform: 'linux',
-      bell: vi.fn(),
-      spawn,
-    })).resolves.toBeUndefined();
-  });
-
-  it('uses singular noun for count=1, plural otherwise', async () => {
-    const spawn1 = vi.fn().mockResolvedValue(undefined);
-    await notifyAwaitingPermission({ pendingCount: 1, platform: 'linux', bell: vi.fn(), spawn: spawn1 });
-    expect(spawn1.mock.calls[0][1]).toEqual(['NFO', '1 musician awaiting permission']);
-
-    const spawnN = vi.fn().mockResolvedValue(undefined);
-    await notifyAwaitingPermission({ pendingCount: 3, platform: 'linux', bell: vi.fn(), spawn: spawnN });
-    expect(spawnN.mock.calls[0][1]).toEqual(['NFO', '3 musicians awaiting permission']);
-  });
-});

package/tests/orchestrator/report-back.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatMusicianDonePrompt } from '../../src/orchestrator/report-back.js';
-
-describe('formatMusicianDonePrompt', () => {
-  it('requires a tool call instead of a prose acknowledgement', () => {
-    const prompt = formatMusicianDonePrompt({
-      musicianId: 'mus-007',
-      musicianName: 'fixer',
-      summary: 'Patched the failing assertion',
-      nextSteps: 'Ask me to add one more regression test if needed.',
-    });
-
-    expect(prompt).toContain('Resolve this now with an NFO tool call only:');
-    expect(prompt).toContain('dismiss_musician');
-    expect(prompt).toContain('message_musician');
-    expect(prompt).toContain('A plain-text acknowledgement is invalid here.');
-  });
-});

package/tests/permission.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  PERMISSION_LEVELS,
-  claudeFlagsForLevel,
-  isPermissionLevel,
-  type PermissionLevel,
-} from '../src/permission.js';
-
-describe('permission levels', () => {
-  it('lists all five levels in order from most to least permissive', () => {
-    expect(PERMISSION_LEVELS).toEqual([
-      'dangerouslySkipPermissions',
-      'auto',
-      'acceptEdits',
-      'supervised',
-      'strict',
-    ]);
-  });
-
-  it('isPermissionLevel rejects unknown strings', () => {
-    expect(isPermissionLevel('dangerouslySkipPermissions')).toBe(true);
-    expect(isPermissionLevel('auto')).toBe(true);
-    expect(isPermissionLevel('acceptEdits')).toBe(true);
-    expect(isPermissionLevel('supervised')).toBe(true);
-    expect(isPermissionLevel('strict')).toBe(true);
-    expect(isPermissionLevel('YOLO')).toBe(false);
-    expect(isPermissionLevel('')).toBe(false);
-  });
-
-  it('claudeFlagsForLevel returns the right flag list per level', () => {
-    expect(claudeFlagsForLevel('dangerouslySkipPermissions')).toEqual([
-      '--dangerously-skip-permissions',
-    ]);
-    expect(claudeFlagsForLevel('auto')).toEqual(['--permission-mode', 'auto']);
-    expect(claudeFlagsForLevel('acceptEdits')).toEqual(['--permission-mode', 'acceptEdits']);
-    expect(claudeFlagsForLevel('supervised')).toEqual(['--permission-mode', 'default']);
-    expect(claudeFlagsForLevel('strict')).toEqual(['--permission-mode', 'plan']);
-  });
-});

package/tests/project-key.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { projectKeyFromPath } from '../src/project-key.js';
-
-describe('projectKeyFromPath', () => {
-  it('produces a stable key for a given absolute path', () => {
-    const key1 = projectKeyFromPath('/home/user/projects/myrepo');
-    const key2 = projectKeyFromPath('/home/user/projects/myrepo');
-    expect(key1).toBe(key2);
-  });
-
-  it('includes the basename as a readable suffix', () => {
-    const key = projectKeyFromPath('/home/user/projects/myrepo');
-    expect(key.endsWith('-myrepo')).toBe(true);
-  });
-
-  it('produces a 10-char sha1 prefix', () => {
-    const key = projectKeyFromPath('/home/user/projects/myrepo');
-    const prefix = key.split('-')[0];
-    expect(prefix).toHaveLength(10);
-    expect(prefix).toMatch(/^[0-9a-f]{10}$/);
-  });
-
-  it('produces different keys for different paths', () => {
-    const a = projectKeyFromPath('/home/user/projects/foo');
-    const b = projectKeyFromPath('/home/user/projects/bar');
-    expect(a).not.toBe(b);
-  });
-
-  it('sanitizes non-alphanumeric basename characters', () => {
-    const key = projectKeyFromPath('/tmp/my repo with spaces');
-    expect(key).toMatch(/^[0-9a-f]{10}-[a-z0-9-]+$/);
-  });
-});

package/tests/prompts/tool-discipline.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ORCHESTRATOR_ROLE_PROMPT_V1 } from '../../src/prompts/orchestrator-role.js';
-import { MUSICIAN_ROLE_PROMPT_V1 } from '../../src/prompts/musician-role.js';
-import { buildMusicianInitialPrompt } from '../../src/prompts/tool-discipline.js';
-
-describe('tool-discipline prompts', () => {
-  it('requires the orchestrator to resolve coordination via NFO tools', () => {
-    expect(ORCHESTRATOR_ROLE_PROMPT_V1).toContain('Tool discipline (mandatory):');
-    expect(ORCHESTRATOR_ROLE_PROMPT_V1).toContain('Call the corresponding NFO tool in the same turn.');
-    expect(ORCHESTRATOR_ROLE_PROMPT_V1).toContain('A prose-only');
-  });
-
-  it('requires musicians to use report_done instead of plain text', () => {
-    expect(MUSICIAN_ROLE_PROMPT_V1).toContain('Plain-text status reports are');
-    expect(MUSICIAN_ROLE_PROMPT_V1).toContain('next action must be `report_done');
-    expect(MUSICIAN_ROLE_PROMPT_V1).toContain('Do not end with "done"');
-  });
-
-  it('injects the tool contract into the initial musician task prompt', () => {
-    const prompt = buildMusicianInitialPrompt('Run the failing test and fix it.');
-    expect(prompt).toContain('Run the failing test and fix it.');
-    expect(prompt).toContain('NFO operating contract (mandatory):');
-    expect(prompt).toContain('instead of replying with a plain-text completion message');
-  });
-});

package/tests/repo.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { resolveRepoRoot } from '../src/repo.js';
-import { makeTmpRepo, makeTmpNonRepo, type TmpRepo } from './helpers/tmp-repo.js';
-import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-
-describe('resolveRepoRoot', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  afterEach(async () => {
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-  });
-
-  async function track(t: TmpRepo) {
-    cleanups.push(t.cleanup);
-    return t;
-  }
-
-  it('returns the repo root when invoked from inside a repo', async () => {
-    const repo = await track(await makeTmpRepo());
-    const result = await resolveRepoRoot(repo.path);
-    expect(result).toBe(repo.path);
-  });
-
-  it('returns the repo root when invoked from a subdirectory', async () => {
-    const repo = await track(await makeTmpRepo());
-    const subdir = join(repo.path, 'src', 'nested');
-    await mkdir(subdir, { recursive: true });
-    const result = await resolveRepoRoot(subdir);
-    expect(result).toBe(repo.path);
-  });
-
-  it('returns null when invoked outside any repo', async () => {
-    const nonRepo = await track(await makeTmpNonRepo());
-    const result = await resolveRepoRoot(nonRepo.path);
-    expect(result).toBeNull();
-  });
-});