habithive-code 0.2.3 → 0.3.0

package/src/omniroute.js

@@ -0,0 +1,119 @@
+// habithive-code — the OmniRoute provider Hive ships (ADR-0007: Hive owns the shipped keys, the user owns
+// the rest, Hive never writes secrets). Keys come from opencode's /connect; no model is ever made a default.
+//
+// ensureOmniroute(config): pure — resets name, adapter and the shipped model entries; keeps extra
+//   models and every other option (e.g. an old apiKey); touches nothing outside provider.omniroute.
+// omnirouteTargets(): the one file to edit per existing mode set (highest-precedence file that already has
+//   the block, else that set's opencode.jsonc), for reconcile() to apply via safeEdit.
+
+import { join, basename } from "node:path";
+import { readConfig, safeEdit, ConfigParseError } from "./jsonc.js";
+import { CONFIG_DIR, filesForMode } from "./config.js";
+
+export const OMNIROUTE_ID = "omniroute";
+// The package ships no gateway address: baseURL is a placeholder until `habithive --gateway <ip>` sets it.
+export const PLACEHOLDER_BASE_URL = "http://localhost:20128/v1";
+export const GATEWAY_PORT = 20128;
+export const GATEWAY_SCHEME = "http";
+export const OMNIROUTE_BASE = {
+  name: "OmniRoute",
+  npm: "@ai-sdk/openai-compatible",
+  options: { baseURL: PLACEHOLDER_BASE_URL },
+};
+
+// id, context (= input), output — the design appendix, in order
+const ROWS = `auto/best-coding 1000000 384000
+auto/best-reasoning 1000000 384000
+auto/best-fast 1000000 384000
+auto/best-vision 200000 131072
+auto/best-chat 1000000 384000
+auto/best-coding-fast 1000000 384000
+auto/pro-coding 1000000 384000
+auto/pro-reasoning 1000000 384000
+auto/pro-vision 128000 8192
+auto/pro-chat 1000000 384000
+auto/pro-fast 1000000 384000
+auto/coding 1000000 384000
+auto/fast 1000000 384000
+auto/chat 1000000 384000
+auto/cheap 1000000 384000
+auto/offline 1000000 384000
+auto/smart 1000000 384000
+auto/claude-opus 1000000 384000
+auto/claude-sonnet 1000000 384000
+auto/best-free 1000000 384000
+auto/best-chaos 1000000 384000
+auto/chaos 1000000 384000
+auto/coding:fast 1000000 384000
+auto/coding:cheap 1000000 384000
+auto/coding:free 1000000 384000
+auto/coding:pro 128000 8192
+auto/coding:reliable 1000000 384000
+auto/reasoning 1000000 384000
+auto/reasoning:pro 128000 8192
+auto/vision 200000 131072
+auto/multimodal 200000 131072
+auto/glm 1000000 131072
+auto/minimax 128000 8192
+auto/mimo 200000 131072
+auto/zai 128000 8192
+auto/gemma 128000 8192
+auto/llama 128000 8192
+auto/gemini 1048576 65535`;
+
+export const OMNIROUTE_MODELS = Object.fromEntries(ROWS.split("\n").map((l) => {
+  const [id, context, output] = l.split(" ");
+  return [id, { name: id, reasoning: true, temperature: true, tool_call: true, limit: { context: +context, output: +output, input: +context } }];
+}));
+
+const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+
+export function ensureOmniroute(config) {
+  const out = structuredClone(config ?? {});
+  if (!isObj(out.provider)) out.provider = {};
+  const cur = isObj(out.provider[OMNIROUTE_ID]) ? out.provider[OMNIROUTE_ID] : (out.provider[OMNIROUTE_ID] = {});
+  const { options, ...own } = structuredClone(OMNIROUTE_BASE);
+  Object.assign(cur, own);
+  cur.options = { ...(isObj(cur.options) ? cur.options : {}) };
+  if (typeof cur.options.baseURL !== "string" || !cur.options.baseURL) cur.options.baseURL = options.baseURL;
+  cur.models = { ...(isObj(cur.models) ? cur.models : {}), ...structuredClone(OMNIROUTE_MODELS) };
+  return out;
+}
+
+const hasBlock = (f) => {
+  const r = readConfig(f);
+  if (!r.ok) throw new ConfigParseError(r.file, r.line, r.column, r.message);
+  return r.value?.provider?.[OMNIROUTE_ID] != null;
+};
+
+// De-duplicated absolute paths, one per existing mode set (complex, simple). Throws ConfigParseError on an unreadable file.
+export function omnirouteTargets() {
+  const out = new Set();
+  for (const mode of ["complex", "simple"]) {
+    const files = filesForMode(mode);
+    if (!files) continue;
+    const named = (n) => files.find((f) => basename(f) === n);
+    const jsonc = named("opencode.jsonc");
+    const cands = [jsonc, named("opencode.json") ?? join(CONFIG_DIR, "opencode.json"), join(CONFIG_DIR, "config.json")];
+    out.add(cands.find(hasBlock) ?? jsonc);
+  }
+  return [...out];
+}
+
+// Validate a bare dotted-quad IPv4 (no scheme/port) and build the gateway base URL.
+export function gatewayURL(input) {
+  const ip = String(input ?? "").trim();
+  if (ip.includes(":")) return { ok: false, error: "pass only the IP address: habithive --gateway <ip>" };
+  const p = ip.split(".");
+  if (p.length !== 4 || !p.every((x) => /^(0|[1-9]\d{0,2})$/.test(x) && +x <= 255)) return { ok: false, error: `not a valid IPv4 address: ${input}` };
+  return { ok: true, url: `${GATEWAY_SCHEME}://${ip}:${GATEWAY_PORT}/v1` };
+}
+
+// Write the gateway URL into every mode set's OmniRoute block (adding the block if missing). Returns changed paths.
+export function setGateway(url) {
+  return { files: omnirouteTargets().filter((t) => safeEdit(t, (c) => {
+    const out = ensureOmniroute(c);
+    out.provider[OMNIROUTE_ID].options.baseURL = url;
+    return out;
+  }).changed) };
+}

