u-foo 3.0.1 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agents/prompts/native/tasks.js

@@ -11,7 +11,10 @@ function getDoingTasksSection() {
  - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).
  - Don't create helpers, utilities, or abstractions for one-time operations. Three similar lines of code is better than a premature abstraction.
  - Follow workspace conventions and project instructions (AGENTS.md) when present.
- - Prefer concrete code edits and verifiable outcomes over explanations.`;
+ - Prefer concrete code edits and verifiable outcomes over explanations.
+ - For simple, single-goal work, execute directly with read/write/edit/bash.
+ - For complex work — multiple goals, several subsystems, long multi-step delivery, or clear parallel tracks — automatically decompose before diving in: split into concrete sub-objectives, then start one or more TaskRuns via task_run (standalone; no Plan Mode required). Use plan_graph only when durable dependencies, checkpoints, or a shared executable plan are needed.
+ - When decomposing, each TaskRun objective should be independently verifiable; prefer a few sharp tasks over one vague mega-task.`;
 }
 
 module.exports = { getDoingTasksSection };

package/src/app/chat/commandExecutor.js

@@ -166,6 +166,7 @@ function createCommandExecutor(options = {}) {
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     schedule = (fn, ms) => setTimeout(fn, ms),
     clearLog = null,
+    fetchModelsImpl = null,
   } = options;
 
   if (!projectRoot) {
@@ -1623,7 +1624,35 @@ function createCommandExecutor(options = {}) {
       logMessage("system", `  • url: ${url || "(unset)"}`);
       logMessage("system", `  • key: ${maskSecret(key)}`);
       logMessage("system", `  • transport: ${transport} (auto)`);
+      try {
+        const { currentThinkingLevel } = require("../../code/modelCommand");
+        logMessage("system", `  • thinking: ${currentThinkingLevel({})}`);
+      } catch {
+        // ignore
+      }
       logMessage("system", "  • tip: url supports generic gateway base, transport is auto-detected");
+      try {
+        const { listUcodeModels } = require("../../code/modelCommand");
+        const listed = await listUcodeModels({
+          provider,
+          model,
+        }, {
+          workspaceRoot: getActiveProjectRoot() || projectRoot,
+          fetchImpl: fetchModelsImpl || undefined,
+        });
+        if (listed.ok && listed.models.length > 0) {
+          const sample = listed.models.slice(0, 10);
+          logMessage("system", `  • models route: ${listed.models.length} available`);
+          logMessage("system", `  • models: ${sample.join(", ")}${listed.models.length > 10 ? "…" : ""}`);
+          if (model && !listed.models.includes(model)) {
+            logMessage("system", `  • warning: configured model "${model}" is not in the provider catalog`);
+          }
+        } else if (listed.error) {
+          logMessage("system", `  • models route: ${listed.error}`);
+        }
+      } catch (err) {
+        logMessage("system", `  • models route: ${err && err.message ? err.message : "unavailable"}`);
+      }
       return;
     }
 
@@ -1645,6 +1674,52 @@ function createCommandExecutor(options = {}) {
         logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings ucode set provider=<openai|anthropic> model=<id> url=<baseUrl> key=<apiKey>");
         return;
       }
+
+      // Preview the config that would apply after this set, then confirm the
+      // model id against the provider /models route when a model is present.
+      const preview = {
+        ...(loadUcodeConfig() || {}),
+        ...updates,
+      };
+      const modelToConfirm = String(preview.ucodeModel || "").trim();
+      if (modelToConfirm) {
+        try {
+          const { confirmModelSupported } = require("../../code/providers/modelsCatalog");
+          const { resolveRuntimeConfig } = require("../../code/nativeRunner");
+          const runtime = resolveRuntimeConfig({
+            workspaceRoot: getActiveProjectRoot() || projectRoot,
+            provider: preview.ucodeProvider || "",
+            model: modelToConfirm,
+          });
+          // Prefer the previewed url/key over env-only resolution so a single
+          // set line that changes url+model validates against the new gateway.
+          const confirmation = await confirmModelSupported({
+            provider: runtime.provider,
+            transport: inferUcodeTransport(preview.ucodeProvider, preview.ucodeBaseUrl || runtime.baseUrl),
+            baseUrl: String(preview.ucodeBaseUrl || runtime.baseUrl || "").trim(),
+            apiKey: String(preview.ucodeApiKey || runtime.apiKey || "").trim(),
+            model: modelToConfirm,
+            strict: false,
+            fetchImpl: fetchModelsImpl || undefined,
+          });
+          if (!confirmation.allowed) {
+            logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(confirmation.error || "model not supported")}`);
+            if (confirmation.models && confirmation.models.length > 0) {
+              const sample = confirmation.models.slice(0, 10).join(", ");
+              logMessage("system", `  • available: ${escapeBlessed(sample)}${confirmation.models.length > 10 ? "…" : ""}`);
+            }
+            return;
+          }
+          if (confirmation.warning) {
+            logMessage("system", `{gray-fg}note:{/gray-fg} ${escapeBlessed(confirmation.warning)}`);
+          } else if (confirmation.ok) {
+            logMessage("system", `{gray-fg}models route:{/gray-fg} confirmed ${escapeBlessed(modelToConfirm)}`);
+          }
+        } catch (err) {
+          logMessage("system", `{gray-fg}note:{/gray-fg} models route check skipped (${escapeBlessed(err && err.message ? err.message : "unavailable")})`);
+        }
+      }
+
       saveUcodeConfig(updates);
       logMessage("system", "{white-fg}✓{/white-fg} ucode config updated (global)");
       if (Object.prototype.hasOwnProperty.call(updates, "ucodeProvider")) {
@@ -1664,6 +1739,41 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
+    if (action === "models") {
+      try {
+        const { listUcodeModels } = require("../../code/modelCommand");
+        const config = loadUcodeConfig() || {};
+        const listed = await listUcodeModels({
+          provider: config.ucodeProvider || "",
+          model: config.ucodeModel || "",
+        }, {
+          workspaceRoot: getActiveProjectRoot() || projectRoot,
+          skipCache: true,
+          fetchImpl: fetchModelsImpl || undefined,
+        });
+        if (!listed.ok) {
+          logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(listed.error || "models route failed")}`);
+          if (listed.url) logMessage("system", `  • url: ${escapeBlessed(listed.url)}`);
+          return;
+        }
+        logMessage("system", `{cyan-fg}ucode models:{/cyan-fg} ${listed.models.length} from ${escapeBlessed(listed.url)}`);
+        if (listed.models.length === 0) {
+          logMessage("system", "  • (empty catalog)");
+          return;
+        }
+        listed.models.slice(0, 40).forEach((id) => {
+          const current = String(config.ucodeModel || "").trim() === id ? " {gray-fg}(current){/gray-fg}" : "";
+          logMessage("system", `  • ${escapeBlessed(id)}${current}`);
+        });
+        if (listed.models.length > 40) {
+          logMessage("system", `  • … ${listed.models.length - 40} more`);
+        }
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(err && err.message ? err.message : "models route failed")}`);
+      }
+      return;
+    }
+
     if (action === "clear") {
       const fieldsRaw = args.slice(1).map((item) => String(item || "").trim().toLowerCase()).filter(Boolean);
       const fields = fieldsRaw.length === 0 ? ["all"] : fieldsRaw;
@@ -1682,7 +1792,7 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    logMessage("error", "{white-fg}✗{/white-fg} Unknown settings ucode action. Use: show, set, clear");
+    logMessage("error", "{white-fg}✗{/white-fg} Unknown settings ucode action. Use: show, set, models, clear");
   }
 
   async function executeCommand(text) {

package/src/app/chat/commands.js

@@ -135,7 +135,8 @@ const COMMAND_TREE = {
         children: {
           show: { desc: "Show ucode provider/model/url/key", order: 1 },
           set: { desc: "Set ucode provider/model/url/key", order: 2 },
-          clear: { desc: "Clear ucode provider/model/url/key", order: 3 },
+          models: { desc: "List models from the provider /models route", order: 3 },
+          clear: { desc: "Clear ucode provider/model/url/key", order: 4 },
         },
       },
     },

package/src/app/chat/daemonMessageRouter.js

@@ -416,7 +416,7 @@ function createDaemonMessageRouter(options = {}) {
       const publisher = report.agent_id || data.publisher || "ufoo-agent";
       const displayName = resolveAgentDisplayName(publisher);
       const detail = report.summary || report.message || data.message || report.task_id || "report";
-      logMessage("bus", `${speakerPrefix(displayName)}${escapeBlessed(detail)}`);
+      logMessage("report", `${speakerPrefix(displayName)}${escapeBlessed(detail)}`, data);
       requestStatus();
       renderScreen();
       return true;

package/src/app/chat/inputSubmitHandler.js

@@ -33,8 +33,9 @@ function createInputSubmitHandler(options = {}) {
 
   function userEcho(text, targetLabel = "") {
     const body = escapeBlessed(text);
-    if (!targetLabel) return body;
-    return `{magenta-fg}@${escapeBlessed(targetLabel)}{/magenta-fg} ${body}`;
+    // Match ucode › prompt echo so history reload and live log share a prefix.
+    if (!targetLabel) return `› ${body}`;
+    return `› {magenta-fg}@${escapeBlessed(targetLabel)}{/magenta-fg} ${body}`;
   }
 
   async function tryActivateTargetAgent(agentId) {

package/src/code/commands.js

@@ -7,7 +7,7 @@
 const UCODE_COMMAND_REGISTRY = [
   { cmd: "/help", desc: "Show available commands", order: 10 },
   { cmd: "/status", desc: "Show session / usage status", order: 20 },
-  { cmd: "/model", desc: "Show or switch the active model", order: 25 },
+  { cmd: "/model", desc: "Show or switch model (+ thinking intensity)", order: 25 },
   { cmd: "/plan", desc: "Show plan progress or set plan mode", order: 27 },
   { cmd: "/ubus", desc: "Check pending bus messages", order: 30 },
   { cmd: "/resume", desc: "Resume a saved session", order: 40 },
@@ -20,7 +20,7 @@ const UCODE_COMMAND_TREE = {
   "/help": { desc: "Show available commands" },
   "/status": { desc: "Show session / usage status" },
   "/model": {
-    desc: "Show or switch the active model",
+    desc: "Show or switch model, then pick thinking intensity",
     hasArguments: true,
     optionalArguments: true,
   },
@@ -59,7 +59,7 @@ function listUcodeCommandsForHelp() {
     "  /exit|/quit",
     "  /ubus",
     "  /status",
-    "  /model [model-id]",
+    "  /model [model-id] [off|low|medium|high|max]",
     "  /plan [on|off|show|hide|focus|debug|clear]",
     "  /skills [list]",
     "  /skills show <name>",

package/src/code/context/promptLayers.js

@@ -31,7 +31,7 @@ const {
 } = require("../skills");
 const { hashContent } = require("./artifacts");
 
-const PROMPT_VERSION = "native-v5";
+const PROMPT_VERSION = "native-v6";
 
 function buildImmutablePrefix() {
   return [
@@ -44,19 +44,20 @@ function buildImmutablePrefix() {
     getOutputEfficiencySection(),
     [
       "Tool calling grammar:",
-      "- Use read, write, edit, bash, and artifact_read for direct work, even when it takes several tool calls. Use plan_graph only when the work needs a durable semantic/executable plan, explicit dependencies or checkpoints, or asynchronous TaskRuns.",
-      "- Plan Mode is a runtime posture for the Agent Loop, not an agent tool. While Plan Mode is ON, direct write, edit, and bash calls from the Agent Loop are blocked; read and artifact_read remain available.",
+      "- Use read, write, edit, bash, and artifact_read for direct, single-goal work, even when it takes several tool calls.",
+      "- TaskRuns are orthogonal to Plan Mode. A TaskRun does not require Plan Mode or a plan_graph. Use task_run operation=start with an objective for a standalone single-point TaskRun; it starts asynchronously and returns immediately.",
+      "- On complex or multi-goal requests, automatically decompose into concrete sub-objectives and start TaskRun(s) via task_run. Prefer task_run for independent or loosely coupled tracks; use plan_graph only when you need durable dependencies, checkpoints, or a shared executable plan.",
+      "- Use plan_graph for durable graph structure: create, patch, inspect, cancel_graph, and control. Graph-bound TaskRuns use plan_graph control.start_task on execution.kind=task_loop nodes.",
+      "- Plan Mode is a runtime posture for the Agent Loop, not an agent tool. While Plan Mode is ON, direct write, edit, and bash calls from the Agent Loop are blocked; read and artifact_read remain available. TaskRuns still run independently of Plan Mode.",
       "- In the Agent Loop, plan_graph operation=create automatically enables Plan Mode. The user may also use /plan on or /plan off.",
-      "- Turning Plan Mode off does not cancel an existing graph or running TaskRuns. Use plan_graph operation=cancel_graph or operation=control with cancel_task to stop them.",
+      "- Turning Plan Mode off does not cancel an existing graph or running TaskRuns. Cancel with task_run (standalone) or plan_graph operation=cancel_graph / control.cancel_task (graph-bound).",
       "- When the user enables Plan Mode and no active graph exists, create a plan_graph before performing side effects.",
-      "- Use plan_graph for durable graph structure and TaskRun lifecycle: create, patch, inspect, cancel_graph, and control.",
       "- After an accepted plan_graph create or patch, Runtime automatically advances ready tool nodes. Never invent or request an execute_graph tool.",
-      "- Do not call plan_graph together with read, write, edit, bash, or artifact_read in the same assistant turn.",
+      "- Do not call plan_graph or task_run together with read, write, edit, bash, or artifact_read in the same assistant turn.",
       "- When an active graph is waiting on a task, advance that node through plan_graph instead of bypassing it with direct workspace tools: use patch.expand_node for execution.kind=expand, control.complete_task (nodeId) for execution.kind=inline_llm, or control.start_task for execution.kind=task_loop.",
-      "- control.complete_task with nodeId completes a waiting_llm inline_llm task for the current Graph owner. control.complete_task with taskRunId is reserved for the owning TaskLoop. Do not directly complete expand or aggregate tasks.",
-      "- While Plan Mode is ON, workspace mutations must be represented as plan_graph tool nodes or performed inside a running task_loop.",
+      "- control.complete_task with nodeId completes a waiting_llm inline_llm task for the current Graph owner. control.complete_task with taskRunId (or task_run complete) is reserved for the owning TaskLoop. Do not directly complete expand or aggregate tasks.",
+      "- While Plan Mode is ON, workspace mutations must be represented as plan_graph tool nodes or performed inside a running TaskRun/task_loop.",
       "- Treat a User reminder as the latest user instruction. Reconcile it before continuing from tool results. If it is compatible with the active plan, resume the waiting plan node; otherwise patch, cancel, or replan first.",
-      "- Use execution.kind=task_loop for work that should continue asynchronously without occupying the Agent Loop. plan_graph operation=control action=start_task starts the TaskRun and returns immediately.",
       "- TaskLoops do not consume User reminders. The Agent Loop is woken by runtime task_started, task_succeeded, task_failed, and task_cancelled events.",
       "- Runtime enforces TaskRun concurrency limits and workspace write leases. Direct Agent write, edit, or bash calls may be rejected while writing TaskRuns are active.",
       "- Tool results may contain an artifactId. Use artifact_read to hydrate raw stored output or a slice of it; use read for workspace file paths.",

package/src/code/dispatch.js

@@ -6,6 +6,7 @@ const { runEditTool } = require("./tools/edit");
 const { runBashTool } = require("./tools/bash");
 const { runArtifactReadTool } = require("./tools/artifactRead");
 const { runPlanGraphTool } = require("./tools/planGraph");
+const { runTaskRunTool } = require("./tools/taskRun");
 const { runAskUserTool } = require("./tools/askUser");
 
 const TOOL_NAMES = [
@@ -15,6 +16,7 @@ const TOOL_NAMES = [
   "bash",
   "artifact_read",
   "plan_graph",
+  "task_run",
   "ask_user",
 ];
 
@@ -26,6 +28,7 @@ function normalizeToolName(value = "") {
   if (text === "bash") return "bash";
   if (text === "artifact_read" || text === "artifact-read" || text === "artifactread") return "artifact_read";
   if (text === "plan_graph" || text === "plan-graph" || text === "plangraph") return "plan_graph";
+  if (text === "task_run" || text === "task-run" || text === "taskrun") return "task_run";
   if (text === "ask_user" || text === "ask-user" || text === "askuser") return "ask_user";
   return "";
 }
@@ -45,6 +48,7 @@ function runToolCall(input = {}, options = {}) {
   if (tool === "edit") return runEditTool(args, options);
   if (tool === "artifact_read") return runArtifactReadTool(args, options);
   if (tool === "plan_graph") return runPlanGraphTool(args, options);
+  if (tool === "task_run") return runTaskRunTool(args, options);
   if (tool === "ask_user") return runAskUserTool(args, options);
   return runBashTool(args, options);
 }

package/src/code/modelCommand.js

@@ -1,37 +1,176 @@
 "use strict";
 
-const { saveGlobalUcodeConfig } = require("../config");
+const { saveGlobalUcodeConfig, loadGlobalUcodeConfig } = require("../config");
+const {
+  listProviderModels,
+  confirmModelSupported,
+} = require("./providers/modelsCatalog");
+const {
+  normalizeThinkingLevel,
+  suggestThinkingLevels,
+  applyThinkingLevelToEnv,
+  resolveThinkingFromEnvAndConfig,
+  DEFAULT_THINKING_LEVEL,
+} = require("./thinkingLevels");
+
+function fallbackModelSuggestions(provider = "") {
+  const text = String(provider || "").trim().toLowerCase();
+  if (text.includes("anthropic") || text.includes("claude")) {
+    return ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5"];
+  }
+  if (text.includes("kimi") || text.includes("moonshot")) {
+    return ["k3", "kimi-k2.5", "moonshot-v1-128k"];
+  }
+  return ["gpt-5.4", "gpt-5.3", "o3", "o4-mini"];
+}
+
+function resolveModelRuntime(state = {}, options = {}) {
+  // Lazy require: nativeRunner pulls agent/repl paths that can load modelCommand.
+  const { resolveRuntimeConfig } = require("./nativeRunner");
+  return resolveRuntimeConfig({
+    workspaceRoot: options.workspaceRoot || process.cwd(),
+    provider: options.provider || (state && state.provider) || "",
+    model: options.model || (state && state.model) || "",
+  });
+}
+
+function currentThinkingLevel(state = {}) {
+  let configLevel = "";
+  try {
+    configLevel = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+  } catch {
+    configLevel = "";
+  }
+  const fromState = normalizeThinkingLevel(state && state.thinking);
+  const resolved = resolveThinkingFromEnvAndConfig({
+    env: process.env,
+    configLevel: fromState || configLevel,
+  });
+  if (resolved.level) return resolved.level;
+  if (resolved.source === "env-budget") {
+    // Approximate a named level for the secondary menu highlight.
+    const budget = Number(resolved.budgetTokens) || 0;
+    if (budget <= 0) return "off";
+    if (budget <= 3000) return "low";
+    if (budget <= 16000) return "medium";
+    if (budget <= 40000) return "high";
+    return "max";
+  }
+  return DEFAULT_THINKING_LEVEL;
+}
+
+function persistThinkingLevel(state = {}, level = "") {
+  const normalized = normalizeThinkingLevel(level);
+  if (!normalized) return "";
+  if (state && typeof state === "object") state.thinking = normalized;
+  try {
+    saveGlobalUcodeConfig({ ucodeThinking: normalized });
+  } catch {
+    // best-effort
+  }
+  applyThinkingLevelToEnv(normalized, process.env);
+  return normalized;
+}
+
+/**
+ * Fetch models from the configured provider's /models route.
+ */
+async function listUcodeModels(state = {}, options = {}) {
+  const runtime = resolveModelRuntime(state, options);
+  const listed = await listProviderModels({
+    ...runtime,
+    fetchImpl: options.fetchImpl,
+    timeoutMs: options.timeoutMs,
+    skipCache: options.skipCache === true,
+  });
+  return {
+    ...listed,
+    provider: runtime.provider,
+    transport: runtime.transport,
+    baseUrl: runtime.baseUrl,
+  };
+}
 
 /**
  * Apply /model show|set against the live session state.
- * Persists ucodeModel to the global config so the next launch keeps it.
+ * Persists ucodeModel / ucodeThinking so the next launch keeps them.
+ * Set validates against the provider models route when available.
+ *
+ * result.shape:
+ *   { action: "show" }
+ *   { action: "set", model, thinking? }
  */
-function applyUcodeModelCommand(state = {}, result = {}) {
+async function applyUcodeModelCommand(state = {}, result = {}, options = {}) {
   const action = String((result && result.action) || "").trim().toLowerCase();
   if (action === "show") {
     const model = String((state && state.model) || "").trim() || "(unset)";
     const provider = String((state && state.provider) || "").trim() || "(unset)";
+    const thinking = currentThinkingLevel(state);
+    const lines = [
+      `model: ${model}`,
+      `provider: ${provider}`,
+      `thinking: ${thinking}`,
+      "usage: /model <model-id> [off|low|medium|high|max]",
+    ];
+    try {
+      const listed = await listUcodeModels(state, options);
+      if (listed.ok && listed.models.length > 0) {
+        const sample = listed.models.slice(0, 12);
+        lines.push(`models route: ${listed.url}`);
+        lines.push(`available (${listed.models.length}): ${sample.join(", ")}${listed.models.length > 12 ? "…" : ""}`);
+      } else if (listed.error) {
+        lines.push(`models route: ${listed.error}`);
+      }
+    } catch (err) {
+      lines.push(`models route: ${err && err.message ? err.message : "unavailable"}`);
+    }
     return {
       ok: true,
       error: "",
-      output: [
-        `model: ${model}`,
-        `provider: ${provider}`,
-        "usage: /model <model-id>",
-      ].join("\n"),
+      output: lines.join("\n"),
       model: String((state && state.model) || "").trim(),
+      thinking,
     };
   }
   if (action === "set") {
     const next = String((result && result.model) || "").trim();
+    const thinkingRaw = String((result && result.thinking) || "").trim();
+    const thinkingNext = normalizeThinkingLevel(thinkingRaw);
     if (!next) {
       return {
         ok: false,
-        error: "usage: /model [model-id]",
-        output: "usage: /model [model-id]",
+        error: "usage: /model [model-id] [off|low|medium|high|max]",
+        output: "usage: /model [model-id] [off|low|medium|high|max]",
       };
     }
+    if (thinkingRaw && !thinkingNext) {
+      return {
+        ok: false,
+        error: `unknown thinking level "${thinkingRaw}" (use off|low|medium|high|max)`,
+        output: `unknown thinking level "${thinkingRaw}" (use off|low|medium|high|max)`,
+      };
+    }
+
+    const runtime = resolveModelRuntime(state, { ...options, model: next });
+    const confirmation = await confirmModelSupported({
+      ...runtime,
+      model: next,
+      fetchImpl: options.fetchImpl,
+      timeoutMs: options.timeoutMs,
+      skipCache: options.skipCache === true,
+      strict: options.strict === true,
+    });
+    if (!confirmation.allowed) {
+      return {
+        ok: false,
+        error: confirmation.error || `model "${next}" is not supported`,
+        output: confirmation.error || `model "${next}" is not supported`,
+        models: confirmation.models,
+      };
+    }
+
     const previous = String((state && state.model) || "").trim();
+    const previousThinking = currentThinkingLevel(state);
     if (state && typeof state === "object") state.model = next;
     try {
       saveGlobalUcodeConfig({ ucodeModel: next });
@@ -43,45 +182,82 @@ function applyUcodeModelCommand(state = {}, result = {}) {
     } catch {
       // ignore env write failures
     }
-    const output = previous && previous !== next
+
+    const lines = [];
+    const modelOutput = previous && previous !== next
       ? `model switched: ${previous} → ${next}`
       : `model set: ${next}`;
+    lines.push(modelOutput);
+
+    let appliedThinking = "";
+    if (thinkingNext) {
+      appliedThinking = persistThinkingLevel(state, thinkingNext);
+      if (previousThinking && previousThinking !== appliedThinking) {
+        lines.push(`thinking: ${previousThinking} → ${appliedThinking}`);
+      } else {
+        lines.push(`thinking: ${appliedThinking}`);
+      }
+    }
+
+    if (confirmation.warning) lines.push(`note: ${confirmation.warning}`);
+    if (confirmation.ok && confirmation.models.length > 0) {
+      lines.push(`confirmed via models route (${confirmation.models.length} available)`);
+    }
     return {
       ok: true,
       error: "",
-      output,
+      output: lines.join("\n"),
       model: next,
       previous,
+      thinking: appliedThinking || previousThinking,
+      warning: confirmation.warning || "",
+      models: confirmation.models,
     };
   }
   return {
     ok: false,
-    error: "usage: /model [model-id]",
-    output: "usage: /model [model-id]",
+    error: "usage: /model [model-id] [off|low|medium|high|max]",
+    output: "usage: /model [model-id] [off|low|medium|high|max]",
   };
 }
 
-function suggestUcodeModels(state = {}) {
+/**
+ * Build /model completion rows. Prefer a live models-route catalog when
+ * provided; otherwise fall back to a small hardcoded list.
+ * Models are marked hasChildren so the TUI opens a thinking-intensity
+ * secondary menu after the id is chosen.
+ */
+function suggestUcodeModels(state = {}, options = {}) {
   const current = String((state && state.model) || "").trim();
   const provider = String((state && state.provider) || "").trim().toLowerCase();
-  let defaults = ["gpt-5.4", "gpt-5.3", "o3", "o4-mini"];
-  if (provider.includes("anthropic") || provider.includes("claude")) {
-    defaults = ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5"];
-  } else if (provider.includes("kimi") || provider.includes("moonshot")) {
-    defaults = ["kimi-k2.5", "moonshot-v1-128k"];
-  }
+  const remote = Array.isArray(options.models)
+    ? options.models.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  const defaults = remote.length > 0 ? remote : fallbackModelSuggestions(provider);
   const ids = [];
   if (current) ids.push(current);
   for (const id of defaults) {
     if (id && !ids.includes(id)) ids.push(id);
   }
-  return ids.map((id) => ({
+  return ids.slice(0, 40).map((id) => ({
     id,
-    desc: id === current ? "current" : "",
+    desc: id === current
+      ? "current · pick thinking next"
+      : (remote.length > 0 ? "models route · pick thinking next" : "pick thinking next"),
+    hasChildren: true,
   }));
 }
 
+function suggestUcodeThinkingLevels(state = {}) {
+  return suggestThinkingLevels({ current: currentThinkingLevel(state) });
+}
+
 module.exports = {
   applyUcodeModelCommand,
   suggestUcodeModels,
+  suggestUcodeThinkingLevels,
+  listUcodeModels,
+  fallbackModelSuggestions,
+  currentThinkingLevel,
+  persistThinkingLevel,
 };