@ordewell/cli 0.5.0 → 0.5.2

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_core23 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -94,7 +94,8 @@ 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)
+  ordewell handoff [action]       Review, merge, discard or clean up a finished isolated run
 
 Tasks (<id> is an order number or a task ID):
   ordewell add-task --title "..."  Add a task to the current plan
@@ -123,6 +124,7 @@ Planner, models and runners:
   ordewell runners [<id> on|off]  Enable or disable runners (claude-code, opencode, codex)
   ordewell allowlist set|clear|show       Limit which models a runner may use
   ordewell auto [on|off]          Autonomous permission mode for new sessions
+  ordewell parallel [<n>]         How many AI tasks run at once (default 3; applies to a live run)
   ordewell refresh                Re-discover runners and model catalogs
   ordewell models                 List every provider's catalog (works without a server)
 
@@ -196,8 +198,9 @@ Environment:
   OPENROUTER_BASE_URL        Default: https://openrouter.ai/api/v1
   ORDEWELL_AUTONOMOUS_MODE   Approval posture for new sessions (see "ordewell auto")
   ORDEWELL_PORT              Daemon port CLI commands target (default: 3742)
+  ORDEWELL_DIRENV            false: agents skip the project's direnv .envrc
   ORDEWELL_RESEARCH_ENABLED  true (default) or false
-  ORDEWELL_MAX_PARALLEL      Default: 3
+  ORDEWELL_MAX_PARALLEL      Default: 3 \u2014 set with "ordewell parallel"
 `);
 }
 
@@ -616,13 +619,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
@@ -937,6 +944,25 @@ function readLastSession(workspace) {
   }
   return null;
 }
+var SESSION_PREFIX = "session-";
+function expandSessionId(id, workspace) {
+  if (id.startsWith(SESSION_PREFIX)) return id;
+  let files;
+  try {
+    files = (0, import_fs3.readdirSync)((0, import_path3.join)((0, import_core5.getStateDir)(workspace), "sessions")).filter((f) => f.endsWith(".json"));
+  } catch {
+    return id;
+  }
+  const matches = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    try {
+      const full = JSON.parse((0, import_fs3.readFileSync)((0, import_path3.join)((0, import_core5.getStateDir)(workspace), "sessions", file), "utf8"))?.meta?.id;
+      if (typeof full === "string" && (full.endsWith(id) || full.slice(SESSION_PREFIX.length).startsWith(id))) matches.add(full);
+    } catch {
+    }
+  }
+  return matches.size === 1 ? [...matches][0] : id;
+}
 
 // src/approvals.ts
 function describeApproval(event) {
@@ -1262,6 +1288,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 +1320,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 +1361,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 +1380,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 +2427,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 +2441,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 +2667,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 +2697,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 +2769,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 +2842,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;
@@ -2928,30 +2983,47 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   console.log(`Planner effort set to ${level}.`);
 }
 
-// src/commands/key.ts
+// src/commands/parallel.ts
 var import_core14 = require("@ordewell/core");
-var USAGE5 = "Usage: ordewell key [list | set <provider> <key>]";
+var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
+async function handleParallel(subArgs, injectedApi) {
+  const [wanted] = positionals(subArgs);
+  const api = await connect(subArgs, injectedApi);
+  if (!wanted || wanted === "show") {
+    const settings = await api.getSettings();
+    console.log(`Up to ${String(settings.maxParallel ?? "?")} AI tasks run at once. Change with: ordewell parallel <n>`);
+    return;
+  }
+  const limit = (0, import_core14.parseMaxParallel)(wanted);
+  if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
+  await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
+  console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
+}
+
+// src/commands/key.ts
+var import_core15 = require("@ordewell/core");
+var USAGE6 = "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}"`, USAGE5);
+    fail(`Unknown key action: "${action}"`, USAGE6);
   }
   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_core14.PROVIDER_PRIORITY) {
-      const meta2 = import_core14.ALL_PROVIDERS[id2];
+    for (const id2 of import_core15.PROVIDER_PRIORITY) {
+      const meta2 = import_core15.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. ${USAGE5}`);
+  \u2713 = a working key was found. ${USAGE6}`);
     return;
   }
-  if (!provider) fail(USAGE5);
+  if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core14.ALL_PROVIDERS[id];
+  const meta = import_core15.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -2962,7 +3034,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var USAGE6 = "Usage: ordewell runners [<runner-id> on|off]";
+var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
   const api = await connect(subArgs, injectedApi);
