@metaphi-ai/hum 0.1.26 → 0.1.30

package/dist/cli.mjs

@@ -1257,26 +1257,26 @@ var require_react_development = __commonJS({
           }
           return lazyType;
         }
-        function forwardRef3(render2) {
+        function forwardRef3(render3) {
           {
-            if (render2 != null && render2.$$typeof === REACT_MEMO_TYPE) {
+            if (render3 != null && render3.$$typeof === REACT_MEMO_TYPE) {
               error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).");
-            } else if (typeof render2 !== "function") {
-              error("forwardRef requires a render function but was given %s.", render2 === null ? "null" : typeof render2);
+            } else if (typeof render3 !== "function") {
+              error("forwardRef requires a render function but was given %s.", render3 === null ? "null" : typeof render3);
             } else {
-              if (render2.length !== 0 && render2.length !== 2) {
-                error("forwardRef render functions accept exactly two parameters: props and ref. %s", render2.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+              if (render3.length !== 0 && render3.length !== 2) {
+                error("forwardRef render functions accept exactly two parameters: props and ref. %s", render3.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
               }
             }
-            if (render2 != null) {
-              if (render2.defaultProps != null || render2.propTypes != null) {
+            if (render3 != null) {
+              if (render3.defaultProps != null || render3.propTypes != null) {
                 error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
               }
             }
           }
           var elementType = {
             $$typeof: REACT_FORWARD_REF_TYPE,
-            render: render2
+            render: render3
           };
           {
             var ownName;
@@ -1288,8 +1288,8 @@ var require_react_development = __commonJS({
               },
               set: function(name) {
                 ownName = name;
-                if (!render2.name && !render2.displayName) {
-                  render2.displayName = name;
+                if (!render3.name && !render3.displayName) {
+                  render3.displayName = name;
                 }
               }
             });
@@ -2249,7 +2249,7 @@ var require_signal_exit = __commonJS({
     } else {
       assert = __require("assert");
       signals = require_signals();
-      isWin = /^win/i.test(process13.platform);
+      isWin2 = /^win/i.test(process13.platform);
       EE = __require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
@@ -2321,7 +2321,7 @@ var require_signal_exit = __commonJS({
             unload();
             emit("exit", null, sig);
             emit("afterexit", null, sig);
-            if (isWin && sig === "SIGHUP") {
+            if (isWin2 && sig === "SIGHUP") {
               sig = "SIGINT";
             }
             process13.kill(process13.pid, sig);
@@ -2378,7 +2378,7 @@ var require_signal_exit = __commonJS({
     }
     var assert;
     var signals;
-    var isWin;
+    var isWin2;
     var EE;
     var emitter;
     var unload;
@@ -13104,7 +13104,7 @@ var require_react_reconciler_development = __commonJS({
         }
         function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
           fiber.flags |= StoreConsistency;
-          var check = {
+          var check2 = {
             getSnapshot,
             value: renderedSnapshot
           };
@@ -13112,13 +13112,13 @@ var require_react_reconciler_development = __commonJS({
           if (componentUpdateQueue === null) {
             componentUpdateQueue = createFunctionComponentUpdateQueue();
             currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-            componentUpdateQueue.stores = [check];
+            componentUpdateQueue.stores = [check2];
           } else {
             var stores = componentUpdateQueue.stores;
             if (stores === null) {
-              componentUpdateQueue.stores = [check];
+              componentUpdateQueue.stores = [check2];
             } else {
-              stores.push(check);
+              stores.push(check2);
             }
           }
         }
@@ -15465,7 +15465,7 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           }
-          var render2 = Component.render;
+          var render3 = Component.render;
           var ref = workInProgress2.ref;
           var nextChildren;
           var hasId;
@@ -15476,12 +15476,12 @@ var require_react_reconciler_development = __commonJS({
           {
             ReactCurrentOwner$1.current = workInProgress2;
             setIsRendering(true);
-            nextChildren = renderWithHooks(current2, workInProgress2, render2, nextProps, ref, renderLanes2);
+            nextChildren = renderWithHooks(current2, workInProgress2, render3, nextProps, ref, renderLanes2);
             hasId = checkDidRenderIdHook();
             if (workInProgress2.mode & StrictLegacyMode) {
               setIsStrictModeForDevtools(true);
               try {
-                nextChildren = renderWithHooks(current2, workInProgress2, render2, nextProps, ref, renderLanes2);
+                nextChildren = renderWithHooks(current2, workInProgress2, render3, nextProps, ref, renderLanes2);
                 hasId = checkDidRenderIdHook();
               } finally {
                 setIsStrictModeForDevtools(false);
@@ -16661,7 +16661,7 @@ var require_react_reconciler_development = __commonJS({
             }
           }
         }
-        function initSuspenseListRenderState(workInProgress2, isBackwards, tail2, lastContentRow, tailMode) {
+        function initSuspenseListRenderState(workInProgress2, isBackwards, tail3, lastContentRow, tailMode) {
           var renderState = workInProgress2.memoizedState;
           if (renderState === null) {
             workInProgress2.memoizedState = {
@@ -16669,7 +16669,7 @@ var require_react_reconciler_development = __commonJS({
               rendering: null,
               renderingStartTime: 0,
               last: lastContentRow,
-              tail: tail2,
+              tail: tail3,
               tailMode
             };
           } else {
@@ -16677,7 +16677,7 @@ var require_react_reconciler_development = __commonJS({
             renderState.rendering = null;
             renderState.renderingStartTime = 0;
             renderState.last = lastContentRow;
-            renderState.tail = tail2;
+            renderState.tail = tail3;
             renderState.tailMode = tailMode;
           }
         }
@@ -16709,19 +16709,19 @@ var require_react_reconciler_development = __commonJS({
             switch (revealOrder) {
               case "forwards": {
                 var lastContentRow = findLastContentRow(workInProgress2.child);
-                var tail2;
+                var tail3;
                 if (lastContentRow === null) {
-                  tail2 = workInProgress2.child;
+                  tail3 = workInProgress2.child;
                   workInProgress2.child = null;
                 } else {
-                  tail2 = lastContentRow.sibling;
+                  tail3 = lastContentRow.sibling;
                   lastContentRow.sibling = null;
                 }
                 initSuspenseListRenderState(
                   workInProgress2,
                   false,
                   // isBackwards
-                  tail2,
+                  tail3,
                   lastContentRow,
                   tailMode
                 );
@@ -16835,9 +16835,9 @@ var require_react_reconciler_development = __commonJS({
             }
           }
           var newProps = workInProgress2.pendingProps;
-          var render2 = newProps.children;
+          var render3 = newProps.children;
           {
-            if (typeof render2 !== "function") {
+            if (typeof render3 !== "function") {
               error("A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it.");
             }
           }
@@ -16850,7 +16850,7 @@ var require_react_reconciler_development = __commonJS({
           {
             ReactCurrentOwner$1.current = workInProgress2;
             setIsRendering(true);
-            newChildren = render2(newValue);
+            newChildren = render3(newValue);
             setIsRendering(false);
           }
           {
@@ -20619,9 +20619,9 @@ var require_react_reconciler_development = __commonJS({
                 var checks = updateQueue.stores;
                 if (checks !== null) {
                   for (var i = 0; i < checks.length; i++) {
-                    var check = checks[i];
-                    var getSnapshot = check.getSnapshot;
-                    var renderedValue = check.value;
+                    var check2 = checks[i];
+                    var getSnapshot = check2.getSnapshot;
+                    var renderedValue = check2.value;
                     try {
                       if (!objectIs(getSnapshot(), renderedValue)) {
                         return false;
@@ -22744,10 +22744,10 @@ var require_react_reconciler_development = __commonJS({
         var setErrorHandler = null;
         var setSuspenseHandler = null;
         {
-          var copyWithDeleteImpl = function(obj, path4, index2) {
-            var key = path4[index2];
+          var copyWithDeleteImpl = function(obj, path6, index2) {
+            var key = path6[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            if (index2 + 1 === path4.length) {
+            if (index2 + 1 === path6.length) {
               if (isArray(updated)) {
                 updated.splice(key, 1);
               } else {
@@ -22755,11 +22755,11 @@ var require_react_reconciler_development = __commonJS({
               }
               return updated;
             }
-            updated[key] = copyWithDeleteImpl(obj[key], path4, index2 + 1);
+            updated[key] = copyWithDeleteImpl(obj[key], path6, index2 + 1);
             return updated;
           };
-          var copyWithDelete = function(obj, path4) {
-            return copyWithDeleteImpl(obj, path4, 0);
+          var copyWithDelete = function(obj, path6) {
+            return copyWithDeleteImpl(obj, path6, 0);
           };
           var copyWithRenameImpl = function(obj, oldPath, newPath, index2) {
             var oldKey = oldPath[index2];
@@ -22797,17 +22797,17 @@ var require_react_reconciler_development = __commonJS({
             }
             return copyWithRenameImpl(obj, oldPath, newPath, 0);
           };
-          var copyWithSetImpl = function(obj, path4, index2, value) {
-            if (index2 >= path4.length) {
+          var copyWithSetImpl = function(obj, path6, index2, value) {
+            if (index2 >= path6.length) {
               return value;
             }
-            var key = path4[index2];
+            var key = path6[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            updated[key] = copyWithSetImpl(obj[key], path4, index2 + 1, value);
+            updated[key] = copyWithSetImpl(obj[key], path6, index2 + 1, value);
             return updated;
           };
-          var copyWithSet = function(obj, path4, value) {
-            return copyWithSetImpl(obj, path4, 0, value);
+          var copyWithSet = function(obj, path6, value) {
+            return copyWithSetImpl(obj, path6, 0, value);
           };
           var findHook = function(fiber, id) {
             var currentHook2 = fiber.memoizedState;
@@ -22817,10 +22817,10 @@ var require_react_reconciler_development = __commonJS({
             }
             return currentHook2;
           };
-          overrideHookState = function(fiber, id, path4, value) {
+          overrideHookState = function(fiber, id, path6, value) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithSet(hook.memoizedState, path4, value);
+              var newState = copyWithSet(hook.memoizedState, path6, value);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -22830,10 +22830,10 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideHookStateDeletePath = function(fiber, id, path4) {
+          overrideHookStateDeletePath = function(fiber, id, path6) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithDelete(hook.memoizedState, path4);
+              var newState = copyWithDelete(hook.memoizedState, path6);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -22856,8 +22856,8 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideProps = function(fiber, path4, value) {
-            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path4, value);
+          overrideProps = function(fiber, path6, value) {
+            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path6, value);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -22866,8 +22866,8 @@ var require_react_reconciler_development = __commonJS({
               scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
             }
           };
-          overridePropsDeletePath = function(fiber, path4) {
-            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path4);
+          overridePropsDeletePath = function(fiber, path6) {
+            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path6);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -29446,7 +29446,7 @@ var require_has_flag = __commonJS({
 var require_supports_colors = __commonJS({
   "node_modules/@colors/colors/lib/system/supports-colors.js"(exports, module) {
     "use strict";
-    var os6 = __require("os");
+    var os8 = __require("os");
     var hasFlag2 = require_has_flag();
     var env3 = process.env;
     var forceColor = void 0;
@@ -29484,7 +29484,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os6.release().split(".");
+        var osRelease = os8.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -31587,7 +31587,7 @@ var require_core = __commonJS({
       function close(node) {
         result += "</" + tag2(node) + ">";
       }
-      function render2(event) {
+      function render3(event) {
         (event.event === "start" ? open : close)(event.node);
       }
       while (original.length || highlighted.length) {
@@ -31597,7 +31597,7 @@ var require_core = __commonJS({
         if (stream === original) {
           nodeStack.reverse().forEach(close);
           do {
-            render2(stream.splice(0, 1)[0]);
+            render3(stream.splice(0, 1)[0]);
             stream = selectStream();
           } while (stream === original && stream.length && stream[0].offset === processed);
           nodeStack.reverse().forEach(open);
@@ -31607,7 +31607,7 @@ var require_core = __commonJS({
           } else {
             nodeStack.pop();
           }
-          render2(stream.splice(0, 1)[0]);
+          render3(stream.splice(0, 1)[0]);
         }
       }
       return result + escapeHTML(value.substr(processed));
@@ -73569,15 +73569,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path4 = [graph[toModel].parent, toModel];
+      const path6 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path4.unshift(graph[cur].parent);
+        path6.unshift(graph[cur].parent);
         fn = link3(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path4;
+      fn.conversion = path6;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -73817,7 +73817,7 @@ var require_has_flag2 = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os6 = __require("os");
+    var os8 = __require("os");
     var tty2 = __require("tty");
     var hasFlag2 = require_has_flag2();
     var { env: env3 } = process;
@@ -73865,7 +73865,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os8.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -74575,6 +74575,246 @@ var require_dist = __commonJS({
   }
 });
 
+// src/install.js
+import { spawnSync } from "node:child_process";
+import fs2 from "node:fs";
+import os3 from "node:os";
+import path from "node:path";
+function importedVersion(env3 = process.env, runImpl = run) {
+  const r = runImpl(enginePython(env3), ASK_VERSION);
+  return r && r.status === 0 ? String(r.stdout).trim() : null;
+}
+function installedVersion(env3 = process.env, runImpl = run) {
+  try {
+    return fs2.readFileSync(stampPath(env3), "utf8").trim() || null;
+  } catch {
+  }
+  if (!fs2.existsSync(enginePython(env3))) return null;
+  const v = importedVersion(env3, runImpl);
+  if (v) {
+    try {
+      fs2.writeFileSync(stampPath(env3), `${v}
+`);
+    } catch {
+    }
+  }
+  return v;
+}
+function needsInstall(version, { env: env3 = process.env, installed = () => installedVersion(env3), now = Date.now(), state = readInstallState(env3) } = {}) {
+  if (!version || env3.HUM_ENGINE || env3.HUM_ENGINE_PORT) return false;
+  if (installed() === version) return false;
+  if (state && !state.ok && state.version === version && now - (state.at || 0) < 10 * 60 * 1e3) return false;
+  return true;
+}
+function installEngine(version, { env: env3 = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
+  const home = humHome(env3);
+  const dir = engineDir(env3);
+  const python = enginePython(env3);
+  const localBin = path.join(os3.homedir(), ".local", "bin");
+  const uvNames = ["uv", path.join(localBin, win ? "uv.exe" : "uv")];
+  const uv = () => uvNames.find((u) => {
+    const r = runImpl(u, ["--version"]);
+    return r && r.status === 0;
+  });
+  const spec = env3.HUM_ENGINE_SPEC || `hum-cli==${version}`;
+  const outcome = (ok, error = null, got = version) => {
+    writeInstallState({ version: got, wanted: version, ok, error, at: now }, env3);
+    return { ok, version: got, error };
+  };
+  try {
+    let u = uv();
+    if (!u) {
+      say("installing uv (it creates the Python environment for the part of hum that does the work) \u2026");
+      const r = win ? runImpl("powershell", ["-ExecutionPolicy", "ByPass", "-c", "irm https://astral.sh/uv/install.ps1 | iex"], { stdio: "inherit" }) : runImpl("sh", ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"], { stdio: "inherit" });
+      u = r && r.status === 0 ? uv() : null;
+      if (!u) return outcome(false, `could not install uv; install it from https://astral.sh/uv and run:  ${npmFix(version)}`);
+    }
+    say(`installing ${env3.HUM_ENGINE_SPEC ? spec : `hum ${version}`} into ${dir} \u2026`);
+    fs2.mkdirSync(home, { recursive: true });
+    try {
+      fs2.unlinkSync(stampPath(env3));
+    } catch {
+    }
+    if (!fs2.existsSync(python)) {
+      const args2 = ["venv", "--quiet", "--python", "3.12", ...fs2.existsSync(dir) ? ["--clear"] : [], dir];
+      if ((runImpl(u, args2, { stdio: "inherit" }) || {}).status !== 0) return outcome(false, "uv venv failed");
+    }
+    if ((runImpl(u, ["pip", "install", "--quiet", "--python", python, spec], { stdio: "inherit" }) || {}).status !== 0) return outcome(false, `uv pip install ${spec} failed`);
+    const got = importedVersion(env3, runImpl);
+    if (!got) return outcome(false, "hum did not import after the install");
+    if (got !== version && !env3.HUM_ENGINE_SPEC) return outcome(false, `installed ${got}, wanted ${version}`, got);
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(stampPath(env3), `${got}
+`);
+    const list2 = runImpl(u, ["tool", "list"]);
+    if (list2 && list2.status === 0 && /^hum-cli\b/m.test(list2.stdout)) {
+      const rm = runImpl(u, ["tool", "uninstall", "hum-cli"]);
+      if (rm && rm.status === 0) say(`removed the uv install of hum-cli and its shims in ${localBin}; hum lives in ${dir} now`);
+    }
+    say(`hum ${got} ready`);
+    return outcome(true, null, got);
+  } catch (e) {
+    return outcome(false, e && e.message ? e.message : String(e));
+  }
+}
+var win, npmFix, NPM_FIX, humHome, engineDir, enginePython, stampPath, statePath, run, ASK_VERSION, readInstallState, writeInstallState;
+var init_install = __esm({
+  "src/install.js"() {
+    win = process.platform === "win32";
+    npmFix = (version = "") => `npm i -g @metaphi-ai/hum@${version || "latest"} --foreground-scripts`;
+    NPM_FIX = npmFix("latest");
+    humHome = (env3 = process.env) => env3.HUM_HOME || path.join(os3.homedir(), ".hum");
+    engineDir = (env3 = process.env) => path.join(humHome(env3), "engine");
+    enginePython = (env3 = process.env) => win ? path.join(engineDir(env3), "Scripts", "python.exe") : path.join(engineDir(env3), "bin", "python");
+    stampPath = (env3) => path.join(engineDir(env3), "version");
+    statePath = (env3) => path.join(humHome(env3), "engine-install.json");
+    run = (cmd, args2, opts = {}) => spawnSync(cmd, args2, { encoding: "utf8", windowsHide: true, ...opts });
+    ASK_VERSION = ["-I", "-c", "import hum; print(hum.__version__)"];
+    readInstallState = (env3 = process.env) => {
+      try {
+        return JSON.parse(fs2.readFileSync(statePath(env3), "utf8"));
+      } catch {
+        return null;
+      }
+    };
+    writeInstallState = (s, env3) => {
+      try {
+        fs2.mkdirSync(humHome(env3), { recursive: true });
+        fs2.writeFileSync(statePath(env3), JSON.stringify(s));
+      } catch {
+      }
+    };
+  }
+});
+
+// src/update.js
+import fs3 from "node:fs";
+import os4 from "node:os";
+import path2 from "node:path";
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+async function latestVersion(fetchImpl = globalThis.fetch, env3 = process.env) {
+  if (env3.HUM_NO_UPDATE_CHECK || typeof fetchImpl !== "function") return "";
+  try {
+    const r = await fetchImpl(`${dist(env3)}/releases/latest`, { signal: AbortSignal.timeout(2500) });
+    if (!r.ok) return "";
+    const v = (await r.text()).trim();
+    return /^\d+\.\d+\.\d+$/.test(v) ? v : "";
+  } catch {
+    return "";
+  }
+}
+function installLayout(execPath = process.execPath, env3 = process.env) {
+  const exe = String(execPath).split(/[\\/]/).pop();
+  if (/^(node|bun)(\.exe)?$/i.test(exe)) return { kind: env3.HUM_ENGINE_PORT ? "python" : "npm" };
+  let real = execPath;
+  try {
+    real = fs3.realpathSync(execPath);
+  } catch {
+  }
+  return { kind: "native", exe, dir: path2.dirname(real), base: path2.dirname(path2.dirname(real)) };
+}
+function installerArgv(version, platform2 = process.platform) {
+  const base = dist();
+  if (platform2 === "win32") return ["powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", `irm ${base}/install.ps1 | iex`]];
+  return ["/bin/sh", ["-c", `curl -fsSL "${base}/install.sh" | sh`]];
+}
+function startBackgroundUpdate(version, { env: env3 = process.env, now = Date.now(), spawnImpl = spawn } = {}) {
+  if (env3.HUM_NO_AUTO_UPDATE) return false;
+  const s = readState(env3);
+  if (s.version === version && now - (s.started || 0) < 30 * 60 * 1e3) return false;
+  const log = path2.join(humHome2(env3), "update.log");
+  let out = "ignore";
+  try {
+    fs3.mkdirSync(humHome2(env3), { recursive: true });
+    out = fs3.openSync(log, "w");
+  } catch {
+  }
+  const [bin, args2] = installerArgv(version);
+  try {
+    const child = spawnImpl(bin, args2, {
+      detached: true,
+      stdio: ["ignore", out, out],
+      windowsHide: true,
+      env: { ...env3, HUM_VERSION: version, HUM_DIST: dist(env3) }
+    });
+    child.unref();
+    writeState({ version, started: now }, env3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mismatchLine(mine, running, { env: env3 = process.env, layout: layout2 = installLayout(process.execPath, env3), state = readInstallState(env3) } = {}) {
+  if (!mine || !running || mine === running) return "";
+  const head = `hum ${mine} is installed but ${running} is what runs`;
+  if (env3.HUM_ENGINE) return `${head}: HUM_ENGINE points at it \xB7 unset HUM_ENGINE to use ${mine}`;
+  const fix = layout2.kind === "npm" ? npmFix(mine) : updateCommand(layout2);
+  if (state && !state.ok && state.wanted === mine && state.error) return `${head}: the update did not finish (${state.error}) \xB7 ${fix}`;
+  return `${head} \xB7 ${fix}`;
+}
+async function updateNotice(mine, { running = "", env: env3 = process.env, fetchImpl = globalThis.fetch, layout: layout2 = installLayout(process.execPath, env3), spawnImpl = spawn } = {}) {
+  const drift = mismatchLine(mine, running, { env: env3, layout: layout2 });
+  if (drift) return drift;
+  const latest = await latestVersion(fetchImpl, env3);
+  if (!latest || !newer(latest, mine)) return "";
+  if (layout2.kind !== "native") return `hum ${latest} is out (this is ${mine}) \xB7 ${updateCommand(layout2)}`;
+  if (readyVersion(layout2, latest)) return `hum ${latest} is ready \xB7 restart hum to use it`;
+  if (startBackgroundUpdate(latest, { env: env3, spawnImpl })) return `hum ${latest} is downloading in the background \xB7 it takes effect the next time you start hum`;
+  const s = readState(env3);
+  if (s.version === latest && !env3.HUM_NO_AUTO_UPDATE) return `hum ${latest} is still installing in the background (${path2.join(humHome2(env3), "update.log")} has the details)`;
+  return `hum ${latest} is out (this is ${mine}) \xB7 ${updateCommand(layout2)}`;
+}
+function updateNow(layout2 = installLayout()) {
+  if (layout2.kind === "native") {
+    const [bin, args2] = installerArgv();
+    return spawnSync2(bin, args2, { stdio: "inherit", env: { ...process.env, HUM_DIST: dist() } }).status ?? 1;
+  }
+  if (layout2.kind === "python") {
+    process.stdout.write(`update with your package manager:  ${updateCommand(layout2)}
+`);
+    return 0;
+  }
+  const r = spawnSync2(win2() ? "npm.cmd" : "npm", ["i", "-g", "@metaphi-ai/hum@latest"], { stdio: "inherit", shell: win2() });
+  return r.status ?? 1;
+}
+var dist, humHome2, win2, newer, updateCommand, readyVersion, stateFile, readState, writeState;
+var init_update = __esm({
+  "src/update.js"() {
+    init_install();
+    dist = (env3 = process.env) => (env3.HUM_DIST || "https://metaphi.ai/hum").replace(/\/+$/, "");
+    humHome2 = (env3 = process.env) => env3.HUM_HOME || path2.join(os4.homedir(), ".hum");
+    win2 = () => process.platform === "win32";
+    newer = (a, b) => {
+      const pa = String(a).split(".").map(Number), pb = String(b).split(".").map(Number);
+      for (let i = 0; i < 3; i += 1) {
+        if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
+      }
+      return false;
+    };
+    updateCommand = (layout2 = installLayout(), platform2 = process.platform) => {
+      if (layout2.kind === "native") return platform2 === "win32" ? `irm ${dist()}/install.ps1 | iex` : `curl -fsSL ${dist()}/install.sh | sh`;
+      if (layout2.kind === "python") return "uv tool upgrade hum-cli   (or: pip install -U hum-cli)";
+      return "npm i -g @metaphi-ai/hum@latest";
+    };
+    readyVersion = (layout2, version) => layout2.kind === "native" && version && fs3.existsSync(path2.join(layout2.base, version, layout2.exe)) ? version : "";
+    stateFile = (env3 = process.env) => path2.join(humHome2(env3), "update.json");
+    readState = (env3 = process.env) => {
+      try {
+        return JSON.parse(fs3.readFileSync(stateFile(env3), "utf8"));
+      } catch {
+        return {};
+      }
+    };
+    writeState = (s, env3 = process.env) => {
+      try {
+        fs3.mkdirSync(humHome2(env3), { recursive: true });
+        fs3.writeFileSync(stateFile(env3), JSON.stringify(s));
+      } catch {
+      }
+    };
+  }
+});
+
 // node_modules/react/cjs/react-jsx-runtime.production.min.js
 var require_react_jsx_runtime_production_min = __commonJS({
   "node_modules/react/cjs/react-jsx-runtime.production.min.js"(exports) {
@@ -75505,6 +75745,571 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
+// src/engine.js
+import fs5 from "node:fs";
+import net from "node:net";
+import os6 from "node:os";
+import path4 from "node:path";
+import crypto from "node:crypto";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
+function uvToolDirs() {
+  const dirs = [];
+  if (process.env.UV_TOOL_DIR) dirs.push(process.env.UV_TOOL_DIR);
+  if (win3) {
+    for (const base of [process.env.APPDATA, process.env.LOCALAPPDATA]) if (base) dirs.push(path4.join(base, "uv", "tools"));
+  } else dirs.push(path4.join(process.env.XDG_DATA_HOME || path4.join(os6.homedir(), ".local", "share"), "uv", "tools"));
+  if (!dirs.some(exists)) {
+    for (const uv of ["uv", path4.join(os6.homedir(), ".local", "bin", win3 ? "uv.exe" : "uv")]) {
+      try {
+        const r = spawnSync3(uv, ["tool", "dir"], { encoding: "utf8", windowsHide: true });
+        if (r.status === 0 && r.stdout.trim()) {
+          dirs.push(r.stdout.trim());
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  return dirs;
+}
+function enginePython2(dirs = uvToolDirs()) {
+  for (const dir of dirs) for (const name of ["hum-cli", "hum"]) {
+    const py = win3 ? path4.join(dir, name, "Scripts", "python.exe") : path4.join(dir, name, "bin", "python");
+    if (exists(py)) return py;
+  }
+  return null;
+}
+function siblingEngine(execPath = process.execPath) {
+  let dir;
+  try {
+    dir = path4.dirname(fs5.realpathSync(execPath));
+  } catch {
+    return null;
+  }
+  const p = path4.join(dir, "engine", win3 ? "hum-engine.exe" : "hum-engine");
+  return exists(p) ? p : null;
+}
+function homeEngine(env3 = process.env) {
+  const home = env3.HUM_HOME || path4.join(os6.homedir(), ".hum");
+  const py = win3 ? path4.join(home, "engine", "Scripts", "python.exe") : path4.join(home, "engine", "bin", "python");
+  return exists(py) ? py : null;
+}
+function engineCandidates(env3 = process.env) {
+  const out = [];
+  if (env3.HUM_ENGINE) {
+    const [bin, ...args2] = env3.HUM_ENGINE.split(" ");
+    out.push({ bin, args: args2, where: "HUM_ENGINE" });
+  }
+  const sib = siblingEngine();
+  if (sib) out.push({ bin: sib, args: ["engine"], where: "beside hum" });
+  const home = homeEngine(env3);
+  if (home) out.push({ bin: home, args: ["-m", "hum.cli", "engine"], where: "HUM_HOME/engine" });
+  const py = enginePython2();
+  if (py) out.push({ bin: py, args: ["-m", "hum.cli", "engine"], where: "the interpreter beside it" });
+  out.push({ bin: "hum-engine", args: [], where: "PATH" });
+  out.push({ bin: path4.join(os6.homedir(), ".local", "bin", win3 ? "hum-engine.exe" : "hum-engine"), args: [], where: "uv's bin dir" });
+  return out;
+}
+function engineCommand(argv, candidates = engineCandidates()) {
+  for (const c of candidates) {
+    if (c.args[c.args.length - 1] !== "engine") continue;
+    return { bin: c.bin, args: [...c.args.slice(0, -1), ...argv], where: c.where };
+  }
+  return null;
+}
+function candidateVersion(c, { env: env3 = process.env, runImpl = spawnSync3 } = {}) {
+  if (!c || !c.bin) return null;
+  if (c.where === "HUM_HOME/engine") return installedVersion(env3);
+  const interp = c.args.length >= 3 && c.args[c.args.length - 3] === "-m" && c.args[c.args.length - 2] === "hum.cli";
+  let r;
+  try {
+    r = runImpl(c.bin, interp ? ASK_VERSION : ["--version"], { encoding: "utf8", windowsHide: true, timeout: 2e4 });
+  } catch {
+    return null;
+  }
+  if (!r || r.status !== 0) return null;
+  const m = String(r.stdout || "").match(/(\d+\.\d+\.\d+)/);
+  return m ? m[1] : null;
+}
+function runningVersion(candidates = engineCandidates(), opts = {}) {
+  for (const c of candidates) {
+    const v = candidateVersion(c, opts);
+    if (v) return { version: v, where: c.where };
+  }
+  return null;
+}
+function startFailure(failures, { npm = /^(node|bun)(\.exe)?$/i.test(String(process.execPath).split(/[\\/]/).pop()), platform: platform2 = process.platform, version = true ? "0.1.30" : "" } = {}) {
+  const refused = failures.find((f) => f.error && f.error.code !== "ENOENT");
+  const fix = npm ? npmFix(version) : updateCommand({ kind: "native" }, platform2);
+  if (!refused) {
+    return `Hum is not fully installed here \u2014 the half that does the work is missing. Run:  ${fix}   (or set HUM_ENGINE to the command that runs it)`;
+  }
+  const what = refused.error.code || refused.error.message;
+  const lines = [
+    `Hum is installed (${refused.bin}) but this machine would not run it: ${what}.`
+  ];
+  if (win3) {
+    lines.push("On a managed Windows machine that is usually Device Guard / WDAC refusing an executable it does not know.");
+    lines.push(`To see the policy's own message, run:  "${refused.bin}" --help`);
+    const dir = uvToolDirs()[0];
+    lines.push(`If uv's environment is elsewhere, point Hum at its interpreter:  set HUM_ENGINE=${path4.join(dir || "<uv tool dir>", "hum-cli", "Scripts", "python.exe")} -m hum.cli engine`);
+  } else {
+    lines.push('Set HUM_ENGINE to a command that starts it, e.g.  HUM_ENGINE="python -m hum.cli engine"');
+  }
+  return lines.join("\n");
+}
+function attempt({ bin, args: args2 }, cwd2, { task, images, resume }) {
+  return new Promise((resolve, reject) => {
+    const runId = crypto.randomBytes(6).toString("hex");
+    fs5.mkdirSync(runDir(), { recursive: true });
+    const logPath = path4.join(runDir(), `${runId}.log`);
+    const log = fs5.openSync(logPath, "a");
+    const argv = [...args2, "-C", cwd2, "--run-id", runId];
+    if (task) argv.push("--task", task);
+    for (const p of images) argv.push("--image", p);
+    if (resume) argv.push("--resume", resume);
+    let settled = false;
+    const settle = (fn) => {
+      if (!settled) {
+        settled = true;
+        fn();
+      }
+    };
+    let child;
+    try {
+      child = spawn2(bin, argv, { stdio: ["ignore", log, log], detached: true, windowsHide: true });
+    } catch (e) {
+      fs5.closeSync(log);
+      reject({ spawn: e });
+      return;
+    }
+    fs5.closeSync(log);
+    let died = false;
+    child.on("error", (e) => settle(() => reject({ spawn: e })));
+    child.on("exit", () => {
+      died = true;
+    });
+    const t0 = Date.now();
+    const poll = () => {
+      if (settled) return;
+      const rec = readRun(runId);
+      if (rec && rec.port) {
+        child.unref();
+        settle(() => resolve(rec));
+        return;
+      }
+      if (rec && rec.error) {
+        settle(() => reject({ failed: rec.error }));
+        return;
+      }
+      if (died && !rec) {
+        settle(() => reject({ died: logPath }));
+        return;
+      }
+      if (Date.now() - t0 > 9e4) {
+        settle(() => reject({ timeout: true }));
+        return;
+      }
+      setTimeout(poll, 50);
+    };
+    poll();
+  });
+}
+function failureMessage(error) {
+  return error.message + (error.hint ? `
+  ${error.hint}` : "");
+}
+function diedMessage(logPath, text = null) {
+  let tail3 = "";
+  try {
+    tail3 = (text ?? fs5.readFileSync(logPath, "utf8")).trim().split("\n").slice(-3).join("\n").trim();
+  } catch {
+  }
+  return `the session did not start${tail3 ? `:
+${tail3}` : ""}
+(its log: ${logPath})`;
+}
+async function spawnEngine(cwd2, { task = null, images = [], resume = null, candidates = engineCandidates() } = {}) {
+  const failures = [];
+  for (const cand of candidates) {
+    if (!cand.bin) continue;
+    try {
+      return await attempt(cand, cwd2, { task, images, resume });
+    } catch (f) {
+      if (f && f.spawn) {
+        failures.push({ ...cand, error: f.spawn });
+        continue;
+      }
+      if (f && f.failed) throw new EngineError(failureMessage(f.failed));
+      if (f && f.died) throw new EngineError(diedMessage(f.died));
+      if (f && f.timeout) throw new EngineError("the session did not start in time");
+      throw f;
+    }
+  }
+  throw new EngineError(startFailure(failures));
+}
+var runDir, readRun, EngineError, win3, exists, Engine;
+var init_engine = __esm({
+  "src/engine.js"() {
+    init_install();
+    init_update();
+    runDir = () => path4.join(process.env.HUM_HOME || path4.join(os6.homedir(), ".hum"), "run");
+    readRun = (id) => {
+      try {
+        return JSON.parse(fs5.readFileSync(path4.join(runDir(), `${id}.json`), "utf8"));
+      } catch {
+        return null;
+      }
+    };
+    EngineError = class extends Error {
+    };
+    win3 = process.platform === "win32";
+    exists = (p) => {
+      try {
+        fs5.accessSync(p);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    Engine = class {
+      constructor(port2) {
+        this.port = port2;
+        this.handlers = [];
+        this.closed = false;
+      }
+      connect() {
+        return new Promise((resolve, reject) => {
+          const sock = net.createConnection({ host: "127.0.0.1", port: this.port }, () => resolve());
+          this.sock = sock;
+          sock.on("error", (e) => {
+            if (!this.closed && this.sock === sock) reject(new EngineError(`could not reach the session: ${e.message}`));
+          });
+          let buf = "";
+          sock.on("data", (d) => {
+            if (this.sock !== sock) return;
+            buf += d.toString();
+            const lines = buf.split("\n");
+            buf = lines.pop();
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              let ev;
+              try {
+                ev = JSON.parse(line);
+              } catch {
+                continue;
+              }
+              for (const h of this.handlers) h(ev);
+            }
+          });
+          sock.on("close", () => {
+            if (this.sock !== sock) return;
+            this.closed = true;
+            for (const h of this.handlers) h({ type: "bye", gone: true });
+          });
+        });
+      }
+      // Attach to another engine (a session running elsewhere on this machine): the old
+      // socket is dropped quietly, the new one greets us with hello and a replay.
+      async reconnect(port2) {
+        const old = this.sock;
+        this.sock = null;
+        this.port = port2;
+        this.closed = false;
+        try {
+          old.destroy();
+        } catch {
+        }
+        await this.connect();
+      }
+      on(handler) {
+        this.handlers.push(handler);
+      }
+      send(cmd) {
+        if (this.closed) return;
+        try {
+          this.sock.write(JSON.stringify(cmd) + "\n");
+        } catch {
+        }
+      }
+      close() {
+        this.closed = true;
+        try {
+          this.sock.end();
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/doctor.js
+var doctor_exports = {};
+__export(doctor_exports, {
+  diagnose: () => diagnose,
+  doctor: () => doctor,
+  onPath: () => onPath,
+  render: () => render2
+});
+import fs6 from "node:fs";
+import os7 from "node:os";
+import path5 from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+function jsonError(text, e) {
+  const msg = e.message || "";
+  const lc = /\(line (\d+) column \d+\)/.exec(msg);
+  if (lc) return `line ${lc[1]}: ${msg.replace(/ in JSON.*$/, "")}`;
+  const m = /position (\d+)/.exec(msg);
+  if (!m) return msg;
+  const line = text.slice(0, Number(m[1])).split("\n").length;
+  return `line ${line}: ${msg.replace(/ in JSON.*$/, "")}`;
+}
+function onPath(env3, { platform: platform2 = process.platform } = {}) {
+  const names = isWin(platform2) ? ["hum.cmd", "hum.exe", "hum", "hum-engine.exe", "hum-engine.cmd"] : ["hum", "hum-engine"];
+  const seen = /* @__PURE__ */ new Set();
+  const hits = [];
+  for (const dir of String(env3.PATH || env3.Path || "").split(path5.delimiter).filter(Boolean)) {
+    for (const n of names) {
+      const p = path5.join(dir, n);
+      if (!exists2(p) || seen.has(p)) continue;
+      seen.add(p);
+      hits.push({ path: p, name: n, real: realpath(p) });
+    }
+  }
+  return hits;
+}
+async function diagnose({
+  env: env3 = process.env,
+  mine = "0.0.0",
+  platform: platform2 = process.platform,
+  execPath = process.execPath,
+  homedir = os7.homedir(),
+  cwd: cwd2 = process.cwd(),
+  layout: layout2 = installLayout(execPath, env3),
+  candidates = engineCandidates(env3),
+  runImpl = spawnSync4,
+  fetchImpl = globalThis.fetch
+} = {}) {
+  const home = env3.HUM_HOME || path5.join(homedir, ".hum");
+  const sections = [];
+  {
+    const checks = [];
+    const from = layout2.kind === "native" ? path5.join(layout2.dir, layout2.exe) : realpath(execPath);
+    const how = { native: "the native install", npm: "npm", python: "Python (uv or pip)" }[layout2.kind] || layout2.kind;
+    checks.push(check("ok", `hum ${mine} \xB7 installed with ${how} \xB7 runs from ${from}`));
+    if (layout2.kind === "native") {
+      const launcher = isWin(platform2) ? path5.join(env3.LOCALAPPDATA || path5.join(homedir, "AppData", "Local"), "hum", "bin", "hum.cmd") : path5.join(homedir, ".local", "bin", "hum");
+      if (!exists2(launcher)) checks.push(check("warn", `no launcher at ${launcher}`, updateCommand(layout2, platform2)));
+      else {
+        const target = isWin(platform2) ? (fs6.readFileSync(launcher, "utf8").match(new RegExp('"([^"]+)"')) || [])[1] || "" : realpath(launcher);
+        const insideVersions = target && realpath(target).startsWith(realpath(layout2.base));
+        checks.push(insideVersions ? check("ok", `launcher ${launcher} \u2192 ${target}`) : check("warn", `launcher ${launcher} is not the installer's (it points at ${target || "?"})`, updateCommand(layout2, platform2)));
+      }
+    }
+    const hits = onPath(env3, { platform: platform2 });
+    const hums = hits.filter((h) => !h.name.startsWith("hum-engine"));
+    const stale = hits.filter((h) => h.name.startsWith("hum-engine"));
+    const targets = new Set(hums.map((h) => h.real));
+    if (hums.length === 0) checks.push(check("warn", "no hum on PATH: a new terminal may not find it", layout2.kind === "native" ? isWin(platform2) ? "open a new terminal" : 'export PATH="$HOME/.local/bin:$PATH"' : "npm bin -g, and put that directory on PATH"));
+    else if (targets.size > 1) checks.push(check("warn", `more than one hum on PATH; the first wins: ${hums.map((h) => h.path).join(" \xB7 ")}`, "remove the ones you did not mean to keep"));
+    else checks.push(check("ok", `hum on PATH: ${hums[0].path}`));
+    for (const s of stale) checks.push(check("warn", `an older install left ${s.path} on PATH`, "uv tool uninstall hum-cli"));
+    sections.push({ key: "install", title: "Install", checks });
+  }
+  let running = null;
+  {
+    const checks = [];
+    if (env3.HUM_ENGINE_PORT) checks.push(check("ok", `started by Python for this hum (HUM_ENGINE_PORT=${env3.HUM_ENGINE_PORT})`));
+    for (const c of candidates) {
+      const v = candidateVersion(c, { env: env3, runImpl });
+      if (v) {
+        running = { ...c, version: v };
+        break;
+      }
+    }
+    if (!running) checks.push(check("fail", "nothing answers: the part of hum that does the work is missing", layout2.kind === "npm" ? npmFix2(mine) : updateCommand(layout2, platform2)));
+    else if (running.version === mine) checks.push(check("ok", `${running.version} runs from ${running.where} (${running.bin})`));
+    else if (env3.HUM_ENGINE) checks.push(check("fail", `${running.version} is what runs: HUM_ENGINE points at it (${env3.HUM_ENGINE}); you installed ${mine}`, "unset HUM_ENGINE"));
+    else checks.push(check("fail", `${running.version} is what runs (${running.where}: ${running.bin}); you installed ${mine}`, layout2.kind === "npm" ? npmFix2(mine) : updateCommand(layout2, platform2)));
+    if (env3.HUM_ENGINE && running && running.version === mine) checks.push(check("warn", `HUM_ENGINE is set (${env3.HUM_ENGINE}): it decides what runs, ahead of any install`, "unset HUM_ENGINE"));
+    if (layout2.kind === "npm") {
+      const st = readInstallState(env3);
+      const stamp = installedVersion(env3, runImpl);
+      if (st && !st.ok) checks.push(check(stamp === mine ? "warn" : "fail", `the last install attempt (wanted ${st.wanted || st.version}) did not finish: ${st.error}`, npmFix2(mine)));
+      else if (!stamp) checks.push(check("fail", `nothing installed under ${engineDir(env3)}`, npmFix2(mine)));
+      else checks.push(check(stamp === mine ? "ok" : "warn", `${engineDir(env3)} holds ${stamp}`, stamp === mine ? "" : npmFix2(mine)));
+    }
+    if (layout2.kind === "native") {
+      const sib = path5.join(layout2.dir, "engine", isWin(platform2) ? "hum-engine.exe" : "hum-engine");
+      checks.push(exists2(sib) ? check("ok", `the working half is beside hum: ${sib}`) : check("fail", `nothing beside hum at ${sib}: the install is incomplete`, updateCommand(layout2, platform2)));
+    }
+    sections.push({ key: "runtime", title: "The part of hum that does the work", checks });
+  }
+  {
+    const checks = [];
+    const st = readState(env3);
+    if (st && st.version) {
+      const ready = readyVersion(layout2, st.version);
+      checks.push(check("ok", `last background update: ${st.version}, started ${st.started ? new Date(st.started).toISOString() : "?"}${ready ? " \xB7 ready, takes effect on restart" : ""}`));
+      const last = tail2(path5.join(home, "update.log"));
+      if (last) checks.push(check("ok", `update.log: ${last}`));
+    } else checks.push(check("ok", "no background update recorded"));
+    if (env3.HUM_NO_UPDATE_CHECK) checks.push(check("warn", "HUM_NO_UPDATE_CHECK is set: hum does not look for releases", "unset HUM_NO_UPDATE_CHECK"));
+    if (env3.HUM_NO_AUTO_UPDATE) checks.push(check("warn", "HUM_NO_AUTO_UPDATE is set: hum tells you about releases but does not fetch them", "unset HUM_NO_AUTO_UPDATE"));
+    const latest = env3.HUM_NO_UPDATE_CHECK ? "" : await latestVersion(fetchImpl, env3);
+    if (!latest && !env3.HUM_NO_UPDATE_CHECK) checks.push(check("warn", `could not reach ${dist(env3)} (offline, or a proxy in the way)`, "try again with a connection"));
+    else if (latest && newer(latest, mine)) checks.push(check("warn", `${latest} is out \xB7 this is ${mine}`, updateCommand(layout2, platform2)));
+    else if (latest) checks.push(check("ok", `${mine} is the latest release`));
+    sections.push({ key: "updates", title: "Updates", checks });
+  }
+  const interp = running && running.args.length >= 3 && running.args[running.args.length - 2] === "hum.cli" ? running.bin : exists2(enginePython(env3)) ? enginePython(env3) : null;
+  let toolServers = null;
+  {
+    const checks = [];
+    try {
+      fs6.accessSync(home, fs6.constants.W_OK);
+      checks.push(check("ok", `HUM_HOME ${home} is writable`));
+    } catch {
+      checks.push(exists2(home) ? check("fail", `${home} is not writable`, `chmod u+w ${home}`) : check("warn", `${home} does not exist yet: it is made on first run`));
+    }
+    const configPath = env3.HUM_CONFIG || path5.join(home, "config.toml");
+    if (!exists2(configPath)) checks.push(check("ok", `no ${configPath}: defaults`));
+    else if (!interp) checks.push(check("warn", `${configPath} not checked: nothing here can parse TOML`, layout2.kind === "npm" ? npmFix2(mine) : updateCommand(layout2, platform2)));
+    else {
+      const r = runImpl(interp, ["-I", "-c", PARSE_CONFIG, configPath], { encoding: "utf8", windowsHide: true, timeout: 2e4 });
+      let parsed = null;
+      try {
+        parsed = JSON.parse(String(r && r.stdout || ""));
+      } catch {
+      }
+      if (!parsed) checks.push(check("warn", `${configPath} not checked: ${interp} did not answer`));
+      else if (parsed.error) checks.push(check("fail", `${configPath}: ${parsed.error}`, `fix ${configPath}`));
+      else {
+        checks.push(check("ok", `${configPath} parses`));
+        toolServers = parsed.mcp;
+      }
+    }
+    for (const f of [path5.join(home, "hooks.json"), path5.join(cwd2, ".hum", "hooks.json"), path5.join(home, "autonomy.json"), path5.join(home, "update.json"), path5.join(home, "engine-install.json")]) {
+      if (!exists2(f)) continue;
+      const text = fs6.readFileSync(f, "utf8");
+      try {
+        JSON.parse(text);
+        checks.push(check("ok", `${f} parses`));
+      } catch (e) {
+        checks.push(check("fail", `${f}: ${jsonError(text, e)}`, `fix ${f}`));
+      }
+    }
+    const credPath = path5.join(home, "credentials.json");
+    let cred = null;
+    if (exists2(credPath)) {
+      const text = fs6.readFileSync(credPath, "utf8");
+      try {
+        cred = JSON.parse(text);
+      } catch (e) {
+        checks.push(check("fail", `${credPath}: ${jsonError(text, e)}`, "hum login"));
+      }
+    }
+    if (cred && cred.access_token) checks.push(check("ok", `signed in${cred.email ? ` as ${cred.email}` : ""}`));
+    else if (!cred) checks.push(check("warn", "not signed in", "hum login"));
+    checks.push(sandboxCheck(platform2, env3));
+    sections.push({ key: "configuration", title: "Configuration", checks });
+  }
+  {
+    const checks = [];
+    const local = Array.isArray(toolServers) ? toolServers : null;
+    if (local) for (const s of local) checks.push(check("ok", `${s.name} \xB7 ${s.transport}${s.at ? ` \xB7 ${s.at}` : ""} \xB7 from config.toml`));
+    else if (toolServers === null && exists2(env3.HUM_CONFIG || path5.join(home, "config.toml"))) checks.push(check("warn", "config.toml servers not listed (it did not parse, or nothing here can read it)"));
+    let cred = null;
+    try {
+      cred = JSON.parse(fs6.readFileSync(path5.join(home, "credentials.json"), "utf8"));
+    } catch {
+    }
+    for (const s of cred && Array.isArray(cred.mcp) ? cred.mcp : []) if (s && s.name) checks.push(check("ok", `${s.name} \xB7 http \xB7 via the server`));
+    if (checks.length === 0) checks.push(check("ok", "none configured"));
+    sections.push({ key: "tool_servers", title: "Tool servers", checks });
+  }
+  const summary = { ok: 0, warn: 0, fail: 0 };
+  for (const s of sections) for (const c of s.checks) summary[c.status] += 1;
+  return { hum: mine, platform: platform2, layout: layout2.kind, sections, summary };
+}
+function sandboxCheck(platform2, env3) {
+  if (isWin(platform2)) return check("ok", "no sandbox on Windows: commands run as you, in your account");
+  if (platform2 === "darwin") return exists2("/usr/bin/sandbox-exec") ? check("ok", "sandbox: macOS Seatbelt (/usr/bin/sandbox-exec)") : check("warn", "/usr/bin/sandbox-exec is missing: commands run unsandboxed");
+  const dirs = String(env3.PATH || "").split(path5.delimiter);
+  const bwrap = dirs.map((d) => path5.join(d, "bwrap")).find(exists2);
+  if (!bwrap) return check("warn", "bubblewrap is not installed: commands run unsandboxed", "sudo apt install bubblewrap");
+  const restricted = (() => {
+    try {
+      return fs6.readFileSync("/proc/sys/kernel/apparmor_restrict_unprivileged_userns", "utf8").trim() === "1";
+    } catch {
+      return false;
+    }
+  })();
+  if (restricted) return check("warn", "bubblewrap is installed but unprivileged user namespaces are restricted", "sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0");
+  return check("ok", `sandbox: bubblewrap (${bwrap})`);
+}
+function render2(report) {
+  const out = [];
+  for (const s of report.sections) {
+    out.push(s.title);
+    for (const c of s.checks) out.push(`  ${MARK[c.status]}  ${c.text}${c.fix ? `
+          \u2192 ${c.fix}` : ""}`);
+    out.push("");
+  }
+  out.push(`${report.summary.ok} ok \xB7 ${report.summary.warn} warn \xB7 ${report.summary.fail} fail`);
+  return out.join("\n") + "\n";
+}
+async function doctor({ json = false, mine, write = (t) => process.stdout.write(t), ...opts } = {}) {
+  const report = await diagnose({ mine, ...opts });
+  write(json ? JSON.stringify(report, null, 2) + "\n" : render2(report));
+  return report.summary.fail ? 1 : 0;
+}
+var isWin, npmFix2, exists2, realpath, tail2, check, PARSE_CONFIG, MARK;
+var init_doctor = __esm({
+  "src/doctor.js"() {
+    init_engine();
+    init_install();
+    init_update();
+    isWin = (platform2) => platform2 === "win32";
+    npmFix2 = (version) => `npm i -g @metaphi-ai/hum@${version || "latest"} --foreground-scripts`;
+    exists2 = (p) => {
+      try {
+        fs6.accessSync(p);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    realpath = (p) => {
+      try {
+        return fs6.realpathSync(p);
+      } catch {
+        return p;
+      }
+    };
+    tail2 = (p) => {
+      try {
+        const lines = fs6.readFileSync(p, "utf8").trim().split("\n");
+        return lines[lines.length - 1] || "";
+      } catch {
+        return "";
+      }
+    };
+    check = (status, text, fix = "") => ({ status, text, ...fix ? { fix } : {} });
+    PARSE_CONFIG = [
+      "import json, sys, tomllib",
+      "p = sys.argv[1]",
+      "try:",
+      '    d = tomllib.loads(open(p, "rb").read().decode("utf-8"))',
+      "except Exception as e:",
+      '    print(json.dumps({"error": str(e)})); sys.exit(0)',
+      'mcp = [{"name": s.get("name", "?"), "transport": "http" if s.get("url") else "stdio", "at": s.get("url") or s.get("command") or ""} for s in d.get("mcp", [])]',
+      'print(json.dumps({"mcp": mcp}))'
+    ].join("\n");
+    MARK = { ok: "ok  ", warn: "warn", fail: "FAIL" };
+  }
+});
+
 // src/cli.jsx
 var import_react25 = __toESM(require_react(), 1);
 
@@ -80199,7 +81004,7 @@ var create = (stream, { showCursor = false } = {}) => {
   let previousLineCount = 0;
   let previousOutput = "";
   let hasHiddenCursor = false;
-  const render2 = (str) => {
+  const render3 = (str) => {
     if (!showCursor && !hasHiddenCursor) {
       cli_cursor_default.hide();
       hasHiddenCursor = true;
@@ -80212,12 +81017,12 @@ var create = (stream, { showCursor = false } = {}) => {
     stream.write(base_exports.eraseLines(previousLineCount) + output);
     previousLineCount = output.split("\n").length;
   };
-  render2.clear = () => {
+  render3.clear = () => {
     stream.write(base_exports.eraseLines(previousLineCount));
     previousOutput = "";
     previousLineCount = 0;
   };
-  render2.done = () => {
+  render3.done = () => {
     previousOutput = "";
     previousLineCount = 0;
     if (!showCursor) {
@@ -80225,7 +81030,7 @@ var create = (stream, { showCursor = false } = {}) => {
       hasHiddenCursor = false;
     }
   };
-  return render2;
+  return render3;
 };
 var logUpdate = { create };
 var log_update_default = logUpdate;
@@ -80406,8 +81211,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
-var cleanupPath = (path4) => {
-  return path4?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path6) => {
+  return path6?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -81042,7 +81847,7 @@ var getInstance = (stdout, createInstance) => {
 // node_modules/ink/build/components/Static.js
 var import_react11 = __toESM(require_react(), 1);
 function Static(props) {
-  const { items, children: render2, style: customStyle } = props;
+  const { items, children: render3, style: customStyle } = props;
   const [index, setIndex] = (0, import_react11.useState)(0);
   const itemsToRender = (0, import_react11.useMemo)(() => {
     return items.slice(index);
@@ -81051,7 +81856,7 @@ function Static(props) {
     setIndex(items.length);
   }, [items.length]);
   const children = itemsToRender.map((item, itemIndex) => {
-    return render2(item, index + itemIndex);
+    return render3(item, index + itemIndex);
   });
   const style = (0, import_react11.useMemo)(() => ({
     position: "absolute",
@@ -81353,9 +82158,9 @@ var import_react21 = __toESM(require_react(), 1);
 
 // src/app.jsx
 var import_react24 = __toESM(require_react(), 1);
-import fs3 from "node:fs";
-import os4 from "node:os";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import os5 from "node:os";
+import path3 from "node:path";
 
 // node_modules/ink-spinner/build/index.js
 var import_react22 = __toESM(require_react(), 1);
@@ -83584,124 +84389,16 @@ var MASCOT = [
 var MASCOT_WIDTH = 10;
 
 // src/banner.js
-function bannerLines(ev, homeRel2 = (p) => p) {
+function bannerLines(ev, homeRel2 = (p) => p, mine = "") {
   const state = ev.state && ev.state !== "new" && ev.state !== "idle" ? ` \xB7 ${ev.state}` : "";
+  const drift = mine && ev.version && mine !== ev.version ? ` \xB7 you installed ${mine}` : "";
   const where = `${homeRel2(ev.cwd || "")}${ev.workspace ? ` \xB7 ${ev.workspace}` : ""}`;
   const agents = ev.agents_model ? ` \xB7 agents on ${ev.agents_model}` : "";
-  return [`hum ${ev.version || ""}`.trim() + state, `${ev.model || ""}${agents}${ev.user ? ` \xB7 ${ev.user}` : ""}`, where];
+  return [`hum ${ev.version || ""}`.trim() + drift + state, `${ev.model || ""}${agents}${ev.user ? ` \xB7 ${ev.user}` : ""}`, where];
 }
 
-// src/update.js
-import fs2 from "node:fs";
-import os3 from "node:os";
-import path from "node:path";
-import { spawn, spawnSync } from "node:child_process";
-var dist = (env3 = process.env) => (env3.HUM_DIST || "https://storage.googleapis.com/hum-dist").replace(/\/+$/, "");
-var humHome = (env3 = process.env) => env3.HUM_HOME || path.join(os3.homedir(), ".hum");
-var win = () => process.platform === "win32";
-async function latestVersion(fetchImpl = globalThis.fetch, env3 = process.env) {
-  if (env3.HUM_NO_UPDATE_CHECK || typeof fetchImpl !== "function") return "";
-  try {
-    const r = await fetchImpl(`${dist(env3)}/releases/latest`, { signal: AbortSignal.timeout(2500) });
-    if (!r.ok) return "";
-    const v = (await r.text()).trim();
-    return /^\d+\.\d+\.\d+$/.test(v) ? v : "";
-  } catch {
-    return "";
-  }
-}
-var newer = (a, b) => {
-  const pa = String(a).split(".").map(Number), pb = String(b).split(".").map(Number);
-  for (let i = 0; i < 3; i += 1) {
-    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
-  }
-  return false;
-};
-function installLayout(execPath = process.execPath, env3 = process.env) {
-  const exe = String(execPath).split(/[\\/]/).pop();
-  if (/^(node|bun)(\.exe)?$/i.test(exe)) return { kind: env3.HUM_ENGINE_PORT ? "python" : "npm" };
-  let real = execPath;
-  try {
-    real = fs2.realpathSync(execPath);
-  } catch {
-  }
-  return { kind: "native", exe, dir: path.dirname(real), base: path.dirname(path.dirname(real)) };
-}
-var updateCommand = (layout = installLayout(), platform2 = process.platform) => {
-  if (layout.kind === "native") return platform2 === "win32" ? `irm ${dist()}/install.ps1 | iex` : `curl -fsSL ${dist()}/install.sh | sh`;
-  if (layout.kind === "python") return "uv tool upgrade hum-cli   (or: pip install -U hum-cli)";
-  return "npm i -g @metaphi-ai/hum@latest";
-};
-var readyVersion = (layout, version) => layout.kind === "native" && version && fs2.existsSync(path.join(layout.base, version, layout.exe)) ? version : "";
-var stateFile = (env3 = process.env) => path.join(humHome(env3), "update.json");
-var readState = (env3 = process.env) => {
-  try {
-    return JSON.parse(fs2.readFileSync(stateFile(env3), "utf8"));
-  } catch {
-    return {};
-  }
-};
-var writeState = (s, env3 = process.env) => {
-  try {
-    fs2.mkdirSync(humHome(env3), { recursive: true });
-    fs2.writeFileSync(stateFile(env3), JSON.stringify(s));
-  } catch {
-  }
-};
-function installerArgv(version, platform2 = process.platform) {
-  const base = dist();
-  if (platform2 === "win32") return ["powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", `irm ${base}/install.ps1 | iex`]];
-  return ["/bin/sh", ["-c", `curl -fsSL "${base}/install.sh" | sh`]];
-}
-function startBackgroundUpdate(version, { env: env3 = process.env, now = Date.now(), spawnImpl = spawn } = {}) {
-  if (env3.HUM_NO_AUTO_UPDATE) return false;
-  const s = readState(env3);
-  if (s.version === version && now - (s.started || 0) < 30 * 60 * 1e3) return false;
-  const log = path.join(humHome(env3), "update.log");
-  let out = "ignore";
-  try {
-    fs2.mkdirSync(humHome(env3), { recursive: true });
-    out = fs2.openSync(log, "w");
-  } catch {
-  }
-  const [bin, args2] = installerArgv(version);
-  try {
-    const child = spawnImpl(bin, args2, {
-      detached: true,
-      stdio: ["ignore", out, out],
-      windowsHide: true,
-      env: { ...env3, HUM_VERSION: version, HUM_DIST: dist(env3) }
-    });
-    child.unref();
-    writeState({ version, started: now }, env3);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function updateNotice(mine, { env: env3 = process.env, fetchImpl = globalThis.fetch, layout = installLayout(process.execPath, env3), spawnImpl = spawn } = {}) {
-  const latest = await latestVersion(fetchImpl, env3);
-  if (!latest || !newer(latest, mine)) return "";
-  if (layout.kind !== "native") return `hum ${latest} is out (this is ${mine}) \xB7 ${updateCommand(layout)}`;
-  if (readyVersion(layout, latest)) return `hum ${latest} is ready \xB7 restart hum to use it`;
-  if (startBackgroundUpdate(latest, { env: env3, spawnImpl })) return `hum ${latest} is downloading in the background \xB7 it takes effect the next time you start hum`;
-  const s = readState(env3);
-  if (s.version === latest && !env3.HUM_NO_AUTO_UPDATE) return `hum ${latest} is still installing in the background (${path.join(humHome(env3), "update.log")} has the details)`;
-  return `hum ${latest} is out (this is ${mine}) \xB7 ${updateCommand(layout)}`;
-}
-function updateNow(layout = installLayout()) {
-  if (layout.kind === "native") {
-    const [bin, args2] = installerArgv();
-    return spawnSync(bin, args2, { stdio: "inherit", env: { ...process.env, HUM_DIST: dist() } }).status ?? 1;
-  }
-  if (layout.kind === "python") {
-    process.stdout.write(`update with your package manager:  ${updateCommand(layout)}
-`);
-    return 0;
-  }
-  const r = spawnSync(win() ? "npm.cmd" : "npm", ["i", "-g", "@metaphi-ai/hum@latest"], { stdio: "inherit", shell: win() });
-  return r.status ?? 1;
-}
+// src/app.jsx
+init_update();
 
 // src/input.jsx
 var import_react23 = __toESM(require_react(), 1);
@@ -83844,6 +84541,7 @@ var input_default = MultilineInput;
 
 // src/app.jsx
 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+var MINE = true ? "0.1.30" : "";
 var fmtDur = (s) => s < 60 ? `${Math.max(1, Math.round(s))}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`;
 var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
 var firstResp = (e) => e.first_response_s ? ` \xB7 first response ${e.first_response_s.toFixed(1)}s` : "";
@@ -83851,7 +84549,7 @@ var shortSession = (name) => (name || "").replace(/\.jsonl$/, "");
 var PICKER_ROWS = 8;
 var sessionRows = (p, here) => {
   const q = p.query.trim().toLowerCase();
-  const all = p.all.map((it) => ({ ...it, dir: it.cwd ? path2.basename(it.cwd) : "" }));
+  const all = p.all.map((it) => ({ ...it, dir: it.cwd ? path3.basename(it.cwd) : "" }));
   const inHere = all.filter((it) => it.cwd && here && it.cwd === here);
   const scope = p.scope === "here" && inHere.length ? "here" : "all";
   let rows = all;
@@ -83865,8 +84563,15 @@ var sessionRows = (p, here) => {
   if (q) rows = rows.filter((it) => [it.instruction, it.dir, it.name, it.model].some((v) => (v || "").toLowerCase().includes(q)));
   return { rows, scope };
 };
+var ago = (at) => {
+  const secs = Math.max(0, Date.now() / 1e3 - (at || 0));
+  if (secs < 90) return "just now";
+  if (secs < 3600) return `${Math.floor(secs / 60)}m ago`;
+  if (secs < 86400) return `${Math.floor(secs / 3600)}h ago`;
+  return `${Math.floor(secs / 86400)}d ago`;
+};
 var homeRel = (p) => {
-  const h = os4.homedir();
+  const h = os5.homedir();
   return p && h && p.startsWith(h) ? "~" + p.slice(h.length) : p;
 };
 var handEdit = (stat) => {
@@ -83877,11 +84582,11 @@ var handEdit = (stat) => {
   ${lines.join("\n  ")}`;
 };
 var fmtCost = (c) => c >= 0.01 ? `$${c.toFixed(2)}` : c > 0 ? `$${c.toFixed(4)}` : "$0";
-var HISTORY_PATH = path2.join(os4.homedir(), ".hum", "history.json");
+var HISTORY_PATH = path3.join(os5.homedir(), ".hum", "history.json");
 var HISTORY_MAX = 300;
 var loadHistory = () => {
   try {
-    const a = JSON.parse(fs3.readFileSync(HISTORY_PATH, "utf8"));
+    const a = JSON.parse(fs4.readFileSync(HISTORY_PATH, "utf8"));
     return Array.isArray(a) ? a.filter((x) => typeof x === "string") : [];
   } catch {
     return [];
@@ -83889,8 +84594,8 @@ var loadHistory = () => {
 };
 var saveHistory = (arr) => {
   try {
-    fs3.mkdirSync(path2.dirname(HISTORY_PATH), { recursive: true });
-    fs3.writeFileSync(HISTORY_PATH, JSON.stringify(arr.slice(-HISTORY_MAX)));
+    fs4.mkdirSync(path3.dirname(HISTORY_PATH), { recursive: true });
+    fs4.writeFileSync(HISTORY_PATH, JSON.stringify(arr.slice(-HISTORY_MAX)));
   } catch {
   }
 };
@@ -83901,8 +84606,10 @@ var tail = (s, n) => {
 };
 var COMMANDS = [
   { name: "/resume", desc: "pick a past session to continue (this machine or any other)" },
-  { name: "/compact", desc: "summarise and restart the context now" },
+  { name: "/compact", desc: "summarise and restart the context now (/compact <what the note should attend to>)" },
   { name: "/model", desc: "switch between the models you can use; /model <name> switches straight away" },
+  { name: "/diff", desc: "what has changed since this session began (/diff last: the last exchange; /diff <path>: one file)" },
+  { name: "/rewind", desc: "go back to something you said: the files, the conversation, or both (esc esc opens it too)" },
   { name: "/cost", desc: "tokens and cost so far" },
   { name: "/approve", desc: "approvals on|off \u2014 whether every change and command waits for you first (leaving the sandbox always asks)" },
   { name: "/continue", desc: "after a pause: let the agent carry on" },
@@ -83916,8 +84623,16 @@ var COMMANDS = [
   { name: "/quit", desc: "leave; the session keeps running (hum resume brings you back)" },
   { name: "/stop", desc: "end this session for good (the record is saved)" }
 ];
-var HELP = "!cmd runs a command as you \xB7 esc interrupts the model (what it had is kept) \xB7 type while it works to steer \xB7 edit files in your editor any time (recorded as your turn) \xB7 ctrl+o shows the full output of the last tool result \xB7 ctrl+v pastes a screenshot from the clipboard \xB7 @path.png or /image <path> attaches an image file \xB7 commands run in a sandbox (writes in the working directory, no network); leaving it asks you first (enter approves, a typed reason rejects) \xB7 /approve makes every change and command wait for you; at the panel, a allows that shape for the session and p writes it into the project \xB7 /permissions lists the rules in force \xB7 /mcp lists the tool servers \xB7 /resume picks a past session (a running one attaches) \xB7 /compact restarts the context from a summary \xB7 ctrl+c twice leaves and the session keeps running (`hum resume` brings you back) \xB7 /stop ends it";
+var HELP = "!cmd runs a command as you \xB7 esc interrupts the model (what it had is kept) \xB7 esc twice while it is idle opens the rewind picker \xB7 type while it works to steer \xB7 edit files in your editor any time (recorded as your turn) \xB7 ctrl+o shows the full output of the last tool result \xB7 ctrl+v pastes a screenshot from the clipboard \xB7 @path.png or /image <path> attaches an image file \xB7 commands run in a sandbox (writes in the working directory, no network); leaving it asks you first (enter approves, a typed reason rejects) \xB7 /approve makes every change and command wait for you; at the panel, a allows that shape for the session and p writes it into the project \xB7 /permissions lists the rules in force \xB7 /diff shows what has changed since the session began \xB7 /rewind takes the files or the conversation back to something you said \xB7 /mcp lists the tool servers \xB7 /resume picks a past session (a running one attaches) \xB7 /compact restarts the context from a summary \xB7 ctrl+c twice leaves and the session keeps running (`hum resume` brings you back) \xB7 /stop ends it";
 var DIFF_TAIL_LINES = 20;
+var PATCH_LINES = 200;
+var ESC_ESC_MS = 800;
+var REWIND_ROWS = 8;
+var REWIND_CHOICES = [
+  { key: "files", label: "restore the files", desc: "the workspace goes back to how it was then" },
+  { key: "chat", label: "restore the conversation", desc: "hum carries on from what you said, on a new branch; nothing is deleted" },
+  { key: "both", label: "both", desc: "" }
+];
 var OUTPUT_MAX_LINES = 200;
 var ERR_TAIL_LINES = 5;
 function App2({ engine: engine2, task, resume, images = [] }) {
@@ -83944,6 +84659,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
   const [qAnswers, setQAnswers] = (0, import_react24.useState)({});
   const [qPicks, setQPicks] = (0, import_react24.useState)([]);
   const [qCursor, setQCursor] = (0, import_react24.useState)(0);
+  const [confirm, setConfirm] = (0, import_react24.useState)(null);
   const [gate, setGate] = (0, import_react24.useState)("off");
   const [paused, setPaused] = (0, import_react24.useState)(false);
   const attachRef = (0, import_react24.useRef)([]);
@@ -83961,6 +84677,9 @@ function App2({ engine: engine2, task, resume, images = [] }) {
   const lastOutRef = (0, import_react24.useRef)(null);
   const helloRef = (0, import_react24.useRef)(false);
   const startedRef = (0, import_react24.useRef)(false);
+  const escRef = (0, import_react24.useRef)(0);
+  const rewindRef = (0, import_react24.useRef)({ files: true, conversation: true });
+  const wantRow = (0, import_react24.useRef)(null);
   const preHello = (0, import_react24.useRef)([]);
   const [meter, setMeter] = (0, import_react24.useState)({ tokens: 0, cap: 0, input: 0, output: 0 });
   const setPhaseBoth = (p) => {
@@ -84005,6 +84724,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
     setQCursor(0);
     setPaused(false);
     setPicker(null);
+    setConfirm(null);
     setSpend(0);
     setGoal(null);
     setSession(null);
@@ -84070,7 +84790,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
         setGate(ev.gate === "approve" ? "approve" : "off");
         if (ev.session) setSession(ev.session);
         if (ev.fresh) append({ kind: "wordmark" });
-        append({ kind: "banner", lines: bannerLines(ev, homeRel), instruction: ev.session ? ev.instruction : null });
+        append({ kind: "banner", lines: bannerLines(ev, homeRel, MINE), instruction: ev.session ? ev.instruction : null });
         if (ev.note) append({ kind: "warn", text: ev.note });
         setGoal(ev.goal || null);
         if (ev.goal) append({ kind: "info", text: `goal: ${ev.goal}` });
@@ -84299,6 +85019,39 @@ function App2({ engine: engine2, task, resume, images = [] }) {
         setProposal(null);
         append({ kind: "info", text: "approvals off: the waiting proposal ran" });
         break;
+      case "diff": {
+        const text = String(ev.text || "");
+        if (!text.trim()) {
+          append({ kind: "info", text: ev.scope === "last" ? "nothing changed in the last exchange" : ev.scope ? `nothing changed in ${ev.scope}` : "nothing has changed since this session began" });
+          break;
+        }
+        const ls = text.split("\n");
+        const stat = String(ev.stat || "").split("\n").filter((l) => l.trim()).pop() || "";
+        append({ kind: "patch", lines: ls.slice(0, PATCH_LINES), more: Math.max(0, ls.length - PATCH_LINES), stat });
+        break;
+      }
+      case "rewind_list": {
+        const items2 = ev.items || [];
+        if (!items2.length) {
+          append({ kind: "info", text: "nothing to go back to yet" });
+          break;
+        }
+        const want = items2.findIndex((it) => it.n === wantRow.current);
+        wantRow.current = null;
+        setPicker({ kind: "rewind", items: items2, index: want >= 0 ? want : items2.length - 1, top: 0, choice: null });
+        break;
+      }
+      case "rewind_confirm":
+        setPicker(null);
+        setConfirm({ node: ev.node, said: ev.said || "", stat: ev.stat || "", why: ev.why || "" });
+        break;
+      case "rewind": {
+        setConfirm(null);
+        const did = [ev.files ? "the files" : null, ev.conversation ? "the conversation" : null].filter(Boolean).join(" and ");
+        append({ kind: "info", text: `back to \u201C${(ev.said || "").slice(0, 60)}\u201D \xB7 ${did} restored` });
+        if (ev.stat) append({ kind: "info", text: `  ${String(ev.stat).split("\n").filter((l) => l.trim()).join("\n  ")}` });
+        break;
+      }
       case "goal":
         setGoal(ev.text || null);
         append({ kind: "info", text: ev.text ? `goal: ${ev.text}` : "goal cleared" });
@@ -84375,7 +85128,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
   (0, import_react24.useEffect)(() => {
     if (!hello) return void 0;
     let live = true;
-    updateNotice(true ? "0.1.26" : hello.version || "0.0.0").then((line) => {
+    updateNotice(MINE || hello.version || "0.0.0", { running: hello.version || "" }).then((line) => {
       if (live && line) append({ kind: "info", text: line });
     }).catch(() => {
     });
@@ -84423,6 +85176,47 @@ function App2({ engine: engine2, task, resume, images = [] }) {
       }
       return;
     }
+    if (confirm && !picker) {
+      if (key.return) {
+        setConfirm(null);
+        engine2.send({ cmd: "rewind", to: confirm.node, ...rewindRef.current, confirm: true });
+        return;
+      }
+      if (key.escape) {
+        setConfirm(null);
+        append({ kind: "info", text: "left as it is" });
+        return;
+      }
+      return;
+    }
+    if (picker && picker.kind === "rewind") {
+      if (picker.choice === null) {
+        const n = picker.items.length;
+        const move = (d) => setPicker((pk) => {
+          const index = (pk.index + d + n) % n;
+          const top = index < pk.top ? index : index >= pk.top + REWIND_ROWS ? index - REWIND_ROWS + 1 : pk.top;
+          return { ...pk, index, top };
+        });
+        if (key.upArrow) move(-1);
+        else if (key.downArrow || key.tab) move(1);
+        else if (key.escape) setPicker(null);
+        else if (key.return) setPicker((pk) => ({ ...pk, choice: 0 }));
+        return;
+      }
+      const pick = (c) => {
+        const it = picker.items[picker.index];
+        setPicker(null);
+        if (!it) return;
+        rewindRef.current = { files: c !== "chat", conversation: c !== "files" };
+        engine2.send({ cmd: "rewind", to: it.node, ...rewindRef.current });
+      };
+      if (key.upArrow) setPicker((pk) => ({ ...pk, choice: (pk.choice + REWIND_CHOICES.length - 1) % REWIND_CHOICES.length }));
+      else if (key.downArrow || key.tab) setPicker((pk) => ({ ...pk, choice: (pk.choice + 1) % REWIND_CHOICES.length }));
+      else if (key.escape) setPicker((pk) => ({ ...pk, choice: null }));
+      else if (key.return) pick(REWIND_CHOICES[picker.choice].key);
+      else if (/^[1-3]$/.test(input)) pick(REWIND_CHOICES[Number(input) - 1].key);
+      return;
+    }
     if (proposal && !picker) {
       if (key.return && !value.trim()) {
         decide("accept");
@@ -84519,7 +85313,20 @@ function App2({ engine: engine2, task, resume, images = [] }) {
       else if (key.tab) setValue(menu[Math.min(menuIndex, menu.length - 1)].name + " ");
       return;
     }
-    if (key.escape && phaseRef.current === "busy") engine2.send({ cmd: "interrupt" });
+    if (key.escape) {
+      if (phaseRef.current === "busy") {
+        engine2.send({ cmd: "interrupt" });
+        escRef.current = 0;
+        return;
+      }
+      const now = Date.now();
+      if (now - escRef.current < ESC_ESC_MS) {
+        escRef.current = 0;
+        engine2.send({ cmd: "rewind_list" });
+        return;
+      }
+      escRef.current = now;
+    }
   });
   (0, import_react24.useEffect)(() => {
     setMenuIndex(0);
@@ -84587,7 +85394,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
         engine2.send({ cmd: "sessions" });
         break;
       case "/compact":
-        engine2.send({ cmd: "compact" });
+        engine2.send(arg ? { cmd: "compact", text: arg } : { cmd: "compact" });
         break;
       case "/model":
         if (arg) {
@@ -84595,6 +85402,13 @@ function App2({ engine: engine2, task, resume, images = [] }) {
           engine2.send({ cmd: "model", name: arg });
         } else engine2.send({ cmd: "model" });
         break;
+      case "/diff":
+        engine2.send({ cmd: "diff", scope: arg });
+        break;
+      case "/rewind":
+        wantRow.current = /^\d+$/.test(arg) ? Number(arg) : null;
+        engine2.send({ cmd: "rewind_list" });
+        break;
       case "/cost": {
         const ctx = ctxPct > 0 ? ` \xB7 context ${ctxPct}% of the compaction threshold` : "";
         append({ kind: "info", text: `${fmtCost(spend)} this session \xB7 ${meter.input.toLocaleString()}+${meter.output.toLocaleString()} tokens${ctx}` });
@@ -84772,6 +85586,19 @@ function App2({ engine: engine2, task, resume, images = [] }) {
         )),
         item.more > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: `\u2026 +${item.more} more diff lines` }) : null
       ] }),
+      item.kind === "patch" && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingLeft: 2, children: [
+        item.lines.map((l, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          Text,
+          {
+            color: l.startsWith("+") ? "green" : l.startsWith("-") ? "red" : l.startsWith("@@") ? "cyan" : void 0,
+            dimColor: !l.startsWith("+") && !l.startsWith("-"),
+            children: l || " "
+          },
+          i
+        )),
+        item.more > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: `\u2026 +${item.more} more lines \xB7 /diff <path> narrows it` }) : null,
+        item.stat ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: item.stat.trim() }) : null
+      ] }),
       item.kind === "errtail" && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Box_default, { flexDirection: "column", paddingLeft: 6, children: item.lines.map((l, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "red", dimColor: true, children: l }, i)) }),
       item.kind === "output" && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingLeft: 4, children: [
         /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: `full output \xB7 ${item.name}` }),
@@ -84909,6 +85736,73 @@ function App2({ engine: engine2, task, resume, images = [] }) {
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
       /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "Enter to switch \xB7 Esc to cancel" })
     ] }),
+    confirm && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: "yellow", bold: true, children: [
+        "\u23EE ",
+        confirm.why || "the workspace has changed since hum last looked"
+      ] }),
+      String(confirm.stat || "").split("\n").filter((l) => l.trim()).slice(0, 8).map((l, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { dimColor: true, children: [
+        "  ",
+        l
+      ] }, i)),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "they are kept in this session's history and can be found again \xB7 enter goes back anyway \xB7 esc leaves it as it is" })
+    ] }),
+    picker && picker.kind === "rewind" && (() => {
+      const it = picker.items[picker.index];
+      if (picker.choice !== null) {
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: ACCENT, bold: true, children: [
+            "Rewind to ",
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "white", children: `\u201C${(it?.said || "").slice(0, width - 24)}\u201D` })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+          REWIND_CHOICES.map((c, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: ACCENT, children: i === picker.choice ? "\u276F " : "  " }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { bold: i === picker.choice, children: [
+              i + 1,
+              ". ",
+              c.label.padEnd(26)
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: c.desc })
+          ] }, c.key)),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "Enter to go back \xB7 Esc for the list again" })
+        ] });
+      }
+      const top = Math.min(picker.top, Math.max(0, picker.items.length - REWIND_ROWS));
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { color: ACCENT, bold: true, children: [
+          "Rewind ",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: `(${picker.index + 1} of ${picker.items.length})` })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "Every checkpoint is something you said. Nothing is deleted: what you go back past stays in the session." }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+        picker.items.slice(top, top + REWIND_ROWS).map((c, j) => {
+          const i = top + j;
+          const sel = i === picker.index;
+          const meta = [`${c.steps} ${c.steps === 1 ? "step" : "steps"}`, c.files ? `${c.files} ${c.files === 1 ? "file" : "files"} changed since` : null].filter(Boolean).join(" \xB7 ");
+          const said = (c.said || "(nothing said)").replace(/\s+/g, " ");
+          const room = Math.max(16, width - 26);
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Box_default, { flexDirection: "column", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: ACCENT, children: sel ? "\u276F " : "  " }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { dimColor: true, children: [
+                String(ago(c.at)).padStart(9),
+                "  "
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { bold: sel, color: sel ? ACCENT : void 0, children: said.length > room ? said.slice(0, room - 1) + "\u2026" : said })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { dimColor: true, children: [
+              "             ",
+              meta
+            ] })
+          ] }, c.node);
+        }),
+        top + REWIND_ROWS < picker.items.length ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: `\u2193 ${picker.items.length - top - REWIND_ROWS} more` }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: " " }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: "Enter to choose what comes back \xB7 Esc to cancel" })
+      ] });
+    })(),
     picker && picker.kind === "session" && (() => {
       const { rows, scope } = sessionRows(picker, hello?.cwd);
       const top = Math.min(picker.top, Math.max(0, rows.length - PICKER_ROWS));
@@ -84970,7 +85864,7 @@ function App2({ engine: engine2, task, resume, images = [] }) {
           value,
           onChange: setValue,
           onSubmit,
-          focus: phase !== "dead" && !picker,
+          focus: phase !== "dead" && !picker && !confirm,
           navActive: menu.length === 0,
           history: historyRef.current,
           mask: !!(step && step.secret),
@@ -84999,293 +85893,48 @@ function App2({ engine: engine2, task, resume, images = [] }) {
   ] });
 }
 
-// src/engine.js
-import fs4 from "node:fs";
-import net from "node:net";
-import os5 from "node:os";
-import path3 from "node:path";
-import crypto from "node:crypto";
-import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-var runDir = () => path3.join(process.env.HUM_HOME || path3.join(os5.homedir(), ".hum"), "run");
-var readRun = (id) => {
-  try {
-    return JSON.parse(fs4.readFileSync(path3.join(runDir(), `${id}.json`), "utf8"));
-  } catch {
-    return null;
-  }
-};
-var EngineError = class extends Error {
-};
-var win2 = process.platform === "win32";
-var exists = (p) => {
-  try {
-    fs4.accessSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-};
-function uvToolDirs() {
-  const dirs = [];
-  if (process.env.UV_TOOL_DIR) dirs.push(process.env.UV_TOOL_DIR);
-  if (win2) {
-    for (const base of [process.env.APPDATA, process.env.LOCALAPPDATA]) if (base) dirs.push(path3.join(base, "uv", "tools"));
-  } else dirs.push(path3.join(process.env.XDG_DATA_HOME || path3.join(os5.homedir(), ".local", "share"), "uv", "tools"));
-  if (!dirs.some(exists)) {
-    for (const uv of ["uv", path3.join(os5.homedir(), ".local", "bin", win2 ? "uv.exe" : "uv")]) {
-      try {
-        const r = spawnSync2(uv, ["tool", "dir"], { encoding: "utf8", windowsHide: true });
-        if (r.status === 0 && r.stdout.trim()) {
-          dirs.push(r.stdout.trim());
-          break;
-        }
-      } catch {
-      }
-    }
-  }
-  return dirs;
-}
-function enginePython(dirs = uvToolDirs()) {
-  for (const dir of dirs) for (const name of ["hum-cli", "hum"]) {
-    const py = win2 ? path3.join(dir, name, "Scripts", "python.exe") : path3.join(dir, name, "bin", "python");
-    if (exists(py)) return py;
-  }
-  return null;
-}
-function siblingEngine(execPath = process.execPath) {
-  let dir;
-  try {
-    dir = path3.dirname(fs4.realpathSync(execPath));
-  } catch {
-    return null;
-  }
-  const p = path3.join(dir, "engine", win2 ? "hum-engine.exe" : "hum-engine");
-  return exists(p) ? p : null;
-}
-function homeEngine(env3 = process.env) {
-  const home = env3.HUM_HOME || path3.join(os5.homedir(), ".hum");
-  const py = win2 ? path3.join(home, "engine", "Scripts", "python.exe") : path3.join(home, "engine", "bin", "python");
-  return exists(py) ? py : null;
-}
-function engineCandidates(env3 = process.env) {
-  const out = [];
-  if (env3.HUM_ENGINE) {
-    const [bin, ...args2] = env3.HUM_ENGINE.split(" ");
-    out.push({ bin, args: args2, where: "HUM_ENGINE" });
-  }
-  const sib = siblingEngine();
-  if (sib) out.push({ bin: sib, args: ["engine"], where: "beside hum" });
-  const home = homeEngine(env3);
-  if (home) out.push({ bin: home, args: ["-m", "hum.cli", "engine"], where: "HUM_HOME/engine" });
-  const py = enginePython();
-  if (py) out.push({ bin: py, args: ["-m", "hum.cli", "engine"], where: "the engine's interpreter" });
-  out.push({ bin: "hum-engine", args: [], where: "PATH" });
-  out.push({ bin: path3.join(os5.homedir(), ".local", "bin", win2 ? "hum-engine.exe" : "hum-engine"), args: [], where: "uv's bin dir" });
-  return out;
-}
-function engineCommand(argv, candidates = engineCandidates()) {
-  for (const c of candidates) {
-    if (c.args[c.args.length - 1] !== "engine") continue;
-    return { bin: c.bin, args: [...c.args.slice(0, -1), ...argv], where: c.where };
-  }
-  return null;
-}
-function startFailure(failures) {
-  const refused = failures.find((f) => f.error && f.error.code !== "ENOENT");
-  if (!refused) {
-    return "Hum's engine is not installed. Run:  uv tool install hum-cli   (or set HUM_ENGINE to the command that starts it)";
-  }
-  const what = refused.error.code || refused.error.message;
-  const lines = [
-    `Hum's engine is installed (${refused.bin}) but this machine would not start it: ${what}.`
-  ];
-  if (win2) {
-    lines.push("On a managed Windows machine that is usually Device Guard / WDAC refusing an executable it does not know.");
-    lines.push(`To see the policy's own message, run:  "${refused.bin}" --help`);
-    const dir = uvToolDirs()[0];
-    lines.push(`If uv's environment is elsewhere, point Hum at its interpreter:  set HUM_ENGINE=${path3.join(dir || "<uv tool dir>", "hum-cli", "Scripts", "python.exe")} -m hum.cli engine`);
-  } else {
-    lines.push('Set HUM_ENGINE to a command that starts it, e.g.  HUM_ENGINE="python -m hum.cli engine"');
-  }
-  return lines.join("\n");
-}
-function attempt({ bin, args: args2 }, cwd2, { task, images, resume }) {
-  return new Promise((resolve, reject) => {
-    const runId = crypto.randomBytes(6).toString("hex");
-    fs4.mkdirSync(runDir(), { recursive: true });
-    const logPath = path3.join(runDir(), `${runId}.log`);
-    const log = fs4.openSync(logPath, "a");
-    const argv = [...args2, "-C", cwd2, "--run-id", runId];
-    if (task) argv.push("--task", task);
-    for (const p of images) argv.push("--image", p);
-    if (resume) argv.push("--resume", resume);
-    let settled = false;
-    const settle = (fn) => {
-      if (!settled) {
-        settled = true;
-        fn();
-      }
-    };
-    let child;
-    try {
-      child = spawn2(bin, argv, { stdio: ["ignore", log, log], detached: true, windowsHide: true });
-    } catch (e) {
-      fs4.closeSync(log);
-      reject({ spawn: e });
-      return;
-    }
-    fs4.closeSync(log);
-    let died = false;
-    child.on("error", (e) => settle(() => reject({ spawn: e })));
-    child.on("exit", () => {
-      died = true;
-    });
-    const t0 = Date.now();
-    const poll = () => {
-      if (settled) return;
-      const rec = readRun(runId);
-      if (rec && rec.port) {
-        child.unref();
-        settle(() => resolve(rec));
-        return;
-      }
-      if (rec && rec.error) {
-        settle(() => reject({ failed: rec.error }));
-        return;
-      }
-      if (died && !rec) {
-        settle(() => reject({ died: logPath }));
-        return;
-      }
-      if (Date.now() - t0 > 9e4) {
-        settle(() => reject({ timeout: true }));
-        return;
-      }
-      setTimeout(poll, 50);
-    };
-    poll();
-  });
-}
-function failureMessage(error) {
-  return error.message + (error.hint ? `
-  ${error.hint}` : "");
-}
-function diedMessage(logPath, text = null) {
-  let tail2 = "";
-  try {
-    tail2 = (text ?? fs4.readFileSync(logPath, "utf8")).trim().split("\n").slice(-3).join("\n").trim();
-  } catch {
-  }
-  return `the engine did not start${tail2 ? `:
-${tail2}` : ""}
-(its log: ${logPath})`;
-}
-async function spawnEngine(cwd2, { task = null, images = [], resume = null, candidates = engineCandidates() } = {}) {
-  const failures = [];
-  for (const cand of candidates) {
-    if (!cand.bin) continue;
-    try {
-      return await attempt(cand, cwd2, { task, images, resume });
-    } catch (f) {
-      if (f && f.spawn) {
-        failures.push({ ...cand, error: f.spawn });
-        continue;
-      }
-      if (f && f.failed) throw new EngineError(failureMessage(f.failed));
-      if (f && f.died) throw new EngineError(diedMessage(f.died));
-      if (f && f.timeout) throw new EngineError("the engine did not start in time");
-      throw f;
-    }
-  }
-  throw new EngineError(startFailure(failures));
-}
-var Engine = class {
-  constructor(port2) {
-    this.port = port2;
-    this.handlers = [];
-    this.closed = false;
-  }
-  connect() {
-    return new Promise((resolve, reject) => {
-      const sock = net.createConnection({ host: "127.0.0.1", port: this.port }, () => resolve());
-      this.sock = sock;
-      sock.on("error", (e) => {
-        if (!this.closed && this.sock === sock) reject(new EngineError(`engine: ${e.message}`));
-      });
-      let buf = "";
-      sock.on("data", (d) => {
-        if (this.sock !== sock) return;
-        buf += d.toString();
-        const lines = buf.split("\n");
-        buf = lines.pop();
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          let ev;
-          try {
-            ev = JSON.parse(line);
-          } catch {
-            continue;
-          }
-          for (const h of this.handlers) h(ev);
-        }
-      });
-      sock.on("close", () => {
-        if (this.sock !== sock) return;
-        this.closed = true;
-        for (const h of this.handlers) h({ type: "bye", gone: true });
-      });
-    });
-  }
-  // Attach to another engine (a session running elsewhere on this machine): the old
-  // socket is dropped quietly, the new one greets us with hello and a replay.
-  async reconnect(port2) {
-    const old = this.sock;
-    this.sock = null;
-    this.port = port2;
-    this.closed = false;
-    try {
-      old.destroy();
-    } catch {
-    }
-    await this.connect();
-  }
-  on(handler) {
-    this.handlers.push(handler);
-  }
-  send(cmd) {
-    if (this.closed) return;
-    try {
-      this.sock.write(JSON.stringify(cmd) + "\n");
-    } catch {
-    }
-  }
-  close() {
-    this.closed = true;
-    try {
-      this.sock.end();
-    } catch {
-    }
-  }
-};
-
 // src/cli.jsx
+init_engine();
+init_update();
+init_install();
 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
+var MINE2 = true ? "0.1.30" : "0.0.0";
+var layout = installLayout();
+function completeInstall() {
+  if (layout.kind !== "npm" || !needsInstall(MINE2)) return;
+  const say = (m) => process.stderr.write(`hum: ${m}
+`);
+  say(`updating to ${MINE2} \u2026`);
+  const r = installEngine(MINE2, { say });
+  if (!r.ok) say(`the update did not finish: ${r.error} \xB7 ${npmFix(MINE2)}`);
+}
 var ENGINE_COMMANDS = /* @__PURE__ */ new Set(["run", "login", "logout", "whoami", "model", "key", "sessions", "show", "sync", "skill", "ps", "stop", "hooks", "engine"]);
 var argv0 = process.argv.slice(2);
 if (argv0[0] === "--version" || argv0[0] === "-V") {
-  process.stdout.write(`hum ${true ? "0.1.26" : "0.0.0"}
+  process.stdout.write(`hum ${MINE2}
+`);
+  if (layout.kind === "npm") {
+    const r = runningVersion();
+    const drift = mismatchLine(MINE2, r ? r.version : "", { layout });
+    if (drift) process.stdout.write(`${drift}
 `);
+  }
   process.exit(0);
 }
 if (argv0[0] === "update") process.exit(updateNow());
+if (argv0[0] === "doctor") {
+  const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  process.exit(await doctor2({ json: argv0.includes("--json"), mine: MINE2, layout }));
+}
 if (ENGINE_COMMANDS.has(argv0[0])) {
+  completeInstall();
   const cmd = engineCommand(argv0);
   if (!cmd) {
     process.stderr.write(startFailure([]) + "\n");
     process.exit(1);
   }
-  const r = spawnSync3(cmd.bin, cmd.args, { stdio: "inherit", windowsHide: true });
+  const r = spawnSync5(cmd.bin, cmd.args, { stdio: "inherit", windowsHide: true });
   if (r.error) {
     process.stderr.write(startFailure([{ bin: cmd.bin, error: r.error }]) + "\n");
     process.exit(1);
@@ -85303,7 +85952,7 @@ function parseArgs(argv) {
     } else if (x === "--image" && argv[i + 1]) {
       a.images.push(argv[++i]);
     } else if (x === "-h" || x === "--help") {
-      process.stdout.write("usage: hum [task] [--image path]  |  hum resume [name]\nIn a session: type to talk, !cmd runs a command, esc stops the model, ctrl+v pastes a screenshot, / for commands.\n");
+      process.stdout.write("usage: hum [task] [--image path]  |  hum resume [name]\nIn a session: type to talk, !cmd runs a command, esc stops the model (twice, while it waits: go back), ctrl+v pastes a screenshot, / for commands.\n");
       process.exit(0);
     } else if (!x.startsWith("-")) {
       a.task = a.task ? `${a.task} ${x}` : x;
@@ -85320,6 +85969,7 @@ var port = Number(process.env.HUM_ENGINE_PORT || 0);
 var startedHere = false;
 try {
   if (!port) {
+    completeInstall();
     const rec = await spawnEngine(args.cwd, { task: args.task, images: args.images, resume: args.resume && args.resume !== "pick" ? args.resume : null });
     startedHere = true;
     port = rec.port;