@ordewell/cli 0.10.10 → 0.10.12

package/README.md

@@ -19,17 +19,21 @@ on Windows, run the terminal UI under WSL.
 
 Run `ordewell` in your project to open the terminal UI: the conversation on the
 left, the live plan on the right. The first run lets you pick a planner and runners
-with `/planner` (Harness › Model › Effort, saved at the end) and `/runners`, and no API key is needed if you plan with a coding
+with `/planner` (Harness › Model › Effort, each step saved as you go) and `/runners`, and no API key is needed if you plan with a coding
 agent you already use.
 The welcome screen says it plainly: nothing runs until you approve the plan (unless autorun is on).
 
 `/settings` walks autonomy, supervisor, merge automatically, autorun and parallel
-in one panel and saves only what you changed. `/model` and `/planner-effort` set
-the planner model and effort on their own. Press `?` in the plan pane for the
-full key sheet; the footer shows only the keys that apply to the selected task.
-
-Every command in the terminal UI is also a subcommand, except `/settings`, whose
-settings each have their own:
+in one panel and saves only what you changed. `/planner` walks harness, model and
+effort in one flow, so there is no separate model or effort command. Press `?` in
+the plan pane for the full key sheet; the footer shows only the keys that apply
+to the selected task.
+
+Every command in the terminal UI is also a subcommand, except `/settings`: it is
+a panel over headless commands that remain for scripts (`ordewell auto`,
+`supervisor`, `automerge`, `autorun` and `parallel`). `/planner` has its own
+`ordewell planner`, and its model and effort steps are `ordewell model` and
+`ordewell planner-effort`.
 
 ```bash
 export AI_PROVIDER=claude-code      # plan with Claude Code, Codex or OpenCode

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core52 = require("@ordewell/core");
+var import_core51 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -129,9 +129,10 @@ function printHelp() {
   console.log(`
 Ordewell: task orchestration for coding agents
 
-Run "ordewell" with no arguments for the TUI. Every command below has a TUI
-slash command of the same name, where each one opens a picker instead of taking
-an id.
+Run "ordewell" with no arguments for the TUI. Where a command has a slash
+command, both take the same name. The headless run-setting and planner-step
+commands marked "(headless)" are set in /settings and /planner in the TUI and
+VS Code.
 
 Planning:
   ordewell                        Full-screen terminal UI (everything the VS Code extension does)
@@ -172,17 +173,17 @@ Per-task assignment (omit the value to list the options):
 
 Planner, models and runners:
   ordewell planner [<provider>]   Choose who plans: an API provider or a coding agent (no API key)
-  ordewell model [set <id>]       Show or set the planner model (applies without a restart)
-  ordewell planner-effort [lvl]   Thinking effort for a coding-agent planner
+  ordewell model [set <id>]       (headless) Show or set the planner model; /planner covers it in the TUI and VS Code
+  ordewell planner-effort [lvl]   (headless) Thinking effort for a coding-agent planner; /planner covers it
   ordewell key [set <p> <key>]    Show which providers have a key, or store one
   ordewell runners [<id> on|off]  Enable or disable runners (${runnerIdList()})
   ordewell allowlist set|clear|show       Limit which models a runner may use
-  ordewell auto [full|guarded]    Autonomy level for new plans: Full or Guarded
-  ordewell supervisor [off|watch|act]  Whether the planner watches or acts on your runs (default watch);
-                                  also: supervisor retries <n>, supervisor reads <n>
-  ordewell automerge [on|off]     Merge into your branch by itself at merge gates and at the end of a run (default off)
-  ordewell autorun [on|off]       Start each plan the planner submits, without review (default off)
-  ordewell parallel [<n>]         How many AI tasks run at once (default 5; applies to a live run)
+  ordewell auto [full|guarded]    (headless) Autonomy level for new plans, Full or Guarded; /settings covers it
+  ordewell supervisor [off|watch|act]  (headless) Whether the planner watches or acts on your runs;
+                                  also: supervisor retries <n>, supervisor reads <n>; /settings covers it
+  ordewell automerge [on|off]     (headless) Merge at merge gates and at the end of a run; /settings covers it
+  ordewell autorun [on|off]       (headless) Start each plan the planner submits, without review; /settings covers it
+  ordewell parallel [<n>]         (headless) How many AI tasks run at once, a live run included; /settings covers it
   ordewell refresh                Re-discover runners and model catalogs
   ordewell models                 List every provider's catalog (works without a server)
 
@@ -4672,7 +4673,7 @@ ${namedOf(tasks, task)} is ${task.ops ? "an ops task: it runs in your checkout o
 }
 
 // src/tui/index.ts