@@ -2973,7 +3045,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. ${USAGE6}`);
+  \u2713 = offered to the planner. ${USAGE7}`);
     return;
   }
   const state = await api.getRunners();
@@ -2982,7 +3054,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(USAGE6);
+  if (enabled === null) fail(USAGE7);
   await api.setRunnerEnabled(runner, enabled);
   console.log(`${runner} ${enabled ? "enabled" : "disabled"}.`);
 }
@@ -3032,7 +3104,7 @@ async function handleApprove(subArgs, injectedApi) {
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core15 = require("@ordewell/core");
+var import_core16 = 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);
@@ -3052,16 +3124,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_core15.hasTmux;
+  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core16.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_core15.tmuxSessionName)(port);
-  const socket = (0, import_core15.tmuxSocketName)(port);
-  const base = (0, import_core15.tmuxWindowName)(taskId, planSessionId);
+  const session = (0, import_core16.tmuxSessionName)(port);
+  const socket = (0, import_core16.tmuxSocketName)(port);
+  const base = (0, import_core16.tmuxWindowName)(taskId, planSessionId);
   let windows;
   try {
     const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
@@ -3355,7 +3427,7 @@ Dependencies \xB7 #${task.order} ${task.title}
 }
 
 // src/tui/index.ts
-var import_core19 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3517,6 +3589,7 @@ var SLASH_COMMANDS = [
   { name: "allowlist", usage: "/allowlist [set <runner> <ids> | clear <runner>]", description: "Limit which models a runner may use", category: "models" },
   { name: "runners", usage: "/runners [<id> on|off]", description: "Enable or disable runners (claude-code, opencode, codex)", category: "models" },
   { name: "auto", usage: "/auto [on|off]", description: "Autonomous permission mode for new plans", category: "models" },
+  { name: "parallel", usage: "/parallel [<n>]", description: "How many AI tasks run at once (applies to a live run)", category: "models" },
   { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
   // Skills
   { name: "tdd", usage: "/tdd [on|off]", description: "Test-Driven Development mode", category: "skills" },
@@ -3525,7 +3598,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" },
@@ -3741,6 +3814,7 @@ function chatEditorRoom(cols, active) {
 }
 
 // src/tui/state.ts
+var import_core17 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -3805,6 +3879,7 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
+    maxParallel: import_core17.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
@@ -3824,7 +3899,7 @@ function initialState(overrides = {}) {
 }
 
 // src/tui/layout.ts
-var import_core16 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -3951,21 +4026,18 @@ function chatBodyLines(messages, cols) {
 }
 function chatLayout(state, rows, cols) {
   const welcome = state.tasks.length === 0;
-  if (welcome && state.messages.length === 0) {
-    return { lines: welcomeLines(state, cols), anchor: "top", maxScroll: 0 };
-  }
   const body = chatBodyLines(state.messages, cols);
-  const lines = welcome ? [...welcomeLines(state, cols), "", ...body] : body;
-  return { lines, anchor: "bottom", maxScroll: Math.max(0, lines.length - rows) };
+  const lines = !welcome ? body : state.messages.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
+  return { lines, anchor: lines.length > rows ? "bottom" : "top", maxScroll: Math.max(0, lines.length - rows) };
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core16.ALL_PROVIDERS[provider];
+  const registration = import_core18.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core16.runnerForProvider)(provider);
+  const runner = (0, import_core18.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -4073,33 +4145,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;
@@ -4112,7 +4220,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_core16.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
+  const orderLabel = parent ? (0, import_core18.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));
@@ -4133,12 +4241,22 @@ function taskLines(state, row, index, cols) {
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${modeInfo?.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
   const bodyPad = parent ? "      " : "    ";
-  const meta = [running ? "working" : "", runner, model].filter(Boolean).join(" \xB7 ");
+  const activity = idle ? "quiet \u2014 t opens its terminal" : running ? "working" : "";
+  const meta = [activity, 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)));
+    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core18.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_core18.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_core18.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
   }
   let editorLine;
   if (expanded) {
@@ -4223,6 +4341,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
+var import_core19 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -4321,8 +4440,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 +4580,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 +4604,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_core19.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 +4667,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 +4695,9 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core17 = require("@ordewell/core");
+var import_core20 = 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_core20.ALL_PROVIDERS);
 var DEFAULT_EFFORT = "__runner_default__";
 function step(state, effects = []) {
   return { state, effects };
@@ -4584,6 +4716,17 @@ function alreadySpoken(messages, content) {
   const redrawn = messages.at(-1)?.role === "system" && messages.at(-1)?.content === content;
   return spoken || redrawn;
 }
+function runLabel(tasks) {
+  const running = tasks.filter(isTaskRunning);
+  if (running.length > 0) {
+    const [first] = running;
+    const name = first.assignedRunner ? `${first.title} \xB7 ${first.assignedRunner}` : first.title;
+    return running.length > 1 ? `${name} (+${running.length - 1} more)` : name;
+  }
+  const waiting = tasks.filter((t) => t.status === "awaiting_user").length;
+  if (waiting === 0) return "";
+  return waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`;
+}
 function researchLabel(messages, summary) {
   const others = messages.filter(isPendingResearch).length - 1;
   return others > 0 ? `${summary} (+${others} more)` : summary;
@@ -4653,7 +4796,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);
@@ -4686,6 +4830,16 @@ function reduce(state, action) {
       const status = state.status === "planning" ? "researching" : state.status;
       return step({ ...spoken, status, busyLabel: researchLabel(spoken.messages, summary) });
     }
+    // A settled transcript line, not a research step: nothing ever settles a
+    // task's start, so as a step it stayed "⋯" forever and was counted into
+    // the planner's next "(+N more)".
+    case "taskStarted": {
+      if (stale(state, action.sessionId)) return step(state);
+      const tasks = state.tasks.map((t) => t.id === action.taskId && !isTaskRunning(t) ? { ...t, status: "in_progress" } : t);
+      const who = action.runner ? ` \xB7 ${action.runner}` : "";
+      const spoken = say(state, "system", sanitize(`Started "${action.title}"${who}`));
+      return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
+    }
     case "researchStepDone": {
       if (stale(state, action.sessionId)) return step(state);
       const messages = settleResearchStep(state.messages, action);
@@ -4726,7 +4880,7 @@ function reduce(state, action) {
         return t;
       });
       if (!changed) return step(state);
-      return step({ ...state, status: "executing", tasks });
+      return step({ ...state, status: "executing", tasks, busyLabel: runLabel(tasks) });
     }
     case "queueReady": {
       if (stale(state, action.sessionId)) return step(state);
@@ -4746,7 +4900,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 +4941,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 +4957,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 +4991,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.
@@ -4890,6 +5050,7 @@ function applySettings(state, settings) {
     orchestratorModel: typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : state.orchestratorModel,
     plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
     plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
+    maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
@@ -4906,11 +5067,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_core20.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_core20.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 +5085,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_core20.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -5049,7 +5210,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 +5243,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 +5289,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 +5324,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 +5358,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 +5373,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 +5434,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 +5458,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 +5483,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 +5556,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 +5637,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":
@@ -5484,6 +5666,8 @@ function runCommand(state, { name, args }) {
       return runners(state, args);
     case "auto":
       return setAutonomous(state, args[0]);
+    case "parallel":
+      return setMaxParallel(state, args[0]);
     case "mouse":
       return setMouseCapture(state, args[0]);
     case "sessions":
@@ -5571,12 +5755,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 +5824,7 @@ function newSession(state) {
     expandedTaskId: null,
     taskEditor: null,
     scroll: 0,
+    planScroll: null,
     status: "idle",
     busyLabel: "",
     thinkingLine: "",
@@ -5629,7 +5836,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_core20.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 +5858,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_core20.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core20.runnerForProvider)(id);
     const ready = installed.has(runner);
     return {
       id,
-      label: import_core17.ALL_PROVIDERS[id].label,
+      label: import_core20.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_core20.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_core20.ALL_PROVIDERS[id].label,
+    detail: import_core20.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 +5930,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_core20.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core17.ALL_PROVIDERS[id].label,
-    detail: import_core17.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core20.ALL_PROVIDERS[id].label,
+    detail: import_core20.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_core20.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -5807,6 +6014,12 @@ function runners(state, args) {
     })
   } });
 }
+function setMaxParallel(state, arg) {
+  if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
+  const limit = (0, import_core20.parseMaxParallel)(arg);
+  if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
+  return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
+}
 function setAutonomous(state, arg) {
   const enabled = resolveToggle(arg, state.autonomous);
   if (enabled === null) return fail3(state, "Usage: /auto [on|off]");
@@ -6009,16 +6222,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) => {
@@ -6058,7 +6275,9 @@ function createApp(deps) {
   function dispatch(action) {
     if (exited) return;
     const result = reduce(state, action);
+    const previousSession = state.sessionId;
     state = result.state;
+    if (state.sessionId && state.sessionId !== previousSession) deps.onSessionChange?.(state.sessionId, state);
     if (state.exiting) {
       exited = true;
       clearInterval(spinnerInterval);
@@ -6090,7 +6309,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core18 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var ConversationQueue = class {
   tail = Promise.resolve();
@@ -6261,7 +6480,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_core21.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 +6492,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_core21.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 +6504,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_core21.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);
@@ -6316,6 +6535,11 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: effect.message });
       return;
     }
+    case "setMaxParallel":
+      await api.updateSettings({ env: { ORDEWELL_MAX_PARALLEL: String(effect.limit) } });
+      deps.setEnvVar("ORDEWELL_MAX_PARALLEL", String(effect.limit));
+      dispatch({ type: "notice", message: `Up to ${effect.limit} AI task${effect.limit === 1 ? "" : "s"} now run at once.` });
+      return;
     case "setAutonomous":
       deps.setEnvVar("ORDEWELL_AUTONOMOUS_MODE", String(effect.enabled));
       dispatch({ type: "notice", message: `Autonomous mode ${effect.enabled ? "on" : "off"}.` });
@@ -6352,13 +6576,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 +6607,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 +6654,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 +6670,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_core21.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -6571,12 +6807,12 @@ function onExecutionEvent(dispatch, event, sessionId) {
       return;
     }
     case "task_started":
-      dispatch({ type: "researchStep", summary: `${event.title ?? event.taskId} \xB7 ${event.runner ?? ""}`.trim(), sessionId });
+      dispatch({ type: "taskStarted", taskId: String(event.taskId), title: String(event.title ?? event.taskId), runner: event.runner, sessionId });
       return;
     // 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_core21.truncateCheckpointSummary)(event.summary)}` });
       return;
     case "approval_decided":
       dispatch({ type: "notice", message: describeApprovalDecision2(event) });
@@ -6632,8 +6868,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 +7196,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core19.assertWorkspaceExists)(workspace);
+    (0, import_core22.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -6967,7 +7205,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_core22.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 +7224,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_core22.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -7003,7 +7241,16 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       },
       exit: () => shutdown(0)
     }),