package/src/openspec.js

@@ -0,0 +1,87 @@
+// habithive-code — ships the intent-driven OpenSpec schema into OpenSpec's user-level data dir.
+// openspecDataDir mirrors OpenSpec 1.5.0 getGlobalDataDir() exactly.
+
+import { homedir as osHomedir } from "node:os";
+import { posix, win32, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, renameSync, rmSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { STORE_DIR } from "./core.js";
+
+export const SCHEMA_NAME = "intent-driven";
+export const SHIPPED_SCHEMA_DIR = fileURLToPath(new URL("../openspec-schemas/intent-driven", import.meta.url));
+// sha256 of the schema tree Hive last installed (tells our copy from the user's edits)
+const INSTALLED_HASH = join(STORE_DIR, "schema-installed.sha256");
+
+export function openspecDataDir({ env = process.env, platform = process.platform, homedir = osHomedir() } = {}) {
+  const j = platform === "win32" ? win32.join : posix.join;
+  if (env.XDG_DATA_HOME) return j(env.XDG_DATA_HOME, "openspec");
+  if (platform === "win32") {
+    if (env.LOCALAPPDATA) return j(env.LOCALAPPDATA, "openspec");
+    return j(homedir, "AppData", "Local", "openspec");
+  }
+  return j(homedir, ".local", "share", "openspec");
+}
+
+export function userSchemaDir(opts) {
+  const o = opts || {};
+  const j = (o.platform || process.platform) === "win32" ? win32.join : posix.join;
+  return j(openspecDataDir(o), "schemas", SCHEMA_NAME);
+}
+
+function files(dir, rel = "") {
+  const out = [];
+  for (const n of readdirSync(join(dir, rel)).sort()) {
+    const r = rel ? `${rel}/${n}` : n;
+    if (statSync(join(dir, r)).isDirectory()) out.push(...files(dir, r));
+    else out.push(r);
+  }
+  return out;
+}
+
+export function treeHash(dir) {
+  if (!existsSync(dir)) return null;
+  const h = createHash("sha256");
+  for (const r of files(dir)) {
+    h.update(r + "\0");
+    h.update(readFileSync(join(dir, r)));
+    h.update("\0");
+  }
+  return h.digest("hex");
+}
+
+export function copyTree(src, dst) {
+  mkdirSync(dst, { recursive: true });
+  for (const n of readdirSync(src)) {
+    const s = join(src, n), d = join(dst, n);
+    if (statSync(s).isDirectory()) copyTree(s, d);
+    else copyFileSync(s, d);
+  }
+}
+
+const stamp = (d) => d.toISOString().replace(/\.\d+Z$/, "").replace(/[-:]/g, "").replace("T", "-");
+
+export function installSchema({ now = new Date(), env, platform, homedir } = {}) {
+  const path = userSchemaDir({ env, platform, homedir });
+  const want = treeHash(SHIPPED_SCHEMA_DIR);
+  if (!want) throw new Error(`shipped schema missing: ${SHIPPED_SCHEMA_DIR}`);
+  const have = treeHash(path);
+  if (have === want) return { changed: false, path };
+  const tmp = `${path}.tmp-${process.pid}`;
+  rmSync(tmp, { recursive: true, force: true });
+  copyTree(SHIPPED_SCHEMA_DIR, tmp);
+  let backup;
+  if (have !== null) {
+    const last = existsSync(INSTALLED_HASH) ? readFileSync(INSTALLED_HASH, "utf8").trim() : null;
+    if (have !== last) { // kept outside OpenSpec's schemas/ dir, which lists every folder there as a schema
+      backup = join(STORE_DIR, "schema-backups", `${SCHEMA_NAME}-${stamp(now)}`);
+      mkdirSync(join(STORE_DIR, "schema-backups"), { recursive: true });
+      renameSync(path, backup);
+    }
+    else rmSync(path, { recursive: true, force: true });
+  }
+  renameSync(tmp, path);
+  mkdirSync(STORE_DIR, { recursive: true });
+  writeFileSync(INSTALLED_HASH, want + "\n");
+  return backup ? { changed: true, path, backup } : { changed: true, path };
+}

package/src/plugin.js

@@ -3,18 +3,35 @@
 // dialogs are nested calls. Everything is wrapped so it can never throw at init.
 //
 // Commands:
-//   /habithive        umbrella menu (set model / switch mode / reset)
-//   /model        nested model tree: level (main / all / group / agent / category) -> model
+//   /habithive        umbrella menu (model tree / switch mode / reset)
+//   /hive-models      nested model tree (alias hivemodels): "This screen (live)" opens opencode's
+//                     own picker; everything / group / agent / tier rows write oh-my-openagent.json
+//                     and relaunch. A main-agent change also reorders model.json `recent` and leaves
+//                     a pending-apply marker; the next load fires model.cycle_recent once to move the
+//                     on-screen agent (opencode restores the session's last model over any config).
 //   /habithive-mode   switch complex <-> simple: queues a marker + quits (app.exit);
-//                 the `habithive` launcher relaunches in the queued mode, same session.
+//                     the `habithive` launcher relaunches in the queued mode, same session.
 
 import {
   loadStore, saveStore, applyStore, loadBaseline, ensureBaseline,
   setModelOverride, clearModelOverride, effectiveModel, writeNextMode,
-  setMainModel, currentMainModel, isMainAgent,
-  KNOWN_CATEGORIES, MAIN_AGENTS, SUB_AGENTS,
+  writePendingApply, readPendingApply, clearPendingApply, arrangeRecent, revertedAgents,
+  isMainAgent, KNOWN_CATEGORIES, MAIN_AGENTS, SUB_AGENTS, ALL_AGENTS,
 } from "./core.js";
 import { registerLogo } from "./logo.js";
+import { OPENCODE_PIN, compareVersions } from "./versions.js";
+import { readCache, isDue, checkLatest, updateAvailable } from "./update.js";
+
+const MAIN_KEYS = MAIN_AGENTS.map((a) => a.key);
+const SUB_KEYS = SUB_AGENTS.map((a) => a.key);
+const WHY = { sisyphus: "Sisyphus can't run this GPT model", hephaestus: "Hephaestus is GPT-only" };
+let shown = false; // at most one "update available" toast per process
+let SNAP = null; // overrides store as of plugin load = what this process runs; rows that differ are "pending relaunch"
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const bad = (r) => r === false || r?.ok === false;
+// "Sisyphus (Ultraworker)" / "sisyphus" -> "sisyphus"
+const agentKey = (a) => (/[a-z][a-z-]*/.exec(String(a ?? "").toLowerCase())?.[0] ?? "").replace(/-+$/, "");
 
 function listModels(api) {
   const out = [];
@@ -33,45 +50,157 @@ function listModels(api) {
   return out;
 }
 
-function toast(api, message, variant = "info") {
-  try { api.ui.toast({ message, variant }); } catch {}
+function toast(api, message, variant = "info", duration) {
+  try { api.ui.toast({ message, variant, ...(duration ? { duration } : {}) }); } catch {}
 }
 
-// Queue a mode switch and quit; the launcher relaunches (same session, --continue).
-async function switchMode(api, mode) {
-  // Only target a REAL session (one with messages). A brand-new/empty session has
-  // no persisted id yet, so we leave it null and the launcher opens a fresh session.
-  let sessionID = null;
+// Run an opencode built-in command: api.keymap (newer builds) else the deprecated api.command.trigger.
+// Returns the call's result (true if undefined); false if neither exists or it throws.
+function dispatch(api, name) {
   try {
-    const cur = api?.route?.current;
-    if (cur && cur.name === "session" && cur.params && cur.params.sessionID) {
-      const id = cur.params.sessionID;
-      const msgs = api?.state?.session?.messages?.(id);
-      if (msgs && msgs.length > 0) sessionID = id;
-    }
-  } catch {}
+    const km = api?.keymap, trig = api?.command?.trigger;
+    const r = typeof km?.dispatchCommand === "function" ? km.dispatchCommand(name)
+      : typeof trig === "function" ? trig.call(api.command, name) : false;
+    if (typeof r?.then === "function") r.then(undefined, () => {});
+    return r === undefined ? true : r;
+  } catch { return false; }
+}
+
+// Resolves true once fn() is truthy; false on abort (plugin disposed) or after maxMs.
+function until(api, ms, fn, maxMs = Infinity) {
+  return new Promise((res) => {
+    const sig = api?.lifecycle?.signal;
+    if (sig?.aborted) return res(false);
+    const t0 = Date.now();
+    let h;
+    const done = (v) => { clearInterval(h); sig?.removeEventListener?.("abort", stop); res(v); };
+    const stop = () => done(false);
+    const tick = () => { try { if (fn()) return done(true); } catch {} if (Date.now() - t0 >= maxMs) done(false); };
+    sig?.addEventListener?.("abort", stop, { once: true });
+    h = setInterval(tick, ms);
+    tick();
+  });
+}
+
+// ---- session probes (all tolerate a missing/older API) --------------------
+
+function curSession(api) {
+  try { const c = api?.route?.current; return c && c.name === "session" && c.params?.sessionID ? c.params.sessionID : null; } catch { return null; }
+}
+function msgsOf(api, id) {
+  try { return api?.state?.session?.messages?.(id) || []; } catch { return []; }
+}
+// agent + "provider/model" of the session's last user message (what opencode restores on reopen)
+function lastUser(api, id) {
+  const m = msgsOf(api, id);
+  for (let i = m.length - 1; i >= 0; i--) {
+    const x = m[i];
+    if (x?.role !== "user") continue;
+    const mm = x.model;
+    return { agent: agentKey(x.agent), model: mm?.providerID && mm?.modelID ? `${mm.providerID}/${mm.modelID}` : null };
+  }
+  return null;
+}
+function openPrompts(api, id) {
+  try {
+    const s = api.state.session;
+    return (s.permission?.(id)?.length || 0) + (s.question?.(id)?.length || 0) > 0;
+  } catch { return false; }
+}
+
+// ---- relaunch ---------------------------------------------------------------
+
+// Queue a relaunch and quit; the launcher reopens (same session). Never quits without the launcher
+// or while a permission/question prompt is open (app.exit would reject it); warns if the quit is ignored.
+async function relaunch(api, mode = "complex", saved = true) {
+  if (process.env.HABITHIVE_LAUNCHER !== "1") {
+    toast(api, saved ? "saved — restart with `habithive -c` to apply" : `restart with \`habithive ${mode}\` to switch mode`, "warning");
+    return;
+  }
+  const id = curSession(api);
+  if (id && openPrompts(api, id)) {
+    toast(api, "waiting for the open prompt — the change applies once it's answered", "warning", 8000);
+    if (!(await until(api, 500, () => !openPrompts(api, id)))) return; // disposed while waiting
+  }
+  // Only target a REAL session (one with messages). A brand-new/empty session has no persisted id
+  // yet, so we leave it null and the launcher opens a fresh session.
+  const cur = curSession(api);
+  const sessionID = cur && msgsOf(api, cur).length > 0 ? cur : null;
   try { writeNextMode(mode, sessionID); }
   catch (e) { toast(api, `could not queue switch: ${String(e?.message || e)}`, "error"); return; }
   toast(api, `Switching to ${mode.toUpperCase()} — reopening this session…`, "info");
-  let exited = false;
-  for (const cmd of ["app.exit", "app.quit", "quit", "exit"]) {
-    try { await api.keymap.dispatchCommand(cmd); exited = true; break; } catch {}
+  dispatch(api, "app.exit");
+  const t = setTimeout(() => toast(api, "opencode did not quit — type /exit so habithive can reopen this session", "warning", 10000), 3000);
+  api?.lifecycle?.signal?.addEventListener?.("abort", () => clearTimeout(t), { once: true });
+}
+
+// ---- main-agent apply (design D2) -------------------------------------------
+
+// toast the agents oh-my-openagent will reroute for this model; true if it warned
+function warnReverted(api, id, keys) {
+  try {
+    const allow = loadBaseline()?.agents?.hephaestus?.allow_non_gpt_model === true;
+    const rev = revertedAgents(id, keys, { allowNonGptHephaestus: allow });
+    if (!rev?.length) return false;
+    toast(api, `${rev.map((k) => WHY[k] || k).join("; ")} — oh-my-openagent will reroute (keeps previous model)`, "warning", 7000);
+    return true;
+  } catch { return false; }
+}
+
+// If the on-screen agent is affected and runs another model Y, put [Y, X] first in `recent` and leave a
+// marker so the reopened session can cycle Y -> X (opencode restores Y on reopen, over any config).
+function queueApply(api, id, keys) {
+  try {
+    const sid = curSession(api);
+    if (!sid) return;
+    const lu = lastUser(api, sid);
+    if (!lu?.agent || !lu.model || !keys.includes(lu.agent) || lu.model === id) return;
+    const r = arrangeRecent(lu.model, id);
+    if (!r?.ok) { toast(api, `could not reorder recent models: ${r?.error || "unknown"}`, "warning"); return; }
+    writePendingApply({ sessionID: sid, agent: lu.agent, from: lu.model, to: id });
+  } catch (e) { toast(api, `could not queue apply: ${String(e?.message || e)}`, "warning"); }
+}
+
+// At load: wait for the session route + messages, then dispatch model.cycle_recent EXACTLY ONCE
+// (each dispatch moves one step); fall back to the native picker if it can't run.
+async function applyPending(api) {
+  const sig = api?.lifecycle?.signal;
+  let sid = null, mk = null, none = false;
+  const ready = await until(api, 300, () => {
+    if (!sid) {
+      const id = curSession(api);
+      if (!id) return false;
+      mk = readPendingApply(id);
+      sid = id;
+      if (!mk) return (none = true);
+    }
+    return msgsOf(api, sid).length > 0;
+  }, 20000);
+  if (none || !mk || sig?.aborted) return;
+  if (ready) {
+    await sleep(500);
+    if (sig?.aborted) return; // quitting: keep the marker for the next start
+    let r = dispatch(api, "model.cycle_recent");
+    try { r = await r; } catch { r = false; }
+    if (bad(r)) { dispatch(api, "model.list"); toast(api, `select ${mk.to} to apply it to ${mk.agent}`, "warning", 10000); }
+    else toast(api, `${mk.agent} → ${mk.to}`, "success");
   }
-  if (!exited) toast(api, `Quit opencode — it relaunches in ${mode} mode (habithive launcher).`, "warning");
+  clearPendingApply();
 }
 
 // ---- model tree ----------------------------------------------------------
 
 function openModelPicker(api, level, target) {
   const models = listModels(api);
-  const current = level === "main" ? currentMainModel()
-    : (level === "agent" || level === "category") ? effectiveModel(loadStore(), loadBaseline(), level, target)
-    : null;
-  const label = level === "main" ? "MAIN agent (this screen)"
-    : level === "all" ? "ALL (on-screen + subagents)"
+  const current = level === "agent" || level === "category" || level === "all"
+    ? effectiveModel(loadStore(), loadBaseline(), level, target) : null;
+  const label = level === "all" ? "Everything (agents + tiers)"
     : level === "main-group" ? "ALL main agents"
     : level === "sub-group" ? "ALL sub agents"
     : `${level}: ${target}`;
+  // agents whose on-screen model this pick can change (null: subagents / tiers never touch the screen)
+  const keys = level === "main-group" ? MAIN_KEYS : level === "all" ? ALL_AGENTS
+    : level === "agent" && isMainAgent(target) ? [target] : null;
 
   const options = [
     { title: "↺ Clear override (use default)", value: { clear: true }, category: "Actions" },
@@ -87,72 +216,70 @@ function openModelPicker(api, level, target) {
       placeholder: "filter models…",
       options, current,
       onSelect: async (opt) => {
-        const clear = !!opt.value.clear;
-        const id = opt.value.id;
+        try {
+          const clear = !!opt.value.clear;
+          const id = opt.value.id;
+          const warned = keys && !clear ? warnReverted(api, id, keys) : false;
 
-        if (level === "main") {
-          if (clear) { toast(api, "main agent: pick a model (nothing to clear)", "warning"); return; }
-          const r = setMainModel(id);
-          api.ui.dialog.clear();
-          if (!r.ok) { toast(api, `main set failed: ${r.error}`, "error"); return; }
-          toast(api, `${label} → ${id} · applying (reopening session)…`, "info");
-          await switchMode(api, "complex");
-          return;
-        }
-
-        const s = loadStore();
-        const setKeys = (keys) => keys.forEach((k) => clear ? clearModelOverride(s, "agent", k) : setModelOverride(s, "agent", k, id));
-        let touchesMainScreen = false;
-
-        if (level === "main-group") { setKeys(MAIN_AGENTS.map((a) => a.key)); touchesMainScreen = true; }
-        else if (level === "sub-group") { setKeys(SUB_AGENTS.map((a) => a.key)); }
-        else if (level === "all") { clear ? clearModelOverride(s, "all") : setModelOverride(s, "all", null, id); touchesMainScreen = true; }
-        else {
-          clear ? clearModelOverride(s, level, target) : setModelOverride(s, level, target, id);
-          if (level === "agent" && isMainAgent(target)) touchesMainScreen = true;
-        }
+          const s = loadStore();
+          const setKeys = (ks) => ks.forEach((k) => clear ? clearModelOverride(s, "agent", k) : setModelOverride(s, "agent", k, id));
+          if (level === "main-group") setKeys(MAIN_KEYS);
+          else if (level === "sub-group") setKeys(SUB_KEYS);
+          else if (level === "all") { // Everything: one model for every agent + tier, so drop the more specific overrides
+            if (clear) clearModelOverride(s, "all");
+            else s.modelOverrides = { all: id, categories: {}, agents: {} };
+          }
+          else clear ? clearModelOverride(s, level, target) : setModelOverride(s, level, target, id);
 
-        saveStore(s);
-        const r = applyStore(s);
-        if (!clear && touchesMainScreen) setMainModel(id);
-        api.ui.dialog.clear();
-        if (!r.ok) { toast(api, `apply failed: ${r.error}`, "error"); return; }
-        toast(api, `${label} → ${clear ? "default" : id} · applying (reopening session)…`, "info");
-        await switchMode(api, "complex");
+          saveStore(s);
+          const r = applyStore(s);
+          api.ui.dialog.clear();
+          if (!r.ok) { toast(api, `apply failed: ${r.error}`, "error"); return; }
+          if (keys && !clear) queueApply(api, id, keys);
+          if (warned) await sleep(3000); // let the reroute warning be read before the relaunch toast replaces it
+          await relaunch(api);
+        } catch (e) { toast(api, `model change failed: ${String(e?.message || e)}`, "error"); }
       },
     }),
   );
 }
 
 function openLevelPicker(api) {
-  ensureBaseline();
+  try { ensureBaseline(); } catch {}
   const store = loadStore();
   const baseline = loadBaseline();
-  const fmt = (lvl, tgt) => {
-    const m = lvl === "main" ? currentMainModel() : effectiveModel(store, baseline, lvl, tgt);
-    return m ? `→ ${m}` : "→ (default)";
-  };
-  const groupModel = (keys) => {
-    const uniq = [...new Set(keys.map((k) => effectiveModel(store, baseline, "agent", k)))];
-    return uniq.length === 1 ? (uniq[0] ? `→ all: ${uniq[0]}` : "→ (default)") : "→ (mixed)";
+  // Description = configured model; " · pending relaunch" when saved but not yet what this process runs.
+  const D = (fn) => { const now = fn(store); return now + (SNAP && fn(SNAP) !== now ? " · pending relaunch" : ""); };
+  const one = (lvl, tgt) => (s) => { const m = effectiveModel(s, baseline, lvl, tgt); return m ? `→ ${m}` : "→ (default)"; };
+  const group = (keys) => (s) => {
+    const u = [...new Set(keys.map((k) => effectiveModel(s, baseline, "agent", k)))];
+    return u.length === 1 ? (u[0] ? `→ all: ${u[0]}` : "→ (default)") : "→ (mixed)";
   };
   const options = [
-    { title: "Main agent — this screen", description: fmt("main"), value: { level: "main" }, category: "Quick" },
-    { title: "ALL — on-screen + every subagent + tier", description: fmt("all"), value: { level: "all" }, category: "Quick" },
+    { title: "This screen (live)", description: "opencode's model picker · instant, no relaunch", value: { live: true }, category: "Live" },
+
+    { title: "★ Everything (agents + tiers)", description: D(one("all")), value: { level: "all" }, category: "Everything" },
 
-    { title: "★ All main agents (set together)", description: groupModel(MAIN_AGENTS.map((a) => a.key)), value: { level: "main-group" }, category: "Main agents (primary)" },
-    ...MAIN_AGENTS.map((a) => ({ title: a.label, description: fmt("agent", a.key), value: { level: "agent", target: a.key }, category: "Main agents (primary)" })),
+    { title: "★ All main agents", description: D(group(MAIN_KEYS)), value: { level: "main-group" }, category: "Main agents (primary)" },
+    ...MAIN_AGENTS.map((a) => ({ title: a.label, description: D(one("agent", a.key)), value: { level: "agent", target: a.key }, category: "Main agents (primary)" })),
 
-    { title: "★ All sub agents (set together)", description: groupModel(SUB_AGENTS.map((a) => a.key)), value: { level: "sub-group" }, category: "Subagents" },
-    ...SUB_AGENTS.map((a) => ({ title: a.label, description: fmt("agent", a.key), value: { level: "agent", target: a.key }, category: "Subagents" })),
+    { title: "★ All sub agents", description: D(group(SUB_KEYS)), value: { level: "sub-group" }, category: "Subagents" },
+    ...SUB_AGENTS.map((a) => ({ title: a.label, description: D(one("agent", a.key)), value: { level: "agent", target: a.key }, category: "Subagents" })),
 
-    ...KNOWN_CATEGORIES.map((c) => ({ title: c, description: fmt("category", c), value: { level: "category", target: c }, category: "Categories (tiers)" })),
+    ...KNOWN_CATEGORIES.map((c) => ({ title: c, description: D(one("category", c)), value: { level: "category", target: c }, category: "Categories (tiers)" })),
   ];
   api.ui.dialog.replace(() =>
     api.ui.DialogSelect({
-      title: "habithive · set model — pick a level (most-specific wins)",
+      title: "habithive · model tree (most-specific wins)",
       placeholder: "filter…", options,
-      onSelect: (opt) => openModelPicker(api, opt.value.level, opt.value.target),
+      onSelect: (opt) => {
+        if (opt.value.live) {
+          api.ui.dialog.clear();
+          if (bad(dispatch(api, "model.list"))) toast(api, "model picker unavailable — type /models", "warning");
+          return;
+        }
+        openModelPicker(api, opt.value.level, opt.value.target);
+      },
     }),
   );
 }
@@ -165,7 +292,7 @@ function openModeMenu(api) {
         { title: "→ Simple mode (vanilla opencode, fast)", value: "simple", description: "quits & relaunches vanilla, same session" },
         { title: "→ Complex mode (relaunch to apply model changes)", value: "complex", description: "quits & relaunches full, same session" },
       ],
-      onSelect: (opt) => { api.ui.dialog.clear(); switchMode(api, opt.value); },
+      onSelect: (opt) => { api.ui.dialog.clear(); relaunch(api, opt.value, false); },
     }),
   );
 }
