nfo-cli 0.0.4-improve-prompting → 0.0.5

package/src/cli.ts

@@ -1,197 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { decideAction, createOrchestra } from "./commands/launch.js";
-import { attachOrRestore } from "./commands/attach.js";
-import {
-  listOrchestras,
-  formatOrchestraList,
-  type OrchestraSummary,
-} from "./commands/list.js";
-import {
-  isPermissionLevel,
-  DANGEROUSLY_SKIP_PERMISSIONS_CONFIRM_PHRASE,
-  DANGEROUSLY_SKIP_PERMISSIONS_WARNING,
-  type PermissionLevel,
-} from "./permission.js";
-import { detectClaude } from "./claude-detect.js";
-import { createInterface } from "node:readline/promises";
-import packageJson from "../package.json" with { type: "json" };
-
-const program = new Command();
-program
-  .name("nfo")
-  .description("NoFluffOrchestra — TUI multi-agent orchestrator")
-  .version(packageJson.version);
-
-program
-  .argument("[id]", "Orchestra id to attach (optional)")
-  .option(
-    "--notify-on-permission",
-    "bell + desktop notify when a musician awaits permission",
-  )
-  .action(
-    async (id: string | undefined, opts: { notifyOnPermission?: boolean }) => {
-      await detectClaude();
-      try {
-        if (id) {
-          await attachOrRestore(id);
-          return;
-        }
-        const decision = await decideAction(process.cwd());
-        switch (decision.kind) {
-          case "create": {
-            const level = await promptPermissionLevel();
-            await createOrchestra({
-              repoRoot: decision.repoRoot,
-              orchestraId: decision.orchestraId,
-              permissionLevel: level,
-              notifyOnPermission: opts.notifyOnPermission,
-            });
-            return;
-          }
-          case "attach_existing":
-            await attachOrRestore(decision.orchestraId);
-            return;
-          case "pick": {
-            const picked = await promptOrchestraPicker(decision.summaries);
-            await attachOrRestore(picked);
-            return;
-          }
-          case "error":
-            console.error(decision.message);
-            process.exit(1);
-        }
-      } catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-      }
-    },
-  );
-
-program
-  .command("list")
-  .description("List all known orchestras")
-  .action(async () => {
-    const summaries = await listOrchestras();
-    console.log(formatOrchestraList(summaries));
-  });
-
-program
-  .command("restore <id>")
-  .description("Force-restore a stopped orchestra")
-  .option(
-    "--notify-on-permission",
-    "bell + desktop notify when a musician awaits permission",
-  )
-  .action(async (id: string, opts: { notifyOnPermission?: boolean }) => {
-    const { restoreOrchestra } = await import("./commands/restore.js");
-    await restoreOrchestra(id, undefined, opts.notifyOnPermission);
-  });
-
-program
-  .command("kill <id>")
-  .description("Tear down an orchestra (state archived, notes preserved)")
-  .option("-y, --yes", "Skip confirmation prompt")
-  .action(async (id: string, opts: { yes?: boolean }) => {
-    const { killOrchestra } = await import("./commands/kill.js");
-    await killOrchestra(id, opts);
-  });
-
-program
-  .command("notes <id>")
-  .description("Open the orchestra's notes/ directory in $EDITOR")
-  .action(async (id: string) => {
-    const { openNotes } = await import("./commands/notes.js");
-    await openNotes(id);
-  });
-
-program
-  .command("mcp-server", { hidden: true })
-  .description("(internal) Run the NFO MCP server attached to an orchestra")
-  .requiredOption("--orchestra-id <id>", "Orchestra id")
-  .option("--caller-musician-id <id>", "When the server is hosting a Musician")
-  .action(async (opts: { orchestraId: string; callerMusicianId?: string }) => {
-    const { runMcpServerCli } = await import("./commands/mcp-server.js");
-    await runMcpServerCli({
-      orchestraId: opts.orchestraId,
-      callerMusicianId: opts.callerMusicianId,
-    });
-  });
-
-program
-  .command("tui", { hidden: true })
-  .description("(internal) Run the NFO Ink TUI for an orchestra")
-  .requiredOption("--orchestra-id <id>", "Orchestra id")
-  .action(async (opts: { orchestraId: string }) => {
-    const { runTui } = await import("./commands/tui.js");
-    await runTui({
-      orchestraId: opts.orchestraId,
-      version: packageJson.version,
-    });
-  });
-
-program.parseAsync(process.argv);
-
-async function promptPermissionLevel(): Promise<PermissionLevel> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const ans = (
-      await rl.question(
-        `Permission level for this orchestra:
-  1) Dangerously skip permissions        — RISKY: bypasses all permission checks
-  2) auto                                — Claude auto mode (prompts only on risky actions)
-  3) edits                               — auto-accept edits, prompt on shell/tools
-  4) supervised                          — claude's default prompt-on-risky behavior
-  5) strict                              — read-only / plan mode
-Choose [1-5] (default 4): `,
-      )
-    ).trim();
-
-    const map: Record<string, PermissionLevel> = {
-      "1": "dangerouslySkipPermissions",
-      "2": "auto",
-      "3": "acceptEdits",
-      "4": "supervised",
-      "5": "strict",
-      "": "supervised",
-    };
-    const level = map[ans];
-    if (!level || !isPermissionLevel(level)) {
-      throw new Error(`Invalid choice: ${ans}`);
-    }
-
-    if (level === "dangerouslySkipPermissions") {
-      console.log("\n" + DANGEROUSLY_SKIP_PERMISSIONS_WARNING + "\n");
-      const confirm = (await rl.question("> ")).trim();
-      if (confirm !== DANGEROUSLY_SKIP_PERMISSIONS_CONFIRM_PHRASE) {
-        throw new Error("Auto mode not confirmed. Aborting.");
-      }
-    }
-
-    return level;
-  } finally {
-    rl.close();
-  }
-}
-
-async function promptOrchestraPicker(
-  summaries: OrchestraSummary[],
-): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    console.log("Multiple orchestras found:");
-    summaries.forEach((s, i) => {
-      console.log(
-        `  ${i + 1}) ${s.running ? "●" : "○"} ${s.id}  (${s.project_path})`,
-      );
-    });
-    const choice = (await rl.question("Pick one [1-N]: ")).trim();
-    const idx = Number(choice) - 1;
-    if (Number.isNaN(idx) || idx < 0 || idx >= summaries.length) {
-      throw new Error("Invalid choice");
-    }
-    return summaries[idx].id;
-  } finally {
-    rl.close();
-  }
-}

