diff --git a/chief-of-staff-outside.js b/chief-of-staff-outside.js
index c96d7018..87dc7bad 100644
--- a/chief-of-staff-outside.js
+++ b/chief-of-staff-outside.js
@@ -1,15 +1,24 @@
 'use strict';
 
+const { NullLogger } = require('./logger');
+
 // Independent, listen-only inventory. No outside text enters the managed ledger.
 const SCOPE = { scope: 'chief-of-staff' };
 const ROOT = '/api/chief-of-staff/outside-sessions';
-const ROW_FIELDS = ['id', 'name', 'projectId', 'hostId', 'machine', 'directory', 'branch', 'state', 'since', 'updatedAt', 'source', 'outside', 'readOnly', 'tmuxSession', 'viewable', 'viewReason', 'endedAt'];
+const ROW_FIELDS = ['id', 'name', 'projectId', 'hostId', 'machine', 'directory', 'branch', 'state', 'since', 'updatedAt', 'source', 'outside', 'readOnly', 'tmuxSession', 'viewable', 'viewReason', 'endedAt', 'adoptable', 'adoptReason'];
 const MACHINE_FIELDS = ['hostId', 'machine', 'status', 'lastProbeAt', 'error'];
+const CLAUDE_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const pick = (row, fields) => Object.fromEntries(fields.filter(k => row[k] !== undefined).map(k => [k, row[k]]));
 
 class ChiefOfStaffOutside {
-  constructor({ relayTransport, onSnapshot }) {
+  constructor({ relayTransport, onSnapshot, resolveProject, log }) {
+    this.log = log || new NullLogger();
     this.transport = relayTransport;
+    this.resolveProject = resolveProject || (() => null);
+    // Row id -> Claude session id, ended rows only. Server-only: pick() keeps it out of every row,
+    // so no snapshot, frame, list(), detail() or tool result carries it. Replaced with each accepted snapshot.
+    this.claudeIds = new Map();
+    this.resuming = new Set();
     this.onSnapshot = onSnapshot;
     this.snapshot = { revision: -1, probeIntervalMs: 15000, sessions: [], machines: [] };
     this.stopped = true;
@@ -75,10 +84,19 @@ class ChiefOfStaffOutside {
       sessions: [...sessions.values()], machines: data.machines.filter(r => r && typeof r === 'object').map(r => pick(r, MACHINE_FIELDS)) };
   }
 
+  _claudeIdsOf(data) {
+    const ids = new Map();
+    for (const row of data.sessions) {
+      if (row?.state === 'ended' && typeof row.id === 'string' && typeof row.claudeSessionId === 'string') ids.set(row.id, row.claudeSessionId);
+    }
+    return ids;
+  }
+
   _replace(data, reseed = false) {
     const snapshot = this._snapshotOf(data);
     if (!snapshot || (!reseed && snapshot.revision <= this.snapshot.revision)) return false;
     this.snapshot = snapshot;
+    this.claudeIds = this._claudeIdsOf(data);
     this.onSnapshot?.(this.browserSnapshot());
     if (snapshot.sessions.some(r => r.state === 'ended') || this.turns.size) this._fillTurns();
     return true;
@@ -108,6 +126,51 @@ class ChiefOfStaffOutside {
     }, lastExcerpt: String(data.lastExcerpt || '').slice(-500) };
   }
 
+  // Resume an ended row in a new managed terminal on the same conversation. Never throws.
+  // The browser sends only the row id; the conversation id is eve's own, and it becomes a CLI argument.
+  async resume(id, size) {
+    const result = await this._resume(id, size);
+    // One line per outcome: the row id and the result. Never the Claude session id.
+    const { status, body } = result;
+    const attrs = { op: 'outside.resume', id, http_status: status };
+    if (status === 201) attrs.terminal_id = body.terminal.terminalId;
+    else attrs.error = body.error;
+    this.log[status >= 500 ? 'error' : status >= 400 ? 'warn' : 'info']('Outside resume', attrs);
+    return result;
+  }
+
+  async _resume(id, { cols, rows }) {
+    const refuse = (status, error, message) => ({ status, body: { error, message } });
+    const unavailable = (message) => refuse(409, 'outside_resume_unavailable', message);
+    const row = this.snapshot.sessions.find(r => r.id === id);
+    if (!row) return refuse(404, 'outside_session_not_found', 'That session is no longer in the list.');
+    if (row.state !== 'ended') return refuse(409, 'outside_session_live', 'This session is still running. Only an ended session can be resumed.');
+    const project = row.projectId ? this.resolveProject(row.projectId) : null;
+    if (!project) return unavailable("Not in a project, so it can't be resumed.");
+    if (row.hostId || project.hostId) return unavailable("On a host, so it can't be resumed here.");
+    const claudeSessionId = this.claudeIds.get(id);
+    if (typeof claudeSessionId !== 'string' || !CLAUDE_SESSION_ID.test(claudeSessionId)) {
+      return unavailable("Relay gave no conversation id, so it can't be resumed.");
+    }
+    if (this.resuming.has(id)) return refuse(409, 'outside_resume_busy', 'This session is already being resumed.');
+    this.resuming.add(id);
+    try {
+      const { status, data } = await this.transport.fetch('POST', '/api/terminals', {
+        templateId: 'claude-code', name: `${row.name} (resumed)`, directory: row.directory,
+        projectId: row.projectId, cols, rows, extraArgs: ['--resume', claudeSessionId],
+      });
+      if (status >= 200 && status < 300) {
+        return data?.terminalId ? { status: 201, body: { terminal: data } }
+          : refuse(502, 'resume_failed', 'Relay did not return a terminal.');
+      }
+      return refuse(status, data?.code || 'resume_failed', data?.error || `Relay answered ${status}.`);
+    } catch {
+      return { status: 502, body: { error: 'Service unavailable' } };
+    } finally {
+      this.resuming.delete(id);
+    }
+  }
+
   start() {
     if (!this.stopped) return;
     this.stopped = false;
diff --git a/chief-of-staff.js b/chief-of-staff.js
index e7c276fc..49cbcfd4 100644
--- a/chief-of-staff.js
+++ b/chief-of-staff.js
@@ -257,7 +257,7 @@ class ChiefOfStaff {
     this.state = { day: localDay(new Date(now())), calls: 0, rowCalls: 0, modelSessionId: null, personSessionId: null, limitNoticeDay: null };
     this._writeChain = Promise.resolve();
 
-    this.outside = new ChiefOfStaffOutside({ relayTransport, onSnapshot: (snapshot) => {
+    this.outside = new ChiefOfStaffOutside({ relayTransport, log: this.log, resolveProject: (id) => this.resolveProject(id), onSnapshot: (snapshot) => {
       this._fanOut({ type: 'cos_outside_sessions', ...snapshot });
       this._emitStatus();
     } });
diff --git a/devboxverify/README.md b/devboxverify/README.md
index 53f517cb..fb39a009 100644
--- a/devboxverify/README.md
+++ b/devboxverify/README.md
@@ -1039,7 +1039,7 @@ and within 60 s each folder must show an Ended row under the Ended heading (`rai
   Both of its Claudes (console and host) are cleaned up the same way.
 
 **outside-thread.** An outside Claude with no tmux opens as a read-only thread
-(G6.96, simple path). Not a screen journey (600 s). Same BLOCKED rule for a relay
+(G6.96, simple path). Not a screen journey (720 s). Same BLOCKED rule for a relay
 with no outside inventory, and BLOCKED when claude is not on PATH. It makes a
 scratch git folder in Acme Corp with an empty `keepalive.log` and starts
 `claude -p --model haiku --permission-mode default --setting-sources project,local
@@ -1065,13 +1065,38 @@ the Ended group (heading `Ended`), is a `div` with no button, and its line 2 end
 60 s; eve reads it from relay once per ended row), and line 3 (`data-kind="last-turn"`)
 must show it. Last it asks the Chief of Staff `Summarize the outside session <name>.
 Quote its last reply.`; the `reply` post (up to 120 s) must carry the marker.
+The only button beside the ended row is `Resume <name> in a terminal` (G6.106). The
+journey taps it; eve's `POST /api/outside-sessions/:id/resume` must answer with a
+terminal, its tab must become active, and the terminal (xterm rows plus scrollback,
+whitespace removed) must show the marker from the ended conversation within 120 s. A
+folder-trust prompt is answered once. The journey then closes the tab and the tab must
+leave. A cleanup closes the resumed terminal on any path.
 - Lives in: `public/outside-thread.js`; `public/panes/outside-thread-pane.js`;
-  `routes/index.js` (transcript route); relay's outside transcript route.
+  `routes/index.js` (transcript and resume routes); `chief-of-staff-outside.js` (`resume`); relay's outside transcript route.
 - Traps: BLOCKED setup V-COS; BLOCKED when claude is not on PATH; no NOTRUN path.
   One cleanup, which also runs on FAIL and on timeout, ends the process group
   and then removes the scratch folder. Run it alone:
   `node devboxverify/main.js --only outside-thread`.
 
+**outside-adopt.** An idle outside Claude is adopted from the rail (G6.107, simple
+path). Not a screen journey (480 s). Same BLOCKED rule for a relay with no outside
+inventory, and BLOCKED when tmux or claude is not on PATH. It makes a scratch git folder
+in Acme Corp and starts `claude --model haiku --permission-mode default "Reply with exactly
+verify-<nonce>-adopt and nothing else."` in a detached tmux session, with the stack's
+broker wiring (BLOCKED when the reply never comes). A `cos_outside_sessions` frame must
+list the folder as `idle`, and the rail row must show `Adopt <name>` (a row with
+`adoptable` false or absent fails, naming relay's reason). The journey taps it;
+eve's `POST /api/outside-sessions/:id/adopt` must answer 201 with a `sessionId` and no
+`claudeSessionId`. Then the Outside row must leave the rail, `Drop in to <name>` must
+show under Idle, the tmux session must end (the pane's claude exited), and
+`relay audit --event session_adopt` must hold an `ok` row since the tap. A model id that is
+not a `claude-*` id makes relay answer `model_unknown`, and the journey FAILs with that text.
+A cleanup deletes the adopted session; the usual one ends tmux and removes the folder and the
+transcript.
+- Lives in: `public/agent-board.js`; `routes/index.js` (adopt route); `chief-of-staff-outside.js` (`adoptable`, `adoptReason`); relay's `POST /api/sessions/adopt`.
+- Traps: BLOCKED setup V-COS; no NOTRUN path. Run it alone:
+  `node devboxverify/main.js --only outside-adopt`.
+
 **cos-outside-hooks.** An outside Claude's hook report moves its row at once
 (G6.93, power path). Not a screen journey (360 s). Same BLOCKED
 rule for a relay with no outside inventory. It makes a scratch git folder in Acme
diff --git a/devboxverify/journeys-cos-outside.js b/devboxverify/journeys-cos-outside.js
index 93d5c340..6371b050 100644
--- a/devboxverify/journeys-cos-outside.js
+++ b/devboxverify/journeys-cos-outside.js
@@ -22,6 +22,7 @@ const CLAUDE_MODEL = 'haiku';
 const INVENTORY_WITHIN_MS = 40000; // two probe intervals of 15 s, plus the first snapshot
 const TRUST_WITHIN_MS = 30000;
 const TRUST_MAX_DOWNS = 4;
+const READY_WITHIN_MS = 30000; // the input box, after start-up and the MCP servers
 const ROW_WITHIN_MS = 60000; // a probe interval of 15 s, claude start-up, and an ssh probe
 const REPLY_WITHIN_MS = 120000;
 const COS_TURN_WITHIN_MS = 120000;
@@ -132,7 +133,7 @@ async function pane(tmux, name) {
 // Starts `claude --model haiku <prompt>` in a detached tmux session and answers
 // the folder-trust prompt if it comes. Returns { trusted } once the prompt text
 // is on the pane or the trust bound passes.
-async function startClaude(env, tools, { name, dir, prompt, settings }) {
+async function startClaude(env, tools, { name, dir, prompt, settings, asPerson = false }) {
   // Default permission mode: the machine's own mode (auto, say) may never show a permission prompt.
   const args = ['--model', CLAUDE_MODEL, '--permission-mode', 'default'];
   if (settings) args.push('--settings', settings);
@@ -142,16 +143,19 @@ async function startClaude(env, tools, { name, dir, prompt, settings }) {
   const sessionId = crypto.randomUUID();
   tools.claudeIds.push({ id: sessionId, journey: tools.journey });
   args.push('--session-id', sessionId);
-  args.push(prompt);
+  // asPerson: no prompt argument. A person types into the ready prompt, after the MCP servers are up; an argv prompt is
+  // answered within a second, and relay vetoes an adopt for a child that started after the first reply.
+  if (!asPerson) args.push(prompt);
   const quote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
   env.step(`start ${name}`);
+  // asPerson: a person's terminal has neither variable; the tmux server inherits them from an agent session, and relay refuses an "sdk-cli" entrypoint.
   // A running tmux server does not inherit the client's environment, so a stack's
   // spool goes in with -e. The spool defaults to a folder in the stack's relay config dir.
   const spool = env.stack ? (env.stack.outsideSpool || path.join(env.relayConfigDir, 'outside-reports')) : null;
   const spoolEnv = spool ? ['-e', `RELAY_OUTSIDE_SPOOL=${spool}`] : [];
   // A stack run's broker wiring goes in through the shell command, which reads the token file itself.
   await writeOutsideSettings(env, dir);
-  await exec(tools.tmux, ['new-session', '-d', ...spoolEnv, '-s', name, '-x', '200', '-y', '50', '-c', dir, `${shellPrefix(env)}exec ${quote(tools.claude)} ${args.map(quote).join(' ')}`],
+  await exec(tools.tmux, ['new-session', '-d', ...spoolEnv, '-s', name, '-x', '200', '-y', '50', '-c', dir, `${shellPrefix(env)}exec ${asPerson ? 'env -u CLAUDE_CODE_ENTRYPOINT -u CLAUDECODE ' : ''}${quote(tools.claude)} ${args.map(quote).join(' ')}`],
     { env: cleanEnv(), timeout: 20000 });
   tools.sessions.push(name);
   let trusted = false;
@@ -171,8 +175,14 @@ async function startClaude(env, tools, { name, dir, prompt, settings }) {
       }
       return null;
     }
+    if (asPerson) return !TRUST_PROMPT.test(text) && /\? for shortcuts/.test(text) ? true : null;
     return text.includes(prompt.slice(-24)) ? true : null;
-  }, { timeoutMs: TRUST_WITHIN_MS, intervalMs: 500 });
+  }, { timeoutMs: asPerson ? TRUST_WITHIN_MS + READY_WITHIN_MS : TRUST_WITHIN_MS, intervalMs: 500 });
+  if (asPerson) {
+    // Waits: none possible: a terminal UI has no signal. The poll above is a bounded pane capture for the input box.
+    await exec(tools.tmux, ['send-keys', '-t', name, '-l', prompt], { timeout: 10000 });
+    await exec(tools.tmux, ['send-keys', '-t', name, 'Enter'], { timeout: 10000 });
+  }
   return { trusted };
 }
 
@@ -685,8 +695,10 @@ async function outsideThread(env) {
   if (!/^Ended\b/.test(endedHead)) problems.push(`the group holding the ended row is headed "${endedHead}", not Ended`);
   const endedMeta = (await metaOf(endedRow.first())).split(' · ').pop();
   if (endedMeta !== 'Ended') problems.push(`the ended row's line 2 ends with "${endedMeta}", not Ended`);
+  // G6.106: the row is no button, and the only button beside it is Resume.
+  const besideEnded = group.locator('.agent-row-wrap').filter({ has: page.locator('[data-state="ended"]').filter({ hasText: base }) }).getByRole('button');
   if ((await endedRow.first().evaluate((el) => el.tagName)) !== 'DIV' || (await endedRow.first().locator('button').count()) > 0
-    || (await group.locator('.agent-row-wrap').filter({ has: endedRow.first() }).getByRole('button').count()) > 0) problems.push('the ended row is a button or has a button beside it');
+    || (await besideEnded.count()) !== 1 || !/^Resume .+ in a terminal$/.test((await besideEnded.first().getAttribute('aria-label')) || '')) problems.push('the ended row is a button, or the only button beside it is not Resume');
 
   env.step('read the last turn on the Ended row');
   const withTurn = await poll(async () => seen.sessions.find((s) => s.id === endedFrame.id && typeof s.lastExcerpt === 'string' && s.lastExcerpt.includes(marker)) || null,
@@ -705,10 +717,179 @@ async function outsideThread(env) {
   if (post.kind !== 'reply') problems.push(`the summary question posted "${post.kind}", want reply: "${summary.slice(0, 160)}"`);
   else if (!summary.includes(marker)) problems.push(`the summary reply does not carry ${marker}: "${summary.slice(0, 200)}"`);
 
+  env.step('tap Resume on the Ended row');
+  // Registered before the tap: whatever terminal the answer names is closed, even on a failure path.
+  let resumedId = '';
+  env.cleanup('close the resumed terminal', async () => { if (resumedId) await env.api.closeTerminal(resumedId).catch(() => {}); });
+  const answered = page.waitForResponse((r) => r.request().method() === 'POST' && r.url().includes(`/api/outside-sessions/${encodeURIComponent(endedFrame.id)}/resume`), { timeout: GONE_WITHIN_MS })
+    .then((r) => r.json()).catch(() => null);
+  if ((await besideEnded.count()) !== 1) return result(id, FAIL, `${problems.join('; ')}${problems.length ? '; ' : ''}no single Resume button beside the ended row for ${base}, so Resume was not tapped`);
+  const clickedAt = Date.now();
+  await besideEnded.first().click({ timeout: 5000 });
+  const answer = await answered;
+  resumedId = answer?.terminal?.terminalId || '';
+  if (!resumedId) return result(id, FAIL, `${problems.join('; ')}${problems.length ? '; ' : ''}Resume on ${base} opened no terminal (answer: ${JSON.stringify(answer || null).slice(0, 160)})`);
+  const tabOpen = await poll(async () => (await page.locator('.tab.active').and(page.locator(`[data-tab-id="${resumedId}"]`)).count()) > 0 || null, { timeoutMs: TRUST_WITHIN_MS, intervalMs: 250 });
+  if (!tabOpen) return result(id, FAIL, `${problems.join('; ')}${problems.length ? '; ' : ''}no active terminal tab for the resumed ${base} within ${TRUST_WITHIN_MS / 1000}s of Resume`);
+
+  env.step('wait for the conversation in the terminal');
+  const termPane = page.locator('#terminal');
+  let trustAnswered = false;
+  const history = await poll(async () => {
+    // xterm wraps rows even mid-word: compare with whitespace gone, over the rows and the scrollback.
+    const visible = await termPane.innerText({ timeout: 2000 }).catch(() => '');
+    const buffered = await page.evaluate(() => {
+      const b = window.client?.terminalManager?.activeTerm?.()?.buffer?.active;
+      if (!b) return '';
+      let out = '';
+      for (let i = 0; i < b.length; i++) out += (b.getLine(i)?.translateToString(true) || '') + '\n';
+      return out;
+    }).catch(() => '');
+    const flat = `${visible}${buffered}`.replace(/\s+/g, '');
+    if (flat.includes(marker)) return true;
+    if (!trustAnswered && /trust/i.test(flat)) {
+      trustAnswered = true;
+      await termPane.locator('.xterm-screen').filter({ visible: true }).last().click({ timeout: 5000 });
+      await page.keyboard.press('Enter');
+    }
+    return null;
+  }, { timeoutMs: Math.max(1, clickedAt + REPLY_WITHIN_MS - Date.now()), intervalMs: 500 });
+  if (!history) problems.push(`"${marker}" is not in the resumed terminal within ${REPLY_WITHIN_MS / 1000}s of Resume${trustAnswered ? ' (a trust prompt was answered)' : ''}`);
+
+  env.step('close the resumed terminal');
+  await page.locator('.tab.active .tab-close').click({ timeout: 5000 });
+  const gone = await expect(page.locator(`[data-tab-id="${resumedId}"]`)).toHaveCount(0, { timeout: GONE_WITHIN_MS }).then(() => true, () => false);
+  if (!gone) problems.push(`the tab for terminal ${resumedId} is still open ${GONE_WITHIN_MS / 1000}s after Close`);
+
   if (problems.length) return result(id, FAIL, problems.join('; '));
   return result(id, PASS, `the row for ${base} read Read-only thread; its thread showed a You entry with the prompt, a Claude entry carrying ${marker} with no script, iframe, img or on* attribute ("${sample}") and a Tool entry shown as a closed details or a short pre, with no textbox, Send or Stop; `
     + `once the claude ended the tab closed with "${notice}" within ${GONE_WITHIN_MS / 1000}s; `
-    + `an ended row for ${base} sat under Ended with Ended in line 2 and no button, line 3 showed ${marker}, and the Chief of Staff's summary quoted it`);
+    + `an ended row for ${base} sat under Ended with Ended in line 2 and Resume as its only button, line 3 showed ${marker}, and the Chief of Staff's summary quoted it; `
+    + `Resume opened a terminal tab that held ${marker} from the ended conversation, and closing it closed the tab`);
+}
+
+// The assistant records of one conversation's transcript (~/.claude/projects/*/<id>.jsonl). `real` is true when a
+// record from a model holds the marker; `synthetic` lists the text of records Claude wrote itself (model "<synthetic>").
+async function assistantReplies(claudeId, marker) {
+  const root = path.join(os.homedir(), '.claude', 'projects');
+  const out = { real: false, synthetic: [] };
+  let dirs;
+  try { dirs = await fs.promises.readdir(root); } catch { return out; }
+  for (const dir of dirs) {
+    let text;
+    try { text = await fs.promises.readFile(path.join(root, dir, `${claudeId}.jsonl`), 'utf8'); } catch { continue; }
+    for (const line of text.split('\n')) {
+      let rec;
+      try { rec = JSON.parse(line); } catch { continue; }
+      if (!rec || rec.type !== 'assistant' || !rec.message) continue;
+      const content = rec.message.content;
+      const said = Array.isArray(content) ? content.filter((c) => c && c.type === 'text').map((c) => c.text).join('\n') : String(content || '');
+      if (rec.message.model === '<synthetic>') out.synthetic.push(said.trim());
+      else if (said.includes(marker)) out.real = true;
+    }
+  }
+  return out;
+}
+
+// G6.107, the simple path: an idle interactive Claude started in tmux under Acme shows Adopt on the
+// rail. One tap and relay takes it over: the outside row goes, the process in the pane exits, and the
+// agent shows under Idle with Drop in. Waits: the outside row's state from the captured frames, the
+// button and the managed row by locator, the eve route's answer by waitForResponse, the pane's exit by
+// the tmux session's end, relay audit by CLI exit. Claude's first reply and its folder-trust prompt
+// have no hook, so they are bounded polls, as outside-thread uses.
+async function outsideAdopt(env) {
+  const id = 'outside-adopt';
+  if (env.cosSetupProblem) return result(id, BLOCKED, env.cosSetupProblem);
+  const tools = newTools(env, id);
+  if (tools.problem) return result(id, BLOCKED, tools.problem);
+  if (!env.relayBin) return result(id, BLOCKED, 'no relay binary to read the audit with');
+
+  const marker = `verify-${env.nonce}-adopt`;
+  const branch = `verify-${env.nonce}-adopt`;
+  const tmuxName = `verify-${env.nonce}-outside-adopt`;
+  const held = { sessionId: '' };
+  // Registered before the tap: the managed session relay makes is deleted even on a failure path.
+  env.cleanup('delete the adopted session', async () => { if (held.sessionId) await require('./journey-kit').deleteSession(env, held.sessionId); });
+
+  const page = await env.newPage();
+  const seen = frames(page);
+  await openEve(page, env);
+  await openChiefOfStaff(page, env);
+  const blocked = await inventoryProblem(seen);
+  if (blocked) return result(id, BLOCKED, blocked);
+
+  env.step('create the folder');
+  const dir = await kit().scratchFolder(env, 'outside-adopt');
+  await gitFolder(dir, branch);
+  const base = path.basename(dir);
+  const started = await startClaude(env, tools, { name: tmuxName, dir, prompt: `Reply with exactly ${marker} and nothing else.`, asPerson: true });
+
+  env.step('wait for the outside reply');
+  // Waits: none possible for model output; a bounded read of the conversation's transcript. The prompt sits in the
+  // transcript and on the pane too, so only an assistant record counts, and a <synthetic> one (a login or API
+  // error Claude writes itself) is no model answer.
+  const claudeId = tools.claudeIds[tools.claudeIds.length - 1].id;
+  const replied = await poll(async () => {
+    const got = await assistantReplies(claudeId, marker);
+    return got.real || got.synthetic.length ? got : null;
+  }, { timeoutMs: REPLY_WITHIN_MS, intervalMs: 1000 });
+  if (!replied) return result(id, BLOCKED, `the outside claude did not reply ${marker} within ${REPLY_WITHIN_MS / 1000}s (model output${started.trusted ? '; a trust prompt was answered' : ''})`);
+  if (!replied.real) return result(id, BLOCKED, `the outside claude answered "<synthetic>": ${replied.synthetic[0]}`);
+
+  env.step('wait for the idle row');
+  const listed = await poll(async () => seen.sessions.find((s) => s.state === 'idle' && String(s.directory || '').includes(base)) || null,
+    { timeoutMs: ROW_WITHIN_MS + IDLE_WITHIN_MS, intervalMs: 500 });
+  if (!listed) return result(id, FAIL, `no cos_outside_sessions frame listed an idle claude in ${base} within ${(ROW_WITHIN_MS + IDLE_WITHIN_MS) / 1000}s of its reply`);
+  const adoptButton = page.getByTestId(`rail-adopt-${listed.id}`);
+  const shown = await expect(adoptButton).toBeVisible({ timeout: ROW_WITHIN_MS }).then(() => true, () => false);
+  if (!shown) {
+    const why = await page.getByTestId(`rail-adopt-reason-${listed.id}`).textContent({ timeout: 1000 }).catch(() => '');
+    return result(id, FAIL, `the idle row for ${base} shows no Adopt button${why ? ` (its line: "${why.trim()}")` : ''} (adoptable: ${JSON.stringify(listed.adoptable)}, reason: ${JSON.stringify(listed.adoptReason)})`);
+  }
+  const label = (await adoptButton.getAttribute('aria-label')) || '';
+  const name = label.replace(/^Adopt /, '');
+
+  env.step('tap Adopt');
+  const sentAt = Date.now();
+  const answered = page.waitForResponse((r) => r.request().method() === 'POST' && r.url().includes(`/api/outside-sessions/${encodeURIComponent(listed.id)}/adopt`), { timeout: 90000 })
+    .then(async (r) => ({ status: r.status(), body: await r.json().catch(() => null) })).catch(() => null);
+  await adoptButton.click({ timeout: 5000 });
+  const answer = await answered;
+  held.sessionId = (answer && answer.body && answer.body.sessionId) || '';
+  const problems = [];
+  if (!answer || answer.status !== 201 || !held.sessionId) {
+    return result(id, FAIL, `POST /api/outside-sessions/<id>/adopt answered ${answer ? answer.status : 'nothing'} (${JSON.stringify(answer && answer.body || null).slice(0, 200)})`);
+  }
+  if (answer.body && 'claudeSessionId' in answer.body) problems.push('the 201 carried claudeSessionId');
+
+  env.step('wait for the managed row');
+  const dropIn = page.getByTestId('rail-agents-group-idle').getByRole('button', { name: `Drop in to ${name}`, exact: true });
+  const managed = await expect(dropIn).toBeVisible({ timeout: ROW_WITHIN_MS }).then(() => true, () => false);
+  if (!managed) problems.push(`no "Drop in to ${name}" button under Idle within ${ROW_WITHIN_MS / 1000}s of the 201`);
+  const gone = await expect(outsideRows(page, base)).toHaveCount(0, { timeout: GONE_WITHIN_MS }).then(() => true, () => false);
+  if (!gone) problems.push(`the Outside row for ${base} is still on the rail ${GONE_WITHIN_MS / 1000}s after the 201`);
+
+  env.step('wait for the pane to exit');
+  const exited = await poll(async () => {
+    try { await exec(tools.tmux, ['has-session', '-t', `=${tmuxName}`], { timeout: 10000 }); return null; } catch { return true; }
+  }, { timeoutMs: GONE_WITHIN_MS, intervalMs: 500 });
+  if (!exited) problems.push(`the outside claude in tmux ${tmuxName} is still running ${GONE_WITHIN_MS / 1000}s after the 201`);
+
+  env.step('read relay audit');
+  const audited = await poll(async () => {
+    const { stdout } = await exec(env.relayBin, ['audit', '--event', 'session_adopt', '--json', '--tail', '200'], { timeout: 10000, maxBuffer: 32 << 20 });
+    for (const line of stdout.split('\n')) {
+      let o;
+      try { o = JSON.parse(line); } catch { continue; }
+      if (o && o.event === 'session_adopt' && o.outcome === 'ok' && Date.parse(o.ts) >= sentAt - 1000) return true;
+    }
+    return null;
+  }, { timeoutMs: HOOK_STATE_WITHIN_MS * 2, intervalMs: 1000 });
+  if (!audited) problems.push('relay audit holds no session_adopt row with outcome ok since the tap');
+
+  if (problems.length) return result(id, FAIL, problems.join('; '));
+  return result(id, PASS, `the idle row for ${base} showed Adopt ${name}; one tap answered 201 with a session and no claudeSessionId, the Outside row left the rail, "Drop in to ${name}" showed under Idle, `
+    + `the claude in the tmux pane exited, and relay audit holds a session_adopt row with outcome ok`);
 }
 
 module.exports = {
@@ -718,7 +899,10 @@ module.exports = {
       id: 'cos-outside-simple', claude: true, timeoutMs: 600000, areas: ['chief-of-staff'], needs: ['project:acme'], screen: true, run: cosOutsideSimple,
     },
     outsideThread: {
-      id: 'outside-thread', claude: true, timeoutMs: 600000, areas: ['chief-of-staff'], needs: ['project:acme'], run: outsideThread,
+      id: 'outside-thread', claude: true, timeoutMs: 720000, areas: ['chief-of-staff'], needs: ['project:acme'], run: outsideThread,
+    },
+    outsideAdopt: {
+      id: 'outside-adopt', claude: true, timeoutMs: 480000, areas: ['chief-of-staff'], needs: ['project:acme'], run: outsideAdopt,
     },
     cosOutsideHooks: {
       id: 'cos-outside-hooks', claude: true, timeoutMs: 360000, areas: ['chief-of-staff'], needs: ['project:acme'], run: cosOutsideHooks,
diff --git a/devboxverify/journeys.js b/devboxverify/journeys.js
index 7ae49ea7..2ed01c41 100644
--- a/devboxverify/journeys.js
+++ b/devboxverify/journeys.js
@@ -4464,6 +4464,7 @@ const journeys = [
   files.filesOnHost,
   cosOutside.cosOutsideSimple,
   cosOutside.outsideThread,
+  cosOutside.outsideAdopt,
   cosOutside.cosOutsideHooks,
   { id: 'project-mode-new', timeoutMs: 90000, areas: ['projects', 'home'], needs: [], screen: true, run: projectModeNew },
   auth.addBrowserInWindow,
diff --git a/docs/FEATURES.md b/docs/FEATURES.md
index ab5a9836..3afaf7f4 100644
--- a/docs/FEATURES.md
+++ b/docs/FEATURES.md
@@ -369,8 +369,8 @@ Code: public/task-viewer.js, public/routine-audit.js, public/routine-history.js,
 | G6.20 | See each agent's state on the board | Today | `relay session list` | Under "Agents", groups "Needs you", "Working", "Idle" and "Done" show counts and a row per agent with a state dot; an errored agent's row adds its provider's last stderr line and exit code, like `<line> (exit 127)` | `relay session list` shows the same sessions | r1: relay down: text "Can't reach relay."; r2: none: text "No agents running" | agent-board-states | g6-board.spec.js, g6-exit.spec.js |
 | G6.21 | Open an agent's thread from the board | Today > button "<agent name>" | none | The agent's thread opens as a tab | none | none | none yet | g6-board.spec.js |
 | G6.22 | See an agent's state change within moments | n/a: background | n/a: background | A row moves between groups, for example from "Working" to "Needs you", within about two seconds | none | none | agent-board-states | g6-board.spec.js |
-| G6.23 | Drop in to an agent that is waiting on me | Today > button "Drop in to <agent name>" | `relay drop-in <session-id>` | A terminal tab opens on the same conversation; the button read "Dropping in…" while relay worked | `relay logs --event session.drop_in` ok; `relay terminal list` shows it | r1: relay refuses: toast "Can't drop in: <reason>"; r2: no terminal back: toast "Can't drop in: relay did not return a terminal."; r3: not a headless Claude session: no button | agent-drop-in | devbox: agent-drop-in |
-| G6.24 | Close a dropped-in terminal to hand the agent back | Terminal > button "Close <tab label>" | none | The tab closes and the agent is back under its old state on the board | none: the hand-back is not in the proof list | none | agent-drop-in | devbox: agent-drop-in |
+| G6.23 | Drop in to an agent that is waiting on me or idle | Today > button "Drop in to <agent name>" | `relay drop-in <session-id>` | A terminal tab opens on the same conversation; the button read "Dropping in…" while relay worked; the agent shows under "Needs you" or "Idle" | `relay logs --event session.drop_in` ok; `relay terminal list` shows it | r1: relay refuses: toast "Can't drop in: <reason>"; r2: no terminal back: toast "Can't drop in: relay did not return a terminal."; r3: not a headless Claude session, or an outside row: no button | agent-drop-in | g6-drop-in.spec.js, devbox: agent-drop-in |
+| G6.24 | Close a dropped-in terminal to hand the agent back | Terminal > button "Close <tab label>" | none | The tab closes and the agent is back under "Idle" with its Drop in button | none: the hand-back is not in the proof list | none | agent-drop-in | g6-drop-in.spec.js, devbox: agent-drop-in |
 | G6.25 | See how many agents need me on a phone | Bottom bar > button "Today" | none | The button "Today" carries a red count read as "<n> need you" | none | r1: none need me: no count shows | none yet | g6-board.spec.js |
 | G6.26 | See which threads are running right now | Today | none | Under "Running", a button per running thread or routine shows a dot titled "Running" | none | r1: nothing running: text "Nothing running." | none yet | g6-board.spec.js |
 | G6.27 | See a running dot on a project chip | Today | none | The project button shows a dot titled "<n> running" | none | none | none yet | none yet: #369 |
@@ -387,7 +387,7 @@ Code: public/task-viewer.js, public/routine-audit.js, public/routine-history.js,
 | G6.38 | See every agent in the rail to the right of the thread | Chief of Staff > navigation "Agents" | `relay session list` | On a window wider than 900px the rail sits to the right of the thread, 280px wide by default. Headings "Needs you", "Working", "Idle" and "Done"; each row shows name, age, project and state words, and a last line (for an errored agent, its exit line) | `relay session list` shows the same sessions | r1: relay down: text "Can't reach relay." | cos-agent-rail | g6-cos.spec.js, g6-exit.spec.js |
 | G6.39 | Open an agent from a rail row | Chief of Staff > navigation "Agents" > button "<agent name>" | none | The agent's thread, or its terminal, opens as a tab | none | none | cos-agent-rail | g6-cos.spec.js |
 | G6.40 | Show the finished agents in the rail | Chief of Staff > button "Done <n>" | none | The "Done" group expands and lists finished agents; a second press collapses it | none | none | none yet | g6-cos.spec.js |
-| G6.41 | Drop in from a rail row | Chief of Staff > button "Drop in to <agent name>" | `relay drop-in <session-id>` | A terminal tab opens on the same conversation | `relay logs --event session.drop_in` ok | r1: relay refuses: toast "Can't drop in: <reason>"; r2: not a headless Claude session: no button | none yet | none yet: #369 |
+| G6.41 | Drop in from a rail row | Chief of Staff > button "Drop in to <agent name>" or the phone dialog "Agents" | `relay drop-in <session-id>` | A terminal tab opens on the same conversation | `relay logs --event session.drop_in` ok | r1: relay refuses: toast "Can't drop in: <reason>"; r2: not a headless Claude session: no button | none yet | g6-drop-in.spec.js |
 | G6.42 | See an idle agent's summary under its rail row | n/a: background | n/a: background | The row's third line shows a one-line summary once the agent's turn ends; no post appears in the thread | none | none | cos-agent-rail | g6-cos.spec.js |
 | G6.43 | Open the agents sheet on a phone | Chief of Staff > resize to 390x844 > button "Agents" (its name starts with the counts, like "2 idle Agents") | none | A dialog "Agents" opens with the same rows; the strip shows red, amber and green counts | none | r1: relay down: no counts show | cos-agent-rail | g6-cos.spec.js |
 | G6.44 | Close the agents sheet | Chief of Staff > dialog "Agents" > button "Close" | none | The sheet closes and focus returns to the strip; Escape, a tap outside or a drag down does the same | none | none | none yet | g6-cos.spec.js |
@@ -439,7 +439,7 @@ Code: public/task-viewer.js, public/routine-audit.js, public/routine-history.js,
 | G6.90 | Add the proposed chat from its Add card | Chief of Staff > button "Add" | relay `settings.json` `projects[].chat_templates` (no relay CLI verb for chats) | The card shows "Approve on the Mac", then "Added"; it lists the chat's Name and Model and has no text field or Edit button | `chat_template.add` ok; the project's `chat_templates` lists the chat | r1: presence refused: card text "Failed: presence was refused"; presence timed out: the card keeps "Approve on the Mac" until relay answers; nothing is written either way; r2: relay refuses, such as `name_taken`: card text "Failed: <reason>"; r3: project removed: "Failed: That project is no longer available" | cos-add-chat | g6-cos-chats.spec.js |
 | G6.91 | Cancel the Add-a-chat card | Chief of Staff > button "Cancel" | none | The card status reads "Cancelled" and no chat is added | none | none | none yet | g6-cos-chats.spec.js |
 | G6.92 | Start a project's chat by name | Chief of Staff > textbox "Tell an agent" > type "start <chat> on <project> and ask it <task>" > press Return | none | Either a Start card (Prompt, Folder, Agent) appears, or at once a post "Started <name> in <project>." with button "Open"; the chat runs without you and its reply shows in the chat view | `relay audit` shows the start by the Chief of Staff | r1: relay refuses: post "Couldn't start an agent in <project>: <reason>" | cos-add-chat | g6-cos-chats.spec.js |
-| G6.93 | Follow outside Claude work | Chief of Staff > navigation "Agents" or phone dialog "Agents" | Relay host configuration and optional outside report hooks | Outside rows show machine, folder, branch and Working, Waiting on you or Idle; waiting rows count once toward need you | Relay outside inventory snapshot | r1: the row reads Read-only thread, or Thread unavailable: Host is unreachable | cos-outside-simple, cos-outside-hooks | g6-cos-outside.spec.js |
+| G6.93 | Follow outside Claude work | Chief of Staff > navigation "Agents" or phone dialog "Agents" | Relay host configuration and optional outside report hooks | Outside rows show machine, folder, branch and Working, Waiting on you or Idle; waiting rows count once toward need you; an adoptable live row also offers Adopt or Interrupt and adopt (G6.107, G6.108) | Relay outside inventory snapshot | r1: the row reads Read-only thread, or Thread unavailable: Host is unreachable | cos-outside-simple, cos-outside-hooks | g6-cos-outside.spec.js |
 | G6.94 | Ask about the latest outside turn | Chief of Staff > textbox "Tell an agent" > ask about an Outside row | none | Reply uses the latest turn read at request time | scoped outside detail | r1: failed read: no successful stale text | cos-outside-simple, outside-thread | devbox: cos-outside-simple, devbox: outside-thread |
 | G6.95 | Watch an outside tmux session safely | Chief of Staff > Outside row > button "View read-only" | Relay host show_all_tmux_sessions | Terminal shows Read-only; input, paste, drop, keybar and remote resize are suppressed; Close detaches only viewer | Relay exact inventory and backend input/resize refusal | r1: opt-in off or capability unavailable: view refused; r2: reserved outside action ID: Outside sessions are read-only. | cos-outside-simple | g6-cos-outside.spec.js |
 | G6.96 | Read an outside session's thread | Chief of Staff > Outside row | none | A tab shows the session's name, the line Outside, machine and folder, a Read-only badge and the conversation (You, Claude and Tool entries, oldest first); Claude entries as Markdown; a tool call as its name and a short summary with its input folded; a tool result past 400 characters or 8 lines folded; You and tool text as plain text; button "Load older" adds the previous page above; new entries show within the probe interval; the tab has no textbox, Send or Stop; the tab closes with a notice when the session leaves the list | Relay outside transcript route | r1: the machine is unreachable: the row reads Thread unavailable: Host is unreachable and opens no tab; r2: the session left the list: the tab closes and the text "<name> left the Agents list, so its thread closed." shows | outside-thread, cos-outside-simple | g6-outside-thread.spec.js, g6-outside-thread-format.spec.js |
@@ -450,7 +450,11 @@ Code: public/task-viewer.js, public/routine-audit.js, public/routine-history.js,
 | G6.101 | Read what happened while I was away | Chief of Staff > thread, when the card reads "Ended: <reason>" | none | One post "While you were away" gives "<HH:MM> to <HH:MM> · <n> sent · ended: <reason>" and the groups "Done for you", "Waits for you" (a session at its cap reads "<label>: message limit reached") and "Ready" with the agent's report; the card reads "Ended: all done" when every session is ready or ended and "Ended: message limit reached" when a session hit its cap | none | none | none yet | g6-cos-delegation-act.spec.js |
 | G6.102 | Answer an agent only when its question fits my condition | Chief of Staff > card, after Approve > say it in the instruction ("say continue to Migration if it asks to proceed") | none | When a listed session ends a turn on a question and a reply rule with a condition fits it, the post names the agent and the rule's text with the chip "Sent for you · rule <n>"; when no rule fits, a notice reads "No rule covers <label>'s last turn; it waits for you." and the digest lists the agent as "no rule matched"; with a keep-going rule for that agent its text goes instead | Relay audit `chief_of_staff.send` per send | r1: the model fails, is off or is at its daily limit: nothing from the rule is sent; r2: a match naming another agent's rule or another trigger is ignored; a match turn counts one model call | none yet | g6-cos-delegation-match.spec.js |
 | G6.103 | Clear the Chief of Staff thread and start afresh | Chief of Staff > textbox "Tell an agent" > type "/clear" > press Return | none | The thread empties to "Nothing yet. I'll post here when an agent needs you.", except cards still waiting on a tap, which still act; the next answer remembers nothing from before | `relay logs --event session.delete` names each Chief of Staff session | r1: a delegation is active: "A delegation is active, so I didn't clear the thread. Stop it on the bar first, then type /clear again." and the thread stays; r2: the archive can't be written: "I couldn't archive the thread, so I didn't clear it. Try again." and the thread stays | cos-clear | g6-cos-clear.spec.js |
-| G6.104 | See recently ended outside sessions | Chief of Staff > navigation "Agents" > heading "Ended" (or the phone dialog "Agents") | Relay `settings.json` `outside_sessions.ended_window_days` | Ended lists ended outside rows newest first; each row shows name, `Outside · machine · folder · Ended`, its age and its last turn; it is not a button and has no View read-only; ended rows add nothing to need you or Watching | The relay outside snapshot (`state:"ended"`, `endedAt`) | r1: relay lists no ended rows: no Ended heading and no error | outside-thread | g6-cos-outside-ended.spec.js |
+| G6.104 | See recently ended outside sessions | Chief of Staff > navigation "Agents" > heading "Ended" (or the phone dialog "Agents") | Relay `settings.json` `outside_sessions.ended_window_days` | Ended lists ended outside rows newest first; each row shows name, `Outside · machine · folder · Ended`, its age and its last turn; it is not a button and its only button is Resume (G6.106); ended rows add nothing to need you or Watching | The relay outside snapshot (`state:"ended"`, `endedAt`) | r1: relay lists no ended rows: no Ended heading and no error | outside-thread | g6-cos-outside-ended.spec.js |
+| G6.105 | Take over a working agent after its turn | Today or Chief of Staff > button "Take over <agent name> after this turn" | `relay drop-in <session-id>` | the button reads "Waiting for the turn to end…" until relay answers, then a terminal tab opens on the same conversation | `relay logs --event session.drop_in` ok | r1: relay refuses (a tool is running, a terminal already has it, the turn did not end): toast "Can't drop in: <reason>"; r2: this page's own drop-in terminal holds it: no button; r3: outside row: no button | none yet | g6-drop-in.spec.js |
+| G6.106 | Resume an ended outside session | Chief of Staff > navigation "Agents" > heading "Ended" > button "Resume <name> in a terminal" (on a phone, the dialog "Agents") | `relay terminal start --project <id> --template claude-code --directory <folder> --extra-arg --resume --extra-arg <session id>` | the button reads "Resuming…" until relay answers, then a terminal tab opens in the session's folder on the same conversation, read-write, and the button reads "Resumed" while that terminal runs | `relay logs --event session.launch` names the `claude-code` template, the folder and `--resume`; `relay audit` shows the sandbox | r1: the folder is in no registered project: no button, the line "Not in a project, so it can't be resumed."; r2: the row is on an SSH host: no button, the line "On a host, so it can't be resumed here."; r3: relay refuses: toast "Can't resume: <reason>" and the button is back to Resume | outside-thread | g6-outside-resume.spec.js |
+| G6.107 | Adopt an idle outside session | Chief of Staff > navigation "Agents" > button "Adopt <name>" (on a phone, the dialog "Agents") | none | the button reads "Adopting…" until relay answers; the outside row goes and the agent shows under Idle with "Drop in to <name>" | `relay logs --event session.adopt` ok; `relay audit --event session_adopt` ok | r1: not adoptable (no project, on a host, not an interactive command-line session): no button and the reason line; r2: relay refuses: toast "Can't adopt: <reason>" and the button is back | outside-adopt | g6-outside-adopt.spec.js |
+| G6.108 | Interrupt and adopt a working outside session | Chief of Staff > navigation "Agents" > button "Interrupt and adopt <name>" (on a phone, the dialog "Agents") | none | the button reads "Interrupting…" until relay answers; the agent shows under Idle with "Drop in to <name>", and its thread starts with relay's message marked "Sent by relay after it took over" | `relay logs --event session.adopt` ok with `interrupted`; `relay audit --event session_interrupt` ok | r1: not adoptable (no project, on a host, not an interactive command-line session): no button and the reason line; r2: relay refuses: toast "Can't adopt: <reason>" and the button is back | none yet | g6-outside-adopt.spec.js |
 
 
 ### G7 · Read and edit project files
diff --git a/docs/api.md b/docs/api.md
index c63c942b..2eb5f870 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -63,6 +63,8 @@ WebAuthn enrollment/login. The four POST routes are rate-limited per client addr
 | GET | `/api/models` | List models. Relay's status and body pass through; 401 and 502 as in Pages, gates and shared answers. |
 | GET | `/api/sessions` | List sessions. relay answers `{ sessions: [...] }` (object-wrapped); eve unwraps it and returns a bare, filtered array to the browser: `__search:` ephemeral sessions are filtered out here, not by relay. A non-2xx relay answer, or a body that is neither shape, passes through unchanged; 502 when relay is unreachable. A live Claude or pi row can carry `attention: {state, since, exit?}` (same values, time format and `exit` as `session_state`); the field is absent otherwise, and eve passes it through unchanged. |
 | POST | `/api/sessions/:id/drop-in` | Drop in to a headless Claude session. Body `{cols, rows}`, each a whole number from 1 to 500, else `400 {"error":"cols and rows must be whole numbers from 1 to 500"}` and relay is not called. eve forwards to relay (`session.drop_in`) and returns relay's status and body unchanged: `201 {sessionId, claudeSessionId, host?, terminal}` (`terminal` has the shape of `POST /api/terminals`; the browser opens it with `terminal_created` handling plus `join_terminal`), or a refusal `{error, message}` (`message` is shown to the person), with relay's status. 502 `{"error":"Service unavailable"}` if relay is unreachable. No timeout: relay bounds the wait. Closing the terminal is the ordinary `terminal_close`. |
+| POST | `/api/outside-sessions/:id/resume` | Resume an ended outside session in a new terminal. Body `{cols, rows}`, each a whole number from 1 to 500. `:id` must match `^outside:[A-Za-z0-9_-]{1,128}$`. A bad id answers `400 {"error":"invalid_request"}`, bad `cols` or `rows` answers `400 {"error":"cols and rows must be whole numbers from 1 to 500"}`, and relay is not called. Eve checks the row in its own outside snapshot, in order: gone `404 outside_session_not_found`; not ended `409 outside_session_live`; not in a project, on a host, or no usable conversation id `409 outside_resume_unavailable`; already in flight `409 outside_resume_busy`. Each refusal is `{error, message}`. Then it makes one `POST /api/terminals` (template `claude-code`, the row's folder and project, `extraArgs: ["--resume", <id>]`). `201 {terminal}` (the shape of `POST /api/terminals`; the browser opens it as for drop-in), relay's refusal with relay's status and `{error, message}`, `502 {"error":"resume_failed",...}` when relay returns no terminal, or `502 {"error":"Service unavailable"}` if relay is unreachable. |
+| POST | `/api/outside-sessions/:id/adopt` | Adopt a live outside session under relay. Body `{interrupt}`, exactly `true` or `false`; other keys are ignored and never forwarded. `:id` must match `^outside:[0-9a-f]{32}$`. A bad id answers `400 {"error":"invalid_request"}`, a non-boolean `interrupt` answers `400 {"error":"interrupt must be true or false"}`, and relay is not called. Eve makes one `POST /api/sessions/adopt` with `{outsideId, interrupt}` as itself (no chief-of-staff scope: relay refuses that scope at this door; `session.adopt` is logged, never the body). `201 {sessionId, interrupted, recoverySent}` (relay's `claudeSessionId` is dropped); relay's refusal with relay's status and `{error, message}` (`message` is shown to the person); `502 {"error":"adopt_failed","message":...}` when relay returns no session; `502 {"error":"Service unavailable"}` if relay is unreachable. No timeout: relay bounds the ladder. The managed session reaches the browser through the session list. With `interrupt:true`, relay may add one user message with origin `relay-recovery`. |
 | POST | `/api/sessions/:id/resume` | Not an eve route: it is the relay route eve calls, and no browser sends it. Resume a dormant session. Called automatically by eve, at most once per user turn, when relay answers a `send_message` with the `resume_required` error below, never host-driven (SH-6). |
 
 Session creation is HTTP (`POST /api/sessions`, triggered by the WS `create_session` frame, see below); messages and the rest of the session lifecycle stay on WebSocket.
@@ -369,7 +371,7 @@ sessions:OutsideSession[],machines:MachineStatus[]}`. Each row has `id`, `name`,
 `projectId`, `hostId`, `machine`, `directory`, `branch`, `state` (running, asking,
 idle, or ended), `since`, `updatedAt`, `endedAt` (ended rows only, RFC 3339 UTC),
 `source` (hook or probe), `outside:true`,
-`readOnly:true`, `tmuxSession`, `viewable`, `viewReason`. IDs have the reserved
+`readOnly:true`, `tmuxSession`, `viewable`, `viewReason`, `adoptable`, `adoptReason`. IDs have the reserved
 `outside:` prefix; nullable project/host/tmux values remain nullable. Machine
 status has `hostId`, `machine`, `status`, `lastProbeAt`, `error`.
 Full snapshots replace membership; a new WS reseeds revision after reconnect.
@@ -397,6 +399,7 @@ managed roster nor browser StateStore nor errands.
 `cos_list_sessions` adds outside rows with `sessionId`, `label`, `project`,
 `projectId`, `state`, `since`, `headless:false`, `origin:'outside'`, `outside:true`,
 `readOnly:true`, `machine`, `directory`, `branch`, `viewable`, `viewReason`,
+`adoptable` and `adoptReason` (relay's judgement; `adoptReason` is a code, present when `adoptable` is false),
 and `endedAt` on an ended row. `cos_session_status` reads a fresh scoped detail response at request time:
 `{session,lastTurn:{text,at,complete},lastExcerpt}`. Latest assistant turn text
 is bounded to its last 8192 characters; excerpt is its last 500. Expired IDs
@@ -404,6 +407,7 @@ return `outside_session_not_found`; failed reads return
 `outside_status_unavailable`, never successful cached text. Existing tool-call
 claims and provenance remain mandatory. Outside sends/cards/actions refuse
 `outside_session_read_only` with `Outside sessions are read-only.`
+The Claude conversation id (`claudeSessionId`), which relay serves on outside rows, stays on eve's server: no row, frame, list or tool result carries it, and the browser sends only the row id to resume or adopt.
 
 `GET /api/outside-sessions/:id/transcript` (browser, `requireAuth`) returns one
 page of an outside session's transcript for the read-only thread tab. `:id` must
diff --git a/docs/design-chief-of-staff.md b/docs/design-chief-of-staff.md
index c948cd6f..68cf9782 100644
--- a/docs/design-chief-of-staff.md
+++ b/docs/design-chief-of-staff.md
@@ -218,6 +218,8 @@ browser frames use `browserSnapshot()`. A failed read stores nothing and the nex
 snapshot retries. Ended rows count in neither `watching` nor `needYou`. The model
 reads an ended session by finding its row and calling `cos_session_status`.
 
+Outside rows stay read-only: eve never writes to, signals or takes over the original process. An ended row in a console project offers Resume, which starts a new managed `claude-code` terminal in the row's folder with `--resume <conversation id>` (`ChiefOfStaffOutside#resume`, `POST /api/outside-sessions/:id/resume`). Relay serves that id (`claudeSessionId`) on ended rows only; eve keeps it in a private map, strips it from every row, frame and tool result, and the browser sends only the row id. Eve checks the row (in the list, ended, in a console project, a UUID id, not already in flight) and makes one `POST /api/terminals` through the same door as `terminal_create`, so relay's sandbox and project rules apply unchanged.
+
 ChiefOfStaffPage keeps a private outside Map and passes it only to its rail
 and phone-sheet boards. Today, projects, managed attention, StateStore, errands
 and wake summaries retain their existing membership. Viewer terminals are
@@ -272,6 +274,8 @@ literal, and links and images stay sanitised as in the main chat. You and tool
 text stay `textContent`: a tool call shows its name and a short summary with its
 input folded, and a tool result past 400 characters or 8 lines is folded. Eve folds by relay's `kind` and uses `name` as the label, and guesses by text shape only for an entry with no `kind`.
 
+**Adopt (eve#597).** A live outside row relay marks `adoptable` and not on a host offers a button on the Agents board: `Adopt` when idle, `Interrupt and adopt` when working. The browser sends only the row id and `interrupt` to `POST /api/outside-sessions/:id/adopt`. Eve makes one call to relay's `POST /api/sessions/adopt` as itself, with no chief-of-staff scope: relay refuses that scope at this door, and the Chief of Staff gets no adopt action or tool (its outside actions still refuse `outside_session_read_only`). Relay judges the row, the project, idleness and the launch; eve adds no filter and shows the button only on `adoptable === true`. A row relay marks not adoptable shows relay's reason as one line. The conversation id relay returns is dropped at the route. After adopt, relay lists a managed headless session and the board shows it with Drop in. Interrupt and adopt makes relay send one message with origin `relay-recovery`, shown with the chip `Sent by relay after it took over`.
+
 Relay independently probes healthy machines every 15 seconds, drains optional
 native hook reports within two seconds, and emits full changed snapshots.
 Eve immediately fans them out: end-to-end promises remain hook state <=5s,
diff --git a/docs/design-workbench.md b/docs/design-workbench.md
index 8348e2ec..21c96327 100644
--- a/docs/design-workbench.md
+++ b/docs/design-workbench.md
@@ -245,3 +245,11 @@ The board becomes the shared component for a third mount, the Chief of Staff rai
   - `onOpen(row)`: called after a row tap or Drop in.
 - **Rail headers.** In the rail layout each group header has `tabindex="-1"` and the test id `{p}-agents-group-{key}-head`, so "N need you" can scroll to it and focus it.
 - **Touch.** Rail rows and the Done toggle are at least 44px high under `(pointer: coarse)`.
+
+## Amended by eve#592
+
+- **Rule.** `AgentBoard.showsDropIn(r)`: a headless Claude session row (never an outside row) shows the button in Needs you and Idle, and in Working unless this page's own drop-in terminal holds it. Done and Ended never show it.
+- **Labels.** Needs you and Idle: `Drop in` (`{p}-drop-in-{id}`, busy `Dropping in…`). Working: `Take over after this turn` (`{p}-take-over-{id}`, accessible name `Take over {label} after this turn`, busy `Waiting for the turn to end…`). It is the same POST; relay waits for the turn. The busy text follows the kind fixed at the tap.
+- **`held`.** `AgentBoard.held` maps a session id to the terminal a drop-in on this page opened. `collect()` drops an entry once that terminal is gone or stopped. Another page or device still shows Take over and gets relay's `dropped_in` refusal.
+- **`onOpen` timing.** A row's Drop in or Take over calls `onOpen(row)` when relay answers (terminal or refusal), not at the tap, so the phone sheet stays open on the waiting text. A row tap is unchanged.
+- **Refusal.** The existing error toast, text collapsed to one line.
diff --git a/public/agent-board.js b/public/agent-board.js
index 41a849fb..211c083b 100644
--- a/public/agent-board.js
+++ b/public/agent-board.js
@@ -157,12 +157,24 @@ class AgentBoard {
   // relay's deriveSessionKind: these models are Claude sessions.
   static CLAUDE_MODELS = ['haiku', 'sonnet', 'opus'];
   static DROP_IN_SIZE = { cols: 80, rows: 24 };
-  // Session ids with a drop-in in flight, shared by every board.
-  static dropping = new Set();
+  // sessionId -> 'drop' | 'wait': a drop-in in flight, shared by every board. The kind is
+  // fixed at the tap, so the busy text does not change when the row changes group.
+  static dropping = new Map();
+  // sessionId -> terminalId of a drop-in this page opened. While that terminal lives, this
+  // page does not offer Take over: relay reads the held session as running and would refuse.
+  static held = new Map();
+  // Ended outside rows: ids with a Resume request open, and id -> terminalId of a resume this
+  // page opened. Shared by every board, like `dropping`.
+  static resuming = new Set();
+  static resumed = new Map();
+  // Live outside rows: id -> 'adopt' | 'interrupt' for an Adopt request open (the kind is fixed at
+  // the tap), and id -> managed sessionId of an adopt this page made. Shared by every board.
+  static adopting = new Map();
+  static adopted = new Map();
 
   // Rail and sheet options (eve#274): `maxRows` (Infinity: no cap), `layout` ('board' or
   // 'rail'), `collapseDone`, `note(sessionId)` for a row's third line, `onCounts` (group
-  // counts, or null while offline or loading) and `onOpen(row)` after a tap or Drop in.
+  // counts, or null while offline or loading) and `onOpen(row)` after a tap, or when relay answers a Drop in or Take over.
   constructor({
     container, testidPrefix, showProject, filter, onCount,
     maxRows = AgentBoard.MAX_ROWS, layout = 'board', collapseDone = false,
@@ -238,7 +250,12 @@ class AgentBoard {
     if (relayDown) kind = 'offline';
     else if (!mgr || !mgr.listLoaded) kind = 'loading';
     else {
-      rows = AgentBoard.collect(this.container, this.filter, this.outsideRows?.() || []);
+      const outside = this.outsideRows?.() || [];
+      rows = AgentBoard.collect(this.container, this.filter, outside);
+      // A row that left the Ended list (or went live) forgets its Resumed state.
+      if (this.outsideRows) for (const oid of AgentBoard.resumed.keys()) if (!outside.some(o => o?.id === oid && o.state === 'ended')) AgentBoard.resumed.delete(oid);
+      // An adopted row that left the outside list forgets its Adopted state.
+      if (this.outsideRows) for (const oid of AgentBoard.adopted.keys()) if (!outside.some(o => o?.id === oid)) AgentBoard.adopted.delete(oid);
       if (rows.length === 0) kind = 'empty';
     }
     el.dataset.state = kind;
@@ -276,28 +293,40 @@ class AgentBoard {
     return AgentBoard.CLAUDE_MODELS.includes(session?.model);
   }
 
-  // The one place the Drop in rule lives: a headless Claude session that needs me.
+  // The one place the Drop in rule lives: a headless Claude session that needs me or is
+  // idle, or a working one (Take over after the turn) that this page does not already hold.
   static showsDropIn(r) {
-    return r.kind === 'session' && AgentBoard.isClaude(r.item) && r.item.headless === true
-      && (r.group === 'needs' || AgentBoard.dropping.has(r.id));
+    if (r.kind !== 'session' || !AgentBoard.isClaude(r.item) || r.item.headless !== true) return false;
+    return AgentBoard.dropping.has(r.id) || r.group === 'needs' || r.group === 'idle'
+      || (r.group === 'working' && !AgentBoard.held.has(r.id));
   }
 
   // Never rejects. No client timeout: relay bounds the wait, and giving up sooner
   // would orphan a terminal it already launched.
-  static async dropIn(container, sessionId) {
+  // `wait` marks "Take over after this turn": the same POST, relay waits for the turn.
+  // `onAnswer` runs when relay answers (terminal or refusal), before the terminal opens.
+  static async dropIn(container, sessionId, { wait = false, onAnswer = null } = {}) {
     if (sessionId?.startsWith('outside:')) return;
     if (AgentBoard.dropping.has(sessionId)) return;
-    AgentBoard.dropping.add(sessionId);
+    AgentBoard.dropping.set(sessionId, wait ? 'wait' : 'drop');
     const renderAll = () => { for (const b of AgentBoard.live) b.render(); };
     const toast = (message) => container.get('bus').emit(EVT.TOAST_SHOW, {
-      id: `drop-in-${sessionId}`, message, type: 'error', duration: 8000,
+      id: `drop-in-${sessionId}`, message: message.replace(/\s+/g, ' ').trim(), type: 'error', duration: 8000,
     });
     renderAll();
     try {
       const body = await container.get('api').dropIn(sessionId, AgentBoard.DROP_IN_SIZE);
-      if (body?.terminal?.terminalId) AgentBoard._termMgr(container)?.openDropIn(body.terminal);
-      else toast("Can't drop in: relay did not return a terminal.");
+      const terminal = body?.terminal;
+      if (terminal?.terminalId) {
+        AgentBoard.held.set(sessionId, terminal.terminalId);
+        onAnswer?.();
+        AgentBoard._termMgr(container)?.openDropIn(terminal);
+      } else {
+        onAnswer?.();
+        toast("Can't drop in: relay did not return a terminal.");
+      }
     } catch (err) {
+      onAnswer?.();
       toast(`Can't drop in: ${err?.body?.message || err?.body?.error || "relay isn't reachable"}`);
     } finally {
       AgentBoard.dropping.delete(sessionId);
@@ -305,6 +334,98 @@ class AgentBoard {
     }
   }
 
+  // The one place the Resume rule lives: an ended outside row in a console project.
+  static showsResume(r) {
+    return r.kind === 'outside' && r.group === 'ended' && r.item.state === 'ended'
+      && !!r.project && !r.item.hostId && !r.project.hostId;
+  }
+
+  // The line for an ended outside row that has no Resume button.
+  static resumeReason(r) {
+    if (r.kind !== 'outside' || r.group !== 'ended' || r.item.state !== 'ended' || AgentBoard.showsResume(r)) return '';
+    return r.project ? "On a host, so it can't be resumed here." : "Not in a project, so it can't be resumed.";
+  }
+
+  // Never rejects. No client timeout: relay bounds the wait, and giving up sooner
+  // would orphan a terminal it already launched.
+  static async resumeOutside(container, id) {
+    if (!id?.startsWith('outside:') || AgentBoard.resuming.has(id)) return;
+    AgentBoard.resuming.add(id);
+    const renderAll = () => { for (const b of AgentBoard.live) b.render(); };
+    const toast = (message) => container.get('bus').emit(EVT.TOAST_SHOW, {
+      id: `resume-${id}`, message: `Can't resume: ${String(message).replace(/\s+/g, ' ').trim()}`, type: 'error', duration: 8000,
+    });
+    renderAll();
+    try {
+      const body = await container.get('api').resumeOutside(id, AgentBoard.DROP_IN_SIZE);
+      const terminal = body?.terminal;
+      if (terminal?.terminalId) {
+        AgentBoard.resumed.set(id, terminal.terminalId);
+        AgentBoard._termMgr(container)?.openDropIn(terminal);
+      } else {
+        toast('relay did not return a terminal.');
+      }
+    } catch (err) {
+      toast(err?.body?.message || err?.body?.error || "relay isn't reachable");
+    } finally {
+      AgentBoard.resuming.delete(id);
+      renderAll();
+    }
+  }
+
+  // The one place the Adopt rule lives: a live outside row relay marked adoptable, not on a
+  // host. An absent `adoptable` gives no button (fail closed).
+  static showsAdopt(r) {
+    return r.kind === 'outside' && r.group !== 'ended'
+      && ['idle', 'running', 'asking'].includes(r.item.state)
+      && r.item.adoptable === true && !r.item.hostId;
+  }
+
+  static ADOPT_REASONS = {
+    host_unsupported: "On a host, so it can't be adopted here.",
+    no_project: "Not in a project, so it can't be adopted.",
+    not_registered: "Claude keeps no session record for it, so it can't be adopted.",
+    invalid_id: "Its conversation id is not valid, so it can't be adopted.",
+    start_mismatch: "Its process changed, so it can't be adopted.",
+    not_interactive: "Not an interactive session, so it can't be adopted.",
+    not_command_line: "Not started from the command line, so it can't be adopted.",
+    ambiguous: "Two processes hold this conversation, so it can't be adopted.",
+  };
+
+  // The line for a live outside row that has no Adopt button; '' when none applies.
+  static adoptReason(r) {
+    if (r.kind !== 'outside' || r.group === 'ended' || r.item.adoptable !== false || typeof r.item.adoptReason !== 'string') return '';
+    return AgentBoard.ADOPT_REASONS[r.item.adoptReason] || "Relay can't adopt this session.";
+  }
+
+  // Never rejects. No client timeout: relay bounds the ladder, and giving up sooner would
+  // orphan a session it already launched. `onRefuse` runs before the toast on a refusal.
+  static async adoptOutside(container, id, { interrupt, onRefuse = null } = {}) {
+    if (!id?.startsWith('outside:') || AgentBoard.adopting.has(id)) return;
+    AgentBoard.adopting.set(id, interrupt ? 'interrupt' : 'adopt');
+    const renderAll = () => { for (const b of AgentBoard.live) b.render(); };
+    const toast = (message) => container.get('bus').emit(EVT.TOAST_SHOW, {
+      id: `adopt-${id}`, message: `Can't adopt: ${String(message).replace(/\s+/g, ' ').trim()}`, type: 'error', duration: 8000,
+    });
+    renderAll();
+    try {
+      const body = await container.get('api').adoptOutside(id, { interrupt: interrupt === true });
+      if (body?.sessionId) {
+        AgentBoard.adopted.set(id, body.sessionId);
+        await container.get('app').loadSessions();
+      } else {
+        onRefuse?.();
+        toast('relay did not return a session.');
+      }
+    } catch (err) {
+      onRefuse?.();
+      toast(err?.body?.message || err?.body?.error || "relay isn't reachable");
+    } finally {
+      AgentBoard.adopting.delete(id);
+      renderAll();
+    }
+  }
+
   static groupOf(state) {
     return AgentBoard.GROUPS.find(g => g.states.includes(state))?.key || 'working';
   }
@@ -342,6 +463,14 @@ class AgentBoard {
     const add = (kind, item, id, st, label, project, since = '', exit = null, group = AgentBoard.groupOf(st)) => {
       if (filter(item, project)) rows.push({ kind, id, state: st, group, label, project, since, exit, item });
     };
+    for (const [sid, tid] of AgentBoard.held) {
+      const t = mgr?.allTerminals.get(tid);
+      if (!t || t.state === 'stopped') AgentBoard.held.delete(sid);
+    }
+    for (const [oid, tid] of AgentBoard.resumed) {
+      const t = mgr?.allTerminals.get(tid);
+      if (!t || t.state === 'stopped') AgentBoard.resumed.delete(oid);
+    }
     for (const t of mgr ? mgr.allTerminals.values() : []) {
       if (state.isTaskRun(t.id) || t.outside === true) continue;
       const project = AgentBoard._projectOf(state, t);
@@ -403,7 +532,8 @@ class AgentBoard {
     return () => { for (const off of offs) off(); badge.remove(); button.removeAttribute('aria-describedby'); };
   }
 
-  // An ended outside row: read-only text in a div. No handler, no tab stop, no sibling button.
+  // An ended outside row: read-only text in a div. No handler, no tab stop. Its one sibling
+  // button is Resume (a new managed terminal; the outside process is never touched).
   _endedRow(r) {
     const { id, label, item: t } = r;
     const row = document.createElement('div');
@@ -434,6 +564,10 @@ class AgentBoard {
     meta.className = 'agent-row__meta agent-row__outside';
     meta.textContent = ['Outside', t.machine, t.directory, t.branch, 'Ended'].filter(Boolean).join(' \u00b7 ');
     row.append(head, meta);
+    const reason = AgentBoard.resumeReason(r);
+    if (reason) {
+      row.appendChild(this._reasonLine(`${this.prefix}-resume-reason-${id}`, 'resume-reason', reason));
+    }
     if (typeof t.lastExcerpt === 'string' && t.lastExcerpt) {
       const line = document.createElement('span');
       line.className = 'agent-row__line';
@@ -442,7 +576,63 @@ class AgentBoard {
       line.textContent = t.lastExcerpt;
       row.appendChild(line);
     }
-    return row;
+    return this._withResume(row, r);
+  }
+
+  // The one builder for a row's sibling action button. `busy` and `done` disable it; only `busy` sets aria-busy.
+  _actionButton({ testid, name, text, busyText, busy = false, done = false, onClick }) {
+    const act = document.createElement('button');
+    act.type = 'button';
+    act.className = 'agent-row__action';
+    act.dataset.testid = testid;
+    act.setAttribute('aria-label', name);
+    if (busy) {
+      act.disabled = true;
+      act.setAttribute('aria-busy', 'true');
+      act.textContent = busyText;
+    } else if (done) {
+      act.disabled = true;
+      act.textContent = text;
+    } else {
+      act.textContent = text;
+      act.addEventListener('click', onClick);
+    }
+    return act;
+  }
+
+  // A one-line reason inside a row that offers no action.
+  _reasonLine(testid, kind, text) {
+    const why = document.createElement('span');
+    why.className = 'agent-row__line';
+    why.dataset.testid = testid;
+    why.dataset.kind = kind;
+    why.textContent = text;
+    return why;
+  }
+
+  // The action is a sibling of the row: a button cannot hold a button.
+  _wrapActions(row, ...buttons) {
+    const wrap = document.createElement('div');
+    wrap.className = 'agent-row-wrap';
+    wrap.append(row, ...buttons);
+    return wrap;
+  }
+
+  _withResume(row, r) {
+    if (!AgentBoard.showsResume(r)) return row;
+    const { id, label } = r;
+    return this._wrapActions(row, this._actionButton({
+      testid: `${this.prefix}-resume-${id}`,
+      name: `Resume ${label} in a terminal`,
+      text: AgentBoard.resumed.has(id) ? 'Resumed' : 'Resume',
+      busyText: 'Resuming\u2026',
+      busy: AgentBoard.resuming.has(id),
+      done: AgentBoard.resumed.has(id),
+      onClick: () => {
+        this.onOpen?.(r);
+        AgentBoard.resumeOutside(this.container, id);
+      },
+    }));
   }
 
   _row(r, held) {
@@ -541,6 +731,8 @@ class AgentBoard {
       action.className = 'agent-row__line';
       action.textContent = t.machineStatus === 'unreachable' ? 'Thread unavailable: Host is unreachable' : 'Read-only thread';
       row.append(meta, action);
+      const why = AgentBoard.adoptReason(r);
+      if (why) row.appendChild(this._reasonLine(`${this.prefix}-adopt-reason-${id}`, 'adopt-reason', why));
       return;
     }
     const words = kind === 'session' ? AgentBoard.STATE_WORDS[state] || state
@@ -584,55 +776,60 @@ class AgentBoard {
     row.appendChild(line);
   }
 
-  // The sibling button a row offers, if any: Drop in or, on an outside row in tmux, View read-only.
+  // The sibling buttons a row offers, if any: Drop in or, on an outside row, View read-only
+  // (in tmux) and Adopt.
   _withActions(row, r) {
-    return r.kind === 'outside' ? this._withView(row, r) : this._withDropIn(row, r);
+    return r.kind === 'outside' ? this._withOutsideActions(row, r) : this._withDropIn(row, r);
+  }
+
+  _withOutsideActions(row, r) {
+    const buttons = [];
+    // The tmux viewer (G6.95) keeps a door of its own beside the row's thread.
+    if (r.item.viewable) {
+      buttons.push(this._actionButton({
+        testid: `${this.prefix}-view-${r.id}`,
+        name: `View ${r.label} read-only`,
+        text: 'View read-only',
+        onClick: () => {
+          this.onOpen?.(r);
+          this.openOutside?.(r.item);
+        },
+      }));
+    }
+    if (AgentBoard.showsAdopt(r)) buttons.push(this._adoptButton(r));
+    return buttons.length ? this._wrapActions(row, ...buttons) : row;
   }
 
-  // The tmux viewer (G6.95) keeps a door of its own beside the row's thread.
-  _withView(row, r) {
-    const { id, label, item } = r;
-    if (!item.viewable) return row;
-    const wrap = document.createElement('div');
-    wrap.className = 'agent-row-wrap';
-    const act = document.createElement('button');
-    act.type = 'button';
-    act.className = 'agent-row__action';
-    act.dataset.testid = `${this.prefix}-view-${id}`;
-    act.setAttribute('aria-label', `View ${label} read-only`);
-    act.textContent = 'View read-only';
-    act.addEventListener('click', () => {
-      this.onOpen?.(r);
-      this.openOutside?.(item);
+  _adoptButton(r) {
+    const { id, label } = r;
+    const kind = AgentBoard.adopting.get(id);
+    const interrupt = kind ? kind === 'interrupt' : r.item.state !== 'idle';
+    return this._actionButton({
+      testid: `${this.prefix}-${interrupt ? 'interrupt-adopt' : 'adopt'}-${id}`,
+      name: interrupt ? `Interrupt and adopt ${label}` : `Adopt ${label}`,
+      text: AgentBoard.adopted.has(id) ? 'Adopted' : interrupt ? 'Interrupt and adopt' : 'Adopt',
+      busyText: interrupt ? 'Interrupting\u2026' : 'Adopting\u2026',
+      busy: !!kind,
+      done: AgentBoard.adopted.has(id),
+      // A refusal closes a phone sheet so the toast shows; a success leaves it open on the result.
+      onClick: () => AgentBoard.adoptOutside(this.container, id, { interrupt, onRefuse: () => this.onOpen?.(r) }),
     });
-    wrap.append(row, act);
-    return wrap;
   }
 
   _withDropIn(row, r) {
     const { id, label } = r;
     if (!AgentBoard.showsDropIn(r)) return row;
-    // The action is a sibling of the row button: a button cannot hold a button.
-    const wrap = document.createElement('div');
-    wrap.className = 'agent-row-wrap';
-    const act = document.createElement('button');
-    act.type = 'button';
-    act.className = 'agent-row__action';
-    act.dataset.testid = `${this.prefix}-drop-in-${id}`;
-    act.setAttribute('aria-label', `Drop in to ${label}`);
-    if (AgentBoard.dropping.has(id)) {
-      act.disabled = true;
-      act.setAttribute('aria-busy', 'true');
-      act.textContent = 'Dropping in…';
-    } else {
-      act.textContent = 'Drop in';
-      act.addEventListener('click', () => {
-        this.onOpen?.(r);
-        AgentBoard.dropIn(this.container, id);
-      });
-    }
-    wrap.append(row, act);
-    return wrap;
+    const kind = AgentBoard.dropping.get(id);
+    const wait = kind ? kind === 'wait' : r.group === 'working';
+    return this._wrapActions(row, this._actionButton({
+      testid: `${this.prefix}-${wait ? 'take-over' : 'drop-in'}-${id}`,
+      name: wait ? `Take over ${label} after this turn` : `Drop in to ${label}`,
+      text: wait ? 'Take over after this turn' : 'Drop in',
+      busyText: wait ? 'Waiting for the turn to end…' : 'Dropping in…',
+      busy: !!kind,
+      // onOpen fires when relay answers, so a sheet stays open on the waiting text.
+      onClick: () => AgentBoard.dropIn(this.container, id, { wait, onAnswer: () => this.onOpen?.(r) }),
+    }));
   }
 
   _group(key, rows, shown, mgr, fetch) {
diff --git a/public/apple/agents.css b/public/apple/agents.css
index 2df2159c..0212c7f3 100644
--- a/public/apple/agents.css
+++ b/public/apple/agents.css
@@ -54,6 +54,9 @@
   font-family: var(--font-ui);
   font-size: 12px;
   cursor: pointer;
+  max-width: calc(100% - 28px);
+  text-align: left;
+  overflow-wrap: anywhere;
 }
 .agent-row__action:hover:not(:disabled) { background: var(--bg-hover); }
 .agent-row__action:focus-visible { outline: none; box-shadow: var(--focus-ring); }
diff --git a/public/core/api-client.js b/public/core/api-client.js
index 3a04b603..c5d4bb65 100644
--- a/public/core/api-client.js
+++ b/public/core/api-client.js
@@ -41,6 +41,18 @@ class ApiClient {
     return this._request('GET', `/api/outside-sessions/${encodeURIComponent(id)}/transcript${query ? `?${query}` : ''}`);
   }
 
+  // Resume an ended outside session in a new terminal. A refusal arrives as err.body = {error, message}.
+  resumeOutside(id, size) {
+    if (typeof id !== 'string' || !id.startsWith('outside:')) return Promise.reject(new Error('Outside resume unavailable'));
+    return this._request('POST', `/api/outside-sessions/${encodeURIComponent(id)}/resume`, size);
+  }
+
+  // Adopt an idle (or, with interrupt, working) outside session. A refusal arrives as err.body = {error, message}.
+  adoptOutside(id, { interrupt }) {
+    if (typeof id !== 'string' || !id.startsWith('outside:')) return Promise.reject(new Error('Outside adopt unavailable'));
+    return this._request('POST', `/api/outside-sessions/${encodeURIComponent(id)}/adopt`, { interrupt: interrupt === true });
+  }
+
   dropIn(sessionId, size) {
     if (sessionId?.startsWith('outside:')) return Promise.reject(new Error('Outside sessions are read-only.'));
     return this._request('POST', `/api/sessions/${encodeURIComponent(sessionId)}/drop-in`, size);
diff --git a/public/message-renderer.js b/public/message-renderer.js
index af21e9f4..f59b8d4d 100644
--- a/public/message-renderer.js
+++ b/public/message-renderer.js
@@ -453,11 +453,11 @@ class MessageRenderer {
       content.appendChild(mark);
     }
     // Only relay's marker, set by the server for a send the Chief of Staff made.
-    if (origin === 'chief-of-staff') {
+    if (origin === 'chief-of-staff' || origin === 'relay-recovery') {
       const chip = document.createElement('span');
       chip.className = 'message-origin-chip';
       chip.dataset.testid = 'message-origin-chip';
-      chip.textContent = 'Sent by Chief of Staff';
+      chip.textContent = origin === 'chief-of-staff' ? 'Sent by Chief of Staff' : 'Sent by relay after it took over';
       content.appendChild(chip);
     }
     if (shownFiles.length > 0 || shownUrls.length > 0) {
diff --git a/routes/index.js b/routes/index.js
index 0fbe49fe..1f551883 100644
--- a/routes/index.js
+++ b/routes/index.js
@@ -7,7 +7,7 @@ const { projectAudit } = require('../project-audit');
 
 const { NullLogger } = require('../logger');
 
-function registerRoutes(app, { authService, trustedNetwork, relayTransport, enrollmentWindow, passkeySync, refreshProjectCache, removeFromProjectCache, resolveProject, fileServiceFor, files, refreshHostCache, removeFromHostCache, ttsService, sttService, voiceSettings, log: parentLog }) {
+function registerRoutes(app, { authService, trustedNetwork, relayTransport, enrollmentWindow, passkeySync, refreshProjectCache, removeFromProjectCache, resolveProject, resumeOutside, fileServiceFor, files, refreshHostCache, removeFromHostCache, ttsService, sttService, voiceSettings, log: parentLog }) {
   const routeLog = parentLog?.child('Routes') || new NullLogger();
   function requireAuth(req, res, next) {
     if (!authService.isEnrolled() || process.env.EVE_NO_AUTH === '1' || trustedNetwork.isTrusted(req)) {
@@ -329,6 +329,47 @@ function registerRoutes(app, { authService, trustedNetwork, relayTransport, enro
     proxy(req, res, 'GET', `/api/outside-sessions/${encodeURIComponent(req.params.id)}/transcript${query ? `?${query}` : ''}`);
   });
 
+  // Resume an ended outside session in a new managed terminal. The browser sends only the
+  // row id and a size; eve holds the conversation id (chief-of-staff-outside.js) and checks the row.
+  app.post('/api/outside-sessions/:id/resume', requireAuth, async (req, res) => {
+    const whole = (n) => Number.isInteger(n) && n >= 1 && n <= 500;
+    const { cols, rows } = req.body || {};
+    if (!OUTSIDE_ID.test(req.params.id)) return res.status(400).json({ error: 'invalid_request' });
+    if (!whole(cols) || !whole(rows)) {
+      return res.status(400).json({ error: 'cols and rows must be whole numbers from 1 to 500' });
+    }
+    const { status, body } = await resumeOutside(req.params.id, { cols, rows });
+    res.status(status).json(body);
+  });
+
+  // Adopt an idle outside session. The browser sends the row id and `interrupt` only. This is
+  // eve's own call (no chief-of-staff scope: relay refuses that scope at this door), and the
+  // conversation id relay returns is dropped here.
+  app.post('/api/outside-sessions/:id/adopt', requireAuth, async (req, res) => {
+    const id = req.params.id;
+    if (!/^outside:[0-9a-f]{32}$/.test(id)) return res.status(400).json({ error: 'invalid_request' });
+    const interrupt = req.body?.interrupt;
+    if (interrupt !== true && interrupt !== false) return res.status(400).json({ error: 'interrupt must be true or false' });
+    const relayPath = '/api/sessions/adopt';
+    const startedAt = Date.now();
+    try {
+      const { status, data } = await relayTransport.fetch('POST', relayPath, { outsideId: id, interrupt }, { traceId: req.traceId });
+      let answer;
+      if (status >= 200 && status < 300) {
+        answer = typeof data?.sessionId === 'string' && data.sessionId
+          ? [201, { sessionId: data.sessionId, interrupted: data.interrupted === true, recoverySent: data.recoverySent === true }]
+          : [502, { error: 'adopt_failed', message: 'Relay did not return a session.' }];
+      } else {
+        answer = [status, { error: data?.error || 'adopt_failed', message: data?.message || `Relay answered ${status}.` }];
+      }
+      res.status(answer[0]).json(answer[1]);
+      logProxyCall(req, { op: 'session.adopt', method: 'POST', relayPath, startedAt, httpStatus: answer[0] });
+    } catch (err) {
+      res.status(502).json({ error: 'Service unavailable' });
+      logProxyCall(req, { op: 'session.adopt', method: 'POST', relayPath, startedAt, err });
+    }
+  });
+
   // The id is forwarded without shape validation here: relayLLM rejects ids it
   // won't accept before joining one into a log filename.
   app.get('/api/terminals/:id/log', requireAuth, async (req, res) => {
diff --git a/server.js b/server.js
index 7db1c339..504d6570 100644
--- a/server.js
+++ b/server.js
@@ -468,6 +468,7 @@ registerRoutes(app, {
   refreshProjectCache,
   removeFromProjectCache: (id) => projectCache.delete(id),
   resolveProject,
+  resumeOutside: (id, size) => chiefOfStaff.outside.resume(id, size),
   fileServiceFor: (project) => fileHandlers.fileServiceFor(project),
   files: relayFileClient,
   refreshHostCache,
diff --git a/test/e2e/g6-drop-in.spec.js b/test/e2e/g6-drop-in.spec.js
new file mode 100644
index 00000000..85169912
--- /dev/null
+++ b/test/e2e/g6-drop-in.spec.js
@@ -0,0 +1,401 @@
+const { test, expect, profiles } = require('./support/fixtures');
+const worlds = require('./support/worlds');
+
+// An idle headless Claude agent comes from a Chief of Staff Start card for a chat template on model haiku.
+// The pinned fakerelay cannot hold a Claude turn, so the Working state is reached the way a person reaches
+// it from a second device: another page's drop-in terminal holds the session, and relay reads it as running.
+// Its drop-in terminal is an echo terminal with no transcript, so the earlier history is a real-app check.
+
+const LATER = '2026-10-13T10:00:00Z';
+
+const DROP = /^Drop in to .*Reviewer$/;
+const TAKE = /^Take over .*Reviewer after this turn$/;
+const DROP_TAB = /\(drop-in\)$/;
+const CLOSE_DROP = /^Close .*\(drop-in\)$/;
+const REFUSED_HELD = "Can't drop in: a terminal already has this session; close it first";
+const DROP_ROUTE = 'POST /api/sessions/{id}/drop-in';
+
+function agentWorld() {
+  const w = worlds.base();
+  w.chief_of_staff = { project_id: 'p_acme', model: 'haiku', daily_model_calls: 20 };
+  w.projects[0].chat_templates = [{ id: 't_review', name: 'Reviewer', model: 'haiku' }];
+  // An ordinary thread: idle, but not a headless agent.
+  w.sessions = [
+    { id: 's_ledger', project_id: 'p_acme', name: 'Ledger', model: 'haiku', state: 'idle', messages: [{ role: 'user', text: 'first question' }, { role: 'assistant', text: 'first answer' }] },
+  ];
+  w.terminal_templates = [{ id: 'claude-code', name: 'Claude Code', command: '/bin/sh', description: 'Claude Code terminal' }];
+  return w;
+}
+
+function startCard() {
+  return {
+    v: 1,
+    id: 'c_start',
+    at: new Date().toISOString(),
+    kind: 'start_card',
+    byModel: true,
+    card: {
+      state: 'pending', project: { id: 'p_acme', name: 'Acme' }, folder: null, model: null, entry: 'Reviewer',
+      mode: 'headless', prompt: 'review the readme', why: 'read_not_verbatim', turnId: 't_1', result: null, error: null,
+    },
+  };
+}
+
+function outsideRow(over = {}) {
+  return {
+    id: 'outside:c1',
+    name: 'Ledger notes',
+    project_id: 'p_acme',
+    host_id: null,
+    machine: 'acme-console',
+    directory: '/work/acme',
+    branch: 'main',
+    state: 'running',
+    since: LATER,
+    updated_at: LATER,
+    source: 'probe',
+    outside: true,
+    read_only: true,
+    tmux_session: 'ledger-1',
+    viewable: true,
+    view_reason: '',
+    latest_turn: { text: 'The ledger totals match.', at: LATER, complete: true },
+    ...over,
+  };
+}
+
+function outsideWorld() {
+  const w = agentWorld();
+  w.outside_sessions = [
+    outsideRow(),
+    outsideRow({ id: 'outside:c2', name: 'Scratch pad', directory: '/work/scratch', branch: 'wip', state: 'idle', tmux_session: null, viewable: false, view_reason: 'not_in_tmux' }),
+  ];
+  return w;
+}
+
+const railOf = (page) => page.getByRole('navigation', { name: 'Agents' });
+const stripOf = (page) => page.getByRole('button', { name: /Agents$/ });
+const selectedDropTab = (page) => page.getByRole('tab', { name: DROP_TAB });
+const toastOf = (page, text) => page.getByRole('status').filter({ hasText: text });
+
+// A phone has no tab bar: the open terminal is the whole screen, titled with its name.
+async function expectPhoneDropTerminal(page) {
+  await expect(page.getByRole('textbox', { name: 'Terminal input' })).toBeVisible();
+  await expect(page.getByText('Acme - Reviewer (drop-in)', { exact: true }).filter({ visible: true })).toBeVisible();
+}
+
+async function openCos(page) {
+  // Below 600px the Bottom bar is the door a person taps.
+  const compact = page.viewportSize().width < 600;
+  const door = compact ? page.getByRole('navigation', { name: 'Navigation' }) : page;
+  await door.getByRole('button', { name: 'Chief of Staff', exact: true }).click();
+  await expect(page.getByRole('textbox', { name: 'Tell an agent' })).toBeVisible();
+}
+
+// Taps Start on the card; the agent's headless turn runs and leaves it idle.
+async function startAgent(page, relay) {
+  const card = page.getByRole('article');
+  await card.getByRole('button', { name: 'Start', exact: true }).click();
+  await relay.waitForEvent('chief_of_staff.start');
+}
+
+// Starts the agent from a wide page and waits until it rests, so the Drop in button is the signal the turn ended.
+async function startIdleOnWide(page, relay) {
+  await openCos(page);
+  await startAgent(page, relay);
+  await expect(railOf(page).getByRole('button', { name: DROP })).toBeVisible();
+}
+
+async function holdSlow(relay) {
+  const added = await relay.ctl('fault', 'add', '--route', DROP_ROUTE, '--mode', 'slow');
+  expect(added.code).toBe(0);
+  return JSON.parse(added.stdout).id;
+}
+
+async function refuseWith(relay, body) {
+  const added = await relay.ctl('fault', 'add', '--route', DROP_ROUTE, '--mode', 'error', '--status', '409', '--body', JSON.stringify(body));
+  expect(added.code).toBe(0);
+}
+
+// Page A starts the agent and drops in from the rail, so it holds the session. Returns once relay says ok.
+async function holdFromPageA(page, relay) {
+  await startIdleOnWide(page, relay);
+  await railOf(page).getByRole('button', { name: DROP }).click();
+  await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+  await expect(selectedDropTab(page)).toHaveAttribute('aria-selected', 'true');
+}
+
+test.describe('an idle agent', () => {
+  test.use({ world: agentWorld(), cosPosts: [startCard()] });
+
+  test('Today offers Drop in to an idle agent @G6.23', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    await expect(board.getByRole('heading', { name: /^Idle/, level: 4 })).toBeVisible();
+    await expect(board.getByRole('button', { name: DROP })).toBeVisible();
+  });
+
+  test('the rail offers Drop in to an idle agent @G6.41', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    await expect(railOf(page).getByRole('heading', { name: /^Idle/ })).toBeVisible();
+    await expect(railOf(page).getByRole('button', { name: DROP })).toBeEnabled();
+  });
+
+  test('a thread that is not a headless agent has no Drop in @G6.23.r3', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    // The agent's button is the marker that the board has loaded both rows.
+    await expect(board.getByRole('button', { name: DROP })).toBeVisible();
+    // Today also lists Ledger under Continue; the board's row is the one that reads its state.
+    await expect(board.getByRole('button', { name: 'Ledger', exact: true }).filter({ hasText: 'idle' })).toBeVisible();
+    await expect(board.getByRole('button', { name: /^Drop in to Ledger/ })).toHaveCount(0);
+    await expect(board.getByRole('button', { name: /^Take over Ledger/ })).toHaveCount(0);
+  });
+
+  test('the rail has no Drop in on a thread that is not a headless agent @G6.41.r2', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const rail = railOf(page);
+    await expect(rail.getByRole('button', { name: 'Ledger', exact: true })).toBeVisible();
+    await expect(rail.getByRole('button', { name: /^Drop in to Ledger/ })).toHaveCount(0);
+    await expect(rail.getByRole('button', { name: /^Take over Ledger/ })).toHaveCount(0);
+  });
+
+  test('the rail shows relay\'s reason when it refuses @G6.41.r1', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    await refuseWith(relay, { error: 'tool_running', message: 'a tool is running (Bash); wait for it to finish or stop the turn, then try again' });
+    await railOf(page).getByRole('button', { name: DROP }).click();
+    await expect(toastOf(page, "Can't drop in: a tool is running (Bash); wait for it to finish or stop the turn, then try again")).toBeVisible();
+    await expect(selectedDropTab(page)).toHaveCount(0);
+  });
+
+  test('Drop in from the rail opens its terminal @G6.41', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    await railOf(page).getByRole('button', { name: DROP }).click();
+    await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+    await expect(selectedDropTab(page)).toHaveAttribute('aria-selected', 'true');
+  });
+
+  test('closing the terminal hands the agent back to Idle with its Drop in @G6.24', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await holdFromPageA(page, relay);
+    const board = await eve.openAnother('/');
+    // Working counts the headless agent and the drop-in terminal row that holds it.
+    await expect(board.getByRole('heading', { name: 'Working 2', level: 4 })).toBeVisible();
+    await page.getByRole('button', { name: CLOSE_DROP }).click();
+    await expect(selectedDropTab(page)).toHaveCount(0);
+    await expect(board.getByRole('heading', { name: 'Idle 2', level: 4 })).toBeVisible();
+    await expect(board.getByRole('heading', { name: /^Working/, level: 4 })).toBeHidden();
+    await expect(board.getByRole('button', { name: DROP })).toBeVisible();
+  });
+
+  test('the button reads Dropping in until relay answers @G6.23', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    const drop = board.getByRole('button', { name: DROP });
+    await expect(drop).toBeVisible();
+    const faultId = await holdSlow(relay);
+    await drop.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    const busy = board.getByRole('button').filter({ hasText: 'Dropping in…' });
+    await expect(busy).toBeDisabled();
+    await expect(busy).toHaveAttribute('aria-busy', 'true');
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+    await expect(selectedDropTab(board)).toHaveAttribute('aria-selected', 'true');
+  });
+
+  test('a tool is running: one line with relay\'s reason @G6.23.r1', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    const drop = board.getByRole('button', { name: DROP });
+    await expect(drop).toBeVisible();
+    await refuseWith(relay, { error: 'tool_running', message: 'a tool is running (Bash); wait for it to finish or stop the turn, then try again' });
+    await drop.click();
+    await expect(toastOf(board, "Can't drop in: a tool is running (Bash); wait for it to finish or stop the turn, then try again")).toBeVisible();
+    await expect(selectedDropTab(board)).toHaveCount(0);
+    await expect(drop).toBeEnabled();
+  });
+
+  test('no conversation yet: one line with relay\'s reason @G6.23.r1', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    const drop = board.getByRole('button', { name: DROP });
+    await expect(drop).toBeVisible();
+    await refuseWith(relay, { error: 'no_conversation', message: 'the session has not run a turn yet;\n  there is nothing to take over' });
+    await drop.click();
+    // Relay's text had a line break; the toast shows it as one line.
+    const toast = toastOf(board, "Can't drop in: the session has not run a turn yet");
+    await expect(toast).toBeVisible();
+    // Locator text matching normalizes whitespace, so read the raw text (less the toast's close mark).
+    expect((await toast.textContent()).replace(/×$/, '')).toBe("Can't drop in: the session has not run a turn yet; there is nothing to take over");
+    await expect(selectedDropTab(board)).toHaveCount(0);
+  });
+});
+
+test.describe('a working agent', () => {
+  test.use({ world: agentWorld(), cosPosts: [startCard()] });
+
+  test('Take over waits for the turn to end, then opens a terminal @G6.105', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await holdFromPageA(page, relay);
+    const other = await eve.openAnother('/');
+    await expect(other.getByRole('heading', { name: /^Working/, level: 4 })).toBeVisible();
+    const take = other.getByRole('button', { name: TAKE });
+    await expect(take).toBeVisible();
+    await expect(other.getByRole('button', { name: DROP })).toHaveCount(0);
+
+    const faultId = await holdSlow(relay);
+    const mark = await relay.mark();
+    await take.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    const waiting = other.getByRole('button').filter({ hasText: 'Waiting for the turn to end…' });
+    await expect(waiting).toBeDisabled();
+    await expect(waiting).toHaveAttribute('aria-busy', 'true');
+    await expect(selectedDropTab(other)).toHaveCount(0);
+
+    // Page A closes its terminal: the turn is over, then relay may answer.
+    await page.getByRole('button', { name: CLOSE_DROP }).click();
+    // Ledger already sits under Idle, so the Working group emptying is the hand-back signal.
+    await expect(other.getByRole('heading', { name: /^Working/, level: 4 })).toBeHidden();
+    // The busy text follows the kind fixed at the tap, not the row's new state.
+    await expect(waiting).toBeDisabled();
+    await expect(waiting).toHaveText('Waiting for the turn to end…');
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await relay.waitForEvent('session.drop_in', { since: mark, match: (l) => l.status === 'ok' });
+    await expect(selectedDropTab(other)).toHaveAttribute('aria-selected', 'true');
+  });
+
+  test('relay refuses a take over while another terminal holds it @G6.105.r1', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await holdFromPageA(page, relay);
+    const other = await eve.openAnother('/');
+    const take = other.getByRole('button', { name: TAKE });
+    await expect(take).toBeVisible();
+    await take.click();
+    await expect(toastOf(other, REFUSED_HELD)).toBeVisible();
+    await expect(selectedDropTab(other)).toHaveCount(0);
+    await expect(take).toBeEnabled();
+  });
+
+  test('a session this page holds has no Take over here @G6.105.r2', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await holdFromPageA(page, relay);
+    // Another page shows Take over for the same session: that is the marker that the group is Working.
+    const other = await eve.openAnother('/');
+    await expect(other.getByRole('button', { name: TAKE })).toBeVisible();
+    await page.getByRole('tab', { name: 'Chief of Staff', exact: true }).click();
+    const rail = railOf(page);
+    await expect(rail.getByRole('heading', { name: /^Working/ })).toBeVisible();
+    await expect(rail.getByRole('button', { name: /^(?!Take over|Drop in)(?!.*\(drop-in\)).*Reviewer/ })).toBeVisible();
+    await expect(rail.getByRole('button', { name: /^Take over / })).toHaveCount(0);
+    await expect(rail.getByRole('button', { name: /^Drop in to / })).toHaveCount(0);
+  });
+});
+
+test.describe('outside rows', () => {
+  test.use({ world: outsideWorld() });
+
+  test('a read-only outside row never shows Drop in or Take over @G6.23.r3 @G6.105.r3', async ({ eve, page }) => {
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    // One working and one idle outside row; both rows are the marker that the rail has loaded.
+    await expect(rail.getByRole('button', { name: 'Ledger notes', exact: true })).toBeVisible();
+    await expect(rail.getByRole('button', { name: 'Scratch pad', exact: true })).toBeVisible();
+    await expect(rail.getByRole('button', { name: /^Drop in/ })).toHaveCount(0);
+    await expect(rail.getByRole('button', { name: /^Take over/ })).toHaveCount(0);
+  });
+});
+
+test.describe('on a tablet', () => {
+  test.use({ ...profiles.tablet, world: agentWorld(), cosPosts: [startCard()] });
+
+  test('tap Drop in on Today, type into the terminal, close it @G6.23', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    // The agent is started from a wide window; the board below is read at tablet width.
+    await page.setViewportSize({ width: 1280, height: 800 });
+    await startIdleOnWide(page, relay);
+    const board = await eve.openAnother('/');
+    const drop = board.getByRole('button', { name: DROP });
+    await expect(drop).toBeVisible();
+    await drop.tap();
+    await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+    await expect(selectedDropTab(board)).toHaveAttribute('aria-selected', 'true');
+    await expect(board.getByText('Read-only')).toHaveCount(0);
+    await board.getByRole('textbox', { name: 'Terminal input' }).focus();
+    await board.keyboard.type('hello agent');
+    await expect(board.getByText('hello agent', { exact: true })).toBeVisible();
+
+    await board.getByRole('button', { name: CLOSE_DROP }).tap();
+    await expect(board.getByRole('button', { name: DROP })).toBeVisible();
+  });
+});
+
+test.describe('on a phone', () => {
+  test.use({ ...profiles.phone, world: agentWorld(), cosPosts: [startCard()] });
+
+  test('tap Drop in in the agents sheet @G6.41', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await openCos(page);
+    await startAgent(page, relay);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const drop = sheet.getByRole('button', { name: DROP });
+    await expect(drop).toBeVisible();
+    const box = await drop.boundingBox();
+    expect(box.height).toBeGreaterThanOrEqual(44);
+    await drop.tap();
+    await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+    await expect(sheet).toBeHidden();
+    await expectPhoneDropTerminal(page);
+  });
+
+  test('Take over in the sheet keeps it open while it waits @G6.105', async ({ eve, page, relay }) => {
+    await eve.open('/');
+    await openCos(page);
+    await startAgent(page, relay);
+    const board = await eve.openAnother('/');
+    await board.getByRole('button', { name: DROP }).tap();
+    await relay.waitForEvent('session.drop_in', { match: (l) => l.status === 'ok' });
+    await expectPhoneDropTerminal(board);
+
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const take = sheet.getByRole('button', { name: TAKE });
+    await expect(take).toBeVisible();
+    const faultId = await holdSlow(relay);
+    await take.tap();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    await expect(sheet).toBeVisible();
+    await expect(sheet.getByRole('button').filter({ hasText: 'Waiting for the turn to end…' })).toBeDisabled();
+
+    // Relay answers with its refusal, because the other page still holds the session; the sheet then closes.
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await expect(toastOf(page, REFUSED_HELD)).toBeVisible();
+    await expect(sheet).toBeHidden();
+  });
+});
+
+test.describe('outside rows on a phone', () => {
+  test.use({ ...profiles.phone, world: outsideWorld() });
+
+  test('the agents sheet shows no button on an outside row @G6.23.r3', async ({ eve, page }) => {
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    await expect(sheet.getByRole('button', { name: 'Scratch pad', exact: true })).toBeVisible();
+    await expect(sheet.getByRole('button', { name: 'Ledger notes', exact: true })).toBeVisible();
+    await expect(sheet.getByRole('button', { name: /^Drop in/ })).toHaveCount(0);
+    await expect(sheet.getByRole('button', { name: /^Take over/ })).toHaveCount(0);
+  });
+});
diff --git a/test/e2e/g6-outside-adopt.spec.js b/test/e2e/g6-outside-adopt.spec.js
new file mode 100644
index 00000000..5c5f803a
--- /dev/null
+++ b/test/e2e/g6-outside-adopt.spec.js
@@ -0,0 +1,614 @@
+const { test, expect, profiles } = require('./support/fixtures');
+const worlds = require('./support/worlds');
+
+// A live outside Claude session that relay calls adoptable offers Adopt (idle) or Interrupt and adopt (working)
+// on the Agents board. One tap sends the row id and one boolean to eve, which asks relay to take the
+// conversation over. Relay then lists a managed idle headless session with the row's name, and the outside row goes.
+// fakerelay serves the rows from the world key `outside_sessions` (changed live with PUT /v1/outside-sessions) and
+// picks each adopt outcome from the `adopt` object on each adoptable row. The adopted session has run no turn, so a real Drop in
+// onto it is a real-app check; here the Drop in button showing is the proof.
+
+const NOW = Date.now();
+const ago = (hours) => new Date(NOW - hours * 3600 * 1000).toISOString();
+const LIVE_AT = ago(0.1);
+// A marker the browser must never see. A distinctive value, so a leak is found by plain search.
+const SID = '3f2b8c1e-9d4a-4e6b-8a57-1c2d3e4f5a6b';
+const OTHER_SID = '9a8b7c6d-5e4f-4a3b-8c2d-1e0f9a8b7c6d';
+
+const oid = (n) => `outside:${String(n).padStart(32, '0')}`;
+const ADOPT_ROUTE = 'POST /api/sessions/adopt';
+const ADOPT_PATH = /\/api\/outside-sessions\/[^/]+\/adopt$/;
+const CHIP = 'Sent by relay after it took over';
+const OK_WORLD = { model_family: 'haiku' };
+// A row that is still working: relay finds the registry entry busy until the interrupt clears it.
+const BUSY_WORLD = { busy: 'registry_busy', model_family: 'haiku' };
+
+const NO_PROJECT = "Not in a project, so it can't be adopted.";
+const ON_HOST = "On a host, so it can't be adopted here.";
+const NOT_REGISTERED = "Claude keeps no session record for it, so it can't be adopted.";
+const NOT_INTERACTIVE = "Not an interactive session, so it can't be adopted.";
+const NOT_COMMAND_LINE = "Not started from the command line, so it can't be adopted.";
+const INVALID_ID = "Its conversation id is not valid, so it can't be adopted.";
+const START_MISMATCH = "Its process changed, so it can't be adopted.";
+const AMBIGUOUS = "Two processes hold this conversation, so it can't be adopted.";
+
+// fakerelay takes `adopt` only on an adoptable row, and refuses a world where a non-adoptable row carries one.
+function liveRow(dir, over = {}) {
+  const row = {
+    id: oid(1),
+    name: 'Ledger notes',
+    project_id: 'p_acme',
+    host_id: null,
+    machine: 'acme-console',
+    directory: dir,
+    branch: 'main',
+    state: 'idle',
+    since: LIVE_AT,
+    updated_at: LIVE_AT,
+    source: 'probe',
+    outside: true,
+    read_only: true,
+    tmux_session: null,
+    viewable: false,
+    view_reason: 'not_in_tmux',
+    latest_turn: { text: 'Still working.', at: LIVE_AT, complete: true },
+    adoptable: true,
+    adopt: OK_WORLD,
+    claude_session_id: SID,
+    ...over,
+  };
+  if (row.adoptable !== true) delete row.adopt;
+  return row;
+}
+
+function endedRow(dir, over = {}) {
+  return liveRow(dir, {
+    id: oid(2),
+    name: 'Old notes',
+    state: 'ended',
+    branch: null,
+    since: ago(3),
+    updated_at: ago(2),
+    ended_at: ago(2),
+    adoptable: false,
+    adopt_reason: 'ended',
+    claude_session_id: OTHER_SID,
+    latest_turn: { text: 'Old notes final answer', at: ago(2), complete: true },
+    ...over,
+  });
+}
+
+function adoptWorld() {
+  const w = worlds.base();
+  w.chief_of_staff = { project_id: 'p_acme', model: 'haiku', daily_model_calls: 20 };
+  w.terminal_templates = [{ id: 'claude-code', name: 'Claude Code', command: '/bin/sh', description: 'Claude Code terminal' }];
+  w.hosts = [{
+    id: 'h_box',
+    name: 'testbox',
+    target: 'acme@testbox',
+    probe: { at: '2026-10-09T10:00:00Z', ok: true, os: 'Linux', arch: 'x86_64', home: '/home/acme', shell: '/bin/bash', tmux_path: '/usr/bin/tmux' },
+    tmux_path: '/usr/bin/tmux',
+    agent: 'connected',
+  }];
+  w.projects.push({ id: 'p_box', name: 'Orchard', host_id: 'h_box', path: '/home/acme/orchard', mode: 'work', files: { 'todo.txt': 'one\n' } });
+  w.outside_sessions = [];
+  return w;
+}
+
+const railOf = (page) => page.getByRole('navigation', { name: 'Agents' });
+const stripOf = (page) => page.getByRole('button', { name: /Agents$/ });
+const adoptButton = (scope, name = 'Ledger notes') => scope.getByRole('button', { name: `Adopt ${name}`, exact: true });
+const interruptButton = (scope, name = 'Ledger notes') => scope.getByRole('button', { name: `Interrupt and adopt ${name}`, exact: true });
+const dropIn = (scope, name = 'Ledger notes') => scope.getByRole('button', { name: new RegExp(`^Drop in to ${name}`) });
+const anyAdopt = (scope) => scope.getByRole('button', { name: /^(Interrupt and )?[Aa]dopt /, exact: false });
+const toastOf = (page, text) => page.getByRole('status').filter({ hasText: text });
+const adoptOk = (l) => l.status === 'ok';
+
+async function openCos(page) {
+  // Below 600px the Bottom bar is the door a person taps.
+  const compact = page.viewportSize().width < 600;
+  const door = compact ? page.getByRole('navigation', { name: 'Navigation' }) : page;
+  await door.getByRole('button', { name: 'Chief of Staff', exact: true }).click();
+  await expect(page.getByRole('textbox', { name: 'Tell an agent' })).toBeVisible();
+}
+
+// The rows are folder-bound to the project, as relay reports them: fakerelay's own per-instance folder, read
+// from its state. The rows go in through the control socket before the page opens.
+async function seed(relay, build) {
+  const state = await relay.json('ctl', 'state', '--json');
+  const dir = state.projects.find((p) => p.id === 'p_acme').path;
+  await worlds.outside.replace(relay.dir, build(dir));
+  return dir;
+}
+
+async function holdSlow(relay) {
+  const added = await relay.ctl('fault', 'add', '--route', ADOPT_ROUTE, '--mode', 'slow');
+  expect(added.code).toBe(0);
+  return JSON.parse(added.stdout).id;
+}
+
+const idleRows = (dir, adopt = OK_WORLD) => [liveRow(dir, { adopt }), endedRow(dir)];
+const workingRows = (dir, state = 'running', adopt = BUSY_WORLD) => [liveRow(dir, { state, adopt })];
+
+// One tap on a button, then the request the browser made: its body and eve's answer.
+async function tapAndCapture(page, button) {
+  const sent = page.waitForRequest((r) => r.method() === 'POST' && ADOPT_PATH.test(r.url()));
+  await button.click();
+  const request = await sent;
+  return request;
+}
+
+test.describe('an idle adoptable row', () => {
+  test.use({ world: adoptWorld() });
+
+  test('shows Adopt, and an ended row beside it has only Resume @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const adopt = adoptButton(rail);
+    await expect(adopt).toBeVisible();
+    await expect(adopt).toHaveText('Adopt');
+    await expect(adopt).toBeEnabled();
+    await expect(interruptButton(rail)).toHaveCount(0);
+    // The ended row beside it offers Resume, and no adopt button or line.
+    await expect(rail.getByRole('button', { name: 'Resume Old notes in a terminal', exact: true })).toBeVisible();
+    await expect(adoptButton(rail, 'Old notes')).toHaveCount(0);
+    await expect(anyAdopt(rail)).toHaveCount(1);
+  });
+
+  test('the tap adopts: the outside row goes and the agent shows under Idle with Drop in @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(dropIn(rail)).toHaveCount(0);
+    const request = await tapAndCapture(page, adoptButton(rail));
+    // The browser sends the row id in the path and one boolean, nothing else.
+    expect(decodeURIComponent(request.url())).toContain(`/api/outside-sessions/${oid(1)}/adopt`);
+    expect(request.postData()).toBe('{"interrupt":false}');
+
+    const done = await relay.waitForEvent('session.adopt', { match: adoptOk });
+    expect(done.interrupted).not.toBe(true);
+    await expect(dropIn(rail)).toBeVisible();
+    await expect(rail.getByRole('heading', { name: /^Idle/ })).toBeVisible();
+    await expect(anyAdopt(rail)).toHaveCount(0);
+    // The adopted agent is one managed session now.
+    const state = await relay.json('ctl', 'state', '--json');
+    expect(state.sessions.filter((s) => s.name === 'Ledger notes')).toHaveLength(1);
+  });
+
+  test('the button reads Adopting until relay answers @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const adopt = adoptButton(rail);
+    await expect(adopt).toBeVisible();
+    const faultId = await holdSlow(relay);
+    await adopt.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    const busy = rail.getByRole('button').filter({ hasText: 'Adopting…' });
+    await expect(busy).toBeDisabled();
+    await expect(busy).toHaveAttribute('aria-busy', 'true');
+    await expect(dropIn(rail)).toHaveCount(0);
+
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'released' });
+    await expect(dropIn(rail)).toBeVisible();
+    await expect(anyAdopt(rail)).toHaveCount(0);
+  });
+
+  test('a second page sees the adopted agent under Idle with Drop in @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    await eve.open('/');
+    await openCos(page);
+    await adoptButton(railOf(page)).click();
+    await relay.waitForEvent('session.adopt', { match: adoptOk });
+    const other = await eve.openAnother('/');
+    await openCos(other);
+    await expect(dropIn(railOf(other))).toBeVisible();
+    await expect(anyAdopt(railOf(other))).toHaveCount(0);
+  });
+});
+
+test.describe('a working adoptable row', () => {
+  test.use({ world: adoptWorld() });
+
+  for (const state of ['running', 'asking']) {
+    test(`a ${state} row shows Interrupt and adopt instead of Adopt @G6.108`, async ({ eve, page, relay }) => {
+      await seed(relay, (dir) => workingRows(dir, state));
+      await eve.open('/');
+      await openCos(page);
+      const rail = railOf(page);
+      const interrupt = interruptButton(rail);
+      await expect(interrupt).toBeVisible();
+      await expect(interrupt).toHaveText('Interrupt and adopt');
+      await expect(interrupt).toBeEnabled();
+      await expect(adoptButton(rail)).toHaveCount(0);
+    });
+  }
+
+  test('the tap interrupts, adopts, and the thread opens with relay\'s marked message @G6.108', async ({ eve, page, relay }) => {
+    await seed(relay, workingRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const request = await tapAndCapture(page, interruptButton(rail));
+    expect(decodeURIComponent(request.url())).toContain(`/api/outside-sessions/${oid(1)}/adopt`);
+    expect(request.postData()).toBe('{"interrupt":true}');
+
+    const done = await relay.waitForEvent('session.adopt', { match: adoptOk });
+    expect(done.interrupted).toBe(true);
+    await expect(dropIn(rail)).toBeVisible();
+    await expect(anyAdopt(rail)).toHaveCount(0);
+
+    // Relay sent one message as the owner could not; the thread marks it.
+    await rail.getByRole('button', { name: 'Ledger notes', exact: true }).click();
+    await expect(page.getByText(CHIP, { exact: true })).toBeVisible();
+  });
+
+  test('the button reads Interrupting until relay answers @G6.108', async ({ eve, page, relay }) => {
+    await seed(relay, workingRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const interrupt = interruptButton(rail);
+    await expect(interrupt).toBeVisible();
+    const faultId = await holdSlow(relay);
+    await interrupt.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    const busy = rail.getByRole('button').filter({ hasText: 'Interrupting…' });
+    await expect(busy).toBeDisabled();
+    await expect(busy).toHaveAttribute('aria-busy', 'true');
+
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'released' });
+    await expect(dropIn(rail)).toBeVisible();
+  });
+});
+
+test.describe('a row relay says is not adoptable', () => {
+  test.use({ world: adoptWorld() });
+
+  const refused = (dir) => [
+    liveRow(dir),
+    liveRow(dir, { id: oid(11), name: 'Orphan notes', project_id: null, directory: '/elsewhere', adoptable: false, adopt_reason: 'no_project' }),
+    liveRow(dir, { id: oid(12), name: 'Orchard review', project_id: 'p_box', host_id: 'h_box', machine: 'testbox', directory: '/home/acme/orchard', adoptable: false, adopt_reason: 'host_unsupported' }),
+    liveRow(dir, { id: oid(13), name: 'Piped run', adoptable: false, adopt_reason: 'not_interactive', claude_session_id: OTHER_SID }),
+    liveRow(dir, { id: oid(14), name: 'Editor run', state: 'running', adoptable: false, adopt_reason: 'not_command_line', claude_session_id: OTHER_SID }),
+    liveRow(dir, { id: oid(15), name: 'Unfiled run', adoptable: false, adopt_reason: 'not_registered', claude_session_id: OTHER_SID }),
+    liveRow(dir, { id: oid(16), name: 'Moved run', adoptable: false, adopt_reason: 'start_mismatch', claude_session_id: OTHER_SID }),
+    liveRow(dir, { id: oid(17), name: 'Odd id run', adoptable: false, adopt_reason: 'invalid_id', claude_session_id: OTHER_SID }),
+    liveRow(dir, { id: oid(18), name: 'Twin run', adoptable: false, adopt_reason: 'ambiguous', claude_session_id: OTHER_SID }),
+  ];
+
+  async function expectRefusedRows(scope) {
+    // The adoptable row has its button: the marker that the board has loaded every row.
+    await expect(adoptButton(scope)).toBeVisible();
+    await expect(scope.getByRole('button', { name: 'Orphan notes', exact: true })).toBeVisible();
+    await expect(scope.getByRole('button', { name: 'Twin run', exact: true })).toBeVisible();
+    await expect(scope.getByText(NO_PROJECT)).toBeVisible();
+    await expect(scope.getByText(ON_HOST)).toBeVisible();
+    await expect(scope.getByText(NOT_INTERACTIVE)).toBeVisible();
+    await expect(scope.getByText(NOT_COMMAND_LINE)).toBeVisible();
+    await expect(scope.getByText(NOT_REGISTERED)).toBeVisible();
+    await expect(scope.getByText(START_MISMATCH)).toBeVisible();
+    await expect(scope.getByText(INVALID_ID)).toBeVisible();
+    await expect(scope.getByText(AMBIGUOUS)).toBeVisible();
+    for (const name of ['Orphan notes', 'Orchard review', 'Piped run', 'Editor run', 'Unfiled run', 'Moved run', 'Odd id run', 'Twin run']) {
+      await expect(adoptButton(scope, name)).toHaveCount(0);
+      await expect(interruptButton(scope, name)).toHaveCount(0);
+    }
+    await expect(anyAdopt(scope)).toHaveCount(1);
+  }
+
+  test('no button, one line says why @G6.107.r1', async ({ eve, page, relay }) => {
+    await seed(relay, refused);
+    await eve.open('/');
+    await openCos(page);
+    await expectRefusedRows(railOf(page));
+  });
+
+  test('a working row has no Interrupt and adopt, and the same line @G6.108.r1', async ({ eve, page, relay }) => {
+    await seed(relay, refused);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(adoptButton(rail)).toBeVisible();
+    await expect(rail.getByRole('button', { name: 'Editor run', exact: true })).toBeVisible();
+    await expect(rail.getByText(NOT_COMMAND_LINE)).toBeVisible();
+    await expect(interruptButton(rail, 'Editor run')).toHaveCount(0);
+    await expect(rail.getByRole('button', { name: /^Interrupt and adopt /, exact: false })).toHaveCount(0);
+  });
+});
+
+test.describe('an ended row', () => {
+  test.use({ world: adoptWorld() });
+
+  test('never has an adopt button or line @G6.107.r1', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => [endedRow(dir), endedRow(dir, { id: oid(24), name: 'Older notes' })]);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(rail.getByRole('button', { name: 'Resume Old notes in a terminal', exact: true })).toBeVisible();
+    await expect(rail.getByRole('button', { name: 'Resume Older notes in a terminal', exact: true })).toBeVisible();
+    await expect(anyAdopt(rail)).toHaveCount(0);
+    await expect(rail.getByText(/can't be adopted/)).toHaveCount(0);
+  });
+});
+
+test.describe('relay refuses the adopt', () => {
+  test.describe('with the process changed, idle', () => {
+    test.use({ world: adoptWorld() });
+
+    test('the toast gives its reason on one line and the button is back @G6.107.r2', async ({ eve, page, relay }) => {
+      await seed(relay, (dir) => idleRows(dir, { ...OK_WORLD, refuse: 'changed' }));
+      await eve.open('/');
+      await openCos(page);
+      const rail = railOf(page);
+      const adopt = adoptButton(rail);
+      await expect(adopt).toBeVisible();
+      await adopt.click();
+      const logged = await relay.waitForEvent('session.adopt');
+      expect(logged.status).not.toBe('ok');
+      const toast = toastOf(page, "Can't adopt: the process or its registry entry changed");
+      await expect(toast).toBeVisible();
+      expect((await toast.textContent()).replace(/×$/, '')).toBe("Can't adopt: the process or its registry entry changed");
+      await expect(adopt).toBeEnabled();
+      await expect(adopt).toHaveText('Adopt');
+      await expect(dropIn(rail)).toHaveCount(0);
+    });
+  });
+
+  test.describe('with the process changed, working', () => {
+    test.use({ world: adoptWorld() });
+
+    test('Interrupt and adopt: the same toast and the button is back @G6.108.r2', async ({ eve, page, relay }) => {
+      await seed(relay, (dir) => workingRows(dir, 'running', { ...BUSY_WORLD, refuse: 'changed' }));
+      await eve.open('/');
+      await openCos(page);
+      const rail = railOf(page);
+      const interrupt = interruptButton(rail);
+      await expect(interrupt).toBeVisible();
+      await interrupt.click();
+      const logged = await relay.waitForEvent('session.adopt');
+      expect(logged.status).not.toBe('ok');
+      await expect(toastOf(page, "Can't adopt: the process or its registry entry changed")).toBeVisible();
+      await expect(interrupt).toBeEnabled();
+      await expect(interrupt).toHaveText('Interrupt and adopt');
+      await expect(dropIn(rail)).toHaveCount(0);
+    });
+  });
+
+  test.describe('with no model known', () => {
+    test.use({ world: adoptWorld() });
+
+    test('relay\'s model text shows as the reason @G6.107.r2', async ({ eve, page, relay }) => {
+      await seed(relay, (dir) => idleRows(dir, {}));
+      await eve.open('/');
+      await openCos(page);
+      const adopt = adoptButton(railOf(page));
+      await expect(adopt).toBeVisible();
+      await adopt.click();
+      const logged = await relay.waitForEvent('session.adopt');
+      expect(logged.status).not.toBe('ok');
+      const toast = toastOf(page, /^Can't adopt: .*model/);
+      await expect(toast).toBeVisible();
+      expect((await toast.textContent())).not.toMatch(/\n/);
+      await expect(adopt).toBeEnabled();
+      await expect(dropIn(railOf(page))).toHaveCount(0);
+    });
+  });
+
+  test.describe('with the session busy', () => {
+    test.use({ world: adoptWorld() });
+
+    test('Adopt on an idle row that relay finds busy: the busy reason, and eve sent no interrupt @G6.107.r2', async ({ eve, page, relay }) => {
+      await seed(relay, (dir) => idleRows(dir, BUSY_WORLD));
+      await eve.open('/');
+      await openCos(page);
+      const rail = railOf(page);
+      const adopt = adoptButton(rail);
+      await expect(adopt).toBeVisible();
+      const request = await tapAndCapture(page, adopt);
+      expect(request.postData()).toBe('{"interrupt":false}');
+      const logged = await relay.waitForEvent('session.adopt');
+      expect(logged.status).not.toBe('ok');
+      expect(logged.interrupted).not.toBe(true);
+      await expect(toastOf(page, /^Can't adopt: /)).toBeVisible();
+      await expect(adopt).toBeEnabled();
+      await expect(dropIn(rail)).toHaveCount(0);
+    });
+  });
+});
+
+test.describe('the browser sends only the row id', () => {
+  test.use({ world: adoptWorld() });
+
+  test('no frame, response or page text carries the Claude session id @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    const frames = [];
+    const bodies = [];
+    page.on('websocket', (ws) => {
+      ws.on('framereceived', (frame) => { frames.push(String(frame.payload)); });
+    });
+    page.on('response', (res) => {
+      bodies.push(res.text().catch(() => ''));
+    });
+    await eve.open('/');
+    await openCos(page);
+    const adopt = adoptButton(railOf(page));
+    await expect(adopt).toBeVisible();
+    const sent = page.waitForResponse((r) => ADOPT_PATH.test(r.url()));
+    await adopt.click();
+    const answer = await sent;
+    expect(answer.status()).toBe(201);
+    const body = await answer.json();
+    expect(typeof body.sessionId).toBe('string');
+    expect(Object.keys(body)).not.toContain('claudeSessionId');
+    await relay.waitForEvent('session.adopt', { match: adoptOk });
+    await expect(dropIn(railOf(page))).toBeVisible();
+    // The row reached the page, so the search below looks at real traffic.
+    expect(frames.some((f) => f.includes('Ledger notes'))).toBe(true);
+    expect(frames.filter((f) => f.includes(SID) || f.includes(OTHER_SID))).toEqual([]);
+    const texts = await Promise.all(bodies);
+    expect(texts.length).toBeGreaterThan(0);
+    expect(texts.filter((t) => t.includes(SID) || t.includes(OTHER_SID))).toEqual([]);
+    await expect(page.getByText(SID)).toHaveCount(0);
+  });
+});
+
+test.describe('the adopt route', () => {
+  test.use({ world: adoptWorld() });
+
+  // The button always sends a good request, so a call to the route is the only door to these refusals.
+  async function adoptCall(eve, id, body) {
+    const answer = await fetch(`${eve.url}/api/outside-sessions/${encodeURIComponent(id)}/adopt`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    return { status: answer.status, body: await answer.json() };
+  }
+
+  test('a bad row id answers 400 and calls no relay @G6.107.r2', async ({ eve, relay }) => {
+    await seed(relay, idleRows);
+    const mark = await relay.mark();
+    const upper = `outside:${'A'.repeat(32)}`;
+    const short = `outside:${'a'.repeat(31)}`;
+    const long = `outside:${'a'.repeat(33)}`;
+    for (const id of ['nope', 'outside:', 'outside:a b', 'inside:e1', upper, short, long, 'outside:e1']) {
+      const answer = await adoptCall(eve, id, { interrupt: false });
+      expect(answer.status, id).toBe(400);
+      expect(answer.body.error, id).toBe('invalid_request');
+    }
+    expect(await relay.logs({ event: 'session.adopt', since: mark })).toHaveLength(0);
+  });
+
+  test('an interrupt that is not true or false answers 400 and calls no relay @G6.107.r2', async ({ eve, relay }) => {
+    await seed(relay, idleRows);
+    const mark = await relay.mark();
+    const bad = [{}, { interrupt: 'true' }, { interrupt: 'false' }, { interrupt: 1 }, { interrupt: 0 }, { interrupt: null }, { interrupt: [] }, { interrupt: {} }, { other: true }];
+    for (const body of bad) {
+      const answer = await adoptCall(eve, oid(1), body);
+      expect(answer.status, JSON.stringify(body)).toBe(400);
+      expect(answer.body.error, JSON.stringify(body)).toBe('interrupt must be true or false');
+    }
+    expect(await relay.logs({ event: 'session.adopt', since: mark })).toHaveLength(0);
+  });
+
+  test('a good call answers 201 without the Claude session id, and extra body keys are not forwarded @G6.107', async ({ eve, relay }) => {
+    await seed(relay, idleRows);
+    // fakerelay refuses the chief-of-staff scope on this door, so a 201 shows eve sent none.
+    const answer = await adoptCall(eve, oid(1), { interrupt: false, claudeSessionId: OTHER_SID, model: 'opus', scope: 'chief-of-staff' });
+    expect(answer.status).toBe(201);
+    expect(typeof answer.body.sessionId).toBe('string');
+    expect(answer.body.interrupted).toBe(false);
+    expect(answer.body.recoverySent).toBe(false);
+    expect(Object.keys(answer.body)).not.toContain('claudeSessionId');
+    expect(JSON.stringify(answer.body)).not.toContain(SID);
+    expect(JSON.stringify(answer.body)).not.toContain(OTHER_SID);
+    // Relay judged the row it holds, not the id the caller named.
+    const logged = await relay.waitForEvent('session.adopt', { match: adoptOk });
+    expect(logged.outside_id).toBe(oid(1));
+    expect(logged.claude_session_id).toBe(SID);
+  });
+
+  test('a refusal from relay keeps its status and reason @G6.107.r2', async ({ eve, relay }) => {
+    await seed(relay, idleRows);
+    const answer = await adoptCall(eve, oid(99), { interrupt: false });
+    expect(answer.status).toBe(404);
+    expect(answer.body.error).toBe('outside_session_not_found');
+    expect(typeof answer.body.message).toBe('string');
+    const logged = await relay.waitForEvent('session.adopt');
+    expect(logged.status).not.toBe('ok');
+  });
+});
+
+test.describe('on a phone, an idle row', () => {
+  test.use({ ...profiles.phone, world: adoptWorld() });
+
+  test('tap Adopt in the agents sheet: the sheet stays open and shows Drop in @G6.107', async ({ eve, page, relay }) => {
+    await seed(relay, idleRows);
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const adopt = adoptButton(sheet);
+    await expect(adopt).toBeVisible();
+    const box = await adopt.boundingBox();
+    expect(box.height).toBeGreaterThanOrEqual(44);
+    await expect(interruptButton(sheet)).toHaveCount(0);
+    await adopt.tap();
+    await relay.waitForEvent('session.adopt', { match: adoptOk });
+    await expect(dropIn(sheet)).toBeVisible();
+    await expect(sheet).toBeVisible();
+    await expect(sheet.getByRole('heading', { name: /^Idle/ })).toBeVisible();
+    await expect(anyAdopt(sheet)).toHaveCount(0);
+  });
+
+});
+
+test.describe('on a phone, a working row', () => {
+  test.use({ ...profiles.phone, world: adoptWorld() });
+
+  test('the sheet shows Interrupt and adopt, 44 px tall @G6.108', async ({ eve, page, relay }) => {
+    await seed(relay, workingRows);
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const interrupt = interruptButton(sheet);
+    await expect(interrupt).toBeVisible();
+    expect((await interrupt.boundingBox()).height).toBeGreaterThanOrEqual(44);
+    await expect(adoptButton(sheet)).toHaveCount(0);
+    await interrupt.tap();
+    const done = await relay.waitForEvent('session.adopt', { match: adoptOk });
+    expect(done.interrupted).toBe(true);
+    await expect(dropIn(sheet)).toBeVisible();
+    await expect(sheet).toBeVisible();
+  });
+});
+
+test.describe('on a phone, rows relay says are not adoptable', () => {
+  test.use({ ...profiles.phone, world: adoptWorld() });
+
+  test('the sheet shows each line and no button @G6.107.r1', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => [
+      liveRow(dir),
+      liveRow(dir, { id: oid(11), name: 'Orphan notes', project_id: null, directory: '/elsewhere', adoptable: false, adopt_reason: 'no_project' }),
+      liveRow(dir, { id: oid(13), name: 'Piped run', adoptable: false, adopt_reason: 'not_interactive', claude_session_id: OTHER_SID }),
+    ]);
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    await expect(adoptButton(sheet)).toBeVisible();
+    await expect(sheet.getByText(NO_PROJECT)).toBeVisible();
+    await expect(sheet.getByText(NOT_INTERACTIVE)).toBeVisible();
+    await expect(adoptButton(sheet, 'Orphan notes')).toHaveCount(0);
+    await expect(adoptButton(sheet, 'Piped run')).toHaveCount(0);
+    await expect(anyAdopt(sheet)).toHaveCount(1);
+  });
+});
+
+test.describe('on a phone, when relay refuses', () => {
+  test.use({ ...profiles.phone, world: adoptWorld() });
+
+  test('the sheet closes and the toast shows the reason @G6.107.r2', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => idleRows(dir, { ...OK_WORLD, refuse: 'changed' }));
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const adopt = adoptButton(sheet);
+    await expect(adopt).toBeVisible();
+    await adopt.tap();
+    await relay.waitForEvent('session.adopt');
+    await expect(toastOf(page, "Can't adopt: the process or its registry entry changed")).toBeVisible();
+    await expect(sheet).toBeHidden();
+    await stripOf(page).tap();
+    await expect(adoptButton(page.getByRole('dialog', { name: 'Agents' }))).toBeEnabled();
+  });
+});
diff --git a/test/e2e/g6-outside-resume.spec.js b/test/e2e/g6-outside-resume.spec.js
new file mode 100644
index 00000000..153eafaa
--- /dev/null
+++ b/test/e2e/g6-outside-resume.spec.js
@@ -0,0 +1,399 @@
+const { test, expect, profiles } = require('./support/fixtures');
+const worlds = require('./support/worlds');
+
+// An ended outside Claude session in a registered console project offers Resume: one tap opens a read-write
+// claude-code terminal in the session's folder, resumed on the same conversation. fakerelay serves the rows
+// from the world key `outside_sessions`; an ended row carries `claude_session_id`, which relay keeps private.
+// fakerelay's terminal is an echo terminal with no transcript, so the history in the terminal is a real-app check.
+
+const NOW = Date.now();
+const ago = (hours) => new Date(NOW - hours * 3600 * 1000).toISOString();
+const LIVE_AT = ago(0.1);
+// The id is a marker the browser must never see. A distinctive value, so a leak is found by plain search.
+const SID = '3f2b8c1e-9d4a-4e6b-8a57-1c2d3e4f5a6b';
+
+const RESUME ='Resume Ledger notes in a terminal';
+const TAB = /Ledger notes \(resumed\)$/;
+const CLOSE = /^Close .*\(resumed\)$/;
+const NO_PROJECT = "Not in a project, so it can't be resumed.";
+const ON_HOST = "On a host, so it can't be resumed here.";
+const ROUTE = 'POST /api/terminals';
+
+function liveRow(dir, over = {}) {
+  return {
+    id: 'outside:live',
+    name: 'Live runner',
+    project_id: 'p_acme',
+    host_id: null,
+    machine: 'acme-console',
+    directory: dir,
+    branch: 'main',
+    state: 'running',
+    since: LIVE_AT,
+    updated_at: LIVE_AT,
+    source: 'probe',
+    outside: true,
+    read_only: true,
+    tmux_session: null,
+    viewable: false,
+    view_reason: 'not_in_tmux',
+    latest_turn: { text: 'Still working.', at: LIVE_AT, complete: true },
+    ...over,
+  };
+}
+
+function endedRow(dir, over = {}) {
+  return liveRow(dir, {
+    id: 'outside:e1',
+    name: 'Ledger notes',
+    state: 'ended',
+    branch: null,
+    since: ago(3),
+    updated_at: ago(2),
+    ended_at: ago(2),
+    claude_session_id: SID,
+    latest_turn: { text: 'Ledger notes final answer', at: ago(2), complete: true },
+    ...over,
+  });
+}
+
+function resumeWorld() {
+  const w = worlds.base();
+  w.chief_of_staff = { project_id: 'p_acme', model: 'haiku', daily_model_calls: 20 };
+  w.terminal_templates = [{ id: 'claude-code', name: 'Claude Code', command: '/bin/sh', description: 'Claude Code terminal' }];
+  w.hosts = [{
+    id: 'h_box',
+    name: 'testbox',
+    target: 'acme@testbox',
+    probe: { at: '2026-10-09T10:00:00Z', ok: true, os: 'Linux', arch: 'x86_64', home: '/home/acme', shell: '/bin/bash', tmux_path: '/usr/bin/tmux' },
+    tmux_path: '/usr/bin/tmux',
+    agent: 'connected',
+  }];
+  w.projects.push({ id: 'p_box', name: 'Orchard', host_id: 'h_box', path: '/home/acme/orchard', mode: 'work', files: { 'todo.txt': 'one\n' } });
+  w.outside_sessions = [];
+  return w;
+}
+
+const railOf = (page) => page.getByRole('navigation', { name: 'Agents' });
+const stripOf = (page) => page.getByRole('button', { name: /Agents$/ });
+const resumeButton = (scope, name = RESUME) => scope.getByRole('button', { name, exact: true });
+const anyResume = (scope) => scope.getByRole('button', { name: /^Resume /, exact: false });
+const toastOf = (page, text) => page.getByRole('status').filter({ hasText: text });
+const resumedTab = (page) => page.getByRole('tab', { name: TAB });
+
+async function openCos(page) {
+  // Below 600px the Bottom bar is the door a person taps.
+  const compact = page.viewportSize().width < 600;
+  const door = compact ? page.getByRole('navigation', { name: 'Navigation' }) : page;
+  await door.getByRole('button', { name: 'Chief of Staff', exact: true }).click();
+  await expect(page.getByRole('textbox', { name: 'Tell an agent' })).toBeVisible();
+}
+
+// The ended row's folder is the project's folder, as relay reports it: fakerelay's own per-instance folder,
+// read from its state. The rows go in through the control socket before the page opens.
+async function seed(relay, build) {
+  const state = await relay.json('ctl', 'state', '--json');
+  const dir = state.projects.find((p) => p.id === 'p_acme').path;
+  await worlds.outside.replace(relay.dir, build(dir));
+  return dir;
+}
+
+const resumeLaunch = (l) => l.kind === 'terminal' && Array.isArray(l.extra_args) && l.extra_args[0] === '--resume';
+
+// The rows of the standard world: one live, one ended in a console project.
+const consoleRows = (dir) => [liveRow(dir), endedRow(dir)];
+
+test.describe('an ended row in a console project', () => {
+  test.use({ world: resumeWorld() });
+
+  test('a tap opens a read-write claude-code terminal resumed on the same conversation @G6.106', async ({ eve, page, relay }) => {
+    const dir = await seed(relay, consoleRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const resume = resumeButton(rail);
+    await expect(resume).toBeVisible();
+    await expect(resume).toHaveText('Resume');
+    await expect(resume).toBeEnabled();
+    // A live row beside it has none.
+    await expect(rail.getByRole('button', { name: 'Live runner', exact: true })).toBeVisible();
+    await expect(resumeButton(rail, 'Resume Live runner in a terminal')).toHaveCount(0);
+
+    await resume.click();
+    const launch = await relay.waitForEvent('session.launch', { match: resumeLaunch });
+    expect(launch.template_id).toBe('claude-code');
+    expect(launch.directory).toBe(dir);
+    expect(launch.extra_args).toEqual(['--resume', SID]);
+
+    await expect(resumedTab(page)).toHaveAttribute('aria-selected', 'true');
+    await expect(page.getByText('Read-only', { exact: true })).toHaveCount(0);
+    await page.getByRole('textbox', { name: 'Terminal input' }).focus();
+    await page.keyboard.type('hello resumed');
+    await expect(page.getByText('hello resumed', { exact: true })).toBeVisible();
+  });
+
+  test('the button reads Resuming until relay answers, then Resumed @G6.106', async ({ eve, page, relay }) => {
+    await seed(relay, consoleRows);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    const resume = resumeButton(rail);
+    await expect(resume).toBeVisible();
+    const added = await relay.ctl('fault', 'add', '--route', ROUTE, '--mode', 'slow');
+    expect(added.code).toBe(0);
+    const faultId = JSON.parse(added.stdout).id;
+
+    await resume.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'held' });
+    const busy = rail.getByRole('button').filter({ hasText: 'Resuming…' });
+    await expect(busy).toBeDisabled();
+    await expect(busy).toHaveAttribute('aria-busy', 'true');
+    await expect(resumedTab(page)).toHaveCount(0);
+
+    expect((await relay.ctl('fault', 'release', '--id', faultId)).code).toBe(0);
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'released' });
+    await expect(resumedTab(page)).toHaveAttribute('aria-selected', 'true');
+
+    // Back on the Chief of Staff tab the row says the conversation is resumed, and offers no second terminal.
+    await page.getByRole('tab', { name: 'Chief of Staff', exact: true }).click();
+    const done = rail.getByRole('button').filter({ hasText: /^Resumed$/ });
+    await expect(done).toBeVisible();
+    await expect(done).toBeDisabled();
+  });
+
+  test('closing the resumed terminal brings the Resume button back @G6.106', async ({ eve, page, relay }) => {
+    await seed(relay, consoleRows);
+    await eve.open('/');
+    await openCos(page);
+    await resumeButton(railOf(page)).click();
+    await relay.waitForEvent('session.launch', { match: resumeLaunch });
+    await expect(resumedTab(page)).toHaveAttribute('aria-selected', 'true');
+    await page.getByRole('button', { name: CLOSE }).click();
+    await expect(resumedTab(page)).toHaveCount(0);
+    await expect.poll(async () => (await relay.json('ctl', 'state', '--json')).terminals ?? []).toEqual([]);
+    await openCos(page);
+    const back = resumeButton(railOf(page));
+    await expect(back).toBeVisible();
+    await expect(back).toBeEnabled();
+    await expect(back).toHaveText('Resume');
+  });
+
+  test('relay refuses: the toast gives its reason and the button is back @G6.106.r3', async ({ eve, page, relay }) => {
+    await seed(relay, consoleRows);
+    await eve.open('/');
+    await openCos(page);
+    const resume = resumeButton(railOf(page));
+    await expect(resume).toBeVisible();
+    const added = await relay.ctl('fault', 'add', '--route', ROUTE, '--mode', 'error', '--status', '500', '--body', '{"error":"no room"}');
+    expect(added.code).toBe(0);
+    await resume.click();
+    await relay.waitForEvent('fakerelay.fault', { match: (l) => l.action === 'applied' });
+    await expect(toastOf(page, "Can't resume: no room")).toBeVisible();
+    await expect(resumedTab(page)).toHaveCount(0);
+    await expect(resume).toBeEnabled();
+    await expect(resume).toHaveText('Resume');
+  });
+});
+
+test.describe('the browser never sees the Claude session id', () => {
+  test.use({ world: resumeWorld() });
+
+  test('no frame, response or page text carries the id @G6.106', async ({ eve, page, relay }) => {
+    await seed(relay, consoleRows);
+    const frames = [];
+    const bodies = [];
+    page.on('websocket', (ws) => {
+      ws.on('framereceived', (frame) => { frames.push(String(frame.payload)); });
+    });
+    page.on('response', (res) => {
+      bodies.push(res.text().catch(() => ''));
+    });
+    await eve.open('/');
+    await openCos(page);
+    const resume = resumeButton(railOf(page));
+    await expect(resume).toBeVisible();
+    await resume.click();
+    await relay.waitForEvent('session.launch', { match: resumeLaunch });
+    await expect(resumedTab(page)).toHaveAttribute('aria-selected', 'true');
+    // The row reached the page, so the search below looks at real traffic.
+    expect(frames.some((f) => f.includes('Ledger notes'))).toBe(true);
+    expect(frames.filter((f) => f.includes(SID))).toEqual([]);
+    const texts = await Promise.all(bodies);
+    expect(texts.length).toBeGreaterThan(0);
+    expect(texts.filter((t) => t.includes(SID))).toEqual([]);
+    // Nor does the screen.
+    await expect(page.getByText(SID)).toHaveCount(0);
+  });
+});
+
+test.describe('an ended row with no project', () => {
+  test.use({ world: resumeWorld() });
+
+  test('no button, one line says why @G6.106.r1', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => [endedRow(dir), endedRow(dir, { id: 'outside:e2', name: 'Orphan notes', project_id: null, directory: '/elsewhere' })]);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    // The row in a project has its button: the marker that the rail has loaded both rows.
+    await expect(resumeButton(rail)).toBeVisible();
+    await expect(rail.getByText('Orphan notes', { exact: true })).toBeVisible();
+    await expect(rail.getByText(NO_PROJECT)).toBeVisible();
+    await expect(resumeButton(rail, 'Resume Orphan notes in a terminal')).toHaveCount(0);
+    await expect(anyResume(rail)).toHaveCount(1);
+  });
+});
+
+test.describe('an ended row on a host', () => {
+  test.use({ world: resumeWorld() });
+
+  test('no button, one line says why @G6.106.r2', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => [
+      endedRow(dir),
+      endedRow(dir, { id: 'outside:e3', name: 'Orchard review', project_id: 'p_box', host_id: 'h_box', machine: 'testbox', directory: '/home/acme/orchard' }),
+    ]);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(resumeButton(rail)).toBeVisible();
+    await expect(rail.getByText('Orchard review', { exact: true })).toBeVisible();
+    await expect(rail.getByText(ON_HOST)).toBeVisible();
+    await expect(resumeButton(rail, 'Resume Orchard review in a terminal')).toHaveCount(0);
+    await expect(anyResume(rail)).toHaveCount(1);
+  });
+
+  test('a row with no host in a project on a host: no button, the same line @G6.106.r2', async ({ eve, page, relay }) => {
+    await seed(relay, (dir) => [
+      endedRow(dir),
+      endedRow(dir, { id: 'outside:e4', name: 'Orchard notes', project_id: 'p_box', host_id: null, directory: '/home/acme/orchard' }),
+    ]);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(resumeButton(rail)).toBeVisible();
+    await expect(rail.getByText('Orchard notes', { exact: true })).toBeVisible();
+    await expect(rail.getByText(ON_HOST)).toBeVisible();
+    await expect(resumeButton(rail, 'Resume Orchard notes in a terminal')).toHaveCount(0);
+    await expect(anyResume(rail)).toHaveCount(1);
+  });
+});
+
+test.describe('a live row', () => {
+  test.use({ world: resumeWorld() });
+
+  test('never shows Resume or a reason, and a row that goes live loses its button @G6.106', async ({ eve, page, relay }) => {
+    const dir = await seed(relay, (d) => [endedRow(d), liveRow(d, { id: 'outside:live', name: 'Live runner' })]);
+    await eve.open('/');
+    await openCos(page);
+    const rail = railOf(page);
+    await expect(resumeButton(rail)).toBeVisible();
+    await expect(rail.getByRole('button', { name: 'Live runner', exact: true })).toBeVisible();
+    await expect(resumeButton(rail, 'Resume Live runner in a terminal')).toHaveCount(0);
+    await expect(rail.getByText(NO_PROJECT)).toHaveCount(0);
+    await expect(rail.getByText(ON_HOST)).toHaveCount(0);
+
+    // The same conversation runs again: relay lists it live, with no Claude session id.
+    await worlds.outside.replace(relay.dir, [
+      liveRow(dir, { id: 'outside:e1', name: 'Ledger notes', state: 'running' }),
+      liveRow(dir, { id: 'outside:live', name: 'Live runner' }),
+    ]);
+    const nowLive = rail.getByRole('button', { name: 'Ledger notes', exact: true });
+    await expect(nowLive).toBeVisible();
+    await expect(anyResume(rail)).toHaveCount(0);
+    await expect(rail.getByText(NO_PROJECT)).toHaveCount(0);
+    await expect(rail.getByText(ON_HOST)).toHaveCount(0);
+  });
+});
+
+test.describe('the resume route refuses bad requests', () => {
+  test.use({ world: resumeWorld() });
+
+  // The button always sends a good request, so a call to the route is the only door to these refusals.
+  async function resumeCall(eve, id, body) {
+    const answer = await fetch(`${eve.url}/api/outside-sessions/${encodeURIComponent(id)}/resume`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    return { status: answer.status, body: await answer.json() };
+  }
+
+  test('a bad session id answers 400 and calls no relay @G6.106', async ({ eve, relay }) => {
+    await seed(relay, consoleRows);
+    const mark = await relay.mark();
+    for (const id of ['nope', 'outside:', 'outside:a b', 'inside:e1']) {
+      const answer = await resumeCall(eve, id, { cols: 80, rows: 24 });
+      expect(answer.status).toBe(400);
+      expect(answer.body.error).toBe('invalid_request');
+    }
+    expect(await relay.logs({ event: 'session.launch', since: mark })).toHaveLength(0);
+  });
+
+  test('cols or rows that are not whole numbers from 1 to 500 answer 400 and call no relay @G6.106', async ({ eve, relay }) => {
+    await seed(relay, consoleRows);
+    const mark = await relay.mark();
+    const bad = [
+      { cols: 0, rows: 24 }, { cols: 80, rows: 0 }, { cols: 501, rows: 24 }, { cols: 80, rows: 501 },
+      { cols: 1.5, rows: 24 }, { cols: 80, rows: 2.5 }, { cols: '80', rows: 24 }, { cols: 80, rows: '24' },
+      { cols: -1, rows: 24 }, { rows: 24 }, { cols: 80 }, {},
+    ];
+    for (const body of bad) {
+      const answer = await resumeCall(eve, 'outside:e1', body);
+      expect(answer.status, JSON.stringify(body)).toBe(400);
+      expect(answer.body.error, JSON.stringify(body)).toBe('cols and rows must be whole numbers from 1 to 500');
+    }
+    expect(await relay.logs({ event: 'session.launch', since: mark })).toHaveLength(0);
+  });
+});
+
+test.describe('on a tablet', () => {
+  test.use({ ...profiles.tablet, world: resumeWorld() });
+
+  test('tap Resume, type into the terminal @G6.106', async ({ eve, page, relay }) => {
+    await seed(relay, consoleRows);
+    await eve.open('/');
+    // The Chief of Staff door sits in the Rail, which is closed at tablet width: open it from a wide window,
+    // then use the Agents strip and sheet at tablet width.
+    await page.setViewportSize({ width: 1280, height: 800 });
+    await openCos(page);
+    await page.setViewportSize({ width: 712, height: 1138 });
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const resume = resumeButton(sheet);
+    await expect(resume).toBeVisible();
+    expect((await resume.boundingBox()).height).toBeGreaterThanOrEqual(44);
+    await resume.tap();
+    const launch = await relay.waitForEvent('session.launch', { match: resumeLaunch });
+    expect(launch.template_id).toBe('claude-code');
+    expect(launch.extra_args).toEqual(['--resume', SID]);
+    await expect(resumedTab(page)).toHaveAttribute('aria-selected', 'true');
+    await expect(page.getByText('Read-only', { exact: true })).toHaveCount(0);
+    await page.getByRole('textbox', { name: 'Terminal input' }).focus();
+    await page.keyboard.type('hello resumed');
+    await expect(page.getByText('hello resumed', { exact: true })).toBeVisible();
+  });
+});
+
+test.describe('on a phone', () => {
+  test.use({ ...profiles.phone, world: resumeWorld() });
+
+  test('tap Resume in the agents sheet @G6.106', async ({ eve, page, relay }) => {
+    const dir = await seed(relay, consoleRows);
+    await eve.open('/');
+    await openCos(page);
+    await stripOf(page).tap();
+    const sheet = page.getByRole('dialog', { name: 'Agents' });
+    const resume = resumeButton(sheet);
+    await expect(resume).toBeVisible();
+    expect((await resume.boundingBox()).height).toBeGreaterThanOrEqual(44);
+    await resume.tap();
+    const launch = await relay.waitForEvent('session.launch', { match: resumeLaunch });
+    expect(launch.template_id).toBe('claude-code');
+    expect(launch.directory).toBe(dir);
+    expect(launch.extra_args).toEqual(['--resume', SID]);
+    await expect(sheet).toBeHidden();
+    // A phone has no tab bar: the open terminal is the whole screen, titled with its name.
+    await expect(page.getByRole('textbox', { name: 'Terminal input' })).toBeVisible();
+    await expect(page.getByText(/Ledger notes \(resumed\)/).filter({ visible: true })).toBeVisible();
+    await expect(page.getByText('Read-only', { exact: true })).toHaveCount(0);
+  });
+});
diff --git a/test/e2e/relay-pin.json b/test/e2e/relay-pin.json
index 9e7e87df..c493755b 100644
--- a/test/e2e/relay-pin.json
+++ b/test/e2e/relay-pin.json
@@ -1,5 +1,5 @@
 {
   "schema": 1,
-  "fakerelay": { "repo": "https://github.com/barelyworkingcode/relay", "commit": "319594edb482169f8542edf007e465b2ac6c048c", "dir": "fakerelay", "pkg": "./cmd/fakerelay" },
+  "fakerelay": { "repo": "https://github.com/barelyworkingcode/relay", "commit": "2faa42108c59be39e7fd26d81b0a3886acb5eab4", "dir": "fakerelay", "pkg": "./cmd/fakerelay" },
   "relayScheduler": { "repo": "https://github.com/barelyworkingcode/relayScheduler", "commit": "9fe52fa96e8a8b16a66915c81156841a28548e0d", "dir": ".", "pkg": "." }
 }
diff --git a/test/static/frozen.json b/test/static/frozen.json
index 3c713794..932c815f 100644
--- a/test/static/frozen.json
+++ b/test/static/frozen.json
@@ -110,7 +110,8 @@
     {"id":"research-citations","needs":[],"areas":["chat"],"timeoutMs":180000},
     {"id":"chat-pasted-url-source","needs":[],"areas":["chat"],"timeoutMs":180000},
     {"id":"chat-tool-search","needs":[],"areas":["chat"],"timeoutMs":240000},
-    {"id":"outside-thread","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":600000},
+    {"id":"outside-thread","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":720000},
+    {"id":"outside-adopt","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":480000},
     {"id":"cos-outside-hooks","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":360000},
     {"id":"cos-add-agent","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":300000,"screen":true},
     {"id":"cos-start-entry","needs":["project:acme"],"areas":["chief-of-staff"],"timeoutMs":480000,"screen":true},
diff --git a/test/static/outside-resume-selftest.js b/test/static/outside-resume-selftest.js
new file mode 100644
index 00000000..1698034c
--- /dev/null
+++ b/test/static/outside-resume-selftest.js
@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+'use strict';
+
+// Self-test for resuming an ended outside session (#593), from the issue's contract for
+// ChiefOfStaffOutside#resume. A stub relayTransport serves the inventory and records every
+// call; the POST answer is a promise the test controls. No waits on durations.
+// The route (400s) is not covered here: no static selftest runs routes without the full server.
+
+const assert = require('assert');
+const path = require('path');
+
+const EVE = path.resolve(__dirname, '..', '..');
+const { ChiefOfStaffOutside } = require(path.join(EVE, 'chief-of-staff-outside'));
+
+const ROOT = '/api/chief-of-staff/outside-sessions';
+const UUID = '0a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d';
+const UUID2 = 'f0e1d2c3-b4a5-4968-8776-655443322110';
+const SIZE = { cols: 120, rows: 40 };
+
+const ended = (n, extra = {}) => ({
+  id: `outside:${n}`, name: `Claude — folder${n}`, machine: 'testbox', directory: `/work/folder${n}`,
+  projectId: 'p1', state: 'ended', endedAt: '2026-10-01T00:00:00Z', outside: true, readOnly: true,
+  claudeSessionId: UUID, ...extra,
+});
+
+function setup({ rows, project = { id: 'p1' } } = {}) {
+  const f = { revision: 0, rows: rows || [], calls: [], post: null, frames: [] };
+  f.transport = {
+    async fetch(method, url, body, scope) {
+      f.calls.push({ method, url, body, scope, argc: arguments.length });
+      if (method === 'GET' && url === ROOT) {
+        return { status: 200, data: { revision: ++f.revision, probeIntervalMs: 15000, sessions: f.rows, machines: [] } };
+      }
+      if (method === 'GET') {
+        const id = decodeURIComponent(url.slice(ROOT.length + 1));
+        const session = f.rows.find(r => r.id === id);
+        return session ? { status: 200, data: { session, lastTurn: { text: 'hi', at: 'x', complete: true }, lastExcerpt: 'hi' } } : { status: 404, data: {} };
+      }
+      return f.post();
+    },
+  };
+  f.outside = new ChiefOfStaffOutside({
+    relayTransport: f.transport, onSnapshot: s => f.frames.push(s),
+    resolveProject: id => (id === 'p1' ? project : null),
+  });
+  f.posts = () => f.calls.filter(c => c.method === 'POST');
+  f.refresh = () => f.outside.list();
+  return f;
+}
+const answer = (status, data) => () => Promise.resolve({ status, data });
+
+(async () => {
+  // Refusals, in contract order. None calls relay with a POST.
+  {
+    const f = setup({ rows: [ended(1)] });
+    await f.refresh();
+    f.post = () => { throw new Error('relay must not be called'); };
+
+    let r = await f.outside.resume('outside:nope', SIZE);
+    assert.deepStrictEqual(r, { status: 404, body: { error: 'outside_session_not_found', message: 'That session is no longer in the list.' } });
+    assert.strictEqual(f.posts().length, 0);
+
+    // Live row with no project: the live answer wins (check 2 before 3).
+    f.rows = [{ ...ended(2), state: 'working', projectId: undefined, claudeSessionId: undefined }];
+    await f.refresh();
+    r = await f.outside.resume('outside:2', SIZE);
+    assert.deepStrictEqual(r, { status: 409, body: { error: 'outside_session_live', message: 'This session is still running. Only an ended session can be resumed.' } });
+
+    // No project (check 3), and a project that does not resolve; the host check comes after.
+    const noProject = "Not in a project, so it can't be resumed.";
+    f.rows = [ended(3, { projectId: undefined, hostId: 'h1' }), ended(4, { projectId: 'gone' })];
+    await f.refresh();
+    for (const id of ['outside:3', 'outside:4']) {
+      r = await f.outside.resume(id, SIZE);
+      assert.deepStrictEqual(r, { status: 409, body: { error: 'outside_resume_unavailable', message: noProject } }, id);
+    }
+
+    // Host: on the row, or on the project. Host check comes before the id check.
+    const onHost = "On a host, so it can't be resumed here.";
+    f.rows = [ended(5, { hostId: 'h1', claudeSessionId: 'bad' })];
+    await f.refresh();
+    r = await f.outside.resume('outside:5', SIZE);
+    assert.deepStrictEqual(r, { status: 409, body: { error: 'outside_resume_unavailable', message: onHost } });
+    const g = setup({ rows: [ended(6)], project: { id: 'p1', hostId: 'h2' } });
+    await g.refresh();
+    g.post = f.post;
+    r = await g.outside.resume('outside:6', SIZE);
+    assert.deepStrictEqual(r, { status: 409, body: { error: 'outside_resume_unavailable', message: onHost } });
+    assert.strictEqual(g.posts().length, 0);
+
+    // Bad or missing conversation id: not a UUID, extra characters, flag-like, absent.
+    const noId = "Relay gave no conversation id, so it can't be resumed.";
+    const bad = ['--dangerously-skip-permissions', 'not-a-uuid', `${UUID}x`, ` ${UUID}`, `${UUID}\n--x`, '', undefined, 42];
+    for (const [i, v] of bad.entries()) {
+      f.rows = [ended(7, { claudeSessionId: v })];
+      await f.refresh();
+      r = await f.outside.resume('outside:7', SIZE);
+      assert.deepStrictEqual(r, { status: 409, body: { error: 'outside_resume_unavailable', message: noId } }, `bad id #${i}`);
+    }
+    assert.strictEqual(f.posts().length, 0, 'no relay POST on any refusal');
+  }
+
+  // Accepted: one POST with the exact body and no scope; uppercase UUID is accepted.
+  {
+    const f = setup({ rows: [ended(1, { claudeSessionId: UUID.toUpperCase() })] });
+    await f.refresh();
+    f.post = answer(201, { terminalId: 't1', name: 'x' });
+    const r = await f.outside.resume('outside:1', SIZE);
+    assert.deepStrictEqual(r, { status: 201, body: { terminal: { terminalId: 't1', name: 'x' } } });
+    assert.strictEqual(f.posts().length, 1);
+    const [call] = f.posts();
+    assert.strictEqual(call.url, '/api/terminals');
+    assert.strictEqual(call.argc, 3, 'no scope argument');
+    assert.strictEqual(call.scope, undefined);
+    assert.deepStrictEqual(call.body, {
+      templateId: 'claude-code', name: 'Claude — folder1 (resumed)', directory: '/work/folder1',
+      projectId: 'p1', cols: 120, rows: 40, extraArgs: ['--resume', UUID.toUpperCase()],
+    });
+  }
+
+  // Relay answer mappings, and the busy guard.
+  {
+    const f = setup({ rows: [ended(1)] });
+    await f.refresh();
+    const cases = [
+      [answer(200, {}), 502, { error: 'resume_failed', message: 'Relay did not return a terminal.' }],
+      [answer(204, undefined), 502, { error: 'resume_failed', message: 'Relay did not return a terminal.' }],
+      [answer(403, { code: 'forbidden', error: 'Nope.' }), 403, { error: 'forbidden', message: 'Nope.' }],
+      [answer(500, {}), 500, { error: 'resume_failed', message: 'Relay answered 500.' }],
+      [answer(422, undefined), 422, { error: 'resume_failed', message: 'Relay answered 422.' }],
+      [() => Promise.reject(new Error('socket hang up')), 502, { error: 'Service unavailable' }],
+      [() => { throw new Error('sync boom'); }, 502, { error: 'Service unavailable' }],
+    ];
+    for (const [post, status, body] of cases) {
+      f.post = post;
+      const r = await f.outside.resume('outside:1', SIZE);
+      assert.deepStrictEqual(r, { status, body });
+      assert.strictEqual(f.outside.resuming.size, 0, 'busy guard released after an answer');
+    }
+
+    // Second resume while the first is in flight: busy, and no second POST.
+    let release;
+    f.calls.length = 0;
+    f.post = () => new Promise(res => { release = res; });
+    const first = f.outside.resume('outside:1', SIZE);
+    const second = await f.outside.resume('outside:1', SIZE);
+    assert.deepStrictEqual(second, { status: 409, body: { error: 'outside_resume_busy', message: 'This session is already being resumed.' } });
+    assert.strictEqual(f.posts().length, 1);
+    release({ status: 201, data: { terminalId: 't9' } });
+    assert.strictEqual((await first).status, 201);
+    // The bad-id check (5) comes before the busy check (6): a resume in flight, then a snapshot
+    // where the same row has no usable id, answers unavailable and not busy.
+    f.post = () => new Promise(res => { release = res; });
+    const held = f.outside.resume('outside:1', SIZE);
+    f.rows = [ended(1, { claudeSessionId: 'not-a-uuid' })];
+    await f.refresh();
+    assert.deepStrictEqual(await f.outside.resume('outside:1', SIZE),
+      { status: 409, body: { error: 'outside_resume_unavailable', message: "Relay gave no conversation id, so it can't be resumed." } });
+    release({ status: 201, data: { terminalId: 't11' } });
+    await held;
+    f.rows = [ended(1)];
+    await f.refresh();
+    // Released: a later resume is accepted again.
+    f.post = answer(201, { terminalId: 't10' });
+    assert.strictEqual((await f.outside.resume('outside:1', SIZE)).status, 201);
+  }
+
+  // The Claude session id never leaves the class.
+  {
+    const f = setup({ rows: [ended(1), ended(2, { claudeSessionId: UUID2 })] });
+    await f.refresh();
+    const reads = [f.outside.getSnapshot(), f.outside.browserSnapshot(), await f.outside.list(),
+      await f.outside.detail('outside:1'), await f.outside.detail('outside:2'), ...f.frames];
+    // Let the ended-row turn fill finish so its frame is included.
+    await f.outside._fillTurns();
+    reads.push(...f.frames);
+    assert.ok(f.frames.length > 0);
+    for (const out of reads) {
+      const text = JSON.stringify(out);
+      assert.ok(!text.includes(UUID) && !text.includes(UUID2), 'conversation id leaked');
+      assert.ok(!/claudeSessionId/i.test(text), 'conversation id field leaked');
+    }
+  }
+
+  // The map follows each accepted snapshot.
+  {
+    const f = setup({ rows: [ended(1), ended(2)] });
+    await f.refresh();
+    f.post = answer(201, { terminalId: 't1' });
+    assert.strictEqual((await f.outside.resume('outside:2', SIZE)).status, 201);
+    f.rows = [ended(1)];
+    await f.refresh();
+    assert.strictEqual((await f.outside.resume('outside:2', SIZE)).status, 404);
+    // A row that turns live is refused as live, not as a missing id.
+    f.rows = [{ ...ended(1), state: 'working', claudeSessionId: undefined }];
+    await f.refresh();
+    const live = await f.outside.resume('outside:1', SIZE);
+    assert.strictEqual(live.status, 409);
+    assert.strictEqual(live.body.error, 'outside_session_live');
+    // The id in an older snapshot is replaced, not kept: a new id is the one sent.
+    f.rows = [ended(1, { claudeSessionId: UUID2 })];
+    await f.refresh();
+    f.calls.length = 0;
+    await f.outside.resume('outside:1', SIZE);
+    assert.deepStrictEqual(f.posts()[0].body.extraArgs, ['--resume', UUID2]);
+  }
+
+  console.log('outside-resume selftest: ok');
+})().catch(e => { console.error(e); process.exit(1); });