nfo-cli 0.0.3 → 0.0.4-improve-prompting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nfo-cli",
-  "version": "0.0.3",
+  "version": "0.0.4-improve-prompting",
   "description": "No Fluff Orchestra — a simple, fluff-free CLI multi-agent orchestrator",
   "type": "module",
   "bin": {

package/plan-explorer-musician-hardening.md

@@ -0,0 +1,56 @@
+# Plan: Explorer Musician Hardening
+
+Two-file change. Goal: enforce that the Orchestrator always delegates codebase
+exploration to a cheap Sonnet Musician before writing a coding task spec, rather
+than burning Opus tokens reading files itself.
+
+---
+
+## 1. `src/prompts/tool-discipline.ts` — enforce the rule
+
+Add one bullet to `ORCHESTRATOR_TOOL_DISCIPLINE` (the mandatory block):
+
+```
+- For any coding task, always spawn a Sonnet Explorer Musician first
+  (worktree=false, model="sonnet"). Only after the Explorer reports back
+  may you spawn a Coder Musician. Never read source files yourself to
+  build a coding task spec.
+```
+
+Place it after the existing "never write code yourself" bullet (once that is
+added per the earlier plan).
+
+---
+
+## 2. `src/prompts/orchestrator-role.ts` — guide the quality of each stage
+
+Add a new section to the coordination guidance block, after the existing bullets:
+
+```
+- Coding task workflow (two stages):
+
+  Stage 1 — Explorer Musician (Sonnet, worktree=false):
+    Task the Explorer to find and report back:
+    • Relevant file paths and line numbers for the change.
+    • The existing pattern or convention to follow.
+    • Any callers / dependents that may be affected (blast radius).
+    • Anything that would block or constrain the implementation.
+
+  Stage 2 — Coder Musician (Sonnet, fresh worktree):
+    Build the task spec from the Explorer's findings. Include:
+    • Exact files and line numbers to touch.
+    • The change required and why (one sentence).
+    • The pattern to follow (point to an existing example in the codebase).
+    • Acceptance criteria (what done looks like).
+    • Explicit constraints (don't break X, preserve Y interface).
+    A well-scoped spec is your primary output for coding requests.
+```
+
+---
+
+## What does NOT change
+
+- `musician-role.ts` — no change needed; Musicians already call `report_done`.
+- `spawn.ts` / `handlers.ts` — purely a prompting change, no code changes.
+- The Orchestrator still has full judgment on task decomposition and sequencing;
+  the Explorer rule applies to the codebase-research step only.

package/src/cli.ts

@@ -1,99 +1,117 @@
 #!/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, AUTO_CONFIRM_PHRASE, AUTO_WARNING, type PermissionLevel } from './permission.js';
-import { detectClaude } from './claude-detect.js';
-import { createInterface } from 'node:readline/promises';
+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('0.0.0');
+  .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,
-          });
+  .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;
         }
-        case 'attach_existing':
-          await attachOrRestore(decision.orchestraId);
-          return;
-        case 'pick': {
-          const picked = await promptOrchestraPicker(decision.summaries);
-          await attachOrRestore(picked);
-          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);
         }
-        case 'error':
-          console.error(decision.message);
-          process.exit(1);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        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')
+  .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')
+  .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');
+    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')
+  .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');
+    const { killOrchestra } = await import("./commands/kill.js");
     await killOrchestra(id, opts);
   });
 
 program
-  .command('notes <id>')
-  .description('Open the orchestra\'s notes/ directory in $EDITOR')
+  .command("notes <id>")
+  .description("Open the orchestra's notes/ directory in $EDITOR")
   .action(async (id: string) => {
-    const { openNotes } = await import('./commands/notes.js');
+    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')
+  .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');
+    const { runMcpServerCli } = await import("./commands/mcp-server.js");
     await runMcpServerCli({
       orchestraId: opts.orchestraId,
       callerMusicianId: opts.callerMusicianId,
@@ -101,12 +119,15 @@ program
   });
 
 program
-  .command('tui', { hidden: true })
-  .description('(internal) Run the NFO Ink TUI for an orchestra')
-  .requiredOption('--orchestra-id <id>', 'Orchestra id')
+  .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 });
+    const { runTui } = await import("./commands/tui.js");
+    await runTui({
+      orchestraId: opts.orchestraId,
+      version: packageJson.version,
+    });
   });
 
 program.parseAsync(process.argv);