-var import_core51 = require("@ordewell/core");
+var import_core50 = require("@ordewell/core");
 
 // src/tui/slash.ts
 var import_core30 = require("@ordewell/core");
@@ -4705,16 +4706,9 @@ var SLASH_COMMANDS = [
   { name: "task-ops", usage: "/task-ops <id> [on|off]", description: "Choose between an ops task (runs in your checkout once its dependencies are merged) and a change task", category: "tasks" },
   // Models & providers
   { name: "planner", usage: "/planner [<provider>]", description: "Pick the planner: harness, model and effort in one go", category: "models" },
-  { name: "model", usage: "/model [set <id>]", description: "Show or set the planner model", category: "models" },
-  { name: "planner-effort", usage: "/planner-effort [<level>]", description: "Thinking effort for a coding-agent planner", category: "models" },
   { name: "key", usage: "/key [set <provider> <key>]", description: "Configure API provider keys", category: "models" },
   { 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 (${runnerIdList()})`, category: "models" },
-  { name: "auto", usage: "/auto [full|guarded]", description: "Autonomy level for new plans: Full or Guarded", category: "models" },
-  { name: "supervisor", usage: "/supervisor [off|watch|act] \xB7 retries <n> \xB7 reads <n>", description: "Whether the planner watches or acts on your runs, now and from then on", category: "models" },
-  { name: "automerge", usage: "/automerge [on|off]", description: "Merge into your branch by itself at merge gates and at the end of a run", category: "models" },
-  { name: "autorun", usage: "/autorun [on|off]", description: "Start each plan the planner submits, without review", category: "models" },
-  { name: "parallel", usage: "/parallel [<n>]", description: "How many AI tasks run at once (applies to a live run)", category: "models" },
   { name: "settings", usage: "/settings", description: "Run settings: autonomy, supervisor, merging, autorun, parallel tasks", category: "models" },
   { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
   // Sessions
@@ -4855,8 +4849,7 @@ function refillPicker(state, kinds) {
   const overlay = state.overlay;
   if (overlay?.kind !== "picker" || !kinds.includes(overlay.picker.action.kind)) return state;
   const items = pickerItemsFor(state, overlay.picker.action);
-  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 } } };
+  return { ...state, overlay: { kind: "picker", picker: { ...overlay.picker, items, index: 0 } } };
 }
 function reseedRunnerChoice(before, after) {
   const overlay = after.overlay;
@@ -4870,16 +4863,20 @@ function reseedRunnerChoice(before, after) {
 function modelDetail(m) {
   return [m.provider, m.pricing].filter(Boolean).join(" \xB7 ") || void 0;
 }
-function providerErrorHint(state) {
-  const failed = Object.keys(state.providerErrors ?? {});
-  if (failed.length === 0) return void 0;
-  const names = failed.map((p) => (0, import_core31.getProviderMeta)(p)?.label ?? p);
-  return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")}. Showing working providers only.`;
-}
 function plannerModelItems(state, provider, selectedId) {
   const runner = (0, import_core31.runnerForProvider)(provider);
   if (!runner) {
-    return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m), selected: m.id === selectedId }));
+    const failed = Object.entries(state.providerErrors ?? {});
+    const unavailable = failed.length === 0 ? [] : [{
+      id: "",
+      label: "Some providers are unavailable",
+      detail: `\u26A0 ${failed.map(([id]) => (0, import_core31.getProviderMeta)(id)?.label ?? id).join(", ")}: key or fetch failed`,
+      disabled: true
+    }];
+    return [
+      ...unavailable,
+      ...state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m), selected: m.id === selectedId }))
+    ];
   }
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -4902,7 +4899,7 @@ function plannerEffortItems(state, provider, modelId, selectedEffort) {
   }
   const model = plannerHarnessModel(state, provider, modelId);
   if (!model) {
-    return [{ id: "", label: "No planner model selected", detail: "pick one with /model", disabled: true }];
+    return [{ id: "", label: "No planner model selected", detail: "pick one with /planner", disabled: true }];
   }
   const variants = model.variants ?? [];
   if (variants.length === 0) {
@@ -4914,12 +4911,6 @@ function plannerEffortItems(state, provider, modelId, selectedEffort) {
   ];
 }
 function pickerItemsFor(state, action) {
-  if (action.kind === "set-model") {
-    return plannerModelItems(state, state.plannerProvider, state.orchestratorModel);
-  }
-  if (action.kind === "set-planner-effort") {
-    return plannerEffortItems(state, state.plannerProvider, state.orchestratorModel, state.plannerEffort);
-  }
   if (action.kind === "rewind") {
     if (state.rewindTargets === null) return [];
     if (state.rewindTargets.length === 0) {
@@ -5696,7 +5687,7 @@ function taskLines(state, planRow, index, cols) {
       lines.push(...taskText("Forced", `Started before the work of ${row.forcedPastGate.join(", ")} was merged into your branch.`, cols, bodyPad));
     }
     if (row.autonomous) {
-      lines.push(...taskText("Autonomy", "Runs without permission prompts (Full). Change the level with /auto.", cols, bodyPad));
+      lines.push(...taskText("Autonomy", "Runs without permission prompts (Full). Change the level with /settings.", cols, bodyPad));
     }
     const editableSeed = task.prompt ?? task.description ?? task.title;
     if (task.description && task.description !== task.title && task.description !== editableSeed) {
@@ -6276,10 +6267,10 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core49 = require("@ordewell/core");
+var import_core48 = require("@ordewell/core");
 
 // src/tui/reducers/overlays.ts
-var import_core48 = require("@ordewell/core");
+var import_core47 = require("@ordewell/core");
 
 // src/tui/reducers/approvals.ts
 var import_core37 = require("@ordewell/core");
@@ -6348,7 +6339,7 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core47 = require("@ordewell/core");
+var import_core46 = require("@ordewell/core");
 
 // src/tui/reducers/plannerStepper.ts
 var import_core38 = require("@ordewell/core");
@@ -7304,73 +7295,8 @@ function followSession(state, message) {
   return message.type === "approval_settled" ? dropApproval(heard, message.id) : heard;
 }
 
-// src/tui/reducers/runSettings.ts
-var import_core45 = require("@ordewell/core");
-function runSettingsEffect(state, changes) {
-  return { type: "setRunSettings", changes, ...state.sessionId ? { sessionId: state.sessionId } : {} };
-}
-function supervisorCommand(state, args) {
-  const [arg, value] = args;
-  if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core45.supervisorSummary)(state.runSettings)}: /supervisor off|watch|act, /supervisor retries <n>, /supervisor reads <n>.`));
-  }
-  if (arg === "retries") {
-    const n = (0, import_core45.parseCount)(value, 0);
-    return n === null ? fail3(state, "Usage: /supervisor retries <whole number, 0 or more>") : step(state, [runSettingsEffect(state, { supervisorRetryLimit: n })]);
-  }
-  if (arg === "reads") {
-    const n = (0, import_core45.parseCount)(value, 1);
-    return n === null ? fail3(state, "Usage: /supervisor reads <whole number, 1 or more>") : step(state, [runSettingsEffect(state, { wakeUpReadBudget: n })]);
-  }
-  if (arg === "act") return confirmSupervisorAct(state);
-  if (arg === "off" || arg === "watch") return step(state, [runSettingsEffect(state, { supervisorLevel: arg })]);
-  return fail3(state, "Usage: /supervisor [off|watch|act] \xB7 /supervisor retries <n> \xB7 /supervisor reads <n>");
-}
-function automergeCommand(state, arg) {
-  if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core45.automergeSummary)(state.runSettings)}: /automerge on|off.`));
-  }
-  const enabled = (0, import_core45.parseSwitch)(arg);
-  if (enabled === null) return fail3(state, "Usage: /automerge [on|off]");
-  return step(state, [runSettingsEffect(state, { mergeAtGatesAutomatically: enabled })]);
-}
-function autorunCommand(state, arg) {
-  if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core45.autorunSummary)(state.runSettings)}: /autorun on starts each plan the planner submits, without review.`));
-  }
-  const enabled = (0, import_core45.parseSwitch)(arg);
-  if (enabled === null) return fail3(state, "Usage: /autorun [on|off]");
-  if (enabled) return confirmAutorun(state);
-  return step(state, [runSettingsEffect(state, { autorun: false })]);
-}
-function confirmSupervisorAct(state) {
-  return step({
-    ...state,
-    overlay: {
-      kind: "confirm",
-      title: "Let the supervisor act?",
-      message: "At Act the supervisor runs, stops and retries tasks, answers their requests (never allowing), edits the plan and merges, without asking you.",
-      note: `${import_core45.ACT_RISK}
-It applies to this session's run now, and to every later run.`,
-      action: { kind: "supervisor-act" }
-    }
-  });
-}
-function confirmAutorun(state) {
-  return step({
-    ...state,
-    overlay: {
-      kind: "confirm",
-      title: "Start plans without review?",
-      message: "With autorun on, each plan the planner submits starts at once, as if you had pressed Execute. The planner still asks when something is unclear.",
-      note: import_core45.AUTORUN_RISK,
-      action: { kind: "autorun-on" }
-    }
-  });
-}
-
 // src/tui/reducers/settings.ts
