@visual-z/xeno 0.3.0 → 0.5.0

package/src/runtime/tools.ts

@@ -370,7 +370,7 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
     description:
       "Read a file. Returns the contents with 1-indexed line numbers. " +
       "Optionally limit to an inclusive line range. Reports total lines and the next range; end beyond EOF is clamped. " +
-      "Returns read_handle and whole-file sha256 for version checks. Long lines and large previews retain an immutable artifact. Line ranges describe the selection; the observation receipt describes exactly what was visible. An unavailable artifact-recovery capability leaves a gap, not proof of full coverage.",
+      "Session remembers the whole-file version for later changes; no digest copying is needed. Returns read_handle and whole-file sha256 for selecting an explicit observation. Long lines and large previews retain an immutable artifact. Line ranges describe the selection; the observation receipt describes exactly what was visible. An unavailable artifact-recovery capability leaves a gap, not proof of full coverage.",
     input_schema: {
       type: "object",
       properties: {
@@ -384,14 +384,14 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
   {
     name: "write",
     access: "write", execution: "exclusive", branch: "write", run: toolWrite,
-    description: "Write a file, creating parent directories. Replaces existing content. Pass read_handle or expected_sha256 for an explicit version check; otherwise Session uses its last observed version. create_only requires absence. A conflict requires a fresh read. Identical content makes no change.",
+    description: "Write a file, creating parent directories. Replaces existing content. Normally omit read_handle and expected_sha256: Session checks its latest observed version. Without a prior observation, omission has no stale-version protection. To select a specific observation instead, pass its exact version receipt. create_only requires absence. A conflict requires a fresh read. Identical content makes no change.",
     input_schema: {
       type: "object",
       properties: {
         path: { type: "string" },
         content: { type: "string" },
-        read_handle: { type: "string", description: "Descriptor SHA from an observation of this file, workspace and host" },
-        expected_sha256: { type: "string", description: "Expected whole-file raw-byte SHA-256" },
+        read_handle: { type: "string", description: "Optional explicit descriptor SHA for this file, workspace and host; normally omit" },
+        expected_sha256: { type: "string", description: "Optional explicit whole-file raw-byte SHA-256; normally omit" },
         create_only: { type: "boolean", description: "Require that the target does not exist; excludes read_handle and expected_sha256" },
       },
       required: ["path", "content"],
@@ -400,14 +400,16 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
   {
     name: "edit",
     example: { path: "src/main.ts", old_string: "const size = 1;", new_string: "const size = 2;" },
-    guidance: [{ requires: ["read"], text: "Use read to obtain current text and a version receipt before an edit." }],
+    guidance: [{ requires: ["read"], text: "Use read to obtain current text before an edit; Session remembers its version automatically." }],
     access: "write", execution: "exclusive", branch: "write", run: toolEdit,
     description:
-      "Replace exact text in a file. old_string must match once unless replace_all is set; copy it from observed file content, " +
+      "Replace exact text in a file. Normally omit read_handle and expected_sha256: Session checks its latest observed version. " +
+      "Without a prior observation, omission has no stale-version protection. To select a specific observation instead, pass its exact version receipt. " +
+      "old_string must match once unless replace_all is set; copy it from observed file content, " +
       "including indentation (line numbers are not part of the file). For several changes to one file pass edits[], " +
       "each matched against the original; all apply or none do. If there is no exact match, a unique match that differs only in " +
       "trailing whitespace, quote or dash style is applied and flagged fuzzy. A failure shows the closest text in the file. " +
-      "Pass read_handle or expected_sha256 from a file observation to reject stale edits; when omitted, Session uses its last observed version. A conflict requires a fresh observation. A partial read handle checks the whole file version, not permission to edit unseen lines.",
+      "A conflict requires a fresh observation. A partial read handle checks the whole file version, not permission to edit unseen lines.",
     input_schema: {
       type: "object",
       properties: {
@@ -419,8 +421,8 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
           type: "object", required: ["old_string", "new_string"], properties: {
             old_string: { type: "string", minLength: 1 }, new_string: { type: "string" }, replace_all: { type: "boolean" },
           } } },
-        expected_sha256: { type: "string", description: "Observed whole-file version; mismatch leaves the file unchanged" },
-        read_handle: { type: "string", description: "Descriptor SHA from an observation of this file, workspace and host" },
+        expected_sha256: { type: "string", description: "Optional explicit whole-file raw-byte SHA-256; normally omit" },
+        read_handle: { type: "string", description: "Optional explicit descriptor SHA for this file, workspace and host; normally omit" },
       },
       required: ["path"],
     },

package/src/store/resources.ts

@@ -2,8 +2,8 @@
  * Discover and read UI resources: settings, theme, keybindings, skills,
  * prompt templates.
  *
- * I/O lives here; validation is core. A corrupt file is a diagnostic plus
- * a fallback, never a throw -- startup has to survive a missing comma.
+ * I/O lives here; validation is core. Reads diagnose corrupt files and fall
+ * back so startup survives a missing comma. Writes preserve them and report failure.
  *
  * Project-level files follow the same trust rule as `.xeno/settings.json`.
  * Theme and keymap are UI state and are not logged.
@@ -12,7 +12,9 @@
 import { readdir, readFile } from "node:fs/promises";
 import { watch } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { configDir, readJsonFile, writeJsonFile, settingsPath } from "./config.ts";
+import { configDir, readJsonFile } from "./config.ts";
+import { editUserSettings } from "./user-settings.ts";
+import { mergePreferenceJson } from "../core/model-preferences.ts";
 import { discoverResources, themeResourcePath, type ResourceIndex } from "./resource-index.ts";
 import { parseSkill, type Skill } from "../core/skills.ts";
 import { parsePromptTemplate, type PromptTemplate } from "../core/prompts.ts";
@@ -29,7 +31,6 @@ import {
 import {
   defaultSettings,
   mergeSettings,
-  settingsToWrite,
   type Settings,
 } from "../core/settings.ts";
 
@@ -90,28 +91,18 @@ export function selectedThemePath(index: ResourceIndex, name: string, noThemes =
 }
 
 export async function writeUserSettings(overrides: Partial<Settings>): Promise<void> {
-  const { value, error } = await readJsonFile<unknown>(settingsPath());
-  const prev =
-    error === null && typeof value === "object" && value !== null && !Array.isArray(value)
-      ? (value as { readonly [k: string]: unknown })
-      : {};
-  const next = { ...prev, ...settingsToWrite(overrides),
-    ...(overrides.terminal ? { terminal: { ...(typeof prev["terminal"] === "object" ? prev["terminal"] : {}), ...overrides.terminal } } : {}),
-    ...(overrides.modelThinkingLevels ? { modelThinkingLevels: { ...(typeof prev["modelThinkingLevels"] === "object" ? prev["modelThinkingLevels"] : {}), ...overrides.modelThinkingLevels } } : {}),
-    ...Object.fromEntries((["images", "markdown"] as const).filter(key => overrides[key]).map(key => [key, { ...(typeof prev[key] === "object" ? prev[key] : {}), ...overrides[key] }])),
-  };
-  await writeJsonFile(settingsPath(), next, false);
+  const patch = structuredClone(overrides);
+  await editUserSettings(previous => mergePreferenceJson(previous, patch));
 }
 
 /** Remove only the user's override; project defaults and unrelated keys retain their ownership. */
 export async function removeModelThinkingOverride(identity: string): Promise<void> {
-  const { value, error } = await readJsonFile<Record<string, unknown>>(settingsPath());
-  if (error) throw new Error(error);
-  if (!value || typeof value !== "object" || Array.isArray(value)) return;
-  const levels = value["modelThinkingLevels"];
-  if (!levels || typeof levels !== "object" || Array.isArray(levels)) return;
-  const next = Object.fromEntries(Object.entries(levels).filter(([key]) => key !== identity));
-  await writeJsonFile(settingsPath(), { ...value, modelThinkingLevels: next }, false);
+  await editUserSettings(previous => {
+    const levels = previous["modelThinkingLevels"];
+    if (!levels || typeof levels !== "object" || Array.isArray(levels)) return null;
+    const next = Object.fromEntries(Object.entries(levels).filter(([key]) => key !== identity));
+    return { ...previous, modelThinkingLevels: next };
+  });
 }
 
 export async function resolveTheme(spec: string, diagnostics: string[]): Promise<Theme> {

package/src/store/user-settings.ts

@@ -0,0 +1,30 @@
+/** One read/modify/replace owner prevents automatic selections from racing other settings (Q.25). */
+import { readFile } from "node:fs/promises";
+import { settingsPath } from "./config.ts";
+import { atomicWrite } from "./atomic.ts";
+import { serialized } from "./serial.ts";
+
+async function readSettings(path: string): Promise<Record<string, unknown>> {
+  let text: string;
+  try { text = await readFile(path, "utf8"); }
+  catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return {};
+    throw error;
+  }
+  let value: unknown;
+  try { value = JSON.parse(text); }
+  catch { throw new Error(`${path} is not valid JSON; repair it before saving settings`); }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must contain a settings object`);
+  return value as Record<string, unknown>;
+}
+
+export function editUserSettings(edit: (previous: Record<string, unknown>) => Record<string, unknown> | null): Promise<void> {
+  // Capture the destination before any await, including when another profile changes configDir().
+  const path = settingsPath();
+  // Packages and resource overrides already coordinate this file through serialized().
+  return serialized(path, async () => {
+    const next = edit(await readSettings(path));
+    if (next === null) return;
+    await atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
+  });
+}

package/src/tui/ui/composer.ts

@@ -16,6 +16,7 @@ import { draftRows, type DraftRows } from "./draft.ts";
 import type { ListItem } from "./list-model.ts";
 
 export interface Completion {
+  readonly kind: "command" | "argument" | "path";
   /** Replace text[start, end) with an item's value. */
   readonly start: number;
   readonly end: number;
@@ -89,8 +90,8 @@ export class Composer {
   setAtoms(spans: (text: string) => readonly DraftAtom[]): void { this.area.atoms = spans; }
   get completing(): boolean { return this.completion !== undefined && this.completion.items.length > 0; }
   /** What the completion list shows (screen draws it). */
-  get completionView(): { readonly items: readonly ListItem[]; readonly selected: number } | undefined {
-    return this.completion ? { items: this.completion.items, selected: this.completionIndex } : undefined;
+  get completionView(): { readonly kind: Completion["kind"]; readonly items: readonly ListItem[]; readonly selected: number } | undefined {
+    return this.completion ? { kind: this.completion.kind, items: this.completion.items, selected: this.completionIndex } : undefined;
   }
   get historyEntries(): readonly string[] { return this.history; }
   get rows(): number { return Math.max(1, this.area.height); }

package/src/tui/ui/control-panel.ts

@@ -0,0 +1,25 @@
+/** View-only data: apps owns the projection and actions, as required by D20. */
+import { wrapPlain } from "../diff.ts";
+
+export type ControlPanelModel = {
+  thread: string; turn: string | null; goal: string; status: string; execution: string; gaps: readonly string[];
+  progress: readonly { label: string; count: number; sources: readonly string[] }[]; checks: readonly string[];
+  context: readonly string[]; omitted: readonly string[]; history: readonly string[];
+};
+export type ControlTab = "goal" | "progress" | "context";
+export type ControlFocus = "messages" | "omitted" | "history";
+
+export function controlPanelLines(model: ControlPanelModel, tab: ControlTab, width: number, focus: ControlFocus = "messages"): string[] {
+  const lines = tab === "goal" ? [model.goal, `Goal: ${model.status}`, `Execution: ${model.execution}`, "", ...model.gaps,
+      ...model.checks, "", `Thread ${model.thread}`, `Turn ${model.turn ?? "none"}`]
+      : tab === "progress" ? ["Evidence for this request", ...model.progress.map(item => `${item.label}: ${item.count}`), "",
+        "Counts describe observations, not a completion percentage.", ...model.checks,
+        ...model.progress.flatMap(item => item.sources.map(source => `${item.label}: ${source}`))]
+      : focus === "messages" ? ["Actual model context · ←/→ change lens", ...model.context]
+        : focus === "omitted" ? ["Not replayed as messages · ←/→ change lens", ...(model.omitted.length ? model.omitted : ["No omitted events in this segment."])]
+          : ["Handoff retention and recovery · ←/→ change lens", ...(model.history.length ? model.history : ["No carried history in this segment."])];
+  // Unlike status chrome, evidence is inspectable content: every character must
+  // remain reachable by scrolling, including long source paths and CJK (Q24).
+  // A one-cell pane cannot show a wide glyph; its owner shows resize feedback.
+  return lines.flatMap(line => wrapPlain(line.replace(/[\x00-\x1f\x7f-\x9f]/g, " "), Math.max(2, width)));
+}

package/src/tui/ui/control-sidebar.ts

@@ -0,0 +1,49 @@
+/** Persistent view state only; the controller supplies evidence and owns actions (D20/Q24). */
+import { controlPanelLines, type ControlFocus, type ControlPanelModel, type ControlTab } from "./control-panel.ts";
+import { clipText } from "./edge.ts";
+import type { Line } from "./status.ts";
+
+const TABS: readonly ControlTab[] = ["goal", "progress", "context"];
+const LENSES: readonly ControlFocus[] = ["messages", "omitted", "history"];
+/** Below these assumed view-only limits, show reversible size feedback instead of unreadable controls. */
+const MIN_CONTENT_COLUMNS = 16, MIN_CONTENT_ROWS = 8;
+
+export class ControlSidebar {
+  model: ControlPanelModel | undefined;
+  tab: ControlTab = "goal";
+  lens: ControlFocus = "messages";
+  private readonly offsets = new Map<string, number>();
+  private shownOffset = 0;
+  private pageRows = 1;
+  private maxOffset = 0;
+
+  private get page(): string { return this.tab === "context" ? `${this.tab}:${this.lens}` : this.tab; }
+
+  changeTab(delta: number): void { this.tab = TABS[(TABS.indexOf(this.tab) + delta + TABS.length) % TABS.length]!; }
+  changeLens(delta: number): void { this.lens = LENSES[(LENSES.indexOf(this.lens) + delta + LENSES.length) % LENSES.length]!; }
+  scroll(delta: number, page = false): void {
+    this.offsets.set(this.page, Math.max(0, Math.min(this.maxOffset, this.shownOffset + delta * (page ? this.pageRows : 1))));
+  }
+  edge(end: boolean): void { this.offsets.set(this.page, end ? this.maxOffset : 0); }
+
+  rows(width: number, height: number, focused: boolean): readonly Line[] {
+    const w = Math.max(0, Math.floor(width)), h = Math.max(0, Math.floor(height));
+    if (w === 0 || h === 0) return [];
+    const row = (text: string, role: "text" | "muted" | "accent" = "text", bold = false): Line => [{ text: clipText(text, w), role, bold }];
+    if (w < MIN_CONTENT_COLUMNS || h < MIN_CONTENT_ROWS) {
+      // Do not reset the model, tab or desired scroll position: resize is reversible.
+      return [row(w < 6 ? "↔" : "Resize for control", "accent"), row("Esc editor · q close", "muted")].slice(0, h);
+    }
+    const tabs = TABS.map(tab => `${tab === this.tab ? "●" : "○"} ${tab === "context" ? "Context Lens" : tab === "goal" ? "Goal" : "Progress"}`);
+    const heading = [row(`Control panel · ${focused ? "focused" : "F6 focus"}`, "accent", true), row(`${tabs[0]}  ${tabs[1]}`), row(tabs[2]!)];
+    const hints = ["Tab sections · ←→ lenses", "r refresh · i stop · a accept", "Esc editor · q close · F6"];
+    this.pageRows = Math.max(1, h - heading.length - hints.length - 1);
+    const body = this.model ? controlPanelLines(this.model, this.tab, w, this.lens) : ["Evidence unavailable.", "Press r to refresh."];
+    this.maxOffset = Math.max(0, body.length - this.pageRows);
+    this.shownOffset = Math.min(this.maxOffset, this.offsets.get(this.page) ?? 0);
+    const shown = body.slice(this.shownOffset, this.shownOffset + this.pageRows).map(text => row(text));
+    while (shown.length < this.pageRows) shown.push(row(""));
+    const range = `${this.shownOffset + 1}–${Math.min(body.length, this.shownOffset + this.pageRows)}/${body.length}`;
+    return [...heading, ...shown, row(`↑↓ PgUp/PgDn · ${range}`, "muted"), ...hints.map(text => row(text, "muted"))];
+  }
+}

package/src/tui/ui/mascot.ts

@@ -61,7 +61,7 @@ export function greetingLines(greeting: Greeting, frame: readonly string[] = MAS
     [art(0), gap, { text: "xeno", role: "text", bold: true }, { text: ` ${greeting.version}`, role: "muted" }],
     [art(1), gap, ...(greeting.model
       ? [{ text: greeting.model, role: "text" as const }, { text: ` · ${greeting.thinking}`, role: "muted" as const }]
-      : [{ text: "No provider connected yet · /login", role: "warning" as const }])],
+      : [{ text: "No provider connected yet · /provider", role: "warning" as const }])],
     [art(2), gap, { text: greeting.workspace, role: "muted" }, ...(greeting.branch ? [{ text: ` ⎇ ${greeting.branch}`, role: "muted" as const }] : [])],
   ];
 }

package/src/tui/ui/screen.ts

@@ -23,9 +23,11 @@ import { Canvas } from "./canvas.ts";
 import type { UiColors } from "./colors.ts";
 import { Composer, draftMaxLines } from "./composer.ts";
 import { DialogHost } from "./dialog.ts";
+import type { ControlPanelModel, ControlTab } from "./control-panel.ts";
+import { ControlSidebar } from "./control-sidebar.ts";
 import { clipSegs, edgeLine, segsWidth, type Label, type Seg } from "./edge.ts";
-import type { Bindings } from "./keys.ts";
-import { screenLayout, type ScreenLayout } from "./layout.ts";
+import type { Bindings, KeyPress } from "./keys.ts";
+import { screenLayout, sidebarContentWidth, type ScreenLayout } from "./layout.ts";
 import { greetingLines, mascotFrame, MASCOT_FRAME_MS, MASCOT_FRAMES, type Greeting } from "./mascot.ts";
 import { MessageList, type MessageFeatures } from "./messages.ts";
 import { Motion } from "./motion.ts";
@@ -84,6 +86,12 @@ export class Screen {
   private readonly bottomEdge: Canvas;
   private readonly sidebar: BoxRenderable;
   private readonly sidebarRows: Canvas;
+  private readonly middle: BoxRenderable;
+  private readonly messagesArea: BoxRenderable;
+  private readonly controlView = new ControlSidebar();
+  private controlShown = false;
+  private controlHasFocus = false;
+  onControlAction: ((action: "refresh" | "interrupt" | "accept") => void) | undefined;
   private shape: ScreenLayout;
   private sidebarWanted = true;
   private status: StatusModel | undefined;
@@ -118,9 +126,11 @@ export class Screen {
     const root = new BoxRenderable(renderer, { id: "root", flexDirection: "column", width: "100%", height: "100%" });
     this.topbar = new Canvas(renderer, { id: "topbar", height: 1, flexShrink: 0, marginLeft: 1, marginRight: 1, colors });
     const middle = new BoxRenderable(renderer, { id: "middle", flexDirection: "row", flexGrow: 1, flexShrink: 1 });
+    this.middle = middle;
     const main = new BoxRenderable(renderer, { id: "main", flexDirection: "column", flexGrow: 1, flexShrink: 1 });
     this.greeting = new Canvas(renderer, { id: "greeting", height: 3, flexShrink: 0, marginTop: 1, marginLeft: 3, marginBottom: 1, colors });
     const area = new BoxRenderable(renderer, { id: "messages-area", flexDirection: "column", flexGrow: 1, flexShrink: 1 });
+    this.messagesArea = area;
     this.messages = new MessageList(renderer, colors, features, this.glyph);
     area.add(this.messages.scroll);
     this.pill = new Canvas(renderer, { id: "pill", position: "absolute", zIndex: 40, visible: false, height: 1, width: 1, bottom: 0, right: 3, colors });
@@ -140,16 +150,26 @@ export class Screen {
     this.bottomEdge = new Canvas(renderer, { id: "dock-bottom", height: 1, flexShrink: 0, colors });
     this.dock.add(this.topEdge); this.dock.add(this.body); this.dock.add(this.bottomEdge);
     main.add(this.greeting); main.add(area); main.add(this.above); main.add(this.dock);
-    this.sidebar = new BoxRenderable(renderer, { id: "sidebar", flexShrink: 0, border: ["left"], borderColor: colors.line, paddingLeft: 1, paddingRight: 1, paddingTop: 1, flexDirection: "column" });
+    this.sidebar = new BoxRenderable(renderer, { id: "sidebar", flexShrink: 0, border: ["left"], borderColor: colors.line, paddingLeft: 1, paddingRight: 1, paddingTop: 1, flexDirection: "column", overflow: "hidden", backgroundColor: colors.background });
     this.sidebarRows = new Canvas(renderer, { id: "sidebar-rows", flexGrow: 1, colors });
+    this.sidebarRows.onSizeChange = () => this.paintStatus();
+    this.sidebar.onMouseDown = () => { if (this.controlShown && !this.dialogs.open) this.focusControl(); };
     this.sidebar.add(this.sidebarRows);
     middle.add(main); middle.add(this.sidebar);
     root.add(this.topbar); root.add(middle);
     renderer.root.add(root);
     this.dialogs = new DialogHost(renderer, colors, bindings, slot, () => this.dialogRows(), this.glyph);
     this.dialogs.onOpened = () => { this.composer.setCompletion(undefined); this.composer.area.blur(); this.composer.row.visible = false; this.paintAttachments(); this.layout(); };
-    this.dialogs.onClosed = () => { this.composer.row.visible = true; this.paintAttachments(); this.layout(); this.composer.focus(); };
+    this.dialogs.onClosed = () => {
+      this.composer.row.visible = true; this.paintAttachments(); this.layout();
+      // Dialogs temporarily own input; restoring the existing owner preserves a
+      // control-initiated approval without replacing or focusing the editor (Q24).
+      if (this.controlShown && this.controlHasFocus) this.focusControl(); else this.composer.focus();
+    };
     this.dialogs.onChrome = () => { this.paintEdges(); this.syncActivity(); };
+    // Native mouse selection can focus the textarea without going through an
+    // app shortcut. The actual input owner must also release panel actions (Q24).
+    this.composer.area.on("focused", () => { this.controlHasFocus = false; this.paintStatus(); });
     this.composer.onResize = () => this.paintAbove();
     this.composer.onOverflow = () => this.paintEdges();
     this.composer.onChange = () => this.paintGreeting();
@@ -164,6 +184,8 @@ export class Screen {
   get width(): number { return this.renderer.width; }
   get tier(): ScreenLayout["tier"] { return this.shape.tier; }
   get sidebarVisible(): boolean { return this.shape.tier === "sidebar"; }
+  get controlOpen(): boolean { return this.controlShown; }
+  get controlFocused(): boolean { return this.controlShown && this.controlHasFocus && !this.dialogs.open; }
   /** An empty session (the greeting may still be hidden by a draft). */
   get homeVisible(): boolean { return this.home !== undefined; }
   get greetingVisible(): boolean { return this.greeting.visible; }
@@ -184,9 +206,11 @@ export class Screen {
     this.renderer.setBackgroundColor(colors.background);
     for (const canvas of [this.topbar, this.greeting, this.pill, this.completion, this.queueRows, this.widgetRows, this.topEdge, this.bottomEdge, this.sidebarRows]) canvas.setColors(colors);
     this.sidebar.borderColor = colors.line;
+    this.sidebar.backgroundColor = colors.background;
     this.messages.setColors(colors);
     this.composer.setColors(colors);
     this.dialogs.setColors(colors);
+    this.paintStatus();
     this.paintEdges();
   }
 
@@ -197,15 +221,77 @@ export class Screen {
     this.syncActivity();
   }
 
-  toggleSidebar(): void { this.sidebarWanted = !this.sidebarWanted; this.layout(); }
+  toggleSidebar(): void {
+    if (this.controlShown) { this.closeControl(); return; }
+    this.sidebarWanted = !this.sidebarWanted; this.layout();
+  }
+
+  // --------------------------------------------------------------- controls
+  showControl(model: ControlPanelModel | undefined, tab: ControlTab = "goal"): void {
+    this.controlView.model = model; this.controlView.tab = tab; this.controlShown = true;
+    this.composer.setCompletion(undefined);
+    this.focusControl(); this.layout();
+  }
+
+  /** Snapshot updates never open the panel or take the user's input focus. */
+  setControlModel(model: ControlPanelModel | undefined): void { this.controlView.model = model; if (this.controlShown) this.paintStatus(); }
+
+  closeControl(): void { this.controlShown = false; this.focusComposer(); this.layout(); }
+
+  focusComposer(): void {
+    this.controlHasFocus = false;
+    if (!this.dialogs.open) this.composer.focus();
+    this.paintStatus();
+  }
+
+  private focusControl(): void {
+    this.controlHasFocus = true;
+    if (!this.dialogs.open) this.composer.area.blur();
+    this.paintStatus();
+  }
+
+  handleControlKey(key: KeyPress): boolean {
+    if (!this.controlShown || this.dialogs.open) return false;
+    if (key.chord === "f6") { if (this.controlHasFocus) this.focusComposer(); else this.focusControl(); return true; }
+    if (!this.controlHasFocus) return false;
+    if (key.chord === "escape") { this.focusComposer(); return true; }
+    if (key.chord === "q") { this.closeControl(); return true; }
+    if (key.chord === "tab" || key.chord === "shift+tab") this.controlView.changeTab(key.shift ? -1 : 1);
+    else if (key.chord === "left" || key.chord === "right") {
+      const step = key.chord === "left" ? -1 : 1;
+      if (this.controlView.tab === "context") this.controlView.changeLens(step); else this.controlView.changeTab(step);
+    } else if (key.chord === "up" || key.chord === "down") this.controlView.scroll(key.chord === "up" ? -1 : 1);
+    else if (key.chord === "pageup" || key.chord === "pagedown") this.controlView.scroll(key.chord === "pageup" ? -1 : 1, true);
+    else if (key.chord === "home" || key.chord === "end") this.controlView.edge(key.chord === "end");
+    else if (key.chord === "r" || key.chord === "i" || key.chord === "a") this.onControlAction?.(key.chord === "r" ? "refresh" : key.chord === "i" ? "interrupt" : "accept");
+    else {
+      // Let the same key reach the original editor after handing focus back.
+      // Modifier shortcuts remain the app's; panel navigation never eats typing.
+      if (key.text || key.chord === "enter") this.focusComposer();
+      return false;
+    }
+    this.paintStatus();
+    return true;
+  }
 
   // ------------------------------------------------------------------ layout
   private layout(): void {
     const w = this.renderer.width, h = this.renderer.height;
-    this.shape = screenLayout(w, h, this.sidebarWanted);
+    this.shape = screenLayout(w, h, this.sidebarWanted || this.controlShown);
     this.topbar.visible = this.shape.topbar;
-    this.sidebar.visible = this.shape.tier === "sidebar";
-    if (this.sidebar.visible) this.sidebar.width = this.shape.sidebarWidth;
+    const drawer = this.controlShown && this.shape.tier !== "sidebar";
+    // One sidebar changes parent at the responsive boundary. The drawer belongs
+    // to the transcript viewport, so even a growing composer cannot be covered.
+    const parent = drawer ? this.messagesArea : this.middle;
+    if (this.sidebar.parent !== parent) { this.sidebar.parent?.remove(this.sidebar); parent.add(this.sidebar); }
+    this.sidebar.position = drawer ? "absolute" : "relative";
+    this.sidebar.top = drawer ? 0 : undefined; this.sidebar.bottom = drawer ? 0 : undefined; this.sidebar.right = drawer ? 0 : undefined;
+    this.sidebar.zIndex = drawer ? 50 : 0;
+    this.sidebar.visible = (this.shape.tier === "sidebar" || drawer) && w > 0 && h > 3;
+    if (this.sidebar.visible) this.sidebar.width = drawer ? Math.min(w, sidebarContentWidth(w) + 1) : this.shape.sidebarWidth;
+    const compact = drawer && w < 6;
+    this.sidebar.border = compact ? [] : ["left"];
+    this.sidebar.paddingLeft = compact ? 0 : 1; this.sidebar.paddingRight = compact ? 0 : 1; this.sidebar.paddingTop = compact ? 0 : 1;
     // The draft may grow while the transcript keeps its minimum and the box keeps its edges.
     this.composer.setMaxLines(Math.min(draftMaxLines(h), h - (this.shape.topbar ? 1 : 0) - 2 - MIN_TRANSCRIPT_ROWS - this.aboveRows()));
     this.dialogs.layout();
@@ -231,8 +317,14 @@ export class Screen {
 
   private paintStatus(): void {
     const model = this.status;
-    if (!model) return;
-    if (this.topbar.visible) this.topbar.setRows([topbarRow(model, Math.max(1, this.renderer.width - 2))]);
+    if (model && this.topbar.visible) this.topbar.setRows([topbarRow(model, Math.max(1, this.renderer.width - 2))]);
+    if (this.controlShown) {
+      this.sidebar.borderColor = this.controlFocused ? this.colors.accent : this.colors.line;
+      this.sidebarRows.setRows(this.controlView.rows(this.sidebarRows.width, this.sidebarRows.height, this.controlFocused));
+      return;
+    }
+    this.sidebar.borderColor = this.colors.line;
+    if (!model) { this.sidebarRows.setRows([]); return; }
     if (this.sidebar.visible) {
       const width = Math.max(1, this.shape.sidebarWidth - 3);
       this.sidebarRows.setRows(sidebarLines(model, width, Math.max(0, this.renderer.height - 1)));
@@ -270,6 +362,10 @@ export class Screen {
     if (dialog) {
       left = [{ segs: [{ text: this.dialogs.title, role: "text", bold: true }], priority: 0, min: 8 }];
       if (this.dialogs.edgeHint) right.push({ segs: [{ text: this.dialogs.edgeHint, role: "muted" }], priority: 3, min: 10 });
+    } else if (this.controlShown && this.renderer.height <= 3) {
+      // No transcript rows remain for a drawer. Keep its state and explain how
+      // to recover on the existing edge, without putting control content in it.
+      left = [{ segs: [{ text: "Resize for control", role: "accent" }], priority: 0, min: 1 }];
     } else if (d.busy) {
       const seconds = Math.max(0, Math.floor((Date.now() - this.busySince) / 1000));
       left = [{ segs: [{ text: "●", role: "accent", spin: true }, { text: ` ${d.activity}`, role: "muted" }, { text: ` ${seconds}s`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
@@ -379,7 +475,7 @@ export class Screen {
   }
 
   private paintGreeting(): void {
-    const show = this.home !== undefined && !this.composer.text && !this.dialogs.open && this.renderer.height >= GREETING_MIN_ROWS;
+    const show = this.home !== undefined && !this.controlShown && !this.composer.text && !this.dialogs.open && this.renderer.height >= GREETING_MIN_ROWS;
     this.greeting.visible = show;
     if (!show) { if (this.entrance.running) this.finishEntrance(); return; }
     // The entrance plays once per screen, when the greeting first shows on a focused terminal.

package/src/tui/ui/status.ts

@@ -30,6 +30,7 @@ export interface StatusModel {
   readonly version: string;
   /** `/name`, else the first prompt; null for a session with neither. */
   readonly title: string | null;
+  readonly goal?: { readonly text: string; readonly status: string; readonly execution: string; readonly observations: number; readonly retries: number };
   readonly workspace: string;
   readonly workspaceShort: string;
   readonly branch: string | null;
@@ -176,6 +177,13 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
     ...(model.branch ? [[{ text: "⎇ ", role: "muted" }, { text: model.branch, role: "muted" }] as Line] : []),
   ] });
   const context = model.context;
+  if (model.goal) blocks.push({ list: false, items: [], head: [
+    [{ text: "Goal", role: "text", bold: true }, { text: ` · ${model.goal.status}`, role: model.goal.status === "verified" ? "success" : "warning" }],
+    ...wrap(firstLine(model.goal.text), w, 2).map(text => [{ text, role: "text" }] as Line),
+    [{ text: model.goal.execution, role: "muted" }],
+    [{ text: `${model.goal.observations} observations · ${model.goal.retries} retries`, role: "muted" }],
+    [{ text: "/control · goal, evidence, context", role: "muted" }],
+  ] });
   if (context) {
     const share = contextShare(context), est = context.estimated ? "~" : "";
     const filled = share === undefined ? 0 : Math.max(share > 0 ? 1 : 0, Math.round(share * w));