@ordewell/cli 0.5.0 → 0.5.1

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core20 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -94,7 +94,7 @@ Planning:
   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)
+  ordewell rewind [<n>]           Fork the conversation from before message <n> (no <n>: list them)
 
 Tasks (<id> is an order number or a task ID):
   ordewell add-task --title "..."  Add a task to the current plan
@@ -616,13 +616,17 @@ var ApiClient = class {
     }
     return res.data.targets;
   }
-  /** Cut the conversation back to just before the user message at `index` (a transcript position). */
+  /**
+   * Fork the conversation from just before the user message at `index` (a
+   * transcript position) into a session the daemon has already adopted. The
+   * original is left as it was; `rewoundMessage` is that message in full.
+   */
   async rewindConversation(sessionId, index) {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/rewind`, { index });
     if (res.status !== 200) {
       throw new Error(res.data?.error || "Rewind failed");
     }
-    return res.data.plan;
+    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan, rewoundMessage: res.data.rewoundMessage };
   }
   /**
    * Condense the conversation into a summary. One planner call, so it can take
@@ -1262,6 +1266,7 @@ var STATE_OF = {
   active: "active",
   merged: "integrated",
   conflict: "conflict",
+  repairing: "repairing",
   // A failed integration keeps its refs exactly as a failed verdict does; the
   // user sees one thing: work that did not land and can be looked at.
   kept: "kept",
@@ -1293,19 +1298,25 @@ function isolationOfPlan(plan) {
     const state = STATE_OF[String(record.status)];
     if (!state) continue;
     const changed = changedRepos(record, legacy, state);
+    const repairedFiles = Array.isArray(record.repairedFiles) && record.repairedFiles.length > 0 ? record.repairedFiles.map(String) : void 0;
     tasks[taskId] = {
       state,
       branch: String(record.branch ?? ""),
       worktree: String(record.workspace ?? record.worktree ?? ""),
       repos: changed,
-      ...typeof record.conflictRepo === "string" ? { conflictRepo: record.conflictRepo } : legacy && state === "conflict" ? { conflictRepo: "." } : {}
+      ...typeof record.conflictRepo === "string" ? { conflictRepo: record.conflictRepo } : legacy && state === "conflict" ? { conflictRepo: "." } : {},
+      ...Array.isArray(record.conflictFiles) && record.conflictFiles.length > 0 ? { conflictFiles: record.conflictFiles.map(String) } : {},
+      // No `repair` (attempt/limit): `conflictRepairAttempts` is server config, never
+      // sent in a persisted plan, so it cannot be reconstructed here. A live
+      // `tasksStatus` update fills it in once the stream catches up.
+      ...repairedFiles ? { repairedFiles } : {}
     };
     if (state === "integrated") {
-      landed.push({ taskId, order: Number(record.order ?? 0), title: String(record.title ?? taskId), changed });
+      landed.push({ taskId, order: Number(record.order ?? 0), title: String(record.title ?? taskId), changed, ...repairedFiles ? { repairedFiles } : {} });
     }
   }
   landed.sort((a, b) => a.order - b.order);
-  const entry = ({ taskId, order, title }) => ({ taskId, order, title });
+  const entry = ({ taskId, order, title, repairedFiles }) => ({ taskId, order, title, ...repairedFiles ? { repairedFiles } : {} });
   return {
     handoff: {
       repos: repos.map((repo) => ({ ...repo, landed: landed.filter((t) => t.changed.includes(repo.path)).map(entry) })),
@@ -1328,6 +1339,16 @@ function reposWithWork(handoff) {
   const withWork = handoff.repos.filter((r) => r.landed.length > 0);
   return (withWork.length > 0 ? withWork : handoff.repos).map((r) => r.path);
 }
+function repairedLanded(handoff) {
+  return handoff.landed.filter((t) => t.repairedFiles?.length);
+}
+function repairedNotice(handoff) {
+  const repaired = repairedLanded(handoff);
+  if (repaired.length === 0) return "";
+  const named = repaired.map((t) => `${t.title} (${(0, import_core7.capConflictFiles)(t.repairedFiles)})`);
+  const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
+  return ` ${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
+}
 function repoResultLines(handoff) {
   return handoff.repos.map(({ path, landed }) => {
     const n = landed.length;
@@ -1337,12 +1358,12 @@ function repoResultLines(handoff) {
 function taskRepoNames(isolation) {
   return (isolation?.repos ?? []).filter((r) => r !== ".");
 }
-function mergeOutcome(result, branch, group) {
+function mergeOutcome(result, branch, group, repaired = []) {
   const ok = result.outcome === "merged";
   if (!group && result.outcome === "conflict") {
     return { ok, message: `Merging ${branch} conflicted, so it was aborted \u2014 your tree is as it was. Merge it with git and resolve the conflict there.` };
   }
-  const { message } = (0, import_core7.describeMergeResult)(result, branch, group);
+  const { message } = (0, import_core7.describeMergeResult)(result, branch, group, repaired);
   return { ok, message: ok || !group ? message : `${message} Each repository's ${branch} is a plain branch you can merge by hand.` };
 }
 
@@ -2384,7 +2405,7 @@ async function handleCompact(subArgs, injectedApi) {
 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);
+  const { api, sessionId, workspace } = await adopted(subArgs, injectedApi);
   if (arg === void 0) {
     let targets;
     try {
@@ -2398,15 +2419,20 @@ async function handleRewind(subArgs, injectedApi) {
     }
     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.");
+    console.log("\n  `ordewell rewind <n>` forks the conversation from just before message <n>. The original is kept, and the tasks ride along.");
     return;
   }
+  let fork;
   try {
-    await api.rewindConversation(sessionId, Number(arg));
+    fork = 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.`);
+  saveLastSession(fork.sessionId, fork.goal, fork.plan.runners ?? [], workspace);
+  console.log(`Forked ${sessionId} into ${fork.sessionId} from just before message ${arg} \u2014 the fork is now the current session.`);
+  console.log(`  \`ordewell sessions load ${sessionId}\` to go back to the original.`);
+  console.log("\nThe message you rewound to, to resend or edit:\n");
+  console.log(fork.rewoundMessage);
 }
 
 // src/commands/handoff.ts
@@ -2619,12 +2645,12 @@ function runHandoffAction(state, id) {
           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.`,
+            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. Ordewell never does this on its own. It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           } : {
             kind: "confirm",
             title: "Merge into your branch?",
-            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. Ordewell never does this on its own. If it conflicts the merge is aborted and your tree stays as it was.`,
+            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. Ordewell never does this on its own. If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           }
         },
@@ -2649,7 +2675,14 @@ 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) };
+  const repaired = repairedLanded(handoff);
+  const effect = kind === "merge-run" ? {
+    type: "isolationMerge",
+    sessionId,
+    branch: handoffBranch(handoff),
+    ...isRepoGroup(handoff) ? { group: true } : {},
+    ...repaired.length > 0 ? { repaired } : {}
+  } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
   return { state: closed, effects: [effect] };
 }
 function showDiff(state, diff) {
@@ -2714,7 +2747,7 @@ function chooseBlocked(state, choice) {
   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");
+  return a?.state === b?.state && a?.branch === b?.branch && a?.worktree === b?.worktree && a?.conflictRepo === b?.conflictRepo && (a?.repos ?? []).join("\0") === (b?.repos ?? []).join("\0") && (a?.conflictFiles ?? []).join("\0") === (b?.conflictFiles ?? []).join("\0") && a?.repair?.attempt === b?.repair?.attempt && a?.repair?.limit === b?.repair?.limit && (a?.repairedFiles ?? []).join("\0") === (b?.repairedFiles ?? []).join("\0");
 }
 function mapTasks(tasks, map) {
   return tasks.map((task) => {
@@ -2787,8 +2820,8 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
       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);
+      await confirmed((group ? `Merge ${branch} into the branch checked out in each of ${reposWithWork(handoff).join(", ")}? Nothing is merged unless every repository can take it; once all have, the run's worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once merged, the run's worktrees and branches are removed.`) + repairedNotice(handoff));
+      const { ok, message } = mergeOutcome(await attempt(() => api.mergeRun(sessionId)), branch, group, repairedLanded(handoff));
       if (ok) console.log(message);
       else fail(message);
       return;
@@ -3355,7 +3388,7 @@ Dependencies \xB7 #${task.order} ${task.title}
 }
 
 // src/tui/index.ts
-var import_core19 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3525,7 +3558,7 @@ var SLASH_COMMANDS = [
   { 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: "rewind", usage: "/rewind [<message>]", description: "Fork the conversation from just before one of your messages, after a confirmation (the original is kept)", category: "session" },
   { name: "new", usage: "/new", description: "Start a new session", category: "session" },
   { name: "save", usage: "/save", description: "Save the current session", category: "session" },
   { name: "load", usage: "/load <id>", description: "Load a saved session", category: "session" },
@@ -3951,12 +3984,9 @@ function chatBodyLines(messages, cols) {
 }
 function chatLayout(state, rows, cols) {
   const welcome = state.tasks.length === 0;
-  if (welcome && state.messages.length === 0) {
-    return { lines: welcomeLines(state, cols), anchor: "top", maxScroll: 0 };
-  }
   const body = chatBodyLines(state.messages, cols);
-  const lines = welcome ? [...welcomeLines(state, cols), "", ...body] : body;
-  return { lines, anchor: "bottom", maxScroll: Math.max(0, lines.length - rows) };
+  const lines = !welcome ? body : state.messages.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
+  return { lines, anchor: lines.length > rows ? "bottom" : "top", maxScroll: Math.max(0, lines.length - rows) };
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
@@ -4073,33 +4103,69 @@ var STATUS_ICON = {
   pending: "\xB7"
 };
 var IDLE_ICON = "~";
+var FIRST_ROW_LINE = 2;
 function planLayout(state, rows, cols) {
   const done = state.tasks.filter((t) => t.status === "completed").length;
   const lines = [style.bold(`Plan ${done}/${state.tasks.length}`), ""];
-  let selectedLine = 2;
+  const rowSpans = [];
   let editorLine;
   planRows(state).forEach((row, i) => {
     const taskStart = lines.length;
-    if (i === state.selectedTask) selectedLine = taskStart;
     const renderedTask = taskLines(state, row, i, cols);
     if (row.task.id === state.expandedTaskId && renderedTask.editorLine !== void 0) {
       editorLine = taskStart + renderedTask.editorLine;
     }
     lines.push(...renderedTask.lines);
+    rowSpans.push({ start: taskStart, end: lines.length - 1 });
   });
-  const maxScroll = Math.max(0, lines.length - rows);
-  const anchorLine = editorLine ?? selectedLine;
-  return { lines, followOffset: Math.min(maxScroll, Math.max(0, anchorLine - rows + 3)), maxScroll };
+  const selected = rowSpans[state.selectedTask] ?? { start: FIRST_ROW_LINE, end: FIRST_ROW_LINE };
+  const anchor = editorLine === void 0 ? selected : { start: editorLine, end: editorLine };
+  return { lines, rowSpans, anchor, rows, maxScroll: Math.max(0, lines.length - rows) };
+}
+var clampOffset = (layout, offset) => Math.max(0, Math.min(layout.maxScroll, offset));
+function revealOffset(layout, offset, span) {
+  const at = clampOffset(layout, offset);
+  const bodyHeight = layout.rows - 1;
+  const first = span.start <= FIRST_ROW_LINE ? 0 : span.start - 1;
+  if (span.start < 1 + at || span.end - span.start + 1 > bodyHeight) return clampOffset(layout, first);
+  if (span.end > at + layout.rows - 1) return clampOffset(layout, span.end - layout.rows + 1);
+  return at;
 }
 function planOffset(layout, planScroll) {
-  if (planScroll === null) return layout.followOffset;
-  return Math.max(0, Math.min(layout.maxScroll, planScroll));
+  if (planScroll === null) return revealOffset(layout, 0, layout.anchor);
+  return clampOffset(layout, planScroll);
+}
+function topRowInView(layout, offset) {
+  const top = 1 + offset;
+  const whole = layout.rowSpans.findIndex((span) => span.start >= top && span.end <= offset + layout.rows - 1);
+  if (whole >= 0) return whole;
+  const covering = layout.rowSpans.findIndex((span) => span.end >= top);
+  return covering >= 0 ? covering : layout.rowSpans.length - 1;
+}
+function bottomRowInView(layout, offset) {
+  const bottom = offset + layout.rows - 1;
+  const spans = layout.rowSpans;
+  for (let i = spans.length - 1; i >= 0; i--) {
+    if (spans[i].start >= 1 + offset && spans[i].end <= bottom) return i;
+  }
+  for (let i = spans.length - 1; i >= 0; i--) {
+    if (spans[i].start <= bottom) return i;
+  }
+  return 0;
+}
+function rowNearestView(layout, offset, row) {
+  const span = layout.rowSpans[row];
+  if (!span) return row;
+  if (span.end < 1 + offset) return topRowInView(layout, offset);
+  if (span.start > offset + layout.rows - 1) return bottomRowInView(layout, offset);
+  return row;
 }
 function planScrollExtent(state) {
   const cols = planPaneWidth(state);
-  if (cols === 0) return { followOffset: 0, maxScroll: 0 };
-  const { followOffset, maxScroll } = planLayout(state, bodyRows(state), cols);
-  return { followOffset, maxScroll };
+  if (cols === 0) {
+    return { lines: [], rowSpans: [], anchor: { start: FIRST_ROW_LINE, end: FIRST_ROW_LINE }, rows: 0, maxScroll: 0 };
+  }
+  return planLayout(state, bodyRows(state), cols);
 }
 function taskLines(state, row, index, cols) {
   const { task, parent } = row;
@@ -4138,7 +4204,16 @@ function taskLines(state, row, index, 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)));
+    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core16.capConflictFiles)(task.isolation.conflictFiles)})` : "";
+    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files} \u2014 its work is kept on its own branch`, cols)));
+  }
+  if (task.isolation?.state === "repairing") {
+    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core16.capConflictFiles)(task.isolation.conflictFiles)}` : "";
+    const attempt = task.isolation.repair ? ` (attempt ${task.isolation.repair.attempt}/${task.isolation.repair.limit})` : "";
+    lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
+  }
+  if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
+    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core16.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
   }
   let editorLine;
   if (expanded) {
@@ -4223,6 +4298,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
+var import_core17 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -4321,8 +4397,7 @@ function renderSkills(state, cols) {
   return truncate([...badges, auto].join(" "), cols);
 }
 function scrolledBackMark(state) {
-  if (state.focus === "plan") return state.planScroll === null ? "" : "\u2191 scrolled back \xB7 \u2191\u2193 to follow";
-  return state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
+  return state.focus !== "plan" && state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
 }
 function renderStatus(state, cols) {
   const mark = scrolledBackMark(state);
@@ -4462,14 +4537,7 @@ function renderOverlay(state, rows, cols) {
       cols
     );
   }
-  if (overlay.kind === "confirm") {
-    return frame(
-      overlay.title,
-      [overlay.message, "", style.grey("enter confirms \xB7 esc cancels")],
-      rows,
-      cols
-    );
-  }
+  if (overlay.kind === "confirm") return renderConfirm(overlay, rows, cols);
   if (overlay.kind === "prompt") {
     const secret = overlay.action.kind === "api-key";
     const shown = secret ? "\u2022".repeat(overlay.value.length) : overlay.value;
@@ -4493,7 +4561,10 @@ function renderHandoff(state, overlay, rows, cols) {
     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 landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core17.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} #${task.order} ${task.title}${repaired}`;