-var import_core46 = require("@ordewell/core");
+var import_core45 = require("@ordewell/core");
 var SUPERVISOR_DETAIL = {
   off: "The planner speaks only when you write",
   watch: "The planner follows your runs and suggests what to do",
@@ -7395,7 +7321,7 @@ var SETTINGS = {
         {
           id: "guarded",
           label: "Guarded",
-          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core46.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
+          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core45.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
           selected: !state.autonomous
         }
       ]
@@ -7405,7 +7331,7 @@ var SETTINGS = {
       label: "Supervisor",
       items: (state) => ["off", "watch", "act"].map((level) => ({
         id: level,
-        label: import_core46.SUPERVISOR_LEVEL_LABEL[level],
+        label: import_core45.SUPERVISOR_LEVEL_LABEL[level],
         detail: SUPERVISOR_DETAIL[level],
         selected: state.runSettings.supervisorLevel === level
       }))
@@ -7459,12 +7385,12 @@ function saveChoices(state, choices) {
   const autonomous = choices.autonomy === "full";
   if (autonomous !== state.autonomous) {
     save2.autonomous = autonomous;
-    changed.push(`Autonomy ${(0, import_core46.autonomyLevelLabel)(autonomous)}`);
+    changed.push(`Autonomy ${(0, import_core45.autonomyLevelLabel)(autonomous)}`);
   }
   const level = choices.supervisor;
   if (level !== state.runSettings.supervisorLevel) {
     run.supervisorLevel = level;
-    changed.push(`Supervisor ${import_core46.SUPERVISOR_LEVEL_LABEL[level]}`);
+    changed.push(`Supervisor ${import_core45.SUPERVISOR_LEVEL_LABEL[level]}`);
   }
   if (choices.retries !== void 0 && Number(choices.retries) !== state.runSettings.supervisorRetryLimit) {
     run.supervisorRetryLimit = Number(choices.retries);
@@ -7491,7 +7417,7 @@ function saveChoices(state, choices) {
   }
   if (changed.length === 0) return step(state);
   const effect = { ...save2, message: `Settings: ${changed.join(" \xB7 ")}` };
-  const risks = [...run.supervisorLevel === "act" ? [import_core46.ACT_RISK] : [], ...run.autorun ? [import_core46.AUTORUN_RISK] : []];
+  const risks = [...run.supervisorLevel === "act" ? [import_core45.ACT_RISK] : [], ...run.autorun ? [import_core45.AUTORUN_RISK] : []];
   if (risks.length === 0) return saveSettings(state, effect);
   return step({
     ...state,
@@ -7542,28 +7468,14 @@ function runCommand(state, { name, args }) {
         state,
         (sessionId) => plannerInFlight(state) ? stopPlanning(state, sessionId) : step(state, [{ type: "stopExecution", sessionId }])
       );
-    case "model":
-      return setModel(state, args);
     case "planner":
       return setPlanner(state, args);
-    case "planner-effort":
-      return setPlannerEffort(state, args);
     case "key":
       return setKey(state, args);
     case "allowlist":
       return allowlist(state, args);
     case "runners":
       return runners(state, args);
-    case "auto":
-      return setAutonomous(state, args[0]);
-    case "supervisor":
-      return supervisorCommand(state, args);
-    case "automerge":
-      return automergeCommand(state, args[0]);
-    case "autorun":
-      return autorunCommand(state, args[0]);
-    case "parallel":
-      return setMaxParallel(state, args[0]);
     case "settings":
       return openSettings(state);
     case "mouse":
@@ -7684,8 +7596,8 @@ function newSession(state) {
     goal: "",
     taskView: null,
     planApproved: false,
-    conversation: import_core47.EMPTY_CONVERSATION,
-    turnGate: import_core47.NO_TURN,
+    conversation: import_core46.EMPTY_CONVERSATION,
+    turnGate: import_core46.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -7696,40 +7608,16 @@ function newSession(state) {
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
-    queuedPrompts: import_core47.EMPTY_HOLD,
+    queuedPrompts: import_core46.EMPTY_HOLD,
     stopArmed: false,
     forceSendPending: null,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
-  }, import_core47.EMPTY_RUN), closeEffects);
-}
-function setModel(state, args) {
-  if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core47.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}.`);
-    }
-    const refusal = known.length === 0 ? vendorModelRefusal(state.plannerProvider, args[1], import_core47.TERMINAL_UI_COMMANDS.pickPlanner) : null;
-    if (refusal) return fail3(state, refusal);
-    return step(state, [{ type: "setModel", modelId: args[1] }]);
-  }
-  if (args.length > 0 && args[0] !== "set") return fail3(state, "Usage: /model [set <model-id>]");
-  const items = pickerItemsFor(state, { kind: "set-model" });
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker("Planner model", items, { kind: "set-model" }, { hint: providerErrorHint(state), filterable: true })
-      }
-    },
-    [{ type: "loadModels" }]
-  );
+  }, import_core46.EMPTY_RUN), closeEffects);
 }
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
-    if (!(0, import_core47.isPlannerBackend)(id)) {
+    if (!(0, import_core46.isPlannerBackend)(id)) {
       return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
@@ -7737,31 +7625,10 @@ function setPlanner(state, args) {
   const opened = openStepper(state, plannerStepper);
   return { ...opened, effects: [...opened.effects, { type: "loadModels" }] };
 }
-function setPlannerEffort(state, args) {
-  const items = plannerEffortItems(state, state.plannerProvider, state.orchestratorModel, state.plannerEffort);
-  if (args[0]) {
-    const wanted = args[0].toLowerCase();
-    const match = items.find((i) => !i.disabled && (i.id === wanted || wanted === "default" && i.id === DEFAULT_EFFORT));
-    if (!match) {
-      const available = items.filter((i) => !i.disabled && i.id !== DEFAULT_EFFORT).map((i) => i.id);
-      return fail3(state, available.length > 0 ? `Unknown effort: ${args[0]}. Available: ${available.join(", ")}, default.` : items[0]?.label ?? "No effort levels available.");
-    }
-    return step(state, [{ type: "setPlannerEffort", effort: match.id === DEFAULT_EFFORT ? "" : match.id }]);
-  }
-  return step({
-    ...state,
-    overlay: {
-      kind: "picker",
-      picker: picker("Planner thinking effort", items, { kind: "set-planner-effort" }, {
-        hint: "How hard the planning agent thinks per turn. Higher costs latency and tokens against your subscription."
-      })
-    }
-  });
-}
 function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
-    if (!(0, import_core47.isApiProvider)(provider)) {
+    if (!(0, import_core46.isApiProvider)(provider)) {
       return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
@@ -7772,16 +7639,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core47.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core46.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: (0, import_core47.getProviderMeta)(id).label,
-    detail: (0, import_core47.getProviderMeta)(id).apiKeyEnvVar,
+    label: (0, import_core46.getProviderMeta)(id).label,
+    detail: (0, import_core46.getProviderMeta)(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 = (0, import_core47.getProviderMeta)(provider);
+  const meta = (0, import_core46.getProviderMeta)(provider);
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -7856,18 +7723,6 @@ function runners(state, args) {
     })
   } }, [{ 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.`));
-  const limit = (0, import_core47.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) {
-  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core47.autonomyLevelLabel)(state.autonomous)}. /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core47.parseAutonomyLevel)(arg);
-  if (enabled === null) return fail3(state, "Usage: /auto [full|guarded]");
-  return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
-}
 function setMouseCapture(state, arg) {
   const enabled = resolveToggle(arg, state.mouseCapture);
   if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
@@ -7958,8 +7813,6 @@ function runConfirm(state, overlay) {
     if (!state.sessionId) return step(closed);
     return step(closed, [taskActionEffect(closed, state.sessionId, overlay.action.taskId, "force-start")]);
   }
-  if (overlay.action.kind === "supervisor-act") return step(closed, [runSettingsEffect(closed, { supervisorLevel: "act" })]);
-  if (overlay.action.kind === "autorun-on") return step(closed, [runSettingsEffect(closed, { autorun: true })]);
   if (overlay.action.kind === "save-settings") return answerSaveSettings(state, overlay.action, true);
   if (overlay.action.kind === "merge-run" || overlay.action.kind === "discard-run") {
     return confirmedHandoff(state, overlay.action.kind);
@@ -8062,10 +7915,6 @@ function choose2(state, picker2, item) {
     return step(say(state, "error", item.detail ? `${item.label}: ${item.detail}` : `${item.label} is not available.`));
   }
   switch (picker2.action.kind) {
-    case "set-model":
-      return step(closed, [{ type: "setModel", modelId: item.id }]);
-    case "set-planner-effort":
-      return step(closed, [{ type: "setPlannerEffort", effort: item.id === DEFAULT_EFFORT ? "" : item.id }]);
     case "load-session":
       return step(closed, [{ type: "loadSession", sessionId: item.id }]);
     case "rewind":
@@ -8073,7 +7922,7 @@ function choose2(state, picker2, item) {
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
-      return (0, import_core48.isApiProvider)(item.id) ? step({ ...state, overlay: keyPrompt(item.id) }) : step(closed);
+      return (0, import_core47.isApiProvider)(item.id) ? step({ ...state, overlay: keyPrompt(item.id) }) : step(closed);
     case "choose-allowlist-runner": {
       const action = { kind: "set-allowlist", runner: item.id };
       const items = pickerItemsFor(state, action);
@@ -8149,7 +7998,7 @@ function reduceAction(state, action) {
     // (`task-1`), so nothing of the last one's — a merge gate, a checkpoint, its
     // tasks — may carry over into this.
     case "sessionStarted":
-      return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core49.EMPTY_RUN));
+      return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core48.EMPTY_RUN));
     // A loaded session is a different one: the turn the old one had out, the
     // prompts held behind it and a stop armed against it are not this one's.
     // (`sessionStarted` cannot reset them: `startConversation` dispatches it
@@ -8161,13 +8010,13 @@ function reduceAction(state, action) {
         goal: action.goal,
         taskView: null,
         planner: "idle",
-        turnGate: import_core49.NO_TURN,
+        turnGate: import_core48.NO_TURN,
         pendingApprovals: [],
-        queuedPrompts: import_core49.EMPTY_HOLD,
+        queuedPrompts: import_core48.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core49.EMPTY_RUN));
+      }, import_core48.EMPTY_RUN));
     // The daemon registers a session only once planning succeeds; when it does
     // not, holding on to the id would send every next message to a session the
     // server never had.