@@ -175,7 +302,7 @@ function openUmbrella(api) {
     api.ui.DialogSelect({
       title: "habithive-code",
       options: [
-        { title: "Set model (main / all / groups / agent / tier)", value: "model" },
+        { title: "Model tree (this screen / everything / groups / agent / tier)", value: "model" },
         { title: "Switch mode (simple / complex)", value: "mode" },
         { title: "Reset all model overrides", value: "reset" },
       ],
@@ -202,12 +329,21 @@ const HabithiveTui = async (api) => {
       try { api.ui.toast({ message: "habithive-code: command API unavailable", variant: "warning" }); } catch {}
       return;
     }
+    try { SNAP = loadStore(); } catch {}
     reg(() => [
       { title: "habithive-code", value: "habithive.menu", description: "model tree + mode switch", category: "habithive-code", slash: { name: "habithive", aliases: ["habithive-code"] }, onSelect: () => openUmbrella(api) },
-      { title: "habithive · set model", value: "habithive.model", description: "set model by level (main / all / groups / agent / tier)", category: "habithive-code", slash: { name: "model", aliases: ["habithivemodel"] }, onSelect: () => openLevelPicker(api) },
+      { title: "habithive · model tree", value: "habithive.models", description: "this screen (live) / everything / groups / agent / tier", category: "habithive-code", slash: { name: "hive-models", aliases: ["hivemodels"] }, onSelect: () => openLevelPicker(api) },
       { title: "habithive · switch mode", value: "habithive.mode", description: "complex <-> simple (relaunch, same session)", category: "habithive-code", slash: { name: "habithive-mode", aliases: ["habithivemode"] }, onSelect: () => openModeMenu(api) },
     ]);
     registerLogo(api); // v2 — HABITHIVE wordmark in home_logo (self-guarded, test-constructed)
+    const v = api.app?.version; // started without the launcher? still say when opencode is not the tested version
+    if (typeof v === "string" && v && compareVersions(v, OPENCODE_PIN) !== 0) toast(api, `opencode ${v} is not the tested ${OPENCODE_PIN} — run habithive update`, "warning");
+    // daily update check: toast from the cache now, refresh it in the background (never awaited, silent on failure)
+    const msg = (v) => `habithive v${v} available — quit and run habithive update`;
+    const cache = readCache();
+    if (updateAvailable(cache)) { shown = true; toast(api, msg(cache.latest), "info"); }
+    if (isDue(cache)) checkLatest().then((l) => { if (l && !shown && updateAvailable({ latest: l })) { shown = true; toast(api, msg(l), "info"); } }).catch(() => {});
+    applyPending(api).catch(() => {}); // non-blocking: finish a main-agent change after the relaunch
   } catch (e) {
     try { api.ui.toast({ message: `habithive-code init failed: ${String(e?.message || e)}`, variant: "error" }); } catch {}
   }