package/src/commands/attach.ts

@@ -1,24 +0,0 @@
-import type { LaunchResult } from './launch.js';
-import { sessionExists, sessionName, attachSession, ensureNfoSessionUi, selectWindow } from '../tmux.js';
-import { restoreOrchestra } from './restore.js';
-import { readState } from '../state.js';
-import { DASHBOARD_WINDOW_NAME } from '../dashboard.js';
-import { ensureDashboardWindow, migrateLegacySidebarPane } from './dashboard-window.js';
-
-export async function attachOrRestore(orchestraId: string, dryRun?: boolean): Promise<LaunchResult> {
-  const state = await readState(orchestraId);
-  if (!state) throw new Error(`Unknown orchestra: ${orchestraId}`);
-
-  const name = sessionName(orchestraId);
-  if (await sessionExists(name)) {
-    await ensureNfoSessionUi(name);
-    await ensureDashboardWindow(name, state.project_path, orchestraId);
-    await migrateLegacySidebarPane(name);
-    if (!dryRun) {
-      await selectWindow(name, DASHBOARD_WINDOW_NAME);
-      await attachSession(name);
-    }
-    return { action: 'attached', orchestraId };
-  }
-  return restoreOrchestra(orchestraId, dryRun);
-}

package/src/commands/dashboard-window.ts

