From 0deec4190bfd84608bcafa7ff87c804a09c82604 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 11:09:25 -0700
Subject: [PATCH 1/7] bugs fixes v1

---
 CHANGELOG.md                                  |  36 +++++
 docs/configuration.md                         |  24 +++
 packages/core/src/config.ts                   |  51 +++++-
 packages/core/src/engine.ts                   |  15 +-
 packages/core/src/fleet.ts                    |  80 +++++----
 packages/core/src/keybindings.ts              |   5 +-
 packages/core/src/runner.ts                   |  34 +++-
 packages/core/src/sessions.ts                 |  28 +++-
 packages/core/test/config.test.ts             |  36 +++++
 packages/core/test/keybindings.test.ts        |   5 +-
 packages/providers/src/paths.ts               |   8 +
 packages/shared/src/theme.ts                  | 104 ++++++------
 packages/shared/test/theme.test.ts            |   2 +-
 packages/tui/src/App.tsx                      |  12 ++
 packages/tui/src/components/ComputerModal.tsx |  12 ++
 packages/tui/src/components/ConsoleView.tsx   |   3 +-
 .../tui/src/components/ContextFilesModal.tsx  | 152 ++++++++++++++++++
 packages/tui/src/components/ContextPanel.tsx  |  36 +++--
 packages/tui/src/components/EffortSlider.tsx  |  69 ++++----
 packages/tui/src/components/StatusStrip.tsx   |   8 +-
 packages/tui/src/index.tsx                    |   6 +
 packages/tui/src/store.tsx                    |  48 +++++-
 packages/tui/src/util/term.ts                 |  19 +++
 packages/tui/test/keymap-pause.test.tsx       |  56 +++++++
 24 files changed, 703 insertions(+), 146 deletions(-)
 create mode 100644 packages/core/test/config.test.ts
 create mode 100644 packages/tui/src/components/ContextFilesModal.tsx
 create mode 100644 packages/tui/test/keymap-pause.test.tsx

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b33e899..71e970b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,42 @@ All notable changes to this project are documented here. The format is based on
 > for the next release. Each tag push also gets a fresh entry generated by the
 > `softprops/action-gh-release` `generate_release_notes: true` step.
 
+## [Unreleased]
+
+### Added
+
+- **Pin context files**: a permanent, clickable context-files chip in the side
+  panel opens a new modal to view auto-loaded context (FRIDAY.md/AGENTS.md) and
+  pin project files into context; pins persist for the session.
+- **Layered config** like Claude Code: `~/.friday/config.json` (user) →
+  `.friday/settings.json` (project, committed) → `.friday/settings.local.json`
+  (project-local, gitignored), deep-merged. See `docs/configuration.md`.
+- **Computer-use permissions**: macOS buttons in the computer-use modal that open
+  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.
+
+### 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.
+- **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
+  titles are now bright and bold, counts/meta stay faint; sections are spaced apart.
+- **Light theme** rebuilt as a warm-paper palette (Claude-Code-style) instead of
+  harsh pure white, keeping the amber brand; high-contrast pushed further from dark.
+- **Effort slider** redrawn as a colored cool→warm intensity bar-ramp.
+- **Icon consistency**: MCP (`⧉`), skills (`◆`), tool (`⚙`) and context (`📎`) now
+  use distinct glyphs from a central table instead of all sharing `⚡`/`✓`.
+
+### Fixed
+
+- **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.
+
 ## [2.0.9] - 2026-06-23
 
 ### Added
diff --git a/docs/configuration.md b/docs/configuration.md
index 71be29a..57d4968 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -48,6 +48,30 @@ list.
 Most of these can also be set from inside the TUI: `/model`, `/effort`,
 `/theme`, `/budget`, `/mcp`. Changes made there are written back to `config.json`.
 
+## Settings precedence (user → project → local)
+
+Like Claude Code, config is layered. Friday reads three files and deep-merges
+them, with later layers winning (nested objects merge key-by-key; arrays and
+scalars are replaced):
+
+1. `~/.friday/config.json` — **user** settings, apply everywhere.
+2. `.friday/settings.json` — **project** settings, committed to the repo so the
+   whole team shares them (model, mcp, hooks, bash policy, theme…).
+3. `.friday/settings.local.json` — **project-local** overrides, **gitignored**;
+   your personal tweaks for this checkout.
+
+All three use the same shape as `config.json` above. TUI changes are written to
+the user file by default. Recommended `.gitignore` for a project that commits
+its settings:
+
+```gitignore
+.friday/*
+!.friday/settings.json
+```
+
+That commits `.friday/settings.json` while keeping `settings.local.json` (and
+everything else under `.friday/`) out of version control.
+
 ## Bash allow and deny
 
 The `bash` block gates shell commands before they run. `deny` blocks a command
diff --git a/packages/core/src/config.ts b/packages/core/src/config.ts
index 6f3f29c..0e5a9a9 100644
--- a/packages/core/src/config.ts
+++ b/packages/core/src/config.ts
@@ -1,6 +1,7 @@
 import fs from "node:fs"
+import path from "node:path"
 import type { McpServerConfig } from "@friday/mcp"
-import { configPath, fridayDir } from "@friday/providers"
+import { configPath, fridayDir, projectConfigPath, projectLocalConfigPath } from "@friday/providers"
 import type { Effort, ModeId } from "@friday/shared"
 import type { HooksConfig } from "./hooks.ts"
 import type { MicConfig } from "./mic.ts"
@@ -45,21 +46,55 @@ export interface FridayConfig {
   autoCompactThreshold?: number
 }
 
