@visual-z/xeno 0.3.0 → 0.5.0

package/src/apps/ui/app.ts

@@ -25,7 +25,7 @@ import { pickerRows } from "../../core/model-picker.ts";
 import { modelKey } from "../../core/session-position.ts";
 import { flattenTree, type TreeFilter, type TreeNode } from "../../core/session-tree.ts";
 import { selectSessions, type SessionSort } from "../../core/session-browser.ts";
-import { DISPLAY_SETTINGS, mergeSettings, settingValue, settingValues } from "../../core/settings.ts";
+import { DISPLAY_SETTINGS, settingValue, settingValues } from "../../core/settings.ts";
 import { THINKING_LEVELS, asThinkingLevel, supportedThinkingLevels } from "../../core/thinking.ts";
 import { builtinTheme } from "../../core/theme.ts";
 import { projectTranscript, type TranscriptItem } from "../../core/transcript.ts";
@@ -36,7 +36,7 @@ import { attachImageBytes, attachImageFile } from "../../runtime/images.ts";
 import { readClipboard, writeClipboard, type ClipboardContent } from "../../runtime/clipboard.ts";
 import { highlightCode, transformMermaid, warmSyntaxLanguages } from "../../runtime/rich-text.ts";
 import { SOURCE_PROVIDERS } from "../../runtime/model-data.ts";
-import { SUBSCRIPTION_OPTIONS, loginGitHubCopilot, startCallbackServer, XENO_VERSION } from "../../runtime/oauth.ts";
+import { SUBSCRIPTION_OPTIONS, subscriptionById, loginGitHubCopilot, startCallbackServer, XENO_VERSION } from "../../runtime/oauth.ts";
 import { reportedCost } from "../../runtime/usage.ts";
 import { fetchLatestVersion } from "../../runtime/update-check.ts";
 import { installKind, updateNotice, updatePlan } from "../../core/update-check.ts";
@@ -50,7 +50,8 @@ import { projectTrust } from "../../store/trust.ts";
 import { discoverResources, setResourceOverride } from "../../store/resource-index.ts";
 import { nextResourceOverride } from "../../core/resource-selection.ts";
 import { archiveSession, renameSession, scanSessionRoots, sessionRoots } from "../../store/session-browser.ts";
-import { discoverThemes, removeModelThinkingOverride, selectedThemePath, watchTheme, writeUserSettings, loadUiResources } from "../../store/resources.ts";
+import { discoverThemes, removeModelThinkingOverride, selectedThemePath, watchTheme, loadUiResources } from "../../store/resources.ts";
+import { commitUserSettings } from "../preferences.ts";
 import { fuzzyMatch } from "../../tui/fuzzy.ts";
 import type { DialogSpec, ListAction } from "../../tui/ui/dialog.ts";
 import { keyPress, bound, type KeyPress } from "../../tui/ui/keys.ts";
@@ -64,6 +65,7 @@ import { displayPath } from "../../tui/ui/paths.ts";
 import { approvalHeading, approvalItems, choiceFromValue } from "../approve.ts";
 import { completionAt, completionSources, commandEntries } from "../completions.ts";
 import { commandDefinition } from "../commands.ts";
+import { completionAction } from "../../core/completion-action.ts";
 import { expandInput } from "../input.ts";
 import type { TrustChoice } from "../project-trust.ts";
 import { describeError, firstLine } from "../render.ts";
@@ -79,6 +81,11 @@ import type { OAuthEffects, Ui } from "./surface.ts";
 import { styleTokens, terminalPalette, uiColors } from "./theme.ts";
 import { ImageCache } from "./image-cache.ts";
 import { ImageDraft } from "../image-draft.ts";
+import { sessionControl, type SessionControl, type ControlSnapshot } from "../../runtime/session-control.ts";
+import { controlModel } from "./control-model.ts";
+import type { ControlTab } from "../../tui/ui/control-panel.ts";
+import { programStatus } from "../../core/program-status.ts";
+import { ProgramStatusReporter } from "../../runtime/program-status.ts";
 import type { PictureSource } from "../../tui/ui/pictures.ts";
 import { DEFAULT_CELL } from "../../tui/ui/image-size.ts";
 import type { TerminalPalette } from "../../tui/ui/ink.ts";
