@ordewell/cli 0.4.23 → 0.5.1

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core19 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -92,6 +92,9 @@ Planning:
   ordewell stop                   Stop execution of the last session (or --server)
   ordewell status                 List recent sessions (use --session-id for detail)
   ordewell sessions list|load|delete            Manage named sessions
+  ordewell fork                   Continue in a copy of the conversation and its tasks
+  ordewell compact                Condense the conversation into a summary (tasks are kept)
+  ordewell rewind [<n>]           Fork the conversation from before message <n> (no <n>: list them)
 
 Tasks (<id> is an order number or a task ID):
   ordewell add-task --title "..."  Add a task to the current plan
@@ -598,6 +601,87 @@ var ApiClient = class {
     }
     return res.data;
   }
+  /** Copy the conversation and its tasks into a new session the daemon has already adopted. */
+  async forkConversation(sessionId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/fork`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Fork failed");
+    }
+    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan };
+  }
+  async rewindTargets(sessionId) {
+    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/conversation/rewind-targets`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Failed to list rewind targets");
+    }
+    return res.data.targets;
+  }
+  /**
+   * Fork the conversation from just before the user message at `index` (a
+   * transcript position) into a session the daemon has already adopted. The
+   * original is left as it was; `rewoundMessage` is that message in full.
+   */
+  async rewindConversation(sessionId, index) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/rewind`, { index });
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Rewind failed");
+    }
+    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan, rewoundMessage: res.data.rewoundMessage };
+  }
+  /**
+   * Condense the conversation into a summary. One planner call, so it can take
+   * as long as a reply; a refusal or failure leaves the conversation as it was.
+   */
+  async compactConversation(sessionId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/compact`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Compaction failed");
+    }
+    return { plan: res.data.plan, summary: res.data.summary, keptMessages: res.data.keptMessages };
+  }
+  async reviewRunDiff(sessionId) {
+    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/isolation/diff`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Could not read the diff");
+    }
+    return res.data.diff;
+  }
+  /**
+   * A conflict or a block is an outcome, not an error. Passed on whole: which
+   * repos blocked the merge, or landed before it stopped, is the answer.
+   */
+  async mergeRun(sessionId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/merge`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Merge failed");
+    }
+    return res.data;
+  }
+  discardRun(sessionId) {
+    return this.isolationAction(sessionId, "discard", "Discard failed");
+  }
+  cleanupRun(sessionId) {
+    return this.isolationAction(sessionId, "cleanup", "Cleanup failed");
+  }
+  continueWithStash(sessionId) {
+    return this.isolationAction(sessionId, "stash-and-continue", "Could not stash and continue");
+  }
+  continueWithoutIsolation(sessionId) {
+    return this.isolationAction(sessionId, "run-without", "Could not continue without isolation");
+  }
+  async isolationAction(sessionId, segment, failure) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/${segment}`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || failure);
+    }
+  }
+  async resolveConflictAsTask(sessionId, taskId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Could not add a resolver task");
+    }
+    return res.data.plan;
+  }
   async closeSession(sessionId) {
     const res = await this.httpRequest("POST", `/api/sessions/${sessionId}/close`);
     return res.data;
@@ -676,7 +760,7 @@ var ApiClient = class {
         try {
           const event = JSON.parse(data.toString());
           onEvent(event);
-          if ((event.type === "execution_complete" || event.type === "execution_stopped") && !resolved) {
+          if ((event.type === "execution_complete" || event.type === "execution_stopped" || event.type === "isolation_blocked") && !resolved) {
             resolved = true;
             socket.close();
             resolve3();
@@ -1176,6 +1260,113 @@ ${lastPlannerMessage(plan)}
   }
 }
 
+// src/isolation.ts
+var import_core7 = require("@ordewell/core");
+var STATE_OF = {
+  active: "active",
+  merged: "integrated",
+  conflict: "conflict",
+  repairing: "repairing",
+  // A failed integration keeps its refs exactly as a failed verdict does; the
+  // user sees one thing: work that did not land and can be looked at.
+  kept: "kept",
+  failed: "kept"
+};
+function reposOf(run) {
+  if (Array.isArray(run.repos)) {
+    const repos = run.repos.filter((r) => r && typeof r.path === "string" && typeof r.integrationBranch === "string" && typeof r.baseRef === "string");
+    return repos.length > 0 ? repos.map((r) => ({ path: String(r.path), integrationBranch: String(r.integrationBranch), baseRef: String(r.baseRef) })) : null;
+  }
+  if (typeof run.integrationBranch === "string" && typeof run.baseRef === "string") {
+    return [{ path: ".", integrationBranch: run.integrationBranch, baseRef: run.baseRef }];
+  }
+  return null;
+}
+function changedRepos(record, legacy, state) {
+  if (legacy) return state === "integrated" ? ["."] : [];
+  return Object.entries(record.repos ?? {}).filter(([, r]) => r?.changed === true).map(([path]) => path);
+}
+function isolationOfPlan(plan) {
+  const run = plan?.isolation?.run;
+  const repos = run ? reposOf(run) : null;
+  if (!run || !repos) return null;
+  const legacy = !Array.isArray(run.repos);
+  const records = Object.entries(run.tasks ?? {});
+  const tasks = {};
+  const landed = [];
+  for (const [taskId, record] of records) {
+    const state = STATE_OF[String(record.status)];
+    if (!state) continue;
+    const changed = changedRepos(record, legacy, state);
+    const repairedFiles = Array.isArray(record.repairedFiles) && record.repairedFiles.length > 0 ? record.repairedFiles.map(String) : void 0;
+    tasks[taskId] = {
+      state,
+      branch: String(record.branch ?? ""),
+      worktree: String(record.workspace ?? record.worktree ?? ""),
+      repos: changed,
+      ...typeof record.conflictRepo === "string" ? { conflictRepo: record.conflictRepo } : legacy && state === "conflict" ? { conflictRepo: "." } : {},
+      ...Array.isArray(record.conflictFiles) && record.conflictFiles.length > 0 ? { conflictFiles: record.conflictFiles.map(String) } : {},
+      // No `repair` (attempt/limit): `conflictRepairAttempts` is server config, never
+      // sent in a persisted plan, so it cannot be reconstructed here. A live
+      // `tasksStatus` update fills it in once the stream catches up.
+      ...repairedFiles ? { repairedFiles } : {}
+    };
+    if (state === "integrated") {
+      landed.push({ taskId, order: Number(record.order ?? 0), title: String(record.title ?? taskId), changed, ...repairedFiles ? { repairedFiles } : {} });
+    }
+  }
+  landed.sort((a, b) => a.order - b.order);
+  const entry = ({ taskId, order, title, repairedFiles }) => ({ taskId, order, title, ...repairedFiles ? { repairedFiles } : {} });
+  return {
+    handoff: {
+      repos: repos.map((repo) => ({ ...repo, landed: landed.filter((t) => t.changed.includes(repo.path)).map(entry) })),
+      landed: landed.map(entry)
+    },
+    tasks
+  };
+}
+function handoffBranch(handoff) {
+  return [...new Set(handoff.repos.map((r) => r.integrationBranch))].join(", ");
+}
+function handoffBase(handoff, length) {
+  const group = isRepoGroup(handoff);
+  return handoff.repos.map((r) => `${group ? `${r.path} ` : ""}${r.baseRef.slice(0, length)}`).join(", ");
+}
+function isRepoGroup(handoff) {
+  return handoff.repos.some((r) => r.path !== ".");
+}
+function reposWithWork(handoff) {
+  const withWork = handoff.repos.filter((r) => r.landed.length > 0);
+  return (withWork.length > 0 ? withWork : handoff.repos).map((r) => r.path);
+}
+function repairedLanded(handoff) {
+  return handoff.landed.filter((t) => t.repairedFiles?.length);
+}
+function repairedNotice(handoff) {
+  const repaired = repairedLanded(handoff);
+  if (repaired.length === 0) return "";
+  const named = repaired.map((t) => `${t.title} (${(0, import_core7.capConflictFiles)(t.repairedFiles)})`);
+  const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
+  return ` ${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
+}
+function repoResultLines(handoff) {
+  return handoff.repos.map(({ path, landed }) => {
+    const n = landed.length;
+    return `${path}: ${n === 0 ? "nothing to merge" : `${n} task${n === 1 ? "" : "s"} landed`}`;
+  });
+}
+function taskRepoNames(isolation) {
+  return (isolation?.repos ?? []).filter((r) => r !== ".");
+}
+function mergeOutcome(result, branch, group, repaired = []) {
+  const ok = result.outcome === "merged";
+  if (!group && result.outcome === "conflict") {
+    return { ok, message: `Merging ${branch} conflicted, so it was aborted \u2014 your tree is as it was. Merge it with git and resolve the conflict there.` };
+  }
+  const { message } = (0, import_core7.describeMergeResult)(result, branch, group, repaired);
+  return { ok, message: ok || !group ? message : `${message} Each repository's ${branch} is a plain branch you can merge by hand.` };
+}
+
 // src/utils/output.ts
 function iconFor(status) {
   switch (status) {
@@ -1193,7 +1384,98 @@ function iconFor(status) {
 }
 
 // src/commands/run.ts
-var import_core7 = require("@ordewell/core");
+var import_core8 = require("@ordewell/core");
+
+// src/catalog.ts
+function normalizeCatalog(result) {
+  const runnersByModel = /* @__PURE__ */ new Map();
+  for (const [runner, entries] of Object.entries(result.modelsByRunner ?? {})) {
+    for (const entry of entries ?? []) {
+      const id = String(entry.modelId ?? entry.id);
+      runnersByModel.set(id, [.../* @__PURE__ */ new Set([...runnersByModel.get(id) ?? [], runner])]);
+    }
+  }
+  const models = (result.models ?? []).map((m) => {
+    const id = String(m.modelId ?? m.id);
+    return {
+      id,
+      label: String(m.modelLabel ?? m.label ?? id),
+      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? m.provider ?? ""),
+      pricing: m.pricing ? `$${m.pricing}/MTok` : void 0,
+      variants: Array.isArray(m.variants) ? m.variants.map((v) => ({ id: String(v.id), label: String(v.label ?? v.id) })) : [],
+      runners: runnersByModel.get(id) ?? []
+    };
+  });
+  const orchestratorModels = (result.orchestratorModels ?? []).map((m) => ({
+    id: String(m.id),
+    label: String(m.label ?? m.id),
+    provider: String(m.provider ?? ""),
+    pricing: m.pricing ? `$${m.pricing}/MTok` : void 0
+  }));
+  return {
+    models,
+    orchestratorModels,
+    providers: result.providers ?? [],
+    providerErrors: result.providerErrors ?? {},
+    modesByRunner: Object.fromEntries(
+      Object.entries(result.modesByRunner ?? {}).map(([runner, modes]) => [
+        runner,
+        (modes ?? []).map((m) => ({
+          id: String(m.id),
+          label: String(m.label ?? m.id),
+          description: m.description ? String(m.description) : void 0,
+          autonomous: m.autonomous ? true : void 0
+        }))
+      ])
+    )
+  };
+}
+
+// src/commands/shared.ts
+async function connect(subArgs, injected) {
+  return injected ?? new ApiClient(await ensureDaemon(resolvePort(subArgs)));
+}
+async function fetchCatalog(api) {
+  return normalizeCatalog(await api.getModels());
+}
+function fail(...lines) {
+  for (const line of lines) console.error(line);
+  process.exit(1);
+}
+function writeEnv(env) {
+  const envFile = findEnvFile();
+  for (const [key, value] of Object.entries(env)) {
+    writeEnvVar(envFile, key, value);
+    process.env[key] = value;
+  }
+}
+async function persistEnv(api, env) {
+  const settings = await api.updateSettings({ env });
+  writeEnv(env);
+  return settings;
+}
+function toTaskView(task) {
+  return {
+    id: task.id,
+    order: task.order,
+    title: task.title,
+    description: task.description,
+    prompt: task.prompt ?? void 0,
+    type: task.type === "user" ? "user" : "ai",
+    status: task.status ?? "pending",
+    dependencies: task.dependencies ?? [],
+    assignedRunner: task.assignedRunner || void 0,
+    taskMode: task.taskMode || void 0,
+    assignedModel: task.assignedModel ?? void 0,
+    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView)
+  };
+}
+function taskViews(plan) {
+  const tasks = allTasksOf(plan);
+  return [...tasks].sort((a, b) => a.order - b.order).map(toTaskView);
+}
+
+// src/commands/run.ts
 function resolveSessionId(subArgs) {
   const explicit = flag(subArgs, "--session-id");
   if (explicit) return explicit;
@@ -1206,7 +1488,9 @@ function resolveSessionId(subArgs) {
   console.error(`Using last session: ${last.sessionId} ("${last.goal}")`);
   return last.sessionId;
 }
-async function followExecution(api, sessionId) {
+async function followExecution(api, sessionId, start, onBlocked) {
+  let blocked = null;
+  let dirtyRepos = [];
   const taskStates = /* @__PURE__ */ new Map();
   let lastPrinted = "";
   function printStatus(tasks) {
@@ -1230,55 +1514,87 @@ async function followExecution(api, sessionId) {
       lastPrinted = output;
     }
   }
-  try {
-    await api.streamExecution(sessionId, (event) => {
-      if (event.type === "task_started") {
-        process.stderr.write(`[${event.order}/${event.title}] Started: ${event.runner} / ${event.modelId}
+  let settleReady = () => {
+  };
+  const streamReady = new Promise((resolve3, reject) => {
+    settleReady = (error) => error ? reject(error) : resolve3();
+  });
+  const stream = api.streamExecution(sessionId, (event) => {
+    if (event.type === "task_started") {
+      process.stderr.write(`[${event.order}/${event.title}] Started: ${event.runner} / ${event.modelId}
 `);
-      }
-      if (event.type === "checkpoint") {
-        process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core7.truncateCheckpointSummary)(event.summary)}
+    }
+    if (event.type === "checkpoint") {
+      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core8.truncateCheckpointSummary)(event.summary)}
 `);
-      }
-      if (event.type === "status_update" && event.tasks) {
-        printStatus(event.tasks);
-      }
-      if (event.type === "review_needed") {
-        console.log("\nPlan needs your sign-off \u2014 run `ordewell approve` to continue.");
-      }
-      if (event.type === "execution_complete") {
-        const s = event;
-        const summary = s.summary || { total: 0 };
-        console.log(
-          `
+    }
+    if (event.type === "status_update" && event.tasks) {
+      printStatus(event.tasks);
+    }
+    if (event.type === "review_needed") {
+      console.log("\nPlan needs your sign-off \u2014 run `ordewell approve` to continue.");
+    }
+    if (event.type === "execution_complete") {
+      const s = event;
+      const summary = s.summary || { total: 0 };
+      console.log(
+        `
 Done. ${summary.completed || 0} completed, ${summary.failed || 0} failed, ${summary.blocked ?? summary.total - (summary.completed || 0) - (summary.failed || 0)} blocked.`
-        );
-      }
-      if (event.type === "execution_stopped") {
-        console.log("\nExecution stopped.");
-      }
-    });
-  } catch (err) {
+      );
+    }
+    if (event.type === "execution_stopped") {
+      console.log("\nExecution stopped.");
+    }
+    if (event.type === "notice") console.error(`\xB7 ${event.message}`);
+    if (event.type === "isolation_blocked") {
+      blocked = event.message;
+      dirtyRepos = event.repos ?? [];
+    }
+    if (event.type === "isolation_handoff") {
+      const n = event.landed.length;
+      const where = isRepoGroup(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
+      console.log(`
+Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" : "s"} landed.`);
+      if (isRepoGroup(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
+      console.log("  `ordewell handoff review|merge|discard|cleanup` to land it.");
+    }
+  }, settleReady);
+  const streamFailed = (err) => {
     console.error(`Execution stream error: ${err.message}`);
     process.exit(1);
+  };
+  void stream.catch(settleReady);
+  await streamReady.catch(streamFailed);
+  await start();
+  await stream.catch(streamFailed);
+  if (blocked === null) return;
+  if (!onBlocked) {
+    await api.stopExecution(sessionId);
+    console.error(blocked);
+    const where = dirtyRepos.length > 0 ? ` in ${dirtyRepos.join(", ")}` : "";
+    console.error(`Nothing was started. Re-run with \`--stash\` to stash your tracked changes${where} first, or \`--without-isolation\` to run in your working tree this once.`);
+    process.exit(1);
   }
+  await followExecution(api, sessionId, () => onBlocked === "stash" ? api.continueWithStash(sessionId) : api.continueWithoutIsolation(sessionId));
 }
-async function handleRun(subArgs) {
+async function handleRun(subArgs, injectedApi) {
   const sessionId = resolveSessionId(subArgs);
-  const api = new ApiClient(await ensureDaemon(resolvePort(subArgs)));
+  const api = await connect(subArgs, injectedApi);
   console.error(`Executing plan...`);
-  try {
-    await api.executePlan(sessionId);
-  } catch (err) {
-    console.error(`Failed to start execution: ${err.message}`);
-    process.exit(1);
-  }
-  await followExecution(api, sessionId);
+  const onBlocked = hasFlag(subArgs, "--stash") ? "stash" : hasFlag(subArgs, "--without-isolation") ? "shared" : void 0;
+  await followExecution(api, sessionId, async () => {
+    try {
+      await api.executePlan(sessionId);
+    } catch (err) {
+      console.error(`Failed to start execution: ${err.message}`);
+      process.exit(1);
+    }
+  }, onBlocked);
 }
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core8 = require("@ordewell/core");
+var import_core9 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -1349,12 +1665,12 @@ function printOneSession(sessionId, meta, plan) {
     const icon = iconFor(t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
-    console.log(`  ${(0, import_core8.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    console.log(`  ${(0, import_core9.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
     for (const sub of t.subtasks || []) {
       const subIcon = iconFor(sub.status);
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
-      console.log(`    ${(0, import_core8.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      console.log(`    ${(0, import_core9.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
     }
   }
 }
@@ -1406,123 +1722,32 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
-var import_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 
 // src/commands/model.ts
-var import_core9 = require("@ordewell/core");
-
-// src/catalog.ts
-function normalizeCatalog(result) {
-  const runnersByModel = /* @__PURE__ */ new Map();
-  for (const [runner, entries] of Object.entries(result.modelsByRunner ?? {})) {
-    for (const entry of entries ?? []) {
-      const id = String(entry.modelId ?? entry.id);
-      runnersByModel.set(id, [.../* @__PURE__ */ new Set([...runnersByModel.get(id) ?? [], runner])]);
-    }
-  }
-  const models = (result.models ?? []).map((m) => {
-    const id = String(m.modelId ?? m.id);
-    return {
-      id,
-      label: String(m.modelLabel ?? m.label ?? id),
-      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? m.provider ?? ""),
-      pricing: m.pricing ? `$${m.pricing}/MTok` : void 0,
-      variants: Array.isArray(m.variants) ? m.variants.map((v) => ({ id: String(v.id), label: String(v.label ?? v.id) })) : [],
-      runners: runnersByModel.get(id) ?? []
-    };
-  });
-  const orchestratorModels = (result.orchestratorModels ?? []).map((m) => ({
-    id: String(m.id),
-    label: String(m.label ?? m.id),
-    provider: String(m.provider ?? ""),
-    pricing: m.pricing ? `$${m.pricing}/MTok` : void 0
-  }));
-  return {
-    models,
-    orchestratorModels,
-    providers: result.providers ?? [],
-    providerErrors: result.providerErrors ?? {},
-    modesByRunner: Object.fromEntries(
-      Object.entries(result.modesByRunner ?? {}).map(([runner, modes]) => [
-        runner,
-        (modes ?? []).map((m) => ({
-          id: String(m.id),
-          label: String(m.label ?? m.id),
-          description: m.description ? String(m.description) : void 0,
-          autonomous: m.autonomous ? true : void 0
-        }))
-      ])
-    )
-  };
-}
-
-// src/commands/shared.ts
-async function connect(subArgs, injected) {
-  return injected ?? new ApiClient(await ensureDaemon(resolvePort(subArgs)));
-}
-async function fetchCatalog(api) {
-  return normalizeCatalog(await api.getModels());
-}
-function fail(...lines) {
-  for (const line of lines) console.error(line);
-  process.exit(1);
-}
-function writeEnv(env) {
-  const envFile = findEnvFile();
-  for (const [key, value] of Object.entries(env)) {
-    writeEnvVar(envFile, key, value);
-    process.env[key] = value;
-  }
-}
-async function persistEnv(api, env) {
-  const settings = await api.updateSettings({ env });
-  writeEnv(env);
-  return settings;
-}
-function toTaskView(task) {
-  return {
-    id: task.id,
-    order: task.order,
-    title: task.title,
-    description: task.description,
-    prompt: task.prompt ?? void 0,
-    type: task.type === "user" ? "user" : "ai",
-    status: task.status ?? "pending",
-    dependencies: task.dependencies ?? [],
-    assignedRunner: task.assignedRunner || void 0,
-    taskMode: task.taskMode || void 0,
-    assignedModel: task.assignedModel ?? void 0,
-    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView)
-  };
-}
-function taskViews(plan) {
-  const tasks = allTasksOf(plan);
-  return [...tasks].sort((a, b) => a.order - b.order).map(toTaskView);
-}
-
-// src/commands/model.ts
-var USAGE = "Usage: ordewell model [show | set <model-id>]";
-async function handleModel(subArgs, injectedApi) {
-  const [action, modelId] = positionals(subArgs);
-  if (action && action !== "show" && action !== "set") {
-    fail(`Unknown model action: "${action}"`, USAGE);
-  }
-  const api = await connect(subArgs, injectedApi);
-  if (action !== "set") {
-    await showModels(api);
-    return;
-  }
-  if (!modelId) fail(USAGE);
-  const settings = await api.getSettings();
-  const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const runner = (0, import_core9.runnerForProvider)(provider);
-  if (runner) {
-    const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
-    if (known.length > 0 && !known.some((m) => m.id === modelId)) {
-      fail(
-        `${modelId} was not discovered for ${runner}.`,
-        `Run \`ordewell model\` to see what ${runner} offers.`
-      );
+var import_core10 = require("@ordewell/core");
+var USAGE = "Usage: ordewell model [show | set <model-id>]";
+async function handleModel(subArgs, injectedApi) {
+  const [action, modelId] = positionals(subArgs);
+  if (action && action !== "show" && action !== "set") {
+    fail(`Unknown model action: "${action}"`, USAGE);
+  }
+  const api = await connect(subArgs, injectedApi);
+  if (action !== "set") {
+    await showModels(api);
+    return;
+  }
+  if (!modelId) fail(USAGE);
+  const settings = await api.getSettings();
+  const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
+  const runner = (0, import_core10.runnerForProvider)(provider);
+  if (runner) {
+    const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
+    if (known.length > 0 && !known.some((m) => m.id === modelId)) {
+      fail(
+        `${modelId} was not discovered for ${runner}.`,
+        `Run \`ordewell model\` to see what ${runner} offers.`
+      );
     }
   }
   await api.updateSettings({ orchestratorModel: modelId });
@@ -1534,7 +1759,7 @@ async function showModels(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const runner = (0, import_core9.runnerForProvider)(provider);
+  const runner = (0, import_core10.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
@@ -1568,8 +1793,8 @@ async function handleModels(subArgs) {
     const rest = subArgs.filter((_, i) => i !== setIdx && i !== setIdx + 1);
     return handleModel(["set", subArgs[setIdx + 1], ...rest]);
   }
-  const config = new import_core10.EnvConfig();
-  const providers = (0, import_core10.configuredProviders)(config);
+  const config = new import_core11.EnvConfig();
+  const providers = (0, import_core11.configuredProviders)(config);
   if (providers.length === 0) {
     console.error("No providers configured. Set an API key for a provider, e.g.:");
     console.error("  OPENROUTER_API_KEY=...   (OpenRouter)");
@@ -1578,19 +1803,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core10.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core11.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core10.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core10.toOrchestratorOptions)(result.models, import_core10.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core11.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core11.toOrchestratorOptions)(result.models, import_core11.ORCHESTRATOR_SHORTCUTS);
     errors = result.errors;
   } catch (err) {
     console.error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
     return;
   }
-  const providerLabel = (p) => (0, import_core10.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core11.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -1707,9 +1932,9 @@ function handleSetup(subArgs) {
 }
 
 // src/commands/plugins.ts
-var import_core11 = require("@ordewell/core");
+var import_core12 = require("@ordewell/core");
 function handlePlugins(subArgs) {
-  const registry = new import_core11.RunnerRegistry();
+  const registry = new import_core12.RunnerRegistry();
   registry.loadUserPlugins();
   const sub = subArgs[0];
   if (sub === "list" || !sub) {
@@ -1745,7 +1970,7 @@ ${plugins.length} plugin(s):
       process.exit(1);
     }
     try {
-      const resolved = (0, import_core11.classifyPluginSource)(source);
+      const resolved = (0, import_core12.classifyPluginSource)(source);
       const manifest = resolved.kind === "git" ? registry.installFromGit(resolved.url) : registry.installFromPath(resolved.path);
       console.log(`Installed plugin: ${manifest.name} v${manifest.version}`);
     } catch (err) {
@@ -2139,153 +2364,627 @@ async function handleSessions(subArgs, injectedApi) {
   process.exit(1);
 }
 
-// src/commands/planner.ts
-var import_core12 = require("@ordewell/core");
-
-// src/plannerModelSwitch.ts
-function describePlannerSwitch(settings, provider) {
-  const model = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const effort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  if (!model) return { model: "", effort: "", source: "none" };
-  return rememberedModelFor(settings, provider) === model ? { model, effort, source: "remembered" } : { model, effort, source: "catalog-default" };
-}
-function rememberedModelFor(settings, provider) {
-  const map = settings.plannerModels;
-  if (!map || typeof map !== "object") return void 0;
-  const entry = map[provider];
-  if (!entry || typeof entry !== "object") return void 0;
-  const { model } = entry;
-  return typeof model === "string" ? model : void 0;
-}
-
-// src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core12.ALL_PROVIDERS);
-async function handlePlanner(subArgs, injectedApi) {
+// src/commands/conversation.ts
+var REWIND_USAGE = "Usage: ordewell rewind [<n>] [--session-id <id>] [--workspace /path] \u2014 with no <n>, lists the messages you can rewind to.";
+async function adopted(subArgs, injectedApi) {
+  const workspace = flag(subArgs, "--workspace") || process.cwd();
+  const sessionId = resolveSessionId(subArgs);
   const api = await connect(subArgs, injectedApi);
-  const [wanted] = positionals(subArgs);
-  if (!wanted || wanted === "show") {
-    await showPlanners(api);
-    return;
-  }
-  const provider = wanted.toLowerCase();
-  if (!KNOWN_PROVIDERS.includes(provider)) {
-    fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
-  }
-  const settings = await persistEnv(api, { AI_PROVIDER: provider });
-  const recall2 = describePlannerSwitch(settings, provider);
-  writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core12.ALL_PROVIDERS[provider];
-  const catalog = await fetchCatalog(api);
-  console.log(
-    (0, import_core12.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
-  );
-  console.log(plannerModelLine(recall2));
-  if (!(0, import_core12.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
-    console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
+  let plan;
+  try {
+    ({ plan } = await api.adoptSession(sessionId, workspace));
+  } catch (err) {
+    fail(`Failed to load session: ${err.message}`);
   }
+  return { api, sessionId, workspace, plan };
 }
-function plannerModelLine(recall2) {
-  switch (recall2.source) {
-    case "remembered":
-      return `  Restored its planner model: ${recall2.model}.`;
-    case "catalog-default":
-      return `  Using ${recall2.model}, its default model \u2014 pick another with \`ordewell model set <id>\`.`;
-    case "none":
-      return "  Pick a model with `ordewell model set <id>`, or leave it on the default.";
+async function handleFork(subArgs, injectedApi) {
+  const { api, sessionId, workspace } = await adopted(subArgs, injectedApi);
+  let fork;
+  try {
+    fork = await api.forkConversation(sessionId);
+  } catch (err) {
+    fail(`Failed to fork: ${err.message}`);
   }
+  saveLastSession(fork.sessionId, fork.goal, fork.plan.runners ?? [], workspace);
+  console.log(`Forked ${sessionId} into ${fork.sessionId} \u2014 the fork is now the current session.`);
+  console.log(`  \`ordewell sessions load ${sessionId}\` to go back to the original.`);
 }
-async function showPlanners(api) {
-  const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
-  const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core12.CLI_PROVIDERS) {
-    const runner = (0, import_core12.runnerForProvider)(id);
-    const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core12.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+async function handleCompact(subArgs, injectedApi) {
+  const { api, sessionId } = await adopted(subArgs, injectedApi);
+  let result;
+  try {
+    result = await api.compactConversation(sessionId);
+  } catch (err) {
+    fail(`Failed to condense: ${err.message}`);
   }
-  console.log("\nAPI providers");
-  for (const id of import_core12.PROVIDER_PRIORITY) {
-    const configured = catalog.providers.includes(id);
-    const meta = import_core12.ALL_PROVIDERS[id];
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
+  console.log(`Condensed ${sessionId}. The last two exchanges were kept as they were; the tasks are unchanged.
+`);
+  console.log(result.summary);
+}
+async function handleRewind(subArgs, injectedApi) {
+  const arg = positionals(subArgs)[0];
+  if (arg !== void 0 && !/^\d+$/.test(arg)) fail(REWIND_USAGE);
+  const { api, sessionId, workspace } = await adopted(subArgs, injectedApi);
+  if (arg === void 0) {
+    let targets;
+    try {
+      targets = await api.rewindTargets(sessionId);
+    } catch (err) {
+      fail(`Failed to list messages: ${err.message}`);
+    }
+    if (targets.length === 0) {
+      console.log("Nothing to rewind to yet \u2014 the only message so far is the goal.");
+      return;
+    }
+    console.log("Your messages, most recent first:\n");
+    for (const t of [...targets].reverse()) console.log(`  ${String(t.index).padStart(4)}  ${t.preview}`);
+    console.log("\n  `ordewell rewind <n>` forks the conversation from just before message <n>. The original is kept, and the tasks ride along.");
+    return;
   }
-  console.log(`
-  * = current. Set with: ordewell planner <id>`);
+  let fork;
+  try {
+    fork = await api.rewindConversation(sessionId, Number(arg));
+  } catch (err) {
+    fail(`Failed to rewind: ${err.message}`);
+  }
+  saveLastSession(fork.sessionId, fork.goal, fork.plan.runners ?? [], workspace);
+  console.log(`Forked ${sessionId} into ${fork.sessionId} from just before message ${arg} \u2014 the fork is now the current session.`);
+  console.log(`  \`ordewell sessions load ${sessionId}\` to go back to the original.`);
+  console.log("\nThe message you rewound to, to resend or edit:\n");
+  console.log(fork.rewoundMessage);
 }
-function marker(selected) {
-  return selected ? "*" : " ";
+
+// src/commands/handoff.ts
+var import_readline2 = require("readline");
+
+// src/tui/ansi.ts
+var import_string_width = __toESM(require("string-width"));
+var ESCAPE = /\x1b(?:\][\s\S]*?(?:\x07|\x1b\\|$)|[P^_][\s\S]*?(?:\x1b\\|$)|\[[0-?]*[ -/]*[@-~]?|[ -/]*[0-~]?)/g;
+var ESCAPE_SPLIT = new RegExp(`(${ESCAPE.source})`);
+var CONTROL = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+var CONTROL_IN_ROW = /[\x00-\x1f\x7f-\x9f]/g;
+var HAS_CONTROL = /[\x00-\x1f\x7f-\x9f]/;
+var PAINT_ESCAPE = /^\x1b\[[0-9;]*[mGK]$/;
+function stripAnsi(text) {
+  return text.replace(ESCAPE, "");
 }
-var EFFORT_USAGE = "Usage: ordewell planner-effort [<level>|default]";
-async function handlePlannerEffort(subArgs, injectedApi) {
-  const api = await connect(subArgs, injectedApi);
-  const [wanted] = positionals(subArgs);
-  const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
-  const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = (0, import_core12.runnerForProvider)(provider);
-  if (!runner) {
-    fail(
-      "Thinking effort applies to a coding-agent planner.",
-      "Switch with: ordewell planner claude-code|codex|opencode"
-    );
+function sanitize(text) {
+  return text.replace(ESCAPE, "").replace(/\r\n?/g, "\n").replace(/\t/g, " ").replace(CONTROL, "");
+}
+function paintOnly(line) {
+  if (!HAS_CONTROL.test(line)) return line;
+  return line.split(ESCAPE_SPLIT).map((piece) => piece.startsWith("\x1B") ? PAINT_ESCAPE.test(piece) ? piece : "" : piece.replace(CONTROL_IN_ROW, "")).join("");
+}
+function width(text) {
+  return (0, import_string_width.default)(stripAnsi(text));
+}
+function truncate(text, max) {
+  if (max <= 0) return "";
+  if (width(text) <= max) return text;
+  let out = "";
+  let used = 0;
+  for (const char of stripAnsi(text)) {
+    const w = (0, import_string_width.default)(char);
+    if (used + w > max - 1) break;
+    out += char;
+    used += w;
   }
-  const model = catalog.models.find((m) => m.id === modelId && m.runners?.includes(runner));
-  const variants = model?.variants ?? [];
-  if (!wanted || wanted === "show") {
-    console.log(`Planner effort: ${currentEffort || "runner default"}`);
-    if (!model) {
-      console.log(`  No planner model selected for ${runner} \u2014 pick one with \`ordewell model set <id>\`.`);
-    } else if (variants.length === 0) {
-      console.log(`  ${model.label} exposes no effort levels; it always runs at the agent's default.`);
+  return out + "\u2026";
+}
+function pad(text, target) {
+  const current = width(text);
+  if (current > target) return truncate(text, target);
+  return text + " ".repeat(target - current);
+}
+function chopWord(piece, max) {
+  const chunks = [];
+  let cur = "";
+  let curWidth = 0;
+  for (const ch of piece) {
+    const w = (0, import_string_width.default)(ch);
+    if (cur && curWidth + w > max) {
+      chunks.push(cur);
+      cur = ch;
+      curWidth = w;
     } else {
-      console.log(`  Available for ${model.label}: ${variants.map((v) => v.id).join(", ")}, default`);
+      cur += ch;
+      curWidth += w;
     }
-    console.log(`  ${EFFORT_USAGE}`);
-    return;
   }
-  const level = wanted.toLowerCase();
-  if (level === "default") {
-    await persistEnv(api, { ORDEWELL_PLANNER_EFFORT: "" });
-    console.log("Planner effort set to the runner default.");
-    return;
+  chunks.push(cur);
+  return chunks;
+}
+var wrapMemo = /* @__PURE__ */ new Map();
+var WRAP_MEMO_MAX = 64;
+function wrapLines(text, max) {
+  const key = `${max}\0${text}`;
+  const cached = wrapMemo.get(key);
+  if (cached) {
+    wrapMemo.delete(key);
+    wrapMemo.set(key, cached);
+    return cached;
   }
-  if (!model) {
-    fail(`No planner model selected for ${runner}.`, "Pick one with: ordewell model set <id>");
+  const result = computeWrapLines(text, max);
+  if (wrapMemo.size >= WRAP_MEMO_MAX) {
+    const oldest = wrapMemo.keys().next().value;
+    if (oldest !== void 0) wrapMemo.delete(oldest);
   }
-  if (!variants.some((v) => v.id === level)) {
-    fail(
-      variants.length > 0 ? `Unknown effort: ${wanted}. Available for ${model.label}: ${variants.map((v) => v.id).join(", ")}, default.` : `${model.label} exposes no effort levels; it always runs at the agent's default.`
-    );
+  wrapMemo.set(key, result);
+  return result;
+}
+function computeWrapLines(text, max) {
+  if (max <= 0) return [{ line: "", start: 0 }];
+  const out = [];
+  let pos = 0;
+  for (const paragraph of text.split("\n")) {
+    let current = "";
+    let currentStart = pos;
+    let first = true;
+    let wordPos = pos;
+    for (const word of paragraph.split(" ")) {
+      let piece = word;
+      let pieceStart = wordPos;
+      if (width(piece) > max) {
+        const chunks = chopWord(piece, max);
+        for (let ci = 0; ci < chunks.length - 1; ci++) {
+          const head = chunks[ci];
+          if (!first) {
+            out.push({ line: current, start: currentStart });
+            current = "";
+          }
+          out.push({ line: head, start: pieceStart });
+          pieceStart += head.length;
+          first = true;
+        }
+        piece = chunks[chunks.length - 1];
+      }
+      const candidate = first ? piece : `${current} ${piece}`;
+      const candidateStart = first ? pieceStart : currentStart;
+      first = false;
+      if (width(candidate) > max) {
+        out.push({ line: current, start: currentStart });
+        current = piece;
+        currentStart = pieceStart;
+      } else {
+        current = candidate;
+        currentStart = candidateStart;
+      }
+      wordPos += word.length + 1;
+    }
+    out.push({ line: current, start: currentStart });
+    pos += paragraph.length + 1;
+  }
+  return out.length > 0 ? out : [{ line: "", start: 0 }];
+}
+function wrap(text, max) {
+  return wrapLines(text, max).map((l) => l.line);
+}
+function colour(open) {
+  return (text) => style.enabled ? `\x1B[${open}m${text}\x1B[0m` : text;
+}
+var style = {
+  /** Set false when the output is piped or the terminal has no colour. */
+  enabled: true,
+  bold: colour("1"),
+  dim: colour("2"),
+  italic: colour("3"),
+  underline: colour("4"),
+  inverse: colour("7"),
+  red: colour("31"),
+  green: colour("32"),
+  yellow: colour("33"),
+  blue: colour("34"),
+  magenta: colour("35"),
+  cyan: colour("36"),
+  grey: colour("90")
+};
+
+// src/tui/transcript.ts
+function say(state, role, content, research, extra) {
+  const message = {
+    role,
+    content: sanitize(content),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...research ? { research } : {},
+    ...extra
+  };
+  return { ...state, messages: [...state.messages, message], scroll: 0 };
+}
+
+// src/tui/handoff.ts
+var HANDOFF_ACTIONS = [
+  { id: "review", label: "Review diff", hint: "the branch against the commit it forked from" },
+  { id: "merge", label: "Merge", hint: "into the branch you have checked out \u2014 asks first" },
+  { id: "discard", label: "Discard", hint: "the run, its worktrees and this branch \u2014 asks first" },
+  { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches, keep this branch" }
+];
+function handoffActions(handoff) {
+  if (!isRepoGroup(handoff)) return HANDOFF_ACTIONS;
+  return [
+    { id: "review", label: "Review diff", hint: "each repository's branch against the commit it forked from" },
+    { id: "merge", label: "Merge all", hint: "every repository's branch into what you have checked out there \u2014 asks first" },
+    { id: "discard", label: "Discard", hint: "the run, its worktrees and every repository's branch \u2014 asks first" },
+    { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches everywhere, keep the integration branches" }
+  ];
+}
+var reposOf2 = (handoff) => handoff.repos.map((r) => r.path).join(", ");
+var HANDOFF_USAGE = `/handoff [${HANDOFF_ACTIONS.map((a) => a.id).join("|")}]`;
+var diffRoom = (rows) => Math.max(1, rows - 3);
+var fail2 = (state, content) => ({ state: say(state, "error", content), effects: [] });
+function handoffCommand(state, arg) {
+  if (!state.sessionId || !state.handoff) return fail2(state, "No isolated run to hand off \u2014 a plan that ran in worktrees leaves one here.");
+  if (arg === void 0) return { state: { ...state, overlay: { kind: "handoff", index: 0, diff: null } }, effects: [] };
+  const action = HANDOFF_ACTIONS.find((a) => a.id === arg.toLowerCase());
+  if (!action) return fail2(state, `Usage: ${HANDOFF_USAGE}`);
+  return runHandoffAction(state, action.id);
+}
+function handoffArrived(state, handoff) {
+  const landed = handoff.landed.length;
+  const where = isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : "";
+  const told = say(
+    { ...state, handoff },
+    "system",
+    `Run finished on ${handoffBranch(handoff)}${where} \u2014 ${landed} task${landed === 1 ? "" : "s"} landed. /handoff to review and land it.`
+  );
+  return state.overlay ? told : { ...told, overlay: { kind: "handoff", index: 0, diff: null } };
+}
+function runHandoffAction(state, id) {
+  const { sessionId, handoff } = state;
+  if (!sessionId || !handoff) return fail2(state, "No isolated run to hand off.");
+  const closed = { ...state, overlay: null };
+  switch (id) {
+    case "review":
+      return { state, effects: [{ type: "isolationReviewDiff", sessionId }] };
+    case "cleanup":
+      return { state: closed, effects: [{ type: "isolationCleanup", sessionId, branch: handoffBranch(handoff) }] };
+    case "merge":
+      return {
+        state: {
+          ...state,
+          overlay: isRepoGroup(handoff) ? {
+            kind: "confirm",
+            title: "Merge all into your branches?",
+            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. Ordewell never does this on its own. It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed.${repairedNotice(handoff)}`,
+            action: { kind: "merge-run" }
+          } : {
+            kind: "confirm",
+            title: "Merge into your branch?",
+            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. Ordewell never does this on its own. If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed.${repairedNotice(handoff)}`,
+            action: { kind: "merge-run" }
+          }
+        },
+        effects: []
+      };
+    case "discard":
+      return {
+        state: {
+          ...state,
+          overlay: {
+            kind: "confirm",
+            title: "Discard this run?",
+            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status \u2014 mark one not done if you did not keep its work.`,
+            action: { kind: "discard-run" }
+          }
+        },
+        effects: []
+      };
+  }
+}
+function confirmedHandoff(state, kind) {
+  const closed = { ...state, overlay: null };
+  if (!state.sessionId || !state.handoff) return { state: closed, effects: [] };
+  const { sessionId, handoff } = state;
+  const repaired = repairedLanded(handoff);
+  const effect = kind === "merge-run" ? {
+    type: "isolationMerge",
+    sessionId,
+    branch: handoffBranch(handoff),
+    ...isRepoGroup(handoff) ? { group: true } : {},
+    ...repaired.length > 0 ? { repaired } : {}
+  } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
+  return { state: closed, effects: [effect] };
+}
+function showDiff(state, diff) {
+  if (diff.trim() === "") return say(state, "system", `Nothing differs from ${state.handoff ? handoffBase(state.handoff, 8) : "the base commit"}.`);
+  const index = state.overlay?.kind === "handoff" ? state.overlay.index : 0;
+  const lines = sanitize(diff.replace(/\t/g, "    ")).split("\n");
+  return { ...state, overlay: { kind: "handoff", index, diff: { lines, scroll: 0 } } };
+}
+function handleHandoffKey(state, overlay, key, rows) {
+  const hold = { state, effects: [] };
+  const up = key.name === "up" || key.name === "scrollup";
+  const down = key.name === "down" || key.name === "scrolldown";
+  if (overlay.diff) {
+    const { lines, scroll } = overlay.diff;
+    const room = diffRoom(rows);
+    const max = Math.max(0, lines.length - room);
+    const delta = up ? -1 : down ? 1 : key.name === "pageup" ? -room : key.name === "pagedown" ? room : null;
+    if (delta !== null) {
+      const next = Math.min(max, Math.max(0, scroll + delta));
+      return { state: { ...state, overlay: { ...overlay, diff: { lines, scroll: next } } }, effects: [] };
+    }
+    if (key.name === "escape" || key.name === "enter") return { state: { ...state, overlay: { ...overlay, diff: null } }, effects: [] };
+    return hold;
+  }
+  if (key.name === "escape") return { state: { ...state, overlay: null }, effects: [] };
+  if (up || down) {
+    const index = Math.min(HANDOFF_ACTIONS.length - 1, Math.max(0, overlay.index + (up ? -1 : 1)));
+    return { state: { ...state, overlay: { ...overlay, index } }, effects: [] };
+  }
+  if (key.name === "enter") return runHandoffAction(state, HANDOFF_ACTIONS[overlay.index].id);
+  return hold;
+}
+var BLOCKED_ITEMS = [
+  { id: "stash", label: "Stash and continue", detail: "git stash your tracked changes, then run in worktrees" },
+  { id: "shared", label: "Run without isolation", detail: "this run only, in your working tree" },
+  { id: "cancel", label: "Cancel", detail: "start nothing" }
+];
+function blockedPicker(state, message, repos = []) {
+  const items = repos.length === 0 ? BLOCKED_ITEMS : BLOCKED_ITEMS.map((item) => item.id === "stash" ? { ...item, detail: `git stash the tracked changes in ${repos.join(", ")}, then run in worktrees` } : item);
+  return {
+    ...state,
+    overlay: {
+      kind: "picker",
+      picker: {
+        title: "Run blocked by uncommitted changes",
+        hint: message,
+        items,
+        filter: "",
+        index: 0,
+        multi: false,
+        chosen: [],
+        action: { kind: "isolation-blocked" }
+      }
+    }
+  };
+}
+function chooseBlocked(state, choice) {
+  const closed = { ...state, overlay: null };
+  if (!state.sessionId) return { state: closed, effects: [] };
+  const { sessionId } = state;
+  if (choice === "cancel") return { state: closed, effects: [{ type: "stopExecution", sessionId }] };
+  return { state: closed, effects: [{ type: "isolationContinue", sessionId, mode: choice }] };
+}
+function sameIsolation(a, b) {
+  return a?.state === b?.state && a?.branch === b?.branch && a?.worktree === b?.worktree && a?.conflictRepo === b?.conflictRepo && (a?.repos ?? []).join("\0") === (b?.repos ?? []).join("\0") && (a?.conflictFiles ?? []).join("\0") === (b?.conflictFiles ?? []).join("\0") && a?.repair?.attempt === b?.repair?.attempt && a?.repair?.limit === b?.repair?.limit && (a?.repairedFiles ?? []).join("\0") === (b?.repairedFiles ?? []).join("\0");
+}
+function mapTasks(tasks, map) {
+  return tasks.map((task) => {
+    const mapped = map(task);
+    return task.subtasks ? { ...mapped, subtasks: mapTasks(task.subtasks, map) } : mapped;
+  });
+}
+function clearIsolation(state) {
+  return {
+    ...state,
+    handoff: null,
+    tasks: mapTasks(state.tasks, ({ isolation: _dropped, ...task }) => task)
+  };
+}
+function isolationForPlan(tasks, record, previous) {
+  const known = /* @__PURE__ */ new Map();
+  mapTasks(previous, (task) => {
+    if (task.isolation) known.set(task.id, task.isolation);
+    return task;
+  });
+  return mapTasks(tasks, (task) => {
+    const isolation = record ? record.tasks[task.id] ?? { state: "none" } : known.get(task.id);
+    return isolation ? { ...task, isolation } : task;
+  });
+}
+
+// src/commands/handoff.ts
+var USAGE4 = "Usage: ordewell handoff [review|merge|discard|cleanup] [--session-id <id>] [--workspace /path] [--yes]";
+async function askYesNo(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve3) => rl.question(`${question} [y/N] `, resolve3));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
+  const action = positionals(subArgs)[0]?.toLowerCase();
+  if (action === void 0) {
+    console.log(`${USAGE4}
+`);
+    for (const a of HANDOFF_ACTIONS) console.log(`  ${a.id.padEnd(8)} ${a.label} \u2014 ${a.hint}`);
+    return;
+  }
+  if (!HANDOFF_ACTIONS.some((a) => a.id === action)) fail(`Unknown handoff action "${action}".`, USAGE4);
+  const { api, sessionId, plan } = await adopted(subArgs, injectedApi);
+  const handoff = isolationOfPlan(plan)?.handoff;
+  if (!handoff) fail("This session has no isolated run to hand off.");
+  const branch = handoffBranch(handoff);
+  const group = isRepoGroup(handoff);
+  if (group) for (const line of repoResultLines(handoff)) console.error(line);
+  const asked = hasFlag(subArgs, "--yes");
+  const confirmed = async (question) => {
+    if (asked || await confirm(question)) return;
+    fail("Not confirmed \u2014 nothing was changed. Pass --yes to confirm without a prompt.");
+  };
+  const attempt = async (work) => {
+    try {
+      return await work();
+    } catch (err) {
+      return fail(`Handoff ${action} failed: ${err.message}`);
+    }
+  };
+  switch (action) {
+    case "review": {
+      const diff = await attempt(() => api.reviewRunDiff(sessionId));
+      console.log(diff.trim() === "" ? `Nothing differs from ${handoffBase(handoff, 8)}.` : diff);
+      return;
+    }
+    case "merge": {
+      await confirmed((group ? `Merge ${branch} into the branch checked out in each of ${reposWithWork(handoff).join(", ")}? Nothing is merged unless every repository can take it; once all have, the run's worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once merged, the run's worktrees and branches are removed.`) + repairedNotice(handoff));
+      const { ok, message } = mergeOutcome(await attempt(() => api.mergeRun(sessionId)), branch, group, repairedLanded(handoff));
+      if (ok) console.log(message);
+      else fail(message);
+      return;
+    }
+    case "discard":
+      await confirmed(group ? `Discard this run's worktrees and task branches, and delete ${branch} in every repository?` : `Discard this run's worktrees and task branches, and delete ${branch}?`);
+      await attempt(() => api.discardRun(sessionId));
+      console.log(`Discarded the run and ${branch}${group ? " in every repository" : ""}.`);
+      return;
+    case "cleanup":
+      await attempt(() => api.cleanupRun(sessionId));
+      console.log(`Removed the run's worktrees and task branches; ${branch} is kept${group ? " in every repository" : ""}.`);
+      return;
+  }
+}
+
+// src/commands/planner.ts
+var import_core13 = require("@ordewell/core");
+
+// src/plannerModelSwitch.ts
+function describePlannerSwitch(settings, provider) {
+  const model = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
+  const effort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
+  if (!model) return { model: "", effort: "", source: "none" };
+  return rememberedModelFor(settings, provider) === model ? { model, effort, source: "remembered" } : { model, effort, source: "catalog-default" };
+}
+function rememberedModelFor(settings, provider) {
+  const map = settings.plannerModels;
+  if (!map || typeof map !== "object") return void 0;
+  const entry = map[provider];
+  if (!entry || typeof entry !== "object") return void 0;
+  const { model } = entry;
+  return typeof model === "string" ? model : void 0;
+}
+
+// src/commands/planner.ts
+var KNOWN_PROVIDERS = Object.keys(import_core13.ALL_PROVIDERS);
+async function handlePlanner(subArgs, injectedApi) {
+  const api = await connect(subArgs, injectedApi);
+  const [wanted] = positionals(subArgs);
+  if (!wanted || wanted === "show") {
+    await showPlanners(api);
+    return;
+  }
+  const provider = wanted.toLowerCase();
+  if (!KNOWN_PROVIDERS.includes(provider)) {
+    fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
+  }
+  const settings = await persistEnv(api, { AI_PROVIDER: provider });
+  const recall2 = describePlannerSwitch(settings, provider);
+  writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
+  const meta = import_core13.ALL_PROVIDERS[provider];
+  const catalog = await fetchCatalog(api);
+  console.log(
+    (0, import_core13.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+  );
+  console.log(plannerModelLine(recall2));
+  if (!(0, import_core13.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+    console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
+  }
+}
+function plannerModelLine(recall2) {
+  switch (recall2.source) {
+    case "remembered":
+      return `  Restored its planner model: ${recall2.model}.`;
+    case "catalog-default":
+      return `  Using ${recall2.model}, its default model \u2014 pick another with \`ordewell model set <id>\`.`;
+    case "none":
+      return "  Pick a model with `ordewell model set <id>`, or leave it on the default.";
+  }
+}
+async function showPlanners(api) {
+  const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
+  const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
+  console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
+  for (const id of import_core13.CLI_PROVIDERS) {
+    const runner = (0, import_core13.runnerForProvider)(id);
+    const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core13.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+  }
+  console.log("\nAPI providers");
+  for (const id of import_core13.PROVIDER_PRIORITY) {
+    const configured = catalog.providers.includes(id);
+    const meta = import_core13.ALL_PROVIDERS[id];
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
+  }
+  console.log(`
+  * = current. Set with: ordewell planner <id>`);
+}
+function marker(selected) {
+  return selected ? "*" : " ";
+}
+var EFFORT_USAGE = "Usage: ordewell planner-effort [<level>|default]";
+async function handlePlannerEffort(subArgs, injectedApi) {
+  const api = await connect(subArgs, injectedApi);
+  const [wanted] = positionals(subArgs);
+  const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
+  const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
+  const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
+  const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
+  const runner = (0, import_core13.runnerForProvider)(provider);
+  if (!runner) {
+    fail(
+      "Thinking effort applies to a coding-agent planner.",
+      "Switch with: ordewell planner claude-code|codex|opencode"
+    );
+  }
+  const model = catalog.models.find((m) => m.id === modelId && m.runners?.includes(runner));
+  const variants = model?.variants ?? [];
+  if (!wanted || wanted === "show") {
+    console.log(`Planner effort: ${currentEffort || "runner default"}`);
+    if (!model) {
+      console.log(`  No planner model selected for ${runner} \u2014 pick one with \`ordewell model set <id>\`.`);
+    } else if (variants.length === 0) {
+      console.log(`  ${model.label} exposes no effort levels; it always runs at the agent's default.`);
+    } else {
+      console.log(`  Available for ${model.label}: ${variants.map((v) => v.id).join(", ")}, default`);
+    }
+    console.log(`  ${EFFORT_USAGE}`);
+    return;
+  }
+  const level = wanted.toLowerCase();
+  if (level === "default") {
+    await persistEnv(api, { ORDEWELL_PLANNER_EFFORT: "" });
+    console.log("Planner effort set to the runner default.");
+    return;
+  }
+  if (!model) {
+    fail(`No planner model selected for ${runner}.`, "Pick one with: ordewell model set <id>");
+  }
+  if (!variants.some((v) => v.id === level)) {
+    fail(
+      variants.length > 0 ? `Unknown effort: ${wanted}. Available for ${model.label}: ${variants.map((v) => v.id).join(", ")}, default.` : `${model.label} exposes no effort levels; it always runs at the agent's default.`
+    );
   }
   await persistEnv(api, { ORDEWELL_PLANNER_EFFORT: level });
   console.log(`Planner effort set to ${level}.`);
 }
 
 // src/commands/key.ts
-var import_core13 = require("@ordewell/core");
-var USAGE4 = "Usage: ordewell key [list | set <provider> <key>]";
+var import_core14 = require("@ordewell/core");
+var USAGE5 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
   if (action && action !== "list" && action !== "set") {
-    fail(`Unknown key action: "${action}"`, USAGE4);
+    fail(`Unknown key action: "${action}"`, USAGE5);
   }
   const api = await connect(subArgs, injectedApi);
   if (action !== "set") {
     const catalog = await fetchCatalog(api);
     console.log("\nAPI provider keys\n");
-    for (const id2 of import_core13.PROVIDER_PRIORITY) {
-      const meta2 = import_core13.ALL_PROVIDERS[id2];
+    for (const id2 of import_core14.PROVIDER_PRIORITY) {
+      const meta2 = import_core14.ALL_PROVIDERS[id2];
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
     console.log(`
-  \u2713 = a working key was found. ${USAGE4}`);
+  \u2713 = a working key was found. ${USAGE5}`);
     return;
   }
-  if (!provider) fail(USAGE4);
+  if (!provider) fail(USAGE5);
   const id = provider.toLowerCase();
-  const meta = import_core13.ALL_PROVIDERS[id];
+  const meta = import_core14.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -2296,7 +2995,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var USAGE5 = "Usage: ordewell runners [<runner-id> on|off]";
+var USAGE6 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
   const api = await connect(subArgs, injectedApi);
@@ -2307,7 +3006,7 @@ async function handleRunners(subArgs, injectedApi) {
       console.log(`  ${r.enabled ? "\u2713" : " "} ${r.id.padEnd(14)} ${r.name}${r.enabled ? "" : "  (disabled)"}`);
     }
     console.log(`
-  \u2713 = offered to the planner. ${USAGE5}`);
+  \u2713 = offered to the planner. ${USAGE6}`);
     return;
   }
   const state = await api.getRunners();
@@ -2316,7 +3015,7 @@ async function handleRunners(subArgs, injectedApi) {
     fail(`Unknown runner: ${runner}`, `Enabled or not, this daemon knows: ${state.runners.map((r) => r.id).join(", ")}`);
   }
   const enabled = toggle === void 0 ? !known.enabled : toggle === "on" ? true : toggle === "off" ? false : null;
-  if (enabled === null) fail(USAGE5);
+  if (enabled === null) fail(USAGE6);
   await api.setRunnerEnabled(runner, enabled);
   console.log(`${runner} ${enabled ? "enabled" : "disabled"}.`);
 }
@@ -2352,20 +3051,21 @@ async function handleRefresh(subArgs, injectedApi) {
 async function handleApprove(subArgs, injectedApi) {
   const sessionId = resolveSessionId(subArgs);
   const api = await connect(subArgs, injectedApi);
-  try {
-    await api.approveReview(sessionId);
-  } catch (err) {
-    console.error(`Failed to approve: ${err.message}`);
-    process.exit(1);
-  }
-  console.error("Plan approved \u2014 continuing execution.");
-  await followExecution(api, sessionId);
+  await followExecution(api, sessionId, async () => {
+    try {
+      await api.approveReview(sessionId);
+    } catch (err) {
+      console.error(`Failed to approve: ${err.message}`);
+      process.exit(1);
+    }
+    console.error("Plan approved \u2014 continuing execution.");
+  });
 }
 
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core14 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
 var defaultExecFile = async (command, args) => {
   const { stdout, stderr } = await execFileAsync(command, args);
@@ -2385,16 +3085,16 @@ var defaultWhich = (bin) => {
 async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
-  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core14.hasTmux;
+  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core15.hasTmux;
   const execFileImpl = deps.execFileImpl ?? defaultExecFile;
   const spawnImpl = deps.spawnImpl ?? defaultSpawn;
   const which = deps.which ?? defaultWhich;
   if (!hasTmuxImpl()) {
     return { ok: false, message: "tmux is not installed \u2014 install it to get a real terminal per task." };
   }
-  const session = (0, import_core14.tmuxSessionName)(port);
-  const socket = (0, import_core14.tmuxSocketName)(port);
-  const base = (0, import_core14.tmuxWindowName)(taskId, planSessionId);
+  const session = (0, import_core15.tmuxSessionName)(port);
+  const socket = (0, import_core15.tmuxSocketName)(port);
+  const base = (0, import_core15.tmuxWindowName)(taskId, planSessionId);
   let windows;
   try {
     const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
@@ -2598,239 +3298,97 @@ Model \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assigne
 var EFFORT_USAGE2 = "Usage: ordewell task-effort <task-id-or-order> [<level>|default] [--session-id <id>]";
 async function handleTaskEffort(subArgs, injectedApi) {
   await withTask(subArgs, EFFORT_USAGE2, injectedApi, async (api, sessionId, task, _tasks, level) => {
-    const catalog = await fetchCatalog(api);
-    const variants = effortsForTask(catalog.models, task);
-    const current = task.assignedModel?.thinkingEffort;
-    if (!level) {
-      console.log(`
-Thinking effort \xB7 #${task.order} ${task.title}
-`);
-      console.log(`  ${current ? " " : "*"} default        Let the executor choose`);
-      for (const v of variants) {
-        console.log(`  ${v.id === current ? "*" : " "} ${v.id.padEnd(14)} ${v.label}`);
-      }
-      if (variants.length === 0) {
-        console.log(`
-  ${task.assignedModel?.modelLabel ?? "This model"} exposes no effort levels.`);
-      }
-      console.log(`
-  ${EFFORT_USAGE2}`);
-      return;
-    }
-    const wanted = level.toLowerCase();
-    const thinkingEffort = wanted === "default" ? void 0 : wanted;
-    if (thinkingEffort && !variants.some((v) => v.id === thinkingEffort)) {
-      fail(
-        variants.length > 0 ? `Unknown effort: ${level}. Available: ${variants.map((v) => v.id).join(", ")}, default.` : `${task.assignedModel?.modelLabel ?? "This task model"} exposes no effort levels.`
-      );
-    }
-    await api.updateTask(sessionId, task.id, {
-      assignedModel: task.assignedModel ? { ...task.assignedModel, thinkingEffort } : void 0,
-      thinkingEffort: thinkingEffort ?? null
-    });
-    console.log(`Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`);
-  });
-}
-var MODE_USAGE = "Usage: ordewell task-mode <task-id-or-order> [<mode>] [--session-id <id>]";
-async function handleTaskMode(subArgs, injectedApi) {
-  await withTask(subArgs, MODE_USAGE, injectedApi, async (api, sessionId, task, _tasks, mode) => {
-    const catalog = await fetchCatalog(api);
-    const modes = modesForTask(catalog.modesByRunner, task);
-    if (!mode) {
-      console.log(`
-Mode \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
-`);
-      if (modes.length === 0) {
-        console.log("  This task has no runner, or its runner declares no modes.");
-      }
-      for (const m of modes) {
-        console.log(`  ${m.id === task.taskMode ? "*" : " "} ${m.id.padEnd(14)} ${m.label}${m.description ? ` \u2014 ${m.description}` : ""}`);
-      }
-      console.log(`
-  ${MODE_USAGE}`);
-      return;
-    }
-    const chosen = modes.find((m) => m.id === mode);
-    if (!chosen) {
-      fail(
-        modes.length > 0 ? `Unknown mode "${mode}" for ${task.assignedRunner}. Available: ${modes.map((m) => m.id).join(", ")}.` : `${task.assignedRunner ?? "This task"} declares no modes.`
-      );
-    }
-    await api.updateTask(sessionId, task.id, { taskMode: chosen.id });
-    console.log(`Task #${task.order} mode set to ${chosen.label}.`);
-  });
-}
-var DEPS_USAGE = "Usage: ordewell task-deps <task-id-or-order> [<id,id,\u2026>|none] [--session-id <id>]";
-async function handleTaskDeps(subArgs, injectedApi) {
-  await withTask(subArgs, DEPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
-    const candidates = (0, import_plan_utils2.dependencyCandidates)(tasks, task.id);
-    if (!value) {
-      console.log(`
-Dependencies \xB7 #${task.order} ${task.title}
-`);
-      if (candidates.length === 0) {
-        console.log(`  Nothing runs before #${task.order}, so it has no possible dependencies.`);
-      }
-      for (const c of candidates) {
-        const chosen = task.dependencies.includes(c.id);
-        console.log(`  ${chosen ? "*" : " "} ${c.id}  #${c.order} ${c.title}${c.status === "completed" ? "  (already completed)" : ""}`);
-      }
-      console.log(`
-  * = current. ${DEPS_USAGE}`);
-      return;
-    }
-    const dependencies = value.toLowerCase() === "none" ? [] : value.split(",").map((s) => s.trim()).filter(Boolean).map((token) => tasks.find((t) => t.id === token || String(t.order) === token)?.id ?? token);
-    const check = (0, import_plan_utils2.canSetDependencies)(tasks, task.id, dependencies);
-    if (!check.ok) fail(check.error ?? "Invalid dependencies.");
-    await api.updateTask(sessionId, task.id, { dependencies });
-    console.log(dependencies.length > 0 ? `Task #${task.order} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`);
-  });
-}
-
-// src/tui/index.ts
-var import_core18 = require("@ordewell/core");
-
-// src/tui/ansi.ts
-var import_string_width = __toESM(require("string-width"));
-var ESCAPE = /\x1b(?:\][\s\S]*?(?:\x07|\x1b\\|$)|[P^_][\s\S]*?(?:\x1b\\|$)|\[[0-?]*[ -/]*[@-~]?|[ -/]*[0-~]?)/g;
-var ESCAPE_SPLIT = new RegExp(`(${ESCAPE.source})`);
-var CONTROL = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
-var CONTROL_IN_ROW = /[\x00-\x1f\x7f-\x9f]/g;
-var HAS_CONTROL = /[\x00-\x1f\x7f-\x9f]/;
-var PAINT_ESCAPE = /^\x1b\[[0-9;]*[mGK]$/;
-function stripAnsi(text) {
-  return text.replace(ESCAPE, "");
-}
-function sanitize(text) {
-  return text.replace(ESCAPE, "").replace(/\r\n?/g, "\n").replace(/\t/g, " ").replace(CONTROL, "");
-}
-function paintOnly(line) {
-  if (!HAS_CONTROL.test(line)) return line;
-  return line.split(ESCAPE_SPLIT).map((piece) => piece.startsWith("\x1B") ? PAINT_ESCAPE.test(piece) ? piece : "" : piece.replace(CONTROL_IN_ROW, "")).join("");
-}
-function width(text) {
-  return (0, import_string_width.default)(stripAnsi(text));
-}
-function truncate(text, max) {
-  if (max <= 0) return "";
-  if (width(text) <= max) return text;
-  let out = "";
-  let used = 0;
-  for (const char of stripAnsi(text)) {
-    const w = (0, import_string_width.default)(char);
-    if (used + w > max - 1) break;
-    out += char;
-    used += w;
-  }
-  return out + "\u2026";
-}
-function pad(text, target) {
-  const current = width(text);
-  if (current > target) return truncate(text, target);
-  return text + " ".repeat(target - current);
-}
-function chopWord(piece, max) {
-  const chunks = [];
-  let cur = "";
-  let curWidth = 0;
-  for (const ch of piece) {
-    const w = (0, import_string_width.default)(ch);
-    if (cur && curWidth + w > max) {
-      chunks.push(cur);
-      cur = ch;
-      curWidth = w;
-    } else {
-      cur += ch;
-      curWidth += w;
-    }
-  }
-  chunks.push(cur);
-  return chunks;
-}
-var wrapMemo = /* @__PURE__ */ new Map();
-var WRAP_MEMO_MAX = 64;
-function wrapLines(text, max) {
-  const key = `${max}\0${text}`;
-  const cached = wrapMemo.get(key);
-  if (cached) {
-    wrapMemo.delete(key);
-    wrapMemo.set(key, cached);
-    return cached;
-  }
-  const result = computeWrapLines(text, max);
-  if (wrapMemo.size >= WRAP_MEMO_MAX) {
-    const oldest = wrapMemo.keys().next().value;
-    if (oldest !== void 0) wrapMemo.delete(oldest);
-  }
-  wrapMemo.set(key, result);
-  return result;
-}
-function computeWrapLines(text, max) {
-  if (max <= 0) return [{ line: "", start: 0 }];
-  const out = [];
-  let pos = 0;
-  for (const paragraph of text.split("\n")) {
-    let current = "";
-    let currentStart = pos;
-    let first = true;
-    let wordPos = pos;
-    for (const word of paragraph.split(" ")) {
-      let piece = word;
-      let pieceStart = wordPos;
-      if (width(piece) > max) {
-        const chunks = chopWord(piece, max);
-        for (let ci = 0; ci < chunks.length - 1; ci++) {
-          const head = chunks[ci];
-          if (!first) {
-            out.push({ line: current, start: currentStart });
-            current = "";
-          }
-          out.push({ line: head, start: pieceStart });
-          pieceStart += head.length;
-          first = true;
-        }
-        piece = chunks[chunks.length - 1];
+    const catalog = await fetchCatalog(api);
+    const variants = effortsForTask(catalog.models, task);
+    const current = task.assignedModel?.thinkingEffort;
+    if (!level) {
+      console.log(`
+Thinking effort \xB7 #${task.order} ${task.title}
+`);
+      console.log(`  ${current ? " " : "*"} default        Let the executor choose`);
+      for (const v of variants) {
+        console.log(`  ${v.id === current ? "*" : " "} ${v.id.padEnd(14)} ${v.label}`);
       }
-      const candidate = first ? piece : `${current} ${piece}`;
-      const candidateStart = first ? pieceStart : currentStart;
-      first = false;
-      if (width(candidate) > max) {
-        out.push({ line: current, start: currentStart });
-        current = piece;
-        currentStart = pieceStart;
-      } else {
-        current = candidate;
-        currentStart = candidateStart;
+      if (variants.length === 0) {
+        console.log(`
+  ${task.assignedModel?.modelLabel ?? "This model"} exposes no effort levels.`);
       }
-      wordPos += word.length + 1;
+      console.log(`
+  ${EFFORT_USAGE2}`);
+      return;
     }
-    out.push({ line: current, start: currentStart });
-    pos += paragraph.length + 1;
-  }
-  return out.length > 0 ? out : [{ line: "", start: 0 }];
+    const wanted = level.toLowerCase();
+    const thinkingEffort = wanted === "default" ? void 0 : wanted;
+    if (thinkingEffort && !variants.some((v) => v.id === thinkingEffort)) {
+      fail(
+        variants.length > 0 ? `Unknown effort: ${level}. Available: ${variants.map((v) => v.id).join(", ")}, default.` : `${task.assignedModel?.modelLabel ?? "This task model"} exposes no effort levels.`
+      );
+    }
+    await api.updateTask(sessionId, task.id, {
+      assignedModel: task.assignedModel ? { ...task.assignedModel, thinkingEffort } : void 0,
+      thinkingEffort: thinkingEffort ?? null
+    });
+    console.log(`Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`);
+  });
 }
-function wrap(text, max) {
-  return wrapLines(text, max).map((l) => l.line);
+var MODE_USAGE = "Usage: ordewell task-mode <task-id-or-order> [<mode>] [--session-id <id>]";
+async function handleTaskMode(subArgs, injectedApi) {
+  await withTask(subArgs, MODE_USAGE, injectedApi, async (api, sessionId, task, _tasks, mode) => {
+    const catalog = await fetchCatalog(api);
+    const modes = modesForTask(catalog.modesByRunner, task);
+    if (!mode) {
+      console.log(`
+Mode \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
+`);
+      if (modes.length === 0) {
+        console.log("  This task has no runner, or its runner declares no modes.");
+      }
+      for (const m of modes) {
+        console.log(`  ${m.id === task.taskMode ? "*" : " "} ${m.id.padEnd(14)} ${m.label}${m.description ? ` \u2014 ${m.description}` : ""}`);
+      }
+      console.log(`
+  ${MODE_USAGE}`);
+      return;
+    }
+    const chosen = modes.find((m) => m.id === mode);
+    if (!chosen) {
+      fail(
+        modes.length > 0 ? `Unknown mode "${mode}" for ${task.assignedRunner}. Available: ${modes.map((m) => m.id).join(", ")}.` : `${task.assignedRunner ?? "This task"} declares no modes.`
+      );
+    }
+    await api.updateTask(sessionId, task.id, { taskMode: chosen.id });
+    console.log(`Task #${task.order} mode set to ${chosen.label}.`);
+  });
 }
-function colour(open) {
-  return (text) => style.enabled ? `\x1B[${open}m${text}\x1B[0m` : text;
+var DEPS_USAGE = "Usage: ordewell task-deps <task-id-or-order> [<id,id,\u2026>|none] [--session-id <id>]";
+async function handleTaskDeps(subArgs, injectedApi) {
+  await withTask(subArgs, DEPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
+    const candidates = (0, import_plan_utils2.dependencyCandidates)(tasks, task.id);
+    if (!value) {
+      console.log(`
+Dependencies \xB7 #${task.order} ${task.title}
+`);
+      if (candidates.length === 0) {
+        console.log(`  Nothing runs before #${task.order}, so it has no possible dependencies.`);
+      }
+      for (const c of candidates) {
+        const chosen = task.dependencies.includes(c.id);
+        console.log(`  ${chosen ? "*" : " "} ${c.id}  #${c.order} ${c.title}${c.status === "completed" ? "  (already completed)" : ""}`);
+      }
+      console.log(`
+  * = current. ${DEPS_USAGE}`);
+      return;
+    }
+    const dependencies = value.toLowerCase() === "none" ? [] : value.split(",").map((s) => s.trim()).filter(Boolean).map((token) => tasks.find((t) => t.id === token || String(t.order) === token)?.id ?? token);
+    const check = (0, import_plan_utils2.canSetDependencies)(tasks, task.id, dependencies);
+    if (!check.ok) fail(check.error ?? "Invalid dependencies.");
+    await api.updateTask(sessionId, task.id, { dependencies });
+    console.log(dependencies.length > 0 ? `Task #${task.order} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`);
+  });
 }
-var style = {
-  /** Set false when the output is piped or the terminal has no colour. */
-  enabled: true,
-  bold: colour("1"),
-  dim: colour("2"),
-  italic: colour("3"),
-  underline: colour("4"),
-  inverse: colour("7"),
-  red: colour("31"),
-  green: colour("32"),
-  yellow: colour("33"),
-  blue: colour("34"),
-  magenta: colour("35"),
-  cyan: colour("36"),
-  grey: colour("90")
-};
+
+// src/tui/index.ts
+var import_core20 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -2968,6 +3526,7 @@ var SLASH_COMMANDS = [
   { name: "approve", usage: "/approve", description: "Approve the drafted plan", category: "planning" },
   { name: "run", usage: "/run", description: "Execute the approved plan", category: "planning" },
   { name: "stop", usage: "/stop", description: "Stop the planner or the running execution, whichever is active", category: "planning" },
+  { name: "handoff", usage: "/handoff [review|merge|discard|cleanup]", description: "Land an isolated run's branch: review it, merge it into yours, or discard it", category: "planning" },
   // Tasks
   { name: "add-task", usage: "/add-task <title>", description: "Add a task to the current plan", category: "tasks" },
   { name: "remove-task", usage: "/remove-task <id>", description: "Remove a task from the plan", category: "tasks" },
@@ -2997,6 +3556,9 @@ var SLASH_COMMANDS = [
   { name: "verify", usage: "/verify [on|off]", description: "Verification mode \u2014 final evidence-based task that runs the suite", category: "skills" },
   // Sessions
   { name: "sessions", usage: "/sessions", description: "List saved sessions", category: "session" },
+  { name: "fork", usage: "/fork", description: "Continue in a copy of this conversation and its tasks; the original stays as it is", category: "session" },
+  { name: "compact", usage: "/compact", description: "Condense this conversation into a summary; the last two exchanges and all tasks are kept", category: "session" },
+  { name: "rewind", usage: "/rewind [<message>]", description: "Fork the conversation from just before one of your messages, after a confirmation (the original is kept)", category: "session" },
   { name: "new", usage: "/new", description: "Start a new session", category: "session" },
   { name: "save", usage: "/save", description: "Save the current session", category: "session" },
   { name: "load", usage: "/load <id>", description: "Load a saved session", category: "session" },
@@ -3268,6 +3830,7 @@ function initialState(overrides = {}) {
     skills: noSkills(),
     runners: [],
     sessions: [],
+    rewindTargets: null,
     models: [],
     modesByRunner: {},
     orchestratorModels: [],
@@ -3281,6 +3844,7 @@ function initialState(overrides = {}) {
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
+    handoff: null,
     overlay: null,
     pendingApprovals: [],
     toast: "",
@@ -3293,7 +3857,7 @@ function initialState(overrides = {}) {
 }
 
 // src/tui/layout.ts
-var import_core15 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -3301,7 +3865,9 @@ function chatInputWrap(state) {
   return wrapLines(state.editor.text, chatEditorRoom(state.cols, true));
 }
 function footerHints(state) {
-  const markHint = selectedPlanRow(state)?.task.status === "completed" ? "m undone" : "m done";
+  const selected = selectedPlanRow(state)?.task;
+  const markHint = selected?.status === "completed" ? "m undone" : "m done";
+  const resolveHint = selected?.isolation?.state === "conflict" ? ["x resolve conflict"] : [];
   const planning = state.status === "planning" || state.status === "researching";
   const escHint = planning ? "esc stop planning" : null;
   if (state.focus === "plan") {
@@ -3324,6 +3890,7 @@ function footerHints(state) {
       "a add",
       "d remove",
       "t terminal",
+      ...resolveHint,
       "pgup/pgdn scroll",
       "tab chat"
     ];
@@ -3417,21 +3984,18 @@ function chatBodyLines(messages, cols) {
 }
 function chatLayout(state, rows, cols) {
   const welcome = state.tasks.length === 0;
-  if (welcome && state.messages.length === 0) {
-    return { lines: welcomeLines(state, cols), anchor: "top", maxScroll: 0 };
-  }
   const body = chatBodyLines(state.messages, cols);
-  const lines = welcome ? [...welcomeLines(state, cols), "", ...body] : body;
-  return { lines, anchor: "bottom", maxScroll: Math.max(0, lines.length - rows) };
+  const lines = !welcome ? body : state.messages.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
+  return { lines, anchor: lines.length > rows ? "bottom" : "top", maxScroll: Math.max(0, lines.length - rows) };
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core15.ALL_PROVIDERS[provider];
+  const registration = import_core16.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core15.runnerForProvider)(provider);
+  const runner = (0, import_core16.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -3539,33 +4103,69 @@ var STATUS_ICON = {
   pending: "\xB7"
 };
 var IDLE_ICON = "~";
+var FIRST_ROW_LINE = 2;
 function planLayout(state, rows, cols) {
   const done = state.tasks.filter((t) => t.status === "completed").length;
   const lines = [style.bold(`Plan ${done}/${state.tasks.length}`), ""];
-  let selectedLine = 2;
+  const rowSpans = [];
   let editorLine;
   planRows(state).forEach((row, i) => {
     const taskStart = lines.length;
-    if (i === state.selectedTask) selectedLine = taskStart;
     const renderedTask = taskLines(state, row, i, cols);
     if (row.task.id === state.expandedTaskId && renderedTask.editorLine !== void 0) {
       editorLine = taskStart + renderedTask.editorLine;
     }
     lines.push(...renderedTask.lines);
+    rowSpans.push({ start: taskStart, end: lines.length - 1 });
   });
-  const maxScroll = Math.max(0, lines.length - rows);
-  const anchorLine = editorLine ?? selectedLine;
-  return { lines, followOffset: Math.min(maxScroll, Math.max(0, anchorLine - rows + 3)), maxScroll };
+  const selected = rowSpans[state.selectedTask] ?? { start: FIRST_ROW_LINE, end: FIRST_ROW_LINE };
+  const anchor = editorLine === void 0 ? selected : { start: editorLine, end: editorLine };
+  return { lines, rowSpans, anchor, rows, maxScroll: Math.max(0, lines.length - rows) };
+}
+var clampOffset = (layout, offset) => Math.max(0, Math.min(layout.maxScroll, offset));
+function revealOffset(layout, offset, span) {
+  const at = clampOffset(layout, offset);
+  const bodyHeight = layout.rows - 1;
+  const first = span.start <= FIRST_ROW_LINE ? 0 : span.start - 1;
+  if (span.start < 1 + at || span.end - span.start + 1 > bodyHeight) return clampOffset(layout, first);
+  if (span.end > at + layout.rows - 1) return clampOffset(layout, span.end - layout.rows + 1);
+  return at;
 }
 function planOffset(layout, planScroll) {
-  if (planScroll === null) return layout.followOffset;
-  return Math.max(0, Math.min(layout.maxScroll, planScroll));
+  if (planScroll === null) return revealOffset(layout, 0, layout.anchor);
+  return clampOffset(layout, planScroll);
+}
+function topRowInView(layout, offset) {
+  const top = 1 + offset;
+  const whole = layout.rowSpans.findIndex((span) => span.start >= top && span.end <= offset + layout.rows - 1);
+  if (whole >= 0) return whole;
+  const covering = layout.rowSpans.findIndex((span) => span.end >= top);
+  return covering >= 0 ? covering : layout.rowSpans.length - 1;
+}
+function bottomRowInView(layout, offset) {
+  const bottom = offset + layout.rows - 1;
+  const spans = layout.rowSpans;
+  for (let i = spans.length - 1; i >= 0; i--) {
+    if (spans[i].start >= 1 + offset && spans[i].end <= bottom) return i;
+  }
+  for (let i = spans.length - 1; i >= 0; i--) {
+    if (spans[i].start <= bottom) return i;
+  }
+  return 0;
+}
+function rowNearestView(layout, offset, row) {
+  const span = layout.rowSpans[row];
+  if (!span) return row;
+  if (span.end < 1 + offset) return topRowInView(layout, offset);
+  if (span.start > offset + layout.rows - 1) return bottomRowInView(layout, offset);
+  return row;
 }
 function planScrollExtent(state) {
   const cols = planPaneWidth(state);
-  if (cols === 0) return { followOffset: 0, maxScroll: 0 };
-  const { followOffset, maxScroll } = planLayout(state, bodyRows(state), cols);
-  return { followOffset, maxScroll };
+  if (cols === 0) {
+    return { lines: [], rowSpans: [], anchor: { start: FIRST_ROW_LINE, end: FIRST_ROW_LINE }, rows: 0, maxScroll: 0 };
+  }
+  return planLayout(state, bodyRows(state), cols);
 }
 function taskLines(state, row, index, cols) {
   const { task, parent } = row;
@@ -3578,7 +4178,7 @@ function taskLines(state, row, index, cols) {
   const icon = paint(rawIcon);
   const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : style.grey(" AI");
   const caret = selected ? style.cyan("\u276F") : " ";
-  const orderLabel = parent ? (0, import_core15.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
+  const orderLabel = parent ? (0, import_core16.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
   const indent = parent ? "  " : "";
   const head = `${indent}${caret} ${icon} ${orderLabel} ${kind} `;
   const titleRoom = Math.max(1, cols - width(head));
@@ -3602,9 +4202,30 @@ function taskLines(state, row, index, cols) {
   const meta = [running ? "working" : "", runner, model].filter(Boolean).join(" \xB7 ");
   if (meta) lines.push(style.grey(truncate(`${bodyPad}${meta}`, cols)));
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
+  if (task.isolation?.state === "conflict") {
+    const where = task.isolation.conflictRepo && task.isolation.conflictRepo !== "." ? ` in ${task.isolation.conflictRepo}` : "";
+    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core16.capConflictFiles)(task.isolation.conflictFiles)})` : "";
+    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files} \u2014 its work is kept on its own branch`, cols)));
+  }
+  if (task.isolation?.state === "repairing") {
+    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core16.capConflictFiles)(task.isolation.conflictFiles)}` : "";
+    const attempt = task.isolation.repair ? ` (attempt ${task.isolation.repair.attempt}/${task.isolation.repair.limit})` : "";
+    lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
+  }
+  if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
+    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core16.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
+  }
   let editorLine;
   if (expanded) {
     lines.push(style.grey(`${bodyPad}${task.status.replace(/_/g, " ")}`));
+    if (task.isolation && task.isolation.state !== "none" && task.isolation.branch) {
+      lines.push(...taskText("Branch", task.isolation.branch, cols, bodyPad));
+      const repos = taskRepoNames(task.isolation);
+      if (repos.length > 0) lines.push(...taskText("Repos", repos.join(", "), cols, bodyPad));
+      if (task.isolation.state !== "integrated" && task.isolation.worktree) {
+        lines.push(...taskText("Worktree", task.isolation.worktree, cols, bodyPad));
+      }
+    }
     if (modeInfo?.autonomous) {
       lines.push(...taskText("Autonomy", "Runs without permission prompts. Toggle with /auto.", cols, bodyPad));
     }
@@ -3677,6 +4298,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
+var import_core17 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -3775,8 +4397,7 @@ function renderSkills(state, cols) {
   return truncate([...badges, auto].join(" "), cols);
 }
 function scrolledBackMark(state) {
-  if (state.focus === "plan") return state.planScroll === null ? "" : "\u2191 scrolled back \xB7 \u2191\u2193 to follow";
-  return state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
+  return state.focus !== "plan" && state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
 }
 function renderStatus(state, cols) {
   const mark = scrolledBackMark(state);
@@ -3916,14 +4537,7 @@ function renderOverlay(state, rows, cols) {
       cols
     );
   }
-  if (overlay.kind === "confirm") {
-    return frame(
-      overlay.title,
-      [overlay.message, "", style.grey("enter confirms \xB7 esc cancels")],
-      rows,
-      cols
-    );
-  }
+  if (overlay.kind === "confirm") return renderConfirm(overlay, rows, cols);
   if (overlay.kind === "prompt") {
     const secret = overlay.action.kind === "api-key";
     const shown = secret ? "\u2022".repeat(overlay.value.length) : overlay.value;
@@ -3934,8 +4548,54 @@ function renderOverlay(state, rows, cols) {
       cols
     );
   }
+  if (overlay.kind === "handoff") return renderHandoff(state, overlay, rows, cols);
   return renderPicker(overlay.picker, rows, cols);
 }
+function renderHandoff(state, overlay, rows, cols) {
+  const handoff = state.handoff;
+  if (!handoff) return frame("Handoff", [style.grey("Nothing to hand off.")], rows, cols);
+  if (overlay.diff) {
+    const room = diffRoom(rows);
+    const { lines, scroll } = overlay.diff;
+    const shown = lines.slice(scroll, scroll + room).map((line) => paintDiffLine(truncate(line, Math.max(1, cols - 2))));
+    const more = scroll + room < lines.length ? "\u2191\u2193 pgup/pgdn scroll \xB7 " : "";
+    return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
+  }
+  const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core17.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} #${task.order} ${task.title}${repaired}`;
+  });
+  const actions = handoffActions(handoff).map((action, index) => {
+    const active = index === overlay.index;
+    const caret = active ? style.cyan("\u276F") : " ";
+    return `${caret} ${active ? style.bold(action.label) : action.label}${style.grey(` \u2014 ${action.hint}`)}`;
+  });
+  const perRepo = isRepoGroup(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
+  return frame(
+    "Run handoff",
+    [
+      `Branch  ${style.cyan(handoffBranch(handoff))}`,
+      style.grey(`Forked from ${handoffBase(handoff, 12)}`),
+      "",
+      ...perRepo,
+      "Landed on it, in plan order:",
+      ...landed,
+      "",
+      ...actions,
+      "",
+      style.grey("\u2191\u2193 choose \xB7 enter selects \xB7 esc closes")
+    ],
+    rows,
+    cols
+  );
+}
+function paintDiffLine(line) {
+  if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff ")) return style.bold(line);
+  if (line.startsWith("+")) return style.green(line);
+  if (line.startsWith("-")) return style.red(line);
+  if (line.startsWith("@@")) return style.cyan(line);
+  return line;
+}
 function renderPicker(picker2, rows, cols) {
   const items = visibleItems(picker2);
   const body = [];
@@ -3964,6 +4624,24 @@ function renderHelp(scroll, rows, cols) {
   const footer = style.grey(offset < maxScroll ? "\u2191\u2193 scroll \xB7 any other key closes" : "any key closes");
   return frame("Commands", [...lines.slice(offset, offset + room), footer], rows, cols);
 }
+var QUOTE_MAX_LINES = 8;
+function renderConfirm(overlay, rows, cols) {
+  const { choice, quote, note } = overlay;
+  const inner = Math.max(1, cols - 3);
+  const options = (choice?.options ?? []).map((o, i) => `${i === choice?.index ? style.cyan("\u276F") : " "} ${i + 1}. ${o.label}`);
+  const hint = choice ? style.grey(`\u2191\u2193 move \xB7 enter or 1\u2013${choice.options.length} chooses \xB7 esc cancels`) : style.grey("enter confirms \xB7 esc cancels");
+  const noteLines = note ? ["", ...note.split("\n")] : [];
+  const rest = [...noteLines, ...options.length > 0 ? ["", ...options] : [], "", hint];
+  const quoted = [];
+  if (quote !== void 0) {
+    const fixed = 1 + wrap(overlay.message, inner).length + 1 + 1 + rest.flatMap((l) => wrap(l, inner)).length;
+    const room = Math.max(2, Math.min(QUOTE_MAX_LINES, rows - fixed));
+    const wrapped = wrap(quote, inner - 2);
+    const shown = wrapped.length > room ? [...wrapped.slice(0, room - 1), "\u2026"] : wrapped;
+    quoted.push("", ...shown.map((l) => `${style.grey("\u2502")} ${l}`));
+  }
+  return frame(overlay.title, [overlay.message, ...quoted, ...rest], rows, cols);
+}
 function frame(title, body, rows, cols) {
   const inner = Math.max(1, cols - 2);
   const lines = [
@@ -3974,26 +4652,16 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core16 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var import_plan_utils3 = require("@ordewell/core/plan-utils");
-var KNOWN_PROVIDERS2 = Object.keys(import_core16.ALL_PROVIDERS);
+var KNOWN_PROVIDERS2 = Object.keys(import_core18.ALL_PROVIDERS);
 var DEFAULT_EFFORT = "__runner_default__";
 function step(state, effects = []) {
   return { state, effects };
 }
-function say(state, role, content, research, extra) {
-  const message = {
-    role,
-    content: sanitize(content),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    ...research ? { research } : {},
-    ...extra
-  };
-  return { ...state, messages: [...state.messages, message], scroll: 0 };
-}
 function restoredMessages(history) {
   return history.map((entry) => ({
-    role: entry.kind === "plan_generated" ? "system" : entry.kind === "system" ? "system" : entry.role,
+    role: entry.kind === "plan_generated" || entry.kind === "system" || entry.kind === "compaction" ? "system" : entry.role,
     content: sanitize(entry.kind === "plan_generated" ? "Plan generated." : entry.content),
     timestamp: entry.timestamp
   }));
@@ -4001,7 +4669,9 @@ function restoredMessages(history) {
 var isPendingResearch = (m) => m.role === "research" && !m.research?.outcome;
 function alreadySpoken(messages, content) {
   const last = findLastIndex(messages, (m) => m.role === "assistant" || m.role === "user");
-  return last >= 0 && messages[last].role === "assistant" && messages[last].content === content;
+  const spoken = last >= 0 && messages[last].role === "assistant" && messages[last].content === content;
+  const redrawn = messages.at(-1)?.role === "system" && messages.at(-1)?.content === content;
+  return spoken || redrawn;
 }
 function researchLabel(messages, summary) {
   const others = messages.filter(isPendingResearch).length - 1;
@@ -4025,20 +4695,22 @@ function findLastIndex(items, match) {
   return -1;
 }
 var THINKING_TAIL = 400;
-var fail2 = (state, message) => step(say(state, "error", message));
+var fail3 = (state, message) => step(say(state, "error", message));
 var stale = (state, sessionId) => sessionId !== void 0 && sessionId !== state.sessionId;
 function reduce(state, action) {
   switch (action.type) {
     case "key":
       return handleKey2(state, action.key);
+    // Isolation belongs to one session's plan, and task ids repeat across
+    // sessions, so nothing of the last one's may carry over into this.
     case "sessionStarted":
-      return step({ ...state, sessionId: action.sessionId, goal: action.goal });
+      return step(clearIsolation({ ...state, sessionId: action.sessionId, goal: action.goal }));
     // The daemon registers a session only once planning succeeds; when it does
     // not, holding on to the id would send every next message to a session the
     // server never had.
     case "sessionCleared":
       return step({
-        ...state,
+        ...clearIsolation(state),
         sessionId: null,
         goal: "",
         pendingApprovals: [],
@@ -4057,18 +4729,21 @@ function reduce(state, action) {
       return step({ ...state, messages: restoredMessages(action.history), scroll: 0 });
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
-      const tasks = normalizeTasks(action.plan);
+      const isolation = isolationOfPlan(action.plan);
+      const tasks = isolationForPlan(normalizeTasks(action.plan), isolation, state.tasks);
       const expandedTaskId = state.expandedTaskId && findTask(tasks, state.expandedTaskId) ? state.expandedTaskId : null;
       const next = {
         ...state,
         tasks,
+        handoff: isolation ? isolation.handoff : state.handoff,
         status: state.status === "planning" || state.status === "researching" ? "idle" : state.status,
         busyLabel: "",
         thinkingLine: "",
         expandedTaskId,
         taskEditor: expandedTaskId !== null ? state.taskEditor : null
       };
-      return step({ ...next, selectedTask: Math.min(state.selectedTask, Math.max(0, planRows(next).length - 1)) });
+      const selectedTask = clampSelection(state.selectedTask, planRows(next).length);
+      return step(settlePlan({ ...next, selectedTask, focus: tasks.length === 0 ? "chat" : state.focus }));
     }
     case "plannerMessage": {
       if (stale(state, action.sessionId)) return step(state);
@@ -4133,9 +4808,10 @@ function reduce(state, action) {
         const update = updates[t.id];
         if (update === void 0) return t;
         const idleSince = update.idleSince ?? null;
-        if (update.status !== t.status || idleSince !== (t.idleSince ?? null)) {
+        const isolation = update.isolation ?? t.isolation;
+        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation)) {
           changed = true;
-          return { ...t, status: update.status, idleSince };
+          return { ...t, status: update.status, idleSince, isolation };
         }
         return t;
       });
@@ -4148,6 +4824,23 @@ function reduce(state, action) {
       if (sessionId === null) return step(state);
       return step(state, [{ type: "processQueued", sessionId }]);
     }
+    case "isolationBlocked": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(blockedPicker(state, action.message, action.repos));
+    }
+    case "isolationHandoff": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(handoffArrived(state, action.handoff));
+    }
+    case "handoffDiff": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(showDiff(state, action.diff));
+    }
+    case "runCleared": {
+      if (stale(state, action.sessionId)) return step(state);
+      const overlay = state.overlay?.kind === "handoff" ? null : state.overlay;
+      return step({ ...clearIsolation(state), overlay });
+    }
     case "executionComplete": {
       if (stale(state, action.sessionId)) return step(state);
       const { completed, total, failed } = action.summary ?? {
@@ -4182,6 +4875,33 @@ function reduce(state, action) {
       );
     case "sessionsLoaded":
       return step(refillPicker({ ...state, sessions: action.sessions }, ["load-session", "delete-session"]));
+    case "rewindTargetsLoaded":
+      if (stale(state, action.sessionId)) return step(state);
+      if (action.pick !== void 0) return pickRewindTarget({ ...state, rewindTargets: action.targets }, action.pick);
+      return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
+    // A fork holds no run, whatever the session it came from was doing — the
+    // original keeps its run, and its events are stale from here on.
+    case "sessionForked":
+      return step({
+        ...clearIsolation(state),
+        sessionId: action.sessionId,
+        goal: action.goal,
+        status: "idle",
+        busyLabel: "",
+        thinkingLine: "",
+        planApproved: false,
+        pendingApprovals: [],
+        overlay: state.overlay?.kind === "approval" ? null : state.overlay
+      });
+    // The rewound message comes back as a draft to edit and resend, so it lands
+    // as if just typed: history is not being browsed, and nothing is parked.
+    case "inputPrefilled":
+      if (stale(state, action.sessionId)) return step(state);
+      return step({
+        ...state,
+        focus: "chat",
+        editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
+      });
     case "runnersLoaded":
       return step(refillPicker({
         ...state,
@@ -4207,11 +4927,7 @@ function reduce(state, action) {
       return step(say(state, "system", action.message));
     case "resize": {
       const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
-      return step({
-        ...resized,
-        scroll: clamp(resized.scroll, chatScrollMax(resized)),
-        planScroll: resized.planScroll === null ? null : clamp(resized.planScroll, planScrollExtent(resized).maxScroll)
-      });
+      return step(settlePlan({ ...resized, scroll: clamp(resized.scroll, chatScrollMax(resized)) }));
     }
     // Whether there is anything to animate is the app loop's call (it owns the
     // timer); a tick that arrives simply advances the frame.
@@ -4286,11 +5002,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core16.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core18.ALL_PROVIDERS[p]?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state) {
-  const runner = (0, import_core16.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
   if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -4304,7 +5020,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core16.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -4331,6 +5047,13 @@ function pickerItemsFor(state, action) {
   if (action.kind === "set-planner-effort") {
     return plannerEffortItems(state);
   }
+  if (action.kind === "rewind") {
+    if (state.rewindTargets === null) return [];
+    if (state.rewindTargets.length === 0) {
+      return [{ id: "", label: "Nothing to rewind to yet", detail: "the only message so far is the goal", disabled: true }];
+    }
+    return [...state.rewindTargets].reverse().map((t) => ({ id: String(t.index), label: t.preview, detail: `message ${t.index}` }));
+  }
   if (action.kind === "load-session" || action.kind === "delete-session") {
     return state.sessions.map((s) => ({
       id: s.id,
@@ -4422,7 +5145,7 @@ function pointerPane(state, key) {
 }
 function scrollPointed(state, key) {
   const delta = key.name === "scrollup" ? WHEEL_NOTCH : -WHEEL_NOTCH;
-  return pointerPane(state, key) === "plan" ? scrollPlan(state, delta) : scrollChat(state, delta);
+  return pointerPane(state, key) === "plan" ? scrollPlan(state, delta, false) : scrollChat(state, delta);
 }
 var isMouseSelect = (key) => key.name === "mousedown" || key.name === "mousedrag" || key.name === "mouseup";
 function selectionCell(state, pane, key) {
@@ -4455,10 +5178,23 @@ function clamp(value, max) {
 function scrollChat(state, delta) {
   return step({ ...state, scroll: clamp(state.scroll + delta, chatScrollMax(state)) });
 }
-function scrollPlan(state, delta) {
-  const { followOffset, maxScroll } = planScrollExtent(state);
-  const from = state.planScroll ?? followOffset;
-  return step({ ...state, planScroll: clamp(from - delta, maxScroll) });
+function settlePlan(state) {
+  if (planPaneWidth(state) === 0) return state;
+  const layout = planScrollExtent(state);
+  return { ...state, planScroll: revealOffset(layout, planOffset(layout, state.planScroll), layout.anchor) };
+}
+function scrollPlan(state, delta, paged) {
+  const layout = planScrollExtent(state);
+  const from = planOffset(layout, state.planScroll);
+  const to = clamp(from - delta, layout.maxScroll);
+  const scrolled = { ...state, planScroll: to };
+  if (state.taskEditor || layout.rowSpans.length === 0) return step(scrolled);
+  const back = delta > 0;
+  if (!paged) {
+    return step({ ...scrolled, selectedTask: rowNearestView(layout, to, state.selectedTask) });
+  }
+  if (to === from) return step({ ...scrolled, selectedTask: back ? 0 : layout.rowSpans.length - 1 });
+  return step({ ...scrolled, selectedTask: back ? bottomRowInView(layout, to) : topRowInView(layout, to) });
 }
 var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function stopPlanning(state, sessionId) {
@@ -4488,7 +5224,10 @@ function handleKey2(state, key) {
       return step({ ...state, editor: { ...state.editor, text, cursor: token.start + completed.length } });
     }
   }
-  if (key.name === "tab") return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
+  if (key.name === "tab") {
+    if (state.focus === "chat" && state.tasks.length === 0) return step(state);
+    return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
+  }
   if (state.focus === "plan") return handlePlanKey(state, key);
   if (key.name === "enter") return submit(state);
   if (key.name === "escape") return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
@@ -4520,35 +5259,32 @@ function handlePlanKey(state, key) {
   const editingTask = state.expandedTaskId ? findTask(state.tasks, state.expandedTaskId) : void 0;
   if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
   if (key.name === "escape") {
-    if (state.expandedTaskId) return step({ ...state, expandedTaskId: null, planScroll: null });
+    if (state.expandedTaskId) return step(settlePlan({ ...state, expandedTaskId: null }));
     return step({ ...state, focus: "chat" });
   }
   if (key.name === "up") {
-    return step({ ...state, selectedTask: Math.max(0, state.selectedTask - 1), planScroll: null });
+    return step(settlePlan({ ...state, selectedTask: Math.max(0, state.selectedTask - 1) }));
   }
   if (key.name === "down") {
-    return step({
-      ...state,
-      selectedTask: Math.min(planRows(state).length - 1, state.selectedTask + 1),
-      planScroll: null
-    });
+    return step(settlePlan({ ...state, selectedTask: clampSelection(state.selectedTask + 1, planRows(state).length) }));
   }
   const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll);
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  if (key.name === "char" && key.char === "a") return addTask(state, "");
   const row = selectedPlanRow(state);
   if (!row) return step(state);
   const task = row.task;
   if (key.name === "enter" || key.name === "right") {
     const hasSubtasks = (task.subtasks?.length ?? 0) > 0;
     if (hasSubtasks && state.expandedTaskId !== task.id) {
-      return step({ ...state, expandedTaskId: task.id, taskEditor: null, planScroll: null });
+      return step(settlePlan({ ...state, expandedTaskId: task.id, taskEditor: null }));
     }
     const text = task.prompt ?? task.description ?? task.title;
-    return step({
+    return step(settlePlan({
       ...state,
       expandedTaskId: task.id,
       taskEditor: { ...emptyEditor(), text, cursor: text.length }
-    });
+    }));
   }
   if (!state.sessionId || key.name !== "char") return step(state);
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
@@ -4557,10 +5293,12 @@ function handlePlanKey(state, key) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
   if (key.char === "d") return confirmRemoveTask(state, task);
-  if (key.char === "a") return addTask(state, "");
   if (key.char === "t") {
     return step(state, [{ type: "openTaskTerminal", sessionId: state.sessionId, taskId: task.id }]);
   }
+  if (key.char === "x" && task.isolation?.state === "conflict") {
+    return step(state, [{ type: "resolveConflict", sessionId: state.sessionId, taskId: task.id }]);
+  }
   if (key.char === "R") return openTaskRunnerPicker(state, task);
   if (key.char === "o") return openTaskModelPicker(state, task);
   if (key.char === "e") return openTaskEffortPicker(state, task);
@@ -4570,13 +5308,13 @@ function handlePlanKey(state, key) {
 }
 function handleTaskEditKey(state, task, editor, key) {
   if (key.name === "enter") return commitTaskEdit(state, task, editor);
-  if (key.name === "escape") return step({ ...state, expandedTaskId: null, taskEditor: null });
+  if (key.name === "escape") return step(settlePlan({ ...state, expandedTaskId: null, taskEditor: null }));
   const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll);
-  return step({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) });
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  return step(settlePlan({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) }));
 }
 function commitTaskEdit(state, task, editor) {
-  const collapsed = { ...state, expandedTaskId: null, taskEditor: null };
+  const collapsed = settlePlan({ ...state, expandedTaskId: null, taskEditor: null });
   const prompt = editor.text.trim();
   const original = task.prompt ?? task.description ?? task.title;
   if (!prompt || prompt === original || !state.sessionId) return step(collapsed);
@@ -4618,26 +5356,45 @@ function handleApprovalKey(state, overlay, key) {
 function handleOverlayKey(state, overlay, key) {
   if (overlay.kind === "help") return handleHelpKey(state, overlay.scroll ?? 0, key);
   if (key.name === "wheelignored") return step(state);
+  if (overlay.kind === "handoff") return handleHandoffKey(state, overlay, key, bodyRows(state));
   if (isWheel(key) && overlay.kind !== "picker") return scrollPointed(state, key);
   if (overlay.kind === "approval") return handleApprovalKey(state, overlay, key);
   if (overlay.kind === "confirm") return handleConfirmKey(state, overlay, key);
+  if (key.name === "escape" && overlay.kind === "picker" && overlay.picker.action.kind === "isolation-blocked") {
+    return chooseBlocked(state, "cancel");
+  }
   if (key.name === "escape") return step({ ...state, overlay: null });
   if (overlay.kind === "prompt") return handlePromptKey(state, overlay, key);
   return handlePickerKey(state, overlay.picker, key);
 }
 function handleConfirmKey(state, overlay, key) {
   if (key.name === "escape") return step({ ...state, overlay: null });
-  if (key.name !== "enter") return step(state);
+  const { choice } = overlay;
+  if (!choice) return key.name === "enter" ? runConfirm(state, overlay) : step(state);
+  if (key.name === "up" || key.name === "down") {
+    const index = clamp(choice.index + (key.name === "down" ? 1 : -1), choice.options.length - 1);
+    return step({ ...state, overlay: { ...overlay, choice: { ...choice, index } } });
+  }
+  const chosen = key.name === "enter" ? choice.index : key.name === "char" ? Number(key.char) - 1 : -1;
+  const option = choice.options[chosen];
+  if (!option) return step(state);
+  return option.confirms ? runConfirm(state, overlay) : step({ ...state, overlay: null });
+}
+function runConfirm(state, overlay) {
   const closed = { ...state, overlay: null };
   if (overlay.action.kind === "new-session") return newSession(closed);
   if (overlay.action.kind === "remove-task") {
     if (!state.sessionId) return step(closed);
     return step(closed, [{ type: "removeTask", sessionId: state.sessionId, taskId: overlay.action.taskId }]);
   }
+  if (overlay.action.kind === "merge-run" || overlay.action.kind === "discard-run") {
+    return confirmedHandoff(state, overlay.action.kind);
+  }
   if (overlay.action.kind === "init-workspace") {
     return step({ ...closed, status: "planning" }, [{ type: "startConversation", goal: overlay.action.goal, allowInit: true }]);
   }
-  return step(closed);
+  const { index } = overlay.action;
+  return withIdlePlanner(closed, (sessionId) => step(closed, [{ type: "rewindConversation", sessionId, index }]));
 }
 function handleHelpKey(state, scroll, key) {
   const page = pageNotch(bodyRows(state));
@@ -4661,7 +5418,7 @@ function handlePromptKey(state, overlay, key) {
     if (overlay.action.kind === "api-key") {
       return step(closed, [{ type: "setApiKey", provider: overlay.action.provider, key: value2 }]);
     }
-    if (!state.sessionId) return fail2(closed, "No active plan to add a task to.");
+    if (!state.sessionId) return fail3(closed, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
     return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
   }
   const value = editText(overlay.value, key);
@@ -4694,6 +5451,7 @@ function handlePickerKey(state, picker2, key) {
 }
 function choose(state, picker2, item) {
   const closed = { ...state, overlay: null };
+  if (picker2.action.kind === "isolation-blocked") return chooseBlocked(state, item?.id ?? "cancel");
   if (picker2.action.kind === "set-allowlist") {
     return step(closed, [{ type: "setAllowlist", runner: picker2.action.runner, modelIds: picker2.chosen }]);
   }
@@ -4732,6 +5490,8 @@ function choose(state, picker2, item) {
       return step(closed, [{ type: "setPlannerEffort", effort: item.id === DEFAULT_EFFORT ? "" : item.id }]);
     case "load-session":
       return step(closed, [{ type: "loadSession", sessionId: item.id }]);
+    case "rewind":
+      return pickRewindTarget(state, Number(item.id));
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
@@ -4801,7 +5561,7 @@ function submit(state) {
 }
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) {
-    return fail2(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
+    return fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
   }
   if (SKILL_IDS.includes(name)) {
     return toggleSkill(state, name, args[0]);
@@ -4812,7 +5572,7 @@ function runCommand(state, { name, args }) {
     case "quit":
       return step({ ...state, exiting: true }, [{ type: "exit" }]);
     case "refresh":
-      return step(state, [{ type: "refresh" }]);
+      return step(state, [{ type: "refresh", announce: true }]);
     case "run":
       return withSession(state, (sessionId) => step(state, [{ type: "execute", sessionId }]));
     case "approve":
@@ -4848,14 +5608,25 @@ function runCommand(state, { name, args }) {
         { ...state, overlay: { kind: "picker", picker: picker("Sessions", [], { kind: "load-session" }) } },
         [{ type: "loadSessions" }]
       );
+    case "handoff":
+      return handoffCommand(state, args[0]);
+    case "fork":
+      return withIdlePlanner(state, (sessionId) => step(state, [{ type: "forkConversation", sessionId }]));
+    case "rewind":
+      return rewind(state, args[0]);
+    case "compact":
+      return withIdlePlanner(
+        state,
+        (sessionId) => step({ ...state, status: "planning", busyLabel: "Condensing the conversation\u2026" }, [{ type: "compactConversation", sessionId }])
+      );
     case "new":
       return requestNewSession(state);
     case "save":
       return withSession(state, (sessionId) => step(state, [{ type: "saveSession", sessionId }]));
     case "load":
-      return args[0] ? step(state, [{ type: "loadSession", sessionId: args[0] }]) : fail2(state, "Usage: /load <session-id> \u2014 or run /sessions to pick one.");
+      return args[0] ? step(state, [{ type: "loadSession", sessionId: args[0] }]) : fail3(state, "Usage: /load <session-id> \u2014 or run /sessions to pick one.");
     case "delete":
-      return args[0] ? step(state, [{ type: "deleteSession", sessionId: args[0] }]) : fail2(state, "Usage: /delete <session-id>");
+      return args[0] ? step(state, [{ type: "deleteSession", sessionId: args[0] }]) : fail3(state, "Usage: /delete <session-id>");
     case "add-task":
       return addTask(state, args.join(" "));
     case "remove-task":
@@ -4896,17 +5667,57 @@ function runCommand(state, { name, args }) {
         (sessionId, taskId) => step(state, [taskActionEffect(state, sessionId, taskId, name)])
       );
   }
-  return fail2(state, `/${name} is not wired up yet.`);
+  return fail3(state, `/${name} is not wired up yet.`);
 }
 function picker(title, items, action, extra = {}) {
   return { title, items, filter: "", index: 0, multi: false, chosen: [], action, ...extra };
 }
 function withSession(state, run) {
   if (!state.sessionId) {
-    return fail2(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
+    return fail3(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
   }
   return run(state.sessionId);
 }
+function withIdlePlanner(state, run) {
+  return withSession(
+    state,
+    (sessionId) => state.status === "planning" || state.status === "researching" ? fail3(state, "The planner is still answering \u2014 wait for its reply, or /stop it first.") : run(sessionId)
+  );
+}
+function rewind(state, arg) {
+  return withIdlePlanner(state, (sessionId) => {
+    if (arg === void 0) {
+      return step(
+        { ...state, rewindTargets: null, overlay: { kind: "picker", picker: picker("Rewind to before\u2026", [], { kind: "rewind" }, { hint: "Rewinding forks the conversation from just before the chosen message; the original is kept and the tasks ride along." }) } },
+        [{ type: "loadRewindTargets", sessionId }]
+      );
+    }
+    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
+    return step(state, [{ type: "loadRewindTargets", sessionId, pick: Number(arg) }]);
+  });
+}
+var REWIND_OPTIONS = [
+  { label: "Restore Conversation", confirms: true },
+  { label: "Never mind", confirms: false }
+];
+function pickRewindTarget(state, index) {
+  return withIdlePlanner({ ...state, overlay: null }, () => {
+    const target = state.rewindTargets?.find((t) => t.index === index);
+    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to \u2014 /rewind alone lists them.`);
+    return step({
+      ...state,
+      overlay: {
+        kind: "confirm",
+        title: "Rewind",
+        message: "Confirm you want to restore to the point before you sent this message:",
+        quote: target.content,
+        note: "The conversation will be forked.\nThe code will be unchanged.",
+        action: { kind: "rewind", index },
+        choice: { options: REWIND_OPTIONS, index: 0 }
+      }
+    });
+  });
+}
 function resolveToggle(arg, current) {
   const value = arg?.toLowerCase();
   if (value === "on") return true;
@@ -4916,7 +5727,7 @@ function resolveToggle(arg, current) {
 }
 function toggleSkill(state, skill, arg) {
   const enabled = resolveToggle(arg, state.skills[skill]);
-  if (enabled === null) return fail2(state, `Usage: /${skill} [on|off]`);
+  if (enabled === null) return fail3(state, `Usage: /${skill} [on|off]`);
   return step(state, [{ type: "command", name: skill, action: enabled ? "on" : "off" }]);
 }
 function requestNewSession(state) {
@@ -4936,6 +5747,7 @@ function newSession(state) {
   const closeEffects = state.sessionId ? [{ type: "closeSession", sessionId: state.sessionId }] : [];
   return step({
     ...state,
+    handoff: null,
     sessionId: null,
     goal: "",
     tasks: [],
@@ -4945,6 +5757,7 @@ function newSession(state) {
     expandedTaskId: null,
     taskEditor: null,
     scroll: 0,
+    planScroll: null,
     status: "idle",
     busyLabel: "",
     thinkingLine: "",
@@ -4956,14 +5769,14 @@ function newSession(state) {
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core16.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
-      return fail2(state, `${args[1]} was not discovered for ${runner}.`);
+      return fail3(state, `${args[1]} was not discovered for ${runner}.`);
     }
     return step(state, [{ type: "setModel", modelId: args[1] }]);
   }
-  if (args.length > 0 && args[0] !== "set") return fail2(state, "Usage: /model [set <model-id>]");
+  if (args.length > 0 && args[0] !== "set") return fail3(state, "Usage: /model [set <model-id>]");
   const items = pickerItemsFor(state, { kind: "set-model" });
   return step(
     {
@@ -4978,21 +5791,21 @@ function setModel(state, args) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core16.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core16.runnerForProvider)(id);
+  const agents = import_core18.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core18.runnerForProvider)(id);
     const ready = installed.has(runner);
     return {
       id,
-      label: import_core16.ALL_PROVIDERS[id].label,
+      label: import_core18.ALL_PROVIDERS[id].label,
       detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
       selected: state.plannerProvider === id,
       disabled: !ready
     };
   });
-  const vendors = import_core16.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
+  const vendors = import_core18.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
     id,
-    label: import_core16.ALL_PROVIDERS[id].label,
-    detail: import_core16.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core18.ALL_PROVIDERS[id].label,
+    detail: import_core18.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.plannerProvider === id
   }));
   return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
@@ -5001,7 +5814,7 @@ function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
     if (!KNOWN_PROVIDERS2.includes(id)) {
-      return fail2(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
+      return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
   }
@@ -5022,7 +5835,7 @@ function setPlannerEffort(state, args) {
     const match = items.find((i) => !i.disabled && (i.id === wanted || wanted === "default" && i.id === DEFAULT_EFFORT));
     if (!match) {
       const available = items.filter((i) => !i.disabled && i.id !== DEFAULT_EFFORT).map((i) => i.id);
-      return fail2(state, available.length > 0 ? `Unknown effort: ${args[0]}. Available: ${available.join(", ")}, default.` : items[0]?.label ?? "No effort levels available.");
+      return fail3(state, available.length > 0 ? `Unknown effort: ${args[0]}. Available: ${available.join(", ")}, default.` : items[0]?.label ?? "No effort levels available.");
     }
     return step(state, [{ type: "setPlannerEffort", effort: match.id === DEFAULT_EFFORT ? "" : match.id }]);
   }
@@ -5040,7 +5853,7 @@ function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
     if (!KNOWN_PROVIDERS2.includes(provider)) {
-      return fail2(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
+      return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
       return step({
@@ -5050,16 +5863,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core16.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core18.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core16.ALL_PROVIDERS[id].label,
-    detail: import_core16.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core18.ALL_PROVIDERS[id].label,
+    detail: import_core18.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core16.ALL_PROVIDERS[provider];
+  const meta = import_core18.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -5071,23 +5884,23 @@ function keyPrompt(provider) {
 function allowlist(state, args) {
   const [sub, runner, ...rest] = args;
   if (sub === "set") {
-    if (!runner || rest.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
+    if (!runner || rest.length === 0) return fail3(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
     if (state.runners.length > 0 && !state.runners.some((r) => r.id === runner)) {
-      return fail2(state, `Unknown runner "${runner}".`);
+      return fail3(state, `Unknown runner "${runner}".`);
     }
     const modelIds = rest.join(" ").split(",").map((s) => s.trim()).filter(Boolean);
-    if (modelIds.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
+    if (modelIds.length === 0) return fail3(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
     const known = modelsForRunner(state.models, runner);
     if (state.models.length > 0 && known.length > 0) {
       const stray = modelIds.filter((id) => !known.some((m) => m.id === id));
       if (stray.length > 0) {
-        return fail2(state, `Not discovered for ${runner}: ${stray.join(", ")}.`);
+        return fail3(state, `Not discovered for ${runner}: ${stray.join(", ")}.`);
       }
     }
     return step(state, [{ type: "setAllowlist", runner, modelIds }]);
   }
   if (sub === "clear") {
-    if (!runner) return fail2(state, "Usage: /allowlist clear <runner>");
+    if (!runner) return fail3(state, "Usage: /allowlist clear <runner>");
     return step(state, [{ type: "setAllowlist", runner, modelIds: [] }]);
   }
   if (sub === "show" || sub === void 0) {
@@ -5109,7 +5922,7 @@ function allowlist(state, args) {
       [{ type: "loadModels" }]
     );
   }
-  return fail2(state, "Usage: /allowlist [set <runner> <ids> | clear <runner>]");
+  return fail3(state, "Usage: /allowlist [set <runner> <ids> | clear <runner>]");
 }
 function describeAllowlist(ids) {
   if (!ids || ids.length === 0) return "no restriction";
@@ -5120,7 +5933,7 @@ function runners(state, args) {
   if (runner) {
     const known = state.runners.find((r) => r.id === runner);
     const enabled = resolveToggle(arg, known?.enabled ?? true);
-    if (enabled === null) return fail2(state, "Usage: /runners [<runner-id> on|off]");
+    if (enabled === null) return fail3(state, "Usage: /runners [<runner-id> on|off]");
     return step(state, [{ type: "setRunnerEnabled", runner, enabled }]);
   }
   const action = { kind: "set-runners" };
@@ -5136,12 +5949,12 @@ function runners(state, args) {
 }
 function setAutonomous(state, arg) {
   const enabled = resolveToggle(arg, state.autonomous);
-  if (enabled === null) return fail2(state, "Usage: /auto [on|off]");
+  if (enabled === null) return fail3(state, "Usage: /auto [on|off]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
 function setMouseCapture(state, arg) {
   const enabled = resolveToggle(arg, state.mouseCapture);
-  if (enabled === null) return fail2(state, "Usage: /mouse [on|off]");
+  if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
   const noted = say(
     // A selection made under capture is meaningless once the terminal owns the
     // mouse again, and its highlight would sit on screen with nothing able to
@@ -5153,7 +5966,7 @@ function setMouseCapture(state, arg) {
   return step(noted, [{ type: "setMouseCapture", enabled }]);
 }
 function openTaskRunnerPicker(state, task) {
-  if (task.type !== "ai") return fail2(state, "Manual tasks do not run on an executor, so they have no runner.");
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not run on an executor, so they have no runner.");
   const action = { kind: "set-task-runner", taskId: task.id };
   return step(
     {
@@ -5183,7 +5996,7 @@ function confirmRemoveTask(state, task) {
 function openTaskDepsPicker(state, task) {
   const action = { kind: "set-task-deps", taskId: task.id };
   const items = pickerItemsFor(state, action);
-  if (items.length === 0) return fail2(state, `Nothing runs before #${task.order}, so it has no possible dependencies.`);
+  if (items.length === 0) return fail3(state, `Nothing runs before #${task.order}, so it has no possible dependencies.`);
   return step({
     ...state,
     overlay: {
@@ -5197,10 +6010,10 @@ function openTaskDepsPicker(state, task) {
   });
 }
 function openTaskModePicker(state, task) {
-  if (task.type !== "ai") return fail2(state, "Manual tasks do not have an executor mode.");
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor mode.");
   const modes = modesForTask(state.modesByRunner, task);
   if (modes.length === 0) {
-    return fail2(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
+    return fail3(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
   }
   const action = { kind: "set-task-mode", taskId: task.id };
   return step(
@@ -5216,7 +6029,7 @@ function openTaskModePicker(state, task) {
   );
 }
 function openTaskModelPicker(state, task) {
-  if (task.type !== "ai") return fail2(state, "Manual tasks do not have an executor model.");
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor model.");
   const action = { kind: "set-task-model", taskId: task.id };
   return step(
     {
@@ -5232,8 +6045,8 @@ function openTaskModelPicker(state, task) {
   );
 }
 function openTaskEffortPicker(state, task) {
-  if (task.type !== "ai") return fail2(state, "Manual tasks do not have a thinking effort.");
-  if (!task.assignedModel) return fail2(state, "Choose a model for this task before setting its thinking effort.");
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have a thinking effort.");
+  if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
   const action = { kind: "set-task-effort", taskId: task.id };
   return step(
     {
@@ -5299,7 +6112,7 @@ function taskModelCommand(state, args) {
       variants: []
     };
     if (!runnerAccepts(task, model)) {
-      return fail2(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
+      return fail3(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
     }
     return assignTaskModel(state, sessionId, task, model);
   });
@@ -5309,7 +6122,7 @@ function taskRunnerCommand(state, args) {
     const task = findTask(state.tasks, taskId);
     if (!args[1]) return openTaskRunnerPicker(state, task);
     const runner = state.runners.find((candidate) => candidate.id === args[1]);
-    if (!runner) return fail2(state, `Unknown runner "${args[1]}".`);
+    if (!runner) return fail3(state, `Unknown runner "${args[1]}".`);
     return assignTaskRunner(state, sessionId, task, runner.id, runner.name);
   });
 }
@@ -5318,7 +6131,7 @@ function taskModeCommand(state, args) {
     const task = findTask(state.tasks, taskId);
     if (!args[1]) return openTaskModePicker(state, task);
     const mode = modesForTask(state.modesByRunner, task).find((candidate) => candidate.id === args[1]);
-    if (!mode) return fail2(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
+    if (!mode) return fail3(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
     return assignTaskMode(state, sessionId, task, mode.id, mode.label);
   });
 }
@@ -5326,32 +6139,36 @@ function taskEffortCommand(state, args) {
   return taskCommand(state, args[0], (sessionId, taskId) => {
     const task = findTask(state.tasks, taskId);
     if (!args[1]) return openTaskEffortPicker(state, task);
-    if (!task.assignedModel) return fail2(state, "Choose a model for this task before setting its thinking effort.");
+    if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
     const effort = args[1].toLowerCase();
     const value = effort === "default" || effort === "none" ? void 0 : args[1];
     const supported = effortsForTask(state.models, task);
     if (value && supported.length > 0 && !supported.some((variant) => variant.id === value)) {
-      return fail2(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
+      return fail3(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
     }
     return assignTaskEffort(state, sessionId, task, value);
   });
 }
+function clampSelection(index, rows) {
+  return Math.max(0, Math.min(index, rows - 1));
+}
 function addTask(state, title) {
-  return withSession(state, (sessionId) => {
-    if (!title) {
-      return step({
-        ...state,
-        overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
-      });
-    }
-    return step(state, [{ type: "addTask", sessionId, title }]);
-  });
+  if (!state.sessionId) {
+    return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
+  }
+  if (!title) {
+    return step({
+      ...state,
+      overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
+    });
+  }
+  return step(state, [{ type: "addTask", sessionId: state.sessionId, title }]);
 }
 function taskCommand(state, token, run) {
   return withSession(state, (sessionId) => {
-    if (!token) return fail2(state, "Which task? Pass a task id or its number in the plan.");
+    if (!token) return fail3(state, "Which task? Pass a task id or its number in the plan.");
     const taskId = resolveTaskId2(state, token);
-    if (!taskId) return fail2(state, `No task matching "${token}" in the current plan.`);
+    if (!taskId) return fail3(state, `No task matching "${token}" in the current plan.`);
     return run(sessionId, taskId);
   });
 }
@@ -5417,7 +6234,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core17 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var ConversationQueue = class {
   tail = Promise.resolve();
@@ -5588,7 +6405,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core17.ALL_PROVIDERS[effect.provider];
+      const meta = import_core19.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
@@ -5600,7 +6417,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core17.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core19.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -5612,7 +6429,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core17.ALL_PROVIDERS[effect.provider];
+      const meta = import_core19.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -5668,6 +6485,79 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Loaded "${goal || effect.sessionId}".` });
       return;
     }
+    // The daemon has already adopted the fork, so switching is only the TUI
+    // catching up — the original session is not closed: it may be running.
+    case "forkConversation": {
+      const fork = await api.forkConversation(effect.sessionId);
+      dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
+      dispatch({ type: "chatRestored", history: fork.plan.conversationHistory ?? [], sessionId: fork.sessionId });
+      dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
+      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} \u2014 you are in the fork now. /sessions to go back.` });
+      return;
+    }
+    case "loadRewindTargets":
+      dispatch({
+        type: "rewindTargetsLoaded",
+        targets: await api.rewindTargets(effect.sessionId),
+        sessionId: effect.sessionId,
+        ...effect.pick !== void 0 && { pick: effect.pick }
+      });
+      return;
+    // A rewind is a fork from an earlier point, so the TUI follows it the way
+    // it follows `/fork`; the original keeps its whole conversation. The
+    // rewound message comes back into the input, to edit and send again.
+    case "rewindConversation": {
+      const fork = await api.rewindConversation(effect.sessionId, effect.index);
+      dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
+      dispatch({ type: "chatRestored", history: fork.plan.conversationHistory ?? [], sessionId: fork.sessionId });
+      dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
+      dispatch({ type: "inputPrefilled", text: fork.rewoundMessage, sessionId: fork.sessionId });
+      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} from before that message \u2014 the original is kept (/sessions to go back). The message is ready to edit and resend.` });
+      return;
+    }
+    // The redrawn transcript opens with the summary entry, which is what the
+    // user gets to read — no separate notice to repeat it.
+    case "compactConversation": {
+      const { plan } = await api.compactConversation(effect.sessionId);
+      dispatch({ type: "chatRestored", history: plan.conversationHistory ?? [], sessionId: effect.sessionId });
+      dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
+      return;
+    }
+    case "isolationReviewDiff":
+      dispatch({ type: "handoffDiff", diff: await api.reviewRunDiff(effect.sessionId), sessionId: effect.sessionId });
+      return;
+    // A conflict or a refusal is an answer, not a fault: either way the user's
+    // tree is exactly as it was, and the words say what to do next. A full
+    // merge leaves nothing to hand over — the daemon has cleared the run up.
+    case "isolationMerge": {
+      const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true, effect.repaired ?? []);
+      if (ok) dispatch({ type: "runCleared", sessionId: effect.sessionId });
+      dispatch({ type: ok ? "notice" : "failed", message });
+      return;
+    }
+    case "isolationDiscard":
+      await api.discardRun(effect.sessionId);
+      dispatch({ type: "runCleared", sessionId: effect.sessionId });
+      dispatch({ type: "notice", message: `Discarded the run and ${effect.branch}.` });
+      return;
+    case "isolationCleanup":
+      await api.cleanupRun(effect.sessionId);
+      await refreshPlan(deps, effect.sessionId);
+      dispatch({ type: "notice", message: `Removed the run's worktrees and task branches; ${effect.branch} is kept.` });
+      return;
+    // Spawns runners again, so it needs the stream a run needs — the blocked
+    // one closed itself when nothing started.
+    case "isolationContinue": {
+      const { sessionId } = effect;
+      await withExecutionStream(deps, sessionId, () => effect.mode === "stash" ? api.continueWithStash(sessionId) : api.continueWithoutIsolation(sessionId));
+      await refreshPlan(deps, sessionId);
+      return;
+    }
+    case "resolveConflict":
+      await api.resolveConflictAsTask(effect.sessionId, effect.taskId);
+      await refreshPlan(deps, effect.sessionId);
+      dispatch({ type: "notice", message: "Added a task that merges the conflicted branch by hand. Run it with E (run plan); when it lands, the conflicted task lands through it." });
+      return;
     case "deleteSession":
       await api.deleteSession(effect.sessionId, workspace);
       await loadSessions(deps);
@@ -5684,7 +6574,7 @@ async function perform(effect, deps) {
       return;
     case "refresh":
       await Promise.all([loadRunners(deps), loadSettings(deps), loadModels(deps)]);
-      dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
+      if (effect.announce) dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
       return;
     case "exit":
       deps.exit();
@@ -5700,7 +6590,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core17.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core19.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -5831,7 +6721,7 @@ function onExecutionEvent(dispatch, event, sessionId) {
     case "status_update": {
       const updates = {};
       for (const task of event.tasks ?? []) {
-        updates[String(task.id)] = { status: String(task.status), idleSince: task.idleSince ?? null };
+        updates[String(task.id)] = { status: String(task.status), idleSince: task.idleSince ?? null, isolation: task.isolation };
       }
       dispatch({ type: "tasksStatus", updates, sessionId });
       return;
@@ -5842,7 +6732,7 @@ function onExecutionEvent(dispatch, event, sessionId) {
     // The extension shows these in its checkpoint panel; here they are
     // transcript lines, which is the TUI's equivalent surface.
     case "checkpoint":
-      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core17.truncateCheckpointSummary)(event.summary)}` });
+      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core19.truncateCheckpointSummary)(event.summary)}` });
       return;
     case "approval_decided":
       dispatch({ type: "notice", message: describeApprovalDecision2(event) });
@@ -5873,10 +6763,41 @@ function onExecutionEvent(dispatch, event, sessionId) {
     case "execution_stopped":
       dispatch({ type: "executionComplete", stopped: true, sessionId });
       return;
-    // task_output / plan_token / plan_thinking are raw runner chatter; the
-    // status line and the plan pane already say everything the user needs.
-    default:
+    // Nothing started; the user chooses how to go on.
+    case "isolation_blocked":
+      dispatch({ type: "isolationBlocked", message: event.message, ...event.repos ? { repos: event.repos } : {}, sessionId });
+      return;
+    // How the run isolates. The daemon has no toast channel, so this is the only place the user hears it.
+    case "notice":
+      dispatch({ type: "notice", message: event.message });
+      return;
+    case "isolation_handoff":
+      dispatch({ type: "isolationHandoff", handoff: { repos: event.repos, landed: event.landed }, sessionId });
       return;
+    // Raw runner chatter, and the planner's own turn: the status line and the
+    // plan pane already say everything the user needs during a run. Listed
+    // rather than defaulted, so a new SessionMessage variant fails to compile
+    // here until someone decides what a run's watcher does with it.
+    case "task_updated":
+    case "task_output":
+    case "plan_thinking":
+    case "planner_liveness":
+    case "research_step":
+    case "plan_token":
+    case "research_step_done":
+    case "approval_request":
+    case "approval_settled":
+      return;
+    // Its asker already has the words, from the merge request itself; a
+    // viewer that did not ask still has to drop a run that is gone.
+    case "isolation_merge":
+      if (event.result.outcome === "merged") dispatch({ type: "runCleared", sessionId });
+      return;
+    default: {
+      const unhandled = event;
+      void unhandled;
+      return;
+    }
   }
 }
 async function refreshPlan(deps, sessionId) {
@@ -6195,7 +7116,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core18.assertWorkspaceExists)(workspace);
+    (0, import_core20.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -6204,7 +7125,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core18.createSkillsService)(workspace).listSkills());
+  registerSkillCommands((0, import_core20.createSkillsService)(workspace).listSkills());
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
@@ -6223,7 +7144,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       conversationQueue,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core18.mintSessionId)(),
+      newSessionId: () => (0, import_core20.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -6311,6 +7232,10 @@ var COMMANDS = {
   "task-deps": handleTaskDeps,
   terminal: handleTerminal,
   "sessions": handleSessions,
+  fork: handleFork,
+  compact: handleCompact,
+  rewind: handleRewind,
+  handoff: handleHandoff,
   tui: handleTui
 };
 
@@ -6329,7 +7254,7 @@ function cliVersion() {
 
 // src/main.ts
 async function main() {
-  (0, import_core19.migrateOldConfigDir)();
+  (0, import_core21.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   const command = argv[0] ?? (process.stdin.isTTY ? "tui" : "--help");