@@ -8177,20 +8026,20 @@ function reduceAction(state, action) {
         sessionId: null,
         goal: "",
         taskView: null,
-        turnGate: import_core49.NO_TURN,
+        turnGate: import_core48.NO_TURN,
         pendingApprovals: [],
-        queuedPrompts: import_core49.EMPTY_HOLD,
+        queuedPrompts: import_core48.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core49.EMPTY_RUN));
+      }, import_core48.EMPTY_RUN));
     // Deleting the session on screen stops it in the daemon; a view left on it
     // would answer every next message with a session-not-found.
     case "sessionDeleted":
       return action.sessionId === state.sessionId ? newSession(state) : step(state);
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, conversation: (0, import_core49.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core48.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
     case "planRefreshed":
       if (stale(state, action.sessionId)) return step(state);
       return step(showPlan(state, action.plan));
@@ -8243,9 +8092,9 @@ function reduceAction(state, action) {
         taskId: action.taskId,
         order: action.order ?? 0,
         title: action.title,
-        runner: action.runner ?? import_core49.DEFAULT_RUNNERS[0]
+        runner: action.runner ?? import_core48.DEFAULT_RUNNERS[0]
       });
-      const spoken = say(folded, "system", (0, import_core49.taskStartedNotice)(action.title, action.runner));
+      const spoken = say(folded, "system", (0, import_core48.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, status: "executing" });
     }
     case "taskCheckpoint":
