@nanhara/hara 0.89.0 → 0.98.0

package/dist/index.js

@@ -2,24 +2,26 @@
 import { Command } from "commander";
 import { createInterface } from "node:readline/promises";
 import { emitKeypressEvents } from "node:readline";
-import { runTui } from "./tui/run.js";
+import { runTui, askConfirm } from "./tui/run.js";
 import { readClipboardImage, mediaTypeFor } from "./images.js";
 import { describeImages, locateImage, classifyVision, SCREENSHOT_SYSTEM } from "./vision.js";
 import { setTheme } from "./tui/theme.js";
 import { memoryDigest, memoryDir, readRecentLogs, scaffoldMemory } from "./memory/store.js";
 import { nextMode as cycleMode } from "./tui/InputBox.js";
 import { stdin, stdout } from "node:process";
+import { execFileSync } from "node:child_process";
 import { readFileSync, existsSync, writeFileSync, rmSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { loadConfig, configPath, readRawConfig, writeConfigValue, setModelVisionOverride, providerEnvKey, CONFIG_KEYS, APPROVAL_MODES, SANDBOX_MODES, } from "./config.js";
+import { dirname, join, relative } from "node:path";
+import { loadConfig, configPath, readRawConfig, writeConfigValue, setModelVisionOverride, providerEnvKey, providerDefaultBaseURL, CONFIG_KEYS, APPROVAL_MODES, SANDBOX_MODES, REASONING_EFFORTS, } from "./config.js";
 import { runAgent } from "./agent/loop.js";
 import { notifyDone } from "./notify.js";
 import { startMcpServer, mcpServeToolNames } from "./mcp/server.js";
 import { completionScript } from "./completions.js";
 import { renderSessionMarkdown } from "./export.js";
-import { loadEnrollment, clearEnrollment, enrollDevice, heartbeat, gatewayBaseURL, syncOrgRoles } from "./org-fleet/enroll.js";
+import { clearEnrollment, enrollDevice, heartbeat, syncOrgRoles } from "./org-fleet/enroll.js";
+import { loadActiveProfile, listProfiles, useProfile, addProfile, upsertProfile, removeProfile, setModel as setProfileModel, resetModel as resetProfileModel, getProfile, effectiveModel, routingLabel, routeHost, activeId, resolveActive, setFlagOverride, writePin, removePin, pinFilePath, DEFAULT_ORG_ID, PERSONAL_ID, } from "./profile/profile.js";
 import { loadPermissionRules, scaffoldPermissions, globalPermissionsPath, projectPermissionsPath } from "./security/permissions.js";
 import { routingProvider } from "./agent/route.js";
 import { shouldAutoCompact } from "./agent/compact.js";
@@ -42,9 +44,10 @@ import { collectRepoChunks, collectDirChunks, buildIndex, indexPath, indexExists
 import { searchHybrid } from "./search/hybrid.js";
 import { expandMentions, fileCandidates } from "./context/mentions.js";
 import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, listSessions, latestForCwd, titleFrom, slugify, } from "./session/store.js";
+import { setSessionForceModel, isSessionForceModel, effectiveRoleModel } from "./session/session-model.js";
 import { loadRoles, scaffoldRoles, subagentToolFilter } from "./org/roles.js";
 import { loadSkillIndex, loadSkillBody, scaffoldSkills, globalSkillsDir } from "./skills/skills.js";
-import { installPlugin, uninstallPlugin, listInstalled, enabledPlugins, setPluginEnabled, pluginMcpServers, pluginHooks } from "./plugins/plugins.js";
+import { installPlugin, uninstallPlugin, listInstalled, enabledPlugins, setPluginEnabled, pluginMcpServers, pluginHooks, haraBinDir } from "./plugins/plugins.js";
 import { routeByKeywords, buildDispatchPrompt, parseRoleId } from "./org/router.js";
 import { decompose, topoOrder, topoWaves, savePlan, loadPlan, atomPrompt, verify, runCheck } from "./org/planner.js";
 import { connectMcpServers, closeMcp } from "./mcp/client.js";
@@ -65,6 +68,8 @@ import "./tools/skill.js"; // register the skill loader tool
 import "./tools/codebase.js"; // register codebase_search (repo as a knowledge base)
 import "./tools/todo.js"; // register todo_write (inline task checklist)
 import "./tools/send.js"; // register send_file (self-gates on HARA_GATEWAY — pushes a file to the chat)
+import "./tools/external_agent.js"; // register external_agent (delegate to claude-code / codex headless)
+import "./tools/ask_user.js"; // register ask_user (pause mid-turn to ask the user a structured question)
 import { computerBackends } from "./tools/computer.js"; // register the computer tool + expose the backend probe
 const here = dirname(fileURLToPath(import.meta.url));
 // Version: from a build-time define in the compiled single-binary (no package.json on its virtual FS),
@@ -82,24 +87,44 @@ const pkg = {
 };
 const maskKey = (v) => (v ? `${v.slice(0, 7)}…${v.slice(-4)}` : "(unset)");
 async function buildProvider(cfg) {
-    if (cfg.provider === "qwen-oauth") {
+    // Identity-profile is the source of truth for routing. `cfg` is the *merged* HaraConfig (env +
+    // project + global) and still drives non-routing concerns (model overrides, baseURL fallbacks
+    // for things like vision/route/fallback sidecars). The active profile decides "where to send
+    // requests" — gateway (deviceToken at the gateway) vs BYOK (user's key direct to the provider).
+    const ap = loadActiveProfile();
+    // CFG-OVERRIDE PATH: when a sidecar (vision / route / fallback) calls buildProvider with a tweaked
+    // cfg that explicitly carries an apiKey + baseURL, honor those over the profile — they're the
+    // sidecar's intended target. Detected by "cfg.apiKey present + cfg.baseURL present and we're not
+    // routing to a gateway." This keeps `withRouting`/vision unchanged.
+    const isSidecarOverride = !!cfg.apiKey && !!cfg.baseURL && ap.kind === "byok" && cfg.apiKey !== ap.apiKey;
+    if (ap.kind === "gateway" && !isSidecarOverride) {
+        if (!ap.gatewayUrl || !ap.deviceToken)
+            return null;
+        const baseURL = ap.baseURL || `${ap.gatewayUrl.replace(/\/$/, "")}/v1`;
+        const model = cfg.model || effectiveModel(ap);
+        return createOpenAIProvider({ apiKey: ap.deviceToken, baseURL, model, label: "hara-gateway", reasoningEffort: cfg.reasoningEffort });
+    }
+    // BYOK paths — use the active profile's provider/key/baseURL by default, but let the merged cfg
+    // override (so `--profile`/`HARA_PROFILE`-overridden values flow + sidecar provider builds work).
+    const provider = (cfg.provider && cfg.provider !== "hara-gateway" ? cfg.provider : ap.provider) || "anthropic";
+    const apiKey = cfg.apiKey ?? ap.apiKey;
+    // Resolve base URL: explicit (cfg → profile) wins; otherwise fall back to the provider's preset
+    // (GLM/DeepSeek/OpenRouter). This keeps `profile add --byok --provider glm` working even when the
+    // user didn't pass --base-url (anthropic/openai stay undefined → their SDK defaults).
+    const baseURL = cfg.baseURL ?? ap.baseURL ?? providerDefaultBaseURL(provider);
+    const model = cfg.model || effectiveModel(ap);
+    if (provider === "qwen-oauth") {
         const auth = await getValidQwenAuth();
         if (!auth)
             return null;
-        return createOpenAIProvider({ apiKey: auth.accessToken, baseURL: auth.baseURL, model: cfg.model, label: "qwen-oauth" });
-    }
-    if (cfg.provider === "hara-gateway") {
-        const e = loadEnrollment();
-        if (!e)
-            return null; // not enrolled → `hara enroll`
-        return createOpenAIProvider({ apiKey: e.deviceToken, baseURL: gatewayBaseURL(e), model: cfg.model || e.model, label: "hara-gateway" });
+        return createOpenAIProvider({ apiKey: auth.accessToken, baseURL: auth.baseURL, model, label: "qwen-oauth", reasoningEffort: cfg.reasoningEffort });
     }
-    if (!cfg.apiKey)
+    if (!apiKey)
         return null;
-    if (cfg.provider === "anthropic") {
-        return createAnthropicProvider({ apiKey: cfg.apiKey, model: cfg.model, baseURL: cfg.baseURL });
+    if (provider === "anthropic") {
+        return createAnthropicProvider({ apiKey, model, baseURL, reasoningEffort: cfg.reasoningEffort });
     }
-    return createOpenAIProvider({ apiKey: cfg.apiKey, model: cfg.model, baseURL: cfg.baseURL, label: cfg.provider });
+    return createOpenAIProvider({ apiKey, model, baseURL, label: provider, reasoningEffort: cfg.reasoningEffort });
 }
 /** Wrap the main provider with per-turn model routing when `routeModel` is configured: trivial/non-coding
  *  turns go to the alternate (cheap/general) model, real coding/action work stays on the primary. No-op when
@@ -110,13 +135,143 @@ async function withRouting(primary, cfg) {
     const alt = await buildProvider({ ...cfg, model: cfg.routeModel, baseURL: cfg.routeBaseURL ?? cfg.baseURL, apiKey: cfg.routeApiKey ?? cfg.apiKey });
     return alt ? routingProvider(primary, alt) : primary;
 }
+/** Guardian veto model: the CHEAP tier if `routeModel` is configured (a small classifier call, not real
+ *  work), else the primary provider. Never blocks startup — any build failure just yields the fallback (and
+ *  the guardian fails open when even that is absent). Returns the `{ provider, enabled }` shape runAgent wants,
+ *  or undefined when guardian is off in config/env. */
+async function buildGuardian(cfg, primary) {
+    if (cfg.guardian === "off")
+        return undefined;
+    let gp = primary;
+    if (cfg.routeModel && cfg.routeModel !== cfg.model) {
+        gp = (await buildProvider({ ...cfg, model: cfg.routeModel, baseURL: cfg.routeBaseURL ?? cfg.baseURL, apiKey: cfg.routeApiKey ?? cfg.apiKey })) ?? primary;
+    }
+    return { provider: gp, enabled: true };
+}
 function authHint(cfg) {
-    if (cfg.provider === "qwen-oauth")
+    const ap = loadActiveProfile();
+    if (ap.kind === "gateway")
+        return `Active profile '${ap.id}' is a gateway profile but is missing deviceToken — re-enroll with \`hara profile add ${ap.id} --gateway <url> --code <code>\`.`;
+    const provider = ap.provider ?? cfg.provider;
+    if (provider === "qwen-oauth")
         return `Run ${c.bold("hara login qwen")} to authenticate.`;
-    return `Set ${c.bold(providerEnvKey(cfg.provider))} (or ${c.bold("HARA_API_KEY")}), or run ${c.bold("hara setup")}.`;
+    return `Set ${c.bold(providerEnvKey(provider))} (or ${c.bold("HARA_API_KEY")}), or run ${c.bold("hara setup")}.`;
+}
+const SETUP_DEFAULT_MODEL = { anthropic: "claude-opus-4-8", qwen: "qwen-plus", openai: "gpt-4o-mini", glm: "glm-4.6", deepseek: "deepseek-chat", openrouter: "openai/gpt-4o-mini", "qwen-oauth": "coder-model" };
+/** Numbered provider menu for `hara setup`. Order is the displayed order; `id` maps to a ProviderId
+ *  (or the special "custom"/"qwen-oauth" routes). GLM/DeepSeek carry a preset base URL so the user
+ *  never types one; "custom" prompts for an OpenAI-compatible base URL. */
+const SETUP_MENU = [
+    { label: "Anthropic", id: "anthropic" },
+    { label: "OpenAI", id: "openai" },
+    { label: "GLM (Zhipu)", id: "glm" },
+    { label: "DeepSeek", id: "deepseek" },
+    { label: "Qwen (DashScope key)", id: "qwen" },
+    { label: "OpenAI-compatible (custom base URL)", id: "custom" },
+    { label: "Qwen — free, no key (browser sign-in)", id: "qwen-oauth" },
+];
+/** Read a secret from the TTY without echoing it (shows `*` per char). Falls back to a plain
+ *  readline question when stdin isn't a raw-capable TTY (piped input / odd terminals) so scripted
+ *  `printf 'key\n' | hara setup` still works. Handles backspace, Enter, and Ctrl-C/Ctrl-D. */
+function readSecret(prompt, rl) {
+    const input = stdin;
+    if (!input.isTTY || typeof input.setRawMode !== "function") {
+        // Non-TTY (piped/scripted): can't suppress echo at the terminal level; read it plainly.
+        return rl.question(prompt);
+    }
+    return new Promise((resolve, reject) => {
+        stdout.write(prompt);
+        let buf = "";
+        const prevRaw = input.isRaw ?? false;
+        // Pause the readline interface so it doesn't also consume keystrokes / echo while we read raw.
+        // We restore it in cleanup() before the next rl.question() runs.
+        rl.pause();
+        input.setRawMode(true);
+        input.resume();
+        const onData = (chunk) => {
+            const s = chunk.toString("utf8");
+            for (const ch of s) {
+                const code = ch.charCodeAt(0);
+                if (ch === "\r" || ch === "\n") {
+                    cleanup();
+                    stdout.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                else if (code === 3) {
+                    // Ctrl-C → abort the wizard (mirror readline's SIGINT behavior).
+                    cleanup();
+                    stdout.write("\n");
+                    reject(new Error("cancelled"));
+                    return;
+                }
+                else if (code === 4) {
+                    // Ctrl-D → end of input; resolve with whatever we have.
+                    cleanup();
+                    stdout.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                else if (code === 127 || code === 8) {
+                    // Backspace/Delete.
+                    if (buf.length) {
+                        buf = buf.slice(0, -1);
+                        stdout.write("\b \b");
+                    }
+                }
+                else if (code >= 32) {
+                    buf += ch;
+                    stdout.write("*");
+                }
+            }
+        };
+        const cleanup = () => {
+            input.removeListener("data", onData);
+            try {
+                input.setRawMode(prevRaw);
+            }
+            catch {
+                /* best-effort */
+            }
+            // Hand control back to readline for the next prompt (model question).
+            rl.resume();
+        };
+        input.on("data", onData);
+    });
+}
+/** One-shot validation ping: build the provider exactly as the runtime would (anthropic vs the
+ *  OpenAI-compatible path with the resolved base URL) and send a tiny prompt with a short timeout.
+ *  Never throws — returns true on a clean turn, false on any error/timeout. Used only to print a
+ *  friendly "connected" hint; the wizard saves config regardless. */
+async function pingProvider(args) {
+    const { provider, apiKey, model, baseURL } = args;
+    if (!apiKey || !model)
+        return false;
+    const prov = provider === "anthropic"
+        ? createAnthropicProvider({ apiKey, model, baseURL })
+        : createOpenAIProvider({ apiKey, model, baseURL, label: provider });
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 12_000);
+    try {
+        const r = await prov.turn({
+            system: "Reply with the single word: ok",
+            history: [{ role: "user", content: "ping" }],
+            tools: [],
+            onText: () => { },
+            signal: ctrl.signal,
+        });
+        return r.stop !== "error";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
 }
-const SETUP_DEFAULT_MODEL = { anthropic: "claude-opus-4-8", qwen: "qwen-plus", openai: "gpt-4o-mini", "qwen-oauth": "coder-model" };
-/** Interactive first-run setup: pick a provider, (optional) base URL, API key, and model → ~/.hara/config.json. */
+/** Interactive first-run setup: pick a provider (numbered menu), API key (masked), and model →
+ *  ~/.hara/config.json. GLM/DeepSeek/OpenRouter and "custom" route through the OpenAI-compatible
+ *  path; "Qwen free" routes to the device-login flow. Storage model is unchanged (config.json 0600). */
 async function runSetup() {
     if (!stdin.isTTY) {
         out(c.yellow("`hara setup` is interactive — run it in a terminal, or use `hara config set <key> <value>` in scripts.\n"));
@@ -125,14 +280,42 @@ async function runSetup() {
     const rl = createInterface({ input: stdin, output: stdout });
     try {
         out(c.bold("hara setup") + c.dim(" — configure a provider, key, and model (Ctrl-C to cancel)\n\n"));
-        const provider = ((await rl.question(`Provider ${c.dim("anthropic / qwen / openai")} [anthropic]: `)).trim() || "anthropic").toLowerCase();
+        SETUP_MENU.forEach((m, i) => out(`  ${c.bold(String(i + 1))}) ${m.label}\n`));
+        out("\n");
+        const pick = (await rl.question(`Provider [1]: `)).trim() || "1";
+        const idx = Number.parseInt(pick, 10);
+        const choice = Number.isInteger(idx) && idx >= 1 && idx <= SETUP_MENU.length ? SETUP_MENU[idx - 1] : SETUP_MENU[0];
+        // Route 7: Qwen free device login — no key, no model prompt. Reuse the existing flow + config writes.
+        if (choice.id === "qwen-oauth") {
+            try {
+                await qwenDeviceLogin((m) => out(m + "\n"));
+                writeConfigValue("provider", "qwen-oauth");
+                writeConfigValue("model", "coder-model");
+                out(c.green("\n✓ Qwen OAuth complete — provider set to qwen-oauth (model coder-model).\n") + c.dim(`Check it with ${c.bold("hara doctor")}, then just run ${c.bold("hara")}.\n`));
+            }
+            catch (e) {
+                out(c.red(`\nQwen OAuth failed: ${e?.message ?? e}\n`));
+            }
+            return;
+        }
+        // Resolve the concrete provider id + base URL. "custom" = OpenAI-compatible: ask for the base
+        // URL and store the chosen provider as "openai" (the generic OpenAI-compatible dispatch).
+        let provider;
         let baseURL = "";
-        if (provider === "qwen" || provider === "openai") {
-            baseURL = (await rl.question(`Base URL ${c.dim("(blank = default; set for an OpenAI-compatible endpoint, e.g. GLM/Kimi/DashScope)")}: `)).trim();
+        if (choice.id === "custom") {
+            provider = "openai";
+            baseURL = (await rl.question(`Base URL ${c.dim("(OpenAI-compatible endpoint, e.g. https://your-host/v1)")}: `)).trim();
+        }
+        else {
+            provider = choice.id;
+            // GLM/DeepSeek/OpenRouter carry a preset base URL (PROVIDER_DEFAULTS) — written explicitly so
+            // the personal profile is self-contained. anthropic/openai use their built-in defaults.
+            baseURL = providerDefaultBaseURL(provider) ?? "";
         }
         const envKey = providerEnvKey(provider);
-        const apiKey = (await rl.question(`API key ${c.dim(`(blank = use the ${envKey} env var)`)}: `)).trim();
-        const model = (await rl.question(`Model [${SETUP_DEFAULT_MODEL[provider] ?? "?"}]: `)).trim() || SETUP_DEFAULT_MODEL[provider] || "";
+        const apiKey = (await readSecret(`API key ${c.dim(`(masked; blank = use the ${envKey} env var)`)}: `, rl)).trim();
+        const defaultModel = SETUP_DEFAULT_MODEL[choice.id === "custom" ? "openai" : provider] ?? "";
+        const model = (await rl.question(`Model [${defaultModel || "?"}]: `)).trim() || defaultModel;
         writeConfigValue("provider", provider);
         if (baseURL)
             writeConfigValue("baseURL", baseURL);
@@ -140,8 +323,20 @@ async function runSetup() {
             writeConfigValue("apiKey", apiKey);
         if (model)
             writeConfigValue("model", model);
+        // One-shot validation ping (best-effort; never blocks saving). Only when we have a key + model.
+        if (apiKey && model) {
+            out(c.dim("\nChecking connection… "));
+            const ok = await pingProvider({ provider, apiKey, model, baseURL: baseURL || undefined });
+            out(ok ? c.green("✓ connected\n") : c.yellow(`⚠ couldn't reach ${provider} (saved anyway)\n`));
+        }
         out(c.green(`\n✓ saved to ${configPath()}\n`) + c.dim(`Check it with ${c.bold("hara doctor")}, then just run ${c.bold("hara")}.\n`));
     }
+    catch (e) {
+        if (e?.message === "cancelled")
+            out(c.dim("\n(cancelled)\n"));
+        else
+            throw e;
+    }
     finally {
         rl.close();
     }
@@ -236,8 +431,10 @@ async function runOrg(task, o) {
         }
     }
     out(c.dim(`→ ${role.id} owns this task\n`));
-    const roleProvider = role.model && role.model !== o.cfg.model
-        ? ((await buildProvider({ ...o.cfg, model: role.model })) ?? o.baseProvider)
+    // Role-model resolution: respect role.model by default; --force collapses everything to cfg.model.
+    const __roleModel = effectiveRoleModel(role.model, o.cfg.model);
+    const roleProvider = __roleModel
+        ? ((await buildProvider({ ...o.cfg, model: __roleModel })) ?? o.baseProvider)
         : o.baseProvider;
     const toolFilter = role.allowTools
         ? (n) => role.allowTools.includes(n)
@@ -273,7 +470,8 @@ async function runOrg(task, o) {
     }
     // Review chain: a reviewer role inspects the diff and APPROVES or sends it back, looping until clean.
     const reviewer = roles.find((r) => r.id === "reviewer");
-    const revProvider = reviewer?.model && reviewer.model !== o.cfg.model ? ((await buildProvider({ ...o.cfg, model: reviewer.model })) ?? o.baseProvider) : o.baseProvider;
+    const __revModel = effectiveRoleModel(reviewer?.model, o.cfg.model);
+    const revProvider = __revModel ? ((await buildProvider({ ...o.cfg, model: __revModel })) ?? o.baseProvider) : o.baseProvider;
     const revSystem = reviewer?.system ?? REVIEWER_SYSTEM;
     const revTools = reviewer?.allowTools ? (n) => reviewer.allowTools.includes(n) : (n) => READONLY_TOOLS.has(n);
     const maxRounds = Math.max(1, o.rounds ?? 3);
@@ -325,7 +523,8 @@ async function executeAtom(atom, plan, done, roles, o) {
     atom.status = "running";
     savePlan(o.cwd, plan);
     const role = atom.role ? roles.find((r) => r.id === atom.role) : undefined;
-    const roleProvider = role?.model && role.model !== o.cfg.model ? ((await buildProvider({ ...o.cfg, model: role.model })) ?? o.baseProvider) : o.baseProvider;
+    const __atomModel = effectiveRoleModel(role?.model, o.cfg.model);
+    const roleProvider = __atomModel ? ((await buildProvider({ ...o.cfg, model: __atomModel })) ?? o.baseProvider) : o.baseProvider;
     const toolFilter = role?.allowTools
         ? (n) => role.allowTools.includes(n)
         : role?.denyTools
@@ -559,7 +758,8 @@ async function maybeAutoCompact(provider, history, meta, stats, cfg, notify) {
 async function runSubagent(cfg, baseProvider, cwd, sandbox, projectContext, stats, task, roleId) {
     const roles = loadRoles(cwd);
     const role = roleId ? roles.find((r) => r.id === roleId) : undefined;
-    const provider = role?.model && role.model !== cfg.model ? ((await buildProvider({ ...cfg, model: role.model })) ?? baseProvider) : baseProvider;
+    const __subModel = effectiveRoleModel(role?.model, cfg.model);
+    const provider = __subModel ? ((await buildProvider({ ...cfg, model: __subModel })) ?? baseProvider) : baseProvider;
     // A sub-agent runs full-auto + UNCONFIRMED + parallel, so it is ALWAYS read-only — a role may narrow
     // further but can never GRANT write/exec to a fan-out sub-agent (that would bypass the approval gate).
     // Write-capable roles run in the main loop via `hara org`, behind the user's gate.
@@ -637,10 +837,27 @@ program
     .option("-y, --yes", "auto-approve all tool actions (= --approval full-auto)")
     .option("-m, --model <model>", "model id (overrides config)")
     .option("--approval <mode>", "approval mode: suggest | auto-edit | full-auto")
-    .option("--profile <name>", "use a named profile from ~/.hara/config.json")
+    .option("--profile <id>", "use this identity profile for this run (personal / org id) — see `hara profile list`")
+    .option("--overlay <name>", "apply a named config overlay from ~/.hara/config.json (legacy: --profile)")
     .option("-c, --continue", "resume the most recent session in this directory")
     .option("--resume <id>", "resume a specific session by id")
     .option("--sandbox <mode>", "sandbox the shell: off | workspace-write | read-only");
+// Wire the global `--profile <id>` flag into the resolution chain BEFORE any subcommand
+// action runs. resolveActive() consults setFlagOverride() at the top of the priority chain,
+// so this single hook covers `hara whoami`, `hara profile list`, `hara model …`, and the
+// default REPL action — without each subcommand having to reach into program.opts() itself.
+// Validation: unknown id is a hard fail (don't silently fall through to default; the user
+// asked for a specific identity, surface the mistake).
+program.hook("preAction", (thisCmd) => {
+    const flag = thisCmd.opts().profile;
+    if (!flag)
+        return;
+    if (!getProfile(flag)) {
+        out(c.red(`No identity profile '${flag}'.\n`) + c.dim("List: `hara profile list`\n"));
+        process.exit(1);
+    }
+    setFlagOverride(flag);
+});
 program
     .command("init")
     .description("analyze the project and (re)generate AGENTS.md")
@@ -664,8 +881,33 @@ program
         return;
     }
     for (const m of metas) {
-        out(`${c.bold(m.id)}  ${c.dim(m.updatedAt.slice(0, 16).replace("T", " "))}  ${m.provider}:${m.model}  ${m.title}\n`);
+        out(`${c.bold(shortId(m.id))}  ${c.dim(m.updatedAt.slice(0, 16).replace("T", " "))}  ${c.dim(m.provider + ":" + m.model)}  ${m.title || c.dim("(untitled)")}\n`);
+    }
+    out(c.dim("\nResume:  hara resume <id>\n"));
+});
+program
+    .command("resume [id]")
+    .description("resume a session — no id resumes the most recent here (list ids with `hara sessions`)")
+    .action((id) => {
+    let full;
+    if (id) {
+        full = resolveSessionId(id) ?? undefined;
+        if (!full) {
+            out(c.red(`No session matching '${id}'.`) + c.dim(" Run `hara sessions` to list.\n"));
+            process.exit(1);
+        }
+    }
+    else {
+        const latest = latestForCwd(process.cwd());
+        if (!latest) {
+            out(c.dim("No sessions for this directory yet — `hara sessions` lists all.\n"));
+            process.exit(0);
+        }
+        full = latest.meta.id;
     }
+    out(c.dim(`↩ resuming ${shortId(full)}…\n`));
+    // reuse the existing --resume path exactly (one engine), inheriting this terminal
+    execFileSync(process.execPath, [process.argv[1], "--resume", full], { stdio: "inherit" });
 });
 program
     .command("org <task...>")
@@ -800,30 +1042,407 @@ program
     .command("setup")
     .description("interactive first-run setup — pick a provider, API key, and model")
     .action(runSetup);
+// ────────────────────────────────────────────────────────────────────────────────
+// Identity profiles — the single switch for "who am I as right now" (personal vs each
+// org I belong to). Switching a profile flips provider, key/token, base URL, AND the
+// default model the gateway / setup chose. See src/profile/profile.ts.
+// ────────────────────────────────────────────────────────────────────────────────
+function fmtProfile(p, mark = "") {
+    const kindBadge = p.kind === "gateway" ? c.bold(c.cyan("ORG")) : c.bold(c.dim("PERSONAL"));
+    const label = p.label ? `${c.bold(p.label)} ` : "";
+    const model = effectiveModel(p) || c.dim("(unset)");
+    const route = routingLabel(p);
+    return `${mark} ${kindBadge}  ${label}${c.dim("[" + p.id + "]")}  ${c.dim("· model")} ${model}  ${c.dim("· →")} ${route}`;
+}
+/** Human-readable suffix for the active row: "(active · <where it came from>)".
+ *  pin gets a relative file path; flag/env/default each get their own tag. */
+function activeSuffix(r) {
+    switch (r.source) {
+        case "flag":
+            return c.dim("(active · ") + c.bold("--profile flag") + c.dim(")");
+        case "env":
+            return c.dim("(active · ") + c.bold("HARA_PROFILE env") + c.dim(")");
+        case "pin": {
+            const rel = r.pinFile ? relPath(r.pinFile) : ".hara-profile";
+            return c.dim("(active · ") + c.bold("pinned by " + rel) + c.dim(")");
+        }
+        case "default":
+            return c.dim("(active · ") + c.bold("global default") + c.dim(")");
+        case "fallback":
+            return c.dim("(active · fallback)");
+    }
+}
+/** Render an absolute path relative to cwd. Same-dir paths get `./` for clarity
+ *  ("pinned by ./.hara-profile" reads better than "pinned by .hara-profile" because
+ *  the leading `.` of the filename is otherwise hard to spot). Parent-dir pins keep
+ *  their relative form (`../../.hara-profile`) — still way more readable than absolute. */
+function relPath(abs) {
+    try {
+        const r = relative(process.cwd(), abs);
+        if (!r)
+            return ".";
+        // r could be: ".hara-profile", "sub/.hara-profile", "../.hara-profile".
+        // For the same-cwd hit we want `./.hara-profile` — start with "./" unless it already
+        // navigates with ".." (which speaks for itself).
+        if (r.startsWith(".."))
+            return r;
+        return "./" + r;
+    }
+    catch {
+        return abs;
+    }
+}
+/** Stable "▶ active" line — first thing printed at startup so the user always sees where requests
+ *  are going. Tests look for this prefix; keep the format. */
+export function activeProfileLine(p) {
+    const route = routingLabel(p);
+    const model = effectiveModel(p) || "(unset)";
+    return `▶ ${p.label || p.id} · ${model} · ${route}`;
+}
+/** Shared whoami body so the `profile current` alias reuses the same output exactly. */
+function printWhoami() {
+    const r = resolveActive();
+    const p = loadActiveProfile();
+    out(c.bold("active profile") + "  " + activeSuffix(r) + "\n" + fmtProfile(p, " ") + "\n");
+    if (p.kind === "gateway") {
+        out(c.dim(`  gateway:  ${p.gatewayUrl}\n`));
+        if (p.deviceId)
+            out(c.dim(`  device:   ${p.deviceId.length > 8 ? "…" + p.deviceId.slice(-8) : p.deviceId}\n`));
+        if (p.availableModels?.length)
+            out(c.dim(`  available: ${p.availableModels.join(", ")}\n`));
+    }
+    else {
+        out(c.dim(`  provider: ${p.provider}\n`));
+        if (p.baseURL)
+            out(c.dim(`  baseURL:  ${p.baseURL}\n`));
+        out(c.dim(`  key:      ${p.apiKey ? maskKey(p.apiKey) : "(env / unset)"}\n`));
+    }
+}
+program
+    .command("whoami")
+    .description("show the active identity profile (label · model · routing target · source)")
+    .action(printWhoami);
+const profileCmd = program.command("profile").description("manage identity profiles (personal / org A / org B…)");
+// `profile current` — nvm muscle-memory ("nvm current" → "hara profile current"). Same as `hara whoami`.
+profileCmd
+    .command("current")
+    .description("alias of `hara whoami` — print the active identity profile (with source)")
+    .action(printWhoami);
+// ── `profile list` (alias `ls`) ────────────────────────────────────────────────
+// Layout: profiles grouped by kind (PERSONAL above ORG), one line per profile, columns
+// aligned across the whole table (so id/model/routing visually stack). Active row is
+// prefixed with `→ *` (so you can read it at a glance even in copy-pasted output) and
+// suffixed with the source tag. Footer is a 2-line hint pointing at the two switching
+// gestures: `profile use <id>` (write the default), `profile pin <id>` (lock this dir).
+function renderProfileList() {
+    const r = resolveActive();
+    const ps = listProfiles();
+    const lines = [];
+    // Group by kind so the "where am I in the world" stratification is visible.
+    const groups = [
+        { kind: "byok", title: "PERSONAL", rows: ps.filter((p) => p.kind === "byok") },
+        { kind: "gateway", title: "ORG", rows: ps.filter((p) => p.kind === "gateway") },
+    ];
+    // Column widths from raw (un-styled) strings — styling never participates in padding.
+    const idW = Math.max(2, ...ps.map((p) => p.id.length));
+    const labelW = Math.max(0, ...ps.map((p) => (p.label || "").length));
+    const modelW = Math.max(5, ...ps.map((p) => (effectiveModel(p) || "(unset)").length));
+    for (const g of groups) {
+        if (!g.rows.length)
+            continue;
+        if (lines.length)
+            lines.push(""); // blank between groups
+        lines.push(c.dim(g.title));
+        for (const p of g.rows) {
+            const isActive = p.id === r.id;
+            const mark = isActive ? c.green("→ *") : "   ";
+            const id = p.id.padEnd(idW, " ");
+            const label = (p.label || "").padEnd(labelW, " ");
+            const model = (effectiveModel(p) || "(unset)").padEnd(modelW, " ");
+            const route = routingLabel(p);
+            const tail = isActive ? "  " + activeSuffix(r) : "";
+            const cols = `${mark}  ${c.dim("[")}${c.bold(id)}${c.dim("]")}  ${label}  ${c.dim("· model")} ${model}  ${c.dim("· →")} ${route}${tail}`;
+            lines.push(cols);
+        }
+    }
+    // Tail hint — nudge users toward the two everyday gestures.
+    lines.push("");
+    lines.push(c.dim("💡 use ") + "`hara profile use <id>`" + c.dim(" to switch · ") + "`hara profile pin <id>`" + c.dim(" to lock to this dir"));
+    return lines.join("\n");
+}
+profileCmd
+    .command("list")
+    .alias("ls")
+    .description("list all profiles (active marked with → *) — alias: `ls`")
+    .action(() => {
+    out(renderProfileList() + "\n");
+});
+profileCmd
+    .command("use <id>")
+    .description("switch the active profile (echoes the diff: profile / model / routing)")
+    .option("-y, --yes", "skip confirmation when switching INTO a gateway profile from BYOK")
+    .action(async (id, opts) => {
+    const before = loadActiveProfile();
+    const target = getProfile(id);
+    if (!target) {
+        out(c.red(`No profile '${id}'.\n`) + c.dim("List: `hara profile list`\n"));
+        process.exit(1);
+    }
+    // Safety: BYOK → gateway is the direction that changes where your traffic goes (from your own
+    // key to a controlled gateway). Confirm unless -y. The reverse direction is allowed silently
+    // but the diff is still echoed.
+    if (before.kind === "byok" && target.kind === "gateway" && !opts.yes) {
+        const ok = await askConfirm(`Switch to gateway profile '${id}' (${target.gatewayUrl})? Traffic will route through the org gateway.`);
+        if (!ok) {
+            out(c.dim("(unchanged)\n"));
+            return;
+        }
+    }
+    const r = useProfile(id);
+    if (!r.ok) {
+        out(c.red(r.reason + "\n"));
+        process.exit(1);
+    }
+    const after = r.profile;
+    const modelBefore = effectiveModel(before) || "(unset)";
+    const modelAfter = effectiveModel(after) || "(unset)";
+    const routeBefore = routingLabel(before);
+    const routeAfter = routingLabel(after);
+    out(c.green("✓ switched\n"));
+    out(`  profile:  ${c.dim(before.id)} ${c.dim("→")} ${c.bold(after.id)}\n`);
+    out(`  model:    ${c.dim(modelBefore)} ${c.dim("→")} ${c.bold(modelAfter)}\n`);
+    out(`  routing:  ${c.dim(routeBefore)} ${c.dim("→")} ${c.bold(routeAfter)}\n`);
+});
+profileCmd
+    .command("add <id>")
+    .description("add a new identity profile (gateway = `hara enroll`; byok = your own key)")
+    .option("--gateway <url>", "(gateway) join this hara-control gateway")
+    .option("--code <code>", "(gateway) enrollment code from your admin")
+    .option("--label <label>", "human-friendly label for the profile")
+    .option("--byok", "(byok) BYOK profile — bring your own provider key")
+    .option("--provider <id>", "(byok) anthropic | openai | glm | deepseek | openrouter | qwen | qwen-oauth")
+    .option("--key <key>", "(byok) API key (else read from the provider's env var at use-time)")
+    .option("--base-url <url>", "(byok) override the provider base URL (OpenAI-compatible endpoints)")
+    .option("--model <model>", "(byok) default model for this profile")
+    .action(async (id, opts) => {
+    if (opts.gateway) {
+        if (!opts.code)
+            return void out(c.red("gateway profile add needs --code <code> from your hara-control admin\n"));
+        try {
+            const e = await enrollDevice(opts.gateway, opts.code);
+            const p = {
+                id,
+                kind: "gateway",
+                label: opts.label || id,
+                gatewayUrl: e.gatewayUrl,
+                deviceId: e.deviceId,
+                deviceToken: e.deviceToken,
+                baseURL: e.baseURL,
+                defaultModel: e.model || "",
+                availableModels: e.model ? [e.model] : [],
+                enrolledAt: e.enrolledAt,
+            };
+            upsertProfile(p); // upsert: re-enrolling the same id rotates the token
+            const r = useProfile(id);
+            if (r.ok) {
+                out(c.green(`✓ enrolled and switched to '${id}' (${e.gatewayUrl})`) + c.dim(` · model ${p.defaultModel || "(gateway default)"}\n`));
+                const nRoles = await syncOrgRoles();
+                if (nRoles > 0)
+                    out(c.dim(`  ↳ synced ${nRoles} org role${nRoles === 1 ? "" : "s"} → ~/.hara/org-roles/\n`));
+            }
+        }
+        catch (err) {
+            out(c.red(`Enroll failed: ${err instanceof Error ? err.message : String(err)}\n`));
+            process.exit(1);
+        }
+        return;
+    }
+    if (opts.byok || opts.provider) {
+        const provider = (opts.provider || "anthropic");
+        if (provider === "hara-gateway")
+            return void out(c.red("`--provider hara-gateway` is retired — use --gateway <url> --code <code> instead.\n"));
+        const p = {
+            id,
+            kind: "byok",
+            label: opts.label || id,
+            provider,
+            apiKey: opts.key,
+            baseURL: opts.baseUrl,
+            defaultModel: opts.model,
+        };
+        const r = addProfile(p);
+        if (!r.ok) {
+            out(c.red(r.reason + "\n"));
+            process.exit(1);
+        }
+        out(c.green(`✓ added BYOK profile '${id}'`) + c.dim(` · provider ${provider}${opts.model ? " · model " + opts.model : ""}\n`));
+        out(c.dim(`Switch to it with \`hara profile use ${id}\`.\n`));
+        return;
+    }
+    out(c.red("usage:\n") + c.dim("  hara profile add <id> --gateway <url> --code <code> [--label …]\n") + c.dim("  hara profile add <id> --byok --provider anthropic|openai|glm|deepseek|openrouter|qwen|qwen-oauth [--key … --base-url … --model …]\n"));
+    process.exit(1);
+});
+profileCmd
+    .command("remove <id>")
+    .alias("rm")
+    .alias("uninstall")
+    .description("remove a profile (active falls back to personal) — aliases: `rm`, `uninstall`")
+    .action((id) => {
+    // Capture the profile before removal so we can mention the gateway host in the token-hint
+    // line (5 below). After removeProfile, getProfile(id) is gone.
+    const before = getProfile(id);
+    const r = removeProfile(id);
+    if (!r.ok) {
+        out(c.red(r.reason + "\n"));
+        process.exit(1);
+    }
+    if (r.activeChanged) {
+        // Single line that reads naturally: "removed 'X' · active → personal".
+        out(c.green(`✓ removed '${id}'`) + c.dim(` · active → ${PERSONAL_ID}\n`));
+    }
+    else {
+        out(c.green(`✓ removed '${id}'\n`));
+    }
+    // For gateway profiles: we deliberately do NOT phone the control plane to revoke the device
+    // token (that's a privileged operation that needs admin auth + we don't want a stale CLI
+    // calling production). Print a one-line hint so the user knows the *server-side* identity
+    // outlives this local removal — and who to ask if they want it gone there too.
+    if (r.removedKind === "gateway") {
+        const host = (() => {
+            try {
+                return before?.gatewayUrl ? new URL(before.gatewayUrl).host : (before?.gatewayUrl || "the gateway");
+            }
+            catch {
+                return before?.gatewayUrl || "the gateway";
+            }
+        })();
+        out(c.dim(`💡 token left registered at ${host}; ask your admin to revoke if needed\n`));
+    }
+});
+// ── `.hara-profile` project pin (like .nvmrc but personal — keep it out of repos) ─────
+profileCmd
+    .command("pin [id]")
+    .description("write `.hara-profile` in this dir to lock the active profile here (omit id = pin current active)")
+    .action((id) => {
+    const target = (id && id.trim()) || activeId();
+    if (!getProfile(target)) {
+        out(c.red(`No profile '${target}'.\n`) + c.dim("List: `hara profile list`\n"));
+        process.exit(1);
+    }
+    try {
+        const { file } = writePin(process.cwd(), target);
+        out(c.green(`✓ pinned ${target} to ${relPath(file)}\n`));
+        // .hara-profile carries personal identity (which org you're as), unlike .nvmrc which
+        // is project-level. Nudge user toward GLOBAL gitignore so they don't accidentally
+        // commit it. We intentionally do NOT modify .gitignore — that's user space.
+        out(c.dim("💡 .hara-profile is personal identity — add it to your global gitignore (unlike .nvmrc, don't commit it)\n"));
+    }
+    catch (err) {
+        out(c.red(`pin failed: ${err instanceof Error ? err.message : String(err)}\n`));
+        process.exit(1);
+    }
+});
+profileCmd
+    .command("unpin")
+    .description("remove `.hara-profile` from this dir")
+    .action(() => {
+    const file = pinFilePath(process.cwd());
+    const ok = removePin(process.cwd());
+    if (ok)
+        out(c.green(`✓ unpinned`) + c.dim(` · removed ${relPath(file)}\n`));
+    else
+        out(c.dim(`(no ${relPath(file)} here — nothing to unpin)\n`));
+});
+// ── per-profile model switching ──────────────────────────────────────────────────
+const modelCmd = program.command("model").description("manage the model on the active profile");
+modelCmd
+    .command("list")
+    .description("list models for the active profile (gateway profiles list what the control plane advertised)")
+    .action(() => {
+    const p = loadActiveProfile();
+    const cur = effectiveModel(p);
+    if (p.kind === "gateway") {
+        const list = p.availableModels?.length ? p.availableModels : (p.defaultModel ? [p.defaultModel] : []);
+        if (!list.length) {
+            out(c.dim("(gateway didn't advertise any models — use the gateway default; `hara model use <id>` to override locally)\n"));
+            return;
+        }
+        for (const m of list)
+            out(`${m === cur ? c.green("*") : " "} ${m}\n`);
+    }
+    else {
+        // BYOK has no constrained list — show the current effective + suggestion.
+        out(`${c.green("*")} ${cur || c.dim("(unset)")}\n`);
+        out(c.dim("(BYOK profiles accept any model id the provider supports — `hara model use <id>` to switch)\n"));
+    }
+});
+modelCmd
+    .command("use <model>")
+    .description("override the model on the active profile (validated against availableModels on gateway profiles)")
+    .action((model) => {
+    const id = activeId();
+    const r = setProfileModel(id, model);
+    if (!r.ok) {
+        out(c.red(r.reason + "\n"));
+        process.exit(1);
+    }
+    out(c.green(`✓ model → ${model}`) + c.dim(` (profile ${id})\n`));
+});
+modelCmd
+    .command("reset")
+    .description("clear the per-profile model override → fall back to defaultModel")
+    .action(() => {
+    const id = activeId();
+    const r = resetProfileModel(id);
+    if (!r.ok) {
+        out(c.red(r.reason + "\n"));
+        process.exit(1);
+    }
+    const p = loadActiveProfile();
+    out(c.green(`✓ reset`) + c.dim(` · effective model → ${effectiveModel(p) || "(unset)"}\n`));
+});
+// ── `hara enroll` — kept as a convenience alias mapping to the default-org gateway profile.
 program
     .command("enroll [gateway-url]")
-    .description("B-end: join a fleet — trade a one-time code for a device token (routes hara through your org's gateway; no provider key on this device)")
+    .description("alias of `hara profile add default-org --gateway <url> --code <code>` (B-end: join a fleet)")
     .option("--code <code>", "enrollment code from your hara-control admin")
-    .option("--status", "show the current enrollment")
-    .option("--clear", "remove the enrollment (revert to your own provider config)")
+    .option("--status", "alias of `hara whoami`")
+    .option("--clear", "switch active profile back to personal (does NOT delete the gateway profile)")
     .action(async (gatewayUrl, opts) => {
     if (opts.status) {
-        const e = loadEnrollment();
-        return void out(e ? c.green("enrolled") + c.dim(` · ${e.gatewayUrl} · device ${e.deviceId || "?"} · model ${e.model || "(gateway default)"} · since ${e.enrolledAt}\n`) : c.dim("Not enrolled — `hara enroll <gateway-url> --code <code>`.\n"));
+        const p = loadActiveProfile();
+        return void out(p.kind === "gateway" ? c.green("enrolled") + c.dim(` · ${p.gatewayUrl} · device ${p.deviceId || "?"} · model ${effectiveModel(p) || "(gateway default)"} · since ${p.enrolledAt || "?"}\n`) : c.dim("Not enrolled — `hara enroll <gateway-url> --code <code>`.\n"));
+    }
+    if (opts.clear) {
+        // Behavior change: don't *delete* the gateway profile (keeps the token around for re-use);
+        // just switch active back to personal. Legacy clearEnrollment() also called to remove any
+        // stray org.json file from pre-migration installs.
+        clearEnrollment();
+        const r = useProfile(PERSONAL_ID);
+        return void out(r.ok ? c.green("✓ active → personal") + c.dim(" — gateway profile preserved (remove with `hara profile remove default-org`)\n") : c.dim("(no change)\n"));
     }
-    if (opts.clear)
-        return void out(clearEnrollment() ? c.green("✓ enrollment cleared — set your own provider with `hara setup`.\n") : c.dim("(not enrolled)\n"));
     if (!gatewayUrl)
         return void out(c.red("usage: hara enroll <gateway-url> --code <code>   (or --status / --clear)\n"));
     if (!opts.code)
         return void out(c.red("Need --code <code> — ask your hara-control admin to issue an enrollment code.\n"));
     try {
         const e = await enrollDevice(gatewayUrl, opts.code);
-        writeConfigValue("provider", "hara-gateway");
-        if (e.model)
-            writeConfigValue("model", e.model);
-        out(c.green(`✓ enrolled with ${e.gatewayUrl}`) + c.dim(` · device ${e.deviceId || "?"} · model ${e.model || "(gateway default)"}\n`) + c.dim("hara routes through the gateway now — the real provider key stays server-side.\n"));
-        const nRoles = await syncOrgRoles(); // pull this device's governed digital-employee bundle (B3)
+        const p = {
+            id: DEFAULT_ORG_ID,
+            kind: "gateway",
+            label: "Default Org",
+            gatewayUrl: e.gatewayUrl,
+            deviceId: e.deviceId,
+            deviceToken: e.deviceToken,
+            baseURL: e.baseURL,
+            defaultModel: e.model || "",
+            availableModels: e.model ? [e.model] : [],
+            enrolledAt: e.enrolledAt,
+        };
+        upsertProfile(p);
+        useProfile(DEFAULT_ORG_ID);
+        out(c.green(`✓ enrolled with ${e.gatewayUrl}`) + c.dim(` · device ${e.deviceId || "?"} · model ${e.model || "(gateway default)"} · profile ${DEFAULT_ORG_ID}\n`) + c.dim("hara routes through the gateway now — the real provider key stays server-side.\n"));
+        const nRoles = await syncOrgRoles();
         if (nRoles > 0)
             out(c.dim(`  ↳ synced ${nRoles} org role${nRoles === 1 ? "" : "s"} → ~/.hara/org-roles/\n`));
     }
@@ -855,7 +1474,7 @@ program
 program
     .command("gateway")
     .description("run a chat gateway (Telegram or WeChat) so you can drive your local hara from your phone — opt-in daemon")
-    .option("--platform <name>", "chat platform: telegram | weixin | discord | feishu | slack | mattermost | matrix | dingtalk", "telegram")
+    .option("--platform <name>", "chat platform: telegram | weixin | discord | feishu | slack | mattermost | matrix | dingtalk | wecom | signal", "telegram")
     .option("--login", "(weixin) scan a QR to log in and save credentials, then exit")
     .option("--cwd <dir>", "directory hara operates in per message (default: ~/.hara/workspace)")
     .action(async (opts) => {
@@ -867,6 +1486,66 @@ program
     const cwd = opts.cwd ? (await import("node:path")).resolve(opts.cwd) : undefined; // undefined → ~/.hara/workspace
     await mod.runGateway({ cwd, platform: opts.platform });
 });
+program
+    .command("remote [action] [text]")
+    .description("drive THIS tmux session from chat: register the pane so WeChat replies inject back into it. actions: ask \"<q>\" | bind | back | status")
+    .action(async (action = "status", text) => {
+    const { registerTmuxRoute, unbindPane, listRoutes } = await import("./gateway/tmux-routes.js");
+    const pane = process.env.TMUX_PANE; // set by tmux inside every pane
+    const needPane = () => {
+        if (!pane) {
+            out(c.red("`hara remote` must run inside tmux ($TMUX_PANE unset) — it injects chat replies into a tmux pane.\n"));
+            process.exit(2);
+        }
+    };
+    if (action === "status") {
+        const rs = listRoutes();
+        out(rs.length ? rs.map((r) => `${r.pane}  [${r.mode ?? "once"}]  ${r.cwd ?? ""}`).join("\n") + "\n" : "(no panes registered)\n");
+        return;
+    }
+    if (action === "unbind" || action === "back") {
+        needPane();
+        out(unbindPane(pane) ? `✓ ${action === "back" ? "back from remote — unbound" : "unbound"} ${pane}\n` : `${pane} was not registered\n`);
+        return;
+    }
+    if (action === "bind") {
+        needPane();
+        registerTmuxRoute(pane, undefined, process.cwd(), "bind");
+        out(c.green(`🔗 bound ${pane}`) + ` — every WeChat reply now injects here until \`hara remote unbind\` (or send /detach in chat). Daemon must be running.\n`);
+        return;
+    }
+    if (action === "ask") {
+        needPane();
+        if (!text)
+            return void out(c.red('usage: hara remote ask "<question>"\n'));
+        registerTmuxRoute(pane, undefined, process.cwd(), "once"); // register first — inbound inject works even if the push is throttled
+        try {
+            const wx = await import("./gateway/weixin.js");
+            const creds = wx.loadWeixinCreds();
+            if (!creds)
+                return void out(c.yellow(`↩ ${pane} registered, but no WeChat login (run \`hara gateway --platform weixin --login\`). Your next reply to the bot still injects here.\n`));
+            let peer = process.env.HARA_WX_PEER;
+            if (!peer) {
+                try {
+                    const f = join(homedir(), ".hara", "weixin", `${creds.account_id}.context-tokens.json`);
+                    const keys = Object.keys(JSON.parse(readFileSync(f, "utf8")));
+                    peer = keys.find((k) => k.endsWith("@im.wechat")) || keys[0];
+                }
+                catch {
+                    /* no peer file */
+                }
+            }
+            if (peer)
+                await wx.weixinAdapter(creds).send(peer, text);
+            out(c.green(`↩ asked on WeChat + registered ${pane}`) + ` — reply on WeChat and it'll be injected here. Daemon must be running.\n`);
+        }
+        catch (e) {
+            out(c.yellow(`↩ ${pane} registered; WeChat push failed (${e.message}) — your next reply to the bot still injects here.\n`));
+        }
+        return;
+    }
+    out(c.red(`unknown action '${action}'. use: ask "<q>" | bind | back | status\n`));
+});
 program
     .command("export [session]")
     .description("export a session to a Markdown transcript (default: the latest in this directory)")
@@ -1217,6 +1896,14 @@ pluginCmd
             m.mcpServers ? `${Object.keys(m.mcpServers).length} mcp server(s)` : "",
         ].filter(Boolean);
         out(c.green(`Installed ${p.name}@${p.version}${parts.length ? c.dim(" — " + parts.join(", ")) : ""}\n`));
+        // A plugin can ship CLI commands (manifest `bin`); they're linked into ~/.hara/bin. Tell the user to PATH it.
+        const bins = Object.keys(m.bin ?? {});
+        if (bins.length) {
+            const onPath = (process.env.PATH ?? "").split(":").includes(haraBinDir());
+            out(c.green(`Linked command(s): ${bins.join(", ")} → ${c.dim(haraBinDir())}\n`));
+            if (!onPath)
+                out(c.yellow(`  add to PATH once:  echo 'export PATH="$HOME/.hara/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc\n`));
+        }
         // Surface the code-execution surface: a plugin's MCP servers + hooks run shell commands on every
         // hara launch with no prompt. Installing a plugin = trusting its author to run code; show what.
         const execs = [];
@@ -1289,6 +1976,10 @@ config
         out(c.red(`Invalid sandbox mode. One of: ${SANDBOX_MODES.join(", ")}.\n`));
         process.exit(1);
     }
+    if (key === "reasoningEffort" && !REASONING_EFFORTS.includes(value)) {
+        out(c.red(`Invalid reasoning effort. One of: ${REASONING_EFFORTS.join(", ")}.\n`));
+        process.exit(1);
+    }
     writeConfigValue(key, value);
     out(c.green(`Set ${key} → ${configPath()}\n`));
 });
@@ -1316,12 +2007,17 @@ config
     .action(() => out(configPath() + "\n"));
 // default action (interactive REPL / one-shot)
 program.action(async (opts) => {
-    const cfg = loadConfig({ profile: opts.profile });
+    // Identity-profile selection (--profile flag) is now handled by the program-level preAction
+    // hook above — see setFlagOverride() + resolveActive() in profile.ts. activeId() / loadActiveProfile()
+    // pick it up automatically. `HARA_PROFILE` env still works as a transient override (one slot lower
+    // in the priority chain than --profile).
+    const cfg = loadConfig({ overlay: opts.overlay });
     if (opts.model)
         cfg.model = opts.model;
     const provider0 = await withRouting(await buildProvider(cfg), cfg);
     const fallbackProvider = provider0 && cfg.fallbackModel && cfg.fallbackModel !== cfg.model ? await buildProvider({ ...cfg, model: cfg.fallbackModel, baseURL: cfg.fallbackBaseURL ?? cfg.baseURL, apiKey: cfg.fallbackApiKey ?? cfg.apiKey }) : null;
     const fbOpt = fallbackProvider ? { provider: fallbackProvider } : undefined; // app-failover for the main chat turns
+    const guardianOpt = await buildGuardian(cfg, provider0); // internal safety layer (high-risk actions only)
     if (!provider0) {
         // First-run friendliness: offer the setup wizard instead of just erroring (interactive TTY only).
         if (stdin.isTTY && !opts.print) {
@@ -1338,7 +2034,18 @@ program.action(async (opts) => {
         process.exit(1);
     }
     let provider = provider0;
-    if (cfg.provider === "hara-gateway") {
+    // Active profile is the source of truth for gateway-side concerns (heartbeat / role sync).
+    // Legacy: cfg.provider==='hara-gateway' kept for users still pointing config.json at the old
+    // sentinel — but profile.kind is what the rest of the CLI now reasons about.
+    const __activeP = loadActiveProfile();
+    // Safety UX: first line of stdout = "where am I sending requests right now". Stable, scriptable,
+    // and reassuring at the start of every session. Suppressed in pure -p print mode to keep that
+    // path clean stdout-only (the user wants the model output, not banner noise). Set HARA_QUIET=1
+    // to suppress everywhere.
+    if (!opts.print && process.env.HARA_QUIET !== "1") {
+        out(c.dim(activeProfileLine(__activeP)) + "\n");
+    }
+    if (__activeP.kind === "gateway" || cfg.provider === "hara-gateway") {
         void heartbeat(); // fleet visibility — fire-and-forget, never blocks startup
         void syncOrgRoles(); // refresh governed org-role bundle (B3) in the background; best-effort, never blocks
     }
@@ -1389,6 +2096,35 @@ program.action(async (opts) => {
             if (prior?.history)
                 history.push(...prior.history);
             meta = prior?.meta ?? { id: rid ?? newSessionId(), cwd, provider: cfg.provider, model: cfg.model, title: "", createdAt: new Date().toISOString(), updatedAt: "" };
+            // Apply per-session pinned model on headless resume (mirrors the interactive path).
+            // --model flag wins (already on cfg.model) and is written back; otherwise restore meta.model.
+            if (prior) {
+                if (opts.model) {
+                    meta.model = cfg.model;
+                }
+                else if (meta.model && meta.model !== cfg.model) {
+                    const __allowed = __activeP.kind === "gateway" && __activeP.availableModels && __activeP.availableModels.length > 0;
+                    if (__allowed && !__activeP.availableModels.includes(meta.model)) {
+                        const __fb = __activeP.defaultModel || cfg.model;
+                        // headless: log to stderr so it doesn't pollute the captured stdout reply
+                        try {
+                            process.stderr.write(`hara: resumed session pinned '${meta.model}' not in availableModels — falling back to '${__fb}'.\n`);
+                        }
+                        catch { /* ignore */ }
+                        cfg.model = __fb;
+                        meta.model = __fb;
+                        const __rb = await buildProvider(cfg);
+                        if (__rb)
+                            provider = __rb;
+                    }
+                    else {
+                        cfg.model = meta.model;
+                        const __rb = await buildProvider(cfg);
+                        if (__rb)
+                            provider = __rb;
+                    }
+                }
+            }
         }
         // Inbound images (gateway): the platform downloaded the user's photo(s) and passed their paths via env.
         // Let the agent actually SEE them — attached inline for a vision-capable main model, else described via the
@@ -1429,6 +2165,7 @@ program.action(async (opts) => {
             projectContext,
             memory: memoryDigest(cwd),
             stats,
+            guardian: guardianOpt, // safety layer stays on in headless -p (fail-open; breaker aborts, never hangs)
         });
         if (meta) {
             // Long-session safety: auto-compact before saving so a long chat/cron thread never overflows context.
@@ -1457,6 +2194,22 @@ program.action(async (opts) => {
         },
     });
     const confirm = async (q) => (await rl.question(`${q} ${c.dim("[y/N]")} `)).trim().toLowerCase().startsWith("y");
+    // ask_user (classic REPL): print the question + a numbered menu (matching the setup menu look) and read the
+    // answer through the SAME rl.question channel confirm uses. A bare option number selects it; any other text
+    // is taken as a free-text answer — so the user can always type their own response.
+    const askUser = async (q, options) => {
+        out(c.bold("\n? ") + q + "\n");
+        const opts = (options ?? []).map((o) => o.trim()).filter(Boolean);
+        opts.forEach((o, i) => out(`  ${c.bold(String(i + 1))}) ${o}\n`));
+        const hint = opts.length ? c.dim(`(1-${opts.length} to pick, or type your own answer) `) : c.dim("(type your answer) ");
+        const raw = (await rl.question(`${c.cyan("›")} ${hint}`)).trim();
+        if (opts.length) {
+            const n = Number.parseInt(raw, 10);
+            if (Number.isInteger(n) && n >= 1 && n <= opts.length)
+                return opts[n - 1];
+        }
+        return raw;
+    };
     // shift+tab cycles the approval mode (classic REPL only; the TUI handles its own keys).
     // Bare /approval is the reliable fallback everywhere.
     if (stdin.isTTY && !useTui) {
@@ -1477,7 +2230,10 @@ program.action(async (opts) => {
             /* keypress unavailable; /approval still works */
         }
     }
-    if (!hasAgentsMd(cwd)) {
+    // First-run AGENTS.md offer — classic REPL only. In TUI mode we must NOT call rl.question before ink
+    // mounts: a readline question puts stdin in a state ink can't read from, leaving the input box dead
+    // (the TUI shows a `/init` tip instead, below). See the `tip` in the runTui header.
+    if (!hasAgentsMd(cwd) && !useTui) {
         const ans = (await rl.question(`${c.dim("No AGENTS.md here — analyze this project and create one?")} ${c.dim("[Y/n]")} `)).trim().toLowerCase();
         if (ans === "" || ans.startsWith("y")) {
             out(c.dim("Analyzing project…\n"));
@@ -1513,11 +2269,43 @@ program.action(async (opts) => {
         createdAt: new Date().toISOString(),
         updatedAt: "",
     };
+    // Per-session model precedence on resume:
+    //   1. --model flag (already applied to cfg.model up-top) → wins and is written back to meta.model.
+    //   2. resumed meta.model → restored into cfg.model (the user's last /model choice).
+    //   3. otherwise leave cfg.model as the profile-resolved default.
+    // Safety: if we're on a gateway profile with a finite availableModels list and the resumed
+    // meta.model isn't in it (e.g. user switched profiles between sessions), warn and degrade to
+    // profile.defaultModel — a stale pinned model shouldn't brick the resume.
+    if (resumed) {
+        if (opts.model) {
+            // explicit --model on the command line wins; persist it onto the session.
+            meta.model = cfg.model;
+        }
+        else if (meta.model && meta.model !== cfg.model) {
+            const __ap = __activeP;
+            const __allowed = __ap.kind === "gateway" && __ap.availableModels && __ap.availableModels.length > 0;
+            if (__allowed && !__ap.availableModels.includes(meta.model)) {
+                const __fallback = __ap.defaultModel || cfg.model;
+                out(c.yellow(`⚠ resumed session was pinned to '${meta.model}', which isn't in this profile's availableModels (${__ap.availableModels.join(", ")}). Falling back to '${__fallback}'.\n`));
+                cfg.model = __fallback;
+                meta.model = __fallback;
+                const __rebuilt = await buildProvider(cfg);
+                if (__rebuilt)
+                    provider = __rebuilt;
+            }
+            else {
+                cfg.model = meta.model;
+                const __rebuilt = await buildProvider(cfg);
+                if (__rebuilt)
+                    provider = __rebuilt;
+            }
+        }
+    }
     const history = resumed?.history ? [...resumed.history] : [];
     const memorySnap = memoryDigest(cwd); // durable memory, read once (frozen snapshot)
     const buildMemory = () => (meta.workingSet?.length ? `## Working memory (this task)\n${meta.workingSet.map((w) => `- ${w}`).join("\n")}\n\n` : "") + memorySnap;
     if (resumed)
-        out(c.dim(`(resumed ${shortId(meta.id)} · ${history.length} msgs)\n`));
+        out(c.dim(`(resumed ${shortId(meta.id)} · ${history.length} msgs · model = ${cfg.model})\n`));
     // Vision describer state — shared by the `/vision` command (both REPLs) and the TUI image pipeline.
     let visionProvider;
     let remindedVision = false;
@@ -1580,24 +2368,48 @@ program.action(async (opts) => {
         },
         {
             name: "model",
-            desc: "show or switch model: /model [id]",
+            desc: "show or switch model: /model [id [--force|all]]",
             run: async (a) => {
-                if (a) {
-                    cfg.model = a;
-                    visionProvider = undefined;
-                    remindedVision = false;
-                    const p = await buildProvider(cfg);
-                    if (p) {
-                        provider = p;
-                        if (bar.isActive())
-                            bar.update({ model: a });
-                        out(c.dim(`(model → ${cfg.provider}:${a})\n`));
+                const parts = (a || "").trim().split(/\s+/).filter(Boolean);
+                const force = parts.some((p) => p === "--force" || p === "all" || p === "-f");
+                const id = parts.find((p) => p !== "--force" && p !== "all" && p !== "-f");
+                if (!id) {
+                    // Bare /model: pinned model + per-role overrides table, so the user sees what's pinned now
+                    // and which roles deviate from it.
+                    const __force = isSessionForceModel();
+                    const __lines = [`${cfg.provider}:${cfg.model}`];
+                    if (meta.model && meta.model !== cfg.model) {
+                        __lines.push(c.dim(`session pinned: ${meta.model} (cfg drift — /model ${meta.model} to re-pin)`));
                     }
-                    else
-                        out(c.red("(could not rebuild provider)\n"));
+                    else {
+                        __lines.push(c.dim(`session pinned: ${meta.model || "(none)"}${__force ? c.yellow(" · forced (all roles use session model)") : ""}`));
+                    }
+                    const __roles = loadRoles(cwd);
+                    if (__roles.length) {
+                        __lines.push(c.dim("roles:"));
+                        for (const r of __roles) {
+                            const eff = __force ? cfg.model : (r.model || cfg.model);
+                            const tag = __force && r.model && r.model !== cfg.model ? c.yellow(" (overridden by --force)") : r.model ? c.dim(" (role pin)") : c.dim(" (session)");
+                            __lines.push(`  ${r.id}: ${eff}${tag}`);
+                        }
+                    }
+                    return void out(__lines.join("\n") + "\n");
+                }
+                cfg.model = id;
+                meta.model = id;
+                setSessionForceModel(force);
+                visionProvider = undefined;
+                remindedVision = false;
+                const p = await buildProvider(cfg);
+                if (p) {
+                    provider = p;
+                    if (bar.isActive())
+                        bar.update({ model: id });
+                    saveSession(meta, history); // persist the session-pinned model so resume restores it
+                    out(c.dim(`(model → ${cfg.provider}:${id}${force ? " · forced (all roles)" : ""})\n`));
                 }
                 else
-                    out(`${cfg.provider}:${cfg.model}\n`);
+                    out(c.red("(could not rebuild provider)\n"));
             },
         },
         {
@@ -1789,6 +2601,21 @@ program.action(async (opts) => {
     }
     if (useTui) {
         rl.close(); // hand stdin over to ink
+        // First-run AGENTS.md offer — via a tiny ink prompt, NOT readline. A readline question before the
+        // main TUI leaves stdin unreadable by ink (dead input box); ink cleans up on unmount, so the TUI
+        // mounted right after gets working input. Runs before mount, like the classic path.
+        if (!hasAgentsMd(cwd)) {
+            if (await askConfirm("No AGENTS.md here — analyze this project and create one?")) {
+                out(c.dim("Analyzing project…\n"));
+                try {
+                    await runInit(provider, cwd, sandbox);
+                }
+                catch (e) {
+                    out(c.red(`[init error] ${e.message}\n`));
+                }
+                projectContext = loadAgentsMd(cwd) || undefined;
+            }
+        }
         setTheme(cfg.theme);
         // Vision: a text-only main model routes pasted images through a describer (`visionModel`); a
         // vision-capable main model gets them inline (describer auto-suspended). Unknown models are asked
@@ -1876,19 +2703,48 @@ program.action(async (opts) => {
                 return { skip: true };
             }
         };
-        const mainCap = classifyVision(cfg.provider, cfg.model, cfg.modelVision);
-        const visionLine = mainCap === "vision"
-            ? `${cfg.model} reads images directly`
-            : cfg.visionModel
-                ? `${cfg.model} is text-only → images read by ${cfg.visionModel}`
-                : mainCap === "text"
-                    ? `${cfg.model} is text-only — /vision <model> to read pasted images`
-                    : `${cfg.model} image support unknown — asked on first paste`;
+        // ── Header (rebuilt per 顾雅 spec, 2026-06):
+        //   • Single-line logo + tagline (no ASCII banner block).
+        //   • Identity line branches on profile kind: personal collapses to `personal <provider>:<model>`
+        //     (route host only when baseURL is custom); org spreads to `org <label> · <id> → <host>`
+        //     plus its own `model` line annotated with the source (org default / user override).
+        //   • cwd line silently appends "· AGENTS.md" when loaded — we never show a negative noise line.
+        //   • Vision routing is NOT in the header anymore — App emits a one-shot inline notice via
+        //     `visionNotice` the first time an image lands in the session.
+        const __mainCap = classifyVision(cfg.provider, cfg.model, cfg.modelVision);
+        const __routeForHeader = routeHost(__activeP);
+        // Model-source label (org only). `loadConfig` already merges env > project > overlay > globals,
+        // so cfg.model is whatever the runtime will actually use. If it equals the profile's defaultModel
+        // we treat it as "org default"; otherwise it's a user override (per-profile setModel, env, or flag).
+        const __modelSource = __activeP.kind === "gateway"
+            ? cfg.model && __activeP.defaultModel && cfg.model === __activeP.defaultModel
+                ? "org default"
+                : "user override"
+            : undefined;
+        // Lazy vision notice: only set it for the "describer in use" path (header used to always-on it).
+        // Native-vision models stay silent (the routing IS direct, nothing to say). "Unknown" stays silent
+        // too — the existing per-image picker (resolveImages) handles that on first paste.
+        const __visionNotice = __mainCap === "text" && cfg.visionModel
+            ? `${cfg.model} is text-only — images read by ${cfg.visionModel}`
+            : undefined;
         await runTui({
             initialStatus: { sessionName: meta.title || shortId(meta.id), approval, input: stats.input, output: stats.output, ctxPct: 0, agents: 0 },
             model: cfg.model,
             cwd,
-            header: { version: pkg.version, model: `${cfg.provider}:${cfg.model}`, cwd, vision: visionLine, session: meta.id, tip: `/help · @file attaches · shift+tab cycles modes · esc interrupts${projectContext ? " · AGENTS.md loaded" : ""}` },
+            header: {
+                version: pkg.version,
+                modelLabel: `${cfg.provider}:${cfg.model}`,
+                cwd,
+                agentsMdLoaded: !!projectContext,
+                session: meta.id,
+                kind: __activeP.kind === "gateway" ? "org" : "personal",
+                profileId: __activeP.kind === "gateway" || __activeP.id === PERSONAL_ID ? undefined : __activeP.id,
+                orgLabel: __activeP.kind === "gateway" ? __activeP.label : undefined,
+                orgId: __activeP.kind === "gateway" ? __activeP.deviceId || __activeP.id : undefined,
+                routeHost: __routeForHeader?.host,
+                modelSource: __modelSource,
+            },
+            visionNotice: __visionNotice,
             cycleApproval: (m) => cycleMode(m),
             onClipboardImage: readClipboardImage,
             vim: cfg.vimMode,
@@ -1933,15 +2789,39 @@ program.action(async (opts) => {
                         return void h.sink.notice("error" in r ? `(${r.error})` : `↩ reverted: ${r.files.join(", ")}`);
                     }
                     if (nm === "model") {
-                        if (!arg)
-                            return void h.sink.notice(`model: ${cfg.provider}:${cfg.model}`);
-                        cfg.model = arg;
+                        const parts = (arg || "").trim().split(/\s+/).filter(Boolean);
+                        const force = parts.some((p) => p === "--force" || p === "all" || p === "-f");
+                        const id = parts.find((p) => p !== "--force" && p !== "all" && p !== "-f");
+                        if (!id) {
+                            const __force = isSessionForceModel();
+                            const __lines = [`model: ${cfg.provider}:${cfg.model}`];
+                            if (meta.model && meta.model !== cfg.model) {
+                                __lines.push(`session pinned: ${meta.model} (cfg drift — /model ${meta.model} to re-pin)`);
+                            }
+                            else {
+                                __lines.push(`session pinned: ${meta.model || "(none)"}${__force ? " · forced (all roles use session model)" : ""}`);
+                            }
+                            const __roles = loadRoles(cwd);
+                            if (__roles.length) {
+                                __lines.push("roles:");
+                                for (const r of __roles) {
+                                    const eff = __force ? cfg.model : (r.model || cfg.model);
+                                    const tag = __force && r.model && r.model !== cfg.model ? " (overridden by --force)" : r.model ? " (role pin)" : " (session)";
+                                    __lines.push(`  ${r.id}: ${eff}${tag}`);
+                                }
+                            }
+                            return void h.sink.notice(__lines.join("\n"));
+                        }
+                        cfg.model = id;
+                        meta.model = id;
+                        setSessionForceModel(force);
                         visionProvider = undefined; // new model may resolve a different describer / capability
                         remindedVision = false;
                         const p = await buildProvider(cfg);
                         if (p) {
                             provider = p;
-                            return void h.sink.notice(`(model → ${cfg.provider}:${arg})`);
+                            saveSession(meta, history); // persist the session-pinned model so resume restores it
+                            return void h.sink.notice(`(model → ${cfg.provider}:${id}${force ? " · forced (all roles)" : ""})`);
                         }
                         return void h.sink.notice("(could not rebuild provider)");
                     }
@@ -2095,6 +2975,37 @@ program.action(async (opts) => {
                     }
                     if (byName.has(nm))
                         return void h.sink.notice(`/${nm} isn't wired into the TUI yet — use \`hara ${nm} …\` as a subcommand, or HARA_TUI=0.`);
+                    // /<skill> — a user-invocable skill (built-in/global/plugin). ENTER it: load the skill + run a kickoff
+                    // turn so the agent acts at once (e.g. design mode opens its live workspace + surfaces prior progress).
+                    {
+                        const sk = loadSkillIndex(cwd).find((s) => s.id === nm && s.userInvocable);
+                        if (sk) {
+                            h.sink.notice(`↗ entering ${sk.id}…`);
+                            history.push({
+                                role: "user",
+                                content: `Skill \`${sk.id}\`:\n${loadSkillBody(sk)}\n\n---\nEntering ${sk.id} mode${arg ? ` — request: ${arg}` : ""}. Follow this skill now. If it has a workspace or live preview, OPEN it FIRST so any existing progress is visible, then proceed — offer to continue existing work or start fresh.`,
+                            });
+                            const skin = stats.input;
+                            const skout = stats.output;
+                            // `h.approval` is the TUI-level union (includes "plan"); runAgent wants the config-level
+                            // ApprovalMode (no "plan"). Inside a /<skill> kickoff "plan" wouldn't make sense anyway —
+                            // fall back to "suggest" so we keep the user's confirm gate without crashing the type check.
+                            const __skApproval = h.approval === "plan" ? "suggest" : h.approval;
+                            try {
+                                await runAgent(history, { provider, ctx: { cwd, sandbox, spawn, ui: { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice }, ask: h.ask, describeImage: describeScreenshot, locate: locateScreenshot }, approval: __skApproval, confirm: h.confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: h.signal, fallback: fbOpt, guardian: guardianOpt });
+                            }
+                            catch (e) {
+                                h.sink.notice(`[error] ${e?.message ?? e}`);
+                            }
+                            if (!meta.title) {
+                                meta.title = await nameSession(provider, history);
+                                h.sink.session(meta.title);
+                            }
+                            h.sink.usage(stats.input - skin, stats.output - skout);
+                            saveSession(meta, history);
+                            return;
+                        }
+                    }
                     const near = nearest(nm, [...byName.keys()]);
                     return void h.sink.notice(`Unknown command /${nm}.${near.length ? " Did you mean " + near.map((n) => "/" + n).join(", ") + "?" : ""}`);
                 }
@@ -2127,7 +3038,7 @@ program.action(async (opts) => {
                     const pout = stats.output;
                     await runAgent(history, {
                         provider,
-                        ctx: { cwd, sandbox, spawn, ui, describeImage: describeScreenshot, locate: locateScreenshot },
+                        ctx: { cwd, sandbox, spawn, ui, ask: h.ask, describeImage: describeScreenshot, locate: locateScreenshot },
                         approval: "suggest",
                         confirm: h.confirm,
                         toolFilter: (n) => READONLY_TOOLS.has(n),
@@ -2156,7 +3067,7 @@ program.action(async (opts) => {
                         const xout = stats.output;
                         await runAgent(history, {
                             provider,
-                            ctx: { cwd, sandbox, spawn, ui, describeImage: describeScreenshot, locate: locateScreenshot },
+                            ctx: { cwd, sandbox, spawn, ui, ask: h.ask, describeImage: describeScreenshot, locate: locateScreenshot },
                             approval: choice,
                             memory: buildMemory(),
                             confirm: h.confirm,
@@ -2165,6 +3076,7 @@ program.action(async (opts) => {
                             stats,
                             signal: h.signal,
                             pendingInput,
+                            guardian: guardianOpt,
                         });
                         h.sink.usage(stats.input - xin, stats.output - xout);
                         saveSession(meta, history);
@@ -2184,7 +3096,7 @@ program.action(async (opts) => {
                 const beforeOut = stats.output;
                 await runAgent(history, {
                     provider,
-                    ctx: { cwd, sandbox, spawn, ui, describeImage: describeScreenshot, locate: locateScreenshot },
+                    ctx: { cwd, sandbox, spawn, ui, ask: h.ask, describeImage: describeScreenshot, locate: locateScreenshot },
                     approval: appr,
                     memory: buildMemory(),
                     confirm: h.confirm,
@@ -2194,6 +3106,7 @@ program.action(async (opts) => {
                     signal: h.signal,
                     pendingInput,
                     fallback: fbOpt,
+                    guardian: guardianOpt,
                 });
                 if (!meta.title) {
                     meta.title = await nameSession(provider, history);
@@ -2205,11 +3118,12 @@ program.action(async (opts) => {
                 await maybeAutoCompact(provider, history, meta, stats, cfg, (m) => h.sink.notice(m));
             },
         });
+        out("\n" + c.dim("Session ") + c.bold(shortId(meta.id)) + c.dim(" saved · resume:  ") + c.cyan(`hara resume ${shortId(meta.id)}`) + "\n");
         await closeMcp();
         process.exit(0); // TUI done — exit cleanly (ink can leave stdin referenced)
     }
     out(c.dim(`Type a task. /help · @path attaches a file · shift+tab cycles mode · Esc interrupts · /exit to quit.${projectContext ? "  (AGENTS.md loaded)" : ""}\n\n`));
-    bar.install({ sessionName: meta.title || shortId(meta.id), model: cfg.model, approval, input: stats.input, output: stats.output });
+    bar.install({ sessionName: meta.title || shortId(meta.id), model: cfg.model, approval, input: stats.input, output: stats.output, profileId: __activeP.id, profileKind: __activeP.kind });
     process.on("exit", () => {
         try {
             bar.uninstall();
@@ -2234,6 +3148,30 @@ program.action(async (opts) => {
             const [name, ...rest] = line.slice(1).split(/\s+/);
             const cmd = byName.get(name);
             if (!cmd) {
+                const sk = loadSkillIndex(cwd).find((s) => s.id === name && s.userInvocable);
+                if (sk) {
+                    // ENTER the mode: load the skill + run a kickoff turn now (mirrors the TUI path) so e.g. /design
+                    // opens its workspace + surfaces prior progress immediately, instead of just staging context.
+                    out(c.dim(`↗ entering ${sk.id}…\n`));
+                    history.push({
+                        role: "user",
+                        content: `Skill \`${sk.id}\`:\n${loadSkillBody(sk)}\n\n---\nEntering ${sk.id} mode${rest.length ? ` — request: ${rest.join(" ")}` : ""}. Follow this skill now. If it has a workspace or live preview, OPEN it FIRST so any existing progress is visible, then proceed — offer to continue existing work or start fresh.`,
+                    });
+                    currentTurn = new AbortController();
+                    try {
+                        await runAgent(history, { provider, ctx: { cwd, sandbox, spawn, ask: askUser }, approval, confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: currentTurn.signal, fallback: fbOpt, guardian: guardianOpt });
+                    }
+                    catch (e) {
+                        out(c.red(`\n[error] ${e.message}\n`));
+                    }
+                    finally {
+                        currentTurn = null;
+                    }
+                    if (!meta.title)
+                        meta.title = await nameSession(provider, history);
+                    saveSession(meta, history);
+                    continue;
+                }
                 const near = nearest(name, [...byName.keys()]);
                 const hint = near.length ? c.dim(` Did you mean ${near.map((n) => "/" + n).join(", ")}?`) : "";
                 out(c.red(`Unknown command /${name}.`) + hint + c.dim(" — /help for the list.\n"));
@@ -2252,7 +3190,7 @@ program.action(async (opts) => {
         currentTurn = new AbortController();
         const t0 = Date.now();
         try {
-            await runAgent(history, { provider, ctx: { cwd, sandbox, spawn }, approval, confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: currentTurn.signal, fallback: fbOpt });
+            await runAgent(history, { provider, ctx: { cwd, sandbox, spawn, ask: askUser }, approval, confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: currentTurn.signal, fallback: fbOpt, guardian: guardianOpt });
         }
         catch (e) {
             out(c.red(`\n[error] ${e.message}\n`));
@@ -2282,6 +3220,7 @@ program.action(async (opts) => {
         }
     }
     bar.uninstall();
+    out("\n" + c.dim("Session ") + c.bold(shortId(meta.id)) + c.dim(" saved · resume:  ") + c.cyan(`hara resume ${shortId(meta.id)}`) + "\n");
     rl.close();
     await closeMcp();
 });