diff --git a/CHANGELOG.md b/CHANGELOG.md
index b33e899..e6470ae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,69 @@ 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]
+
+## [2.0.10] - 2026-06-23
+
+### 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.
+- **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+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
+  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.
+- **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
 
 ### Added
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/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..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 ----
@@ -434,13 +448,40 @@ 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())
   }
+
+  // ---- 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 {
@@ -507,7 +548,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 +752,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()
   }
@@ -780,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). */
@@ -915,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,
@@ -926,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 ----
@@ -949,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 f0daef0..3fc9ca6 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 {
@@ -28,30 +39,37 @@ 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 _`
 }
 
-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 +78,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 +107,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>`). */
@@ -125,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..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" ...
@@ -61,6 +74,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 e672d77..618667c 100644
--- a/packages/core/src/keybindings.ts
+++ b/packages/core/src/keybindings.ts
@@ -14,7 +14,11 @@ export const DEFAULT_KEYBINDINGS = {
   "dashboard.toggle": "ctrl+o",
   "history.open": "ctrl+y",
   "mode.cycle": "shift+tab",
-  "pause.open": "shift+escape",
+  // 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 34c322e..9784d42 100644
--- a/packages/core/src/runner.ts
+++ b/packages/core/src/runner.ts
@@ -68,13 +68,24 @@ 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,
+  isGitRepo,
+} 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"
 
@@ -354,6 +365,12 @@ 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[] = []
+  /** 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
@@ -364,8 +381,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>()
@@ -426,6 +441,18 @@ 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)
+    // 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)
@@ -445,7 +472,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" }[] = []
@@ -563,8 +605,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) => ({
@@ -611,6 +678,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 =
@@ -645,7 +716,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 {
@@ -673,6 +744,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)
@@ -691,6 +764,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)
@@ -890,6 +964,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
@@ -903,6 +978,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 {
@@ -911,6 +988,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)
@@ -932,6 +1010,7 @@ export class SessionRunner {
       roots: this.roots,
       messages: this.messages,
     })
+    void this.emitSessionFiles() // files were re-applied — refresh the changes panel
   }
 
   // ---- the agentic loop ----
@@ -956,8 +1035,23 @@ export class SessionRunner {
     }
 
     this.busy = true
-    this.planEmitted = false
     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. 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) {
+      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(),
       label: text.replace(/\s+/g, " ").trim().slice(0, 60) || "turn",
@@ -985,6 +1079,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).
@@ -992,19 +1100,12 @@ export class SessionRunner {
         this.emit({ type: "turn-done", id: this.activeAssistantId })
         this.activeAssistantId = undefined
       }
-      void this.hook("Stop")
-      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" })
     }
@@ -1130,6 +1231,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",
@@ -1159,6 +1261,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" })
@@ -1258,7 +1361,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.
@@ -1401,7 +1504,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,
@@ -2050,7 +2152,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 55d8aa3..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
@@ -53,12 +73,25 @@ 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 '[]', meta TEXT NOT NULL DEFAULT '{}'
       );`,
     )
+    // 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", json: string): void {
+  private upsertState(
+    sessionId: string,
+    column: "todos" | "plans" | "checkpoints" | "pinned_files" | "meta",
+    json: string,
+  ): void {
     this.db
       .query(
         `INSERT INTO session_state (session_id, ${column}) VALUES (?, ?)
@@ -66,13 +99,30 @@ 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
     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))
   }
@@ -93,6 +143,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/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/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/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 014fa75..d0b689e 100644
--- a/packages/core/test/keybindings.test.ts
+++ b/packages/core/test/keybindings.test.ts
@@ -24,8 +24,10 @@ 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+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/runtime-gaps.test.ts b/packages/core/test/runtime-gaps.test.ts
index dc05f83..f9cfee0 100644
--- a/packages/core/test/runtime-gaps.test.ts
+++ b/packages/core/test/runtime-gaps.test.ts
@@ -280,7 +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
-  fs.rmSync(dir, { recursive: true, force: true })
+  // 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 () => {
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/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/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/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..5112417
--- /dev/null
+++ b/packages/tui/src/components/ContextFilesModal.tsx
@@ -0,0 +1,162 @@
+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, 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 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()
+  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}`))
+  })
+
+  const pin = (f: string) => {
+    app.pinContextFile(f)
+    setQuery("")
+    setSel(0)
+  }
+
+  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) pin(pick)
+      return
+    }
+    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)
+      return setQuery((q) => q + key.sequence)
+    }
+  })
+
+  const w = () => Math.min(76, dims().width - 4)
+
+  return (
+    <Scrim onClose={() => app.setContextModalOpen(false)}>
+      <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. */}
+        <box flexDirection="column">
+          <SectionLabel text={`pinned (${pinned().length})`} />
+          <Show
+            when={pinned().length}
+            fallback={<text fg={theme.textFaint}> none yet — search above and press ⏎ to pin</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>
+
+        {/* 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>
+
+        <box flexDirection="row" gap={1}>
+          <HintChip label="↑↓ move" />
+          <HintChip label="⏎ pin" accent={theme.success} />
+          <HintChip label="⌫ unpin last" />
+          <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/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/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/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/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..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 }
@@ -255,6 +269,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 +312,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)
@@ -378,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)
@@ -409,6 +455,7 @@ export function createAppStore(engine: Engine, version = "dev") {
     pauseModalOpen() ||
     mcpModalOpen() ||
     skillsModalOpen() ||
+    contextModalOpen() ||
     computerModalOpen() ||
     checkpointsOpen() ||
     forkOpen() ||
@@ -428,9 +475,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}`
 
@@ -772,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
+      }
     }
   })
 
@@ -899,18 +965,59 @@ export function createAppStore(engine: Engine, version = "dev") {
       setMicModalOpen(true)
     }
   }
-  // ---- dashboard launchers (open work in its own window; the dashboard stays the console) ----
-  /** Open a brand-new interactive friday window (new chat) in the current directory. */
+  // ---- 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}`
+
+  // 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})` : "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. */
+  /** 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])
-    pushToast(r.ok ? `opened session (${r.backend})` : "no terminal backend to open a window", r.ok ? "done" : "error")
+    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())
@@ -918,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). */
@@ -1139,7 +1250,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
@@ -1326,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 ----
@@ -1494,8 +1609,9 @@ 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}` : "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)
@@ -1669,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,
@@ -1679,6 +1803,8 @@ export function createAppStore(engine: Engine, version = "dev") {
     busy,
     pending,
     askPending,
+    pendingFrom,
+    askFrom,
     replyAsk,
     plans,
     planPending,
@@ -1744,6 +1870,7 @@ export function createAppStore(engine: Engine, version = "dev") {
     computerInstallLog,
     installComputer,
     uninstallComputer,
+    openMacPrivacy,
     setMcpModalOpen,
     mcpConfig,
     refreshMcp,
@@ -1775,6 +1902,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..cdad0f9
--- /dev/null
+++ b/packages/tui/test/keymap-pause.test.tsx
@@ -0,0 +1,60 @@
+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+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()
+})
+
+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()
+})
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()
+})