@nanhara/hara 0.70.0 → 0.95.2

package/dist/index.js

@@ -2,24 +2,32 @@
 import { Command } from "commander";
 import { createInterface } from "node:readline/promises";
 import { emitKeypressEvents } from "node:readline";
-import { runTui } from "./tui/run.js";
-import { readClipboardImage } from "./images.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, 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";
+import { formatContextReport } from "./agent/context-report.js";
+import { userTurnPreviews, rewindTo } from "./agent/rewind.js";
+import { checkpoint, listCheckpoints, restoreCheckpoint } from "./checkpoints.js";
 import { mapLimit, maxParallel } from "./concurrency.js";
 import { parseVerdict, captureChanges, reviewPrompt, fixPrompt, REVIEWER_SYSTEM, isTreeClean, stripCommitFence } from "./org/review-chain.js";
 import { parseSchedule, describeSchedule, nextRun } from "./cron/schedule.js";
@@ -36,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";
@@ -58,6 +67,8 @@ import "./tools/memory.js"; // register memory_search/get/write/forget/skill_cre
 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 { 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),
@@ -75,29 +86,59 @@ 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;
+    const baseURL = cfg.baseURL ?? ap.baseURL;
+    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
+ *  routeModel is unset or equals the primary model. routeBaseURL/routeApiKey default to the primary's. */
+async function withRouting(primary, cfg) {
+    if (!primary || !cfg.routeModel || cfg.routeModel === cfg.model)
+        return primary;
+    const alt = await buildProvider({ ...cfg, model: cfg.routeModel, baseURL: cfg.routeBaseURL ?? cfg.baseURL, apiKey: cfg.routeApiKey ?? cfg.apiKey });
+    return alt ? routingProvider(primary, alt) : primary;
 }
 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", "qwen-oauth": "coder-model" };
 /** Interactive first-run setup: pick a provider, (optional) base URL, API key, and model → ~/.hara/config.json. */
@@ -220,8 +261,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)
@@ -257,7 +300,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);
@@ -309,7 +353,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
@@ -486,20 +531,65 @@ const MEMORY_DISTILL_SYSTEM = "You consolidate an agent's short-term daily memor
     "conventions / user preferences from the logs that are NOT already captured, and persist each with " +
     "memory_write (target=memory, or target=user for preferences; pick the right scope=project|global). " +
     "Skip the ephemeral, the one-off, and anything already known. Be terse and de-duplicated. Then reply DONE.";
-const COMPACT_SYSTEM = "Summarize the conversation so far into a concise but complete brief so the assistant can " +
-    "continue seamlessly: the user's goal, key decisions, files changed, current state, and open next steps. " +
-    "Be specific. Output only the summary.";
+const COMPACT_SYSTEM = "Summarize the conversation so far into a structured, complete brief so the assistant can continue with NO " +
+    "loss of context. First think privately in a brief <analysis> scratchpad (what matters, what's in flight), " +
+    "then output ONLY the summary under these exact headings:\n" +
+    "1. Goal — the user's overall intent, in their own framing.\n" +
+    "2. Key decisions — choices made and why (so they aren't relitigated).\n" +
+    "3. Files & code — files created/changed and the important snippets, with why each matters.\n" +
+    "4. Errors & fixes — failures hit, how they were resolved, and any correction the user gave (quote pointed feedback verbatim).\n" +
+    "5. Current state — what works now / what is verified.\n" +
+    "6. Next step — the immediate next action, INCLUDING a direct verbatim quote of the user's most recent request so there is no drift.\n" +
+    "Be specific and concrete. Drop the <analysis>; output only the headed summary.";
 const workingSetFromSummary = (s) => s
     .split("\n")
     .map((l) => l.replace(/^[-*\d.\s]+/, "").trim())
     .filter((l) => l.length > 3)
     .slice(0, 12)
     .map((l) => l.slice(0, 140));
