@@ -0,0 +1,151 @@
+import { test, expect, type ElectronApplication, type Page } from "@playwright/test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { launch, seedHome, tid, items } from "./support";
+
+// Native questions through the real CodexBackend, runner, IPC and UI (#276). The local executable below speaks
+// codex-cli 0.163.0's app-server protocol for `item/tool/requestUserInput` (experimental) the way its schema
+// describes it: questions with ids, headers, options, `isOther` and `isSecret`, answered with `{ answers }`.
+// It is a scripted fixture, not live-model evidence. Its log lives outside MODEX_HOME so the secret check
+// below can read every file Modex wrote.
+
+function fixture(dir: string): string {
+  const cli = path.join(dir, "codex-questions.cjs");
+  fs.writeFileSync(cli, `#!${process.execPath}
+const fs = require('node:fs');
+if (process.argv.includes('--version')) { console.log('codex-cli 0.163.0'); process.exit(0); }
+if (process.argv.includes('login') || process.argv.includes('auth')) { console.log('Logged in using ChatGPT'); process.exit(0); }
+const log = ${JSON.stringify(path.join(dir, "codex-replies.jsonl"))};
+const emit = (o) => process.stdout.write(JSON.stringify(o) + '\\n');
+const questions = [
+  { id: 'q-env', header: 'Environment', question: 'Which environment?', isOther: false, isSecret: false, options: [{ label: 'staging', description: 'Safe to try' }, { label: 'production', description: 'Live traffic' }] },
+  { id: 'q-token', header: 'Token', question: 'Paste the deploy token', isOther: true, isSecret: true, options: null },
+];
+let turn = 0, asked = 0, open = null;
+const cwds = new Map();
+require('node:readline').createInterface({ input: process.stdin }).on('line', (line) => {
+  const msg = JSON.parse(line);
+  const p = msg.params || {};
+  if (msg.method === 'initialize') return emit({ id: msg.id, result: { userAgent: 'codex-questions/0.163.0' } });
+  if (msg.method === 'initialized') return;
+  if (msg.method === 'account/read') return emit({ id: msg.id, result: { account: { type: 'chatgpt' }, requiresOpenaiAuth: true } });
+  if (msg.method === 'model/list') return emit({ id: msg.id, result: { data: [{ id: 'fixture', model: 'fixture', displayName: 'Fixture', isDefault: true }], nextCursor: null } });
+  if (msg.method === 'thread/start' || msg.method === 'thread/resume') {
+    const id = p.threadId || 'thr-' + cwds.size;
+    cwds.set(id, p.cwd || '');
+    return emit({ id: msg.id, result: { thread: { id } } });
+  }
+  if (msg.method === 'turn/start' && /modex-title-/.test(cwds.get(p.threadId) || '')) {
+    // Thread naming runs in its own folder and asks nothing.
+    const id = 'title-' + (++turn);
+    emit({ id: msg.id, result: { turn: { id } } });
+    emit({ method: 'item/completed', params: { threadId: p.threadId, turnId: id, item: { id: 'name-' + turn, type: 'agentMessage', text: 'Deploy', phase: 'final_answer' } } });
+    emit({ method: 'turn/completed', params: { threadId: p.threadId, turn: { id, status: 'completed', error: null } } });
+    return;
+  }
+  if (msg.method === 'turn/start') {
+    const id = 'turn-' + (++turn);
+    open = { thread: p.threadId, turn: id, request: 900 + (++asked), done: false };
+    emit({ id: msg.id, result: { turn: { id } } });
+    emit({ method: 'turn/started', params: { threadId: p.threadId, turn: { id } } });
+    emit({ id: open.request, method: 'item/tool/requestUserInput', params: { threadId: p.threadId, turnId: id, itemId: 'ask-' + asked, isBlocking: true, autoResolutionMs: null, questions } });
+    return;
+  }
+  const finish = (status, text) => {
+    if (!open || open.done) return;
+    open.done = true;
+    if (text) emit({ method: 'item/completed', params: { threadId: open.thread, turnId: open.turn, item: { id: 'say-' + turn, type: 'agentMessage', text, phase: 'final_answer' } } });
+    emit({ method: 'turn/completed', params: { threadId: open.thread, turn: { id: open.turn, status, error: null } } });
+  };
+  if (msg.method === 'turn/interrupt') { emit({ id: msg.id, result: {} }); return finish('interrupted'); }
+  if (open && msg.id === open.request && !msg.method) {
+    fs.appendFileSync(log, JSON.stringify({ request: msg.id, result: msg.result, error: msg.error }) + '\\n');
+    if (msg.result) finish('completed', 'Deploying to ' + msg.result.answers['q-env'].answers[0] + '.');
+    return;
+  }
+  if (msg.id !== undefined && msg.method) emit({ id: msg.id, error: { code: -32601, message: 'fixture does not implement ' + msg.method } });
+});
+`, { mode: 0o755 });
+  return cli;
+}
+
+type Reply = { request: number; result?: { answers: Record<string, { answers: string[] }> }; error?: { code: number; message: string } };
+const replies = (dir: string): Reply[] => {
+  const file = path.join(dir, "codex-replies.jsonl");
+  return fs.existsSync(file) ? fs.readFileSync(file, "utf8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line) as Reply) : [];
+};
+/** Every file under `dir`, read as text. */
+const everything = (dir: string): string => fs.readdirSync(dir, { recursive: true, withFileTypes: true })
+  .filter((entry) => entry.isFile()).map((entry) => fs.readFileSync(path.join(entry.parentPath, entry.name), "utf8")).join("\n");
+
+async function send(page: Page, text: string): Promise<void> {
+  await page.keyboard.press("Meta+n");
+  await expect(tid(page, "draft-view")).toBeVisible();
+  await tid(page, "composer-input").fill(text);
+  await tid(page, "send").click();
+}
+const currentRow = (page: Page) => page.locator('[data-testid="thread-row"][aria-current="true"]');
+
+test("Codex questions: the card answers by its schema, the CLI hears once, the secret stays out, Stop withdraws", async () => {
+  const { home } = seedHome({ default_backend: "codex", default_mode: "agent" });
+  const logs = fs.mkdtempSync(path.join(os.tmpdir(), "modex-e2e-codex-questions-"));
+  const statePath = path.join(home, "app/state.json");
+  const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+  state.settings.codex_bin = fixture(logs);
+  fs.writeFileSync(statePath, JSON.stringify(state));
+  let app: ElectronApplication | undefined;
+  try {
+    const opened = await launch(home); app = opened.app;
+    const page = opened.page;
+
+    // 1. The card shows each question with its own control; an incomplete answer is refused in place.
+    await send(page, "deploy it");
+    const card = items(page, "question").first();
+    await expect(tid(card, "question")).toHaveCount(2);
+    await expect(currentRow(page)).toHaveAttribute("data-status", "waiting");
+    await expect(tid(page, "turn-label")).toHaveText(/^Waiting for your answer · \d+s$/);
+    await card.getByRole("radio", { name: "staging" }).check();
+    await tid(card, "question-submit").click();
+    await expect(tid(card, "question-error")).toHaveText("Token needs an answer.");
+    expect(replies(logs)).toEqual([]);
+    const token = card.getByLabel("Token");
+    await expect(token).toHaveAttribute("type", "password");
+    await token.fill("s3cr3t-token");
+    await page.screenshot({ path: test.info().outputPath("codex-question-card.png") });
+    await tid(card, "question-submit").click();
+
+    // 2. Codex hears the answers once; the card shows them with the secret hidden; the turn carries on.
+    await expect(tid(card, "question-answer")).toHaveText(["staging", "(hidden)"]);
+    await expect(items(page, "assistant").last()).toContainText("Deploying to staging.");
+    await expect(currentRow(page)).toHaveAttribute("data-status", "idle");
+    expect(replies(logs)).toEqual([{ request: 901, result: { answers: { "q-env": { answers: ["staging"] }, "q-token": { answers: ["s3cr3t-token"] } } } }]);
+    // A second answer (an old window, or a double click) is refused and reaches nothing.
+    const threadId = (await currentRow(page).getAttribute("data-thread-id"))!;
+    const again = await page.evaluate(async (id) => {
+      const list = await window.modex!.invoke("thread:items", { threadId: id }) as { id: string; kind: string }[];
+      const asked = list.find((i) => i.kind === "question")!;
+      return window.modex!.invoke("thread:answer-question", { threadId: id, itemId: asked.id, answers: { "q-env": ["production"], "q-token": ["other"] } });
+    }, threadId);
+    expect(again).toEqual({ ok: false, reason: "already-resolved" });
+    expect(replies(logs)).toHaveLength(1);
+    await page.screenshot({ path: test.info().outputPath("codex-question-answered.png") });
+
+    // 3. Stop while a question waits: the card closes as stopped, and Codex gets an error, never an empty answer.
+    await send(page, "deploy again");
+    const second = items(page, "question").first();
+    await expect(tid(second, "question-submit")).toBeVisible();
+    await tid(page, "stop").click();
+    await expect(tid(second, "question-closed")).toHaveText("Not answered — the turn was stopped");
+    await expect(tid(second, "question-submit")).toHaveCount(0);
+    await expect(currentRow(page)).toHaveAttribute("data-status", "idle");
+    await expect.poll(() => replies(logs).length).toBe(2);
+    expect(replies(logs)[1]).toMatchObject({ request: 902, error: { code: -32000 } });
+
+    // Nothing Modex saved (threads, journal, state) holds the secret.
+    expect(everything(path.join(home, "app")).includes("s3cr3t-token")).toBe(false);
+  } finally {
+    await app?.close();
+    fs.rmSync(logs, { recursive: true, force: true });
+  }
+});
@@ -182,6 +182,27 @@ test("a delayed browser snapshot cannot replace an address being edited", async
   await expect(input).toHaveValue("https://example.com/fast");
 });
 