@@ -8297,7 +8146,7 @@ function reduceAction(state, action) {
         completed: state.tasks.filter((t) => t.status === "completed").length,
         total: state.tasks.length,
         failed: state.tasks.filter((t) => t.status === "failed").length,
-        blocked: (0, import_core49.blockingFailures)(state.tasks).size,
+        blocked: (0, import_core48.blockingFailures)(state.tasks).size,
         skipped: state.tasks.filter((t) => t.status === "skipped").length
       };
       const failures = `${failed > 0 ? ` \xB7 ${failed} failed` : ""}${blocked ? ` \xB7 ${blocked} blocked` : ""}${skipped ? ` \xB7 ${skipped} skipped` : ""}`;
@@ -8340,7 +8189,7 @@ function reduceAction(state, action) {
             providerErrors: action.providerErrors ?? state.providerErrors,
             modesByRunner: action.modesByRunner ?? state.modesByRunner
           },
-          ["set-model", "set-task-model", "set-task-effort", "set-task-mode"]
+          ["set-task-model", "set-task-effort", "set-task-mode"]
         )
       ));
     case "sessionsLoaded":
@@ -8360,14 +8209,14 @@ function reduceAction(state, action) {
         taskView: null,
         status: "idle",
         planner: "idle",
-        turnGate: import_core49.NO_TURN,
+        turnGate: import_core48.NO_TURN,
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core49.EMPTY_HOLD,
+        queuedPrompts: import_core48.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core49.EMPTY_RUN));
+      }, import_core48.EMPTY_RUN));
     // 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":