@@ -110,7 +117,7 @@ export class InteractiveApp implements Ui {
   oauthEffects: OAuthEffects = { ...loginEffects };
   clipboardWriter: (text: string) => boolean | Promise<boolean> = writeClipboard;
   clipboardReader: () => Promise<ClipboardContent> = readClipboard;
-  /** Test seam for /login custom endpoints. */
+  /** Test seam for /provider custom endpoints. */
   connectFetch: ((input: string, init?: RequestInit) => Promise<Response>) | undefined;
   sessionName: string | null = null;
   queue: QueuedMessage[] = [];
@@ -138,6 +145,12 @@ export class InteractiveApp implements Ui {
   private paintTimer: ReturnType<typeof setTimeout> | undefined;
   /** Handoff-derived status (sidebar / top bar), refreshed single-flight and debounced (DoD 9). */
   private derived: ReturnType<typeof handoffStatus> | undefined;
+  private control: SessionControl | undefined;
+  private stopControl: (() => void) | undefined;
+  private controlSnapshot: ControlSnapshot | undefined;
+  private readonly program: ProgramStatusReporter | undefined;
+  private readonly stopOsc: (() => void) | undefined;
+  private programResult = false;
   private derivedKey = "";
   private derivedTimer: ReturnType<typeof setTimeout> | undefined;
   private derivedRun: Promise<void> | null = null;
@@ -191,10 +204,12 @@ export class InteractiveApp implements Ui {
   /** Set once the renderer is gone; late async work (timers, warmed grammars) must not touch it. */
   private disposed = false;
 
-  constructor(app: App, hooks: Hooks, renderer: CliRenderer) {
+  constructor(app: App, hooks: Hooks, renderer: CliRenderer, program?: ProgramStatusReporter) {
     this.app = app;
     this.hooks = hooks;
     this.renderer = renderer;
+    this.program = program;
+    this.stopOsc = program ? renderer.subscribeOsc(sequence => program.receive(sequence)) : undefined;
     this.closed = new Promise(resolve => { this.closedResolve = resolve; });
     this.branch = currentBranch(app.workspace);
     this.sessionName = app.args.sessionName || null;
@@ -202,6 +217,10 @@ export class InteractiveApp implements Ui {
     this.screen = new Screen(renderer, this.colors(), () => this.keymap().byAction, {
       codeBlock: (code, language) => highlightCode(code, language, (token, text) => this.app.ui?.style.token?.(token, text) ?? ANSI.token?.(token, text) ?? text),
     });
+    this.screen.onControlAction = action => {
+      if (action === "interrupt") this.interrupt();
+      else this.track(async () => { if (action === "refresh") await this.refreshControl(); else this.acceptControlCriterion(); });
+    };
     this.imageDraft = new ImageDraft(this.screen.composer);
     this.extensions = new ExtensionHost({
       dialog: spec => this.screen.dialogs.push(spec),
@@ -274,22 +293,28 @@ export class InteractiveApp implements Ui {
   redraw(): void { this.paint(); }
 
   askSecret(title: string, label: string, hint: string): Promise<string | undefined> {
+    const control = sessionControl(this.app.session); control.setWaiting("auth");
     return new Promise(resolve => this.screen.dialogs.push({ kind: "form", title, label, secret: true, hint,
-      onSubmit: value => resolve(value), onCancel: () => resolve(undefined) }));
+      onSubmit: value => { control.setWaiting(null); resolve(value); },
+      onCancel: () => { control.setWaiting(null); resolve(undefined); } }));
   }
   confirm(title: string, message: string): Promise<boolean> {
-    return new Promise(resolve => this.screen.dialogs.push({ kind: "confirm", title, message, onAnswer: yes => resolve(yes) }));
+    const control = sessionControl(this.app.session); control.setWaiting("question");
+    return new Promise(resolve => this.screen.dialogs.push({ kind: "confirm", title, message, onAnswer: yes => { control.setWaiting(null); resolve(yes); } }));
   }
   waiting(title: string, lines: readonly string[], onCancel: () => void, pasteLabel?: string, onPaste?: (value: string) => void): () => void {
+    const control = sessionControl(this.app.session); control.setWaiting("auth");
+    const cancel = () => { control.setWaiting(null); onCancel(); };
     const spec: DialogSpec = pasteLabel && onPaste
-      ? { kind: "form", title, label: pasteLabel, secret: true, intro: lines, hint: "waiting for the browser · paste the redirect URL + enter · esc cancel", onSubmit: onPaste, onCancel }
-      : { kind: "busy", title, message: lines.join("\n"), onCancel };
+      ? { kind: "form", title, label: pasteLabel, secret: true, intro: lines, hint: "waiting for the browser · paste the redirect URL + enter · esc cancel", onSubmit: onPaste, onCancel: cancel }
+      : { kind: "busy", title, message: lines.join("\n"), onCancel: cancel };
     this.screen.dialogs.push(spec);
-    return () => this.screen.dialogs.remove(spec);
+    return () => { this.screen.dialogs.remove(spec); control.setWaiting(null); };
   }
 
   // ----------------------------------------------------------------- lifecycle
   async start(): Promise<void> {
+    this.program?.start();
     this.applyConfiguration();
     this.followTheme();
     void this.detectPalette();
@@ -341,7 +366,12 @@ export class InteractiveApp implements Ui {
     this.abort?.abort();
     this.closedResolve();
   }
-  interrupt(): void { this.abort?.abort(); this.returnQueueToEditor(); }
+  interrupt(): void {
+    this.abort?.abort();
+    const control = sessionControl(this.app.session);
+    if (control.activeTurnId) control.interrupt(control.activeTurnId);
+    this.returnQueueToEditor();
+  }
 
   async settle(): Promise<void> {
     await this.hooks.cancelPendingOAuth(this.app);
@@ -356,6 +386,8 @@ export class InteractiveApp implements Ui {
 
   dispose(): void {
     this.disposed = true;
+    this.stopControl?.();
+    this.stopOsc?.(); this.program?.close();
     clearTimeout(this.paintTimer); clearInterval(this.retryTimer); clearTimeout(this.derivedTimer); this.derivedTimer = undefined;
     this.stopThemeWatch?.();
     this.renderer.off("theme_mode", this.terminalThemeChanged);
@@ -376,6 +408,7 @@ export class InteractiveApp implements Ui {
 
   // --------------------------------------------------------------- transcript
   async syncTranscript(): Promise<void> {
+    this.bindControl();
     const session = this.app.session, dir = this.app.logDir, node = session.state.node;
     if (dir !== this.historyDir || node !== this.historyNode) {
       const history = await readNodeHistory(dir, node);
@@ -509,7 +542,7 @@ export class InteractiveApp implements Ui {
     const app = this.app, spec = app.providerConfig.spec, budget = this.budget();
     const t = app.session.totals, cost = reportedCost(t, spec.price);
     const tools = items.filter(item => item.kind === "tool");
-    const extension = [this.extensions.status, app.credential.ok ? "" : "no provider · /login"].filter(Boolean).join(" · ");
+    const extension = [this.extensions.status, app.credential.ok ? "" : "no provider · /provider"].filter(Boolean).join(" · ");
     return {
       version: XENO_VERSION, title: this.sessionName ?? this.prompt, workspace: displayPath(app.workspace, homedir()),
       workspaceShort: shortPath(displayPath(app.workspace, homedir())), branch: this.branch,
@@ -519,6 +552,11 @@ export class InteractiveApp implements Ui {
         cost: cost.kind === "usd" && cost.amount >= 0.005 ? `~$${cost.amount.toFixed(2)}` : cost.kind === "partial" && cost.known >= 0.005 ? `≥$${cost.known.toFixed(2)}` : null } } : {}),
       tools: { running: tools.filter(tool => tool.status === "pending").length, done: tools.filter(tool => tool.status === "ok").length, failed: tools.filter(tool => tool.status === "error").length },
       ...(this.derived ?? {}),
+      ...(this.controlSnapshot?.goal ? { goal: { text: this.controlSnapshot.goal.text,
+        status: this.controlSnapshot.goal.state.status,
+        execution: this.inflight ? "running" : this.controlSnapshot.goal.state.execution?.reason ?? "idle",
+        observations: this.controlSnapshot.goal.state.progress.observations.length,
+        retries: this.controlSnapshot.goal.state.progress.unchanged_retries.length } } : {}),
       files: this.files,
       resources: { contextFiles: app.loadedContext.agents.map(file => basename(file.path)), skills: app.slash?.skills.size ?? 0, extensions: app.extensions?.loaded.length ?? 0 },
       ...(extension ? { extension } : {}),
@@ -557,7 +595,7 @@ export class InteractiveApp implements Ui {
    * per debounce window, one run at a time, and only while a surface shows it.
    */
   private requestDerived(): void {
-    if (this.disposed || this.screen.tier === "bare") return;
+    if (this.disposed || (this.screen.tier === "bare" && !this.screen.controlOpen)) return;
     if (this.derivedKey === this.derivedTarget()) return;
     if (this.derivedRun || this.derivedTimer) { this.derivedAgain = true; return; }
     // Throttle, not a pure debounce: the first change after a quiet spell refreshes at once,
@@ -571,8 +609,25 @@ export class InteractiveApp implements Ui {
     this.derivedLast = Date.now();
     const target = this.derivedTarget();
     this.derivedRun = (async () => {
-      try { this.derived = handoffStatus(await this.app.session.previewHandoff()); this.derivedKey = target; }
-      catch { /* preview needs a readable log; the status keeps its last state */ }
+      const session = this.app.session;
+      try {
+        const derived = handoffStatus(await session.previewHandoff());
+        const snapshot = await sessionControl(session).snapshot(false);
+        if (this.disposed || this.app.session !== session) return;
+        this.derived = derived; this.controlSnapshot = snapshot; this.derivedKey = target;
+        // Idle acceptance changes have no model delta. Reconcile terminal attention
+        // with the same evidence projection that refreshes the visible goal.
+        if (!this.inflight) this.program?.update(programStatus({ running: false, waiting: snapshot.waiting,
+          ...(snapshot.goal?.state.execution ? { outcome: snapshot.goal.state.execution } : {}),
+          ...(snapshot.goal ? { goal: snapshot.goal.state.status } : {}) }));
+        this.screen.setControlModel(controlModel(snapshot));
+      }
+      catch {
+        // Unavailable evidence cannot leave a stale verified goal visible.
+        if (this.disposed || this.app.session !== session) return;
+        this.controlSnapshot = undefined;
+        this.screen.setControlModel(undefined);
+      }
     })();
     await this.derivedRun;
     this.derivedRun = null;
@@ -587,6 +642,7 @@ export class InteractiveApp implements Ui {
   private onPaste(event: PasteEvent): void {
     const text = new TextDecoder().decode(event.bytes);
     if (this.screen.dialogs.open) { if (this.screen.dialogs.paste(text)) return; event.preventDefault(); return; }
+    this.screen.focusComposer();
     const paths = droppedImagePaths(text);
     if (paths) { event.preventDefault(); this.track(() => this.pasteClipboard({ files: paths })); }
   }
@@ -602,22 +658,25 @@ export class InteractiveApp implements Ui {
     if (bound(b, "app.exit", key) && !this.screen.dialogs.open && !this.screen.composer.text && !this.pendingImages.length) { this.requestShutdown(); return true; }
     if (bound(b, "app.suspend", key)) { this.suspend(); return true; }
     if (this.screen.dialogs.open) return this.screen.dialogs.key(key);
+    if (this.screen.handleControlKey(key)) return true;
     const composer = this.screen.composer;
     if (composer.completing) {
       if (key.chord === "up") { composer.moveCompletion(-1); return true; }
       if (key.chord === "down") { composer.moveCompletion(1); return true; }
       if (key.chord === "escape") { composer.setCompletion(undefined); return true; }
-      if (key.chord === "tab") { composer.acceptCompletion(); this.updateCompletion(); this.paint(); return true; }
-      if (key.chord === "enter" && /^\/\S*$/.test(composer.text)) {
+      if (key.chord === "tab" || key.chord === "enter") {
+        const kind = composer.completionView!.kind;
         const item = composer.acceptCompletion();
         if (item) {
-          const definition = commandDefinition(item.value.trim());
-          if (definition && "argumentHint" in definition && definition.argumentHint?.startsWith("<")) { this.updateCompletion(); return true; }
-          this.track(() => this.submit(item.value, "steering")); return true;
+          const definition = commandDefinition(composer.text);
+          const required = !!definition && "argumentHint" in definition && definition.argumentHint.startsWith("<");
+          if (completionAction(kind, key.chord, required) === "submit") {
+            const text = composer.text;
+            this.track(() => this.submit(text, "steering"));
+          } else { this.updateCompletion(); this.paint(); }
         }
+        return true;
       }
-      if (key.chord === "enter" && !composer.text.trimEnd().match(/^\/\S+\s*$/)) { composer.acceptCompletion(); this.updateCompletion(); return true; }
-      if (key.chord === "enter") { composer.setCompletion(undefined); }
     }
     if (bound(b, "app.palette", key)) { this.openPalette(); return true; }
     if (bound(b, "app.clear", key)) {
@@ -694,7 +753,7 @@ export class InteractiveApp implements Ui {
   async whenIdle(): Promise<void> {
     for (let round = 0; round < 50; round++) {
       const turn = this.turn, work = this.work.size;
-      await turn; await this.idle(); await this.app.session.whenIdle(); await this.app.extensions?.settle();
+      await turn; await this.control?.whenIdle().catch(() => {}); await this.idle(); await this.app.session.whenIdle(); await this.app.extensions?.settle();
       if (turn === this.turn && !this.inflight && work === this.work.size && !this.work.size) return;
     }
   }
@@ -743,12 +802,22 @@ export class InteractiveApp implements Ui {
   private async runPromptTurn(text: string, images: readonly ImageRef[] = [], skill?: import("../../core/skills.ts").Skill): Promise<void> {
     this.abort = new AbortController();
     this.inflight = true;
+    this.programResult = false;
+    this.program?.update(programStatus({ running: true }));
     this.executionKind = text.startsWith("!") ? "bash" : "model";
     this.paint();
     try {
       const sent = await this.hooks.run(this.app, text, this.abort.signal, this, images, skill);
+      if (!sent && !this.app.credential.ok) {
+        this.programResult = true; this.program?.update(programStatus({ running: false, waiting: "auth" }));
+      }
       if (sent && !this.abort.signal.aborted) await this.drainFollowUps();
+    } catch (error) {
+      this.programResult = true;
+      this.program?.update({ state: "error", msg: "Turn failed; inspect the session" });
+      throw error;
     } finally {
+      if (!this.programResult) this.program?.update(programStatus({ running: false }));
       await this.syncTranscript();
       this.abort = null;
       this.hooks.dropFileIndex(this.app.workspace);
@@ -956,15 +1025,118 @@ export class InteractiveApp implements Ui {
 
   // ---------------------------------------------------------------- approval
   ask(request: PermissionRequest): Promise<ApprovalChoice> {
+    this.program?.update(programStatus({ running: this.inflight, waiting: "permission" }));
     // While the dialog is open the pending call shows ◌: it is waiting on the person, not running.
     this.screen.messages.setWaiting(true);
-    const answered = (choice: ApprovalChoice) => { this.screen.messages.setWaiting(false); return choice; };
+    const present = (_id: string, resolve: (choice: ApprovalChoice) => void) => {
+      const spec: DialogSpec = { kind: "list", title: "Tool approval", search: false, tone: "warning", intro: approvalHeading(request).split("\n"),
+        items: approvalItems(request), onPick: item => resolve(choiceFromValue(item.value)), onCancel: () => resolve("deny") };
+      this.screen.dialogs.push(spec);
+      return () => { this.screen.messages.setWaiting(false); this.screen.dialogs.remove(spec); this.program?.update(programStatus({ running: this.inflight })); };
+    };
+    // Isolated skills and user shell commands retain their existing local approval lifecycle.
+    const control = sessionControl(this.app.session);
+    if (control.activeTurnId) return control.ask(request, present);
     return new Promise(resolve => {
-      this.screen.dialogs.push({ kind: "list", title: "Tool approval", search: false, tone: "warning", intro: approvalHeading(request).split("\n"),
-        items: approvalItems(request), onPick: item => resolve(answered(choiceFromValue(item.value))), onCancel: () => resolve(answered("deny")) });
+      let close: () => void;
+      close = present("local", choice => { close(); resolve(choice); });
     });
   }
 
+  private bindControl(): void {
+    const control = sessionControl(this.app.session);
+    if (this.control === control) return;
+    this.stopControl?.(); this.control = control; this.controlSnapshot = undefined;
+    this.screen.setControlModel(undefined);
+    const detachInput = control.attachInput(phase => this.pullQueued(phase));
+    const unsubscribe = control.subscribe(notice => {
+      if (this.disposed) return;
+      if (notice.method === "turn/started") this.program?.update(programStatus({ running: true }));
+      if (notice.method === "turn/error") {
+        this.programResult = true; this.program?.update({ state: "error", msg: "Turn failed; inspect the session" });
+        this.track(() => this.syncTranscript());
+      }
+      if (notice.method === "approval/request") this.program?.update(programStatus({ running: true, waiting: "permission" }));
+      if (notice.method === "thread/statusChanged" && "waiting" in notice.params)
+        this.program?.update(programStatus({ running: control.busy, waiting: notice.params["waiting"] as ControlSnapshot["waiting"] }));
+      // A remote client drives the same Session; local turns already have the shell's stream adapter.
+      if (!this.abort) {
+        if (notice.method === "turn/started") { this.inflight = true; this.executionKind = "model"; }
+        if (notice.method === "turn/completed") {
+          this.inflight = false; this.executionKind = "idle"; this.clearStream();
+          const outcome = notice.params["outcome"] as import("../../core/outcome.ts").ExecutionOutcome | undefined;
+          this.turn = this.continueRemoteTurn(control, outcome).catch(error => this.notice(describeError(error), "error"));
+        }
+        if (notice.method === "turn/event") {
+          const event = notice.params["event"] as import("../../runtime/loop.ts").LoopEvent;
+          this.observeEvent(event);
+          if (event.kind === "text_delta" || event.kind === "thinking_delta") this.pushDelta(event.kind === "text_delta" ? "text" : "thinking", event.text ?? "");
+          else if (event.kind === "discard") this.discardStream();
+          else if (event.kind === "progress") { if (event.progress) this.pushProgress(event.progress); }
+          else this.track(() => this.syncTranscript());
+        }
+      }
+      if (notice.method !== "turn/event") { this.derivedKey = ""; this.requestDerived(); this.paint(); }
+    });
+    this.stopControl = () => { detachInput(); unsubscribe(); };
+  }
+
+  private async continueRemoteTurn(control: SessionControl, outcome?: import("../../core/outcome.ts").ExecutionOutcome): Promise<void> {
+    // Completion is announced before the iterator releases execution. Follow-ups
+    // remain editor-owned until that release, preserving the existing queue contract.
+    await control.whenIdle().catch(() => {});
+    if (this.disposed || this.shutdownRequested || this.control !== control || this.inflight) return;
+    if (outcome?.status !== "completed") { this.returnQueueToEditor(); return; }
+    const batch = this.nextBatch("turn_end");
+    if (!batch.length) return;
+    this.queue = this.queue.filter(item => !batch.includes(item));
+    await this.runPromptTurn(batch.map(item => item.text).join("\n\n"), batch.flatMap(item => item.images ?? []));
+  }
+
+  observeEvent(event: import("../../runtime/loop.ts").LoopEvent): void {
+    if (event.kind === "done" || event.kind === "stop_and_ask") this.programResult = true;
+    if (event.kind === "done") this.program?.update(programStatus({ running: false,
+      ...(event.outcome ? { outcome: event.outcome } : {}), ...(event.request ? { goal: event.request.status } : {}) }));
+    if (event.kind === "stop_and_ask") this.program?.update(programStatus({ running: false, waiting: "question" }));
+  }
+
+  async openControl(tab: ControlTab = "goal"): Promise<void> {
+    this.bindControl();
+    if (!await this.refreshControl()) return;
+    this.screen.showControl(controlModel(this.controlSnapshot!), tab);
+    this.requestDerived();
+  }
+
+  private async refreshControl(): Promise<boolean> {
+    const control = sessionControl(this.app.session);
+    try {
+      const snapshot = await control.snapshot();
+      if (this.disposed || control !== sessionControl(this.app.session)) return false;
+      this.controlSnapshot = snapshot;
+      this.screen.setControlModel(controlModel(snapshot));
+      return true;
+    } catch (error) {
+      if (!this.disposed && control === sessionControl(this.app.session)) {
+        this.controlSnapshot = undefined;
+        this.screen.setControlModel(undefined);
+      }
+      throw error;
+    }
+  }
+
+  private acceptControlCriterion(): void {
+    const control = sessionControl(this.app.session), goal = this.controlSnapshot?.goal;
+    const criteria = goal?.state.acceptance?.criteria.filter(item => item.kind === "human" && item.status !== "pass" && item.status !== "accepted") ?? [];
+    if (this.inflight || !goal || !criteria.length) { this.toast("No human criterion ready for acceptance", "warning"); return; }
+    this.screen.dialogs.push({ kind: "list", title: "Accept a human criterion", search: false,
+      items: criteria.map(item => ({ value: item.id, label: item.description, description: item.status })),
+      onPick: async item => {
+        if (control !== sessionControl(this.app.session)) throw Error("Session changed; refresh the control panel");
+        await control.accept(goal.state.request.event, item.value);
+        await this.refreshControl();
+      } });
+  }
+
   // ----------------------------------------------------------------- palette
   private paletteInput(): PaletteInput {
     const current = modelKey(this.app.providerConfig.spec);
@@ -1027,42 +1199,22 @@ export class InteractiveApp implements Ui {
       keywords: `${row.model.provider} ${row.model.providerName}`, ...(row.current ? { hint: "● current" } : {}) }));
     items.push({ value: "login", label: "＋ Connect a provider…", section: "More", description: "subscription, API key, gateway or local server" });
     this.push({ kind: "list", title: `Model · ${rows.filter(row => row.model.ready).length} ready`, items, selected: current,
-      actions: [{ key: "ctrl+s", label: "save default", run: item => this.saveDefaultModel(item) }],
       onPick: async item => {
         if (item.value === "login") { this.openLogin(); return; }
         const spec = this.app.catalog.find(model => modelKey(model) === item.value);
         if (spec) await this.hooks.switchToModel(this.app, spec);
       } });
   }
-  private async saveDefaultModel(item: ListItem | undefined): Promise<void> {
-    const spec = item && this.app.catalog.find(model => modelKey(model) === item.value);
-    if (!spec || !this.app.ui) return;
-    const patch = { defaultModel: spec.id, defaultProvider: spec.provider };
-    await writeUserSettings(patch);
-    this.app.ui.userOverrides = { ...this.app.ui.userOverrides, ...patch };
-    this.app.ui.settings = { ...this.app.ui.settings, ...patch };
-    this.toast(`saved default model ${item.value}`, "success");
-  }
-
   openThinking(): void {
     const spec = this.app.providerConfig.spec, current = this.app.providerConfig.effort;
     this.push({ kind: "list", title: "Thinking", search: false, selected: current,
       items: THINKING_LEVELS.map(level => ({ value: level, label: level, disabled: !this.hooks.effortSupported(spec, level),
         ...(level === current ? { hint: "● current" } : !this.hooks.effortSupported(spec, level) ? { description: "not supported by this model" } : {}) })),
-      actions: [{ key: "ctrl+s", label: "save default", run: async item => {
-        const effort = item && asThinkingLevel(item.value);
-        if (!effort || !this.hooks.effortSupported(spec, effort) || !this.app.ui) return;
-        const patch = { modelThinkingLevels: { [modelKey(spec)]: effort } };
-        await writeUserSettings(patch);
-        this.app.ui.userOverrides = mergeSettings({ builtin: this.app.ui.userOverrides, user: patch });
-        this.app.ui.settings = mergeSettings({ builtin: this.app.ui.settings, user: patch });
-        this.toast(`saved default thinking ${effort}`, "success");
-      } }],
       onPick: async item => { const effort = asThinkingLevel(item.value) as Effort | undefined; if (effort) await this.hooks.applyThinking(this.app, effort, this); } });
   }
 
   openLogin(method?: "oauth" | "api_key"): void {
-    const providers = [...new Set(this.app.catalog.map(model => model.provider))];
+    const providers = [...new Set(this.app.catalog.map(model => model.provider))].filter(provider => !subscriptionById(provider));
     const status = (provider: string): string => {
       const spec = this.app.catalog.find(model => model.provider === provider);
       const resolved = spec ? this.app.credentialOf(spec) : undefined;
@@ -1105,13 +1257,12 @@ export class InteractiveApp implements Ui {
     const ready = this.app.catalog.filter(spec => this.app.credentialOf(spec).ok);
     const configured = this.app.ui?.settings.scopedModels;
     const checked = configured ? ready.filter(spec => configured.some(pattern => pattern === modelKey(spec) || pattern === spec.id)).map(modelKey) : ready.map(modelKey);
-    this.push({ kind: "list", title: "Models to cycle with alt+m", multi: true, checked, empty: "No available models. Use /login to add a credential.",
+    this.push({ kind: "list", title: "Models to cycle with alt+m", multi: true, checked, empty: "No available models. Use /provider to add a credential.",
       items: ready.map(spec => ({ value: modelKey(spec), label: spec.id, description: spec.provider, section: SOURCE_PROVIDERS[spec.provider]?.name ?? spec.provider })),
       onSubmitChecked: async values => {
-        await writeUserSettings({ scopedModels: values });
-        if (this.app.ui) { this.app.ui.settings = { ...this.app.ui.settings, scopedModels: values }; this.app.ui.userOverrides = { ...this.app.ui.userOverrides, scopedModels: values }; }
+        const saved = await commitUserSettings(this.app, { scopedModels: values });
         this.app.args.models = ""; this.app.args.modelsExplicit = false;
-        this.toast(`saved ${values.length} scoped models`, "success");
+        if (saved) this.toast(`saved ${values.length} scoped models`, "success");
       } });
   }
 
@@ -1121,7 +1272,7 @@ export class InteractiveApp implements Ui {
     const entries: [string, string, string][] = [
       ["theme", "Theme", settings.theme ?? "dark"],
       ["thinking", "Thinking", this.app.providerConfig.effort],
-      ["defaultModel", "Default model", settings.defaultModel ? `${settings.defaultProvider}/${settings.defaultModel}` : "automatic"],
+      ["defaultModel", "Model", modelKey(this.app.providerConfig.spec)],
       ["modelThinkingLevels", "Model thinking defaults", `${Object.keys(settings.modelThinkingLevels ?? {}).length} configured`],
       ["steeringMode", "Steering delivery", settings.steeringMode ?? "one-at-a-time"],
       ["followUpMode", "Follow-up delivery", settings.followUpMode ?? "one-at-a-time"],
@@ -1169,9 +1320,7 @@ export class InteractiveApp implements Ui {
               ui.userOverrides = { ...ui.userOverrides, modelThinkingLevels: loaded.userOverrides.modelThinkingLevels ?? {} };
             } else {
               const patch = { modelThinkingLevels: { [item.value]: choice.value as Effort } };
-              await writeUserSettings(patch);
-              ui.settings = mergeSettings({ builtin: ui.settings, user: patch });
-              ui.userOverrides = mergeSettings({ builtin: ui.userOverrides, user: patch });
+              await commitUserSettings(this.app, patch);
             }
             this.screen.dialogs.pop(); this.openModelThinkingDefaults();
           } });
@@ -1318,10 +1467,15 @@ function noticeOf(id: string, after: number, lines: string[], tone: Tone): Notic
 export async function runInteractive(app: App, hooks: Hooks, releaseEarlyTty?: () => void, renderer?: CliRenderer): Promise<void> {
   const fullscreen = (app.ui?.settings.tuiMode ?? "fullscreen") !== "regular";
   releaseEarlyTty?.();
+  // Capture the real writer before OpenTUI owns stdout, so OSC never becomes transcript text.
+  const terminalWrite = process.stdout.write.bind(process.stdout);
   const r = renderer ?? await createCliRenderer({ screenMode: fullscreen ? "alternate-screen" : "main-screen", exitOnCtrlC: false, exitSignals: [],
     // Performance (refactor-tui-dock-layout DoD 9): no console capture, no stats, no hover tracking; bursts coalesce at 60 fps.
     consoleMode: "disabled", openConsoleOnError: false, useMouse: true, enableMouseMovement: false, gatherStats: false, memorySnapshotInterval: 0, targetFps: 60, maxFps: 60 });
-  const ui = new InteractiveApp(app, hooks, r);
+  const program = new ProgramStatusReporter({ write: text => { terminalWrite(text); }, id: `xeno-${process.pid}`,
+    tty: !renderer && process.stdout.isTTY === true, mode: process.env["XENO_PROGRAM_STATUS"] ?? "auto",
+    multiplexed: Boolean(process.env["TMUX"] || process.env["STY"]) });
+  const ui = new InteractiveApp(app, hooks, r, program);
   const previousSay = app.io.say;
   app.io.say = line => ui.notice(line);
   const stop = (code: number) => { process.exitCode = code; ui.requestShutdown(); };

package/src/apps/ui/control-model.ts

@@ -0,0 +1,26 @@
+import type { ControlSnapshot } from "../../runtime/session-control.ts";
+import type { ControlPanelModel } from "../../tui/ui/control-panel.ts";
+
+export function controlModel(snapshot: ControlSnapshot): ControlPanelModel {
+  const goal = snapshot.goal, state = goal?.state, context = snapshot.context;
+  const progress = (label: string, sources: readonly { node: number; event: string }[]) => ({ label, count: sources.length, sources: sources.map(source => `${source.node}/${source.event}`) });
+  return { thread: snapshot.threadId, turn: snapshot.activeTurnId ?? state?.request.event ?? null,
+    goal: goal?.text ?? "Send a request to establish a goal.", status: state?.status ?? "idle",
+    execution: snapshot.waiting ? `waiting for ${snapshot.waiting}` : snapshot.activeTurnId ? "running" : state?.execution?.reason ?? "idle",
+    gaps: goal?.gaps ?? [], checks: state?.commands.map(command => `${command.status} · exit ${command.exit} · ${command.command} · ${command.source.node}/${command.source.event}`) ?? [],
+    progress: state ? [
+      progress("New observations", state.progress.observations),
+      progress("Artifact changes", state.progress.artifact_changes),
+      progress("Acceptance advances", state.progress.acceptance_advances),
+      progress("New diagnostics", state.progress.new_diagnostics),
+      progress("Unchanged retries", state.progress.unchanged_retries),
+      progress("Unknown diagnostics", state.progress.unknown_diagnostics),
+    ] : [],
+    context: [`${context.used} tokens (${context.countKind}); ${context.messages.length} messages; ${context.policy}`,
+      ...Object.entries(context.components).map(([name, count]) => `${name}: ~${count}`),
+      ...context.messages.map(message => `#${message.index} ${message.role}: ${message.sources.join(", ")}`)],
+    omitted: context.omitted.map(event => `${event.id}: ${event.type} (original stays in log)`),
+    history: context.sections.filter(section => section.total > 0).map(section => `${section.section}: ${section.retained}/${section.total}` +
+      (section.recovery ? ` · history(${JSON.stringify(section.recovery)})` : "")),
+  };
+}

package/src/apps/ui/surface.ts

@@ -19,6 +19,7 @@ export interface TurnSurface {
   syncTranscript(): Promise<void>;
   pushProgress?(progress: NonNullable<LoopEvent["progress"]>): void;
   pullQueued?(phase: Phase): Promise<UserInput | null>;
+  observeEvent?(event: LoopEvent): void;
 }
 
 export interface Ui extends TurnSurface {
@@ -52,6 +53,7 @@ export interface Ui extends TurnSurface {
   openFork(): Promise<void>;
   openTree(): Promise<void>;
   openResources(): Promise<void>;
+  openControl(tab?: "goal" | "progress" | "context"): Promise<void>;
   openTrust(): Promise<void>;
   openAttachments(): void;
 

package/src/core/completion-action.ts

@@ -0,0 +1,20 @@
+import { assertNever } from "./exhaustive.ts";
+
+/** D19: confirmation follows the selected completion, never the unfinished draft. */
+export function completionAction(kind: "command" | "argument" | "path", key: "enter" | "tab", requiresArgument: boolean): "insert" | "submit" {
+  if (key === "tab") return "insert";
+  switch (kind) {
+    case "command": return requiresArgument ? "insert" : "submit";
+    case "argument": return "submit";
+    case "path": return "insert";
+    default: return assertNever(kind, "completion kind");
+  }
+}
+
+/** Match the parser's exact identity before discoverable prefixes and substrings. */
+export function commandCompletionRank(name: string, query: string): number {
+  const canonical = name.toLowerCase(), typed = query.toLowerCase();
+  if (canonical === typed) return 0;
+  if (canonical.startsWith(typed)) return 1;
+  return typed.length > 1 && canonical.includes(typed) ? 2 : Number.POSITIVE_INFINITY;
+}