release v2.0.10: tmux fleet wall, delegated agent asks, full-session changes panel

- tmux "control center": tiled wall of real terminals for sessions/teams/swarms
  with arrange/close/attach (packages/core/src/tmux.ts), OS-window fallback
- delegated agents (sub-agent/team/swarm) surface asks/permissions in the main
  view and bridge the answer back
- changes panel is a full session summary (committed + uncommitted + removed)
- resume restores per-session model/provider/effort/mode/summary/base/worktree
- plan mode asks before planning; pause moved to Ctrl+Space
- docs: agents-and-teams covers the tmux wall + delegated asks
- CHANGELOG: cut [2.0.10] section

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: katipally

CHANGELOG.md

@@ -11,6 +11,8 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [2.0.10] - 2026-06-23
+
 ### Added
 
 - **Pin context files**: a permanent, clickable context-files chip in the side
@@ -23,12 +25,35 @@ All notable changes to this project are documented here. The format is based on
   the Accessibility and Screen Recording panes directly so you can click-grant.
 - **Kitty keyboard protocol** enabled where supported, so chords legacy terminals
   can't encode (Shift+Enter, Cmd+Enter) work in kitty/WezTerm/Ghostty/modern iTerm2.
+- **tmux control center**: when tmux is available, the dashboard launches sessions/
+  teams/swarms into a tiled tmux "wall" of real terminals — arrange (tiled/cols/
+  rows/main), close each pane or all, and "open" a window attached to the wall to
+  watch everything in one view. Falls back to separate OS windows without tmux.
+- **Delegated agents ask in the main view**: a subagent/team/swarm question or
+  permission prompt now surfaces in your current view, labeled with the agent
+  asking; you answer without switching and it bridges back to that agent.
 
 ### Changed
 
 - **Pause keybinding** moved off `Shift+Esc` (terminals can't encode it — it
-  arrived as plain Esc) onto **Ctrl+P** everywhere, plus **Cmd+Enter** on
-  kitty-protocol terminals. Newline stays Shift+Enter / Option+Enter.
+  arrived as plain Esc) onto **Ctrl+Space** (single-handed, works in every
+  terminal), plus **Cmd+Enter** on kitty-protocol terminals. Newline stays
+  Shift+Enter / Option+Enter.
+- **Changes panel is now a full session summary**: in a git repo it shows
+  everything done since the session started — committed **and** uncommitted **and**
+  removed files — by diffing the working tree against the commit captured at
+  session start (committed files no longer vanish after `git commit`).
+- **Resume restores the whole session feel**: per-session model/provider/effort,
+  mode, the compaction summary, the git base, and an active worktree all persist
+  and come back on resume (previously these reset to the global default or were
+  lost). Resuming a session from the dashboard also opens its window in that
+  session's own folder.
+- **Plan mode** asks before planning: for vague requests it now uses `ask_user`
+  with concrete options first, and `exit_plan` only carries a real implementation
+  plan. A trivial request (a listing, a question) is answered directly instead of
+  being dressed up as a "PLAN READY" gate (removed the last-message fallback).
+- **Settings** uses a horizontal tab bar (the same `Tabs` the dashboard uses) for
+  a consistent feel; the context-files modal now has a proper search/input field.
 - **Side panel**: removed the redundant "context" title; the close control is
   right-aligned with its `ctrl+b` shortcut shown clearly.
 - **Plans/Todos/Changes sections**: reversed the washed-out hierarchy — section
@@ -44,6 +69,8 @@ All notable changes to this project are documented here. The format is based on
 - **Dashboard terminal windows** failing silently: the launcher now resolves the
   friday executable robustly (absolute path / PATH fallback) and surfaces the real
   error in a toast instead of a generic "no backend" message.
+- **Changes panel went stale after a rewind/redo**: `restoreCheckpoint` and
+  `redoLast` now refresh the changes panel (todos/plans already refreshed).
 
 ## [2.0.9] - 2026-06-23
 

docs/agents-and-teams.md

@@ -36,13 +36,21 @@ them when done. The board tools are `board_post`, `board_read`,
 |---|---|---|
 | Dashboard | `/dashboard` or Ctrl+O | Sessions, Teams, and Swarm in one view. |
 | Console | `/console` or Ctrl+T | The live team cockpit: the shared board plus the roster. |