+/** Summarize the conversation and replace history with the summary (keeping working-memory notes). Shared by
+ *  /compact (manual) and auto-compaction. Returns the summary, or null on failure / nothing to do. */
+async function compactConversation(provider, history, meta, stats) {
+    if (history.length < 2)
+        return null;
+    const r = await provider.turn({
+        system: COMPACT_SYSTEM,
+        history: [...history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
+        tools: [],
+        onText: () => { },
+    });
+    if (r.stop === "error")
+        return null;
+    const summary = r.text.trim();
+    if (!summary)
+        return null;
+    meta.workingSet = workingSetFromSummary(summary); // survives the history wipe + injects into the next turns
+    history.length = 0;
+    history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
+    stats.input += r.usage?.input ?? 0;
+    stats.output += r.usage?.output ?? 0;
+    stats.lastInput = r.usage?.input ?? 0; // ctx% now reflects the (small) summary, not the old full turn
+    saveSession(meta, history);
+    return summary;
+}
+/** Auto-compact (à la Claude Code) when the last turn filled the context past the threshold, so the NEXT turn
+ *  doesn't overflow. Opt-out via `autoCompact: false` / `HARA_AUTO_COMPACT=0`. Best-effort; `notify` surfaces
+ *  a one-line status. Returns true if it compacted. */
+async function maybeAutoCompact(provider, history, meta, stats, cfg, notify) {
+    const pct = bar.ctxPctFor(cfg.model, stats.lastInput ?? 0);
+    if (!shouldAutoCompact(pct, history.length, cfg.autoCompact))
+        return false;
+    notify(`✻ Auto-compacting conversation (context ${pct}% full)…`);
+    const summary = await compactConversation(provider, history, meta, stats);
+    notify(summary ? `(auto-compacted — context replaced with a summary; ${meta.workingSet?.length ?? 0} notes kept)` : "(auto-compact failed — use /compact or /clear)");
+    return !!summary;
+}
 /** Run a (read-only by default) sub-agent to completion, quietly, and return its final text. */
 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.
@@ -577,10 +667,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")
@@ -604,8 +711,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...>")
@@ -740,30 +872,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 | qwen | openai | 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|qwen|openai|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`));
     }
@@ -771,6 +1280,102 @@ program
         out(c.red(`Enroll failed: ${err instanceof Error ? err.message : String(err)}\n`));
     }
 });
+program
+    .command("permissions")
+    .description("show or scaffold command permission rules (bash allow/ask/deny + read-only autorun)")
+    .option("--init", "write a starter permissions.json")
+    .option("--project", "with --init, write it in this project (.hara/permissions.json) instead of globally")
+    .action((opts) => {
+    if (opts.init) {
+        const p = scaffoldPermissions(process.cwd(), opts.project ? "project" : "global");
+        return void out(p ? c.green(`✓ wrote ${p}\n`) : c.dim("(permissions file already exists — edit it directly)\n"));
+    }
+    const r = loadPermissionRules(process.cwd());
+    const pp = projectPermissionsPath(process.cwd());
+    out(c.bold("Command permissions") +
+        c.dim(" (bash) — deny blocks even in full-auto; allow / read-only auto-runs even in suggest\n") +
+        `  ${c.dim("global: ")} ${globalPermissionsPath()}\n` +
+        `  ${c.dim("project:")} ${pp ?? "(none)"}\n` +
+        `  ${c.dim("read-only autorun:")} ${r.readonlyAutorun ? c.green("on") : "off"}\n` +
+        `  ${c.green("allow")}: ${r.allow.length ? r.allow.join(", ") : c.dim("(none)")}\n` +
+        `  ${c.red("deny")} : ${r.deny.length ? r.deny.join(", ") : c.dim("(none)")}\n` +
+        c.dim("  edit the JSON to customize, or `hara permissions --init` for a starter.\n"));
+});
+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 | 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) => {
+    const mod = await import("./gateway/serve.js");
+    if (opts.platform === "weixin" && opts.login) {
+        await mod.weixinLogin();
+        return;
+    }
+    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)")
@@ -1121,6 +1726,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 = [];
@@ -1193,6 +1806,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`));
 });