+test("a new tab's late focus never takes the caret from where you started typing", async () => {
+  // Hold animation frames, as Chromium does for an inactive or busy window.
+  await page.evaluate(() => {
+    const w = window as unknown as { __frames: FrameRequestCallback[]; __raf: typeof requestAnimationFrame };
+    w.__frames = []; w.__raf = window.requestAnimationFrame;
+    window.requestAnimationFrame = (callback) => { w.__frames.push(callback); return w.__frames.length; };
+  });
+  await page.keyboard.press("Meta+Shift+b");
+  await expect(tid(page, "workspace-address")).toBeFocused();
+  await tid(page, "composer-input").focus();
+  await page.evaluate(() => {
+    const w = window as unknown as { __frames: FrameRequestCallback[]; __raf: typeof requestAnimationFrame };
+    window.requestAnimationFrame = w.__raf;
+    for (const callback of w.__frames.splice(0)) callback(performance.now());
+  });
+  await expect(tid(page, "composer-input")).toBeFocused();
+  await page.keyboard.type("Keep this draft");
+  await expect(tid(page, "composer-input")).toHaveValue("Keep this draft");
+  await expect(tid(page, "workspace-address")).toHaveValue("");
+});
+
 test("superseded navigation, overlays, guest shortcuts and window destruction preserve browser lifecycle", async () => {
   const { createServer } = await import("node:http");
   const server = createServer((req, res) => { if (req.url === "/slow") return; res.writeHead(200, { "Content-Type": "text/html" }); res.end("<title>Fast destination</title><h1>Ready</h1>"); });
 
@@ -97,6 +97,7 @@ export function registerCommands(handle: RegisterCommand, {
   handle("thread:retry", ({ threadId }) => startTurn(threadId, runner.retry(threadId)));
   handle("thread:stop", ({ threadId }) => runner.stop(threadId));
   handle("thread:answer", ({ threadId, itemId, answer }) => runner.answer(threadId, itemId, answer));
+  handle("thread:answer-question", ({ threadId, itemId, answers }) => runner.answerQuestion(threadId, itemId, answers));
   handle("thread:update", ({ threadId, patch }) => runner.updateThread(threadId, patch));
   handle("thread:archive", ({ threadId, archived }) => runner.setArchived(threadId, archived));
   handle("thread:delete", async ({ threadId, removeWorktree }) => {
 
@@ -550,6 +550,7 @@ export class ClaudeBackend implements Backend {
           detail: shortJson(req.input ?? {}),
           canAlways: Boolean(req.permission_suggestions?.length),
           action: { backend: "claude", tool, title, cwd: ctx.cwd, input: req.input ?? {} },
+          ...(msg.request_id ? { native: { runtime: ctx.native("").runtime, request: msg.request_id, ...(req.tool_use_id ? { item: req.tool_use_id } : {}) } } : {}),
         };
         // The CLI may withdraw the prompt (`control_cancel_request`) while it waits: the sink closes its card,
         // this request is done, and no answer is sent, since the CLI ignores one for a request it cancelled.
 
@@ -6,13 +6,14 @@ import type { CliExecutable } from "../cli-path.js";
 import { generateTitle } from "../titles.js";
 import type { ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import type { Backend, ModelInfo, TitleOptions, TurnOptions, TurnResult, TurnSink } from "./types.js";
+import type { Backend, ModelInfo, NativeRequest, TitleOptions, TurnOptions, TurnResult, TurnSink } from "./types.js";
 import { LineBuffer, stderrTail } from "./types.js";
 import { codexCall, UsageMeter, withUsage } from "./usage.js";
 import { cliEnvironment, cliSpawn, health, installation } from "./health.js";
 import type { AgentActivity, BackendHealth } from "../../../shared/types.js";
 import type { MessagePhase, NativeRef, PlanStepStatus, SettledOutcome } from "../../../shared/conversation-events.js";
 import { boundOutput, byteLength, memoryEvidence } from "../../../shared/evidence.js";
+import { codexAnswerResponse, codexQuestions } from "../../../shared/human-requests.js";
 
 /**
  * Codex's own wording when the sign-in it loaded at startup no longer matches ~/.codex/auth.json
@@ -44,6 +45,11 @@ export class CodexBackend implements Backend {
   private userAgent: string | null = null;
   /** Opaque id of the running app-server process; native thread, turn and item ids are unique only within it. */
   private generation = "";
+  /**
+   * Server requests waiting on a person, keyed `generation:id`. Codex's `serverRequest/resolved` for one still
+   * here means Codex settled it itself (codex-cli 0.163.0): the card is withdrawn and no answer is sent.
+   */
+  private readonly openRequests = new Map<string, AbortController>();
 
   private get bin(): string { return typeof this.executable === "function" ? this.executable() : this.executable; }
 
@@ -344,6 +350,10 @@ export class CodexBackend implements Backend {
           }
           return;
         }
+        if (msg.method === "serverRequest/resolved") {
+          this.openRequests.get(`${runtime}:${String(p.requestId)}`)?.abort();
+          return;
+        }
         if (p.threadId && p.threadId !== tid) {
           const id = String(p.threadId);
           if (!agents.has(id)) return;
@@ -538,7 +548,19 @@ export class CodexBackend implements Backend {
   }
 
   private async handleServerRequest(msg: RpcMessage, sink: TurnSink): Promise<void> {
+    const key = `${this.generation}:${String(msg.id)}`;
+    const withdrawn = new AbortController();
+    this.openRequests.set(key, withdrawn);
+    try {
+      await this.answerServerRequest(msg, sink, withdrawn.signal);
+    } finally {
+      if (this.openRequests.get(key) === withdrawn) this.openRequests.delete(key);
+    }
+  }
+
+  private async answerServerRequest(msg: RpcMessage, sink: TurnSink, withdrawn: AbortSignal): Promise<void> {
     const p = (msg.params ?? {}) as Record<string, unknown>;
+    const native: NativeRequest = { runtime: this.generation, request: String(msg.id), ...(typeof p.itemId === "string" && p.itemId ? { item: p.itemId } : {}) };
     if (msg.method === "item/commandExecution/requestApproval") {
       const cmd = stripShell(String(p.command ?? ""));
       const cwd = typeof p.cwd === "string" && p.cwd ? p.cwd : undefined;
@@ -547,7 +569,9 @@ export class CodexBackend implements Backend {
         detail: [p.reason ? `Reason: ${String(p.reason)}` : "", `cwd: ${String(p.cwd ?? "")}`].filter(Boolean).join("\n"),
         canAlways: true,
         action: { backend: "codex", tool: "command", title: cmd, ...(cwd ? { cwd } : {}), input: { command: cmd } },
-      });
+        native,
+      }, withdrawn);
+      if (withdrawn.aborted) return;
       this.respond(msg.id, { decision: answer === "yes" ? "accept" : answer === "always" ? "acceptForSession" : "decline" });
     } else if (msg.method === "item/fileChange/requestApproval") {
       const grantRoot = typeof p.grantRoot === "string" && p.grantRoot ? p.grantRoot : undefined;
@@ -558,7 +582,9 @@ export class CodexBackend implements Backend {
         canAlways: true,
         // Paths only: the patch body stays out of the action, so no gate can forward it.
         action: { backend: "codex", tool: "fileChange", title: "apply file changes", input: { ...(paths.length ? { paths } : {}), ...(grantRoot ? { grantRoot } : {}) }, ...(grantRoot ? { escalation: true } : {}) },
-      });
+        native,
+      }, withdrawn);
+      if (withdrawn.aborted) return;
       this.respond(msg.id, { decision: answer === "yes" ? "accept" : answer === "always" ? "acceptForSession" : "decline" });
     } else if (msg.method === "item/permissions/requestApproval") {
       const permissions = requestedPermissions(p.permissions);
@@ -567,8 +593,22 @@ export class CodexBackend implements Backend {
         this.respond(msg.id, { permissions: {}, scope: "turn" });
         return;
       }
-      const answer = await sink.approval({ question: "Allow these additional permissions for this turn?", detail: JSON.stringify({ ...p, permissions }, null, 2), canAlways: false, action: { backend: "codex", tool: "permissions", title: "grant additional permissions", escalation: true } });
+      const answer = await sink.approval({ question: "Allow these additional permissions for this turn?", detail: JSON.stringify({ ...p, permissions }, null, 2), canAlways: false, action: { backend: "codex", tool: "permissions", title: "grant additional permissions", escalation: true }, native }, withdrawn);
+      if (withdrawn.aborted) return;
       this.respond(msg.id, { permissions: answer === "yes" ? permissions : {}, scope: "turn" });
+    } else if (msg.method === "item/tool/requestUserInput" && sink.question) {
+      // Experimental in codex-cli 0.163.0. A request Modex cannot read is declined whole, never half-answered.
+      const asked = codexQuestions(p);
+      if (!asked) {
+        sink.notice("warn", "Codex asked a question Modex could not read; it was declined.");
+        this.send({ id: msg.id, error: { code: -32602, message: "modex could not read this requestUserInput" } });
+        return;
+      }
+      const reply = await sink.question({ ...asked, native }, withdrawn);
+      if (withdrawn.aborted) return;
+      // A withdrawn question is an error reply, never an empty answer the model could take as the user's.
+      if ("answers" in reply) this.respond(msg.id, codexAnswerResponse(reply.answers));
+      else this.send({ id: msg.id, error: { code: -32000, message: reply.withdrawn === "stopped" ? "withdrawn by modex: the turn was stopped" : "withdrawn by modex: the turn ended before anyone answered" } });
     } else {
       sink.notice("warn", `Codex asked for ${msg.method}, which Modex does not support yet; declined.`);
       this.send({ id: msg.id, error: { code: -32601, message: `unsupported by modex: ${msg.method}` } });