+  });
   const actions = handoffActions(handoff).map((action, index) => {
     const active = index === overlay.index;
     const caret = active ? style.cyan("\u276F") : " ";
@@ -4553,6 +4624,24 @@ function renderHelp(scroll, rows, cols) {
   const footer = style.grey(offset < maxScroll ? "\u2191\u2193 scroll \xB7 any other key closes" : "any key closes");
   return frame("Commands", [...lines.slice(offset, offset + room), footer], rows, cols);
 }
+var QUOTE_MAX_LINES = 8;
+function renderConfirm(overlay, rows, cols) {
+  const { choice, quote, note } = overlay;
+  const inner = Math.max(1, cols - 3);
+  const options = (choice?.options ?? []).map((o, i) => `${i === choice?.index ? style.cyan("\u276F") : " "} ${i + 1}. ${o.label}`);
+  const hint = choice ? style.grey(`\u2191\u2193 move \xB7 enter or 1\u2013${choice.options.length} chooses \xB7 esc cancels`) : style.grey("enter confirms \xB7 esc cancels");
+  const noteLines = note ? ["", ...note.split("\n")] : [];
+  const rest = [...noteLines, ...options.length > 0 ? ["", ...options] : [], "", hint];
+  const quoted = [];
+  if (quote !== void 0) {
+    const fixed = 1 + wrap(overlay.message, inner).length + 1 + 1 + rest.flatMap((l) => wrap(l, inner)).length;
+    const room = Math.max(2, Math.min(QUOTE_MAX_LINES, rows - fixed));
+    const wrapped = wrap(quote, inner - 2);
+    const shown = wrapped.length > room ? [...wrapped.slice(0, room - 1), "\u2026"] : wrapped;
+    quoted.push("", ...shown.map((l) => `${style.grey("\u2502")} ${l}`));
+  }
+  return frame(overlay.title, [overlay.message, ...quoted, ...rest], rows, cols);
+}
 function frame(title, body, rows, cols) {
   const inner = Math.max(1, cols - 2);
   const lines = [
@@ -4563,9 +4652,9 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core17 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var import_plan_utils3 = require("@ordewell/core/plan-utils");
-var KNOWN_PROVIDERS2 = Object.keys(import_core17.ALL_PROVIDERS);
+var KNOWN_PROVIDERS2 = Object.keys(import_core18.ALL_PROVIDERS);
 var DEFAULT_EFFORT = "__runner_default__";
 function step(state, effects = []) {
   return { state, effects };
@@ -4653,7 +4742,8 @@ function reduce(state, action) {
         expandedTaskId,
         taskEditor: expandedTaskId !== null ? state.taskEditor : null
       };
-      return step({ ...next, selectedTask: Math.min(state.selectedTask, Math.max(0, planRows(next).length - 1)) });
+      const selectedTask = clampSelection(state.selectedTask, planRows(next).length);
+      return step(settlePlan({ ...next, selectedTask, focus: tasks.length === 0 ? "chat" : state.focus }));
     }
     case "plannerMessage": {
       if (stale(state, action.sessionId)) return step(state);
@@ -4746,7 +4836,7 @@ function reduce(state, action) {
       if (stale(state, action.sessionId)) return step(state);
       return step(showDiff(state, action.diff));
     }
-    case "handoffDiscarded": {
+    case "runCleared": {
       if (stale(state, action.sessionId)) return step(state);
       const overlay = state.overlay?.kind === "handoff" ? null : state.overlay;
       return step({ ...clearIsolation(state), overlay });
@@ -4787,6 +4877,7 @@ function reduce(state, action) {
       return step(refillPicker({ ...state, sessions: action.sessions }, ["load-session", "delete-session"]));
     case "rewindTargetsLoaded":
       if (stale(state, action.sessionId)) return step(state);
+      if (action.pick !== void 0) return pickRewindTarget({ ...state, rewindTargets: action.targets }, action.pick);
       return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
     // A fork holds no run, whatever the session it came from was doing — the
     // original keeps its run, and its events are stale from here on.
@@ -4802,6 +4893,15 @@ function reduce(state, action) {
         pendingApprovals: [],
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
+    // The rewound message comes back as a draft to edit and resend, so it lands
+    // as if just typed: history is not being browsed, and nothing is parked.
+    case "inputPrefilled":
+      if (stale(state, action.sessionId)) return step(state);
+      return step({
+        ...state,
+        focus: "chat",
+        editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
+      });
     case "runnersLoaded":
       return step(refillPicker({
         ...state,
@@ -4827,11 +4927,7 @@ function reduce(state, action) {
       return step(say(state, "system", action.message));
     case "resize": {
       const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
-      return step({
-        ...resized,
-        scroll: clamp(resized.scroll, chatScrollMax(resized)),
-        planScroll: resized.planScroll === null ? null : clamp(resized.planScroll, planScrollExtent(resized).maxScroll)
-      });
+      return step(settlePlan({ ...resized, scroll: clamp(resized.scroll, chatScrollMax(resized)) }));
     }
     // Whether there is anything to animate is the app loop's call (it owns the
     // timer); a tick that arrives simply advances the frame.
@@ -4906,11 +5002,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core17.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core18.ALL_PROVIDERS[p]?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state) {
-  const runner = (0, import_core17.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
   if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -4924,7 +5020,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core17.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -5049,7 +5145,7 @@ function pointerPane(state, key) {
 }
 function scrollPointed(state, key) {
   const delta = key.name === "scrollup" ? WHEEL_NOTCH : -WHEEL_NOTCH;
-  return pointerPane(state, key) === "plan" ? scrollPlan(state, delta) : scrollChat(state, delta);
+  return pointerPane(state, key) === "plan" ? scrollPlan(state, delta, false) : scrollChat(state, delta);
 }
 var isMouseSelect = (key) => key.name === "mousedown" || key.name === "mousedrag" || key.name === "mouseup";
 function selectionCell(state, pane, key) {
@@ -5082,10 +5178,23 @@ function clamp(value, max) {
 function scrollChat(state, delta) {
   return step({ ...state, scroll: clamp(state.scroll + delta, chatScrollMax(state)) });
 }
-function scrollPlan(state, delta) {
-  const { followOffset, maxScroll } = planScrollExtent(state);
-  const from = state.planScroll ?? followOffset;
-  return step({ ...state, planScroll: clamp(from - delta, maxScroll) });
+function settlePlan(state) {
+  if (planPaneWidth(state) === 0) return state;
+  const layout = planScrollExtent(state);
+  return { ...state, planScroll: revealOffset(layout, planOffset(layout, state.planScroll), layout.anchor) };
+}
+function scrollPlan(state, delta, paged) {
+  const layout = planScrollExtent(state);
+  const from = planOffset(layout, state.planScroll);
+  const to = clamp(from - delta, layout.maxScroll);
+  const scrolled = { ...state, planScroll: to };
+  if (state.taskEditor || layout.rowSpans.length === 0) return step(scrolled);
+  const back = delta > 0;
+  if (!paged) {
+    return step({ ...scrolled, selectedTask: rowNearestView(layout, to, state.selectedTask) });
+  }
+  if (to === from) return step({ ...scrolled, selectedTask: back ? 0 : layout.rowSpans.length - 1 });
+  return step({ ...scrolled, selectedTask: back ? bottomRowInView(layout, to) : topRowInView(layout, to) });
 }
 var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function stopPlanning(state, sessionId) {
@@ -5115,7 +5224,10 @@ function handleKey2(state, key) {
       return step({ ...state, editor: { ...state.editor, text, cursor: token.start + completed.length } });
     }
   }
-  if (key.name === "tab") return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
+  if (key.name === "tab") {
+    if (state.focus === "chat" && state.tasks.length === 0) return step(state);
+    return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
+  }
   if (state.focus === "plan") return handlePlanKey(state, key);
   if (key.name === "enter") return submit(state);
   if (key.name === "escape") return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
@@ -5147,35 +5259,32 @@ function handlePlanKey(state, key) {
   const editingTask = state.expandedTaskId ? findTask(state.tasks, state.expandedTaskId) : void 0;
   if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
   if (key.name === "escape") {
-    if (state.expandedTaskId) return step({ ...state, expandedTaskId: null, planScroll: null });
+    if (state.expandedTaskId) return step(settlePlan({ ...state, expandedTaskId: null }));
     return step({ ...state, focus: "chat" });
   }
   if (key.name === "up") {
-    return step({ ...state, selectedTask: Math.max(0, state.selectedTask - 1), planScroll: null });
+    return step(settlePlan({ ...state, selectedTask: Math.max(0, state.selectedTask - 1) }));
   }
   if (key.name === "down") {
-    return step({
-      ...state,
-      selectedTask: Math.min(planRows(state).length - 1, state.selectedTask + 1),
-      planScroll: null
-    });
+    return step(settlePlan({ ...state, selectedTask: clampSelection(state.selectedTask + 1, planRows(state).length) }));
   }
   const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll);
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  if (key.name === "char" && key.char === "a") return addTask(state, "");
   const row = selectedPlanRow(state);
   if (!row) return step(state);
   const task = row.task;
   if (key.name === "enter" || key.name === "right") {
     const hasSubtasks = (task.subtasks?.length ?? 0) > 0;
     if (hasSubtasks && state.expandedTaskId !== task.id) {
-      return step({ ...state, expandedTaskId: task.id, taskEditor: null, planScroll: null });
+      return step(settlePlan({ ...state, expandedTaskId: task.id, taskEditor: null }));
     }
     const text = task.prompt ?? task.description ?? task.title;
-    return step({
+    return step(settlePlan({
       ...state,
       expandedTaskId: task.id,
       taskEditor: { ...emptyEditor(), text, cursor: text.length }
-    });
+    }));
   }
   if (!state.sessionId || key.name !== "char") return step(state);
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
@@ -5184,7 +5293,6 @@ function handlePlanKey(state, key) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
   if (key.char === "d") return confirmRemoveTask(state, task);
-  if (key.char === "a") return addTask(state, "");
   if (key.char === "t") {
     return step(state, [{ type: "openTaskTerminal", sessionId: state.sessionId, taskId: task.id }]);
   }
@@ -5200,13 +5308,13 @@ function handlePlanKey(state, key) {
 }
 function handleTaskEditKey(state, task, editor, key) {
   if (key.name === "enter") return commitTaskEdit(state, task, editor);
-  if (key.name === "escape") return step({ ...state, expandedTaskId: null, taskEditor: null });
+  if (key.name === "escape") return step(settlePlan({ ...state, expandedTaskId: null, taskEditor: null }));
   const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll);
-  return step({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) });
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  return step(settlePlan({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) }));
 }
 function commitTaskEdit(state, task, editor) {
-  const collapsed = { ...state, expandedTaskId: null, taskEditor: null };
+  const collapsed = settlePlan({ ...state, expandedTaskId: null, taskEditor: null });
   const prompt = editor.text.trim();
   const original = task.prompt ?? task.description ?? task.title;
   if (!prompt || prompt === original || !state.sessionId) return step(collapsed);
@@ -5261,7 +5369,18 @@ function handleOverlayKey(state, overlay, key) {
 }
 function handleConfirmKey(state, overlay, key) {
   if (key.name === "escape") return step({ ...state, overlay: null });
-  if (key.name !== "enter") return step(state);
+  const { choice } = overlay;
+  if (!choice) return key.name === "enter" ? runConfirm(state, overlay) : step(state);
+  if (key.name === "up" || key.name === "down") {
+    const index = clamp(choice.index + (key.name === "down" ? 1 : -1), choice.options.length - 1);
+    return step({ ...state, overlay: { ...overlay, choice: { ...choice, index } } });
+  }
+  const chosen = key.name === "enter" ? choice.index : key.name === "char" ? Number(key.char) - 1 : -1;
+  const option = choice.options[chosen];
+  if (!option) return step(state);
+  return option.confirms ? runConfirm(state, overlay) : step({ ...state, overlay: null });
+}
+function runConfirm(state, overlay) {
   const closed = { ...state, overlay: null };
   if (overlay.action.kind === "new-session") return newSession(closed);
   if (overlay.action.kind === "remove-task") {
@@ -5274,7 +5393,8 @@ function handleConfirmKey(state, overlay, key) {
   if (overlay.action.kind === "init-workspace") {
     return step({ ...closed, status: "planning" }, [{ type: "startConversation", goal: overlay.action.goal, allowInit: true }]);
   }
-  return step(closed);
+  const { index } = overlay.action;
+  return withIdlePlanner(closed, (sessionId) => step(closed, [{ type: "rewindConversation", sessionId, index }]));
 }
 function handleHelpKey(state, scroll, key) {
   const page = pageNotch(bodyRows(state));
@@ -5298,7 +5418,7 @@ function handlePromptKey(state, overlay, key) {
     if (overlay.action.kind === "api-key") {
       return step(closed, [{ type: "setApiKey", provider: overlay.action.provider, key: value2 }]);
     }
-    if (!state.sessionId) return fail3(closed, "No active plan to add a task to.");
+    if (!state.sessionId) return fail3(closed, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
     return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
   }
   const value = editText(overlay.value, key);
@@ -5371,10 +5491,7 @@ function choose(state, picker2, item) {
     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) }])
-      );
+      return pickRewindTarget(state, Number(item.id));
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
@@ -5455,7 +5572,7 @@ function runCommand(state, { name, args }) {
     case "quit":
       return step({ ...state, exiting: true }, [{ type: "exit" }]);
     case "refresh":
-      return step(state, [{ type: "refresh" }]);
+      return step(state, [{ type: "refresh", announce: true }]);
     case "run":
       return withSession(state, (sessionId) => step(state, [{ type: "execute", sessionId }]));
     case "approve":
@@ -5571,12 +5688,34 @@ 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." }) } },
+        { ...state, rewindTargets: null, overlay: { kind: "picker", picker: picker("Rewind to before\u2026", [], { kind: "rewind" }, { hint: "Rewinding forks the conversation from just before the chosen message; the original is kept and the tasks ride along." }) } },
         [{ type: "loadRewindTargets", sessionId }]
       );
     }
     if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
-    return step(state, [{ type: "rewindConversation", sessionId, index: Number(arg) }]);
+    return step(state, [{ type: "loadRewindTargets", sessionId, pick: Number(arg) }]);
+  });
+}
+var REWIND_OPTIONS = [
+  { label: "Restore Conversation", confirms: true },
+  { label: "Never mind", confirms: false }
+];
+function pickRewindTarget(state, index) {
+  return withIdlePlanner({ ...state, overlay: null }, () => {
+    const target = state.rewindTargets?.find((t) => t.index === index);
+    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to \u2014 /rewind alone lists them.`);
+    return step({
+      ...state,
+      overlay: {
+        kind: "confirm",
+        title: "Rewind",
+        message: "Confirm you want to restore to the point before you sent this message:",
+        quote: target.content,
+        note: "The conversation will be forked.\nThe code will be unchanged.",
+        action: { kind: "rewind", index },
+        choice: { options: REWIND_OPTIONS, index: 0 }
+      }
+    });
   });
 }
 function resolveToggle(arg, current) {
@@ -5618,6 +5757,7 @@ function newSession(state) {
     expandedTaskId: null,
     taskEditor: null,
     scroll: 0,
+    planScroll: null,
     status: "idle",
     busyLabel: "",
     thinkingLine: "",
@@ -5629,7 +5769,7 @@ function newSession(state) {
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core17.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core18.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
       return fail3(state, `${args[1]} was not discovered for ${runner}.`);
@@ -5651,21 +5791,21 @@ function setModel(state, args) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core17.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core17.runnerForProvider)(id);
+  const agents = import_core18.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core18.runnerForProvider)(id);
     const ready = installed.has(runner);
     return {
       id,
-      label: import_core17.ALL_PROVIDERS[id].label,
+      label: import_core18.ALL_PROVIDERS[id].label,
       detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
       selected: state.plannerProvider === id,
       disabled: !ready
     };
   });
-  const vendors = import_core17.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
+  const vendors = import_core18.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
     id,
-    label: import_core17.ALL_PROVIDERS[id].label,
-    detail: import_core17.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core18.ALL_PROVIDERS[id].label,
+    detail: import_core18.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.plannerProvider === id
   }));
   return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
@@ -5723,16 +5863,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core17.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core18.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core17.ALL_PROVIDERS[id].label,
-    detail: import_core17.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core18.ALL_PROVIDERS[id].label,
+    detail: import_core18.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core17.ALL_PROVIDERS[provider];
+  const meta = import_core18.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6009,16 +6149,20 @@ function taskEffortCommand(state, args) {
     return assignTaskEffort(state, sessionId, task, value);
   });
 }
+function clampSelection(index, rows) {
+  return Math.max(0, Math.min(index, rows - 1));
+}
 function addTask(state, title) {
-  return withSession(state, (sessionId) => {
-    if (!title) {
-      return step({
-        ...state,
-        overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
-      });
-    }
-    return step(state, [{ type: "addTask", sessionId, title }]);
-  });
+  if (!state.sessionId) {
+    return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
+  }
+  if (!title) {
+    return step({
+      ...state,
+      overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
+    });
+  }
+  return step(state, [{ type: "addTask", sessionId: state.sessionId, title }]);
 }
 function taskCommand(state, token, run) {
   return withSession(state, (sessionId) => {
@@ -6090,7 +6234,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core18 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var ConversationQueue = class {
   tail = Promise.resolve();
@@ -6261,7 +6405,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core18.ALL_PROVIDERS[effect.provider];
+      const meta = import_core19.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
@@ -6273,7 +6417,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core18.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core19.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -6285,7 +6429,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core18.ALL_PROVIDERS[effect.provider];
+      const meta = import_core19.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -6352,13 +6496,23 @@ async function perform(effect, deps) {
       return;
     }
     case "loadRewindTargets":
-      dispatch({ type: "rewindTargetsLoaded", targets: await api.rewindTargets(effect.sessionId), sessionId: effect.sessionId });
+      dispatch({
+        type: "rewindTargetsLoaded",
+        targets: await api.rewindTargets(effect.sessionId),
+        sessionId: effect.sessionId,
+        ...effect.pick !== void 0 && { pick: effect.pick }
+      });
       return;
+    // A rewind is a fork from an earlier point, so the TUI follows it the way
+    // it follows `/fork`; the original keeps its whole conversation. The
+    // rewound message comes back into the input, to edit and send again.
     case "rewindConversation": {
-      const 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." });
+      const fork = await api.rewindConversation(effect.sessionId, effect.index);
+      dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
+      dispatch({ type: "chatRestored", history: fork.plan.conversationHistory ?? [], sessionId: fork.sessionId });
+      dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
+      dispatch({ type: "inputPrefilled", text: fork.rewoundMessage, sessionId: fork.sessionId });
+      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} from before that message \u2014 the original is kept (/sessions to go back). The message is ready to edit and resend.` });
       return;
     }
     // The redrawn transcript opens with the summary entry, which is what the
@@ -6373,15 +6527,17 @@ async function perform(effect, deps) {
       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.
+    // tree is exactly as it was, and the words say what to do next. A full
+    // merge leaves nothing to hand over — the daemon has cleared the run up.
     case "isolationMerge": {
-      const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true);
+      const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true, effect.repaired ?? []);
+      if (ok) dispatch({ type: "runCleared", sessionId: effect.sessionId });
       dispatch({ type: ok ? "notice" : "failed", message });
       return;
     }
     case "isolationDiscard":
       await api.discardRun(effect.sessionId);
-      dispatch({ type: "handoffDiscarded", sessionId: effect.sessionId });
+      dispatch({ type: "runCleared", sessionId: effect.sessionId });
       dispatch({ type: "notice", message: `Discarded the run and ${effect.branch}.` });
       return;
     case "isolationCleanup":
@@ -6418,7 +6574,7 @@ async function perform(effect, deps) {
       return;
     case "refresh":
       await Promise.all([loadRunners(deps), loadSettings(deps), loadModels(deps)]);
-      dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
+      if (effect.announce) dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
       return;
     case "exit":
       deps.exit();
@@ -6434,7 +6590,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core18.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core19.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -6576,7 +6732,7 @@ function onExecutionEvent(dispatch, event, sessionId) {
     // The extension shows these in its checkpoint panel; here they are
     // transcript lines, which is the TUI's equivalent surface.
     case "checkpoint":
-      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core18.truncateCheckpointSummary)(event.summary)}` });
+      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core19.truncateCheckpointSummary)(event.summary)}` });
       return;
     case "approval_decided":
       dispatch({ type: "notice", message: describeApprovalDecision2(event) });
@@ -6632,8 +6788,10 @@ function onExecutionEvent(dispatch, event, sessionId) {
     case "approval_request":
     case "approval_settled":
       return;
-    // Its asker already has the result, from the merge request itself.
+    // Its asker already has the words, from the merge request itself; a
+    // viewer that did not ask still has to drop a run that is gone.
     case "isolation_merge":
+      if (event.result.outcome === "merged") dispatch({ type: "runCleared", sessionId });
       return;
     default: {
       const unhandled = event;
@@ -6958,7 +7116,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core19.assertWorkspaceExists)(workspace);
+    (0, import_core20.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -6967,7 +7125,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core19.createSkillsService)(workspace).listSkills());
+  registerSkillCommands((0, import_core20.createSkillsService)(workspace).listSkills());
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
@@ -6986,7 +7144,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       conversationQueue,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core19.mintSessionId)(),
+      newSessionId: () => (0, import_core20.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -7096,7 +7254,7 @@ function cliVersion() {
 
 // src/main.ts
 async function main() {
-  (0, import_core20.migrateOldConfigDir)();
+  (0, import_core21.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   const command = argv[0] ?? (process.stdin.isTTY ? "tui" : "--help");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordewell/cli",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Ordewell CLI and TUI — plan, run and verify coding-agent tasks from the terminal.",
   "license": "Apache-2.0",
   "author": "Alessandro Costanzo Ciano",
@@ -48,8 +48,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ordewell/core": "^0.5.0",
-    "@ordewell/web": "^0.5.0",
+    "@ordewell/core": "^0.5.1",
+    "@ordewell/web": "^0.5.1",
     "string-width": "^7.2.0",
     "ws": "^8.18.0"
   },