@@ -1220,10 +1837,16 @@ 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 buildProvider(cfg);
+    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
     if (!provider0) {
         // First-run friendliness: offer the setup wizard instead of just erroring (interactive TTY only).
         if (stdin.isTTY && !opts.print) {
@@ -1240,7 +1863,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
     }
@@ -1261,16 +1895,112 @@ program.action(async (opts) => {
     // one-shot
     if (opts.print) {
         const projectContext = loadAgentsMd(cwd) || undefined;
-        const history = [{ role: "user", content: expandMentions(String(opts.print), cwd) }];
+        // Vision sidecar for headless runs (gateway/cron): without it the computer tool's screenshots come back
+        // "configure a vision model" even when one is set, leaving a headless agent blind. Mirrors the interactive
+        // describeScreenshot — a configured visionModel, else the main model if it's vision-capable.
+        const describeImage = async (path, hint) => {
+            const cap = classifyVision(cfg.provider, cfg.model, cfg.modelVision);
+            const vp = cfg.visionModel
+                ? ((await buildProvider({ ...cfg, model: cfg.visionModel, baseURL: cfg.visionBaseURL ?? cfg.baseURL, apiKey: cfg.visionApiKey ?? cfg.apiKey })) ?? null)
+                : cap === "vision"
+                    ? provider
+                    : null;
+            if (!vp)
+                return "";
+            try {
+                return await describeImages(vp, [{ path, mediaType: "image/png" }], { system: SCREENSHOT_SYSTEM, hint });
+            }
+            catch {
+                return "";
+            }
+        };
+        // Headless session continuity: --resume <id> / --continue loads the session, appends this prompt, and
+        // saves it back — so `hara -p … --resume <id>` continues a thread (used by cron, scripts, the chat gateway).
+        // Plain `hara -p` stays stateless. A --resume id with no match is created WITH that id (stable per caller).
+        let meta = null;
+        const history = [];
+        if (opts.resume || opts.continue) {
+            const rid = opts.resume ? (resolveSessionId(opts.resume) ?? opts.resume) : latestForCwd(cwd)?.meta.id;
+            const prior = rid ? loadSession(rid) : null;
+            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
+        // visionModel sidecar and folded into the message (text-only models can't take image blocks).
+        const userText = expandMentions(String(opts.print), cwd);
+        const inboundImgs = (process.env.HARA_GATEWAY_IMAGES ?? "")
+            .split("\n")
+            .map((s) => s.trim())
+            .filter((p) => p && existsSync(p))
+            .map((p) => ({ path: p, mediaType: mediaTypeFor(p) ?? "image/jpeg" }));
+        if (inboundImgs.length && classifyVision(cfg.provider, cfg.model, cfg.modelVision) === "vision") {
+            history.push({ role: "user", content: userText, images: inboundImgs }); // native vision → inline
+        }
+        else if (inboundImgs.length && cfg.visionModel) {
+            let desc = "";
+            try {
+                const vp = await buildProvider({ ...cfg, model: cfg.visionModel, baseURL: cfg.visionBaseURL ?? cfg.baseURL, apiKey: cfg.visionApiKey ?? cfg.apiKey });
+                if (vp)
+                    desc = await describeImages(vp, inboundImgs);
+            }
+            catch {
+                /* describe is best-effort — fall back to the marker-only text */
+            }
+            const n = inboundImgs.length;
+            history.push({
+                role: "user",
+                content: desc ? `${userText}\n\n[${n} image${n > 1 ? "s" : ""} the user sent — described by ${cfg.visionModel}]\n${desc}` : userText,
+            });
+        }
+        else {
+            history.push({ role: "user", content: userText });
+        }
         await runAgent(history, {
             provider,
-            ctx: { cwd, sandbox, spawn: (t, role) => runSubagent(cfg, provider, cwd, sandbox, projectContext, stats, t, role) },
+            ctx: { cwd, sandbox, spawn: (t, role) => runSubagent(cfg, provider, cwd, sandbox, projectContext, stats, t, role), describeImage },
             approval: "full-auto",
             confirm: async () => true,
             projectContext,
             memory: memoryDigest(cwd),
             stats,
         });
+        if (meta) {
+            // Long-session safety: auto-compact before saving so a long chat/cron thread never overflows context.
+            // Silent (no-op notify) in headless mode so nothing leaks into a captured -p reply. Opt-out via config.
+            await maybeAutoCompact(provider, history, meta, stats, cfg, () => { });
+            saveSession(meta, history); // persist when resuming/continuing; plain -p stays stateless
+        }
         if (stats.input || stats.output)
             out(statusLine(cfg.model, stats.input, stats.output) + "\n");
         await closeMcp();
@@ -1312,7 +2042,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"));
@@ -1348,11 +2081,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;
@@ -1415,24 +2180,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"));
             },
         },
         {
@@ -1538,31 +2327,52 @@ program.action(async (opts) => {
                 out(c.green(`↩ reverted: ${r.files.join(", ")}\n`));
             },
         },
+        {
+            name: "context",
+            desc: "show what's filling the context window (token breakdown by category)",
+            run: () => void out(formatContextReport(history, cfg.model) + "\n"),
+        },
+        {
+            name: "rewind",
+            desc: "fork the conversation back to an earlier turn: /rewind (list) · /rewind <n> (files unchanged)",
+            run: (a) => {
+                const arg = (a ?? "").trim();
+                if (!arg) {
+                    const turns = userTurnPreviews(history);
+                    return void out(turns.length ? "Recent turns (newest first) — `/rewind <n>` forks from before it (files unchanged):\n" + turns.map((t) => `  ${t.n}. ${t.preview}`).join("\n") + "\n" : c.dim("(nothing to rewind)\n"));
+                }
+                const nh = rewindTo(history, Number(arg));
+                if (!nh)
+                    return void out(c.dim(`(no such turn: ${arg})\n`));
+                history.length = 0;
+                history.push(...nh);
+                saveSession(meta, history);
+                out(c.green(`(rewound — dropped the last ${arg} turn(s); ${history.length} messages kept. Files are unchanged. Type your next message.)\n`));
+            },
+        },
+        {
+            name: "checkpoint",
+            desc: "file-state checkpoints: /checkpoint (list) · /checkpoint restore <n> (revert files to a checkpoint)",
+            run: (a) => {
+                const parts = (a ?? "").trim().split(/\s+/);
+                const cps = listCheckpoints(cwd);
+                if (parts[0] !== "restore") {
+                    return void out(cps.length ? "File checkpoints (newest first) — `/checkpoint restore <n>` reverts files to it:\n" + cps.map((cp, i) => `  ${i + 1}. ${cp.sha}  ${cp.label}`).join("\n") + "\n" : c.dim("(no checkpoints yet — taken before each turn when fileCheckpoints is on)\n"));
+                }
+                const cp = cps[Number(parts[1]) - 1];
+                if (!cp)
+                    return void out(c.dim(`(no checkpoint ${parts[1] ?? ""})\n`));
+                const k = restoreCheckpoint(cwd, cp.sha);
+                out(k == null ? c.red("(restore failed)\n") : c.green(`(restored ${k} file(s) to ${cp.sha} — '${cp.label}'; prior state snapshotted too)\n`));
+            },
+        },
         {
             name: "compact",
             desc: "summarize the conversation so far to free up context",
             run: async () => {
-                if (history.length < 2)
-                    return void out(c.dim("(nothing to compact)\n"));
                 out(c.dim("Compacting…\n"));
-                const r = await provider.turn({
-                    system: COMPACT_SYSTEM,
-                    history: [...history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
-                    tools: [],
-                    onText: () => { },
-                });
-                if (r.stop === "error")
-                    return void out(c.red(`(compact failed: ${r.errorMsg})\n`));
-                const summary = r.text.trim();
-                if (!summary)
-                    return void out(c.dim("(compact produced nothing)\n"));
-                meta.workingSet = workingSetFromSummary(summary); // survives the history wipe + injects next turns
-                history.length = 0;
-                history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
-                stats.input += r.usage?.input ?? 0;
-                stats.output += r.usage?.output ?? 0;
-                saveSession(meta, history);
-                out(c.green(`(compacted — ${summary.length} chars; context replaced with the summary)\n`));
+                const summary = await compactConversation(provider, history, meta, stats);
+                out(summary ? c.green(`(compacted — ${summary.length} chars; context replaced with the summary)\n`) : c.dim("(nothing to compact / compact failed)\n"));
             },
         },
         {
@@ -1603,6 +2413,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
@@ -1690,19 +2515,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,
@@ -1747,15 +2601,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)");
                     }
@@ -1776,6 +2654,33 @@ program.action(async (opts) => {
                         saveSession(meta, history);
                         return void h.sink.notice(`(renamed → ${meta.title})`);
                     }
+                    if (nm === "context")
+                        return void h.sink.notice(formatContextReport(history, cfg.model));
+                    if (nm === "rewind") {
+                        if (!arg) {
+                            const turns = userTurnPreviews(history);
+                            return void h.sink.notice(turns.length ? "Recent turns (newest first) — /rewind <n> (files unchanged):\n" + turns.map((t) => `  ${t.n}. ${t.preview}`).join("\n") : "(nothing to rewind)");
+                        }
+                        const nh = rewindTo(history, Number(arg));
+                        if (!nh)
+                            return void h.sink.notice(`(no such turn: ${arg})`);
+                        history.length = 0;
+                        history.push(...nh);
+                        saveSession(meta, history);
+                        return void h.sink.notice(`(rewound — kept ${history.length} messages; files unchanged. Type your next message.)`);
+                    }
+                    if (nm === "checkpoint") {
+                        const parts = arg.split(/\s+/);
+                        const cps = listCheckpoints(cwd);
+                        if (parts[0] !== "restore") {
+                            return void h.sink.notice(cps.length ? "File checkpoints (newest first) — /checkpoint restore <n>:\n" + cps.map((cp, i) => `  ${i + 1}. ${cp.sha}  ${cp.label}`).join("\n") : "(no checkpoints yet)");
+                        }
+                        const cp = cps[Number(parts[1]) - 1];
+                        if (!cp)
+                            return void h.sink.notice(`(no checkpoint ${parts[1] ?? ""})`);
+                        const k = restoreCheckpoint(cwd, cp.sha);
+                        return void h.sink.notice(k == null ? "(restore failed)" : `(restored ${k} file(s) to ${cp.sha} — '${cp.label}')`);
+                    }
                     if (nm === "compact") {
                         if (history.length < 2)
                             return void h.sink.notice("(nothing to compact)");
@@ -1799,25 +2704,8 @@ program.action(async (opts) => {
                                 /* flush is best-effort */
                             }
                         }
-                        const cr = await provider.turn({
-                            system: COMPACT_SYSTEM,
-                            history: [...history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
-                            tools: [],
-                            onText: () => { },
-                        });
-                        if (cr.stop === "error")
-                            return void h.sink.notice(`(compact failed: ${cr.errorMsg})`);
-                        const summary = cr.text.trim();
-                        if (!summary)
-                            return void h.sink.notice("(compact produced nothing)");
-                        meta.workingSet = workingSetFromSummary(summary);
-                        history.length = 0;
-                        history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
-                        stats.input += cr.usage?.input ?? 0;
-                        stats.output += cr.usage?.output ?? 0;
-                        h.sink.usage(cr.usage?.input ?? 0, cr.usage?.output ?? 0);
-                        saveSession(meta, history);
-                        return void h.sink.notice(`(compacted — kept ${meta.workingSet.length} working-memory notes)`);
+                        const summary = await compactConversation(provider, history, meta, stats);
+                        return void h.sink.notice(summary ? `(compacted — kept ${meta.workingSet?.length ?? 0} working-memory notes)` : "(nothing to compact / compact failed)");
                     }
                     if (nm === "sessions") {
                         const ms = listSessions();
@@ -1899,6 +2787,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 }, describeImage: describeScreenshot, locate: locateScreenshot }, approval: __skApproval, confirm: h.confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: h.signal, fallback: fbOpt });
+                            }
+                            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(", ") + "?" : ""}`);
                 }
@@ -1982,6 +2901,8 @@ program.action(async (opts) => {
                 const userContent = (recalledContext ? `${recalledContext}\n\n---\n\n` : "") + expandMentions(line, cwd) + (ri.extraText ?? "");
                 recalledContext = "";
                 history.push({ role: "user", content: userContent, ...(ri.attach?.length ? { images: ri.attach } : {}) });
+                if (cfg.fileCheckpoints)
+                    checkpoint(cwd, line.slice(0, 80)); // shadow-git snapshot before the turn mutates
                 const beforeIn = stats.input;
                 const beforeOut = stats.output;
                 await runAgent(history, {
@@ -1995,6 +2916,7 @@ program.action(async (opts) => {
                     stats,
                     signal: h.signal,
                     pendingInput,
+                    fallback: fbOpt,
                 });
                 if (!meta.title) {
                     meta.title = await nameSession(provider, history);
@@ -2003,13 +2925,15 @@ program.action(async (opts) => {
                 h.sink.usage(stats.input - beforeIn, stats.output - beforeOut);
                 notifyDone(cfg.notify, { message: meta.title || "turn complete", elapsedMs: Date.now() - turnStart });
                 saveSession(meta, history);
+                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();
@@ -2034,6 +2958,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 }, approval, confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: currentTurn.signal, fallback: fbOpt });
+                    }
+                    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"));
@@ -2047,10 +2995,12 @@ program.action(async (opts) => {
         const userContent = (recalledContext ? `${recalledContext}\n\n---\n\n` : "") + expandMentions(line, cwd);
         recalledContext = "";
         history.push({ role: "user", content: userContent });
+        if (cfg.fileCheckpoints)
+            checkpoint(cwd, userContent.slice(0, 80)); // shadow-git snapshot before the turn mutates
         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 });
+            await runAgent(history, { provider, ctx: { cwd, sandbox, spawn }, approval, confirm, autoApprove, projectContext, memory: buildMemory(), stats, signal: currentTurn.signal, fallback: fbOpt });
         }
         catch (e) {
             out(c.red(`\n[error] ${e.message}\n`));
@@ -2073,11 +3023,14 @@ program.action(async (opts) => {
             out(statusLine(cfg.model, stats.input, stats.output) + "\n\n");
         }
         saveSession(meta, history);
-        const ctxPct = bar.ctxPctFor(cfg.model, stats.lastInput ?? 0);
-        if (ctxPct >= 80)
-            out(c.yellow(`  ⚠ context ${ctxPct}% full — /compact to summarize, or /reset to clear\n`));
+        if (!(await maybeAutoCompact(provider, history, meta, stats, cfg, (m) => out(c.dim(`${m}\n`))))) {
+            const ctxPct = bar.ctxPctFor(cfg.model, stats.lastInput ?? 0);
+            if (ctxPct >= 80)
+                out(c.yellow(`  ⚠ context ${ctxPct}% full — /compact to summarize, or /clear to reset\n`));
+        }
     }
     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();
 });