@@ -1,33 +0,0 @@
-import { execa } from 'execa';
-import { DASHBOARD_WINDOW_NAME } from '../dashboard.js';
-import { createDetachedWindow, respawnPane, setPaneOption } from '../tmux.js';
-import { shellQuote } from '../shell-quote.js';
-
-function tuiCommand(orchestraId: string): string {
-  const nfoBin = process.argv[1];
-  return `${shellQuote(nfoBin)} tui --orchestra-id ${shellQuote(orchestraId)}`;
-}
-
-export async function ensureDashboardWindow(
-  session: string,
-  cwd: string,
-  orchestraId: string,
-): Promise<void> {
-  await removeDashboardWindow(session);
-  const paneId = await createDetachedWindow(session, DASHBOARD_WINDOW_NAME, cwd);
-  await setPaneOption(paneId, 'remain-on-exit', 'on');
-  await respawnPane(paneId, tuiCommand(orchestraId));
-}
-
-export async function migrateLegacySidebarPane(session: string): Promise<void> {
-  await execa('tmux', ['kill-pane', '-t', `${session}:0.1`], { reject: false });
-}
-
-async function removeDashboardWindow(session: string): Promise<void> {
-  const { stdout } = await execa('tmux', ['list-windows', '-t', session, '-F', '#{window_name}']);
-  const names = stdout.split('\n').map((line) => { return line.trim(); }).filter(Boolean);
-  if (!names.includes(DASHBOARD_WINDOW_NAME)) {
-    return;
-  }
-  await execa('tmux', ['kill-window', '-t', `${session}:${DASHBOARD_WINDOW_NAME}`], { reject: false });
-}

package/src/commands/kill.ts

@@ -1,50 +0,0 @@
-import { createInterface } from 'node:readline/promises';
-import { rename, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readState } from '../state.js';
-import {
-  sessionName,
-  sessionExists,
-  killSession,
-} from '../tmux.js';
-import { archiveDir, stateFile } from '../config.js';
-
-export interface KillOptions {
-  yes?: boolean;  // skip confirmation prompt
-}
-
-export async function killOrchestra(orchestraId: string, opts: KillOptions = {}): Promise<void> {
-  const state = await readState(orchestraId);
-  if (!state) throw new Error(`Unknown orchestra: ${orchestraId}`);
-
-  if (!opts.yes) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-      const ans = (await rl.question(
-        `Kill orchestra ${orchestraId} (${state.project_path})? [y/N] `,
-      )).trim().toLowerCase();
-      if (ans !== 'y' && ans !== 'yes') {
-        console.log('Aborted.');
-        return;
-      }
-    } finally {
-      rl.close();
-    }
-  }
-
-  // Phase 1: no musicians (and therefore no worktrees to handle).
-  // Phase 2 will add the worktree-archive prompt.
-
-  const name = sessionName(orchestraId);
-  if (await sessionExists(name)) {
-    await killSession(name);
-  }
-
-  // Archive state.json under archive/state-<timestamp>.json so notes/ stays intact.
-  await mkdir(archiveDir(orchestraId), { recursive: true });
-  const archived = join(archiveDir(orchestraId), `state-${Date.now()}.json`);
-  if (existsSync(stateFile(orchestraId))) {
-    await rename(stateFile(orchestraId), archived);
-  }
-}

package/src/commands/launch.ts