-export function loadConfig(): FridayConfig {
+/** Read & parse one JSON config file; missing/invalid files contribute nothing. */
+function readLayer(file: string): Partial<FridayConfig> {
   try {
-    return JSON.parse(fs.readFileSync(configPath(), "utf8"))
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"))
+    return parsed && typeof parsed === "object" ? parsed : {}
   } catch {
     return {}
   }
 }
 
-export function saveConfig(patch: Partial<FridayConfig>): FridayConfig {
-  const next = { ...loadConfig(), ...patch }
+/** Deep-merge plain objects (later wins); arrays and scalars are replaced, not concatenated. */
+function deepMerge<T>(base: T, over: Partial<T>): T {
+  const out: any = { ...base }
+  for (const [k, v] of Object.entries(over)) {
+    if (v === undefined) continue
+    const b = (out as any)[k]
+    out[k] =
+      b && v && typeof b === "object" && typeof v === "object" && !Array.isArray(b) && !Array.isArray(v)
+        ? deepMerge(b, v)
+        : v
+  }
+  return out
+}
+
+/**
+ * Resolved config, layered like Claude Code: user (~/.friday/config.json) → project
+ * (.friday/settings.json, committed) → project-local (.friday/settings.local.json, gitignored).
+ * Later layers win; nested objects deep-merge so a project can override one key without dropping the
+ * rest. `cwd` defaults to the process cwd (the project root friday runs in).
+ */
+export function loadConfig(cwd: string = process.cwd()): FridayConfig {
+  let cfg = readLayer(configPath()) as FridayConfig
+  cfg = deepMerge(cfg, readLayer(projectConfigPath(cwd)))
+  cfg = deepMerge(cfg, readLayer(projectLocalConfigPath(cwd)))
+  return cfg
+}
+
+/**
+ * Persist a patch. Writes to the USER config by default (the resolved view still layers project files
+ * on top at read time). Pass scope "project"/"local" to write the committed/gitignored project file.
+ */
+export function saveConfig(patch: Partial<FridayConfig>, scope: "user" | "project" | "local" = "user"): FridayConfig {
+  const file = scope === "project" ? projectConfigPath() : scope === "local" ? projectLocalConfigPath() : configPath()
+  const next = { ...readLayer(file), ...patch }
   try {
-    fs.mkdirSync(fridayDir(), { recursive: true })
-    fs.writeFileSync(configPath(), JSON.stringify(next, null, 2))
+    fs.mkdirSync(scope === "user" ? fridayDir() : path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, JSON.stringify(next, null, 2))
   } catch {
     /* ignore */
   }
-  return next
+  return loadConfig()
 }
diff --git a/packages/core/src/engine.ts b/packages/core/src/engine.ts
index b841832..5716dcb 100644
--- a/packages/core/src/engine.ts
+++ b/packages/core/src/engine.ts
@@ -434,11 +434,11 @@ export class Engine {
     return id ? this.teamPayload(id) : null
   }
   /** Pop a single agent out into a real terminal window (tmux pane / OS terminal). */
-  popoutAgent(sessionId: string): { ok: boolean; backend: string; opened: number } {
+  popoutAgent(sessionId: string): { ok: boolean; backend: string; opened: number; error?: string } {
     return openFleetWindows([sessionId])
   }
   /** Open a NEW interactive friday window: fresh chat (no args) or resume `-s <id>`, in `cwd`. */
-  openInteractive(args: string[] = [], cwd?: string): { ok: boolean; backend: string; opened: number } {
+  openInteractive(args: string[] = [], cwd?: string): { ok: boolean; backend: string; opened: number; error?: string } {
     return openInteractiveWindow(args, cwd ?? this.currentCwd())
   }
   /** Force-activate deferred tools (by name prefix) for the focused session so the model can use them
@@ -507,7 +507,7 @@ export class Engine {
     return uninstallComputerUse()
   }
   /** Open a viewer window per running task (tmux pane / OS terminal); returns the chosen backend. */
-  openFleet(): { ok: boolean; backend: string; opened: number } {
+  openFleet(): { ok: boolean; backend: string; opened: number; error?: string } {
     const ids = this.taskList()
       .filter((t) => t.status === "running")
       .map((t) => t.id)
@@ -711,9 +711,16 @@ export class Engine {
   currentRoots(): string[] {
     return this.focused().currentRoots()
   }
-  contextInfo(): { files: string[] } {
+  contextInfo(): { files: string[]; pinned: string[] } {
     return this.focused().contextInfo()
   }
+  /** Pin/unpin a file (relative to the focused session's primary root) into context for the session. */
+  pinContextFile(rel: string): void {
+    this.focused().pinFile(rel)
+  }
+  unpinContextFile(rel: string): void {
+    this.focused().unpinFile(rel)
+  }
   listSkills(): SkillInfo[] {
     return this.focused().listSkills()
   }
diff --git a/packages/core/src/fleet.ts b/packages/core/src/fleet.ts
index f0daef0..0732329 100644
--- a/packages/core/src/fleet.ts
+++ b/packages/core/src/fleet.ts
@@ -9,17 +9,28 @@
  * failed or opened blank behind the editor); the common emulators on Linux. Unknown env degrades to
  * "none" so the caller can fall back to the in-TUI view rather than guessing.
  *
+ * Failures are never swallowed: `run()` captures stderr and every result carries an `error` string so
+ * the dashboard can tell the user WHY a window didn't open instead of a generic "no backend".
+ *
  * ponytail: covers tmux + macOS (open .command) + common Linux emulators; add more as users hit them.
  */
 import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
 
-/** Reconstruct how to launch friday itself. Dev: `bun <script>`; compiled: just the binary. */
+/**
+ * Reconstruct how to launch friday itself, as an ABSOLUTE command that survives a fresh shell with a
+ * different PATH (the usual reason a launched window opened then immediately died: bare `friday` not
+ * found). Dev: `<runtime> <abs script>`; compiled: the resolved binary (process.execPath), falling
+ * back to `friday` on PATH only as a last resort.
+ */
 function selfCmd(): string[] {
   const a1 = process.argv[1]
-  if (a1 && /\.(tsx?|jsx?|mjs)$/.test(a1)) return [process.argv[0]!, a1]
-  return [process.argv[0]!]
+  if (a1 && /\.(tsx?|jsx?|mjs)$/.test(a1)) return [process.execPath, path.resolve(a1)]
+  const exec = process.execPath
+  if (exec && fs.existsSync(exec)) return [exec]
+  const onPath = Bun.which("friday")
+  return onPath ? [onPath] : ["friday"]
 }
 
 function sh(parts: string[]): string {
@@ -35,23 +46,29 @@ function fridayCommand(args: string[], cwd?: string): string {
   return `${run}; echo; echo '[friday exited — press Enter to close]'; read _`
 }
 
-function run(cmd: string[]): boolean {
+/** Run a command, capturing stderr so a failure carries a real reason instead of vanishing. */
+function run(cmd: string[]): { ok: boolean; error?: string } {
   try {
-    return Bun.spawnSync(cmd, { stdout: "ignore", stderr: "ignore" }).success
-  } catch {
-    return false
+    const p = Bun.spawnSync(cmd, { stdout: "ignore", stderr: "pipe" })
+    if (p.success) return { ok: true }
+    const err = (p.stderr ? new TextDecoder().decode(p.stderr) : "").trim()
+    return { ok: false, error: err || `${cmd[0]} exited ${p.exitCode}` }
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) }
   }
 }
 
-function openTmux(cmds: string[], tile: boolean): number {
+function openTmux(cmds: string[], tile: boolean): { opened: number; error?: string } {
   let opened = 0
+  let error: string | undefined
   for (const c of cmds) {
     // tile=watch panes (split); otherwise a fresh interactive window.
-    const ok = tile ? run(["tmux", "split-window", "-h", c]) : run(["tmux", "new-window", c])
-    if (ok) opened++
+    const r = tile ? run(["tmux", "split-window", "-h", c]) : run(["tmux", "new-window", c])
+    if (r.ok) opened++
+    else error ??= r.error
   }
   if (tile) run(["tmux", "select-layout", "tiled"])
-  return opened
+  return { opened, error }
 }
 
 /**
@@ -60,23 +77,26 @@ function openTmux(cmds: string[], tile: boolean): number {
  * silently failed from the VS Code terminal) and it raises the terminal to the front. Defaults to
  * Terminal.app; honors iTerm when that's the host terminal.
  */
-function openMacWindows(cmds: string[]): number {
+function openMacWindows(cmds: string[]): { opened: number; error?: string } {
   const app = process.env.TERM_PROGRAM === "iTerm.app" ? "iTerm" : "Terminal"
   let opened = 0
+  let error: string | undefined
   for (const c of cmds) {
     try {
       const file = path.join(os.tmpdir(), `friday-${process.pid}-${opened}-${Date.now()}.command`)
       // Self-delete on launch so temp files never accumulate, then run the command.
       fs.writeFileSync(file, `#!/bin/bash\nrm -f ${sh([file])}\n${c}\n`, { mode: 0o755 })
-      if (run(["open", "-a", app, file])) opened++
-    } catch {
-      /* ignore and try the next */
+      const r = run(["open", "-a", app, file])
+      if (r.ok) opened++
+      else error ??= r.error
+    } catch (e) {
+      error ??= e instanceof Error ? e.message : String(e)
     }
   }
-  return opened
+  return { opened, error }
 }
 
-function openLinuxTerminal(cmds: string[]): { opened: number; backend: string } {
+function openLinuxTerminal(cmds: string[]): { opened: number; backend: string; error?: string } {
   const emulators: { bin: string; argv: (cmd: string) => string[] }[] = [
     { bin: "wezterm", argv: (c) => ["wezterm", "start", "--", "sh", "-c", c] },
     { bin: "gnome-terminal", argv: (c) => ["gnome-terminal", "--", "sh", "-c", c] },
@@ -86,31 +106,37 @@ function openLinuxTerminal(cmds: string[]): { opened: number; backend: string }
   for (const e of emulators) {
     if (!Bun.which(e.bin)) continue
     let opened = 0
-    for (const c of cmds) if (run(e.argv(c))) opened++
+    let error: string | undefined
+    for (const c of cmds) {
+      const r = run(e.argv(c))
+      if (r.ok) opened++
+      else error ??= r.error
+    }
     if (opened) return { opened, backend: e.bin }
+    return { opened: 0, backend: e.bin, error }
   }
-  return { opened: 0, backend: "none" }
+  return { opened: 0, backend: "none", error: "no supported terminal emulator found on PATH" }
 }
 
-type WinResult = { ok: boolean; backend: string; opened: number }
+type WinResult = { ok: boolean; backend: string; opened: number; error?: string }
 
 /** Open one window per command, picking the backend for the current environment. */
 function openWindows(cmds: string[], tile: boolean): WinResult {
   if (!cmds.length) return { ok: false, backend: "none", opened: 0 }
   if (process.env.TMUX) {
-    const opened = openTmux(cmds, tile)
-    return { ok: opened > 0, backend: "tmux", opened }
+    const { opened, error } = openTmux(cmds, tile)
+    return { ok: opened > 0, backend: "tmux", opened, error }
   }
   if (process.platform === "darwin") {
-    const opened = openMacWindows(cmds)
+    const { opened, error } = openMacWindows(cmds)
     const backend = process.env.TERM_PROGRAM === "iTerm.app" ? "iTerm" : "Terminal.app"
-    return { ok: opened > 0, backend, opened }
+    return { ok: opened > 0, backend, opened, error }
   }
   if (process.platform === "linux") {
-    const { opened, backend } = openLinuxTerminal(cmds)
-    return { ok: opened > 0, backend, opened }
+    const { opened, backend, error } = openLinuxTerminal(cmds)
+    return { ok: opened > 0, backend, opened, error }
   }
-  return { ok: false, backend: "none", opened: 0 }
+  return { ok: false, backend: "none", opened: 0, error: `unsupported platform: ${process.platform}` }
 }
 
 /** Read-only tiled watch windows, one per background agent (`friday attach <id>`). */
diff --git a/packages/core/src/keybindings.ts b/packages/core/src/keybindings.ts
index e672d77..3ea2cfd 100644
--- a/packages/core/src/keybindings.ts
+++ b/packages/core/src/keybindings.ts
@@ -14,7 +14,10 @@ export const DEFAULT_KEYBINDINGS = {
   "dashboard.toggle": "ctrl+o",
   "history.open": "ctrl+y",
   "mode.cycle": "shift+tab",
-  "pause.open": "shift+escape",
+  // 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+G (BEL) — reliable across terminals. Ctrl+, can't be used: terminals fold it onto Ctrl+\ (0x1c).
   "settings.open": "ctrl+g",
   "help.open": "f1",
diff --git a/packages/core/src/runner.ts b/packages/core/src/runner.ts
index 34c322e..942f579 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -354,6 +354,8 @@ export class SessionRunner {
   private lastInputTokens = 0
 
   private context: ProjectContext
+  /** Files the user pinned into context (relative paths). Read fresh each turn so edits are reflected. */
+  private pinned: string[] = []
   private skills: Skill[]
   private agents: AgentDef[]
   private lsp: LspManager
@@ -426,6 +428,7 @@ export class SessionRunner {
     this.todos = host.store.loadTodos(row.id)
     this.plans = host.store.loadPlans(row.id)
     this.checkpoints = deserializeCheckpoints(host.store.loadCheckpointsJson(row.id))
+    this.pinned = host.store.loadPinned(row.id)
     this.context = loadProjectContext(this.roots)
     this.skills = loadSkills(this.roots)
     this.agents = loadAgents(this.roots)
@@ -563,8 +566,33 @@ export class SessionRunner {
     })
     return out
   }
-  contextInfo(): { files: string[] } {
-    return { files: this.context.files }
+  contextInfo(): { files: string[]; pinned: string[] } {
+    return { files: this.context.files, pinned: [...this.pinned] }
+  }
+  /** Pin a file (relative to the primary root) into context for this session. Idempotent. */
+  pinFile(rel: string): void {
+    if (!rel.trim() || this.pinned.includes(rel)) return
+    this.pinned.push(rel)
+    this.host.store.setPinned(this.sessionId, this.pinned)
+  }
+  unpinFile(rel: string): void {
+    this.pinned = this.pinned.filter((p) => p !== rel)
+    this.host.store.setPinned(this.sessionId, this.pinned)
+  }
+  /** Read pinned files fresh and render them as <context> blocks appended to the project context. */
+  private pinnedContent(): string {
+    if (!this.pinned.length) return ""
+    const primary = this.roots[0] ?? this.cwd
+    const blocks: string[] = []
+    for (const rel of this.pinned) {
+      try {
+        const content = fs.readFileSync(path.resolve(primary, rel), "utf8")
+        if (content.trim()) blocks.push(`<context file="${rel}">\n${content}\n</context>`)
+      } catch {
+        /* file moved/deleted — skip silently */
+      }
+    }
+    return blocks.length ? `\n\n${blocks.join("\n\n")}` : ""
   }
   listSkills(): SkillInfo[] {
     return this.skills.map((s) => ({
@@ -1258,7 +1286,7 @@ export class SessionRunner {
               cwd: this.cwd,
               roots: this.roots,
               mode: sel.mode,
-              context: this.context.content,
+              context: this.context.content + this.pinnedContent(),
               skills: this.skills.map((s) => ({ name: s.name, description: s.description, whenToUse: s.whenToUse })),
               agents: this.agents.map((a) => ({ name: a.name, description: a.description })),
               // Advertise deferred tools (by name) that aren't yet activated, so the model knows to search.
diff --git a/packages/core/src/sessions.ts b/packages/core/src/sessions.ts
index 55d8aa3..22af7b4 100644
--- a/packages/core/src/sessions.ts
+++ b/packages/core/src/sessions.ts
@@ -53,12 +53,23 @@ export class SessionStore {
     this.db.exec(
       `CREATE TABLE IF NOT EXISTS session_state (
         session_id TEXT PRIMARY KEY, todos TEXT NOT NULL DEFAULT '[]',
-        plans TEXT NOT NULL DEFAULT '[]', checkpoints TEXT NOT NULL DEFAULT '[]'
+        plans TEXT NOT NULL DEFAULT '[]', checkpoints TEXT NOT NULL DEFAULT '[]',
+        pinned_files TEXT NOT NULL DEFAULT '[]'
       );`,
     )
+    // Migrate older DBs that predate pinned_files. Duplicate-column errors are expected & ignored.
+    try {
+      this.db.exec("ALTER TABLE session_state ADD COLUMN pinned_files TEXT NOT NULL DEFAULT '[]'")
+    } catch {
+      /* column already exists */
+    }
   }
 
-  private upsertState(sessionId: string, column: "todos" | "plans" | "checkpoints", json: string): void {
+  private upsertState(
+    sessionId: string,
+    column: "todos" | "plans" | "checkpoints" | "pinned_files",
+    json: string,
+  ): void {
     this.db
       .query(
         `INSERT INTO session_state (session_id, ${column}) VALUES (?, ?)
@@ -66,7 +77,7 @@ export class SessionStore {
       )
       .run(sessionId, json)
   }
-  private readState(sessionId: string, column: "todos" | "plans" | "checkpoints"): string {
+  private readState(sessionId: string, column: "todos" | "plans" | "checkpoints" | "pinned_files"): string {
     const r = this.db.query(`SELECT ${column} AS v FROM session_state WHERE session_id = ?`).get(sessionId) as
       | { v: string }
       | undefined
@@ -93,6 +104,17 @@ export class SessionStore {
       return []
     }
   }
+  /** Files the user pinned into context for this session (relative paths); restored on resume. */
+  setPinned(sessionId: string, files: string[]): void {
+    this.upsertState(sessionId, "pinned_files", JSON.stringify(files))
+  }
+  loadPinned(sessionId: string): string[] {
+    try {
+      return JSON.parse(this.readState(sessionId, "pinned_files")) as string[]
+    } catch {
+      return []
+    }
+  }
   /** Checkpoints serialize their file-snapshot Map to entry arrays; callers (re)hydrate the Map. */
   setCheckpointsJson(sessionId: string, json: string): void {
     this.upsertState(sessionId, "checkpoints", json)
diff --git a/packages/core/test/config.test.ts b/packages/core/test/config.test.ts
new file mode 100644
index 0000000..450ad38
--- /dev/null
+++ b/packages/core/test/config.test.ts
@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+// Isolate the user config dir before importing the module under test.
+process.env.FRIDAY_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "friday-cfg-home-"))
+const { loadConfig } = await import("../src/config.ts")
+const { configPath, projectConfigPath, projectLocalConfigPath } = await import("@friday/providers")
+
+test("config layers user → project → local with deep merge", () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "friday-cfg-proj-"))
+  fs.mkdirSync(path.join(cwd, ".friday"), { recursive: true })
+
+  // user: base model + one mcp server + a bash deny
+  fs.writeFileSync(
+    configPath(),
+    JSON.stringify({ model: "user-model", theme: "dark", mcp: { a: { type: "stdio" } }, bash: { deny: ["rm"] } }),
+  )
+  // project: override model, add a second mcp server (deep-merge keeps `a`)
+  fs.writeFileSync(projectConfigPath(cwd), JSON.stringify({ model: "project-model", mcp: { b: { type: "http" } } }))
+  // local: override theme only
+  fs.writeFileSync(projectLocalConfigPath(cwd), JSON.stringify({ theme: "light" }))
+
+  const cfg = loadConfig(cwd)
+  expect(cfg.model).toBe("project-model") // project beats user
+  expect(cfg.theme).toBe("light") // local beats user
+  expect(Object.keys(cfg.mcp ?? {}).sort()).toEqual(["a", "b"]) // nested objects merge, not replace
+  expect(cfg.bash?.deny).toEqual(["rm"]) // untouched user key survives
+})
+
+test("missing project files are a no-op (user config returned)", () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "friday-cfg-bare-"))
+  fs.writeFileSync(configPath(), JSON.stringify({ model: "solo" }))
+  expect(loadConfig(cwd).model).toBe("solo")
+})
diff --git a/packages/core/test/keybindings.test.ts b/packages/core/test/keybindings.test.ts
index 014fa75..10a78db 100644
--- a/packages/core/test/keybindings.test.ts
+++ b/packages/core/test/keybindings.test.ts
@@ -24,8 +24,9 @@ test("normalizeChord canonicalizes mod order + aliases", () => {
 test("actionForKey matches the default chords exactly", () => {
   const map = { ...DEFAULT_KEYBINDINGS }
   expect(actionForKey({ name: "b", ctrl: true }, map)).toBe("panel.toggle")
-  expect(actionForKey({ name: "escape", shift: true }, map)).toBe("pause.open")
-  // a plain Esc must NOT resolve to pause.open (shift differs) — keeps Esc-Esc stop working
+  // pause moved off shift+escape (terminals can't encode it) onto ctrl+p, which transmits everywhere
+  expect(actionForKey({ name: "p", ctrl: true }, map)).toBe("pause.open")
+  // a plain Esc must NOT resolve to any chord — keeps Esc-Esc stop / checkpoint working
   expect(actionForKey({ name: "escape" }, map)).toBeUndefined()
   expect(actionForKey({ name: "tab", shift: true }, map)).toBe("mode.cycle")
 })
diff --git a/packages/providers/src/paths.ts b/packages/providers/src/paths.ts
index a989455..a7ab5da 100644
--- a/packages/providers/src/paths.ts
+++ b/packages/providers/src/paths.ts
@@ -11,6 +11,14 @@ export function authPath(): string {
 export function configPath(): string {
   return path.join(fridayDir(), "config.json")
 }
+/** Project-level config, committed to the repo (layers over the user config). Like .claude/settings.json. */
+export function projectConfigPath(cwd: string = process.cwd()): string {
+  return path.join(cwd, ".friday", "settings.json")
+}
+/** Project-level local overrides, gitignored (layers over the project config). Like settings.local.json. */
+export function projectLocalConfigPath(cwd: string = process.cwd()): string {
+  return path.join(cwd, ".friday", "settings.local.json")
+}
 export function keybindingsPath(): string {
   return path.join(fridayDir(), "keybindings.json")
 }
diff --git a/packages/shared/src/theme.ts b/packages/shared/src/theme.ts
index fab00e3..107280c 100644
--- a/packages/shared/src/theme.ts
+++ b/packages/shared/src/theme.ts
@@ -86,63 +86,71 @@ const BASE: Theme = { ...theme }
  */
 export const THEMES: Record<string, Partial<Theme>> = {
   dark: {}, // the default — Friday's signature near-black palette
-  // Brighter text + edges on the same black canvas; for low-vision / harsh-light terminals.
+  // Brighter text + edges on the same black canvas; for low-vision / harsh-light terminals. Pushed
+  // clearly past `dark`: pure-white text, near-white muted/faint, bright surfaces and edges, and a
+  // selection band light enough to be unmistakable — so the two themes never look interchangeable.
   "high-contrast": {
+    bgComposer: "#1f2228",
+    bgPanel: "#1f2228",
+    bgElevated: "#2b2f37",
+    bgHover: "#3c414b",
     text: "#ffffff",
-    textMuted: "#d4d6db",
-    textFaint: "#b3b6bd",
-    border: "#8a8d96",
-    borderMuted: "#4a4c54",
+    textMuted: "#e4e6eb",
+    textFaint: "#c4c8d0",
+    border: "#9aa0ab",
+    borderMuted: "#5a5e68",
     borderActive: "#ffffff",
-    bgSelected: "#5a5d68",
+    bgSelected: "#6a6e7a",
   },
-  // A complete light palette — every token overridden so code blocks, markdown and diffs stay legible
-  // on white (a partial override would leave dark-theme text invisible on the light canvas). The
-  // selection band is a saturated mid-blue so the shared white `textOnAccent` reads on it AND on the
-  // semantic (warning/error) bands, matching how the dark theme's single on-accent text works.
+  // Warm-paper light palette (Claude-Code-style) — a soft cream canvas, not harsh pure white, with
+  // Friday's amber brand kept (darkened to read on light). Every token is overridden so dark-theme
+  // values can't bleed through. The selection band is a saturated warm amber so the shared white
+  // `textOnAccent` reads on it AND on the semantic (success/warning/error) bands — same single-
+  // on-accent-text model the dark theme uses.
   light: {
-    bg: "#ffffff",
-    bgComposer: "#f1f2f4",
-    bgPanel: "#f3f4f6",
-    bgElevated: "#e9ebef",
-    bgHover: "#dfe2e8",
-    bgSelected: "#2f6fb0",
-    text: "#1a1c20",
-    textMuted: "#4a4f57",
-    textFaint: "#6b727c",
+    bg: "#faf9f5", // warm paper, not pure white
+    bgComposer: "#f0eee6",
+    bgPanel: "#f0eee6",
+    bgElevated: "#e9e6dc",
+    bgHover: "#e2ded2",
+    bgSelected: "#b5751a", // saturated warm amber band — white text reads on it
+    text: "#2a2824",
+    textMuted: "#5c574e",
+    textFaint: "#8a857a",
     textOnAccent: "#ffffff",
-    brand: "#b36b00",
-    brandDim: "#8a5a14",
-    border: "#c3c7cf",
-    borderMuted: "#d9dce1",
-    borderActive: "#9197a0",
+    brand: "#b3691a", // warm amber, darkened for the light canvas
+    brandDim: "#8a5414",
+    border: "#d8d3c6", // soft warm edges
+    borderMuted: "#e6e1d6",
+    borderActive: "#b3ad9d",
     user: "#3a5a8c",
-    success: "#1f8f3f",
+    success: "#2f8a3e",
     warning: "#9a6a00",
-    error: "#c0394f",
+    error: "#c0392b",
     info: "#1f6fb0",
-    syntaxComment: "#6a737d",
-    syntaxKeyword: "#d73a49",
-    syntaxFunction: "#6f42c1",
-    syntaxVariable: "#24292e",
-    syntaxString: "#22863a",
-    syntaxNumber: "#005cc5",
-    syntaxType: "#005cc5",
-    syntaxOperator: "#d73a49",
-    syntaxPunctuation: "#24292e",
-    markdownHeading: "#005cc5",
-    markdownStrong: "#24292e",
-    markdownEmph: "#6f42c1",
-    markdownLink: "#0366d6",
-    markdownLinkText: "#22863a",
-    markdownCode: "#b31d28",
-    markdownQuote: "#6a737d",
-    markdownListMarker: "#005cc5",
-    diffAdded: "#22863a",
-    diffRemoved: "#b31d28",
-    diffAddedBg: "#e6ffed",
-    diffRemovedBg: "#ffeef0",
-    diffContextBg: "#ffffff",
+    // GitHub-light-style syntax, tuned to sit on the warm canvas.
+    syntaxComment: "#8a857a",
+    syntaxKeyword: "#cf222e",
+    syntaxFunction: "#6639ba",
+    syntaxVariable: "#2a2824",
+    syntaxString: "#1a7f37",
+    syntaxNumber: "#0550ae",
+    syntaxType: "#0550ae",
+    syntaxOperator: "#cf222e",
+    syntaxPunctuation: "#3a3630",
+    markdownHeading: "#0550ae",
+    markdownStrong: "#2a2824",
+    markdownEmph: "#6639ba",
+    markdownLink: "#0969da",
+    markdownLinkText: "#1a7f37",
+    markdownCode: "#b3691a",
+    markdownQuote: "#8a857a",
+    markdownListMarker: "#0550ae",
+    diffAdded: "#1a7f37",
+    diffRemoved: "#cf222e",
+    diffAddedBg: "#e6f4ea",
+    diffRemovedBg: "#fbe9e7",
+    diffContextBg: "#faf9f5",
   },
 }
 
diff --git a/packages/shared/test/theme.test.ts b/packages/shared/test/theme.test.ts
index ee6070c..9276b63 100644
--- a/packages/shared/test/theme.test.ts
+++ b/packages/shared/test/theme.test.ts
@@ -19,7 +19,7 @@ test("themeNames lists the built-in presets with dark first", () => {
 test("applyTheme layers a preset, then resets to default", () => {
   const defaultText = theme.text
   applyTheme("light")
-  expect(theme.bg).toBe("#ffffff") // preset override applied
+  expect(theme.bg).toBe("#faf9f5") // preset override applied (warm-paper light)
   applyTheme("dark")
   expect(theme.text).toBe(defaultText) // reset back to the default palette
 })
diff --git a/packages/tui/src/App.tsx b/packages/tui/src/App.tsx
index bf27b38..0d3a56f 100644
--- a/packages/tui/src/App.tsx
+++ b/packages/tui/src/App.tsx
@@ -10,6 +10,7 @@ import { CompactionCard, CompactionSummary } from "./components/CompactionCard.t
 import { Composer } from "./components/Composer.tsx"
 import { ComputerModal } from "./components/ComputerModal.tsx"
 import { ConsoleView } from "./components/ConsoleView.tsx"
+import { ContextFilesModal } from "./components/ContextFilesModal.tsx"
 import { ContextPanel } from "./components/ContextPanel.tsx"
 import { Dashboard } from "./components/Dashboard.tsx"
 import { DirectoryModal } from "./components/DirectoryModal.tsx"
@@ -198,6 +199,9 @@ function Shell() {
       <Show when={app.skillsModalOpen()}>
         <SkillsModal />
       </Show>
+      <Show when={app.contextModalOpen()}>
+        <ContextFilesModal />
+      </Show>
       <Show when={app.computerModalOpen()}>
         <ComputerModal />
       </Show>
@@ -272,6 +276,14 @@ function AppRoot() {
     // Every other modal / HITL prompt owns its own keyboard; global shortcuts must not fire under
     // them. anyModalOpen() is the single source of truth (store), so nothing can be forgotten here.
     if (app.anyModalOpen()) return
+    // Cmd+Enter pauses the agent. Gated on `super` (Cmd under the kitty protocol) — NOT `meta`,
+    // because legacy terminals deliver Option+Enter as meta+return (a newline), so matching meta
+    // here would hijack the newline key. This lives in the global handler, not the textarea
+    // keyBindings, because the textarea folds Option onto meta and can't tell the two apart.
+    // Ctrl+P (pause.open) is the reliable path on terminals without the kitty protocol.
+    if (key.name === "return" && key.super && !key.ctrl && !key.shift) {
+      return void app.runCommand("pause")
+    }
     // Rebindable named actions (see ~/.friday/keybindings.json). Resolved before the bespoke
     // arming keys below; a plain Esc never matches a chord (shift+escape ≠ escape) so stop/checkpoint
     // arming still works.
diff --git a/packages/tui/src/components/ComputerModal.tsx b/packages/tui/src/components/ComputerModal.tsx
index 31b9f4b..5089f4d 100644
--- a/packages/tui/src/components/ComputerModal.tsx
+++ b/packages/tui/src/components/ComputerModal.tsx
@@ -69,6 +69,18 @@ export function ComputerModal() {
             <text fg={theme.textFaint}>unless you're in yolo mode.</text>
           </box>
 
+          {/* OS permissions — macOS needs Accessibility (control) + Screen Recording (screenshot).
+              These buttons open the exact settings pane so the user can click-grant directly. */}
+          <Show when={support().platform === "macOS"}>
+            <box flexDirection="column" gap={0}>
+              <text fg={theme.textFaint}>macOS permissions — grant these, then restart Friday:</text>
+              <box flexDirection="row" gap={1}>
+                <Pill label="⚙ accessibility" onClick={() => app.openMacPrivacy("accessibility")} />
+                <Pill label="⚙ screen recording" onClick={() => app.openMacPrivacy("screen")} />
+              </box>
+            </box>
+          </Show>
+
           {/* Actions */}
           <box flexDirection="row" gap={1} alignItems="center">
             <Show when={!app.computerReady()}>
diff --git a/packages/tui/src/components/ConsoleView.tsx b/packages/tui/src/components/ConsoleView.tsx
index 397bc29..6e879ec 100644
--- a/packages/tui/src/components/ConsoleView.tsx
+++ b/packages/tui/src/components/ConsoleView.tsx
@@ -2,6 +2,7 @@ import { theme } from "@friday/shared"
 import { useKeyboard } from "@opentui/solid"
 import { createSignal, For, Show } from "solid-js"
 import { type TeamMember, useApp, type ViewItem } from "../store.tsx"
+import { G } from "../util/term.ts"
 import { bandBg, SectionLabel } from "./ui.tsx"
 
 /** Status → dot glyph + color. */
@@ -28,7 +29,7 @@ export function line(it: ViewItem): { text: string; c: string } {
     case "assistant":
       return { text: it.text || (it.done ? "" : "…"), c: theme.text }
     case "tool":
-      return { text: `⚙ ${it.name}${it.title ? `: ${it.title}` : ""}`, c: theme.textMuted }
+      return { text: `${G.tool} ${it.name}${it.title ? `: ${it.title}` : ""}`, c: theme.textMuted }
     case "error":
       return { text: `✗ ${it.text}`, c: theme.error }
     case "notice":
diff --git a/packages/tui/src/components/ContextFilesModal.tsx b/packages/tui/src/components/ContextFilesModal.tsx
new file mode 100644
index 0000000..0e454b1
--- /dev/null
+++ b/packages/tui/src/components/ContextFilesModal.tsx
@@ -0,0 +1,152 @@
+import { theme } from "@friday/shared"
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
+import { createEffect, createSignal, For, Show } from "solid-js"
+import { useApp } from "../store.tsx"
+import { listProjectFiles } from "../util/files.ts"
+import { Scrim } from "./Scrim.tsx"
+import { bandBg, HintChip, Meta, Overlay } from "./ui.tsx"
+
+/**
+ * View and manage the files in this session's context. Two kinds:
+ *   - AUTO: FRIDAY.md / AGENTS.md discovered up the tree (read-only — edit the files to change them).
+ *   - PINNED: files you pin here; their contents are injected into context every turn and persist for
+ *     the session. Type to filter the project, ⏎ to pin; on a pinned row ⏎ (or click ✕) unpins.
+ */
+export function ContextFilesModal() {
+  const app = useApp()
+  const dims = useTerminalDimensions()
+  const [query, setQuery] = createSignal("")
+  const [files, setFiles] = createSignal<string[]>([])
+  const [sel, setSel] = createSignal(0)
+
+  createEffect(() => {
+    if (app.contextModalOpen()) listProjectFiles(app.roots()).then(setFiles)
+  })
+
+  const pinned = () => app.pinnedFiles()
+  // Filtered candidates to add: project files matching the query, not already pinned.
+  const matches = () => {
+    const q = query().toLowerCase().trim()
+    const pset = new Set(pinned())
+    return files()
+      .filter((f) => !pset.has(f) && (!q || f.toLowerCase().includes(q)))
+      .slice(0, 200)
+  }
+  const clamped = () => Math.min(sel(), Math.max(0, matches().length - 1))
+
+  let sb: any
+  createEffect(() => {
+    const i = clamped()
+    queueMicrotask(() => sb?.scrollChildIntoView?.(`ctxfile-${i}`))
+  })
+
+  useKeyboard((key) => {
+    if (!app.contextModalOpen()) return
+    if (key.name === "escape") {
+      if (query()) return setQuery("")
+      return app.setContextModalOpen(false)
+    }
+    const m = matches()
+    if (key.name === "up") return setSel((s) => (m.length ? (s - 1 + m.length) % m.length : 0))
+    if (key.name === "down") return setSel((s) => (m.length ? (s + 1) % m.length : 0))
+    if (key.name === "return" || key.name === "enter") {
+      const pick = m[clamped()]
+      if (pick) {
+        app.pinContextFile(pick)
+        setQuery("")
+        setSel(0)
+      }
+      return
+    }
+    if (key.name === "backspace") return setQuery((q) => q.slice(0, -1))
+    // Printable char → extend the filter.
+    if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta && key.sequence >= " ") {
+      setSel(0)
+      return setQuery((q) => q + key.sequence)
+    }
+  })
+
+  return (
+    <Scrim onClose={() => app.setContextModalOpen(false)}>
+      <Overlay title="context files" hint="what Friday is reading this session" width={Math.min(72, dims().width - 4)}>
+        {/* AUTO context (read-only) */}
+        <Show when={app.contextFiles().length}>
+          <box flexDirection="column">
+            <Meta text="auto · FRIDAY.md / AGENTS.md (edit the files to change)" />
+            <For each={app.contextFiles()}>
+              {(f) => (
+                <box flexDirection="row" gap={1} paddingLeft={1}>
+                  <text fg={theme.textFaint}>📄</text>
+                  <text fg={theme.textMuted}>{f}</text>
+                </box>
+              )}
+            </For>
+          </box>
+        </Show>
+
+        {/* PINNED files — each removable */}
+        <box flexDirection="column">
+          <Meta text={`pinned · ${pinned().length} (persist for this session)`} />
+          <Show
+            when={pinned().length}
+            fallback={<text fg={theme.textFaint}> none yet — type below to pin a file</text>}
+          >
+            <For each={pinned()}>
+              {(f) => (
+                <box flexDirection="row" gap={1} paddingLeft={1} onMouseDown={() => app.unpinContextFile(f)}>
+                  <text fg={theme.brand}>📎</text>
+                  <text fg={theme.text}>{f}</text>
+                  <box flexGrow={1} />
+                  <text fg={theme.error}>✕</text>
+                </box>
+              )}
+            </For>
+          </Show>
+        </box>
+
+        {/* ADD: filter + results */}
+        <box flexDirection="column">
+          <box flexDirection="row" gap={1}>
+            <text fg={theme.textFaint}>+ add file</text>
+            <text fg={theme.text}>{query() || "…"}</text>
+          </box>
+          <Show when={query()}>
+            <scrollbox ref={(r: any) => (sb = r)} maxHeight={10}>
+              <For each={matches()}>
+                {(f, i) => {
+                  const on = () => clamped() === i()
+                  return (
+                    <box
+                      id={`ctxfile-${i()}`}
+                      flexDirection="row"
+                      gap={1}
+                      paddingLeft={1}
+                      paddingRight={1}
+                      backgroundColor={bandBg(on())}
+                      onMouseOver={() => setSel(i())}
+                      onMouseDown={() => {
+                        app.pinContextFile(f)
+                        setQuery("")
+                        setSel(0)
+                      }}
+                    >
+                      <text fg={on() ? theme.textOnAccent : theme.textFaint}>📎</text>
+                      <text fg={on() ? theme.textOnAccent : theme.text}>{f}</text>
+                    </box>
+                  )
+                }}
+              </For>
+            </scrollbox>
+          </Show>
+        </box>
+
+        <box flexDirection="row" gap={1}>
+          <HintChip label="type to filter" />
+          <HintChip label="⏎ pin" accent={theme.success} />
+          <HintChip label="✕ click to unpin" />
+          <HintChip label="esc close" onClick={() => app.setContextModalOpen(false)} />
+        </box>
+      </Overlay>
+    </Scrim>
+  )
+}
diff --git a/packages/tui/src/components/ContextPanel.tsx b/packages/tui/src/components/ContextPanel.tsx
index 8ccc9ea..3263804 100644
--- a/packages/tui/src/components/ContextPanel.tsx
+++ b/packages/tui/src/components/ContextPanel.tsx
@@ -89,7 +89,7 @@ function Section(props: {
 }) {
   const h = useHover({ base: theme.bgPanel, hover: theme.bgHover })
   return (
-    <box flexDirection="column">
+    <box flexDirection="column" marginTop={1}>
       <box
         flexDirection="row"
         gap={1}
@@ -98,8 +98,11 @@ function Section(props: {
         onMouseOut={h.onMouseOut}
         onMouseDown={props.onToggle}
       >
-        <text fg={h.hovered() ? theme.text : theme.textMuted}>{props.open ? "▾" : "▸"}</text>
-        <text fg={h.hovered() ? theme.text : theme.textFaint}>{props.label.toUpperCase()}</text>
+        {/* Reversed hierarchy: the title is the bright, bold anchor; caret + count stay faint. */}
+        <text fg={h.hovered() ? theme.brand : theme.textMuted}>{props.open ? "▾" : "▸"}</text>
+        <text fg={theme.text}>
+          <strong>{props.label.toUpperCase()}</strong>
+        </text>
         <Show when={props.count != null}>
           <text fg={theme.textFaint}>({props.count})</text>
         </Show>
@@ -190,6 +193,7 @@ export function ContextPanel(props: { fullscreen?: boolean; widthOverride?: numb
 
   const mcpHover = useHover({ base: theme.bgPanel, hover: theme.bgHover })
   const skillsHover = useHover({ base: theme.bgPanel, hover: theme.bgHover })
+  const contextHover = useHover({ base: theme.bgPanel, hover: theme.bgHover })
   const [planHov, setPlanHov] = createSignal(-1)
   const pct = () =>
     app.contextWindow() > 0 ? Math.min(100, Math.round((app.tokens() / app.contextWindow()) * 100)) : 0
@@ -242,10 +246,10 @@ export function ContextPanel(props: { fullscreen?: boolean; widthOverride?: numb
         backgroundColor={theme.bgPanel}
         paddingTop={1}
       >
+        {/* No panel title — the close control sits at the right edge with its shortcut shown clearly. */}
         <box flexDirection="row" paddingRight={1} alignItems="center">
-          <CloseButton hint="ctrl+b" onClose={() => app.setRightOpen(false)} />
           <box flexGrow={1} />
-          <SectionLabel text="context" />
+          <CloseButton hint="ctrl+b" onClose={() => app.setRightOpen(false)} />
         </box>
 
         <scrollbox flexGrow={1} minHeight={0} paddingLeft={1} paddingRight={1} paddingTop={1}>
@@ -392,7 +396,7 @@ export function ContextPanel(props: { fullscreen?: boolean; widthOverride?: numb
                 onMouseDown={() => app.setMcpModalOpen(true)}
               >
                 <text fg={app.mcpServers().length ? theme.success : mcpHover.hovered() ? theme.text : theme.textFaint}>
-                  ⚡ {app.mcpServers().length} mcp
+                  {G.mcp} {app.mcpServers().length} mcp
                 </text>
               </box>
               <box
@@ -405,13 +409,25 @@ export function ContextPanel(props: { fullscreen?: boolean; widthOverride?: numb
                 onMouseDown={() => app.setSkillsModalOpen(true)}
               >
                 <text fg={app.skills().length ? theme.text : skillsHover.hovered() ? theme.text : theme.textFaint}>
-                  ◆ {app.skills().length} skills
+                  {G.skill} {app.skills().length} skills
                 </text>
               </box>
             </box>
-            <Show when={app.contextFiles().length}>
-              <text fg={theme.textFaint}>✓ {app.contextFiles().length} context files</text>
-            </Show>
+            {/* Permanent, clickable — opens the context-files modal to view auto context + pin files. */}
+            <box
+              flexGrow={1}
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={contextHover.bg()}
+              onMouseOver={contextHover.onMouseOver}
+              onMouseOut={contextHover.onMouseOut}
+              onMouseDown={() => app.setContextModalOpen(true)}
+            >
+              <text fg={app.pinnedFiles().length ? theme.brand : contextHover.hovered() ? theme.text : theme.textFaint}>
+                {G.pin} {app.contextFiles().length + app.pinnedFiles().length} context
+                {app.pinnedFiles().length ? ` · ${app.pinnedFiles().length} pinned` : ""}
+              </text>
+            </box>
 
             <Rule width={innerW()} />
 
diff --git a/packages/tui/src/components/EffortSlider.tsx b/packages/tui/src/components/EffortSlider.tsx
index cd79360..b23fdb2 100644
--- a/packages/tui/src/components/EffortSlider.tsx
+++ b/packages/tui/src/components/EffortSlider.tsx
@@ -44,19 +44,10 @@ export function EffortGauge(props: {
   const cur = () => props.levels[props.index] ?? props.levels[0]!
   const color = () => RAMP[cur()].color
   const [hov, setHov] = createSignal(-1)
-  // A hand-drawn track (●━━━○━━━○): nodes joined by segments, filled up to the current level.
-  // (`@opentui/solid` has no native <slider>, and a text track aligns cleanly in every terminal.)
-  const SEG = 6
-  const track = () => {
-    let full = ""
-    let thumb = 0
-    props.levels.forEach((_lv, i) => {
-      if (i === props.index) thumb = full.length
-      full += i < props.index ? "●" : i === props.index ? "◉" : "○"
-      if (i < props.levels.length - 1) full += (i < props.index ? "━" : "─").repeat(SEG)
-    })
-    return { filled: full.slice(0, thumb + 1), rest: full.slice(thumb + 1) }
-  }
+  // The gauge is an intensity bar-ramp (▁▃▅▆█): each level is its block glyph, colored on its
+  // cool→warm hue up to and including the current level, dim grey beyond it. This reads as a rising
+  // "more effort = taller, warmer" slider far more clearly than a flat dotted track, and the block
+  // glyphs are single-width so columns stay aligned in every terminal.
   return (
     <Show
       when={props.levels.length}
@@ -64,27 +55,41 @@ export function EffortGauge(props: {
     >
       <box flexDirection="row" gap={1} alignItems="center">
         <text fg={color()}>{badge(cur())}</text>
-        <text fg={theme.text}>{cur()}</text>
-      </box>
-      <box flexDirection="row">
-        <text fg={cur() === "max" ? shimmerAccent(color()) : color()}>{track().filled}</text>
-        <text fg={theme.border}>{track().rest}</text>
+        <text fg={theme.text}>
+          <strong>{cur()}</strong>
+        </text>
       </box>
+      {/* Clickable ramp: each cell is the level's bar over its label; click or hover to target it. */}
       <box flexDirection="row" gap={1}>
-        {props.levels.map((lv, i) => (
-          <box
-            paddingLeft={1}
-            paddingRight={1}
-            backgroundColor={bandBg(hov() === i)}
-            onMouseOver={() => setHov(i)}
-            onMouseOut={() => setHov(-1)}
-            onMouseDown={() => props.onPick(i)}
-          >
-            <text fg={hov() === i ? theme.textOnAccent : i === props.index ? RAMP[lv].color : theme.textFaint}>
-              {lv}
-            </text>
-          </box>
-        ))}
+        {props.levels.map((lv, i) => {
+          const active = () => i <= props.index
+          const on = () => hov() === i
+          const barFg = () =>
+            on()
+              ? theme.textOnAccent
+              : active()
+                ? lv === "max"
+                  ? shimmerAccent(RAMP[lv].color)
+                  : RAMP[lv].color
+                : theme.border
+          return (
+            <box
+              flexDirection="column"
+              alignItems="center"
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={bandBg(on())}
+              onMouseOver={() => setHov(i)}
+              onMouseOut={() => setHov(-1)}
+              onMouseDown={() => props.onPick(i)}
+            >
+              <text fg={barFg()}>{RAMP[lv].ascii}</text>
+              <text fg={on() ? theme.textOnAccent : i === props.index ? RAMP[lv].color : theme.textFaint}>
+                {i === props.index ? <strong>{lv}</strong> : lv}
+              </text>
+            </box>
+          )
+        })}
       </box>
       <text fg={theme.textMuted}>{BLURB[cur()]}</text>
     </Show>
diff --git a/packages/tui/src/components/StatusStrip.tsx b/packages/tui/src/components/StatusStrip.tsx
index e11e2da..b8eedc1 100644
--- a/packages/tui/src/components/StatusStrip.tsx
+++ b/packages/tui/src/components/StatusStrip.tsx
@@ -2,6 +2,7 @@ import { getMode, MASCOT, type MascotState, theme } from "@friday/shared"
 import { createEffect, createSignal, onCleanup, Show } from "solid-js"
 import { useBreathe } from "../motion/index.ts"
 import { useApp } from "../store.tsx"
+import { hasKittyKeyboard } from "../util/term.ts"
 import { useMascotFrame } from "../util/useMascot.ts"
 import { Pressable } from "./Pressable.tsx"
 
@@ -110,14 +111,17 @@ export function StatusStrip() {
           <text fg={app.stopArmed() ? theme.bg : theme.error}>■ stop{app.stopArmed() ? " · esc again" : " · esc"}</text>
         </box>
         {/* Pause — opens the /pause modal so you can course-correct the running agent by adding context.
-            The shown key mirrors the (rebindable) pause.open binding, default Shift+Esc. */}
+            On kitty-protocol terminals show the nicer Cmd+Enter; otherwise the rebindable pause.open
+            binding (Ctrl+P), the chord that transmits everywhere. */}
         <box
           onMouseDown={() => app.runCommand("pause")}
           backgroundColor={theme.bgElevated}
           paddingLeft={1}
           paddingRight={1}
         >
-          <text fg={theme.warning}>⏸ Pause · {fmtChord(app.keymap()["pause.open"])}</text>
+          <text fg={theme.warning}>
+            ⏸ Pause · {hasKittyKeyboard ? "Cmd+Enter" : fmtChord(app.keymap()["pause.open"])}
+          </text>
         </box>
       </Show>
       <box flexGrow={1} />
diff --git a/packages/tui/src/index.tsx b/packages/tui/src/index.tsx
index 5273f3e..85fc26b 100644
--- a/packages/tui/src/index.tsx
+++ b/packages/tui/src/index.tsx
@@ -20,5 +20,11 @@ export async function start(engine: Engine, version = "dev"): Promise<void> {
     exitOnCtrlC: false, // we handle Ctrl+C to show the clean-exit screen
     useMouse: true,
     autoFocus: true,
+    // Kitty keyboard protocol: negotiated via a query/response handshake — terminals that don't
+    // support it (Terminal.app) simply ignore it, so this is safe everywhere. Where supported
+    // (kitty, WezTerm, Ghostty, modern iTerm2) it delivers chords legacy terminals can't encode:
+    // Shift+Enter, Cmd/Super+Enter (pause), and disambiguated Esc. `disambiguate` also fixes the
+    // alt-vs-meta ambiguity and ESC timing.
+    useKittyKeyboard: { disambiguate: true, alternateKeys: true },
   })
 }
diff --git a/packages/tui/src/store.tsx b/packages/tui/src/store.tsx
index 0ac7319..5e81273 100644
--- a/packages/tui/src/store.tsx
+++ b/packages/tui/src/store.tsx
@@ -255,6 +255,8 @@ export function createAppStore(engine: Engine, version = "dev") {
   const EMPTY: never[] = []
   const items = createMemo(() => sessionItems[activeSession()] ?? EMPTY)
   const [contextFiles, setContextFiles] = createSignal<string[]>(engine.contextInfo().files)
+  const [pinnedFiles, setPinnedFiles] = createSignal<string[]>(engine.contextInfo().pinned)
+  const [contextModalOpen, setContextModalOpen] = createSignal(false)
   const [skills, setSkills] = createSignal(engine.listSkills())
   const [mcpServers, setMcpServers] = createSignal(engine.listMcpServers())
   const [sessions, setSessions] = createSignal<SessionItem[]>(engine.listSessions())
@@ -296,6 +298,21 @@ export function createAppStore(engine: Engine, version = "dev") {
     engine.uninstallComputerUse()
     setComputerReady(engine.computerInstalled())
   }
+  /** Open the macOS privacy pane for the permission computer-use needs (control = Accessibility,
+   * screenshot = Screen Recording) so the user can click-grant instead of hunting through Settings. */
+  function openMacPrivacy(pane: "accessibility" | "screen") {
+    if (process.platform !== "darwin") {
+      pushToast("opening privacy settings is only supported on macOS", "input")
+      return
+    }
+    const anchor = pane === "accessibility" ? "Privacy_Accessibility" : "Privacy_ScreenCapture"
+    try {
+      Bun.spawn(["open", `x-apple.systempreferences:com.apple.preference.security?${anchor}`])
+      pushToast(`opened ${pane === "accessibility" ? "Accessibility" : "Screen Recording"} settings`, "done")
+    } catch (e) {
+      pushToast(`couldn't open settings: ${e instanceof Error ? e.message : String(e)}`, "error")
+    }
+  }
   const [checkpointsOpen, setCheckpointsOpen] = createSignal(false)
   const [forkOpen, setForkOpen] = createSignal(false)
   const [settingsModalOpen, setSettingsModalOpen] = createSignal(false)
@@ -409,6 +426,7 @@ export function createAppStore(engine: Engine, version = "dev") {
     pauseModalOpen() ||
     mcpModalOpen() ||
     skillsModalOpen() ||
+    contextModalOpen() ||
     computerModalOpen() ||
     checkpointsOpen() ||
     forkOpen() ||
@@ -428,9 +446,19 @@ export function createAppStore(engine: Engine, version = "dev") {
     setSessions(engine.listSessions())
     setAllSessions(engine.listAllSessions())
     setContextFiles(engine.contextInfo().files)
+    setPinnedFiles(engine.contextInfo().pinned)
     setSkills(engine.listSkills())
   }
 
+  const pinContextFile = (rel: string) => {
+    engine.pinContextFile(rel)
+    setPinnedFiles(engine.contextInfo().pinned)
+  }
+  const unpinContextFile = (rel: string) => {
+    engine.unpinContextFile(rel)
+    setPinnedFiles(engine.contextInfo().pinned)
+  }
+
   let localId = 0
   const nextLocalId = () => `u${++localId}`
 
@@ -900,15 +928,19 @@ export function createAppStore(engine: Engine, version = "dev") {
     }
   }
   // ---- dashboard launchers (open work in its own window; the dashboard stays the console) ----
+  /** A window-launch failure message that names the real reason (truncated) instead of a generic line. */
+  const winFail = (r: { backend: string; error?: string }, what: string) =>
+    r.error ? `couldn't open ${what} (${r.backend}): ${r.error.slice(0, 120)}` : `no terminal backend to open ${what}`
+
   /** Open a brand-new interactive friday window (new chat) in the current directory. */
   function newChatWindow() {
     const r = engine.openInteractive([])
-    pushToast(r.ok ? `opened new chat (${r.backend})` : "no terminal backend to open a window", r.ok ? "done" : "error")
+    pushToast(r.ok ? `opened new chat (${r.backend})` : winFail(r, "a window"), r.ok ? "done" : "error")
   }
   /** Resume an existing session in its own interactive window. */
   function resumeInWindow(id: string) {
     const r = engine.openInteractive(["-s", id])
-    pushToast(r.ok ? `opened session (${r.backend})` : "no terminal backend to open a window", r.ok ? "done" : "error")
+    pushToast(r.ok ? `opened session (${r.backend})` : winFail(r, "the session"), r.ok ? "done" : "error")
   }
   /** Fan out a swarm of independent agents (one task per line) + open watch windows for each. */
   function launchSwarm(tasks: string[]) {
@@ -1139,7 +1171,9 @@ export function createAppStore(engine: Engine, version = "dev") {
         pushToast(
           r.ok
             ? `opened ${r.opened} agent window(s) via ${r.backend}`
-            : "no terminal backend — see the dashboard's Swarm tab (Ctrl+O)",
+            : r.error
+              ? `couldn't open agent windows (${r.backend}): ${r.error.slice(0, 120)}`
+              : "no terminal backend — see the dashboard's Swarm tab (Ctrl+O)",
           r.ok ? "done" : "input",
         )
         return true
@@ -1495,7 +1529,7 @@ export function createAppStore(engine: Engine, version = "dev") {
   }
   function popoutAgent(sessionId: string) {
     const r = engine.popoutAgent(sessionId)
-    pushToast(r.ok ? `opened agent window via ${r.backend}` : "no terminal backend available", r.ok ? "done" : "input")
+    pushToast(r.ok ? `opened agent window via ${r.backend}` : winFail(r, "the agent window"), r.ok ? "done" : "input")
   }
   function deleteSession(id: string) {
     engine.deleteSession(id)
@@ -1744,6 +1778,7 @@ export function createAppStore(engine: Engine, version = "dev") {
     computerInstallLog,
     installComputer,
     uninstallComputer,
+    openMacPrivacy,
     setMcpModalOpen,
     mcpConfig,
     refreshMcp,
@@ -1775,6 +1810,11 @@ export function createAppStore(engine: Engine, version = "dev") {
     listCommands,
     runCommand,
     contextFiles,
+    pinnedFiles,
+    pinContextFile,
+    unpinContextFile,
+    contextModalOpen,
+    setContextModalOpen,
     skills,
     mcpServers,
     runningTools,
diff --git a/packages/tui/src/util/term.ts b/packages/tui/src/util/term.ts
index e05303c..71949b2 100644
--- a/packages/tui/src/util/term.ts
+++ b/packages/tui/src/util/term.ts
@@ -27,6 +27,20 @@ export const hasTruecolor =
     !!process.env.KITTY_WINDOW_ID ||
     ["iTerm.app", "WezTerm", "ghostty", "vscode", "Hyper"].includes(termProgram))
 
+/**
+ * True when the terminal is expected to support the kitty keyboard protocol, which lets us receive
+ * chords legacy terminals can't encode (Shift+Enter, Cmd/Super+Enter, disambiguated Shift+Esc).
+ * Used only to pick which pause hint to SHOW — the actual binding works whenever the protocol
+ * negotiates, regardless of this guess. Apple Terminal and the VS Code terminal don't support it.
+ */
+export const hasKittyKeyboard =
+  !!process.env.KITTY_WINDOW_ID ||
+  !!process.env.WT_SESSION ||
+  /ghostty/i.test(term) ||
+  ["WezTerm", "ghostty"].includes(termProgram) ||
+  // iTerm2 >= 3.5 supports it; assume modern.
+  termProgram === "iTerm.app"
+
 /**
  * Whether to avoid wide/emoji glyphs. We render the FULL glyph set in every terminal (like opencode)
  * so the UI looks identical everywhere — automatic degradation is OFF. `FRIDAY_ASCII=1` is the only
@@ -65,6 +79,11 @@ export const G = {
   // status dots (mcp, etc.)
   dotOn: glyph("●", "o"),
   dotOff: glyph("○", "."),
+  // feature glyphs — each distinct so nothing shares an icon (mcp/skill/tool/pin used to collide with ⚡/✓)
+  mcp: glyph("⧉", "#"), // MCP servers
+  skill: glyph("◆", "*"), // skills
+  tool: glyph("⚙", "%"), // tool calls
+  pin: glyph("📎", "@"), // pinned / context files
   // misc affordances
   bolt: glyph("⚡", "!"),
   warn: glyph("⚠", "!"),
diff --git a/packages/tui/test/keymap-pause.test.tsx b/packages/tui/test/keymap-pause.test.tsx
new file mode 100644
index 0000000..0f2cc12
--- /dev/null
+++ b/packages/tui/test/keymap-pause.test.tsx
@@ -0,0 +1,56 @@
+import { expect, test } from "bun:test"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { Engine } from "@friday/core"
+import { testRender } from "@opentui/solid"
+import { App } from "../src/App.tsx"
+
+process.env.FRIDAY_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "friday-home-"))
+
+function newEngine() {
+  return new Engine({ cwd: fs.mkdtempSync(path.join(os.tmpdir(), "friday-cwd-")) })
+}
+
+async function shell(opts: { kittyKeyboard?: boolean } = {}) {
+  const t = await testRender(() => <App engine={newEngine()} />, { width: 120, height: 36, ...opts })
+  await t.renderOnce()
+  t.mockInput.pressEnter() // trust the workspace
+  await t.flush()
+  await t.mockMouse.click(2, 2) // dismiss first-run /model picker
+  await t.flush()
+  return t
+}
+
+/** Flush a few render cycles, then return the frame (toasts settle a couple of frames after the key). */
+async function settle(t: Awaited<ReturnType<typeof shell>>): Promise<string> {
+  for (let i = 0; i < 6; i++) await t.flush()
+  return t.captureCharFrame()
+}
+
+// Pause moved off the un-encodable Shift+Esc onto Ctrl+P (everywhere) and Cmd/Super+Enter (kitty).
+// When idle there's nothing to pause, so both should surface the same "nothing to pause" toast —
+// proof the binding actually fired and routed to the pause command.
+test("Ctrl+P routes to pause", async () => {
+  const t = await shell()
+  t.mockInput.pressKey("p", { ctrl: true })
+  expect(await settle(t)).toContain("nothing to pause")
+  t.renderer.destroy()
+})
+
+test("Cmd/Super+Enter routes to pause (kitty protocol)", async () => {
+  const t = await shell({ kittyKeyboard: true })
+  t.mockInput.pressEnter({ super: true })
+  expect(await settle(t)).toContain("nothing to pause")
+  t.renderer.destroy()
+})
+
+// The side panel header no longer carries a title — just the close affordance with its shortcut,
+// right-aligned. (The "CONTEXT" further down is the legit context-window usage gauge, not a title.)
+test("context panel header shows the close shortcut, no title", async () => {
+  const t = await shell()
+  const frame = t.captureCharFrame()
+  expect(frame).toContain("ctrl+b ✕") // right-aligned close with its shortcut
+  expect(frame).toContain("📎 0 context") // permanent context-files chip
+  t.renderer.destroy()
+})

From 9de057c9061148063d630ecafb2345088aa5ea37 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:25:32 -0700
Subject: [PATCH 2/7] 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>
---
 CHANGELOG.md                                  |  31 ++++-
 docs/agents-and-teams.md                      |  22 ++-
 packages/core/src/engine.ts                   |  81 ++++++++++-
 packages/core/src/fleet.ts                    |  22 ++-
 packages/core/src/git.ts                      |  54 ++++++++
 packages/core/src/index.ts                    |   1 +
 packages/core/src/keybindings.ts              |   9 +-
 packages/core/src/prompt.ts                   |   8 +-
 packages/core/src/runner.ts                   |  88 +++++++++---
 packages/core/src/sessions.ts                 |  55 ++++++--
 packages/core/src/tmux.ts                     |  99 +++++++++++++
 packages/core/test/git.test.ts                |  32 ++++-
 packages/core/test/keybindings.test.ts        |   5 +-
 packages/core/test/plan.test.ts               |  13 +-
 packages/core/test/sessions.test.ts           |  50 +++++++
 packages/core/test/tmux.test.ts               |  43 ++++++
 packages/tui/src/components/AskCard.tsx       |   3 +
 .../tui/src/components/ContextFilesModal.tsx  | 130 ++++++++++--------
 packages/tui/src/components/Dashboard.tsx     |  52 ++++++-
 .../tui/src/components/PermissionCard.tsx     |   6 +-
 packages/tui/src/components/SettingsModal.tsx |  15 +-
 packages/tui/src/store.tsx                    | 130 +++++++++++++++---
 packages/tui/test/keymap-pause.test.tsx       |  16 ++-
 packages/tui/test/resolve-pending.test.ts     |  16 +++
 24 files changed, 828 insertions(+), 153 deletions(-)
 create mode 100644 packages/core/src/tmux.ts
 create mode 100644 packages/core/test/tmux.test.ts
 create mode 100644 packages/tui/test/resolve-pending.test.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71e970b..e6470ae 100644
--- a/CHANGELOG.md
+++ b/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
 
diff --git a/docs/agents-and-teams.md b/docs/agents-and-teams.md
index 91cb781..f80e608 100644
--- a/docs/agents-and-teams.md
+++ b/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
 
diff --git a/packages/core/src/engine.ts b/packages/core/src/engine.ts
index 5716dcb..7f4424e 100644
--- a/packages/core/src/engine.ts
+++ b/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
diff --git a/packages/core/src/fleet.ts b/packages/core/src/fleet.ts
index 0732329..3fc9ca6 100644
--- a/packages/core/src/fleet.ts
+++ b/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}` }
+}
diff --git a/packages/core/src/git.ts b/packages/core/src/git.ts
index c5b52cd..a1a188c 100644
--- a/packages/core/src/git.ts
+++ b/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"])
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index ced77ca..abd8366 100644
--- a/packages/core/src/index.ts
+++ b/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,
diff --git a/packages/core/src/keybindings.ts b/packages/core/src/keybindings.ts
index 3ea2cfd..618667c 100644
--- a/packages/core/src/keybindings.ts
+++ b/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",
diff --git a/packages/core/src/prompt.ts b/packages/core/src/prompt.ts
index 01e506b..774eb34 100644
--- a/packages/core/src/prompt.ts
+++ b/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."
diff --git a/packages/core/src/runner.ts b/packages/core/src/runner.ts
index 942f579..9fd8654 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -68,13 +68,23 @@ import { type CustomCommand, loadCommands } from "./commands.ts"
 import { COMPACTION, collapseToolOutputs, estimateTokens, renderTranscript, safeCutIndex } from "./compaction.ts"
 import { loadProjectContext, type ProjectContext } from "./context.ts"
 import { formatFile } from "./format.ts"
-import { gitCommitAll, gitDiff, gitIsTracked, gitShowHead, gitStatus, gitWorktreeAdd, gitWorktreeList } from "./git.ts"
+import {
+  gitCommitAll,
+  gitDiff,
+  gitIsTracked,
+  gitRevParse,
+  gitSessionChanges,
+  gitShowHead,
+  gitStatus,
+  gitWorktreeAdd,
+  gitWorktreeList,
+} from "./git.ts"
 import { type HookEvent, type HookPayload, type HooksConfig, runHooks } from "./hooks.ts"
 import { deleteMemory, listMemory, memoryDigest, saveMemory } from "./memory.ts"
 import { collectImages, expandMentions } from "./mentions.ts"
 import { customAgentPrompt, subagentPrompt, systemPrompt } from "./prompt.ts"
 import { bashRisk, matchesList } from "./safety.ts"
-import type { PlanRow, SessionStore } from "./sessions.ts"
+import type { PlanRow, SessionMeta, SessionStore } from "./sessions.ts"
 import { loadSkills, type Skill, type SkillInfo } from "./skills.ts"
 import type { StreamFn } from "./stream.ts"
 
@@ -356,6 +366,8 @@ export class SessionRunner {
   private context: ProjectContext
   /** Files the user pinned into context (relative paths). Read fresh each turn so edits are reflected. */
   private pinned: string[] = []
+  /** git commit captured at session start; the changes panel diffs the working tree against it. */
+  private sessionBaseRef?: string
   private skills: Skill[]
   private agents: AgentDef[]
   private lsp: LspManager
@@ -366,8 +378,6 @@ export class SessionRunner {
   busy = false
   /** id of the assistant message currently streaming — so we can always finalize it (even on abort/error). */
   private activeAssistantId?: string
-  /** set when the model explicitly presented a plan via exit_plan this turn — suppresses the fallback heuristic. */
-  private planEmitted = false
   /** set while a permission/ask card is awaiting the user for this session */
   needsInput = false
   private pending = new Map<string, Pending>()
@@ -429,6 +439,17 @@ export class SessionRunner {
     this.plans = host.store.loadPlans(row.id)
     this.checkpoints = deserializeCheckpoints(host.store.loadCheckpointsJson(row.id))
     this.pinned = host.store.loadPinned(row.id)
+    // Restore the rest of the session's "feel": compacted-history summary, the git base the changes
+    // panel diffs against, and an active worktree (so resuming lands back inside it). Applied BEFORE
+    // loadProjectContext so context/skills/agents load from the worktree roots when one is active.
+    const meta = host.store.loadMeta(row.id)
+    this.compaction = meta.compaction
+    this.sessionBaseRef = meta.baseRef
+    if (meta.worktree) {
+      this.preWorktree = meta.worktree.pre
+      this.cwd = meta.worktree.path
+      this.roots = [meta.worktree.path, ...this.roots.filter((r) => r !== meta.worktree!.path)]
+    }
     this.context = loadProjectContext(this.roots)
     this.skills = loadSkills(this.roots)
     this.agents = loadAgents(this.roots)
@@ -448,7 +469,22 @@ export class SessionRunner {
    * Files this session has modified, derived from its own checkpoint snapshots
    * (not git) — so the panel reflects exactly what THIS session touched.
    */
-  private emitSessionFiles(): void {
+  private async emitSessionFiles(): Promise<void> {
+    // Preferred path: in a git repo we diff the working tree against the base commit captured at
+    // session start — this captures EVERYTHING done this session (committed AND uncommitted AND
+    // removed), which the per-turn snapshot tracker can't (committed files revert to HEAD and vanish).
+    if (this.sessionBaseRef) {
+      try {
+        const changes = await gitSessionChanges(this.cwd, this.sessionBaseRef)
+        const items = changes
+          .map((f) => ({ path: f.path, status: f.status, added: f.added, removed: f.removed, kind: "file" as const }))
+          .sort((a, b) => a.path.localeCompare(b.path))
+        this.emit({ type: "session-files", items })
+        return
+      } catch {
+        /* git hiccup — fall back to the snapshot tracker below */
+      }
+    }
     const prior = new Map<string, string | null>() // path -> content before this session first touched it
     for (const cp of this.checkpoints) for (const [abs, before] of cp.files) if (!prior.has(abs)) prior.set(abs, before)
     const items: { path: string; status: string; added: number; removed: number; kind?: "file" | "dir" }[] = []
@@ -639,6 +675,10 @@ export class SessionRunner {
   private persistCheckpoints(): void {
     this.host.store.setCheckpointsJson(this.sessionId, serializeCheckpoints(this.checkpoints))
   }
+  /** Merge a slice of session meta to disk (compaction summary, git base, worktree) so resume restores it. */
+  private persistMeta(patch: Partial<SessionMeta>): void {
+    this.host.store.setMeta(this.sessionId, patch)
+  }
   /** Record a plan (title = first non-empty line), persist it, and surface the execute gate. */
   private recordPlan(plan: string): void {
     const title =
@@ -673,7 +713,7 @@ export class SessionRunner {
       })
     this.emit({ type: "todos", items: this.todos })
     this.emit({ type: "plans", items: this.plans })
-    this.emitSessionFiles()
+    void this.emitSessionFiles()
   }
 
   addRoot(dir: string): void {
@@ -701,6 +741,8 @@ export class SessionRunner {
     if (!this.preWorktree) this.preWorktree = { cwd: this.cwd, roots: [...this.roots] }
     this.cwd = res.path
     this.roots = [res.path, ...this.roots.filter((r) => r !== res.path)]
+    // Remember the worktree so a resume lands back inside it (with the dir to return to on exit).
+    this.persistMeta({ worktree: { path: res.path, pre: this.preWorktree } })
     this.context = loadProjectContext(this.roots)
     this.skills = loadSkills(this.roots)
     this.agents = loadAgents(this.roots)
@@ -719,6 +761,7 @@ export class SessionRunner {
     this.cwd = this.preWorktree.cwd
     this.roots = this.preWorktree.roots
     this.preWorktree = undefined
+    this.persistMeta({ worktree: undefined }) // no longer in a worktree — resume lands in the real dir
     this.context = loadProjectContext(this.roots)
     this.skills = loadSkills(this.roots)
     this.agents = loadAgents(this.roots)
@@ -918,6 +961,7 @@ export class SessionRunner {
       // Drop any compaction summary — its throughIndex points into the now-truncated history and
       // would otherwise make sendMessages() prepend a stale summary / slice the wrong range.
       this.compaction = undefined
+      this.persistMeta({ compaction: undefined })
     }
 
     if (scope !== "code") this.persistCheckpoints() // the checkpoint list was truncated
@@ -931,6 +975,8 @@ export class SessionRunner {
       roots: this.roots,
       messages: this.messages,
     })
+    // Files on disk changed (reverted) — refresh the changes panel; todos/plans were emitted above.
+    if (scope !== "conversation") void this.emitSessionFiles()
   }
 
   redoLast(): void {
@@ -939,6 +985,7 @@ export class SessionRunner {
     this.messages = [...this.redoState.messages]
     this.seq = this.messages.length
     this.compaction = undefined // rebuilt history — a stale summary index would corrupt context
+    this.persistMeta({ compaction: undefined })
     this.host.store.truncateMessages(this.sessionId, 0)
     this.messages.forEach((m, i) => {
       this.host.store.appendMessage(this.sessionId, i, m)
@@ -960,6 +1007,7 @@ export class SessionRunner {
       roots: this.roots,
       messages: this.messages,
     })
+    void this.emitSessionFiles() // files were re-applied — refresh the changes panel
   }
 
   // ---- the agentic loop ----
@@ -984,8 +1032,14 @@ export class SessionRunner {
     }
 
     this.busy = true
-    this.planEmitted = false
     this.abort = new AbortController()
+    // Capture the git base ONCE, before this session's first edit/commit, so the changes panel can
+    // diff the working tree against it (committed + uncommitted) for a full session footprint.
+    if (this.sessionBaseRef === undefined) {
+      const base = await gitRevParse(this.cwd)
+      this.sessionBaseRef = base ?? "" // "" = checked, not a repo → fall back to snapshot tracking
+      if (base) this.persistMeta({ baseRef: base })
+    }
     this.currentCheckpoint = {
       id: this.host.nextId(),
       label: text.replace(/\s+/g, " ").trim().slice(0, 60) || "turn",
@@ -1021,18 +1075,13 @@ export class SessionRunner {
         this.activeAssistantId = undefined
       }
       void this.hook("Stop")
-      this.emitSessionFiles()
+      void this.emitSessionFiles()
       // The turn's checkpoint now has all its file snapshots — persist so rewind survives a restart.
       this.persistCheckpoints()
-      // Fallback: if the model finished a plan-mode turn WITHOUT calling exit_plan, still surface
-      // something so the gate isn't lost — the plan is the last assistant message produced this turn.
-      // The deterministic path (exit_plan) is preferred; this only runs when it wasn't used.
-      if (!aborted && !this.planEmitted && this.host.selection().mode === "plan") {
-        const last = [...this.messages].reverse().find((m) => m.role === "assistant" && !!m.text)
-        if (last && last.role === "assistant" && last.text && last.text.trim().length > 12) {
-          this.recordPlan(last.text)
-        }
-      }
+      // NOTE: no "last message becomes the plan" fallback. A plan is ONLY what the model deliberately
+      // emits via exit_plan — otherwise a trivial answer (e.g. a file listing) would masquerade as a
+      // "PLAN READY" gate. In plan mode the model either asks clarifying questions, answers directly, or
+      // calls exit_plan with a real implementation plan (see modePostureNote in prompt.ts).
       this.emit({ type: "mascot", state: "idle" })
       this.emit({ type: "status", text: aborted ? "stopped" : "ready" })
     }
@@ -1158,6 +1207,7 @@ export class SessionRunner {
     // Snapshot the prior state so this compaction can be undone (history itself is untouched).
     this.preCompaction = { compaction: this.compaction }
     this.compaction = { summary, throughIndex: cut }
+    this.persistMeta({ compaction: this.compaction }) // survive resume — don't recompute/lose the summary
     const after = estimateTokens(this.sendMessages())
     this.emit({
       type: "compaction",
@@ -1187,6 +1237,7 @@ export class SessionRunner {
       return
     }
     this.compaction = this.preCompaction.compaction
+    this.persistMeta({ compaction: this.compaction })
     this.preCompaction = undefined
     this.emit({ type: "notice", text: "↺ compaction undone — full history restored" })
     this.emit({ type: "status", text: "ready" })
@@ -1429,7 +1480,6 @@ export class SessionRunner {
           // returning from loop() ends the agentic loop the instant the plan is ready.
           const a = safeParse(tc.arguments) as { plan?: string }
           const plan = (a.plan ?? "").trim()
-          this.planEmitted = true
           this.addMessage({
             role: "tool",
             callId: tc.id,
@@ -2078,7 +2128,7 @@ export class SessionRunner {
     this.emit({ type: "mascot", state: "idle" })
     if (res.ok) {
       this.emit({ type: "notice", text: `✓ committed ${res.info} — ${message}` })
-      this.emitSessionFiles()
+      void this.emitSessionFiles()
     } else {
       this.emit({ type: "error", message: `Commit failed: ${res.info}` })
     }
diff --git a/packages/core/src/sessions.ts b/packages/core/src/sessions.ts
index 22af7b4..f2d09c2 100644
--- a/packages/core/src/sessions.ts
+++ b/packages/core/src/sessions.ts
@@ -1,7 +1,27 @@
 import { Database } from "bun:sqlite"
 import fs from "node:fs"
 import { fridayDir, sessionsDb } from "@friday/providers"
-import type { Message, TodoItem } from "@friday/shared"
+import type { Effort, Message, ModeId, TodoItem } from "@friday/shared"
+
+/**
+ * Per-session state that makes a resume feel identical to where you left off — beyond messages/todos/
+ * plans/checkpoints. Stored as one JSON blob (merge-on-write) so adding a field needs no migration.
+ */
+export interface SessionMeta {
+  providerId?: string
+  model?: string
+  reasoning?: boolean
+  effort?: Effort
+  mode?: ModeId
+  contextWindow?: number
+  cost?: { input: number; output: number }
+  /** condensed-history summary so a long session doesn't lose/recompute its compacted context */
+  compaction?: { summary: string; throughIndex: number }
+  /** git commit captured at session start; the "changes" panel diffs the working tree against it */
+  baseRef?: string
+  /** active git worktree (restored on resume), with the dir/roots to return to on exit */
+  worktree?: { path: string; pre: { cwd: string; roots: string[] } }
+}
 
 export interface SessionRow {
   id: string
@@ -54,20 +74,22 @@ export class SessionStore {
       `CREATE TABLE IF NOT EXISTS session_state (
         session_id TEXT PRIMARY KEY, todos TEXT NOT NULL DEFAULT '[]',
         plans TEXT NOT NULL DEFAULT '[]', checkpoints TEXT NOT NULL DEFAULT '[]',
-        pinned_files TEXT NOT NULL DEFAULT '[]'
+        pinned_files TEXT NOT NULL DEFAULT '[]', meta TEXT NOT NULL DEFAULT '{}'
       );`,
     )
-    // Migrate older DBs that predate pinned_files. Duplicate-column errors are expected & ignored.
-    try {
-      this.db.exec("ALTER TABLE session_state ADD COLUMN pinned_files TEXT NOT NULL DEFAULT '[]'")
-    } catch {
-      /* column already exists */
+    // Migrate older DBs that predate these columns. Duplicate-column errors are expected & ignored.
+    for (const col of ["pinned_files TEXT NOT NULL DEFAULT '[]'", "meta TEXT NOT NULL DEFAULT '{}'"]) {
+      try {
+        this.db.exec(`ALTER TABLE session_state ADD COLUMN ${col}`)
+      } catch {
+        /* column already exists */
+      }
     }
   }
 
   private upsertState(
     sessionId: string,
-    column: "todos" | "plans" | "checkpoints" | "pinned_files",
+    column: "todos" | "plans" | "checkpoints" | "pinned_files" | "meta",
     json: string,
   ): void {
     this.db
@@ -84,6 +106,23 @@ export class SessionStore {
     return r?.v ?? "[]"
   }
 
+  /** Merge a partial SessionMeta into the stored blob (read-modify-write) so independent writers —
+   * the runner (compaction/baseRef/worktree) and the engine (model/mode/effort) — never clobber. */
+  setMeta(sessionId: string, patch: Partial<SessionMeta>): void {
+    const next = { ...this.loadMeta(sessionId), ...patch }
+    this.upsertState(sessionId, "meta", JSON.stringify(next))
+  }
+  loadMeta(sessionId: string): SessionMeta {
+    const r = this.db.query("SELECT meta AS v FROM session_state WHERE session_id = ?").get(sessionId) as
+      | { v: string }
+      | undefined
+    try {
+      return r?.v ? (JSON.parse(r.v) as SessionMeta) : {}
+    } catch {
+      return {}
+    }
+  }
+
   setTodos(sessionId: string, todos: TodoItem[]): void {
     this.upsertState(sessionId, "todos", JSON.stringify(todos))
   }
diff --git a/packages/core/src/tmux.ts b/packages/core/src/tmux.ts
new file mode 100644
index 0000000..c1afc9f
--- /dev/null
+++ b/packages/core/src/tmux.ts
@@ -0,0 +1,99 @@
+/**
+ * tmux-backed "control center": one persistent tmux session (default name `friday`) whose panes are
+ * the live terminals for sessions / team members / swarm agents. The dashboard drives it — add a pane
+ * (open a real terminal running friday), kill one, kill all, re-tile, and "open the wall" (attach in a
+ * real terminal so you watch every pane in one tiled view).
+ *
+ * Why tmux: OpenTUI can't embed PTYs, and OS windows can't be tiled/closed programmatically without
+ * automation permission. tmux gives real terminals you CAN arrange and close from code. When tmux
+ * isn't installed the caller falls back to the per-window backends in fleet.ts.
+ *
+ * ponytail: shell out to the tmux CLI (already the de-facto API); no library, no daemon of our own.
+ */
+import { fridayCommand } from "./fleet.ts"
+
+export const WALL = "friday" // the tmux session name we own
+
+export type TmuxLayout = "tiled" | "even-horizontal" | "even-vertical" | "main-vertical"
+export type TmuxPane = { id: string; title: string; active: boolean }
+
+async function tmux(args: string[]): Promise<{ ok: boolean; out: string; err: string }> {
+  try {
+    const p = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "pipe" })
+    const [out, err, code] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text(), p.exited])
+    return { ok: code === 0, out, err }
+  } catch (e) {
+    return { ok: false, out: "", err: e instanceof Error ? e.message : String(e) }
+  }
+}
+
+/** Is the tmux CLI available at all? (The control center degrades to fleet windows when not.) */
+export function tmuxAvailable(): boolean {
+  return !!Bun.which("tmux")
+}
+
+async function hasWall(): Promise<boolean> {
+  return (await tmux(["has-session", "-t", WALL])).ok
+}
+
+/** Add a friday pane to the wall and re-tile. Creates the wall (detached) on first use. `title` labels
+ * the pane; `watch` runs `friday attach <id>` (read-only) vs an interactive `friday -s <id>`. */
+export async function wallAdd(
+  args: string[],
+  cwd: string | undefined,
+  title: string,
+): Promise<{ ok: boolean; error?: string }> {
+  if (!tmuxAvailable()) return { ok: false, error: "tmux is not installed" }
+  const cmd = fridayCommand(args, cwd)
+  if (!(await hasWall())) {
+    // First pane: create the detached session running this command directly.
+    const r = await tmux(["new-session", "-d", "-s", WALL, "-n", "wall", cmd])
+    if (!r.ok) return { ok: false, error: r.err.trim() || "tmux new-session failed" }
+  } else {
+    const r = await tmux(["split-window", "-t", WALL, cmd])
+    if (!r.ok) return { ok: false, error: r.err.trim() || "tmux split-window failed" }
+  }
+  await tmux(["select-pane", "-T", title]) // name the just-created (active) pane
+  await tmux(["select-layout", "-t", WALL, "tiled"])
+  return { ok: true }
+}
+
+/** The wall's panes, or [] when there's no wall. */
+export async function wallPanes(): Promise<TmuxPane[]> {
+  if (!tmuxAvailable() || !(await hasWall())) return []
+  const r = await tmux(["list-panes", "-t", WALL, "-F", "#{pane_id}\t#{pane_title}\t#{pane_active}"])
+  if (!r.ok) return []
+  return r.out
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      const [id, title, active] = l.split("\t")
+      return { id: id!, title: title || id!, active: active === "1" }
+    })
+}
+
+/** Kill one pane and re-tile the rest. */
+export async function wallKill(paneId: string): Promise<{ ok: boolean; error?: string }> {
+  const r = await tmux(["kill-pane", "-t", paneId])
+  if (!r.ok) return { ok: false, error: r.err.trim() || "tmux kill-pane failed" }
+  await tmux(["select-layout", "-t", WALL, "tiled"]) // ignore error if the last pane closed the session
+  return { ok: true }
+}
+
+/** Tear the whole wall down. */
+export async function wallKillAll(): Promise<{ ok: boolean; error?: string }> {
+  if (!(await hasWall())) return { ok: true }
+  const r = await tmux(["kill-session", "-t", WALL])
+  return { ok: r.ok, error: r.ok ? undefined : r.err.trim() || "tmux kill-session failed" }
+}
+
+/** Re-arrange the wall into a named layout. */
+export async function wallLayout(layout: TmuxLayout): Promise<{ ok: boolean; error?: string }> {
+  const r = await tmux(["select-layout", "-t", WALL, layout])
+  return { ok: r.ok, error: r.ok ? undefined : r.err.trim() || "tmux select-layout failed" }
+}
+
+/** The shell command that attaches a terminal to the wall (run it in a real OS window to watch). */
+export function wallAttachCommand(): string {
+  return `tmux attach -t ${WALL}`
+}
diff --git a/packages/core/test/git.test.ts b/packages/core/test/git.test.ts
index 94c50b1..48673a6 100644
--- a/packages/core/test/git.test.ts
+++ b/packages/core/test/git.test.ts
@@ -2,7 +2,7 @@ import { expect, test } from "bun:test"
 import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
-import { gitCommitAll, gitDiff, gitStatus } from "../src/git.ts"
+import { gitCommitAll, gitDiff, gitRevParse, gitSessionChanges, gitStatus } from "../src/git.ts"
 
 async function sh(cwd: string, args: string[]): Promise<void> {
   await Bun.spawn(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" }).exited
@@ -38,3 +38,33 @@ test("git status / diff / commit round-trip on a fresh repo", async () => {
   fs.rmSync(dir, { recursive: true, force: true })
   fs.rmSync(tmp, { recursive: true, force: true })
 })
+
+test("gitSessionChanges reports committed + uncommitted + removed since a base", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "friday-gitsc-"))
+  await sh(dir, ["init"])
+  await sh(dir, ["config", "user.email", "t@t.t"])
+  await sh(dir, ["config", "user.name", "t"])
+  fs.writeFileSync(path.join(dir, "keep.txt"), "a\n")
+  fs.writeFileSync(path.join(dir, "gone.txt"), "x\n")
+  await sh(dir, ["add", "-A"])
+  await sh(dir, ["commit", "-m", "init"])
+
+  // Capture the base as the session would, at "session start".
+  const base = await gitRevParse(dir)
+  expect(base).toBeTruthy()
+
+  // Simulate a session: COMMIT a modification, leave an UNCOMMITTED new file, and DELETE a file.
+  fs.appendFileSync(path.join(dir, "keep.txt"), "b\n")
+  await sh(dir, ["commit", "-am", "edit keep"]) // committed change — the snapshot tracker would lose this
+  fs.writeFileSync(path.join(dir, "new.txt"), "fresh\n") // uncommitted untracked
+  fs.rmSync(path.join(dir, "gone.txt")) // removal
+  await sh(dir, ["add", "-A"]) // stage the deletion so the diff sees it
+
+  const changes = await gitSessionChanges(dir, base!)
+  const byPath = Object.fromEntries(changes.map((c) => [c.path, c.status]))
+  expect(byPath["keep.txt"]).toBe("M") // committed edit still shows
+  expect(byPath["new.txt"]).toBe("A") // uncommitted new file shows
+  expect(byPath["gone.txt"]).toBe("D") // removal shows
+
+  fs.rmSync(dir, { recursive: true, force: true })
+})
diff --git a/packages/core/test/keybindings.test.ts b/packages/core/test/keybindings.test.ts
index 10a78db..d0b689e 100644
--- a/packages/core/test/keybindings.test.ts
+++ b/packages/core/test/keybindings.test.ts
@@ -24,8 +24,9 @@ test("normalizeChord canonicalizes mod order + aliases", () => {
 test("actionForKey matches the default chords exactly", () => {
   const map = { ...DEFAULT_KEYBINDINGS }
   expect(actionForKey({ name: "b", ctrl: true }, map)).toBe("panel.toggle")
-  // pause moved off shift+escape (terminals can't encode it) onto ctrl+p, which transmits everywhere
-  expect(actionForKey({ name: "p", ctrl: true }, map)).toBe("pause.open")
+  // pause moved off shift+escape (terminals can't encode it) onto ctrl+space, which transmits
+  // everywhere (NUL byte) and is single-handed
+  expect(actionForKey({ name: "space", ctrl: true }, map)).toBe("pause.open")
   // a plain Esc must NOT resolve to any chord — keeps Esc-Esc stop / checkpoint working
   expect(actionForKey({ name: "escape" }, map)).toBeUndefined()
   expect(actionForKey({ name: "tab", shift: true }, map)).toBe("mode.cycle")
diff --git a/packages/core/test/plan.test.ts b/packages/core/test/plan.test.ts
index 4a34e5c..1d33224 100644
--- a/packages/core/test/plan.test.ts
+++ b/packages/core/test/plan.test.ts
@@ -16,14 +16,14 @@ function makeStreamFn(scripts: ProviderEvent[][]): StreamFn {
   }
 }
 
-test("plan mode: a completed turn emits plan-ready with the plan text", async () => {
+test("plan mode: plain prose does NOT fabricate a plan-ready (only exit_plan does)", async () => {
+  // Regression: a trivial answer (e.g. a file listing) must not masquerade as a "PLAN READY" gate.
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "friday-test-"))
-  const plan = "# Plan\n\n1. Read the schema\n2. Write the migration\n3. Run the tests"
   const engine = new Engine({
     cwd: dir,
     streamFn: makeStreamFn([
       [
-        { type: "text", delta: plan },
+        { type: "text", delta: "Files in this folder: a.txt, b.txt, README.md" },
         { type: "done", stopReason: "stop" },
       ],
     ]),
@@ -33,12 +33,11 @@ test("plan mode: a completed turn emits plan-ready with the plan text", async ()
 
   const events: EngineEvent[] = []
   engine.subscribe((e) => events.push(e))
-  engine.send({ type: "prompt", text: "how should we do this?" })
+  engine.send({ type: "prompt", text: "list everything in the folder" })
   await Bun.sleep(40)
 
-  const planReady = events.find((e) => e.type === "plan-ready") as Extract<EngineEvent, { type: "plan-ready" }>
-  expect(planReady).toBeTruthy()
-  expect(planReady.plan).toContain("Write the migration")
+  // No exit_plan was called → no plan gate; the prose just stands as a normal answer.
+  expect(events.some((e) => e.type === "plan-ready")).toBe(false)
   fs.rmSync(dir, { recursive: true, force: true })
 })
 
diff --git a/packages/core/test/sessions.test.ts b/packages/core/test/sessions.test.ts
index 12df6bf..d595e56 100644
--- a/packages/core/test/sessions.test.ts
+++ b/packages/core/test/sessions.test.ts
@@ -45,6 +45,56 @@ test("Engine resumes a persisted session", async () => {
   expect(loaded.messages.some((m) => m.role === "user" && m.text === "remember this")).toBe(true)
 })
 
+test("Engine restores a session's own model/mode/effort on resume (per-session, not global default)", async () => {
+  const store = new SessionStore(path.join(tmp, "meta.db"))
+  // Session 1: pick model-A, yolo, high — and run a prompt so the session + its meta persist.
+  const e1 = new Engine({ cwd: "/x", streamFn: textOnly, store })
+  e1.selectModel("mock", "model-A", true, 4242)
+  e1.send({ type: "set-mode", mode: "yolo" })
+  e1.send({ type: "set-effort", effort: "high" })
+  e1.send({ type: "prompt", text: "do a thing" })
+  await Bun.sleep(20)
+  const id = e1.currentSessionId()
+  // The selection was written to THIS session's meta (not just global config).
+  expect(store.loadMeta(id).model).toBe("model-A")
+  expect(store.loadMeta(id).mode).toBe("yolo")
+  expect(store.loadMeta(id).effort).toBe("high")
+
+  // Shift the GLOBAL default to model-B via a separate session, so a correct resume can only get
+  // model-A/yolo/high back from session 1's own meta.
+  const e2 = new Engine({ cwd: "/y", streamFn: textOnly, store })
+  e2.selectModel("mock", "model-B")
+  e2.send({ type: "set-mode", mode: "plan" })
+
+  // Resume session 1 — its own selection must come back, overriding the new global default.
+  const e3 = new Engine({ cwd: "/x", streamFn: textOnly, store, resumeId: id })
+  const sel = e3.selection()
+  expect(sel.model).toBe("model-A")
+  expect(sel.mode).toBe("yolo")
+  expect(sel.effort).toBe("high")
+  expect(sel.reasoning).toBe(true)
+  expect(sel.contextWindow).toBe(4242)
+})
+
+test("pinned context files persist and restore on resume", async () => {
+  const store = new SessionStore(path.join(tmp, "pins.db"))
+  const e1 = new Engine({ cwd: "/x", streamFn: textOnly, store })
+  e1.send({ type: "prompt", text: "start" })
+  await Bun.sleep(20)
+  const id = e1.currentSessionId()
+
+  e1.pinContextFile("README.md")
+  expect(e1.contextInfo().pinned).toContain("README.md")
+  expect(store.loadPinned(id)).toContain("README.md") // persisted, not just in memory
+
+  e1.unpinContextFile("README.md")
+  expect(e1.contextInfo().pinned).not.toContain("README.md")
+  e1.pinContextFile("docs/spec.md")
+
+  const e2 = new Engine({ cwd: "/x", streamFn: textOnly, store, resumeId: id })
+  expect(e2.contextInfo().pinned).toEqual(["docs/spec.md"]) // restored exactly on resume
+})
+
 test("title is derived cleanly from the first prompt (mentions stripped)", async () => {
   const store = new SessionStore(path.join(tmp, "title.db"))
   const e = new Engine({ cwd: "/z", streamFn: textOnly, store })
diff --git a/packages/core/test/tmux.test.ts b/packages/core/test/tmux.test.ts
new file mode 100644
index 0000000..feadcb6
--- /dev/null
+++ b/packages/core/test/tmux.test.ts
@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test"
+import { tmuxAvailable, WALL, wallAttachCommand } from "../src/tmux.ts"
+
+async function tmux(args: string[]): Promise<{ ok: boolean; out: string }> {
+  const p = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "ignore" })
+  const out = await new Response(p.stdout).text()
+  return { ok: (await p.exited) === 0, out }
+}
+
+test("wallAttachCommand targets our session", () => {
+  expect(wallAttachCommand()).toBe(`tmux attach -t ${WALL}`)
+})
+
+// Validate the exact tmux subcommands/flags the control center relies on, against a throwaway session
+// (never the real `friday` wall, never launching friday). Skips cleanly where tmux isn't installed.
+test.skipIf(!tmuxAvailable())("tmux new/split/list/layout/kill flags work on this tmux", async () => {
+  const sess = `friday-test-${process.pid}`
+  try {
+    // new-session -d with an inline command (a harmless long-lived shell).
+    expect((await tmux(["new-session", "-d", "-s", sess, "-n", "wall", "sleep 30"])).ok).toBe(true)
+    await tmux(["select-pane", "-T", "p1"])
+    // split-window adds a second pane.
+    expect((await tmux(["split-window", "-t", sess, "sleep 30"])).ok).toBe(true)
+    await tmux(["select-pane", "-T", "p2"])
+    expect((await tmux(["select-layout", "-t", sess, "tiled"])).ok).toBe(true)
+
+    // list-panes with our exact format string parses to two panes.
+    const lp = await tmux(["list-panes", "-t", sess, "-F", "#{pane_id}\t#{pane_title}\t#{pane_active}"])
+    const panes = lp.out
+      .split("\n")
+      .filter((l) => l.trim())
+      .map((l) => l.split("\t"))
+    expect(panes.length).toBe(2)
+    expect(panes[0]![0]).toMatch(/^%\d+$/) // pane id like %0
+
+    // kill one pane → one left.
+    expect((await tmux(["kill-pane", "-t", panes[0]![0]!])).ok).toBe(true)
+    const after = await tmux(["list-panes", "-t", sess, "-F", "#{pane_id}"])
+    expect(after.out.split("\n").filter((l) => l.trim()).length).toBe(1)
+  } finally {
+    await tmux(["kill-session", "-t", sess])
+  }
+})
diff --git a/packages/tui/src/components/AskCard.tsx b/packages/tui/src/components/AskCard.tsx
index e3082e8..f422f5e 100644
--- a/packages/tui/src/components/AskCard.tsx
+++ b/packages/tui/src/components/AskCard.tsx
@@ -327,6 +327,9 @@ export function AskCard() {
               <text fg={shimmerAccent(theme.brand)}>
                 <strong>? QUESTION</strong>
               </text>
+              <Show when={app.askFrom()}>
+                <text fg={theme.textMuted}>· {app.askFrom()}</text>
+              </Show>
               <Show when={a().questions.length > 1 && !review()}>
                 <text fg={theme.textFaint}>
                   · {qIdx() + 1} of {a().questions.length}
diff --git a/packages/tui/src/components/ContextFilesModal.tsx b/packages/tui/src/components/ContextFilesModal.tsx
index 0e454b1..5112417 100644
--- a/packages/tui/src/components/ContextFilesModal.tsx
+++ b/packages/tui/src/components/ContextFilesModal.tsx
@@ -4,13 +4,14 @@ import { createEffect, createSignal, For, Show } from "solid-js"
 import { useApp } from "../store.tsx"
 import { listProjectFiles } from "../util/files.ts"
 import { Scrim } from "./Scrim.tsx"
-import { bandBg, HintChip, Meta, Overlay } from "./ui.tsx"
+import { bandBg, Field, HintChip, Overlay, SectionLabel } from "./ui.tsx"
 
 /**
  * View and manage the files in this session's context. Two kinds:
  *   - AUTO: FRIDAY.md / AGENTS.md discovered up the tree (read-only — edit the files to change them).
  *   - PINNED: files you pin here; their contents are injected into context every turn and persist for
- *     the session. Type to filter the project, ⏎ to pin; on a pinned row ⏎ (or click ✕) unpins.
+ *     the session. Type in the input to filter the project, ⏎ to pin the highlighted file; click a
+ *     pinned row's ✕ (or highlight it and press ⌫) to unpin.
  */
 export function ContextFilesModal() {
   const app = useApp()
@@ -40,6 +41,12 @@ export function ContextFilesModal() {
     queueMicrotask(() => sb?.scrollChildIntoView?.(`ctxfile-${i}`))
   })
 
+  const pin = (f: string) => {
+    app.pinContextFile(f)
+    setQuery("")
+    setSel(0)
+  }
+
   useKeyboard((key) => {
     if (!app.contextModalOpen()) return
     if (key.name === "escape") {
@@ -51,14 +58,14 @@ export function ContextFilesModal() {
     if (key.name === "down") return setSel((s) => (m.length ? (s + 1) % m.length : 0))
     if (key.name === "return" || key.name === "enter") {
       const pick = m[clamped()]
-      if (pick) {
-        app.pinContextFile(pick)
-        setQuery("")
-        setSel(0)
-      }
+      if (pick) pin(pick)
       return
     }
-    if (key.name === "backspace") return setQuery((q) => q.slice(0, -1))
+    if (key.name === "backspace") {
+      // Backspace on an empty query unpins the last-pinned file; otherwise edit the filter.
+      if (!query() && pinned().length) return app.unpinContextFile(pinned()[pinned().length - 1]!)
+      return setQuery((q) => q.slice(0, -1))
+    }
     // Printable char → extend the filter.
     if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta && key.sequence >= " ") {
       setSel(0)
@@ -66,30 +73,54 @@ export function ContextFilesModal() {
     }
   })
 
+  const w = () => Math.min(76, dims().width - 4)
+
   return (
     <Scrim onClose={() => app.setContextModalOpen(false)}>
-      <Overlay title="context files" hint="what Friday is reading this session" width={Math.min(72, dims().width - 4)}>
-        {/* AUTO context (read-only) */}
-        <Show when={app.contextFiles().length}>
-          <box flexDirection="column">
-            <Meta text="auto · FRIDAY.md / AGENTS.md (edit the files to change)" />
-            <For each={app.contextFiles()}>
-              {(f) => (
-                <box flexDirection="row" gap={1} paddingLeft={1}>
-                  <text fg={theme.textFaint}>📄</text>
-                  <text fg={theme.textMuted}>{f}</text>
-                </box>
-              )}
-            </For>
+      <Overlay title="context files" hint="what Friday reads this session" width={w()}>
+        {/* The input area — a real bordered field so it's obvious you type here to add a file. */}
+        <Field label="add file" hint="type to filter · ⏎ pin" focused>
+          <box flexDirection="row">
+            <text fg={theme.text}>{query()}</text>
+            <text fg={theme.brand}>▏</text>
+            <Show when={!query()}>
+              <text fg={theme.textFaint}>search project files…</text>
+            </Show>
           </box>
+        </Field>
+
+        {/* Live results while filtering. */}
+        <Show when={query()}>
+          <scrollbox ref={(r: any) => (sb = r)} maxHeight={8}>
+            <For each={matches()} fallback={<text fg={theme.textFaint}> no match</text>}>
+              {(f, i) => {
+                const on = () => clamped() === i()
+                return (
+                  <box
+                    id={`ctxfile-${i()}`}
+                    flexDirection="row"
+                    gap={1}
+                    paddingLeft={1}
+                    paddingRight={1}
+                    backgroundColor={bandBg(on())}
+                    onMouseOver={() => setSel(i())}
+                    onMouseDown={() => pin(f)}
+                  >
+                    <text fg={on() ? theme.textOnAccent : theme.textFaint}>＋</text>
+                    <text fg={on() ? theme.textOnAccent : theme.text}>{f}</text>
+                  </box>
+                )
+              }}
+            </For>
+          </scrollbox>
         </Show>
 
-        {/* PINNED files — each removable */}
+        {/* Pinned files — each removable. */}
         <box flexDirection="column">
-          <Meta text={`pinned · ${pinned().length} (persist for this session)`} />
+          <SectionLabel text={`pinned (${pinned().length})`} />
           <Show
             when={pinned().length}
-            fallback={<text fg={theme.textFaint}> none yet — type below to pin a file</text>}
+            fallback={<text fg={theme.textFaint}> none yet — search above and press ⏎ to pin</text>}
           >
             <For each={pinned()}>
               {(f) => (
@@ -104,46 +135,25 @@ export function ContextFilesModal() {
           </Show>
         </box>
 
-        {/* ADD: filter + results */}
-        <box flexDirection="column">
-          <box flexDirection="row" gap={1}>
-            <text fg={theme.textFaint}>+ add file</text>
-            <text fg={theme.text}>{query() || "…"}</text>
+        {/* Auto-loaded context (read-only). */}
+        <Show when={app.contextFiles().length}>
+          <box flexDirection="column">
+            <SectionLabel text="auto · edit the files to change" />
+            <For each={app.contextFiles()}>
+              {(f) => (
+                <box flexDirection="row" gap={1} paddingLeft={1}>
+                  <text fg={theme.textFaint}>📄</text>
+                  <text fg={theme.textMuted}>{f}</text>
+                </box>
+              )}
+            </For>
           </box>
-          <Show when={query()}>
-            <scrollbox ref={(r: any) => (sb = r)} maxHeight={10}>
-              <For each={matches()}>
-                {(f, i) => {
-                  const on = () => clamped() === i()
-                  return (
-                    <box
-                      id={`ctxfile-${i()}`}
-                      flexDirection="row"
-                      gap={1}
-                      paddingLeft={1}
-                      paddingRight={1}
-                      backgroundColor={bandBg(on())}
-                      onMouseOver={() => setSel(i())}
-                      onMouseDown={() => {
-                        app.pinContextFile(f)
-                        setQuery("")
-                        setSel(0)
-                      }}
-                    >
-                      <text fg={on() ? theme.textOnAccent : theme.textFaint}>📎</text>
-                      <text fg={on() ? theme.textOnAccent : theme.text}>{f}</text>
-                    </box>
-                  )
-                }}
-              </For>
-            </scrollbox>
-          </Show>
-        </box>
+        </Show>
 
         <box flexDirection="row" gap={1}>
-          <HintChip label="type to filter" />
+          <HintChip label="↑↓ move" />
           <HintChip label="⏎ pin" accent={theme.success} />
-          <HintChip label="✕ click to unpin" />
+          <HintChip label="⌫ unpin last" />
           <HintChip label="esc close" onClick={() => app.setContextModalOpen(false)} />
         </box>
       </Overlay>
diff --git a/packages/tui/src/components/Dashboard.tsx b/packages/tui/src/components/Dashboard.tsx
index b20678c..9c556ff 100644
--- a/packages/tui/src/components/Dashboard.tsx
+++ b/packages/tui/src/components/Dashboard.tsx
@@ -1,3 +1,4 @@
+import type { TmuxLayout } from "@friday/core"
 import { theme } from "@friday/shared"
 import { useKeyboard } from "@opentui/solid"
 import { createMemo, createSignal, For, type JSX, Match, onCleanup, onMount, Show, Switch } from "solid-js"
@@ -84,10 +85,21 @@ export function Dashboard() {
   // Live updates: in-process teams/tasks already stream via the bus; poll for sessions/history so
   // externally-opened windows (separate friday processes) show up promptly.
   onMount(() => {
-    const iv = setInterval(() => app.refreshSessions(), 1500)
+    app.refreshWall()
+    const iv = setInterval(() => {
+      app.refreshSessions()
+      app.refreshWall()
+    }, 1500)
     onCleanup(() => clearInterval(iv))
   })
 
+  const LAYOUTS: { key: TmuxLayout; label: string }[] = [
+    { key: "tiled", label: "tiled" },
+    { key: "even-horizontal", label: "cols" },
+    { key: "even-vertical", label: "rows" },
+    { key: "main-vertical", label: "main" },
+  ]
+
   function switchTab(n: number) {
     setTab((n + TABS.length) % TABS.length)
     setSel(0)
@@ -154,6 +166,44 @@ export function Dashboard() {
         <text fg={theme.textFaint}>esc back</text>
       </box>
 
+      {/* tmux WALL control center — real, tile-able terminals. Launching anything from the tabs below
+          adds a pane here; arrange / open / close the whole wall from this bar. Hidden without tmux. */}
+      <Show when={app.tmuxOn()}>
+        <box
+          flexDirection="column"
+          backgroundColor={theme.bgElevated}
+          paddingLeft={1}
+          paddingRight={1}
+          marginBottom={1}
+        >
+          <box flexDirection="row" gap={1} alignItems="center">
+            <text fg={accent()}>
+              <strong>▦ wall</strong>
+            </text>
+            <text fg={theme.textFaint}>{app.wallPanes().length} pane(s)</text>
+            <box flexGrow={1} />
+            <For each={LAYOUTS}>{(l) => <Pill label={l.label} onClick={() => app.arrangeWall(l.key)} />}</For>
+            <Pill label="⊞ open" accent={theme.success} onClick={() => app.viewWall()} />
+            <Show when={app.wallPanes().length}>
+              <Pill label="✕ close all" accent={theme.error} onClick={() => app.closeWall()} />
+            </Show>
+          </box>
+          {/* Per-pane list with individual close. */}
+          <Show when={app.wallPanes().length}>
+            <box flexDirection="row" gap={2} paddingTop={0}>
+              <For each={app.wallPanes()}>
+                {(p) => (
+                  <box flexDirection="row" gap={1} onMouseDown={() => app.removeWallPane(p.id)}>
+                    <text fg={p.active ? theme.brand : theme.textMuted}>{p.title}</text>
+                    <text fg={theme.error}>✕</text>
+                  </box>
+                )}
+              </For>
+            </box>
+          </Show>
+        </box>
+      </Show>
+
       <Switch>
         {/* SESSIONS */}
         <Match when={tab() === 0}>
diff --git a/packages/tui/src/components/PermissionCard.tsx b/packages/tui/src/components/PermissionCard.tsx
index fac187b..f8d7710 100644
--- a/packages/tui/src/components/PermissionCard.tsx
+++ b/packages/tui/src/components/PermissionCard.tsx
@@ -48,11 +48,15 @@ export function PermissionCard() {
       {(p: () => PendingPermission) => (
         <Scrim onClose={() => {}}>
           <Overlay width={64}>
-            {/* Semantic warning header — not brand amber, so no Overlay title. */}
+            {/* Semantic warning header — not brand amber, so no Overlay title. When the request comes
+                from a delegated background agent, name it so the user knows who's asking. */}
             <box flexDirection="row" gap={1}>
               <text fg={shimmerAccent(theme.warning)}>
                 <strong>{G.warn} PERMISSION</strong>
               </text>
+              <Show when={app.pendingFrom()}>
+                <text fg={theme.textMuted}>· {app.pendingFrom()}</text>
+              </Show>
               <box flexGrow={1} />
               <text fg={theme.textFaint}>{p().tool}</text>
             </box>
diff --git a/packages/tui/src/components/SettingsModal.tsx b/packages/tui/src/components/SettingsModal.tsx
index 36dc907..bf5ceb5 100644
--- a/packages/tui/src/components/SettingsModal.tsx
+++ b/packages/tui/src/components/SettingsModal.tsx
@@ -4,7 +4,7 @@ import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
 import { createMemo, createSignal, For, Show } from "solid-js"
 import { useApp } from "../store.tsx"
 import { Scrim } from "./Scrim.tsx"
-import { Overlay, Row, SectionLabel } from "./ui.tsx"
+import { Overlay, Row, Tabs } from "./ui.tsx"
 
 const TABS: { key: string; label: string }[] = [
   { key: "general", label: "General" },
@@ -163,16 +163,11 @@ export function SettingsModal() {
         hint="↑↓ move · ⏎ change · ←→ section · esc close"
         width={Math.min(76, dims().width - 4)}
       >
-        <box flexDirection="row" gap={1}>
-          {/* Left tab rail — opencode-style vertical sections. */}
-          <box flexDirection="column" width={16} flexShrink={0}>
-            <For each={TABS}>
-              {(t) => <Row label={t.label} selected={tab() === t.key} onSelect={() => switchTab(t.key)} />}
-            </For>
-          </box>
-          {/* Active section's rows. */}
+        <box flexDirection="column" gap={1}>
+          {/* Horizontal tab bar — same Tabs primitive the dashboard uses, for a consistent feel. */}
+          <Tabs items={TABS} active={tab()} onSelect={switchTab} />
+          {/* Active tab's rows, full width. */}
           <box flexDirection="column" flexGrow={1} gap={0}>
-            <SectionLabel text={TABS.find((t) => t.key === tab())!.label} />
             <For each={rows()}>
               {(r, i) => (
                 <Row
diff --git a/packages/tui/src/store.tsx b/packages/tui/src/store.tsx
index 5e81273..24a5172 100644
--- a/packages/tui/src/store.tsx
+++ b/packages/tui/src/store.tsx
@@ -13,6 +13,8 @@ import {
   runUpdate,
   type SessionStats,
   saveKeybindings,
+  type TmuxLayout,
+  type TmuxPane,
 } from "@friday/core"
 import {
   type AskQuestion,
@@ -79,6 +81,18 @@ export type ViewItem =
    * "attached" (now part of the agent's context). `at` is when sent; `attachedAt` when it landed. */
   | { kind: "inject"; id: string; text: string; state: "pending" | "attached"; at: number; attachedAt?: number }
 
+/**
+ * Resolve which session's pending HITL prompt (permission/ask) to surface: the focused session's own
+ * if it has one, otherwise the oldest background session that's waiting — so a delegated agent's
+ * question reaches the user in the main view. Returns the session id (for clearing + labeling) and the
+ * value (carries the requestId the reply routes back by). Pure so it's unit-testable.
+ */
+export function resolvePending<T>(map: Record<string, T>, active: string): { sid: string; val: T } | null {
+  if (map[active]) return { sid: active, val: map[active]! }
+  for (const sid of Object.keys(map)) if (map[sid]) return { sid, val: map[sid]! }
+  return null
+}
+
 export type PendingPermission = { requestId: string; tool: string; summary: string; detail?: string; risk?: string }
 export type PendingAsk = { requestId: string; questions: AskQuestion[] }
 export type PlanEntry = { id: string; title: string; text: string }
@@ -395,8 +409,23 @@ export function createAppStore(engine: Engine, version = "dev") {
   const busy = () => !!sessionBusy()[activeSession()]
   const tokens = () => sessionTokens()[activeSession()] ?? 0
   const todos = createMemo(() => sessionTodos()[activeSession()] ?? EMPTY)
-  const pending = () => sessionPending()[activeSession()] ?? null
-  const askPending = () => sessionAsk()[activeSession()] ?? null
+  // HITL prompts (permission / ask) surface in the MAIN view even when they come from a delegated
+  // background agent: prefer the focused session's own pending, else the oldest background one that's
+  // waiting. The reply routes back by requestId (engine matches across all runners), so answering from
+  // here bridges to the right agent. `*From` returns the asking agent's label when it isn't the focused
+  // session, so the card can show "agent X asks".
+  const pendingSrc = () => resolvePending(sessionPending(), activeSession())
+  const askSrc = () => resolvePending(sessionAsk(), activeSession())
+  const pending = () => pendingSrc()?.val ?? null
+  const askPending = () => askSrc()?.val ?? null
+  const pendingFrom = () => {
+    const s = pendingSrc()
+    return s && s.sid !== activeSession() ? titleOf(s.sid) : null
+  }
+  const askFrom = () => {
+    const s = askSrc()
+    return s && s.sid !== activeSession() ? titleOf(s.sid) : null
+  }
   const plans = createMemo(() => sessionPlans()[activeSession()] ?? EMPTY)
   const planPending = () => sessionPlanPending()[activeSession()] ?? null
   const diagnostics = createMemo(() => sessionDiag()[activeSession()] ?? EMPTY)
@@ -800,15 +829,24 @@ export function createAppStore(engine: Engine, version = "dev") {
         }
         refreshSessions()
         break
-      case "session-loaded":
+      case "session-loaded": {
         // The focus signal: this session is now on screen.
         setActiveSession(sid)
         seedSession(sid, e.messages)
         setKey(setSessionSeenLen, sid, sessionItems[sid]?.length ?? 0)
         setCurrentCwd(e.cwd)
         setRoots(e.roots)
+        // Re-sync the per-session selection the engine just restored (mode/effort/model), so switching
+        // to or resuming a session shows what IT was using, not the previous session's settings.
+        const sel = engine.selection()
+        setModeSig(sel.mode ?? DEFAULT_MODE)
+        setEffortSig(sel.effort ?? "medium")
+        if (sel.model) setModel(sel.model)
+        setReasoningModel(sel.reasoning ?? false)
+        setProviderId(sel.providerId)
         refreshSessions()
         break
+      }
     }
   })
 
@@ -927,22 +965,59 @@ export function createAppStore(engine: Engine, version = "dev") {
       setMicModalOpen(true)
     }
   }
-  // ---- dashboard launchers (open work in its own window; the dashboard stays the console) ----
+  // ---- dashboard launchers + the tmux "wall" (real, tile-able terminals managed from the dashboard) ----
   /** A window-launch failure message that names the real reason (truncated) instead of a generic line. */
   const winFail = (r: { backend: string; error?: string }, what: string) =>
     r.error ? `couldn't open ${what} (${r.backend}): ${r.error.slice(0, 120)}` : `no terminal backend to open ${what}`
 
-  /** Open a brand-new interactive friday window (new chat) in the current directory. */
+  // The wall: a tmux session of tiled panes. When tmux is available the dashboard launches work INTO
+  // the wall (real terminals you can tile + close from here); otherwise it falls back to OS windows.
+  const tmuxOn = () => engine.tmuxOn()
+  const [wallPanes, setWallPanes] = createSignal<TmuxPane[]>([])
+  const refreshWall = () => {
+    if (tmuxOn()) void engine.wallList().then(setWallPanes)
+  }
+  /** Add a friday pane to the wall (args = [] new chat · ["-s",id] resume · ["attach",id] watch). */
+  function addToWall(args: string[], title: string, cwd?: string) {
+    void engine.wallOpen(args, title, cwd).then((r) => {
+      pushToast(r.ok ? `added "${title}" to the wall` : `wall: ${r.error ?? "failed"}`, r.ok ? "done" : "error")
+      refreshWall()
+    })
+  }
+  function removeWallPane(paneId: string) {
+    void engine.wallRemove(paneId).then(() => refreshWall())
+  }
+  function closeWall() {
+    void engine.wallRemoveAll().then(() => {
+      setWallPanes([])
+      pushToast("closed the wall", "input")
+    })
+  }
+  function arrangeWall(layout: TmuxLayout) {
+    void engine
+      .wallArrange(layout)
+      .then((r) => pushToast(r.ok ? `wall: ${layout}` : `wall: ${r.error ?? "failed"}`, "input"))
+  }
+  /** Open a real OS terminal attached to the wall so you watch every pane tiled. */
+  function viewWall() {
+    const r = engine.wallView()
+    pushToast(r.ok ? `opened the wall (${r.backend})` : winFail(r, "the wall"), r.ok ? "done" : "error")
+  }
+
+  /** Open a brand-new chat — into the wall when tmux is available, else its own OS window. */
   function newChatWindow() {
+    if (tmuxOn()) return addToWall([], "new chat")
     const r = engine.openInteractive([])
     pushToast(r.ok ? `opened new chat (${r.backend})` : winFail(r, "a window"), r.ok ? "done" : "error")
   }
-  /** Resume an existing session in its own interactive window. */
+  /** Resume an existing session, in its own folder. Into the wall when tmux is available. */
   function resumeInWindow(id: string) {
-    const r = engine.openInteractive(["-s", id])
+    const row = allSessions().find((s) => s.id === id) ?? sessions().find((s) => s.id === id)
+    if (tmuxOn()) return addToWall(["-s", id], row?.title ?? "session", row?.cwd)
+    const r = engine.openInteractive(["-s", id], row?.cwd)
     pushToast(r.ok ? `opened session (${r.backend})` : winFail(r, "the session"), r.ok ? "done" : "error")
   }
-  /** Fan out a swarm of independent agents (one task per line) + open watch windows for each. */
+  /** Fan out a swarm of independent agents (one task per line) + a watch pane/window for each. */
   function launchSwarm(tasks: string[]) {
     const jobs = tasks
       .map((t) => t.trim())
@@ -950,7 +1025,11 @@ export function createAppStore(engine: Engine, version = "dev") {
       .map((t) => ({ description: t.slice(0, 40), prompt: t }))
     if (!jobs.length) return
     const ids = engine.spawnAgents(jobs)
-    for (const id of ids) engine.popoutAgent(id) // read-only watch window per agent
+    for (const id of ids) {
+      if (tmuxOn()) void engine.wallOpen(["attach", id], "swarm")
+      else engine.popoutAgent(id) // read-only watch window per agent
+    }
+    refreshWall()
     pushToast(`spawned ${ids.length} swarm agent(s)`, "done")
   }
   /** Ask Friday to form a coordinated team for a goal (it decides the roles via spawn_team). */
@@ -1360,22 +1439,24 @@ export function createAppStore(engine: Engine, version = "dev") {
   }
 
   function replyPermission(decision: "allow-once" | "allow-always" | "deny") {
-    const p = pending()
-    if (!p) return
-    engine.send({ type: "permission-reply", requestId: p.requestId, decision })
+    const src = pendingSrc()
+    if (!src) return
+    engine.send({ type: "permission-reply", requestId: src.val.requestId, decision })
     if (decision === "allow-always") pushToast("✓ remembered for this project (/permissions to manage)", "done")
-    delKey(setSessionPending, activeSession())
-    delKey(setSessionNeeds, activeSession())
+    // Clear the asking session's entry (may be a background agent, not the focused one).
+    delKey(setSessionPending, src.sid)
+    delKey(setSessionNeeds, src.sid)
     // The modal owned focus while open; hand it back so the composer is typeable immediately.
     focusComposer()
   }
 
   function replyAsk(answers: Record<string, string>) {
-    const a = askPending()
-    if (!a) return
-    engine.send({ type: "ask-reply", requestId: a.requestId, answers })
-    delKey(setSessionAsk, activeSession())
-    delKey(setSessionNeeds, activeSession())
+    const src = askSrc()
+    if (!src) return
+    engine.send({ type: "ask-reply", requestId: src.val.requestId, answers })
+    delKey(setSessionAsk, src.sid)
+    delKey(setSessionNeeds, src.sid)
+    focusComposer()
   }
 
   // ---- plan-mode gate ----
@@ -1528,6 +1609,7 @@ export function createAppStore(engine: Engine, version = "dev") {
     pushToast("dismissed team", "input")
   }
   function popoutAgent(sessionId: string) {
+    if (tmuxOn()) return addToWall(["attach", sessionId], titleOf(sessionId))
     const r = engine.popoutAgent(sessionId)
     pushToast(r.ok ? `opened agent window via ${r.backend}` : winFail(r, "the agent window"), r.ok ? "done" : "input")
   }
@@ -1703,6 +1785,14 @@ export function createAppStore(engine: Engine, version = "dev") {
     launchSwarm,
     launchTeam,
     refreshSessions,
+    // tmux wall (control center)
+    tmuxOn,
+    wallPanes,
+    refreshWall,
+    removeWallPane,
+    closeWall,
+    arrangeWall,
+    viewWall,
     trustOpen,
     trustCwd,
     declineTrust,
@@ -1713,6 +1803,8 @@ export function createAppStore(engine: Engine, version = "dev") {
     busy,
     pending,
     askPending,
+    pendingFrom,
+    askFrom,
     replyAsk,
     plans,
     planPending,
diff --git a/packages/tui/test/keymap-pause.test.tsx b/packages/tui/test/keymap-pause.test.tsx
index 0f2cc12..cdad0f9 100644
--- a/packages/tui/test/keymap-pause.test.tsx
+++ b/packages/tui/test/keymap-pause.test.tsx
@@ -28,12 +28,16 @@ async function settle(t: Awaited<ReturnType<typeof shell>>): Promise<string> {
   return t.captureCharFrame()
 }
 
-// Pause moved off the un-encodable Shift+Esc onto Ctrl+P (everywhere) and Cmd/Super+Enter (kitty).
-// When idle there's nothing to pause, so both should surface the same "nothing to pause" toast —
-// proof the binding actually fired and routed to the pause command.
-test("Ctrl+P routes to pause", async () => {
-  const t = await shell()
-  t.mockInput.pressKey("p", { ctrl: true })
+// Pause moved off the un-encodable Shift+Esc onto Ctrl+Space (everywhere, single-handed) and
+// Cmd/Super+Enter (kitty). When idle there's nothing to pause, so both should surface the same
+// "nothing to pause" toast — proof the binding actually fired and routed to the pause command.
+// Real terminals send a NUL byte for Ctrl+Space which OpenTUI parses to {name:"space",ctrl:true}
+// (see getCtrlKeyName(0)); the keybindings unit test covers that chord match. Here we drive it through
+// the kitty path (the harness only synthesizes ctrl+space as a real event under kitty) to prove the
+// global handler routes name=space+ctrl to pause.
+test("Ctrl+Space routes to pause", async () => {
+  const t = await shell({ kittyKeyboard: true })
+  t.mockInput.pressKey(" ", { ctrl: true })
   expect(await settle(t)).toContain("nothing to pause")
   t.renderer.destroy()
 })
diff --git a/packages/tui/test/resolve-pending.test.ts b/packages/tui/test/resolve-pending.test.ts
new file mode 100644
index 0000000..8682686
--- /dev/null
+++ b/packages/tui/test/resolve-pending.test.ts
@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test"
+import { resolvePending } from "../src/store.tsx"
+
+test("focused session's own pending wins", () => {
+  const map = { main: { requestId: "r1" }, bg: { requestId: "r2" } }
+  expect(resolvePending(map, "main")).toEqual({ sid: "main", val: { requestId: "r1" } })
+})
+
+test("a background agent's pending surfaces when the focused session has none", () => {
+  const map = { bg: { requestId: "r2" } }
+  expect(resolvePending(map, "main")).toEqual({ sid: "bg", val: { requestId: "r2" } })
+})
+
+test("nothing pending → null", () => {
+  expect(resolvePending({}, "main")).toBeNull()
+})

From 0642604724ee5d639269abf7638f259ef7b118d8 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:34:04 -0700
Subject: [PATCH 3/7] fix(runner): don't block the turn on the session git-base
 capture

gitRevParse spawns a `git` subprocess; awaiting it at turn start delayed the
first stream event by the spawn time on every session. On Windows (slow process
spawn) this blew the tight timing budgets in the engine/TUI tests, failing 9
Windows-only CI checks. `git rev-parse HEAD` returns the committed sha
regardless of uncommitted edits, so capture it fire-and-forget; the snapshot
tracker covers the brief window before it resolves.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/core/src/runner.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/packages/core/src/runner.ts b/packages/core/src/runner.ts
index 9fd8654..a34c97b 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -1033,12 +1033,20 @@ export class SessionRunner {
 
     this.busy = true
     this.abort = new AbortController()
-    // Capture the git base ONCE, before this session's first edit/commit, so the changes panel can
-    // diff the working tree against it (committed + uncommitted) for a full session footprint.
+    // Capture the git base ONCE, near session start, so the changes panel can diff the working tree
+    // against it (committed + uncommitted) for a full session footprint. Fire-and-forget — `git
+    // rev-parse HEAD` returns the committed sha regardless of uncommitted edits, so it needn't block
+    // the turn (and awaiting a subprocess spawn here measurably delays the first stream event,
+    // especially on Windows). It resolves long before the model emits an edit; until then the
+    // snapshot tracker covers the gap.
     if (this.sessionBaseRef === undefined) {
-      const base = await gitRevParse(this.cwd)
-      this.sessionBaseRef = base ?? "" // "" = checked, not a repo → fall back to snapshot tracking
-      if (base) this.persistMeta({ baseRef: base })
+      this.sessionBaseRef = "" // "" = capturing / not a repo → snapshot fallback until git resolves
+      void gitRevParse(this.cwd).then((base) => {
+        if (base) {
+          this.sessionBaseRef = base
+          this.persistMeta({ baseRef: base })
+        }
+      })
     }
     this.currentCheckpoint = {
       id: this.host.nextId(),

From 1787c5ef91dd57a27d98a1e2f63f12de40faf397 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:38:57 -0700
Subject: [PATCH 4/7] test(runtime-gaps): retry dir cleanup to dodge Windows
 EBUSY
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The changes panel spawns background `git` with cwd=dir; on the slow Windows
runner an immediate fs.rmSync races that subprocess's cwd lock (EBUSY). Use
fs.rmSync's native maxRetries/retryDelay — the option built for exactly this.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/core/test/runtime-gaps.test.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/core/test/runtime-gaps.test.ts b/packages/core/test/runtime-gaps.test.ts
index dc05f83..23f30c4 100644
--- a/packages/core/test/runtime-gaps.test.ts
+++ b/packages/core/test/runtime-gaps.test.ts
@@ -280,7 +280,9 @@ test("checkpoint captures bash-created files; rewind both removes them", async (
   engine.restoreCheckpoint(cps[0]!.id, "both")
   await waitFor(() => !fs.existsSync(path.join(dir, "created.txt")))
   expect(fs.existsSync(path.join(dir, "created.txt"))).toBe(false) // rewind removed the bash-created file
-  fs.rmSync(dir, { recursive: true, force: true })
+  // maxRetries: the changes panel spawns background `git` in this dir (cwd lock); on Windows an
+  // immediate rm races it with EBUSY. Retry briefly — native, exactly what this option is for.
+  fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })
 }, 20_000)
 
 test("scoped rewind: code-only keeps the conversation, conversation-only keeps the files", async () => {

From adfe668bccbde1871252795f3f554a846cdd88e9 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:42:01 -0700
Subject: [PATCH 5/7] test(runtime-gaps): best-effort temp-dir cleanup (Windows
 EBUSY)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Background git in the dir outlives the test and holds a cwd lock; rm retries
weren't enough. The rewind assertion already passed, so swallow teardown
failure — a leaked os.tmpdir() dir is harmless.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/core/test/runtime-gaps.test.ts | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/core/test/runtime-gaps.test.ts b/packages/core/test/runtime-gaps.test.ts
index 23f30c4..f9cfee0 100644
--- a/packages/core/test/runtime-gaps.test.ts
+++ b/packages/core/test/runtime-gaps.test.ts
@@ -280,9 +280,14 @@ test("checkpoint captures bash-created files; rewind both removes them", async (
   engine.restoreCheckpoint(cps[0]!.id, "both")
   await waitFor(() => !fs.existsSync(path.join(dir, "created.txt")))
   expect(fs.existsSync(path.join(dir, "created.txt"))).toBe(false) // rewind removed the bash-created file
-  // maxRetries: the changes panel spawns background `git` in this dir (cwd lock); on Windows an
-  // immediate rm races it with EBUSY. Retry briefly — native, exactly what this option is for.
-  fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })
+  // Best-effort cleanup: the changes panel spawns background `git` in this dir, holding a cwd lock on
+  // Windows that outlives the test; rm races it with EBUSY. The assertion above already passed, so a
+  // leaked temp dir under os.tmpdir() is harmless — don't fail the test on teardown.
+  try {
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })
+  } catch {
+    /* dir still locked by background git — OS temp cleanup handles it */
+  }
 }, 20_000)
 
 test("scoped rewind: code-only keeps the conversation, conversation-only keeps the files", async () => {

From d5f6a8affee3e3c0ffed7d64a0c4704f2357ce77 Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:47:36 -0700
Subject: [PATCH 6/7] fix(runner): settle session git work within the turn
 (Windows EBUSY)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause of the flaky Windows-only failures: the session base-ref capture and
the changes-panel diff each spawn a `git` subprocess. Awaiting at turn start
blocked the hot path (broke tight test timing budgets); fire-and-forget left a
git process holding the dir's cwd lock past turn-done, so whichever temp-dir
test rm'd first hit EBUSY.

Now: kick off the base-ref capture concurrently with the model stream (hot path
stays free), then await both it and emitSessionFiles in the turn's finally
BEFORE emitting turn-done — so no git subprocess outlives the turn. Off the hot
path, this only gates the done/ready signal by a quick git diff.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/core/src/runner.ts | 39 ++++++++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/packages/core/src/runner.ts b/packages/core/src/runner.ts
index a34c97b..8c327c5 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -368,6 +368,8 @@ export class SessionRunner {
   private pinned: string[] = []
   /** git commit captured at session start; the changes panel diffs the working tree against it. */
   private sessionBaseRef?: string
+  /** in-flight base-ref capture (spawned concurrently with the stream, awaited before turn-done). */
+  private baseCapture?: Promise<void>
   private skills: Skill[]
   private agents: AgentDef[]
   private lsp: LspManager
@@ -1034,18 +1036,15 @@ export class SessionRunner {
     this.busy = true
     this.abort = new AbortController()
     // Capture the git base ONCE, near session start, so the changes panel can diff the working tree
-    // against it (committed + uncommitted) for a full session footprint. Fire-and-forget — `git
-    // rev-parse HEAD` returns the committed sha regardless of uncommitted edits, so it needn't block
-    // the turn (and awaiting a subprocess spawn here measurably delays the first stream event,
-    // especially on Windows). It resolves long before the model emits an edit; until then the
-    // snapshot tracker covers the gap.
-    if (this.sessionBaseRef === undefined) {
-      this.sessionBaseRef = "" // "" = capturing / not a repo → snapshot fallback until git resolves
-      void gitRevParse(this.cwd).then((base) => {
-        if (base) {
-          this.sessionBaseRef = base
-          this.persistMeta({ baseRef: base })
-        }
+    // against it (committed + uncommitted) for a full session footprint. Kicked off concurrently with
+    // the model stream — NOT awaited here, because spawning a `git` subprocess on the hot path delays
+    // the first stream event (notably on Windows). The turn's finally awaits this promise before it
+    // signals done, so the subprocess never outlives the turn (a lingering git holds a cwd lock on
+    // Windows, which would EBUSY a test that rm's the dir).
+    if (this.sessionBaseRef === undefined && !this.baseCapture) {
+      this.baseCapture = gitRevParse(this.cwd).then((base) => {
+        this.sessionBaseRef = base ?? "" // "" = checked, not a repo → fall back to snapshot tracking
+        if (base) this.persistMeta({ baseRef: base })
       })
     }
     this.currentCheckpoint = {
@@ -1075,6 +1074,20 @@ export class SessionRunner {
       const aborted = this.abort?.signal.aborted ?? false
       this.busy = false
       this.abort = undefined
+      void this.hook("Stop")
+      // Settle the background git work (base-ref capture + changes-panel diff) WITHIN the turn, before
+      // we signal turn-done — both spawn `git` subprocesses, and on Windows a lingering one holds a cwd
+      // lock that EBUSYs a teardown rm. This runs after the stream, so it only gates the done/ready
+      // signal by a quick git diff; the visible output already streamed.
+      if (this.baseCapture) {
+        try {
+          await this.baseCapture
+        } catch {
+          /* git hiccup — sessionBaseRef stays unset, snapshot tracker covers it */
+        }
+        this.baseCapture = undefined
+      }
+      await this.emitSessionFiles()
       // Always finalize the in-flight assistant item so the UI clears `busy` (stops the timer)
       // and marks the bubble done — turn-done is the ONLY event the UI uses for this, and the
       // normal path may not have emitted it (abort / error / step-limit).
@@ -1082,8 +1095,6 @@ export class SessionRunner {
         this.emit({ type: "turn-done", id: this.activeAssistantId })
         this.activeAssistantId = undefined
       }
-      void this.hook("Stop")
-      void this.emitSessionFiles()
       // The turn's checkpoint now has all its file snapshots — persist so rewind survives a restart.
       this.persistCheckpoints()
       // NOTE: no "last message becomes the plan" fallback. A plan is ONLY what the model deliberately

From 7933db1affab20605da1381a7537918a47fa5d4e Mon Sep 17 00:00:00 2001
From: katipally <yashwanthreddy3471@gmail.com>
Date: Tue, 23 Jun 2026 12:51:30 -0700
Subject: [PATCH 7/7] fix(runner): skip git base-ref spawn outside a repo (fs
 probe)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The per-session base-ref capture spawned `git rev-parse` even in non-repo dirs,
holding a Windows cwd lock that EBUSY'd temp-dir test teardowns. Probe for `.git`
with an fs walk first (no subprocess) — non-repo sessions skip git entirely
(also a small perf win), repos still capture and settle within the turn.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/core/src/git.ts    | 13 +++++++++++++
 packages/core/src/runner.ts | 13 +++++++++----
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/packages/core/src/git.ts b/packages/core/src/git.ts
index a1a188c..e164417 100644
--- a/packages/core/src/git.ts
+++ b/packages/core/src/git.ts
@@ -1,6 +1,19 @@
 /** Lightweight, local-only git helpers (status, diff, commit, worktrees). No network. */
+import fs from "node:fs"
 import path from "node:path"
 
+/** Is `cwd` inside a git repo? An fs walk for `.git` — no subprocess, so it's safe to call on the hot
+ * path and avoids spawning `git` (and holding a cwd lock) in dirs that aren't repos. */
+export function isGitRepo(cwd: string): boolean {
+  let dir = path.resolve(cwd)
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".git"))) return true
+    const parent = path.dirname(dir)
+    if (parent === dir) return false
+    dir = parent
+  }
+}
+
 export interface GitFile {
   path: string
   status: string // "M" | "A" | "D" | "?" | "R" ...
diff --git a/packages/core/src/runner.ts b/packages/core/src/runner.ts
index 8c327c5..9784d42 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -78,6 +78,7 @@ import {
   gitStatus,
   gitWorktreeAdd,
   gitWorktreeList,
+  isGitRepo,
 } from "./git.ts"
 import { type HookEvent, type HookPayload, type HooksConfig, runHooks } from "./hooks.ts"
 import { deleteMemory, listMemory, memoryDigest, saveMemory } from "./memory.ts"
@@ -1042,10 +1043,14 @@ export class SessionRunner {
     // signals done, so the subprocess never outlives the turn (a lingering git holds a cwd lock on
     // Windows, which would EBUSY a test that rm's the dir).
     if (this.sessionBaseRef === undefined && !this.baseCapture) {
-      this.baseCapture = gitRevParse(this.cwd).then((base) => {
-        this.sessionBaseRef = base ?? "" // "" = checked, not a repo → fall back to snapshot tracking
-        if (base) this.persistMeta({ baseRef: base })
-      })
+      if (!isGitRepo(this.cwd)) {
+        this.sessionBaseRef = "" // not a repo (fs probe, no subprocess) → snapshot tracker only
+      } else {
+        this.baseCapture = gitRevParse(this.cwd).then((base) => {
+          this.sessionBaseRef = base ?? "" // "" = checked, not a repo → fall back to snapshot tracking
+          if (base) this.persistMeta({ baseRef: base })
+        })
+      }
     }
     this.currentCheckpoint = {
       id: this.host.nextId(),