@@ -8543,7 +8392,7 @@ function submit(state) {
   const builtIn = builtInCommand(text);
   if (builtIn) return runCommand(cleared, builtIn);
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core49.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core48.holdPrompt)(state.queuedPrompts, text) });
   }
   const spoken = say(cleared, "user", text);
   const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
@@ -8618,7 +8467,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process3 = require("child_process");
-var import_core50 = require("@ordewell/core");
+var import_core49 = require("@ordewell/core");
 
 // src/tui/inbound.ts
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
@@ -9046,9 +8895,9 @@ function plannerModelNotice(recall2) {
     case "remembered":
       return `Restored ${recall2.model}.`;
     case "catalog-default":
-      return `Using its default model, ${recall2.model}. Pick another with /model.`;
+      return `Using its default model, ${recall2.model}. Pick another with /planner.`;
     case "none":
-      return "Pick a model with /model.";
+      return "Pick a model with /planner.";
   }
 }
 async function perform(effect, deps) {
@@ -9108,24 +8957,18 @@ async function perform(effect, deps) {
         await refreshPlan(deps, sessionId);
         return;
       }
-      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : action === "resume-now" ? () => api.resumeNow(sessionId, taskId) : action === "skip" ? () => api.skipTask(sessionId, taskId) : (0, import_core50.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
+      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : action === "resume-now" ? () => api.resumeNow(sessionId, taskId) : action === "skip" ? () => api.skipTask(sessionId, taskId) : (0, import_core49.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
       await (effect.watch ? withExecutionStream(deps, sessionId, request) : request());
       await refreshPlan(deps, sessionId);
       return;
     }
     case "addTask": {
-      const fields = (0, import_core50.newTaskFields)(effect.title);
+      const fields = (0, import_core49.newTaskFields)(effect.title);
       if (!fields) return;
       await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
       return;
     }
-    case "setRunSettings": {
-      const settings = await api.updateRunSettings(effect.changes, effect.sessionId);
-      dispatch({ type: "settingsLoaded", settings });
-      if (effect.sessionId) await refreshPlan(deps, effect.sessionId);
-      return;
-    }
     case "updateTask":
       await api.updateTask(effect.sessionId, effect.taskId, effect.changes);
       await refreshPlan(deps, effect.sessionId);
@@ -9209,20 +9052,12 @@ async function perform(effect, deps) {
     case "interruptTask":
       await api.interruptTask(effect.sessionId, effect.taskId);
       return;
-    case "setModel": {
-      const settled = await api.updateSettings({ orchestratorModel: effect.modelId });
-      const plannerThinkingEffort = typeof settled.plannerThinkingEffort === "string" ? settled.plannerThinkingEffort : "";
-      persistAfterDaemon(deps, { ORCHESTRATOR_MODEL: effect.modelId, ORDEWELL_PLANNER_EFFORT: plannerThinkingEffort });
-      dispatch({ type: "settingsLoaded", settings: { orchestratorModel: effect.modelId, plannerThinkingEffort } });
-      dispatch({ type: "notice", message: `Planner model set to ${effect.modelId}.` });
-      return;
-    }
     case "setPlanner": {
-      const meta = (0, import_core50.getProviderMeta)(effect.provider);
+      const meta = (0, import_core49.getProviderMeta)(effect.provider);
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
-      if ((0, import_core50.isCliProvider)(effect.provider)) {
+      if ((0, import_core49.isCliProvider)(effect.provider)) {
         const installed = ((await api.getRunners()).runners ?? []).map((r) => r.id);
-        const refusal = uninstalledPlannerRefusal(effect.provider, installed, import_core50.TERMINAL_UI_COMMANDS.pickPlanner);
+        const refusal = uninstalledPlannerRefusal(effect.provider, installed, import_core49.TERMINAL_UI_COMMANDS.pickPlanner);
         if (refusal) throw new Error(refusal);
       }
       const env = { AI_PROVIDER: effect.provider };
@@ -9235,7 +9070,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core50.isCliProvider)(effect.provider) ? `Planning with ${meta.label}: no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core49.isCliProvider)(effect.provider) ? `Planning with ${meta.label}: no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -9256,14 +9091,8 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: effect.notice });
       return;
     }
-    case "setPlannerEffort":
-      await api.updateSettings({ env: { ORDEWELL_PLANNER_EFFORT: effect.effort } });
-      deps.setEnvVar("ORDEWELL_PLANNER_EFFORT", effect.effort);
-      dispatch({ type: "settingsLoaded", settings: { plannerThinkingEffort: effect.effort } });
-      dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
-      return;
     case "setApiKey": {
-      const meta = (0, import_core50.isApiProvider)(effect.provider) ? (0, import_core50.getProviderMeta)(effect.provider) : void 0;
+      const meta = (0, import_core49.isApiProvider)(effect.provider) ? (0, import_core49.getProviderMeta)(effect.provider) : void 0;
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -9294,10 +9123,6 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: effect.message });
       return;
     }
