@zhihand/mcp 0.19.0 → 0.20.0

package/bin/zhihand

@@ -6,7 +6,7 @@ import { startStdioServer } from "../dist/index.js";
 import { startDaemon, stopDaemon, isAlreadyRunning } from "../dist/daemon/index.js";
 import { detectCLITools, formatDetectedTools } from "../dist/cli/detect.js";
 import { detectAndSetupOpenClaw } from "../dist/cli/openclaw.js";
-import { loadDefaultCredential, loadBackendConfig, saveBackendConfig } from "../dist/core/config.js";
+import { loadDefaultCredential, loadBackendConfig, saveBackendConfig, DEFAULT_MODELS } from "../dist/core/config.js";
 import { executePairing } from "../dist/core/pair.js";
 import { configureMCP, displayName } from "../dist/cli/mcp-config.js";
 
@@ -23,6 +23,7 @@ const { positionals, values } = parseArgs({
   strict: false,
   options: {
     device: { type: "string" },
+    model: { type: "string", short: "m" },
     help: { type: "boolean", short: "h", default: false },
     detach: { type: "boolean", short: "d", default: false },
     port: { type: "string" },
@@ -41,9 +42,10 @@ Usage:
   zhihand stop               Stop daemon
   zhihand status             Show status (pairing, backend, brain)
 
-  zhihand gemini             Switch backend to Gemini CLI
-  zhihand claude             Switch backend to Claude Code
-  zhihand codex              Switch backend to Codex CLI
+  zhihand gemini             Switch backend to Gemini CLI (default model: flash)
+  zhihand claude             Switch backend to Claude Code (default model: sonnet)
+  zhihand codex              Switch backend to Codex CLI (default model: gpt-5.4-mini)
+  zhihand gemini --model pro Switch backend with custom model
 
   zhihand setup              Interactive setup: pair + configure + start
   zhihand pair               Pair with a phone device
@@ -53,6 +55,7 @@ Usage:
 
 Options:
   --device <name>    Use a specific paired device
+  --model, -m <name> Set model alias (e.g. flash, pro, sonnet, opus, gpt-5.4-mini)
   --port <port>      Override daemon port (default: 18686)
   -d, --detach       Run daemon in background
   -h, --help         Show this help
@@ -82,12 +85,15 @@ if (Object.prototype.hasOwnProperty.call(CLI_TOOL_MAP, command)) {
   const config = loadBackendConfig();
   const previous = config.activeBackend;
 
-  if (previous === backendName) {
-    console.log(`Already using ${displayName(backendName)} as backend.`);
+  const userModel = values.model ?? null;
+  const effectiveModel = userModel ?? DEFAULT_MODELS[backendName];
+
+  if (previous === backendName && !userModel) {
+    console.log(`Already using ${displayName(backendName)} as backend (model: ${effectiveModel}).`);
     process.exit(0);
   }
 
-  console.log(`Switching backend to ${displayName(backendName)}...`);
+  console.log(`Switching backend to ${displayName(backendName)} (model: ${effectiveModel})...`);
 
   // Configure MCP (HTTP transport)
   const { configured, removed } = configureMCP(backendName, previous);
@@ -100,7 +106,7 @@ if (Object.prototype.hasOwnProperty.call(CLI_TOOL_MAP, command)) {
         const res = await fetch(`http://127.0.0.1:${port}/internal/backend`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ backend: backendName }),
+          body: JSON.stringify({ backend: backendName, model: userModel }),
           signal: AbortSignal.timeout(5000),
         });
         if (res.ok) {
@@ -108,11 +114,11 @@ if (Object.prototype.hasOwnProperty.call(CLI_TOOL_MAP, command)) {
         }
       } catch {
         // Daemon not responding, just save config
-        saveBackendConfig({ activeBackend: backendName });
+        saveBackendConfig({ activeBackend: backendName, model: userModel });
         console.log(`\nBackend config saved. Daemon not responding — restart with 'zhihand start'.`);
       }
     } else {
-      saveBackendConfig({ activeBackend: backendName });
+      saveBackendConfig({ activeBackend: backendName, model: userModel });
       console.log(`\nBackend switched to ${displayName(backendName)}.`);
       console.log(`Start the daemon to receive prompts: zhihand start`);
     }
@@ -131,17 +137,29 @@ switch (command) {
   case "relay": {
     if (values.detach) {
       const { spawn: spawnChild } = await import("node:child_process");
+      const fsSync = await import("node:fs");
+      const pathMod = await import("node:path");
+      const osMod = await import("node:os");
+
       const args = [process.argv[1], "start"];
       if (values.port) args.push("--port", values.port);
       if (values.device) args.push("--device", values.device);
 
+      // Write daemon logs to ~/.zhihand/daemon.log
+      const zhihandDir = pathMod.default.join(osMod.default.homedir(), ".zhihand");
+      fsSync.default.mkdirSync(zhihandDir, { recursive: true });
+      const logPath = pathMod.default.join(zhihandDir, "daemon.log");
+      const logFd = fsSync.default.openSync(logPath, "a");
+
       const child = spawnChild(process.execPath, args, {
         detached: true,
-        stdio: "ignore",
+        stdio: ["ignore", logFd, logFd],
         env: { ...process.env },
       });
       child.unref();
+      fsSync.default.closeSync(logFd);
       console.log(`Daemon starting in background (PID ${child.pid}).`);
+      console.log(`Logs: ${logPath}`);
       process.exit(0);
     }
     const port = values.port ? parseInt(values.port, 10) : undefined;
@@ -187,7 +205,11 @@ switch (command) {
     } else {
       console.log("No paired device. Run: zhihand setup");
     }
-    console.log(`Active backend: ${backend.activeBackend ? displayName(backend.activeBackend) : "(none)"}`);
+    const backendLabel = backend.activeBackend ? displayName(backend.activeBackend) : "(none)";
+    const modelLabel = backend.activeBackend
+      ? (backend.model ?? DEFAULT_MODELS[backend.activeBackend])
+      : "-";
+    console.log(`Active backend: ${backendLabel} (model: ${modelLabel})`);
     console.log(`Daemon: ${daemonPid ? `running (PID ${daemonPid})` : "not running"}`);
 
     // If daemon running, get live status

package/dist/cli/detect.d.ts

@@ -1,6 +1,7 @@
 export interface CLITool {
     name: "claudecode" | "codex" | "gemini" | "openclaw";
     command: string;
+    resolvedPath: string;
     version: string;
     loggedIn: boolean;
     priority: number;

package/dist/cli/detect.js

@@ -1,4 +1,5 @@
 import { execSync } from "node:child_process";
+import { resolveExecutable, resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
 function tryExec(cmd) {
     try {
         return execSync(cmd, { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
@@ -7,41 +8,39 @@ function tryExec(cmd) {
         return null;
     }
 }
-function isCommandAvailable(cmd) {
-    return tryExec(`which ${cmd}`) !== null;
-}
 async function detectClaudeCode() {
-    if (!isCommandAvailable("claude"))
-        return null;
-    const version = tryExec("claude --version") ?? "unknown";
-    // Check login: claude has config in ~/.claude/
+    const resolved = resolveClaude();
+    if (resolved === "claude")
+        return null; // bare name = not found
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = tryExec("ls ~/.claude/settings.json") !== null;
-    return { name: "claudecode", command: "claude", version, loggedIn, priority: 1 };
+    return { name: "claudecode", command: "claude", resolvedPath: resolved, version, loggedIn, priority: 1 };
 }
 async function detectCodex() {
-    if (!isCommandAvailable("codex"))
+    const resolved = resolveCodex();
+    if (resolved === "codex")
         return null;
-    const version = tryExec("codex --version") ?? "unknown";
-    // Check login: OPENAI_API_KEY env var or config
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = !!process.env.OPENAI_API_KEY || tryExec("ls ~/.codex/") !== null;
-    return { name: "codex", command: "codex", version, loggedIn, priority: 2 };
+    return { name: "codex", command: "codex", resolvedPath: resolved, version, loggedIn, priority: 2 };
 }
 async function detectGemini() {
-    if (!isCommandAvailable("gemini"))
+    const resolved = resolveGemini();
+    if (resolved === "gemini")
         return null;
-    const version = tryExec("gemini --version") ?? "unknown";
-    // Check login: oauth_creds.json or GOOGLE_API_KEY env var
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = !!process.env.GOOGLE_API_KEY
         || !!process.env.GEMINI_API_KEY
         || tryExec("ls ~/.gemini/oauth_creds.json") !== null;
-    return { name: "gemini", command: "gemini", version, loggedIn, priority: 3 };
+    return { name: "gemini", command: "gemini", resolvedPath: resolved, version, loggedIn, priority: 3 };
 }
 async function detectOpenClaw() {
-    if (!isCommandAvailable("openclaw"))
+    const resolved = resolveExecutable("openclaw", []);
+    if (resolved === "openclaw")
         return null;
-    const version = tryExec("openclaw --version") ?? "unknown";
+    const version = tryExec(`"${resolved}" --version`) ?? "unknown";
     const loggedIn = tryExec("ls ~/.openclaw/openclaw.json") !== null;
-    return { name: "openclaw", command: "openclaw", version, loggedIn, priority: 4 };
+    return { name: "openclaw", command: "openclaw", resolvedPath: resolved, version, loggedIn, priority: 4 };
 }
 export async function detectCLITools() {
     const results = await Promise.allSettled([

package/dist/cli/mcp-config.js

@@ -1,21 +1,26 @@
 import { execSync } from "node:child_process";
+import { resolveClaude, resolveCodex, resolveGemini } from "../core/resolve-path.js";
 const DEFAULT_PORT = 18686;
 function mcpUrl() {
     const port = parseInt(process.env.ZHIHAND_PORT ?? "", 10) || DEFAULT_PORT;
     return `http://localhost:${port}/mcp`;
 }
+/** Quote a path for shell execution (handles spaces in paths) */
+function q(p) {
+    return `"${p}"`;
+}
 const MCP_COMMANDS = {
     claudecode: {
-        add: () => `claude mcp add --transport http zhihand ${mcpUrl()}`,
-        remove: "claude mcp remove zhihand",
+        add: () => `${q(resolveClaude())} mcp add --transport http zhihand ${mcpUrl()}`,
+        remove: () => `${q(resolveClaude())} mcp remove zhihand`,
     },
     codex: {
-        add: () => `codex mcp add zhihand --url ${mcpUrl()}`,
-        remove: "codex mcp remove zhihand",
+        add: () => `${q(resolveCodex())} mcp add zhihand --url ${mcpUrl()}`,
+        remove: () => `${q(resolveCodex())} mcp remove zhihand`,
     },
     gemini: {
-        add: () => `gemini mcp add --transport http --scope user zhihand ${mcpUrl()}`,
-        remove: "gemini mcp remove --scope user zhihand",
+        add: () => `${q(resolveGemini())} mcp add --transport http --scope user zhihand ${mcpUrl()}`,
+        remove: () => `${q(resolveGemini())} mcp remove --scope user zhihand`,
     },
 };
 const DISPLAY_NAMES = {
@@ -44,7 +49,7 @@ export function configureMCP(backend, previousBackend) {
         const cmds = MCP_COMMANDS[previousBackend];
         if (cmds) {
             console.log(`  Removing MCP config from ${DISPLAY_NAMES[previousBackend]}...`);
-            removed = tryRun(cmds.remove);
+            removed = tryRun(cmds.remove());
         }
     }
     // Add to new backend

package/dist/core/config.d.ts

@@ -19,7 +19,16 @@ export interface ZhiHandConfig {
 export type BackendName = "claudecode" | "codex" | "gemini" | "openclaw";
 export interface BackendConfig {
     activeBackend: BackendName | null;
+    model?: string | null;
 }
+/**
+ * Default model aliases per backend.
+ * These are generic aliases that the respective CLIs resolve to the latest version:
+ *   - Gemini CLI: "flash" → latest flash model (e.g. gemini-2.5-flash)
+ *   - Claude Code: "sonnet" → latest sonnet (e.g. claude-sonnet-4-20250514)
+ *   - Codex CLI: requires full model name, no alias support
+ */
+export declare const DEFAULT_MODELS: Record<Exclude<BackendName, "openclaw">, string>;
 export declare function resolveZhiHandDir(): string;
 export declare function ensureZhiHandDir(): void;
 export declare function loadCredentialStore(): CredentialStore | null;

package/dist/core/config.js

@@ -1,6 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+/**
+ * Default model aliases per backend.
+ * These are generic aliases that the respective CLIs resolve to the latest version:
+ *   - Gemini CLI: "flash" → latest flash model (e.g. gemini-2.5-flash)
+ *   - Claude Code: "sonnet" → latest sonnet (e.g. claude-sonnet-4-20250514)
+ *   - Codex CLI: requires full model name, no alias support
+ */
+export const DEFAULT_MODELS = {
+    gemini: "flash", // Gemini CLI resolves to latest flash
+    claudecode: "sonnet", // Claude Code resolves to latest sonnet
+    codex: "gpt-5.4-mini", // Codex default: latest GPT mini model
+};
 const ZHIHAND_DIR = path.join(os.homedir(), ".zhihand");
 const CREDENTIALS_PATH = path.join(ZHIHAND_DIR, "credentials.json");
 const STATE_PATH = path.join(ZHIHAND_DIR, "state.json");

package/dist/core/resolve-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolve an executable by name: first try `which`, then check fallback paths.
+ * Supports a single `*` glob segment in fallback paths (for version directories).
+ * Returns the full path, or the bare name as last resort.
+ */
+export declare function resolveExecutable(name: string, fallbackPaths: string[]): string;
+/** Platform-specific fallback paths for gemini */
+export declare function resolveGemini(): string;
+/** Platform-specific fallback paths for claude */
+export declare function resolveClaude(): string;
+/** Platform-specific fallback paths for codex */
+export declare function resolveCodex(): string;

package/dist/core/resolve-path.js

@@ -0,0 +1,99 @@
+/**
+ * Platform-aware executable path resolution.
+ * Shared by both the CLI detection layer and the daemon dispatcher.
+ */
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/** Cache of resolved executable paths to avoid repeated lookups */
+const cache = new Map();
+/**
+ * Resolve an executable by name: first try `which`, then check fallback paths.
+ * Supports a single `*` glob segment in fallback paths (for version directories).
+ * Returns the full path, or the bare name as last resort.
+ */
+export function resolveExecutable(name, fallbackPaths) {
+    const cached = cache.get(name);
+    if (cached)
+        return cached;
+    // Try `which` first (works when the binary is in PATH)
+    try {
+        const resolved = execSync(`which ${name}`, { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (resolved) {
+            cache.set(name, resolved);
+            return resolved;
+        }
+    }
+    catch {
+        // Not in PATH, try fallback locations
+    }
+    for (const candidate of fallbackPaths) {
+        if (candidate.includes("*")) {
+            // Expand one level of wildcard
+            try {
+                const parts = candidate.split("*");
+                if (parts.length === 2) {
+                    const parentDir = parts[0].replace(/\/$/, "");
+                    const suffix = parts[1];
+                    if (fs.existsSync(parentDir)) {
+                        const entries = fs.readdirSync(parentDir, { withFileTypes: true });
+                        // Sort descending to prefer latest version
+                        const dirs = entries
+                            .filter(e => e.isDirectory())
+                            .map(e => e.name)
+                            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+                        for (const d of dirs) {
+                            const full = parentDir + "/" + d + suffix;
+                            if (fs.existsSync(full)) {
+                                cache.set(name, full);
+                                return full;
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+        else {
+            if (fs.existsSync(candidate)) {
+                cache.set(name, candidate);
+                return candidate;
+            }
+        }
+    }
+    // Last resort: return bare name and let spawn fail with a clear error
+    return name;
+}
+/** Platform-specific fallback paths for gemini */
+export function resolveGemini() {
+    return resolveExecutable("gemini", [
+        "/opt/homebrew/bin/gemini",
+        "/usr/local/bin/gemini",
+        path.join(os.homedir(), ".local/bin/gemini"),
+        path.join(os.homedir(), "bin/gemini"),
+    ]);
+}
+/** Platform-specific fallback paths for claude */
+export function resolveClaude() {
+    const home = os.homedir();
+    const fallbacks = [];
+    if (process.platform === "darwin") {
+        fallbacks.push(path.join(home, "Library/Application Support/Claude/claude-code/*/claude.app/Contents/MacOS/claude"), "/usr/local/bin/claude", "/opt/homebrew/bin/claude");
+    }
+    else if (process.platform === "linux") {
+        fallbacks.push("/usr/local/bin/claude", path.join(home, ".local/bin/claude"), "/snap/bin/claude");
+    }
+    else if (process.platform === "win32") {
+        fallbacks.push(path.join(process.env.LOCALAPPDATA ?? "", "Programs/Claude/claude.exe"), path.join(process.env.APPDATA ?? "", "npm/claude.cmd"));
+    }
+    return resolveExecutable("claude", fallbacks);
+}
+/** Platform-specific fallback paths for codex */
+export function resolveCodex() {
+    return resolveExecutable("codex", [
+        "/opt/homebrew/bin/codex",
+        "/usr/local/bin/codex",
+        path.join(os.homedir(), ".local/bin/codex"),
+    ]);
+}

package/dist/daemon/dispatcher.js

@@ -1,9 +1,10 @@
-import { spawn, execSync } from "node:child_process";
-import fs from "node:fs";
+import { spawn } from "node:child_process";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
+import { DEFAULT_MODELS } from "../core/config.js";
+import { resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
 const CLI_TIMEOUT = 120_000; // 120s
 const SIGKILL_DELAY = 2_000; // 2s after SIGTERM
 const MAX_OUTPUT_BYTES = 100 * 1024; // 100KB
@@ -13,93 +14,6 @@ const SESSION_STABILITY_DELAY = 2_000; // wait 2s after outcome before returning
 // Resolve pty-wrap.py relative to this file (works from both src/ and dist/)
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PTY_WRAP_SCRIPT = path.resolve(__dirname, "../../scripts/pty-wrap.py");
-// ── Executable Path Resolution ───────────────────────────────
-/** Cache of resolved executable paths to avoid repeated lookups */
-const executableCache = new Map();
-/**
- * Resolve the full path of a CLI executable.
- * Searches PATH first via `which`, then falls back to platform-specific known locations.
- */
-function resolveExecutable(name, fallbackPaths) {
-    const cached = executableCache.get(name);
-    if (cached)
-        return cached;
-    // Try `which` first (works when the binary is in PATH)
-    try {
-        const resolved = execSync(`which ${name}`, { encoding: "utf8", timeout: 5000 }).trim();
-        if (resolved) {
-            executableCache.set(name, resolved);
-            return resolved;
-        }
-    }
-    catch {
-        // Not in PATH, try fallback locations
-    }
-    // Try known platform-specific paths
-    for (const candidate of fallbackPaths) {
-        // Support glob-like patterns with * (e.g. version directories)
-        if (candidate.includes("*")) {
-            try {
-                const dir = path.dirname(candidate);
-                const pattern = path.basename(candidate);
-                // Walk one level of glob for version directories
-                const parentDir = path.dirname(dir);
-                const globSegment = path.basename(dir);
-                if (globSegment === "*") {
-                    const entries = fs.readdirSync(parentDir, { withFileTypes: true });
-                    // Sort descending to prefer latest version
-                    const dirs = entries
-                        .filter(e => e.isDirectory())
-                        .map(e => e.name)
-                        .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-                    for (const d of dirs) {
-                        const full = path.join(parentDir, d, pattern);
-                        if (fs.existsSync(full)) {
-                            executableCache.set(name, full);
-                            return full;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Glob resolution failed, skip
-            }
-        }
-        else {
-            if (fs.existsSync(candidate)) {
-                executableCache.set(name, candidate);
-                return candidate;
-            }
-        }
-    }
-    // Last resort: return bare name and let spawn fail with a clear error
-    return name;
-}
-/** Resolve gemini executable path */
-function resolveGemini() {
-    return resolveExecutable("gemini", [
-        "/opt/homebrew/bin/gemini", // macOS ARM (Homebrew)
-        "/usr/local/bin/gemini", // macOS Intel / Linux
-        path.join(os.homedir(), ".local/bin/gemini"), // pip --user install
-        path.join(os.homedir(), "bin/gemini"),
-    ]);
-}
-/** Resolve claude executable path */
-function resolveClaude() {
-    const platform = process.platform;
-    const fallbacks = [];
-    if (platform === "darwin") {
-        // macOS: Claude Code installed via Claude desktop app
-        fallbacks.push(path.join(os.homedir(), "Library/Application Support/Claude/claude-code/*/claude.app/Contents/MacOS/claude"), "/usr/local/bin/claude", "/opt/homebrew/bin/claude");
-    }
-    else if (platform === "linux") {
-        fallbacks.push("/usr/local/bin/claude", path.join(os.homedir(), ".local/bin/claude"), "/snap/bin/claude");
-    }
-    else if (platform === "win32") {
-        fallbacks.push(path.join(process.env.LOCALAPPDATA ?? "", "Programs/Claude/claude.exe"), path.join(process.env.APPDATA ?? "", "npm/claude.cmd"));
-    }
-    return resolveExecutable("claude", fallbacks);
-}
 // Gemini session directories
 const GEMINI_TMP_DIR = path.join(os.homedir(), ".gemini", "tmp");
 let activeChild = null;
@@ -454,14 +368,17 @@ ${userPrompt}`;
 export function dispatchToCLI(backend, prompt, log, model) {
     const startTime = Date.now();
     const wrappedPrompt = wrapPrompt(prompt);
+    // Resolve model: explicit > env > default
+    const resolvedModel = resolveModel(backend, model);
+    log(`[dispatch] Backend: ${backend}, Model: ${resolvedModel}`);
     if (backend === "gemini") {
-        return dispatchGemini(wrappedPrompt, startTime, log, model);
+        return dispatchGemini(wrappedPrompt, startTime, log, resolvedModel);
     }
     if (backend === "codex") {
-        return dispatchCodex(wrappedPrompt, startTime, model);
+        return dispatchCodex(wrappedPrompt, startTime, resolvedModel);
     }
     if (backend === "claudecode") {
-        return dispatchClaude(wrappedPrompt, startTime, model);
+        return dispatchClaude(wrappedPrompt, startTime, resolvedModel);
     }
     return Promise.resolve({
         text: `Unsupported backend: ${backend}`,
@@ -469,12 +386,38 @@ export function dispatchToCLI(backend, prompt, log, model) {
         durationMs: 0,
     });
 }
+/**
+ * Resolve the model to use for a backend.
+ * Priority: explicit parameter > ZHIHAND_MODEL env > backend-specific env > default alias.
+ *
+ * Each backend CLI handles alias→full-name resolution natively:
+ *   - Gemini CLI: "flash" → gemini-2.5-flash, "pro" → gemini-2.5-pro
+ *   - Claude Code: "sonnet" → claude-sonnet-4-*, "opus" → claude-opus-4-*, "haiku" → claude-haiku-4-*
+ *   - Codex CLI: no alias support — pass full model name directly (e.g. "o4-mini", "codex-mini")
+ */
+function resolveModel(backend, explicit) {
+    if (explicit)
+        return explicit;
+    // Global env override
+    const globalEnv = process.env.ZHIHAND_MODEL;
+    if (globalEnv)
+        return globalEnv;
+    // Per-backend env override
+    const envMap = {
+        gemini: process.env.ZHIHAND_GEMINI_MODEL,
+        claudecode: process.env.ZHIHAND_CLAUDE_MODEL,
+        codex: process.env.ZHIHAND_CODEX_MODEL,
+    };
+    const perBackend = envMap[backend];
+    if (perBackend)
+        return perBackend;
+    return DEFAULT_MODELS[backend];
+}
 // ── Gemini Dispatch (PTY + Session File Monitoring) ────────
 function dispatchGemini(prompt, startTime, log, model) {
-    const geminiModel = model ?? process.env.CLAUDE_GEMINI_MODEL ?? "gemini-3.1-pro-preview";
     const cliArgs = [
         "--approval-mode", "yolo",
-        "--model", geminiModel,
+        "--model", model,
         "-i", prompt,
     ];
     const env = {
@@ -501,12 +444,10 @@ function dispatchCodex(prompt, startTime, model) {
     // --dangerously-bypass-approvals-and-sandbox is required so MCP tool calls
     // are not auto-cancelled in non-interactive mode (--full-auto cancels them)
     const args = ["exec", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check", "--json"];
-    const codexModel = model ?? process.env.CLAUDE_CODEX_MODEL;
-    if (codexModel) {
-        args.push("-m", codexModel);
-    }
+    args.push("-m", model);
     args.push(prompt);
-    const child = spawn("codex", args, {
+    const codexPath = resolveCodex();
+    const child = spawn(codexPath, args, {
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,
@@ -517,7 +458,7 @@ function dispatchCodex(prompt, startTime, model) {
 // ── Claude Dispatch ────────────────────────────────────────
 function dispatchClaude(prompt, startTime, model) {
     const claudePath = resolveClaude();
-    const child = spawn(claudePath, ["-p", prompt, "--output-format", "json"], {
+    const child = spawn(claudePath, ["-p", prompt, "--model", model, "--output-format", "json"], {
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false,

package/dist/daemon/index.js

@@ -5,7 +5,8 @@ import path from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 // Transport type used only for cleanup interface
 import { createServer as createMcpServer } from "../index.js";
-import { resolveConfig, loadBackendConfig, saveBackendConfig, resolveZhiHandDir, ensureZhiHandDir, } from "../core/config.js";
+import { resolveConfig, loadBackendConfig, saveBackendConfig, resolveZhiHandDir, ensureZhiHandDir, DEFAULT_MODELS, } from "../core/config.js";
+import { PACKAGE_VERSION } from "../index.js";
 import { startHeartbeatLoop, stopHeartbeatLoop, sendBrainOffline } from "./heartbeat.js";
 import { PromptListener } from "./prompt-listener.js";
 import { dispatchToCLI, postReply, killActiveChild } from "./dispatcher.js";
@@ -13,6 +14,7 @@ const DEFAULT_PORT = 18686;
 const PID_FILE = "daemon.pid";
 // ── State ──────────────────────────────────────────────────
 let activeBackend = null;
+let activeModel = null; // user-selected model alias, null = use default
 let isProcessing = false;
 const promptQueue = [];
 function log(msg) {
@@ -28,7 +30,7 @@ async function processPrompt(config, prompt) {
     }
     const preview = prompt.text.length > 40 ? prompt.text.slice(0, 40) + "..." : prompt.text;
     log(`[relay] Prompt: "${preview}" → dispatching to ${activeBackend}...`);
-    const result = await dispatchToCLI(activeBackend, prompt.text, log);
+    const result = await dispatchToCLI(activeBackend, prompt.text, log, activeModel ?? undefined);
     const ok = await postReply(config, prompt.id, result.text);
     const dur = (result.durationMs / 1000).toFixed(1);
     if (ok) {
@@ -69,7 +71,7 @@ function handleInternalAPI(req, res) {
         });
         req.on("end", () => {
             try {
-                const { backend } = JSON.parse(body);
+                const { backend, model } = JSON.parse(body);
                 const allowed = ["claudecode", "codex", "gemini"];
                 if (!allowed.includes(backend)) {
                     res.writeHead(400, { "Content-Type": "application/json" });
@@ -77,10 +79,12 @@ function handleInternalAPI(req, res) {
                     return;
                 }
                 activeBackend = backend;
-                saveBackendConfig({ activeBackend });
-                log(`[config] Backend switched to ${activeBackend}.`);
+                activeModel = model ?? null;
+                saveBackendConfig({ activeBackend, model: activeModel });
+                const effectiveModel = activeModel ?? DEFAULT_MODELS[activeBackend];
+                log(`[config] Backend switched to ${activeBackend}, model: ${effectiveModel}`);
                 res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ ok: true, backend: activeBackend }));
+                res.end(JSON.stringify({ ok: true, backend: activeBackend, model: effectiveModel }));
             }
             catch {
                 res.writeHead(400, { "Content-Type": "application/json" });
@@ -90,9 +94,12 @@ function handleInternalAPI(req, res) {
         return true;
     }
     if (url === "/internal/status" && req.method === "GET") {
+        const effectiveModel = activeBackend ? (activeModel ?? DEFAULT_MODELS[activeBackend]) : null;
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
+            version: PACKAGE_VERSION,
             backend: activeBackend,
+            model: effectiveModel,
             processing: isProcessing,
             queueLength: promptQueue.length,
             pid: process.pid,
@@ -155,9 +162,19 @@ export async function startDaemon(options) {
         log("Run 'zhihand setup' to pair a device first.");
         process.exit(1);
     }
-    // Load backend
+    // Load backend + model
     const backendConfig = loadBackendConfig();
     activeBackend = backendConfig.activeBackend ?? null;
+    activeModel = backendConfig.model ?? null;
+    // Log startup info
+    log(`ZhiHand v${PACKAGE_VERSION} starting...`);
+    if (activeBackend) {
+        const effectiveModel = activeModel ?? DEFAULT_MODELS[activeBackend];
+        log(`[config] Backend: ${activeBackend}, Model: ${effectiveModel}`);
+    }
+    else {
+        log(`[config] No backend configured. Use: zhihand gemini / zhihand claude / zhihand codex`);
+    }
     // MCP sessions: each client gets its own McpServer + Transport pair
     // because McpServer.connect() can only be called once per instance
     const MAX_MCP_SESSIONS = 20;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const PACKAGE_VERSION = "0.20.0";
 export declare function createServer(deviceName?: string): McpServer;
 export declare function startStdioServer(deviceName?: string): Promise<void>;

package/dist/index.js

@@ -5,7 +5,7 @@ import { controlSchema, screenshotSchema, pairSchema } from "./tools/schemas.js"
 import { executeControl } from "./tools/control.js";
 import { handleScreenshot } from "./tools/screenshot.js";
 import { handlePair } from "./tools/pair.js";
-const PACKAGE_VERSION = "0.19.0";
+export const PACKAGE_VERSION = "0.20.0";
 export function createServer(deviceName) {
     const server = new McpServer({
         name: "zhihand",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhihand/mcp",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "private": false,
   "type": "module",
   "description": "ZhiHand MCP Server — phone control tools for Claude Code, Codex, Gemini CLI, and OpenClaw",