-| Fleet | `/fleet` | One external terminal window per running agent. |
-
-`/fleet` needs a terminal backend: it uses tmux if you are already inside a tmux
-session, otherwise Terminal.app/iTerm on macOS or a detected emulator on Linux
-(wezterm, gnome-terminal, konsole, x-terminal-emulator). Windows is not
-supported. If no backend is found, watch the agents in the dashboard's Swarm tab
-instead.
+| Fleet | `/fleet` | One real terminal per running agent — a tiled tmux wall when tmux is present, otherwise separate OS windows. |
+
+`/fleet` needs a terminal backend. When **tmux** is available it launches every
+session/team/swarm into a tiled "wall" of real terminals you control from the
+dashboard: re-arrange the panes (tiled, columns, rows, or main), close one pane
+or all of them, and "open the wall" to attach a terminal and watch every pane in
+one view. Without tmux it falls back to separate OS windows — Terminal.app/iTerm
+on macOS or a detected emulator on Linux (wezterm, gnome-terminal, konsole,
+x-terminal-emulator); Windows is not supported. If no backend is found, watch the
+agents in the dashboard's Swarm tab instead.
+
+When a delegated agent (sub-agent, team member, or swarm worker) needs to ask a
+question or request a permission, the prompt surfaces in your current view —
+labeled with the agent that's asking — so you answer in place and the answer
+bridges back to that agent without switching windows.
 
 ## Scheduling and isolation
 

packages/core/src/engine.ts

@@ -36,7 +36,7 @@ import { TeamBoard } from "./board.ts"
 import { type CustomCommand, loadCommands } from "./commands.ts"
 import { loadConfig, saveConfig } from "./config.ts"
 import { type CronJob, loadCron, parseInterval, saveCron } from "./cron.ts"