@@ -1,134 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolveRepoRoot } from '../repo.js';
-import { projectKeyFromPath } from '../project-key.js';
-import { ensureOrchestraDir, readState, writeState } from '../state.js';
-import { makeInitialState } from '../state.types.js';
-import {
-  claudeFlagsForLevel,
-  type PermissionLevel,
-} from '../permission.js';
-import {
-  sessionName,
-  sessionExists,
-  createDetachedSession,
-  attachSession,
-  selectWindow,
-  ensureNfoSessionUi,
-  respawnPane,
-  setPaneOption,
-} from '../tmux.js';
-import { ORCHESTRATOR_ROLE_PROMPT_V1 } from '../prompts/orchestrator-role.js';
-import { orchestraDir } from '../config.js';
-import { listOrchestras } from './list.js';
-import type { OrchestraSummary } from './list.js';
-import { noteRead, noteList } from '../notes.js';
-import { DASHBOARD_WINDOW_NAME } from '../dashboard.js';
-import { ensureDashboardWindow } from './dashboard-window.js';
-import { buildClaudeCommand } from '../claude-command.js';
-import { writeOrchestratorMcpConfig } from '../mcp/config.js';
-
-export interface LaunchOptions {
-  cwd: string;
-  interactive?: boolean;          // when false, must supply permissionLevel
-  permissionLevel?: PermissionLevel;
-  dryRun?: boolean;               // when true, do not attach
-}
-
-export interface LaunchResult {
-  action: 'created' | 'attached' | 'restored';
-  orchestraId: string;
-}
-
-export type LaunchDecision =
-  | { kind: 'create'; orchestraId: string; repoRoot: string }
-  | { kind: 'attach_existing'; orchestraId: string }
-  | { kind: 'pick'; summaries: OrchestraSummary[] }
-  | { kind: 'error'; message: string };
-
-export async function decideAction(cwd: string): Promise<LaunchDecision> {
-  const repoRoot = await resolveRepoRoot(cwd);
-
-  if (repoRoot) {
-    const orchestraId = projectKeyFromPath(repoRoot);
-    const existing = await readState(orchestraId);
-    if (existing) {
-      return { kind: 'attach_existing', orchestraId };
-    }
-    return { kind: 'create', orchestraId, repoRoot };
-  }
-
-  // Out of repo. Inspect known orchestras.
-  const summaries = await listOrchestras();
-  if (summaries.length === 0) {
-    return { kind: 'error', message: 'Open NFO in a git repository to create your first orchestra.' };
-  }
-  const running = summaries.filter(s => s.running);
-  if (running.length === 1) {
-    return { kind: 'attach_existing', orchestraId: running[0].id };
-  }
-  return { kind: 'pick', summaries };
-}
-
-export interface CreateOrchestraOptions {
-  repoRoot: string;
-  orchestraId: string;
-  permissionLevel: PermissionLevel;
-  dryRun?: boolean;
-  notifyOnPermission?: boolean;
-}
-
-export async function createOrchestra(opts: CreateOrchestraOptions): Promise<LaunchResult> {
-  await ensureOrchestraDir(opts.orchestraId);
-  const state = makeInitialState({
-    orchestraId: opts.orchestraId,
-    projectPath: opts.repoRoot,
-    permissionLevel: opts.permissionLevel,
-    notifyOnPermission: opts.notifyOnPermission,
-  });
-  await writeState(opts.orchestraId, state);
-
-  const mcpConfigPath = await writeOrchestratorMcpConfig(opts.orchestraId);
-
-  const promptFile = join(orchestraDir(opts.orchestraId), 'orchestrator-prompt.md');
-  const notes = await loadOrchestratorNotes(opts.orchestraId);
-  await writeFile(promptFile, ORCHESTRATOR_ROLE_PROMPT_V1 + notes, 'utf8');
-
-  const name = sessionName(opts.orchestraId);
-  await createDetachedSession(name, opts.repoRoot);
-  await ensureNfoSessionUi(name);
-  await setPaneOption(`${name}:0`, 'remain-on-exit', 'on');
-
-  await ensureDashboardWindow(name, opts.repoRoot, opts.orchestraId);
-
-  const claudeFlags = claudeFlagsForLevel(opts.permissionLevel);
-  const claudeCmd = buildClaudeCommand({
-    flags: claudeFlags,
-    mcpConfigPath,
-    promptFile,
-  });
-  await respawnPane(`${name}:0`, claudeCmd);
-
-  if (!opts.dryRun) {
-    await selectWindow(name, DASHBOARD_WINDOW_NAME);
-    await attachSession(name);
-  }
-  return { action: 'created', orchestraId: opts.orchestraId };
-}
-
-export async function loadOrchestratorNotes(orchestraId: string): Promise<string> {
-  const files = await noteList(orchestraId);
-  const ordered = ['overview.md', 'decisions.md'].filter((f) => { return files.includes(f); });
-  if (ordered.length === 0) {
-    return '';
-  }
-  const parts: string[] = ['\n\n## Curated project notes (loaded from notes/)\n'];
-  for (const f of ordered) {
-    const content = await noteRead(orchestraId, f);
-    if (content.trim().length === 0) {
-      continue;
-    }
-    parts.push(`\n### ${f}\n\n${content}\n`);
-  }
-  return parts.join('');
-}

package/src/commands/list.ts

