@ordewell/cli 0.10.3 → 0.10.5

package/dist/main.js

@@ -145,6 +145,7 @@ Planning:
   ordewell fork                   Continue in a copy of the conversation and its tasks
   ordewell compact                Condense the conversation into a summary (tasks are kept)
   ordewell rewind [<n>]           Fork the conversation from before message <n> (no <n>: list them)
+  ordewell resend cancel          Keep a planner turn waiting on its usage limit from going at the reset
   ordewell handoff [action]       Review, merge, discard or clean up an isolated run
 
 Tasks (<id> is an order number or a task ID):
@@ -153,7 +154,7 @@ Tasks (<id> is an order number or a task ID):
   ordewell complete <id>          Mark a task complete (alias: mark-complete)
   ordewell uncomplete <id>        Mark a completed task not done
   ordewell skip <id>              Skip a task: nothing it did lands, dependents go ahead
-  ordewell force-start <id>       Start a task now, ignoring dependencies (asks past a merge gate)
+  ordewell force-start <id>       Approve a task and start it now, or once its dependencies finish (asks past a merge gate)
   ordewell run-task <id>          Run only one task
   ordewell retry <id>             Re-run a failed task
   ordewell continue <id> <msg>    Continue a finished task in its saved runner session
@@ -548,8 +549,7 @@ var ApiClient = class _ApiClient {
           ...body ? { "Content-Type": "application/json" } : {},
           ...token ? { Authorization: (0, import_core4.bearerHeaderValue)(token) } : {}
         },
-        // Planner research on a real repository regularly exceeds two minutes.
-        // The benchmark harness uses the same 15-minute default explicitly;
+        // Planner research on a real repository regularly exceeds two minutes;
         // keep the env override for callers that need a tighter/looser bound.
         timeout: Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : DEFAULT_HTTP_TIMEOUT_MS
       };
@@ -644,6 +644,10 @@ var ApiClient = class _ApiClient {
   cancelResume(sessionId, taskId) {
     return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resume/cancel`, "Cancel resume failed");
   }
+  /** Keep what waits on the planner's usage limit from being sent at the reset; `cancelled` is false when nothing waited. */
+  cancelPlannerResend(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/converse/resend/cancel`, "Cancel resend failed");
+  }
   /** Resume a task paused on a usage limit now, in its saved session, once the user says the limit has reset. */
   resumeNow(sessionId, taskId) {
     return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resume/now`, "Resume failed");
@@ -1610,10 +1614,21 @@ var STATE_OF = {
 function reposOf(run) {
   if (Array.isArray(run.repos)) {
     const repos = run.repos.filter((r) => r && typeof r.path === "string" && typeof r.integrationBranch === "string" && typeof r.baseRef === "string");
-    return repos.length > 0 ? repos.map((r) => ({ path: String(r.path), integrationBranch: String(r.integrationBranch), baseRef: String(r.baseRef) })) : null;
+    return repos.length > 0 ? repos.map((r) => ({
+      path: String(r.path),
+      integrationBranch: String(r.integrationBranch),
+      baseRef: String(r.baseRef),
+      ...typeof r.baseBranch === "string" && r.baseBranch ? { baseBranch: r.baseBranch } : {},
+      ...r.startedDetached === true ? { startedDetached: true } : {}
+    })) : null;
   }
   if (typeof run.integrationBranch === "string" && typeof run.baseRef === "string") {
-    return [{ path: ".", integrationBranch: run.integrationBranch, baseRef: run.baseRef }];
+    return [{
+      path: ".",
+      integrationBranch: run.integrationBranch,
+      baseRef: run.baseRef,
+      ...typeof run.baseBranch === "string" && run.baseBranch ? { baseBranch: run.baseBranch } : {}
+    }];
   }
   return null;
 }
@@ -1664,15 +1679,11 @@ function handoffBranch(handoff) {
   return [...new Set(handoff.repos.map((r) => r.integrationBranch))].join(", ");
 }
 function handoffBase(handoff, length) {
-  const group = isRepoGroup(handoff);
-  return handoff.repos.map((r) => `${group ? `${r.path} ` : ""}${r.baseRef.slice(0, length)}`).join(", ");
-}
-function isRepoGroup(handoff) {
-  return handoff.repos.some((r) => r.path !== ".");
-}
-function reposWithWork(handoff) {
-  const withWork = handoff.repos.filter((r) => r.landed.length > 0);
-  return (withWork.length > 0 ? withWork : handoff.repos).map((r) => r.path);
+  const group = (0, import_core10.isRepoGroup)(handoff);
+  return handoff.repos.map((r) => {
+    const ref = r.baseRef.slice(0, length);
+    return `${group ? `${r.path}: ` : ""}${r.baseBranch ? `${r.baseBranch} @ ${ref}` : `${r.startedDetached ? "detached at" : "base"} ${ref}`}`;
+  }).join(", ");
 }
 function repairedLanded(handoff) {
   return handoff.landed.filter((t) => t.repairedFiles?.length);
@@ -1750,7 +1761,7 @@ async function followExecution(api, sessionId, start, onBlocked) {
     for (const t of entries) {
       const icon = iconFor(t.status);
       const verdict = t.verdict ? `: ${t.verdict.outcome.toUpperCase()}: ${t.verdict.reason.slice(0, 60)}` : "";
-      const waits = t.waitsForApproval ? `: ${inLine(import_core12.WAITS_FOR_APPROVAL_LABEL)}: \`ordewell run-task <id>\` starts it` : "";
+      const waits = t.waitsForApproval ? `: ${inLine(import_core12.WAITS_FOR_APPROVAL_LABEL)}: \`ordewell force-start <id>\` approves it, \`ordewell run\` approves all` : "";
       lines.push(`  ${icon} #${t.id.slice(-4)} ${t.status}${verdict}${waits}`);
     }
     const output = lines.join("\n");
