Launch-first CLI with auto-detect TUI/model IDs

Rewrite CLI to launch immediately: localcode goose, localcode qwen3-coder,
localcode claude gpt-oss. Parser auto-detects TUI and model IDs from
registries. Add qwen3-coder, glm-flash, gpt-oss models. Add cline,
droid, openclaw TUIs via ollama launch. Use ollamaLaunch field to
delegate to ollama launch for supported TUIs. Auto-pull models before
launch. Set GOOSE_MODEL env var for goose. Default model now qwen3-coder.

src/commands/list.ts

···
+import { execSync } from "node:child_process";
+import { getChatModels, getAutocompleteModels } from "../registry/models.js";
+import { TUIS } from "../registry/tuis.js";
+import { getActiveChatModel, getActiveAutocompleteModel, getActiveTui } from "../runtime-config.js";
+import { commandExists } from "../util.js";
+
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[0;32m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+function isPulled(ollamaTag: string): boolean {
+  try {
+    const output = execSync("ollama list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return output.includes(ollamaTag);
+  } catch {
+    return false;
+  }
+}
+
+export function listModels(): void {
+  const activeChatId = getActiveChatModel().id;
+  const activeAutoId = getActiveAutocompleteModel().id;
+
+  console.log(`\n${BOLD}Chat models:${RESET}`);
+  for (const m of getChatModels()) {
+    const active = m.id === activeChatId ? ` ${GREEN}<- active${RESET}` : "";
+    const pulled = isPulled(m.ollamaTag) ? "" : ` ${DIM}(not pulled)${RESET}`;
+    console.log(
+      `  ${BOLD}${m.id}${RESET}  ${m.name}  ${DIM}${m.ollamaTag}${RESET}${active}${pulled}`,
+    );
+  }
+
+  console.log(`\n${BOLD}Autocomplete models:${RESET}`);
+  for (const m of getAutocompleteModels()) {
+    const active = m.id === activeAutoId ? ` ${GREEN}<- active${RESET}` : "";
+    const pulled = isPulled(m.ollamaTag) ? "" : ` ${DIM}(not pulled)${RESET}`;
+    console.log(
+      `  ${BOLD}${m.id}${RESET}  ${m.name}  ${DIM}${m.ollamaTag}${RESET}${active}${pulled}`,
+    );
+  }
+  console.log("");
+}
+
+export function listTuis(): void {
+  const activeId = getActiveTui().id;
+
+  console.log(`\n${BOLD}Available TUIs:${RESET}`);
+  for (const t of TUIS) {
+    const active = t.id === activeId ? ` ${GREEN}<- active${RESET}` : "";
+    const installed = commandExists(t.checkCmd)
+      ? ""
+      : ` ${DIM}(not installed)${RESET}`;
+    console.log(`  ${BOLD}${t.id}${RESET}  ${t.name}${active}${installed}`);
+  }
+  console.log("");
+}

src/commands/run.ts

···
 import { spawn, execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { OLLAMA_PORT } from "../config.js";
-import { getActiveTui, getActiveChatModel } from "../runtime-config.js";
-import { log } from "../log.js";
-import { ensureOllama } from "./server.js";
+import {
+  loadConfig,
+  saveConfig,
+  getActiveTui,
+  getActiveChatModel,
+} from "../runtime-config.js";
+import { getModelById } from "../registry/models.js";
+import { getTuiById } from "../registry/tuis.js";
+import { log, err } from "../log.js";
+import { ensureOllama, pullIfNeeded } from "./server.js";
+import { commandExists, runPassthrough } from "../util.js";
+import type { ModelDef } from "../registry/models.js";
+import type { TuiDef } from "../registry/tuis.js";
+
+export interface LaunchOverrides {
+  model?: string;
+  tui?: string;
+  passthrough: string[];
+}
 
 function ensureGit(): void {
   if (!existsSync(".git")) {
···
   }
 }
 
-export async function runDefault(args: string[]): Promise<void> {
+function resolveOverrides(overrides: LaunchOverrides): {
+  chatModel: ModelDef;
+  tui: TuiDef;
+} {
+  const config = loadConfig();
+  let changed = false;
+
+  let chatModel: ModelDef;
+  if (overrides.model) {
+    const m = getModelById(overrides.model);
+    if (!m) err(`Unknown model: ${overrides.model}`);
+    if (m.role !== "chat") err(`${overrides.model} is not a chat model.`);
+    chatModel = m;
+    config.chatModel = m.id;
+    changed = true;
+  } else {
+    chatModel = getActiveChatModel();
+  }
+
+  let tui: TuiDef;
+  if (overrides.tui) {
+    const t = getTuiById(overrides.tui);
+    if (!t) err(`Unknown TUI: ${overrides.tui}`);
+    tui = t;
+    config.tui = t.id;
+    changed = true;
+  } else {
+    tui = getActiveTui();
+  }
+
+  if (changed) saveConfig(config);
+
+  return { chatModel, tui };
+}
+
+function ensureTuiInstalled(tui: TuiDef): void {
+  // ollama launch handles installation
+  if (tui.ollamaLaunch) return;
+
+  if (!commandExists(tui.checkCmd)) {
+    log(`Installing ${tui.name}...`);
+    runPassthrough(tui.installCmd);
+  }
+}
+
+export async function runDefault(overrides: LaunchOverrides): Promise<void> {
   await ensureOllama();
+  const { chatModel, tui } = resolveOverrides(overrides);
+  await pullIfNeeded(chatModel.ollamaTag, chatModel.name);
+  ensureTuiInstalled(tui);
   ensureGit();
 
-  const tui = getActiveTui();
-  const chatModel = getActiveChatModel();
+  const args = overrides.passthrough;
   let tuiArgs: string[];
-  let tuiCmd = tui.checkCmd;
+  let tuiCmd: string;
   const env = { ...process.env };
 
-  switch (tui.id) {
-    case "aider":
-      env.OPENAI_API_KEY = "sk-not-needed";
-      env.OPENAI_API_BASE = `http://127.0.0.1:${OLLAMA_PORT}/v1`;
-      tuiArgs = [
-        "--model", `openai/${chatModel.id}`,
-        "--no-show-model-warnings",
-        "--no-check-update",
-        ...args,
-      ];
-      break;
+  if (tui.ollamaLaunch) {
+    // ollama launch handles all config automatically
+    tuiCmd = "ollama";
+    tuiArgs = ["launch", tui.ollamaLaunch, "--model", chatModel.ollamaTag, ...args];
+  } else {
+    tuiCmd = tui.checkCmd;
 
-    case "goose":
-      env.GOOSE_PROVIDER = "ollama";
-      env.OLLAMA_HOST = `http://127.0.0.1:${OLLAMA_PORT}`;
-      tuiArgs = [...args];
-      break;
-
-    case "codex":
-      // Codex reads ~/.codex/config.toml written by writeTuiConfig
-      tuiArgs = ["--provider", "ollama", ...args];
-      break;
+    switch (tui.id) {
+      case "aider":
+        env.OPENAI_API_KEY = "sk-not-needed";
+        env.OPENAI_API_BASE = `http://127.0.0.1:${OLLAMA_PORT}/v1`;
+        tuiArgs = [
+          "--model", `openai/${chatModel.id}`,
+          "--no-show-model-warnings",
+          "--no-check-update",
+          ...args,
+        ];
+        break;
 
-    case "gptme":
-      env.OPENAI_BASE_URL = `http://127.0.0.1:${OLLAMA_PORT}/v1`;
-      tuiArgs = ["--model", `local/${chatModel.ollamaTag}`, ...args];
-      break;
+      case "goose":
+        env.GOOSE_PROVIDER = "ollama";
+        env.GOOSE_MODEL = chatModel.ollamaTag;
+        env.OLLAMA_HOST = `http://127.0.0.1:${OLLAMA_PORT}`;
+        tuiArgs = [...args];
+        break;
 
-    case "claude":
-      // ollama launch claude handles all config automatically
-      tuiCmd = "ollama";
-      tuiArgs = ["launch", "claude", ...args];
-      break;
+      case "gptme":
+        env.OPENAI_BASE_URL = `http://127.0.0.1:${OLLAMA_PORT}/v1`;
+        tuiArgs = ["--model", `local/${chatModel.ollamaTag}`, ...args];
+        break;
 
-    default:
-      tuiArgs = [...args];
-      break;
-  }
+      default:
+        tuiArgs = [...args];
+        break;
+    }
 
-  if (tui.resumeArgs) {
-    tuiArgs.push(...tui.resumeArgs);
+    if (tui.resumeArgs) {
+      tuiArgs.push(...tui.resumeArgs);
+    }
   }
 
-  log(`Launching ${tui.name}...`);
+  log(`Launching ${tui.name} with ${chatModel.name}...`);
   const child = spawn(tuiCmd, tuiArgs, { stdio: "inherit", env });
   child.on("exit", (code) => process.exit(code ?? 0));
 }

src/commands/server.ts

···
   }
 }
 
-function isModelPulled(ollamaTag: string): boolean {
+export function isModelPulled(ollamaTag: string): boolean {
   try {
     const output = execSync("ollama list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     return output.includes(ollamaTag);
···
   }
 }
 
-async function pullIfNeeded(ollamaTag: string, label: string): Promise<void> {
+export async function pullIfNeeded(ollamaTag: string, label: string): Promise<void> {
   if (isModelPulled(ollamaTag)) {
     log(`${label} already pulled: ${ollamaTag}`);
     return;

src/main.ts

···
 import { runSetup } from "./commands/setup.js";
-import { listModels, setChatModel, setAutocompleteModel } from "./commands/models.js";
-import { listTuis, setTui } from "./commands/tuis.js";
+import { listModels, listTuis } from "./commands/list.js";
 import { runBench } from "./commands/bench.js";
 import { runDefault } from "./commands/run.js";
 import { showStatus } from "./commands/status.js";
 import { startServers, stopServers } from "./commands/server.js";
 import { runPipe } from "./commands/pipe.js";
+import { getTuiById } from "./registry/tuis.js";
+import { getModelById } from "./registry/models.js";
 
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
···
   console.log(`
 ${BOLD}localcode${RESET} — local AI coding environment (Ollama)
 
-${BOLD}Usage:${RESET}
-  localcode ${DIM}[flags...]${RESET}              Launch active TUI in current directory
-  localcode status                  Show current config and server health
+${BOLD}Launch:${RESET}
+  localcode                                 Launch with defaults
+  localcode <tui>                           Launch with specified TUI
+  localcode <model>                         Launch with specified model
+  localcode <tui> <model>                   Launch with both overrides
 
 ${BOLD}Server:${RESET}
-  localcode start                   Start Ollama + pull models
-  localcode stop                    Stop Ollama
+  localcode start                           Start Ollama + pull models
+  localcode stop                            Stop Ollama
+  localcode status                          Show config and server health
 
-${BOLD}Config:${RESET}
-  localcode model                   List available models
-  localcode set model <id>          Switch the chat model
-  localcode set autocomplete <id>   Switch the autocomplete model
-  localcode tui                     List available TUIs
-  localcode set tui <id>            Switch the active TUI
+${BOLD}List:${RESET}
+  localcode models                          List available models
+  localcode tuis                            List available TUIs
 
 ${BOLD}Benchmark:${RESET}
-  localcode bench                   Benchmark the running chat model
-  localcode bench history           Show past benchmark results
+  localcode bench                           Benchmark the running chat model
+  localcode bench history                   Show past benchmark results
 
 ${BOLD}Other:${RESET}
-  localcode pipe "prompt"           Pipe stdin through the model
-  localcode setup                   Full install (Ollama, models, tools)
+  localcode pipe "prompt"                   Pipe stdin through the model
+  localcode setup                           Full install (Ollama, models, tools)
 `);
 }
 
+interface LaunchOverrides {
+  model?: string;
+  tui?: string;
+  passthrough: string[];
+}
+
+function parseLaunchArgs(argv: string[]): LaunchOverrides {
+  const overrides: LaunchOverrides = { passthrough: [] };
+  for (const arg of argv) {
+    if (getTuiById(arg)) {
+      overrides.tui = arg;
+    } else if (getModelById(arg)) {
+      overrides.model = arg;
+    } else {
+      overrides.passthrough.push(arg);
+    }
+  }
+  return overrides;
+}
+
 async function main(): Promise<void> {
   const cmd = process.argv[2];
 
   switch (cmd) {
-    case undefined:
-      await runDefault(process.argv.slice(3));
-      break;
-
     case "status":
       await showStatus();
       break;
···
       stopServers();
       break;
 
-    case "model":
     case "models":
       listModels();
       break;
 
-    case "tui":
     case "tuis":
       listTuis();
       break;
 
-    case "set": {
-      const what = process.argv[3];
-      const id = process.argv[4];
-
-      if (what === "model" || what === "chat") {
-        if (!id) {
-          console.error("Usage: localcode set model <model-id>");
-          process.exit(1);
-        }
-        await setChatModel(id);
-      } else if (what === "autocomplete" || what === "auto") {
-        if (!id) {
-          console.error("Usage: localcode set autocomplete <model-id>");
-          process.exit(1);
-        }
-        await setAutocompleteModel(id);
-      } else if (what === "tui") {
-        if (!id) {
-          console.error("Usage: localcode set tui <tui-id>");
-          process.exit(1);
-        }
-        await setTui(id);
-      } else {
-        console.error(`Unknown: localcode set ${what ?? ""}`);
-        console.error("Usage: localcode set model|autocomplete|tui <id>");
-        process.exit(1);
-      }
-      break;
-    }
-
     case "bench": {
       const sub = process.argv[3];
       if (sub === "history") {
···
       printUsage();
       break;
 
-    default:
-      console.error(`Unknown command: ${cmd}`);
-      printUsage();
-      process.exit(1);
+    default: {
+      // Everything else is a launch command with optional overrides:
+      //   localcode
+      //   localcode tui aider
+      //   localcode model qwen3-coder
+      //   localcode model qwen3-coder tui goose
+      const args = process.argv.slice(2);
+      const overrides = parseLaunchArgs(args);
+      await runDefault(overrides);
+      break;
+    }
   }
 }
 

src/registry/models.ts

···
     ctxSize: 16384,
   },
   {
+    id: "qwen3-coder",
+    name: "Qwen3 Coder 30B-A3B",
+    role: "chat",
+    ollamaTag: "qwen3-coder",
+    ctxSize: 65536,
+  },
+  {
+    id: "glm-flash",
+    name: "GLM-4.7 Flash 30B-A3B",
+    role: "chat",
+    ollamaTag: "glm-4.7-flash",
+    ctxSize: 65536,
+  },
+  {
+    id: "gpt-oss",
+    name: "GPT-OSS 20B",
+    role: "chat",
+    ollamaTag: "gpt-oss:20b",
+    ctxSize: 65536,
+  },
+  {
     id: "qwen-1.5b-autocomplete",
     name: "Qwen 2.5 Coder 1.5B",
     role: "autocomplete",

src/registry/tuis.ts

···
   launchArgs: string;
   /** Extra args to pass when resuming a previous session. */
   resumeArgs?: string[];
+  /** If set, launch via `ollama launch <ollamaLaunch> --model <tag>` instead of direct exec. */
+  ollamaLaunch?: string;
 }
 
 export const TUIS: TuiDef[] = [
   {
-    id: "aider",
-    name: "Aider",
-    installCmd: "pipx install aider-chat",
-    checkCmd: "aider",
+    id: "claude",
+    name: "Claude Code",
+    installCmd: "npm install -g @anthropic-ai/claude-code",
+    checkCmd: "claude",
     launchArgs: '"$@"',
+    ollamaLaunch: "claude",
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    installCmd: "npm install -g @openai/codex",
+    checkCmd: "codex",
+    launchArgs: '"$@"',
+    ollamaLaunch: "codex",
   },
   {
     id: "opencode",
···
     installCmd: "npm install -g opencode-ai@latest",
     checkCmd: "opencode",
     launchArgs: '"$@"',
+    ollamaLaunch: "opencode",
   },
   {
     id: "pi",
···
     installCmd: "npm install -g @mariozechner/pi-coding-agent",
     checkCmd: "pi",
     launchArgs: '"$@"',
-    resumeArgs: ["--continue"],
+    ollamaLaunch: "pi",
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    installCmd: "npm install -g @anthropic-ai/cline",
+    checkCmd: "cline",
+    launchArgs: '"$@"',
+    ollamaLaunch: "cline",
+  },
+  {
+    id: "droid",
+    name: "Droid",
+    installCmd: "npm install -g droid",
+    checkCmd: "droid",
+    launchArgs: '"$@"',
+    ollamaLaunch: "droid",
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    installCmd: "npm install -g openclaw",
+    checkCmd: "openclaw",
+    launchArgs: '"$@"',
+    ollamaLaunch: "openclaw",
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    installCmd: "pipx install aider-chat",
+    checkCmd: "aider",
+    launchArgs: '"$@"',
   },
   {
     id: "goose",
     name: "Goose",
     installCmd: "brew install block-goose-cli",
     checkCmd: "goose",
-    launchArgs: '"$@"',
-  },
-  {
-    id: "codex",
-    name: "Codex CLI",
-    installCmd: "npm install -g @openai/codex",
-    checkCmd: "codex",
     launchArgs: '"$@"',
   },
   {
···
     checkCmd: "gptme",
     launchArgs: '"$@"',
     resumeArgs: ["-r"],
-  },
-  {
-    id: "claude",
-    name: "Claude Code",
-    installCmd: "npm install -g @anthropic-ai/claude-code",
-    checkCmd: "claude",
-    launchArgs: '"$@"',
-    resumeArgs: ["--continue"],
   },
 ];
 

src/runtime-config.ts

···
 const CONFIG_PATH = join(homedir(), ".config", "localcode", "config.json");
 
 const DEFAULTS: RuntimeConfig = {
-  chatModel: "qwen-32b-chat",
+  chatModel: "qwen3-coder",
   autocompleteModel: "qwen-1.5b-autocomplete",
   tui: "aider",
 };