@@ -114,28 +135,36 @@ 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) auto        — RISKY: bypasses all permission checks
-  2) autonomous  — auto-accept edits, prompt on risky tools
-  3) supervised  — claude's default prompt-on-risky behavior
-  4) strict      — read-only / plan mode
-Choose [1-4] (default 3): `,
-    )).trim();
+    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': 'auto', '2': 'autonomous', '3': 'supervised', '4': 'strict', '': 'supervised',
+      "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 === 'auto') {
-      console.log('\n' + AUTO_WARNING + '\n');
-      const confirm = (await rl.question('> ')).trim();
-      if (confirm !== AUTO_CONFIRM_PHRASE) {
-        throw new Error('Auto mode not confirmed. Aborting.');
+    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.");
       }
     }
 
@@ -145,17 +174,21 @@ Choose [1-4] (default 3): `,
   }
 }
 
-async function promptOrchestraPicker(summaries: OrchestraSummary[]): Promise<string> {
+async function promptOrchestraPicker(
+  summaries: OrchestraSummary[],
+): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    console.log('Multiple orchestras found:');
+    console.log("Multiple orchestras found:");
     summaries.forEach((s, i) => {
-      console.log(`  ${i + 1}) ${s.running ? '●' : '○'} ${s.id}  (${s.project_path})`);
+      console.log(
+        `  ${i + 1}) ${s.running ? "●" : "○"} ${s.id}  (${s.project_path})`,
+      );
     });
-    const choice = (await rl.question('Pick one [1-N]: ')).trim();
+    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');
+      throw new Error("Invalid choice");
     }
     return summaries[idx].id;
   } finally {

package/src/commands/tui.tsx

@@ -1,9 +1,10 @@
-import { render } from 'ink';
-import { App } from '../tui/App.js';
-import { readState } from '../state.js';
+import { render } from "ink";
+import { App } from "../tui/components/App.js";
+import { readState } from "../state.js";
 
 export interface RunTuiOptions {
   orchestraId: string;
+  version: string;
 }
 
 export async function runTui(opts: RunTuiOptions): Promise<void> {
@@ -11,6 +12,11 @@ export async function runTui(opts: RunTuiOptions): Promise<void> {
   if (!state) {
     throw new Error(`Unknown orchestra: ${opts.orchestraId}`);
   }
-  const instance = render(<App orchestraId={opts.orchestraId} />, { exitOnCtrlC: false });
+  const instance = render(
+    <App orchestraId={opts.orchestraId} version={opts.version} />,
+    {
+      exitOnCtrlC: false,
+    },
+  );
   await instance.waitUntilExit();
 }

package/src/permission.ts

@@ -1,4 +1,4 @@
-export const PERMISSION_LEVELS = ['auto', 'autonomous', 'supervised', 'strict'] as const;
+export const PERMISSION_LEVELS = ['dangerouslySkipPermissions', 'auto', 'acceptEdits', 'supervised', 'strict'] as const;
 export type PermissionLevel = (typeof PERMISSION_LEVELS)[number];
 
 export function isPermissionLevel(s: string): s is PermissionLevel {
@@ -7,11 +7,11 @@ export function isPermissionLevel(s: string): s is PermissionLevel {
 
 export function claudeFlagsForLevel(level: PermissionLevel): string[] {
   switch (level) {
-    case 'auto':
-      // Spec §5.2 + §12.2 open question: exact bypass flag is `--dangerously-skip-permissions`
-      // in current Claude Code releases. If a future release renames it, update here.
+    case 'dangerouslySkipPermissions':
       return ['--dangerously-skip-permissions'];
-    case 'autonomous':
+    case 'auto':
+      return ['--permission-mode', 'auto'];
+    case 'acceptEdits':
       return ['--permission-mode', 'acceptEdits'];
     case 'supervised':
       return ['--permission-mode', 'default'];
@@ -20,11 +20,11 @@ export function claudeFlagsForLevel(level: PermissionLevel): string[] {
   }
 }
 
-export const AUTO_CONFIRM_PHRASE = 'I understand';
+export const DANGEROUSLY_SKIP_PERMISSIONS_CONFIRM_PHRASE = 'I understand';
 
-export const AUTO_WARNING = `⚠ AUTO mode disables all permission checks.
+export const DANGEROUSLY_SKIP_PERMISSIONS_WARNING = `⚠ "Dangerously skip permissions" mode disables all permission checks.
 Musicians can execute arbitrary shell commands, modify files anywhere on
 this system, and access the network without asking. Worktrees limit but
 do not contain risky operations. Use this only in trusted sandboxes or
 when you accept these risks.
-Type "${AUTO_CONFIRM_PHRASE}" to continue.`;
+Type "${DANGEROUSLY_SKIP_PERMISSIONS_CONFIRM_PHRASE}" to continue.`;

package/src/prompts/orchestrator-role.ts

@@ -9,8 +9,8 @@ Available NFO tools (in addition to your normal Claude Code tools):
 
   spawn_musician({ name, task, worktree?, branch_from?, model? })
     Create a Musician with the given task. By default the Musician runs in a
-    fresh git worktree off HEAD. Pass worktree=false for trivially isolated
-    work (e.g., docs-only) that doesn't need an isolated branch. Returns the
+    fresh git worktree off HEAD. 
+    Pass worktree=false for trivially isolated and research work (e.g., docs-only) that doesn't need an isolated branch. Returns the
     musician_id. Provide a model to be used by the Musician, otherwise it defaults to sonnet.
     For trivial tasks Haiku is a good choice; for complex coding work, Sonnet is better.
 
@@ -45,6 +45,12 @@ Coordination guidance:
 - For agent coordination, PREFER the NFO MCP tools over Claude Code's built-in
   Task tool. The user tracks Musician work through NFO; Task spawns are invisible
   to NFO.
+- Deploy research musicians that investigate the codebase for the given task. They are only allowed
+    to research and report back findings, without modifying the codebase.
+- Before spawning a coding Musician, prepare a complete taks spec:
+  Relevant paths, line numbers, the exact changes and why, acceptance criteria,
+  and any constraints (e.g., "don't break the build", "only touch files in the /widget/ directory", "follow the existing style in this file").
+  A well-scoped prompt is your primary output on coding requests.
 - Worktrees solve concurrent file-edit safety, not API coupling. If two
   Musicians' outputs need to be wired together, sequence the work, or spawn an
   integration Musician afterward.
@@ -57,4 +63,22 @@ Coordination guidance:
 - Project-level guidance in CLAUDE.md still applies; respect it.
 - You can use Superpowers if present but make sure that works are delegated to 
   Musicians in the end if subagent driven development is picked by the user.
+- Coding task workflow (two stages):
+
+  Stage 1 — Explorer Musician (Sonnet, worktree=false):
+    Task the Explorer to find and report back:
+    • Relevant file paths and line numbers for the change.
+    • The existing pattern or convention to follow.
+    • Any callers / dependents that may be affected (blast radius).
+    • Anything that would block or constrain the implementation.
+
+  Stage 2 — Coder Musician (Haiku preferred or Sonnet if really needed, fresh worktree if required):
+    Build the task spec from the Explorer's findings. Include:
+    • Exact files and line numbers to touch.
+    • The change required and why (one sentence).
+    • The pattern to follow (point to an existing example in the codebase).
+    • Acceptance criteria (what done looks like).
+    • Explicit constraints (don't break X, preserve Y interface).
+    A well-scoped spec is your primary output for coding requests.
+
 `;

package/src/prompts/tool-discipline.ts

@@ -5,6 +5,12 @@ export const ORCHESTRATOR_TOOL_DISCIPLINE = `Tool discipline (mandatory):
   something later. Call the corresponding NFO tool in the same turn.
 - Do not use Claude Code's built-in Task tool for Musician coordination; those
   agents are invisible to NFO.
+- Never write, edit or refactor code yourself. All coding tasks must be delegated
+  to a Musician via \`spawn_musician\`. Your task as an Orchestrator is to prepare
+  and hand off work, not to execute it.
+- For any coding task, always spawn a Sonnet Explorer Musician first (worktree=false, model="sonnet"), Only
+  after the Explorer reports back may you spawn a Coder Musician. Never read source files
+  yourself to build a coding task spec.
 - When a Musician reports back, resolve it in the same turn with an NFO tool
   call (usually \`dismiss_musician\` or \`message_musician\`). A prose-only
   acknowledgement is non-compliant.

package/src/tui/{App.tsx → components/App.tsx}

@@ -2,30 +2,30 @@ import type { ReactElement } from "react";
 import { useEffect, useRef, useState } from "react";
 import { useInput, useStdout, useWindowSize } from "ink";
 import { AppView } from "./AppView.js";
-import { reduceKey } from "./keymap.js";
-import { pollActivity } from "./poll-activity.js";
+import { reduceKey } from "../keymap.js";
+import { pollActivity } from "../poll-activity.js";
 import {
   syncMusicianIdleState,
   type MusicianIdleTracker,
-} from "./poll-idle.js";
-import { pollPermissions } from "./poll-permission.js";
-import { setMusicianStatus } from "../state-updaters.js";
-import { watchOrchestraState, type StopWatching } from "./watch-state.js";
-import { listOrchestras, type OrchestraSummary } from "../commands/list.js";
+} from "../poll-idle.js";
+import { pollPermissions } from "../poll-permission.js";
+import { setMusicianStatus } from "../../state-updaters.js";
+import { watchOrchestraState, type StopWatching } from "../watch-state.js";
+import { listOrchestras, type OrchestraSummary } from "../../commands/list.js";
 import {
   EmbeddedTerminal,
   type EmbeddedTerminalSnapshot,
-} from "./embedded-terminal.js";
+} from "../embedded-terminal.js";
 import {
   claimEmbeddedSessionLease,
   embeddedSessionLeaseIsCurrent,
   runEmbeddedSessionOperation,
-} from "./embedded-session-lifecycle.js";
+} from "../embedded-session-lifecycle.js";
 import {
   toTerminalMouseScroll,
   toTerminalInput,
   toTerminalViewportCommand,
-} from "./terminal-input.js";
+} from "../terminal-input.js";
 import {
   detachCurrentClient,
   embeddedSessionName,
@@ -33,15 +33,16 @@ import {
   killSession,
   selectWindow,
   sessionName,
-} from "../tmux.js";
-import { openNotes } from "../commands/notes.js";
-import { dismissMusician } from "../musicians/dismiss.js";
-import { readState } from "../state.js";
-import { notifyAwaitingPermission } from "../notify.js";
-import type { Musician, OrchestraState } from "../state.types.js";
+} from "../../tmux.js";
+import { openNotes } from "../../commands/notes.js";
+import { dismissMusician } from "../../musicians/dismiss.js";
+import { readState } from "../../state.js";
+import { notifyAwaitingPermission } from "../../notify.js";
+import type { Musician, OrchestraState } from "../../state.types.js";
 
 export interface AppProps {
   orchestraId: string;
+  version: string;
 }
 
 function textLines(...lines: string[]): EmbeddedTerminalSnapshot["lines"] {
@@ -358,10 +359,10 @@ export function App(props: AppProps): ReactElement {
     const mouseScroll = toTerminalMouseScroll(input);
     if (mouseScroll) {
       const insideTerminalViewport =
-        mouseScroll.column >= terminalScreenLeft
-        && mouseScroll.column <= terminalScreenRight
-        && mouseScroll.row >= terminalScreenTop
-        && mouseScroll.row <= terminalScreenBottom;
+        mouseScroll.column >= terminalScreenLeft &&
+        mouseScroll.column <= terminalScreenRight &&
+        mouseScroll.row >= terminalScreenTop &&
+        mouseScroll.row <= terminalScreenBottom;
       if (insideTerminalViewport) {
         const translatedColumn = mouseScroll.column - terminalScreenLeft + 1;
         const translatedRow = mouseScroll.row - terminalScreenTop + 1;
@@ -527,6 +528,7 @@ export function App(props: AppProps): ReactElement {
       orchestratorConnected={orchestratorSnapshot.connected}
       activeMusicianId={activePaneMusician?.id ?? null}
       orchestratorActive={activePaneMusician === null}
+      version={props.version}
     />
   );
 }

package/src/tui/{AppView.tsx → components/AppView.tsx}

@@ -1,8 +1,8 @@
 import type { ReactElement } from "react";
 import { Box } from "ink";
-import type { Musician } from "../state.types.js";
-import type { OrchestraSummary } from "../commands/list.js";
-import type { EmbeddedTerminalLine } from "./embedded-terminal.js";
+import type { Musician } from "../../state.types.js";
+import type { OrchestraSummary } from "../../commands/list.js";
+import type { EmbeddedTerminalLine } from "../embedded-terminal.js";
 import { ConcertHall } from "./ConcertHall.js";
 import { Auditorium } from "./Auditorium.js";
 import { StatusBar } from "./StatusBar.js";
@@ -28,6 +28,7 @@ export interface AppViewProps {
   orchestratorConnected: boolean;
   activeMusicianId?: string | null;
   orchestratorActive?: boolean;
+  version: string;
 }
 
 export function AppView(props: AppViewProps): ReactElement {
@@ -46,6 +47,7 @@ export function AppView(props: AppViewProps): ReactElement {
             orchestraId={props.currentId}
             musicianCount={props.musicians.length}
             pendingCount={pendingCount}
+            version={props.version}
           />
           <ConcertHall
             orchestras={props.orchestras}

package/src/tui/{Auditorium.tsx → components/Auditorium.tsx}

@@ -1,8 +1,8 @@
 import type { ReactElement } from "react";
 import { Box, Text } from "ink";
-import type { Musician } from "../state.types.js";
-import { statusIcon, statusColor } from "./status-icon.js";
-import { formatRelativeTime } from "./format-time.js";
+import type { Musician } from "../../state.types.js";
+import { statusIcon, statusColor } from "../status-icon.js";
+import { formatRelativeTime } from "../format-time.js";
 
 export interface AuditoriumProps {
   musicians: Musician[];

package/src/tui/{ConcertHall.tsx → components/ConcertHall.tsx}

@@ -1,6 +1,6 @@
 import type { ReactElement } from "react";
 import { Box, Text } from "ink";
-import type { OrchestraSummary } from "../commands/list.js";
+import type { OrchestraSummary } from "../../commands/list.js";
 
 export interface ConcertHallProps {
   orchestras: OrchestraSummary[];

package/src/tui/{Help.tsx → components/Help.tsx}

@@ -42,15 +42,6 @@ const ROWS: Row[] = [
     label:
       "scroll the left terminal through local scrollback when the pointer is over that pane",
   },
-  {
-    key: "F6",
-    label: "tmux global key: jump to the dashboard window from any NFO window",
-  },
-  {
-    key: "F7",
-    label:
-      "tmux global key: jump to the Orchestrator window from any NFO window",
-  },
   { key: "?", label: "toggle this help / close" },
 ];
 

package/src/tui/{OrchestratorPane.tsx → components/OrchestratorPane.tsx}

@@ -3,7 +3,7 @@ import { Box, Text } from "ink";
 import type {
   EmbeddedTerminalLine,
   EmbeddedTerminalSpan,
-} from "./embedded-terminal.js";
+} from "../embedded-terminal.js";
 
 export interface OrchestratorPaneProps {
   title: string;