@@ -1812,10 +1823,10 @@ Done. ${summary.completed || 0} completed, ${summary.failed || 0} failed, ${summ
     }
     if (event.type === "isolation_handoff") {
       const n = event.landed.length;
-      const where = isRepoGroup(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
+      const where = (0, import_core10.isRepoGroup)(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
       console.log(`
 Run finished on ${handoffBranch(event)}${where}: ${n} task${n === 1 ? "" : "s"} landed.`);
-      if (isRepoGroup(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
+      if ((0, import_core10.isRepoGroup)(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
       if (event.deferredTo === "supervisor") console.log("  The supervisor may merge it.");
       console.log("  `ordewell handoff review|merge|discard|cleanup` to land it.");
     }
@@ -2656,27 +2667,28 @@ function formatCost(currency, amount) {
 function tokenLine(blocks2, cols) {
   const usage = blocks2[blocks2.length - 1];
   if (usage?.type !== "usage") return null;
-  const parts = usageMeasures(usage.totals, false);
+  const parts = usageMeasures(usage.totals);
   if (usage.model && !usage.contextFill) parts.push("ctx unknown");
   if (usage.contextFill) parts.splice(2, 0, `${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}% ctx`);
   return parts.length > 0 ? style.grey(truncate(parts.join(" \xB7 "), cols)) : null;
 }
-function usageMeasures(totals, unknown) {
+function usageMeasures(totals) {
   return [
-    ...totals.inputTokens !== void 0 ? [`${compactCount(totals.inputTokens)} in`] : unknown ? ["unknown in"] : [],
-    ...totals.outputTokens !== void 0 ? [`${compactCount(totals.outputTokens)} out`] : unknown ? ["unknown out"] : [],
+    ...totals.inputTokens !== void 0 ? [`${compactCount(totals.inputTokens)} in`] : [],
+    ...totals.outputTokens !== void 0 ? [`${compactCount(totals.outputTokens)} out`] : [],
     ...totals.cachedInputTokens !== void 0 ? [`${compactCount(totals.cachedInputTokens)} cached`] : [],
-    ...Object.entries(totals.reportedCost ?? {}).map(([currency, amount]) => formatCost(currency, amount)),
-    ...unknown && !Object.keys(totals.reportedCost ?? {}).length ? ["cost unknown"] : []
+    ...Object.entries(totals.reportedCost ?? {}).map(([currency, amount]) => formatCost(currency, amount))
   ];
 }
 function taskUsageText(usage) {
   return [
-    ...usageMeasures(usage.totals, true),
-    ...usage.attempt !== void 0 ? [usage.contextFill ? `${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}% ctx` : "ctx unknown"] : [],
-    usage.wallTimeMs !== void 0 ? `${Math.floor(usage.wallTimeMs / 1e3)}s` : "time unknown"
+    ...usageMeasures(usage.totals),
+    ...usage.attempt !== void 0 ? [usage.contextFill ? `ctx ${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}%` : "ctx unknown"] : []
   ].join(" \xB7 ");
 }
+function assignmentFlagText(row) {
+  return `${row.assignmentFlag} \u2014 ${row.assignmentConsequence}`;
+}
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
@@ -2694,7 +2706,7 @@ async function handleStatus(subArgs, injectedApi) {
       emitJson(session, outputPath);
       return;
     }
-    printOneSession(sessionId, session.meta, session.plan);
+    printOneSession(sessionId, session.meta, session.plan, await assignmentScope(api));
   } else {
     const sessions = await api.getSessions(workspace);
     if (asJson) {
@@ -2733,7 +2745,20 @@ function emitJson(payload, outputPath) {
     process.exit(1);
   }
 }
-function printOneSession(sessionId, meta, plan) {
+async function assignmentScope(api) {
+  try {
+    const [runners2, settings, models] = await Promise.all([api.getRunners(), api.getSettings(), api.getModels()]);
+    if (!Array.isArray(runners2.runners) || runners2.runners.length === 0) return void 0;
+    return {
+      enabledRunners: runners2.runners.filter((r) => r.enabled).map((r) => r.id),
+      allowlist: settings.modelAllowlist ?? {},
+      models: models.modelsByRunner ?? {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function printOneSession(sessionId, meta, plan, runnerScope) {
   const allTasks = allTasksOf(plan);
   const everyTask = (0, import_core15.flattenTasks)(allTasks);
   const blocked = (0, import_core15.blockingFailures)(everyTask.map((t) => ({ ...t, subtasks: [], dependencies: t.dependencies ?? [] })));
@@ -2742,20 +2767,23 @@ function printOneSession(sessionId, meta, plan) {
   console.log(`Goal:     ${meta.goal}`);
   console.log(`Runner:   ${(meta.runners || []).join(", ")}  |  Status: ${meta.status}`);
   console.log(`Phase:    ${plan?.phase || "unknown"}  |  Created: ${meta.createdAt}`);
+  const isolation = isolationOfPlan(plan);
+  if (isolation) console.log(`Base:     ${handoffBase(isolation.handoff, 8)}`);
   console.log(`Tasks:    ${everyTask.length} total  |  ${count("completed")} done  |  ${count("failed")} failed  |  ${count("in_progress")} running  |  ${count("blocked")} blocked  |  ${count("skipped")} skipped
 `);
   const usage = (0, import_core15.planUsage)(allTasks);
   if (usage.attempts) console.log(`Tasks total: ${taskUsageText(usage)}`);
   const record = servedApprovalRecord(plan);
-  const approval = (row, ref) => row.waitsForApproval ? `${row.waitsForApproval}: \`ordewell run-task ${ref}\` starts it, or \`ordewell run\` runs the plan` : null;
+  const approval = (row, ref) => row.waitsForApproval ? `${row.waitsForApproval}: \`ordewell force-start ${ref}\` approves it, \`ordewell run\` approves all` : null;
   for (const t of allTasks) {
     const icon = iconFor(blocked.has(t.id) ? "blocked" : t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
     console.log(`  ${(0, import_core15.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
-    const row = (0, import_core15.taskRowView)({ ...t, dependencies: t.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(t, record) }, { tasks: allTasks });
+    const row = (0, import_core15.taskRowView)({ ...t, dependencies: t.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(t, record) }, { tasks: allTasks, runnerScope });
     const waiting = approval(row, (0, import_core15.taskOrderLabel)(t));
     if (waiting) console.log(`      ${waiting}`);
+    if (row.assignmentFlag) console.log(`      \u26A0 ${assignmentFlagText(row)}`);
     if (row.blockedBy) console.log(`      ${(0, import_core15.blockedByLabel)(row.blockedBy)}`);
     if (row.status === "skipped") console.log(`      ${(0, import_core15.skippedLabel)(row.skipReason)}`);
     if (row.usage) console.log(`      ${taskUsageText(row.usage)}`);
@@ -2764,9 +2792,10 @@ function printOneSession(sessionId, meta, plan) {
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
       console.log(`    ${(0, import_core15.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
-      const subRow = (0, import_core15.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(sub, record) }, { parent: t, tasks: allTasks });
+      const subRow = (0, import_core15.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(sub, record) }, { parent: t, tasks: allTasks, runnerScope });
       const subWaiting = approval(subRow, (0, import_core15.taskOrderLabel)(sub, t));
       if (subWaiting) console.log(`        ${subWaiting}`);
+      if (subRow.assignmentFlag) console.log(`        \u26A0 ${assignmentFlagText(subRow)}`);
       if (subRow.blockedBy) console.log(`        ${(0, import_core15.blockedByLabel)(subRow.blockedBy)}`);
       if (subRow.status === "skipped") console.log(`        ${(0, import_core15.skippedLabel)(subRow.skipReason)}`);
       if (subRow.usage) console.log(`        ${taskUsageText(subRow.usage)}`);
@@ -3263,8 +3292,8 @@ function makeHandler(action, command = action) {
       async (api, sessionId, taskId) => {
         if (PASSES_GATE.has(action)) await confirmPastGate(subArgs, api, sessionId, taskId, confirm2);
         try {
-          await api.taskControl(sessionId, taskId, action);
-          console.log(PAST_TENSE[action]);
+          const { queued } = await api.taskControl(sessionId, taskId, action);
+          console.log(queued ?? PAST_TENSE[action]);
         } catch (err) {
           console.error(`Failed to ${action} task: ${err.message}`);
           process.exit(1);
@@ -3561,6 +3590,17 @@ async function handleRewind(subArgs, injectedApi) {
   console.log("\nThe message you rewound to, to resend or edit:\n");
   console.log(fork.rewoundMessage);
 }
+async function handleResend(subArgs, injectedApi) {
+  if (positionals(subArgs)[0] !== "cancel") fail("Usage: ordewell resend cancel [--session-id <id>] [--workspace /path]");
+  const { api, sessionId } = await adopted(subArgs, injectedApi);
+  let cancelled;
+  try {
+    ({ cancelled } = await api.cancelPlannerResend(sessionId));
+  } catch (err) {
+    fail(`Failed to cancel the resend: ${err.message}`);
+  }
+  console.log(cancelled ? "Resend cancelled: what waits goes with your next message." : "Nothing waits on the planner's usage limit to be sent at a reset.");
+}
 
 // src/tui/transcript.ts
 var import_core22 = require("@ordewell/core");
@@ -3594,7 +3634,7 @@ var HANDOFF_ACTIONS = [
   { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches, keep this branch" }
 ];
 function handoffActions(handoff) {
-  if (!isRepoGroup(handoff)) return HANDOFF_ACTIONS;
+  if (!(0, import_core10.isRepoGroup)(handoff)) return HANDOFF_ACTIONS;
   return [
     { id: "review", label: "Review diff", hint: "each repository's branch against the commit it forked from" },
     { id: "merge", label: "Merge all", hint: "every repository's branch into what you have checked out there (asks first)" },
@@ -3619,7 +3659,7 @@ function handoffCommand(state, arg) {
 }
 function handoffArrived(state, handoff) {
   const landed = handoff.landed.length;
-  const where = isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : "";
+  const where = (0, import_core10.isRepoGroup)(handoff) ? ` in ${reposOf2(handoff)}` : "";
   const branch = handoffBranch(handoff);
   const tasks = `${landed} task${landed === 1 ? "" : "s"} landed`;
   const received = { ...state, handoff };
@@ -3654,8 +3694,8 @@ function runHandoffAction(state, id) {
             ...state,
             overlay: {
               kind: "confirm",
-              title: isRepoGroup(handoff) ? "Merge what has landed into your branches?" : "Merge what has landed into your branch?",
-              message: `Merge ${handoffBranch(handoff)} as it stands now into whatever ${isRepoGroup(handoff) ? `each of ${reposWithWork(handoff).join(", ")} has` : "you have"} checked out. The run goes on: tasks waiting for Merge all start once it has merged, and later tasks land on the same branch for the next Merge all. A merge that conflicts is aborted, and your ${isRepoGroup(handoff) ? "trees stay" : "tree stays"} as ${isRepoGroup(handoff) ? "they were" : "it was"}.${repairedNotice(handoff)}`,
+              title: (0, import_core10.isRepoGroup)(handoff) ? "Merge what has landed into your branches?" : "Merge what has landed into your branch?",
+              message: `Merge ${handoffBranch(handoff)} as it stands now into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} The run goes on: tasks waiting for Merge all start once it has merged, and later tasks land on the same branch for the next Merge all. A merge that conflicts is aborted, and your ${(0, import_core10.isRepoGroup)(handoff) ? "trees stay" : "tree stays"} as ${(0, import_core10.isRepoGroup)(handoff) ? "they were" : "it was"}.${repairedNotice(handoff)}`,
               action: { kind: "merge-run" }
             }
           },
@@ -3665,15 +3705,15 @@ function runHandoffAction(state, id) {
       return {
         state: {
           ...state,
-          overlay: isRepoGroup(handoff) ? {
+          overlay: (0, import_core10.isRepoGroup)(handoff) ? {
             kind: "confirm",
             title: "Merge all into your branches?",
-            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. 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 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} 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 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           } : {
             kind: "confirm",
             title: "Merge into your branch?",
-            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. 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 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} 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 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           }
         },
@@ -3686,7 +3726,7 @@ function runHandoffAction(state, id) {
           overlay: {
             kind: "confirm",
             title: "Discard this run?",
-            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status: mark one not done if you did not keep its work.`,
+            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${(0, import_core10.isRepoGroup)(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status: mark one not done if you did not keep its work.`,
             action: { kind: "discard-run" }
           }
         },
@@ -3704,7 +3744,7 @@ function confirmedHandoff(state, kind) {
     type: "isolationMerge",
     sessionId,
     branch: handoffBranch(handoff),
-    ...isRepoGroup(handoff) ? { group: true } : {},
+    ...(0, import_core10.isRepoGroup)(handoff) ? { group: true } : {},
     ...repaired.length > 0 ? { repaired } : {},
     ...midRun(state) ? { midRun: true } : {}
   } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
@@ -3789,7 +3829,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
   const handoff = isolationOfPlan(plan)?.handoff;
   if (!handoff) fail("This session has no isolated run to hand off.");
   const branch = handoffBranch(handoff);
-  const group = isRepoGroup(handoff);
+  const group = (0, import_core10.isRepoGroup)(handoff);
   if (group) for (const line of repoResultLines(handoff)) console.error(line);
   const asked = hasFlag(subArgs, "--yes");
   const confirmed = async (question) => {
@@ -3810,7 +3850,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = 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; once a finished run has merged everything, its worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once a finished run has merged everything, its worktrees and branches are removed.`) + repairedNotice(handoff));
+      await confirmed((group ? `Merge ${branch} into ${(0, import_core10.mergeTarget)(handoff)}? Nothing is merged unless every repository can take it${(0, import_core10.checkoutRule)(handoff) ? " and is on that branch" : ""}; once a finished run has merged everything, its worktrees and branches are removed.` : `Merge ${branch} into ${(0, import_core10.mergeTarget)(handoff)}?${(0, import_core10.checkoutRule)(handoff)} Once a finished run has merged everything, its 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);
@@ -4426,6 +4466,7 @@ function initialState(overrides = {}) {
     workspace: process.cwd(),
     handoff: null,
     runMerge: null,
+    plannerResend: null,
     overlay: null,
     pendingApprovals: [],
     queuedPrompts: import_core28.EMPTY_HOLD,
@@ -4666,6 +4707,7 @@ var SLASH_COMMANDS = [
   { name: "approve", usage: "/approve", description: "Approve the drafted plan", category: "planning" },
   { name: "run", usage: "/run", description: "Execute the approved plan", category: "planning" },
   { name: "stop", usage: "/stop", description: "Stop the planner or the running execution, whichever is active", category: "planning" },
+  { name: "resend", usage: "/resend cancel", description: "Keep what waits on the planner's usage limit from being sent at the reset: it goes with your next message", category: "planning" },
   { name: "handoff", usage: "/handoff [review|merge|discard|cleanup]", description: "Land an isolated run's branch: review it, merge it into yours, or discard it", category: "planning" },
   // Tasks
   { name: "add-task", usage: "/add-task <title>", description: "Add a task to the current plan", category: "tasks" },
@@ -4675,7 +4717,7 @@ var SLASH_COMMANDS = [
   { name: "skip", usage: "/skip <id>", description: "Skip a task", category: "tasks" },
   { name: "retry", usage: "/retry <id>", description: "Re-run a failed task", category: "tasks" },
   { name: "cancel", usage: "/cancel <id>", description: "Kill a running task", category: "tasks" },
-  { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
+  { name: "force-start", usage: "/force-start <id>", description: "Approve a task and start it now, or once its dependencies finish", category: "tasks" },
   { name: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", category: "tasks" },
   { name: "open", usage: "/open <id>", description: "Open a task's view: its log, and the keys that answer its checkpoint or tool request", category: "tasks" },
   { name: "checkpoint", usage: "/checkpoint <id> approve|reject [reason]", description: "Answer the checkpoint a task waits at: approve lets it go on, reject tells it why not", category: "tasks" },
@@ -4841,6 +4883,15 @@ function refillPicker(state, kinds) {
   const hint = overlay.picker.action.kind === "set-model" ? providerErrorHint(state) : overlay.picker.hint;
   return { ...state, overlay: { kind: "picker", picker: { ...overlay.picker, items, hint, index: 0 } } };
 }
+function reseedRunnerChoice(before, after) {
+  const overlay = after.overlay;
+  if (overlay?.kind !== "picker" || overlay.picker.action.kind !== "set-runners") return after;
+  const enabledIds = (state) => state.runners.filter((r) => r.enabled).map((r) => r.id);
+  const shown = enabledIds(before);
+  const untouched = overlay.picker.chosen.length === shown.length && shown.every((id) => overlay.picker.chosen.includes(id));
+  const picker2 = { ...overlay.picker, items: pickerItemsFor(after, overlay.picker.action) };
+  return { ...after, overlay: { kind: "picker", picker: untouched ? { ...picker2, chosen: enabledIds(after) } : picker2 } };
+}
 function modelDetail(m) {
   return [m.provider, m.pricing].filter(Boolean).join(" \xB7 ") || void 0;
 }
@@ -4993,15 +5044,17 @@ function plannerItems(state) {
     const runner = (0, import_core31.runnerForProvider)(id);
     usability[runner] = installed.has(runner) ? { usable: true } : { usable: false, reason: "CLI not installed or not on PATH" };
   }
-  const entries = (0, import_core31.plannerBackendEntries)(usability, state.configuredProviders);
-  const items = entries.map((entry) => ({
+  const offered2 = (0, import_core31.plannerBackendEntries)(usability, state.configuredProviders).filter((entry) => entry.usable);
+  if (offered2.length === 0) {
+    return [{ id: "", label: "No planner available", detail: "install a coding agent or add a key with /key", disabled: true }];
+  }
+  const items = offered2.map((entry) => ({
     id: entry.id,
     label: entry.label,
     detail: entry.reason,
-    selected: state.plannerProvider === entry.id,
-    disabled: !entry.usable
+    selected: state.plannerProvider === entry.id
   }));
-  return entries.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
+  return offered2.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
 }
 
 // src/version.ts
@@ -5037,7 +5090,13 @@ var PLAN_KEYS = {
   deps: { keys: "D", meaning: "pick the tasks it depends on", group: "Assign" },
   skills: { keys: "K", meaning: "pick the skills it loads", group: "Assign" },
   ops: { keys: "O", meaning: "switch between a change and an ops task", group: "Assign" },
-  start: { keys: "f", meaning: "start the task now", group: "Run", hint: "f start" },
+  start: {
+    keys: "f",
+    meaning: "start the task, approving it if it waits for you; it starts once its dependencies finish",
+    group: "Run",
+    // Added after the plan was approved, it waits for this key; the row says the same.
+    hint: (task) => task && (0, import_core32.taskRowView)(task).waitsForApproval ? "f approve" : "f start"
+  },
   runPlan: { keys: "E", meaning: "run the whole plan", group: "Run", hint: "E run plan" },
   stop: { keys: "S", meaning: "stop the run", group: "Run", hint: "S stop" },
   cancel: {
@@ -5293,11 +5352,18 @@ function chatLayout(state, rows, cols) {
   const bubbles = tv ? taskQueuedRows(state, cols) : queuedPromptRows(state, cols);
   const content = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
   const taskHeader = tv ? taskHeaderLines(state, tv, cols) : [];
-  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks2, cols) : tokenRow(blocks2, cols);
+  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks2, cols) : [...plannerResendRow(state, cols), ...tokenRow(blocks2, cols)];
   const footer = usage.slice(0, Math.max(1, rows - taskHeader.length - 1));
   const space = Math.max(0, rows - taskHeader.length - footer.length);
   return { lines: content, header: taskHeader, footer, anchor: content.length > space ? "bottom" : "top", maxScroll: Math.max(0, content.length - space) };
 }
+function plannerResendRow(state, cols) {
+  const { plannerResend } = state;
+  const at = plannerResend ? new Date(plannerResend.at) : null;
+  if (!plannerResend || !at || Number.isNaN(at.getTime())) return [];
+  const whose = plannerResend.runner ? `${plannerResend.runner}'s` : "the planner's";
+  return [style.yellow(truncate(`\u23F8 Resending at ${(0, import_core34.resumeTime)(at)}, once ${whose} usage limit resets \xB7 /resend cancel keeps it for your next message`, cols))];
+}
 var tokenRow = (blocks2, cols) => {
   const line = tokenLine(blocks2, cols);
   return line ? [line] : [];
@@ -5305,15 +5371,13 @@ var tokenRow = (blocks2, cols) => {
 function taskUsageFooter(state, tv, blocks2, cols) {
   const task = findTask(state.tasks, tv.taskId);
   const reported = task?.attemptUsage ?? [];
+  if (!task || reported.length === 0) return tokenRow(blocks2, cols);
   const onScreen = tv.attempt > 0 ? reported.find((a) => a.attempt === tv.attempt) : reported.at(-1);
-  if (!task || !onScreen) return tokenRow(blocks2, cols);
-  const usage = (0, import_core34.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
-  if (!usage) return tokenRow(blocks2, cols);
-  const models = usage.byModel ?? [];
-  return [
-    style.grey(truncate(taskUsageText(usage), cols)),
-    ...models.length > 1 ? models.map((m) => style.grey(truncate(`${sanitize(m.model ?? "unattributed")}: ${usageMeasures(m.totals, true).join(" \xB7 ")}`, cols))) : []
-  ];
+  const spend = (0, import_core34.taskUsageSummary)(task);
+  const total = taskUsageText({ ...spend, attempt: reported.at(-1)?.attempt ?? 0 });
+  if (onScreen === reported.at(-1)) return [style.grey(truncate(total, cols))];
+  const own = onScreen ? [style.grey(truncate(`attempt ${onScreen.attempt}: ${taskUsageText({ totals: onScreen.totals, contextFill: (0, import_core34.plannerContextFill)(onScreen), attempt: onScreen.attempt })}`, cols))] : tokenRow(blocks2, cols);
+  return [...own, style.grey(truncate(`task total: ${total}`, cols))];
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
@@ -5556,9 +5620,17 @@ function planScrollExtent(state) {
   }
   return planLayout(state, bodyRows(state), cols);
 }
+function modelsByRunnerOf(models) {
+  const out = {};
+  for (const m of models) {
+    for (const runner of m.runners ?? []) (out[runner] ??= []).push({ modelId: m.id, modelLabel: m.label, variants: [] });
+  }
+  return out;
+}
 function taskLines(state, planRow, index, cols) {
   const { task, parent } = planRow;
-  const row = (0, import_core34.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task) });
+  const runnerScope = state.runners.length > 0 ? { enabledRunners: state.runners.filter((r) => r.enabled).map((r) => r.id), allowlist: state.allowlist, models: modelsByRunnerOf(state.models) } : void 0;
+  const row = (0, import_core34.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task), runnerScope });
   const selected = state.focus === "plan" && index === state.selectedTask;
   const expanded = state.expandedTaskId === task.id;
   const rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
@@ -5580,8 +5652,7 @@ function taskLines(state, planRow, index, cols) {
     const prefix = lineIndex === 0 ? head : continuation;
     return prefix + (selected ? style.bold(line) : line);
   });
-  const reported = [...new Set((row.usage?.byModel ?? []).flatMap((m) => m.model ? [sanitize(m.model)] : []))];
-  const model = reported.length ? reported.join(", ") : task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
+  const model = task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
   const effort = task.type === "ai" ? `effort: ${task.assignedModel?.thinkingEffort ?? "default"}` : "";
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
@@ -5597,36 +5668,39 @@ function taskLines(state, planRow, index, cols) {
   if (row.conflict) {
     const where = row.conflict.repo ? ` in ${row.conflict.repo}` : "";
     const files = row.conflict.files ? ` (${row.conflict.files})` : "";
-    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files}: its work is kept on its own branch`, cols)));
+    lines.push(...statusLines(style.red, "\u26A0", `merge conflict${where}${files}: its work is kept on its own branch`, cols, bodyPad));
   }
   if (row.repairing) {
     const files = row.repairing.files ? ` in ${row.repairing.files}` : "";
     const attempt = row.repairing.attempt ? ` (attempt ${row.repairing.attempt.attempt}/${row.repairing.attempt.limit})` : "";
-    lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
+    lines.push(...statusLines(style.yellow, "\u21BB", `repairing conflict${files}${attempt}`, cols, bodyPad));
   }
   if (row.mergeGate) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all: ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `waits for Merge all: ${row.mergeGate.join(", ")} not merged into your branch yet`, cols, bodyPad));
+  }
+  if (row.assignmentFlag) {
+    lines.push(...statusLines(style.yellow, "\u26A0", assignmentFlagText(row), cols, bodyPad));
   }
   if (row.waitsForApproval) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.waitsForApproval)}: added after you approved the plan; f starts it, or /run runs the plan`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `${inRow(row.waitsForApproval)} \xB7 f approves it \xB7 /run approves all`, cols, bodyPad));
   }
   if (row.blockedBy) {
-    lines.push(style.red(truncate(`${bodyPad}\u2298 ${inRow((0, import_core34.blockedByLabel)(row.blockedBy))}: runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols)));
+    lines.push(...statusLines(style.red, "\u2298", `${inRow((0, import_core34.blockedByLabel)(row.blockedBy))}: runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols, bodyPad));
   }
   if (row.status === "skipped") {
-    lines.push(style.grey(truncate(`${bodyPad}\xBB ${inRow((0, import_core34.skippedLabel)(row.skipReason))}: nothing of it landed; m done lands its kept work`, cols)));
+    lines.push(...statusLines(style.grey, "\xBB", `${inRow((0, import_core34.skippedLabel)(row.skipReason))}: nothing of it landed; m done lands its kept work`, cols, bodyPad));
   }
   const resumable = row.actions.includes("resume-now");
   if (row.resumes) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.resumes)}, once the usage limit resets: ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `${inRow(row.resumes)}, once the usage limit resets: ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols, bodyPad));
   } else if (resumable) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for the usage limit to reset: r resume now`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", "waits for the usage limit to reset: r resume now", cols, bodyPad));
   }
   if (row.opsChangedFiles) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files: check them, then m done or /retry`, cols)));
+    lines.push(...statusLines(style.yellow, "\u26A0", "an ops task changed tracked files: check them, then m done or /retry", cols, bodyPad));
   }
   if (row.repaired?.landed) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${row.repaired.files}`, cols)));
+    lines.push(...statusLines(style.grey, "\u21BB", `landed after repairing conflict in ${row.repaired.files}`, cols, bodyPad));
   }
   let editorLine;
   if (expanded) {
@@ -5668,6 +5742,11 @@ function taskLines(state, planRow, index, cols) {
   }
   return { lines, editorLine };
 }
+function statusLines(paint, glyph, text, cols, pad2) {
+  const lead = `${pad2}${glyph} `;
+  const room = Math.max(1, cols - width(lead));
+  return wrap(text, room).map((line, i) => paint(`${i === 0 ? lead : " ".repeat(width(lead))}${line}`));
+}
 function taskText(label, text, cols, pad2 = "    ") {
   const room = Math.max(1, cols - width(pad2));
   return [
@@ -6055,7 +6134,7 @@ function renderHandoff(state, overlay, rows, cols) {
     const caret = active ? style.brand("\u276F") : " ";
     return `${caret} ${active ? style.bold(action.label) : action.label}${style.grey(`: ${action.hint}`)}`;
   });
-  const perRepo = isRepoGroup(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
+  const perRepo = (0, import_core10.isRepoGroup)(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
   return frame(
     "Run handoff",
     [
@@ -7591,6 +7670,8 @@ function runCommand(state, { name, args }) {
       return withIdlePlanner(state, (sessionId) => step(state, [{ type: "forkConversation", sessionId }]));
     case "rewind":
       return rewind(state, args[0]);
+    case "resend":
+      return args[0] === "cancel" ? withSession(state, (sessionId) => step(state, [{ type: "cancelPlannerResend", sessionId }])) : step(say(state, "system", "A planner turn that hits the planner's usage limit is sent again at the reset: /resend cancel keeps it for your next message instead."));
     case "compact":
       return withIdlePlanner(
         state,
@@ -7864,7 +7945,7 @@ function runners(state, args) {
       multi: true,
       chosen: state.runners.filter((r) => r.enabled).map((r) => r.id)
     })
-  } });
+  } }, [{ type: "loadRunners" }]);
 }
 function setMaxParallel(state, arg) {
   if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once: /parallel <n> changes it.`));
@@ -8358,13 +8439,15 @@ function reduceAction(state, action) {
         focus: "chat",
         editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
       });
+    case "sharedSettingsChanged":
+      return step(state, [{ type: "loadScope" }]);
     case "runnersLoaded":
-      return step(refreshStepper(refillPicker({
+      return step(refreshStepper(reseedRunnerChoice(state, refillPicker({
         ...state,
         runners: action.runners,
         runnersKnown: true,
         orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
-      }, ["set-task-runner"])));
+      }, ["set-task-runner"]))));
     case "failed": {
       if (!action.turn) return step(say(taskLogAbandoned(state), "error", action.message));
       if (state.forceSendPending) {
@@ -8411,6 +8494,7 @@ function showPlan(state, plan) {
   const expandedTaskId = state.expandedTaskId && findTask(tasks, state.expandedTaskId) ? state.expandedTaskId : null;
   const next = {
     ...folded,
+    plannerResend: plannerResendOf(plan),
     expandedTaskId,
     taskEditor: expandedTaskId !== null ? state.taskEditor : null
   };
@@ -8420,6 +8504,11 @@ function showPlan(state, plan) {
     focus: tasks.length === 0 ? "chat" : state.focus
   });
 }
+function plannerResendOf(plan) {
+  const saved = plan?.plannerResend;
+  if (typeof saved?.at !== "string") return null;
+  return { ...typeof saved.runner === "string" ? { runner: saved.runner } : {}, at: saved.at };
+}
 function runStatus(state, tasks) {
   if (tasks.some(import_core28.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.runMerge?.paused) return "executing";
@@ -9359,6 +9448,12 @@ async function perform(effect, deps) {
     // user gets to read — no separate notice to repeat it. The daemon also
     // broadcast that summary; `redrawn` keeps a late socket copy of it from
     // landing as a second, spoken turn.
+    case "cancelPlannerResend": {
+      const { cancelled } = await api.cancelPlannerResend(effect.sessionId);
+      dispatch({ type: "notice", message: cancelled ? "Resend cancelled: what waits goes with your next message." : "Nothing waits on the planner's usage limit to be sent at a reset." });
+      await refreshPlan(deps, effect.sessionId);
+      return;
+    }
     case "compactConversation": {
       const { plan } = await api.compactConversation(effect.sessionId);
       const inbound = inboundFor(deps.api, deps.dispatch, effect.sessionId);
@@ -9421,6 +9516,12 @@ async function perform(effect, deps) {
       } catch {
       }
       return;
+    case "loadRunners":
+      await loadRunners(deps);
+      return;
+    case "loadScope":
+      await Promise.all([loadRunners(deps), loadSettings(deps)]);
+      return;
     case "refresh":
       await Promise.all([loadRunners(deps), loadSettings(deps), loadModels(deps)]);
       if (effect.announce) dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
@@ -9984,10 +10085,12 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       if (terminal) app.dispatch({ type: "resize", ...terminal.size() });
     }
   });
+  const watchingSettings = settings.watch(() => app.dispatch({ type: "sharedSettingsChanged" }));
   const { rows, cols } = terminal.size();
   app.dispatch({ type: "resize", rows, cols });
   app.start();
   function shutdown(code) {
+    watchingSettings.dispose();
     terminal?.close();
     if (owned) stopDaemon(port).catch(() => {
     });
@@ -10057,6 +10160,7 @@ var COMMANDS = {
   fork: handleFork,
   compact: handleCompact,
   rewind: handleRewind,
+  resend: handleResend,
   handoff: handleHandoff,
   tui: handleTui
 };

package/package.json

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