-    onExit: () => shutdown(0)
+    onExit: () => shutdown(0),
+    // The same pointer `ordewell plan` leaves, so `ordewell handoff`,
+    // `terminal <n>` and the other one-shot commands act on the session this
+    // TUI is showing instead of saying there is none.
+    onSessionChange: (sessionId, state) => {
+      try {
+        saveLastSession(sessionId, state.goal, state.runners.filter((r) => r.enabled).map((r) => r.id), workspace);
+      } catch {
+      }
+    }
   });
   terminal = openTerminal({
     mouse: mouseCapture,
@@ -7049,6 +7296,7 @@ var COMMANDS = {
   model: handleModel,
   planner: handlePlanner,
   "planner-effort": handlePlannerEffort,
+  parallel: handleParallel,
   key: handleKey,
   runners: handleRunners,
   auto: handleAuto,
@@ -7095,10 +7343,12 @@ function cliVersion() {
 }
 
 // src/main.ts
+var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core20.migrateOldConfigDir)();
+  (0, import_core23.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
+  if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");
   const command = argv[0] ?? (process.stdin.isTTY ? "tui" : "--help");
   if (command === "--help" || command === "-h") {
     printHelp();
@@ -7108,6 +7358,10 @@ async function main() {
     console.log(cliVersion());
     return;
   }
+  const sessionAt = argv.indexOf("--session-id");
+  if (sessionAt > 0 && argv[sessionAt + 1]) {
+    argv[sessionAt + 1] = expandSessionId(argv[sessionAt + 1], flag(argv, "--workspace") || process.cwd());
+  }
   const handler = COMMANDS[command];
   if (!handler) {
     console.error(`Unknown command: ${command}`);