@@ -1,43 +0,0 @@
-import { readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { getProjectsDir } from '../config.js';
-import { readState } from '../state.js';
-import { sessionExists, sessionName } from '../tmux.js';
-
-export interface OrchestraSummary {
-  id: string;
-  project_path: string;
-  permission_level: string;
-  created_at: string;
-  running: boolean;
-  musician_count: number;
-}
-
-export async function listOrchestras(): Promise<OrchestraSummary[]> {
-  const projectsDir = getProjectsDir();
-  if (!existsSync(projectsDir)) return [];
-  const dirs = await readdir(projectsDir, { withFileTypes: true });
-  const summaries: OrchestraSummary[] = [];
-  for (const d of dirs) {
-    if (!d.isDirectory()) continue;
-    const state = await readState(d.name);
-    if (!state) continue;
-    summaries.push({
-      id: state.orchestra_id,
-      project_path: state.project_path,
-      permission_level: state.permission_level,
-      created_at: state.created_at,
-      running: await sessionExists(sessionName(state.orchestra_id)),
-      musician_count: state.musicians.length,
-    });
-  }
-  return summaries;
-}
-
-export function formatOrchestraList(summaries: OrchestraSummary[]): string {
-  if (summaries.length === 0) return 'No orchestras found.';
-  const rows = summaries.map(s =>
-    `${s.running ? '●' : '○'}  ${s.id}\n   ${s.project_path}\n   level=${s.permission_level} musicians=${s.musician_count}`,
-  );
-  return rows.join('\n\n');
-}

package/src/commands/mcp-server.ts

@@ -1,18 +0,0 @@
-import { runServer } from '../mcp/server.js';
-import { readState } from '../state.js';
-
-export interface McpServerCliOptions {
-  orchestraId: string;
-  callerMusicianId?: string;
-}
-
-export async function runMcpServerCli(opts: McpServerCliOptions): Promise<void> {
-  const state = await readState(opts.orchestraId);
-  if (!state) {
-    throw new Error(`Unknown orchestra: ${opts.orchestraId}`);
-  }
-  await runServer({
-    orchestraId: opts.orchestraId,
-    callerMusicianId: opts.callerMusicianId,
-  });
-}

package/src/commands/notes.ts

@@ -1,18 +0,0 @@
-import { existsSync } from 'node:fs';
-import { execa } from 'execa';
-import { notesDir } from '../config.js';
-import { readState } from '../state.js';
-
-export async function openNotes(orchestraId: string): Promise<void> {
-  const state = await readState(orchestraId);
-  if (!state) throw new Error(`Unknown orchestra: ${orchestraId}`);
-
-  const dir = notesDir(orchestraId);
-  if (!existsSync(dir)) {
-    throw new Error(`Notes directory missing for ${orchestraId}: ${dir}`);
-  }
-
-  const editor = process.env.EDITOR ?? 'vi';
-  // Open the dir, not a specific file — the user picks which note to edit.
-  await execa(editor, [dir], { stdio: 'inherit' });
-}

package/src/commands/restore.ts

@@ -1,153 +0,0 @@
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { execa } from "execa";
-import { readState, writeState } from "../state.js";
-import { setMusicianTmuxWindowId } from "../state-updaters.js";
-import { orchestraDir } from "../config.js";
-import {
-  sessionName,
-  sessionExists,
-  createDetachedSession,
-  attachSession,
-  ensureNfoSessionUi,
-  selectWindow,
-  respawnPane,
-  setPaneOption,
-} from "../tmux.js";
-import { claudeFlagsForLevel } from "../permission.js";
-import { ORCHESTRATOR_ROLE_PROMPT_V1 } from "../prompts/orchestrator-role.js";
-import { MUSICIAN_ROLE_PROMPT_V1 } from "../prompts/musician-role.js";
-import { loadOrchestratorNotes } from "./launch.js";
-import type { LaunchResult } from "./launch.js";
-import { DASHBOARD_WINDOW_NAME } from "../dashboard.js";
-import {
-  ensureDashboardWindow,
-  migrateLegacySidebarPane,
-} from "./dashboard-window.js";
-import { buildClaudeCommand } from "../claude-command.js";
-import {
-  orchestratorMcpConfigPath,
-  writeMusicianMcpConfig,
-  writeOrchestratorMcpConfig,
-} from "../mcp/config.js";
-
-function sanitiseName(name: string): string {
-  const cleaned = name
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-|-$/g, "")
-    .slice(0, 32);
-  if (cleaned.length === 0) {
-    return "musician";
-  }
-  return cleaned;
-}
-
-export async function restoreOrchestra(
-  orchestraId: string,
-  dryRun?: boolean,
-  notifyOnPermission?: boolean,
-): Promise<LaunchResult> {
-  const state = await readState(orchestraId);
-  if (!state) {
-    throw new Error(`Unknown orchestra: ${orchestraId}`);
-  }
-
-  if (notifyOnPermission !== undefined) {
-    state.notify_on_permission = notifyOnPermission;
-    await writeState(orchestraId, state);
-  }
-
-  const name = sessionName(orchestraId);
-  if (await sessionExists(name)) {
-    await ensureNfoSessionUi(name);
-    await ensureDashboardWindow(name, state.project_path, orchestraId);
-    await migrateLegacySidebarPane(name);
-    if (!dryRun) {
-      await selectWindow(name, DASHBOARD_WINDOW_NAME);
-      await attachSession(name);
-    }
-    return { action: "attached", orchestraId };
-  }
-
-  await createDetachedSession(name, state.project_path);
-  await ensureNfoSessionUi(name);
-  await ensureDashboardWindow(name, state.project_path, orchestraId);
-  await setPaneOption(`${name}:0`, "remain-on-exit", "on");
-
-  const mcpConfigPath = existsSync(orchestratorMcpConfigPath(orchestraId))
-    ? orchestratorMcpConfigPath(orchestraId)
-    : await writeOrchestratorMcpConfig(orchestraId);
-  const flags = claudeFlagsForLevel(state.permission_level);
-
-  // Rebuild the Orchestrator's prompt file with current notes content.
-  const promptFile = join(orchestraDir(orchestraId), "orchestrator-prompt.md");
-  if (existsSync(promptFile)) {
-    const notes = await loadOrchestratorNotes(orchestraId);
-    await writeFile(promptFile, ORCHESTRATOR_ROLE_PROMPT_V1 + notes, "utf8");
-  }
-
-  await respawnPane(
-    `${name}:0`,
-    buildClaudeCommand({
-      flags,
-      resumeSessionId: state.orchestrator_session_id,
-      mcpConfigPath,
-      promptFile: existsSync(promptFile) ? promptFile : undefined,
-    }),
-  );
-
-  // Restore musicians (Phase 2). Stopped musicians are not restored.
-  for (const musician of state.musicians) {
-    if (musician.status === "stopped") {
-      continue;
-    }
-    const workingDir = musician.worktree_path ?? state.project_path;
-    const winLabel = `mus-${musician.id}-${sanitiseName(musician.name)}`;
-    const created = await execa("tmux", [
-      "new-window",
-      "-t",
-      name,
-      "-n",
-      winLabel,
-      "-c",
-      workingDir,
-      "-d",
-      "-P",
-      "-F",
-      "#{window_id}",
-    ]);
-    const newWindowId = created.stdout.trim();
-    // The recreated window has a new id; persist it so message/query target it.
-    await setMusicianTmuxWindowId(orchestraId, musician.id, newWindowId);
-
-    const musicianPromptFile = join(
-      orchestraDir(orchestraId),
-      `musician-${musician.id}-prompt.md`,
-    );
-    await writeFile(musicianPromptFile, MUSICIAN_ROLE_PROMPT_V1, "utf8");
-    const musicianMcpConfigPath = await writeMusicianMcpConfig(
-      orchestraId,
-      musician.id,
-    );
-    await setPaneOption(`${name}:${newWindowId}`, "remain-on-exit", "on");
-    await respawnPane(
-      `${name}:${newWindowId}`,
-      buildClaudeCommand({
-        flags,
-        resumeSessionId: musician.claude_session_id,
-        mcpConfigPath: musicianMcpConfigPath,
-        promptFile: musicianPromptFile,
-        model: musician.model ?? "sonnet",
-      }),
-    );
-  }
-
-  if (!dryRun) {
-    await selectWindow(name, DASHBOARD_WINDOW_NAME);
-    await attachSession(name);
-  }
-  return { action: "restored", orchestraId };
-}