-    case "setMaxParallel":
-      await saveMaxParallel(deps, effect.limit);
-      dispatch({ type: "notice", message: `Up to ${effect.limit} AI task${effect.limit === 1 ? "" : "s"} now run at once.` });
-      return;
     case "saveSettings": {
       if (Object.keys(effect.run).length > 0) {
         const settings = await api.updateRunSettings(effect.run, effect.sessionId);
@@ -9309,12 +9134,6 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: overridden ? `${effect.message}: ORDEWELL_AUTONOMOUS_MODE in the environment decides the autonomy level until it is unset.` : effect.message });
       return;
     }
-    case "setAutonomous": {
-      const { overridden } = deps.saveAutonomy(effect.enabled);
-      const level = (0, import_core50.autonomyLevelLabel)(effect.enabled);
-      dispatch({ type: "notice", message: overridden ? `${level} is saved, but ORDEWELL_AUTONOMOUS_MODE in the environment decides the level until it is unset.` : `Autonomy level: ${level} for new plans.` });
-      return;
-    }
     case "setMouseCapture":
       deps.setMouseCapture(effect.enabled);
       deps.setEnvVar("ORDEWELL_TUI_MOUSE", String(effect.enabled));
@@ -9487,7 +9306,7 @@ async function saveMaxParallel(deps, limit) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core50.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core49.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -9592,7 +9411,7 @@ function turnReplies(plan) {
   const replies = [];
   for (let i = history.length - 1; i >= 0; i--) {
     const entry = history[i];
-    if ((0, import_core50.isUserMessage)(entry)) break;
+    if ((0, import_core49.isUserMessage)(entry)) break;
     if (entry.role === "assistant" && entry.kind === void 0) {
       const { content, timestamp, runs } = entry;
       replies.unshift({ content, ...timestamp ? { timestamp } : {}, ...runs ? { runs } : {} });
@@ -9948,7 +9767,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core51.assertWorkspaceExists)(workspace);
+    (0, import_core50.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -9957,7 +9776,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  const discoveredSkills = (0, import_core51.createSkillsService)(workspace, new import_core51.EnvConfig().workspaceRepos).listSkills();
+  const discoveredSkills = (0, import_core50.createSkillsService)(workspace, new import_core50.EnvConfig().workspaceRepos).listSkills();
   registerSkillCommands(discoveredSkills);
   const taskSkills = discoveredSkills.filter((s) => s.appliesTo === "task").map((s) => ({ name: s.name, description: s.description }));
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
@@ -9967,7 +9786,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
   const api = new ApiClient(port, workspace);
   let terminal;
   const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
-  const settings = new import_core51.SettingsService();
+  const settings = new import_core50.SettingsService();
   const app = createApp({
     // The level the daemon plans with: the saved one, unless the environment overrides it (ADR-0030).
     // The run settings are seeded from the same file because the first frame is
@@ -9989,13 +9808,13 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core51.mintSessionId)(),
+      newSessionId: () => (0, import_core50.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
       },
       saveAutonomy: (enabled) => {
-        const settings2 = new import_core51.SettingsService();
+        const settings2 = new import_core50.SettingsService();
         settings2.setAutonomousMode(enabled);
         return { overridden: settings2.autonomousModeOverridden() };
       },
@@ -10112,7 +9931,7 @@ var COMMANDS = {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core52.migrateOldConfigDir)();
+  (0, import_core51.migrateOldConfigDir)();
   moveAutonomyToSettings();
   loadEnvFile();
   const argv = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordewell/cli",
-  "version": "0.10.10",
+  "version": "0.10.12",
   "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.10",
-    "@ordewell/web": "^0.10.10",
+    "@ordewell/core": "^0.10.12",
+    "@ordewell/web": "^0.10.12",
     "string-width": "^7.2.0",
     "ws": "^8.18.0"
   },