@ordewell/cli 0.4.23 → 0.5.0

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_core20 = 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>]           Rewind the conversation to 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,83 @@ 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;
+  }
+  /** Cut the conversation back to just before the user message at `index` (a transcript position). */
+  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 res.data.plan;
+  }
+  /**
+   * 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 +756,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 +1256,96 @@ ${lastPlannerMessage(plan)}
   }
 }
 
+// src/isolation.ts
+var import_core7 = require("@ordewell/core");
+var STATE_OF = {
+  active: "active",
+  merged: "integrated",
+  conflict: "conflict",
+  // 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);
+    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: "." } : {}
+    };
+    if (state === "integrated") {
+      landed.push({ taskId, order: Number(record.order ?? 0), title: String(record.title ?? taskId), changed });
+    }
+  }
+  landed.sort((a, b) => a.order - b.order);
+  const entry = ({ taskId, order, title }) => ({ taskId, order, title });
+  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 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) {
+  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);
+  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 +1363,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 +1467,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 +1493,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 +1644,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 +1701,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 +1738,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 +1772,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 +1782,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 +1911,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 +1949,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) {
@@ -2132,15 +2336,477 @@ async function handleSessions(subArgs, injectedApi) {
       console.error(`Failed to delete session: ${err.message}`);
       process.exit(1);
     }
-    return;
+    return;
+  }
+  console.error(`Unknown sessions action: "${action}"`);
+  console.error(USAGE3);
+  process.exit(1);
+}
+
+// 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);
+  let plan;
+  try {
+    ({ plan } = await api.adoptSession(sessionId, workspace));
+  } catch (err) {
+    fail(`Failed to load session: ${err.message}`);
+  }
+  return { api, sessionId, workspace, plan };
+}
+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 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(`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 } = 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>` discards message <n> and everything after it. The tasks stay as they are.");
+    return;
+  }
+  try {
+    await api.rewindConversation(sessionId, Number(arg));
+  } catch (err) {
+    fail(`Failed to rewind: ${err.message}`);
+  }
+  console.log(`Rewound ${sessionId} to just before message ${arg}. The tasks are unchanged; the next message continues from there.`);
+}
+
+// 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, "");
+}
+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 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.`,
+            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.`,
+            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 effect = kind === "merge-run" ? { type: "isolationMerge", sessionId, branch: handoffBranch(handoff), ...isRepoGroup(handoff) ? { group: true } : {} } : { 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");
+}
+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.` : `Merge ${branch} into the branch you have checked out?`);
+      const { ok, message } = mergeOutcome(await attempt(() => api.mergeRun(sessionId)), branch, group);
+      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;
   }
-  console.error(`Unknown sessions action: "${action}"`);
-  console.error(USAGE3);
-  process.exit(1);
 }
 
 // src/commands/planner.ts
-var import_core12 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
 function describePlannerSwitch(settings, provider) {
@@ -2159,7 +2825,7 @@ function rememberedModelFor(settings, provider) {
 }
 
 // src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core12.ALL_PROVIDERS);
+var KNOWN_PROVIDERS = Object.keys(import_core13.ALL_PROVIDERS);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -2174,13 +2840,13 @@ async function handlePlanner(subArgs, injectedApi) {
   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 meta = import_core13.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}.`
+    (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_core12.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  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>\`.`);
   }
 }
@@ -2198,15 +2864,15 @@ 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);
+  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_core12.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    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_core12.PROVIDER_PRIORITY) {
+  for (const id of import_core13.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core12.ALL_PROVIDERS[id];
+    const meta = import_core13.ALL_PROVIDERS[id];
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -2223,7 +2889,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   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);
+  const runner = (0, import_core13.runnerForProvider)(provider);
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -2263,29 +2929,29 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // 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 +2962,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 +2973,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 +2982,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 +3018,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 +3052,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}"]);
@@ -2688,149 +3355,7 @@ Dependencies \xB7 #${task.order} ${task.title}
 }
 
 // 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 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")
-};
+var import_core19 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -2968,6 +3493,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 +3523,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: "Rewind the conversation to just before one of your messages (tasks are 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 +3797,7 @@ function initialState(overrides = {}) {
     skills: noSkills(),
     runners: [],
     sessions: [],
+    rewindTargets: null,
     models: [],
     modesByRunner: {},
     orchestratorModels: [],
@@ -3281,6 +3811,7 @@ function initialState(overrides = {}) {
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
+    handoff: null,
     overlay: null,
     pendingApprovals: [],
     toast: "",
@@ -3293,7 +3824,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 +3832,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 +3857,7 @@ function footerHints(state) {
       "a add",
       "d remove",
       "t terminal",
+      ...resolveHint,
       "pgup/pgdn scroll",
       "tab chat"
     ];
@@ -3429,9 +3963,9 @@ function chatScrollMax(state) {
 }
 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 };
 }
@@ -3578,7 +4112,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 +4136,21 @@ 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}` : "";
+    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where} \u2014 its work is kept on its own branch`, 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));
     }
@@ -3934,8 +4480,51 @@ 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) => `  ${style.green("\u2713")} #${task.order} ${task.title}`);
+  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 = [];
@@ -3974,26 +4563,16 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core16 = require("@ordewell/core");
+var import_core17 = 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_core17.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 +4580,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 +4606,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,11 +4640,13 @@ 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: "",
@@ -4133,9 +4718,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 +4734,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 "handoffDiscarded": {
+      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 +4785,23 @@ 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);
+      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
+      });
     case "runnersLoaded":
       return step(refillPicker({
         ...state,
@@ -4286,11 +4906,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_core17.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_core17.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 +4924,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_core17.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -4331,6 +4951,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,
@@ -4561,6 +5188,9 @@ function handlePlanKey(state, key) {
   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);
@@ -4618,9 +5248,13 @@ 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);
@@ -4634,6 +5268,9 @@ function handleConfirmKey(state, overlay, key) {
     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 }]);
   }
@@ -4661,7 +5298,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.");
     return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
   }
   const value = editText(overlay.value, key);
@@ -4694,6 +5331,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 +5370,11 @@ 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 withSession(
+        closed,
+        (sessionId) => step(closed, [{ type: "rewindConversation", sessionId, index: Number(item.id) }])
+      );
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
@@ -4801,7 +5444,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]);
@@ -4848,14 +5491,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 +5550,35 @@ 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: "The chosen message and everything after it are discarded; the tasks stay as they are." }) } },
+        [{ type: "loadRewindTargets", sessionId }]
+      );
+    }
+    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
+    return step(state, [{ type: "rewindConversation", sessionId, index: Number(arg) }]);
+  });
+}
 function resolveToggle(arg, current) {
   const value = arg?.toLowerCase();
   if (value === "on") return true;
@@ -4916,7 +5588,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 +5608,7 @@ function newSession(state) {
   const closeEffects = state.sessionId ? [{ type: "closeSession", sessionId: state.sessionId }] : [];
   return step({
     ...state,
+    handoff: null,
     sessionId: null,
     goal: "",
     tasks: [],
@@ -4956,14 +5629,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_core17.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 +5651,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_core17.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core17.runnerForProvider)(id);
     const ready = installed.has(runner);
     return {
       id,
-      label: import_core16.ALL_PROVIDERS[id].label,
+      label: import_core17.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_core17.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_core17.ALL_PROVIDERS[id].label,
+    detail: import_core17.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 +5674,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 +5695,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 +5713,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 +5723,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_core17.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core16.ALL_PROVIDERS[id].label,
-    detail: import_core16.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core17.ALL_PROVIDERS[id].label,
+    detail: import_core17.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_core17.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -5071,23 +5744,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 +5782,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 +5793,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 +5809,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 +5826,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 +5856,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 +5870,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 +5889,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 +5905,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 +5972,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 +5982,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 +5991,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,12 +5999,12 @@ 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);
   });
@@ -5349,9 +6022,9 @@ function addTask(state, 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 +6090,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core17 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var ConversationQueue = class {
   tail = Promise.resolve();
@@ -5588,7 +6261,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_core18.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 +6273,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_core18.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 +6285,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_core18.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 +6341,67 @@ 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 });
+      return;
+    case "rewindConversation": {
+      const plan = await api.rewindConversation(effect.sessionId, effect.index);
+      dispatch({ type: "chatRestored", history: plan.conversationHistory ?? [], sessionId: effect.sessionId });
+      dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
+      dispatch({ type: "notice", message: "Rewound the conversation. The tasks are unchanged; your next message continues from here." });
+      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.
+    case "isolationMerge": {
+      const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true);
+      dispatch({ type: ok ? "notice" : "failed", message });
+      return;
+    }
+    case "isolationDiscard":
+      await api.discardRun(effect.sessionId);
+      dispatch({ type: "handoffDiscarded", 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);
@@ -5700,7 +6434,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_core18.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -5831,7 +6565,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 +6576,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_core18.truncateCheckpointSummary)(event.summary)}` });
       return;
     case "approval_decided":
       dispatch({ type: "notice", message: describeApprovalDecision2(event) });
@@ -5873,10 +6607,39 @@ 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 result, from the merge request itself.
+    case "isolation_merge":
+      return;
+    default: {
+      const unhandled = event;
+      void unhandled;
+      return;
+    }
   }
 }
 async function refreshPlan(deps, sessionId) {
@@ -6195,7 +6958,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core18.assertWorkspaceExists)(workspace);
+    (0, import_core19.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -6204,7 +6967,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_core19.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 +6986,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_core19.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -6311,6 +7074,10 @@ var COMMANDS = {
   "task-deps": handleTaskDeps,
   terminal: handleTerminal,
   "sessions": handleSessions,
+  fork: handleFork,
+  compact: handleCompact,
+  rewind: handleRewind,
+  handoff: handleHandoff,
   tui: handleTui
 };
 
@@ -6329,7 +7096,7 @@ function cliVersion() {
 
 // src/main.ts
 async function main() {
-  (0, import_core19.migrateOldConfigDir)();
+  (0, import_core20.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   const command = argv[0] ?? (process.stdin.isTTY ? "tui" : "--help");