-import { openFleetWindows, openInteractiveWindow } from "./fleet.ts"
+import { openFleetWindows, openInteractiveWindow, openTerminalRunning } from "./fleet.ts"
 import {
   cancelMic,
   type InputDevice,
@@ -55,9 +55,21 @@ import { type RunnerHost, SessionRunner, type SessionStats } from "./runner.ts"
 import { SessionStore } from "./sessions.ts"
 import type { SkillInfo } from "./skills.ts"
 import type { StreamFn } from "./stream.ts"
+import {
+  type TmuxLayout,
+  type TmuxPane,
+  tmuxAvailable,
+  wallAdd,
+  wallAttachCommand,
+  wallKill,
+  wallKillAll,
+  wallLayout,
+  wallPanes,
+} from "./tmux.ts"
 
 export type { SessionStats } from "./runner.ts"
 export type { StreamFn } from "./stream.ts"
+export type { TmuxLayout, TmuxPane } from "./tmux.ts"
 
 const now = () => Date.now()
 
@@ -192,6 +204,8 @@ export class Engine {
     const row = resumed ?? this.store.buildRow([this.cwd], crypto.randomUUID(), now())
     const runner = this.makeRunner(row)
     this.focusedId = runner.sessionId
+    // Restore a resumed session's own model/provider/mode/effort (new sessions keep the global default).
+    if (resumed) this.applySessionSelection(runner.sessionId)
   }
 
   // ---- shared infra ----
@@ -441,6 +455,33 @@ export class Engine {
   openInteractive(args: string[] = [], cwd?: string): { ok: boolean; backend: string; opened: number; error?: string } {
     return openInteractiveWindow(args, cwd ?? this.currentCwd())
   }
+
+  // ---- tmux control center ("the wall"): real, tile-able, closable terminals managed from the dashboard ----
+  /** Is tmux available? When false, the dashboard hides wall controls and uses separate windows. */
+  tmuxOn(): boolean {
+    return tmuxAvailable()
+  }
+  /** Add a pane to the wall: a fresh chat (no args), a resumed session (`-s <id>`), or a read-only
+   * watch (`attach <id>`). `title` labels the pane in the tiled view. */
+  wallOpen(args: string[], title: string, cwd?: string): Promise<{ ok: boolean; error?: string }> {
+    return wallAdd(args, cwd ?? this.currentCwd(), title)
+  }
+  wallList(): Promise<TmuxPane[]> {
+    return wallPanes()
+  }
+  wallRemove(paneId: string): Promise<{ ok: boolean; error?: string }> {
+    return wallKill(paneId)
+  }
+  wallRemoveAll(): Promise<{ ok: boolean; error?: string }> {
+    return wallKillAll()
+  }
+  wallArrange(layout: TmuxLayout): Promise<{ ok: boolean; error?: string }> {
+    return wallLayout(layout)
+  }
+  /** Open a real OS terminal window attached to the wall, so the user watches every pane tiled. */
+  wallView(): { ok: boolean; backend: string; opened: number; error?: string } {
+    return openTerminalRunning(wallAttachCommand())
+  }
   /** Force-activate deferred tools (by name prefix) for the focused session so the model can use them
    * immediately without calling tool_search first. Returns the number activated. */
   activateTools(prefix: string): number {
@@ -787,6 +828,7 @@ export class Engine {
     const prev = this.focusedId
     this.focusedId = id
     this.discardIfEmpty(prev) // throw away the empty session we just left
+    this.applySessionSelection(id) // restore this session's model/provider/mode/effort
     runner.emitState(true)
   }
   /** Add a directory to the focused session's workspace (no new session). */
@@ -922,7 +964,16 @@ export class Engine {
     this.modelReasoning = reasoning
     if (contextWindow && contextWindow > 0) this.contextWindow = contextWindow
     this.modelCost = cost ?? this.modelCost
+    // Save to the global config (the default for NEW sessions) AND to THIS session's meta, so resuming
+    // it later restores the model it was using rather than the current global default.
     saveConfig({ providerId, model, reasoning, contextWindow: this.contextWindow || undefined, cost: this.modelCost })
+    this.store.setMeta(this.focusedId, {
+      providerId,
+      model,
+      reasoning,
+      contextWindow: this.contextWindow || undefined,
+      cost: this.modelCost,
+    })
     this.dispatch(this.focusedId, {
       type: "model-changed",
       model,
@@ -933,6 +984,32 @@ export class Engine {
   }
   setMode(m: ModeId): void {
     this.mode = m
+    this.store.setMeta(this.focusedId, { mode: m })
+  }
+  /**
+   * Apply a session's persisted selection (model/provider/effort/mode) to the engine when it becomes
+   * focused, so a resumed/switched-to session restores exactly what it was using. New sessions have no
+   * meta, so the current global defaults stand. Emits model-changed; the TUI re-reads mode/effort from
+   * engine.selection() on the accompanying session-changed event.
+   */
+  private applySessionSelection(id: string): void {
+    const m = this.store.loadMeta(id)
+    if (m.providerId) this.providerId = m.providerId
+    if (m.model) this.model = m.model
+    if (typeof m.reasoning === "boolean") this.modelReasoning = m.reasoning
+    if (m.contextWindow && m.contextWindow > 0) this.contextWindow = m.contextWindow
+    if (m.cost) this.modelCost = m.cost
+    if (m.mode) this.mode = m.mode
+    if (m.effort) this.effort = m.effort
+    if (m.model) {
+      this.dispatch(id, {
+        type: "model-changed",
+        model: this.model!,
+        provider: this.providerId!,
+        reasoning: this.modelReasoning,
+        contextWindow: this.contextWindow,
+      })
+    }
   }
 
   // ---- command intake ----
@@ -956,10 +1033,12 @@ export class Engine {
       case "set-mode":
         this.mode = cmd.mode
         saveConfig({ mode: cmd.mode })
+        this.store.setMeta(this.focusedId, { mode: cmd.mode })
         break
       case "set-effort":
         this.effort = cmd.effort as Effort
         saveConfig({ effort: cmd.effort as Effort })
+        this.store.setMeta(this.focusedId, { effort: cmd.effort as Effort })
         break
       case "set-model":
         break

packages/core/src/fleet.ts

@@ -39,8 +39,9 @@ function sh(parts: string[]): string {
 
 /** A shell command string for one window: optionally cd into `cwd`, then run friday with `args`.
  * Keeps the window open if friday ever exits (or fails to start) so it's never a blank black window —
- * the exit screen's resume hint stays visible, and any startup error is readable. */
-function fridayCommand(args: string[], cwd?: string): string {
+ * the exit screen's resume hint stays visible, and any startup error is readable. Exported so the tmux
+ * control center can run the SAME command inside a pane. */
+export function fridayCommand(args: string[], cwd?: string): string {
   const cmd = sh([...selfCmd(), ...args])
   const run = cwd ? `cd ${sh([cwd])} && ${cmd}` : cmd
   return `${run}; echo; echo '[friday exited — press Enter to close]'; read _`
@@ -151,3 +152,20 @@ export function openFleetWindows(ids: string[]): WinResult {
 export function openInteractiveWindow(args: string[] = [], cwd?: string): WinResult {
   return openWindows([fridayCommand(args, cwd)], false)
 }
+
+/** Open ONE real OS terminal window running an arbitrary shell command — used to attach a window to
+ * the tmux wall so the user can watch every pane tiled. Always a separate OS window (not a tmux split),
+ * even when friday itself is running inside tmux. */
+export function openTerminalRunning(cmd: string): WinResult {
+  const full = `${cmd}; echo; echo '[closed — press Enter to close]'; read _`
+  if (process.platform === "darwin") {
+    const { opened, error } = openMacWindows([full])
+    const backend = process.env.TERM_PROGRAM === "iTerm.app" ? "iTerm" : "Terminal.app"
+    return { ok: opened > 0, backend, opened, error }
+  }
+  if (process.platform === "linux") {
+    const { opened, backend, error } = openLinuxTerminal([full])
+    return { ok: opened > 0, backend, opened, error }
+  }
+  return { ok: false, backend: "none", opened: 0, error: `unsupported platform: ${process.platform}` }
+}

packages/core/src/git.ts

@@ -61,6 +61,60 @@ export async function gitIsTracked(cwd: string, relPath: string): Promise<boolea
   return res.ok
 }
 
+/** The current commit (HEAD) sha, or null outside a repo / on an unborn branch. */
+export async function gitRevParse(cwd: string, ref = "HEAD"): Promise<string | null> {
+  const res = await run(cwd, ["rev-parse", "--verify", "--quiet", ref])
+  const sha = res.out.trim()
+  return res.ok && sha ? sha : null
+}
+
+/**
+ * Everything changed since `base` (a commit captured at session start): committed AND uncommitted AND
+ * deletions, in one list — `git diff <base>` compares that commit straight to the working tree, so
+ * intermediate commits collapse into the net change. Untracked files are appended as adds. This is the
+ * full "what happened this session" footprint, robust to commits the snapshot tracker would drop.
+ */
+export async function gitSessionChanges(cwd: string, base: string): Promise<GitFile[]> {
+  const numstat = await run(cwd, ["diff", "--numstat", base])
+  const counts = new Map<string, { added: number; removed: number }>()
+  for (const line of numstat.out.split("\n")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line)
+    if (!m) continue
+    // Renames render as "old => new" or "{a => b}/c"; take the resulting path's last token.
+    const p = m[3]!.includes(" => ")
+      ? m[3]!
+          .replace(/\{.*? => (.*?)\}/, "$1")
+          .split(" => ")
+          .pop()!
+          .trim()
+      : m[3]!
+    counts.set(p, { added: m[1] === "-" ? 0 : Number(m[1]), removed: m[2] === "-" ? 0 : Number(m[2]) })
+  }
+  const nameStatus = await run(cwd, ["diff", "--name-status", base])
+  const files: GitFile[] = []
+  const seen = new Set<string>()
+  for (const line of nameStatus.out.split("\n")) {
+    if (!line.trim()) continue
+    const parts = line.split("\t")
+    const code = parts[0]!.trim()
+    const status = code[0]! // M, A, D, R, C, T…
+    const p = (status === "R" || status === "C" ? parts[2] : parts[1])?.trim()
+    if (!p || seen.has(p)) continue
+    seen.add(p)
+    const c = counts.get(p) ?? { added: 0, removed: 0 }
+    files.push({ path: p, status: status === "R" || status === "C" ? "A" : status, added: c.added, removed: c.removed })
+  }
+  // Untracked (new, never-added) files aren't in the diff — surface them as adds.
+  const untracked = await run(cwd, ["ls-files", "--others", "--exclude-standard"])
+  for (const line of untracked.out.split("\n")) {
+    const p = line.trim()
+    if (!p || seen.has(p)) continue
+    seen.add(p)
+    files.push({ path: p, status: "A", added: 0, removed: 0 })
+  }
+  return files
+}
+
 /** The working-tree diff (staged + unstaged), truncated for prompting. */
 export async function gitDiff(cwd: string, maxChars = 12_000): Promise<string> {
   const res = await run(cwd, ["diff", "HEAD"])

packages/core/src/index.ts

@@ -22,6 +22,7 @@ export { systemPrompt } from "./prompt.ts"
 export { bashRisk, matchesList } from "./safety.ts"
 export { type SessionRow, SessionStore } from "./sessions.ts"
 export { loadSkills, type Skill, type SkillInfo } from "./skills.ts"
+export type { TmuxLayout, TmuxPane } from "./tmux.ts"
 export {
   compareSemver,
   detectInstallMethod,

packages/core/src/keybindings.ts

@@ -14,10 +14,11 @@ export const DEFAULT_KEYBINDINGS = {
   "dashboard.toggle": "ctrl+o",
   "history.open": "ctrl+y",
   "mode.cycle": "shift+tab",
-  // Ctrl+P transmits in every terminal (Shift+Esc could not — Shift never modifies the Esc byte, so
-  // it arrived as plain Esc). On kitty-protocol terminals Cmd/Super+Enter also fires pause; that's
-  // handled in App.tsx's global handler, not here, since the textarea can't tell Option from Cmd.
-  "pause.open": "ctrl+p",
+  // Ctrl+Space transmits in every terminal (a NUL byte → name "space" + ctrl) and is single-handed
+  // (pinky + thumb). Shift+Esc couldn't work — Shift never modifies the Esc byte, so it arrived as
+  // plain Esc. On kitty-protocol terminals Cmd/Super+Enter also fires pause; that's handled in
+  // App.tsx's global handler, not here, since the textarea can't tell Option from Cmd.
+  "pause.open": "ctrl+space",
   // Ctrl+G (BEL) — reliable across terminals. Ctrl+, can't be used: terminals fold it onto Ctrl+\ (0x1c).
   "settings.open": "ctrl+g",
   "help.open": "f1",

packages/core/src/prompt.ts

@@ -146,9 +146,11 @@ function modePostureNote(mode: ModeId): string {
     case "plan":
       return [
         "\n# Mode: plan",
-        "You are in read-only plan mode. You can ONLY investigate — read files and search the codebase (read, ls, glob, grep, lsp_*) and ask the user questions. The edit and bash tools are intentionally unavailable here; do not attempt to change anything or run commands. Your job is to produce a plan, not to carry it out.",
-        "When — and ONLY when — you have a complete, concrete plan, call exit_plan({ plan }) with an ordered, step-by-step plan in markdown that cites the specific files to change.",
-        "exit_plan is the ONLY way the user reviews and approves your plan, so do not just describe the plan in prose and stop — always end a finished investigation by calling exit_plan. The user then chooses whether and how to execute it.",
+        "You are in read-only plan mode. You can ONLY investigate — read files and search the codebase (read, ls, glob, grep, lsp_*) and ask the user questions. The edit and bash tools are intentionally unavailable here; do not change anything or run commands. Your job is to design an implementation plan, not to carry it out.",
+        "ASK FIRST when the request is vague or under-specified. If the goal, scope, or approach is ambiguous, or there are multiple sensible ways to do it, call ask_user with concrete options BEFORE planning — don't guess. Do not reference \"the plan\" in these questions (the user can't see a plan yet); ask about the actual requirements/approach. Skip questions only when the request is already specific.",
+        "PRODUCE A REAL PLAN, not output. exit_plan({ plan }) is for an ordered, step-by-step implementation plan in markdown: a short goal, the approach, the concrete steps, and the specific files to create/change. It is NOT for dumping command output, a file listing, or an answer to a question — that is not a plan.",
+        "If the user's request is NOT an implementation task — a question, a lookup, a file listing, an explanation — just answer it directly in prose and stop. Do NOT call exit_plan and do NOT fabricate a plan for it.",
+        "When — and only when — you have a complete, concrete implementation plan, call exit_plan({ plan }). That is the only way the user reviews and approves it; don't describe a plan in prose and stop. The user then chooses whether and how to execute.",
       ].join("\n")
     case "yolo":
       return "\n# Mode: yolo\nFull autonomy is granted; proceed without asking for confirmation."