@hivefloor/cli 0.1.4 → 0.1.8

package/dist/{chunk-VNCQFFQO.js → chunk-XPGL7VYE.js}

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 
 // src/fsutil.ts
 import fs from "fs";
@@ -17,6 +19,11 @@ var machineFile = () => path.join(configDir(), "machine.json");
 var machineSpoolFile = () => path.join(configDir(), "machine-spool.jsonl");
 var serviceStateFile = () => path.join(configDir(), "service.json");
 var serviceLogFile = () => path.join(configDir(), "service.log");
+var controlFile = () => path.join(configDir(), "control.json");
+var sessionsFile = () => path.join(configDir(), "sessions.json");
+var controlLogFile = () => path.join(configDir(), "control.log");
+var controlInboxDir = () => path.join(configDir(), "control", "inbox");
+var controlDecisionsDir = () => path.join(configDir(), "control", "decisions");
 var cliDir = () => path.join(configDir(), "cli");
 var cliEntry = () => path.join(cliDir(), "index.js");
 function readText(file) {
@@ -117,6 +124,100 @@ function serializeJson(data, style) {
 }
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 
+// src/tools.ts
+import fs2 from "fs";
+import path2 from "path";
+var REAL_TOOLS = ["claude", "codex", "cursor", "gemini", "grok"];
+var TOOL_LABEL = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  gemini: "Gemini CLI",
+  grok: "Grok CLI",
+  other: "Other"
+};
+var BINARIES = {
+  claude: ["claude"],
+  codex: ["codex"],
+  gemini: ["gemini"],
+  grok: ["grok"]
+};
+function isTool(s) {
+  return s === "other" || REAL_TOOLS.includes(s);
+}
+function findBin(name, env) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of (env.PATH ?? "").split(path2.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const p = path2.join(dir, name + ext);
+      try {
+        if (fs2.statSync(p).isFile()) {
+          fs2.accessSync(p, fs2.constants.X_OK);
+          return p;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function firstBin(names, env) {
+  for (const name of names) {
+    const bin = findBin(name, env);
+    if (bin) return bin;
+  }
+  return void 0;
+}
+function sameFile(a, b) {
+  try {
+    return fs2.realpathSync(a) === fs2.realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+function agentIsGrok(agentPath, env) {
+  const grok = findBin("grok", env);
+  if (grok && sameFile(agentPath, grok)) return true;
+  return /(?:^|\/)\.grok(?:\/|$)/.test(agentPath.replace(/\\/g, "/").toLowerCase());
+}
+function hasCursorSignal(agentPath) {
+  let resolved = agentPath;
+  try {
+    resolved = fs2.realpathSync(agentPath);
+  } catch {
+  }
+  return resolved.replace(/\\/g, "/").toLowerCase().includes("cursor");
+}
+function agentIsCursor(agentPath, env) {
+  if (agentIsGrok(agentPath, env)) return false;
+  const cursor = findBin("cursor-agent", env);
+  if (cursor && sameFile(agentPath, cursor)) return true;
+  return hasCursorSignal(agentPath);
+}
+function cursorBin(env) {
+  const linked = findBin("cursor-agent", env);
+  if (linked) return linked;
+  const agent = findBin("agent", env);
+  return agent && agentIsCursor(agent, env) ? agent : void 0;
+}
+function detectTools(env) {
+  const found = [];
+  for (const tool of REAL_TOOLS) {
+    const bin = tool === "cursor" ? cursorBin(env) : firstBin(BINARIES[tool], env);
+    if (bin) found.push({ tool, bin });
+  }
+  return found;
+}
+function toolFromEnv(env) {
+  if (env.GROK_SESSION_ID) return "grok";
+  if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) return "claude";
+  if (env.CODEX_SANDBOX || env.CODEX_SESSION_ID || env.CODEX_THREAD_ID || env.CODEX_CI) return "codex";
+  if (env.CURSOR_AGENT || env.CURSOR_TRACE_ID || env.CURSOR_SESSION_ID) return "cursor";
+  if (env.GEMINI_CLI || env.GEMINI_SESSION_ID) return "gemini";
+  return void 0;
+}
+
 export {
   home,
   configDir,
@@ -127,6 +228,11 @@ export {
   machineSpoolFile,
   serviceStateFile,
   serviceLogFile,
+  controlFile,
+  sessionsFile,
+  controlLogFile,
+  controlInboxDir,
+  controlDecisionsDir,
   cliDir,
   cliEntry,
   readText,
@@ -139,5 +245,12 @@ export {
   ConfigError,
   readJsonFile,
   serializeJson,
-  isRecord
+  isRecord,
+  REAL_TOOLS,
+  TOOL_LABEL,
+  isTool,
+  findBin,
+  agentIsCursor,
+  detectTools,
+  toolFromEnv
 };

package/dist/cli-BFOJWJNG.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  parseArgs
+} from "./chunk-QPAFN47B.js";
+import {
+  VERSION
+} from "./chunk-K2IRTZH5.js";
+import {
+  ApiError
+} from "./chunk-NRJONTFT.js";
+import {
+  defaultCtx
+} from "./chunk-QGULSOQ2.js";
+import {
+  CLI_BIN_NAME,
+  CLI_INSTALL_COMMAND,
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
+
+// src/help.ts
+var HOST_NOTE = `Host: --host URL, else HIVEFLOOR_URL, else the hosted instance. Self-hosting: pass --host or set HIVEFLOOR_URL.`;
+var COMMAND_HELP = {
+  connect: `Usage: ${CLI_BIN_NAME} connect [options]
+
+Connect this computer once: every agent on it (Claude profiles, Codex, ...) shows up.
+
+Options:
+  --host URL      HiveFloor server (default: HIVEFLOOR_URL, else the hosted instance)
+  --name NAME     Display name for this machine (default: the computer's hostname)
+  --no-open       Print the sign-in link instead of opening a browser
+  --no-service    Do not install the background service
+  --yes, -y       Skip confirmation prompts and accept defaults
+  --agent         Connect one agent for the current git repo (MCP and tasks) instead of the machine
+  --tool NAME     Like --agent for one tool: claude, codex, cursor, gemini, grok or other
+  --no-cli        With --agent or --tool: write the tool's config files directly instead of running its own CLI (claude mcp add, ...)
+
+${HOST_NOTE}
+`,
+  disconnect: `Usage: ${CLI_BIN_NAME} disconnect [options]
+
+Remove everything connect added: hooks, MCP entries, service, stored tokens, and the machine on the server.
+
+Options:
+  --host URL      Only remove credentials for this server (a different server leaves this machine in place)
+  --tool NAME     Remove one agent tool only: claude, codex, cursor, gemini or grok
+`,
+  status: `Usage: ${CLI_BIN_NAME} status [options]
+
+This machine and its service; the per-repo agent, its projects and live sessions.
+
+Options:
+  --host URL      Server to query (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Look at one agent tool's token
+
+${HOST_NOTE}
+`,
+  where: `Usage: ${CLI_BIN_NAME} where [tool] [options]
+
+Which account to run next on. Read only: nothing is switched.
+
+Arguments:
+  tool            claude, codex, ... (a tool or provider name)
+
+Options:
+  --json          Print the raw answer
+  --host URL      Server to query (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Look at one agent tool's token
+
+${HOST_NOTE}
+`,
+  service: `Usage: ${CLI_BIN_NAME} service run
+
+Run the background service in the foreground. Your OS starts it for you after connect; you rarely run it by hand.
+`,
+  control: `Usage: ${CLI_BIN_NAME} control on [--verbs message,approve,deny,stop|none] [--from owner|admins] [--replies off|after_message|always] [--orchestrator on|off]
+       ${CLI_BIN_NAME} control off
+       ${CLI_BIN_NAME} control status
+
+Session control: let people you allow send a message to, approve or deny a permission prompt of, or stop a live Claude Code session on this computer.
+Off until you turn it on here. Nothing opens a port: the service asks the server for commands. status says what a compromised server could do with the verbs that are on.
+
+Options:
+  --verbs LIST    Which verbs to turn on (default: message,stop). approve and deny add one synchronous PermissionRequest hook to Claude Code's settings.json
+  --from WHO      owner (default): only the machine's owner; admins: also the project's owners and admins
+  --replies MODE  Send the agent's last message to the server: off, after_message (default) or always
+  --orchestrator on|off  Let the server start one Claude Code session in its own folder and type to it (docs/ORCHESTRATOR.md).
+                  Its tool calls outside reading that folder are asked on the orchestrator page. --verbs none --orchestrator on turns on only this.
+`,
+  orch: `Usage: ${CLI_BIN_NAME} orch enable [--full | --no-full]
+       ${CLI_BIN_NAME} orch disable
+       ${CLI_BIN_NAME} orch status
+
+The orchestrator: let your HiveFloor account start one Claude Code session on this computer and talk to it (docs/ORCHESTRATOR.md).
+
+  enable          Turn the orchestrator on. By default the session is sandboxed: its own folder, none of your settings, every tool call asked on the orchestrator page.
+  --full          Also allow full power: a start from HiveFloor may run the session as a normal Claude Code session of yours (your settings, MCP servers,
+                  skills and environment, any folder, resume any of your sessions by id, permission prompts bypassed when the start asks for it).
+                  That is remote code as you: a session with prompts bypassed asks nothing, so text from fleet reports, scheduled check-ins and
+                  tool output can make it run commands as you. Only this command can turn it on; the server cannot. It asks you to type FULL,
+                  needs a terminal (no pipe or script), and is refused inside a Claude Code session.
+  --no-full       Turn full power off again (a running full-power session is stopped).
+  disable         Turn the orchestrator off (full power too). Session control verbs stay as they are.
+`,
+  link: `Usage: ${CLI_BIN_NAME} link [options]
+
+Link this repo to another project. With neither --project nor --new, your browser opens to pick one.
+
+Options:
+  --project ID    Link to an existing project
+  --new NAME      Create a project and link to it (not together with --project)
+  --path PREFIX   Repo path inside the project (monorepo subfolder)
+  --host URL      Server (default: HIVEFLOOR_URL, else the stored host)
+  --tool NAME     Which agent tool's token to use
+  --no-open       Print the sign-in link instead of opening a browser
+
+${HOST_NOTE}
+`,
+  token: `Usage: ${CLI_BIN_NAME} token [options]
+
+Print the stored token for shell use, for example: export HIVEFLOOR_TOKEN=$(${CLI_BIN_NAME} token)
+It refuses to print to a terminal unless you pass --reveal.
+
+Options:
+  --reveal        Print to a terminal anyway
+  --host URL      Host to look up the token for (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Which agent tool's token to print
+`,
+  mcp: `Usage: ${CLI_BIN_NAME} mcp [options]
+
+Stdio MCP server that proxies to HiveFloor, for tools that cannot send HTTP headers. Needs a stored token (run ${cliNpxCommand("connect")} first).
+
+Options:
+  --url URL       MCP endpoint (default: <host>/mcp)
+  --host URL      Host that resolves the stored token
+  --tool NAME     Which agent tool's token to use
+
+${HOST_NOTE}
+`,
+  voice: `Usage: ${CLI_BIN_NAME} voice status
+       ${CLI_BIN_NAME} voice list [--agent-id ID]
+       ${CLI_BIN_NAME} voice say "<text>" --out FILE.wav [--voice ID | --agent-id AGENT_ID] [--speed N]
+
+Speech from TalkBack's Kokoro voice, which runs on this computer (https://github.com/Errr0rr404/talkback).
+
+  status          Is TalkBack's voice running? (reads ~/.talkback/voiced.json and pings it)
+  list            Print the Kokoro voice ids. Does not contact TalkBack.
+  say             Synthesize the text to a 24 kHz mono WAV file. Nothing is played.
+
+Options for list:
+  --agent-id ID   Print the voice and speed hivefloor gives that agent id
+
+Options for say:
+  --out FILE      Where to write the WAV (required)
+  --voice ID      A Kokoro voice id, for example af_heart or bf_emma
+  --agent-id ID   Use the stable voice and speed hivefloor gives that agent id
+  --speed N       0.5 to 2 (default: TalkBack's setting)
+
+If TalkBack is not installed, status and say print the install line and exit 1. list does not contact TalkBack. Text for say is limited to 2000 characters.
+`,
+  hook: `Usage: ${CLI_BIN_NAME} hook <tool> <event> [--profile KEY]
+
+The hook runner that Claude Code, Codex and other tools call. It reads the event JSON on stdin, reports it to HiveFloor, and always exits 0 so a hook never fails the agent. You do not run it by hand; ${cliNpxCommand("connect")} installs the hook entries.
+
+Arguments:
+  tool            claude, codex, ...
+  event           the tool's native event name, for example PreToolUse
+  --profile KEY   Use this machine profile's token and host (set by machine connect)
+`
+};
+function commandHelp(cmd) {
+  return Object.hasOwn(COMMAND_HELP, cmd) ? COMMAND_HELP[cmd] : void 0;
+}
+
+// src/cli.ts
+var HELP = `hivefloor ${VERSION}
+
+Usage: ${CLI_BIN_NAME} <command> [options]
+       ${cliNpxCommand("<command> [options]")}   (no install)
+
+Commands:
+  connect      Connect this computer once: every agent on it shows up (Claude profiles, Codex, ...)
+                 --host URL   --name NAME   --no-open   --no-service   --yes
+                 --agent | --tool claude|codex|cursor|gemini|grok|other   connect one agent for one repo (MCP and tasks) instead
+  disconnect   Remove everything connect added, the machine on the server included (--tool <name> for one agent tool)
+  status       This machine and its service; the per-repo agent, its projects and live sessions
+  where        [tool] Which account to run next on (read only; --json for the raw answer)
+  control      on [--verbs ...] [--from owner|admins] | off | status: let people message, approve or stop live sessions
+  service      run: the background service (started by your OS; you rarely run it by hand)
+  link         Link this repo to another project (--project ID | --new NAME [--path PREFIX])
+  token        Print the stored token for shell use (--reveal to print to a terminal)
+  voice        status | list [--agent-id ID] | say "<text>" --out file.wav: TalkBack's spoken voice on this computer
+  mcp          Stdio MCP server that proxies to HiveFloor (for tools without HTTP header support)
+  hook         <tool> <event>: the hook runner the tools call (reads JSON on stdin)
+  help         Show this help (hivefloor <command> --help, or help <command>, for one command)
+  --version    Print the version
+
+Install once: ${CLI_INSTALL_COMMAND}
+Host: https://hivefloor.worldofz.info. Self-hosting: pass --host URL or set HIVEFLOOR_URL.
+`;
+async function run(argv, ctx = defaultCtx()) {
+  const [cmd, ...rest] = argv;
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    ctx.out(`${VERSION}
+`);
+    return 0;
+  }
+  if (cmd === "help" && rest[0] !== void 0 && !rest[0].startsWith("-")) {
+    const h = rest[0] === "help" || rest[0] === "version" ? HELP : commandHelp(rest[0]);
+    if (h === void 0) {
+      ctx.err(`hivefloor: unknown command "${rest[0]}". Run "hivefloor help".
+`);
+      return 2;
+    }
+    ctx.out(h);
+    return 0;
+  }
+  if (cmd === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    ctx.out(HELP);
+    return 0;
+  }
+  const p = parseArgs(rest);
+  if (p.flags.help) {
+    ctx.out(commandHelp(cmd) ?? HELP);
+    return 0;
+  }
+  try {
+    switch (cmd) {
+      case "connect":
+        return await (await import("./connect-ZJ4JXBAJ.js")).connect(ctx, p);
+      case "disconnect":
+        return await (await import("./disconnect-3T25NTKX.js")).disconnect(ctx, p);
+      case "status":
+        return await (await import("./status-QXOOJGGN.js")).status(ctx, p);
+      case "where":
+        return await (await import("./where-CMUORQIO.js")).where(ctx, p);
+      case "service":
+        if (p.positionals[0] !== "run") {
+          ctx.err("hivefloor: usage: hivefloor service run\n");
+          return 2;
+        }
+        return await (await import("./run-JL2OZWK3.js")).runService({ ctx });
+      case "control":
+        return await (await import("./control-6GHTZQJV.js")).control(ctx, p);
+      case "orch":
+        return await (await import("./orch-KVRL2YA2.js")).orch(ctx, p);
+      case "link":
+        return await (await import("./link-EAS5F5PC.js")).link(ctx, p);
+      case "token":
+        return await (await import("./token-BFWWQIDA.js")).token(ctx, p);
+      case "voice":
+        return await (await import("./voice-QXHFXRWG.js")).voice(ctx, p);
+      case "mcp":
+        return await (await import("./mcp-LVIYR3EN.js")).runMcpProxy(ctx, p);
+      case "hook": {
+        const { runHook, readStdin } = await import("./hook-TPSHBCWU.js");
+        await runHook(rest, { env: ctx.env, cwd: ctx.cwd, fetch: ctx.fetch, now: ctx.now, readStdin });
+        return 0;
+      }
+      default:
+        ctx.err(`hivefloor: unknown command "${cmd}". Run "hivefloor help".
+`);
+        return 2;
+    }
+  } catch (e) {
+    if (e instanceof ApiError) ctx.err(`hivefloor: ${e.message}
+`);
+    else ctx.err(`hivefloor: ${e.message}
+`);
+    return 1;
+  }
+}
+export {
+  HELP,
+  VERSION,
+  run
+};

package/dist/connect-ZJ4JXBAJ.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  connect,
+  connectAgent,
+  resolveHost
+} from "./chunk-TIR4CV3P.js";
+import "./chunk-FPJNGKT5.js";
+import "./chunk-QBBKGORP.js";
+import "./chunk-X2KH6AR4.js";
+import "./chunk-BLLPDPTL.js";
+import "./chunk-QLMLB7RB.js";
+import "./chunk-QPAFN47B.js";
+import "./chunk-K2IRTZH5.js";
+import "./chunk-LX5A25O6.js";
+import "./chunk-NRJONTFT.js";
+import "./chunk-XAXKZ572.js";
+import "./chunk-XPGL7VYE.js";
+import "./chunk-QGULSOQ2.js";
+import "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
+export {
+  connect,
+  connectAgent,
+  resolveHost
+};

package/dist/control-6GHTZQJV.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  FULL_POWER_MEANS,
+  control,
+  describeFull
+} from "./chunk-HW3KRNCO.js";
+import "./chunk-5XXYQQG6.js";
+import "./chunk-4G362W6G.js";
+import "./chunk-X2KH6AR4.js";
+import "./chunk-QPAFN47B.js";
+import "./chunk-KQMPCV57.js";
+import "./chunk-L6EFW2SJ.js";
+import "./chunk-LX5A25O6.js";
+import "./chunk-NRJONTFT.js";
+import "./chunk-XPGL7VYE.js";
+import "./chunk-QGULSOQ2.js";
+import "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
+export {
+  FULL_POWER_MEANS,
+  control,
+  describeFull
+};

package/dist/{disconnect-MKRHK4CX.js → disconnect-3T25NTKX.js}

@@ -1,55 +1,63 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   removeCliCopy,
   removeMachineHooks
-} from "./chunk-GT3HFFT4.js";
+} from "./chunk-5XXYQQG6.js";
+import "./chunk-4G362W6G.js";
 import {
-  claudeJson,
   geminiSettings,
-  readManifest,
-  removeClaude,
-  removeCodex,
   removeCursor,
   removeGemini,
   removeGrok,
-  removeRcLine,
-  updateManifest
-} from "./chunk-QHYZBHXO.js";
+  removeRcLine
+} from "./chunk-QBBKGORP.js";
 import {
-  REAL_TOOLS,
-  TOOL_LABEL,
-  isTool
-} from "./chunk-2IMJECYD.js";
-import {
-  checkUnknownFlags,
-  flagStr
-} from "./chunk-TKMIV7BG.js";
+  claudeJson,
+  readManifest,
+  removeClaude,
+  removeCodex,
+  updateManifest
+} from "./chunk-X2KH6AR4.js";
 import {
+  KEYCHAIN_SERVICE,
   deleteCredentials,
   readCredentials,
   uninstallService
-} from "./chunk-PDXYOREI.js";
-import "./chunk-UJ4BQFWV.js";
+} from "./chunk-QLMLB7RB.js";
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-QPAFN47B.js";
+import "./chunk-KQMPCV57.js";
+import "./chunk-L6EFW2SJ.js";
 import {
   readMachine,
   removeMachineFile
-} from "./chunk-T7TG6WA4.js";
+} from "./chunk-LX5A25O6.js";
 import {
   apiRequest
-} from "./chunk-PY74LT2W.js";
+} from "./chunk-NRJONTFT.js";
+import "./chunk-XAXKZ572.js";
 import {
   ConfigError,
+  REAL_TOOLS,
+  TOOL_LABEL,
+  isTool,
   machineSpoolFile,
   manifestFile,
   removeFile,
   serviceLogFile,
   serviceStateFile
-} from "./chunk-VNCQFFQO.js";
+} from "./chunk-XPGL7VYE.js";
 import {
-  normalizeHost,
-  runCmd
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
+  hostFromFlag,
+  runCmd,
+  sameOrigin
+} from "./chunk-QGULSOQ2.js";
+import "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
 
 // src/disconnect.ts
 import fs from "fs";
@@ -68,13 +76,13 @@ async function disconnect(ctx, p) {
     return 2;
   }
   const hostFlag = flagStr(p, "host");
-  const host = hostFlag ? normalizeHost(hostFlag) : void 0;
+  const host = hostFlag ? hostFromFlag(ctx, hostFlag) : void 0;
   const tools = toolFlag ? [toolFlag] : REAL_TOOLS;
   const manifest = readManifest();
   const lines = [];
   const warnings = [];
   const machine = readMachine();
-  if (machine && !toolFlag) {
+  if (machine && !toolFlag && (host === void 0 || sameOrigin(machine.host, host))) {
     if (!machine.revoked) {
       try {
         const r = await apiRequest(ctx, machine.host, "/api/v1/machine/disconnect", { method: "POST", token: machine.token, body: {}, timeoutMs: 8e3 });
@@ -95,14 +103,26 @@ async function disconnect(ctx, p) {
     lines.push("Machine token and state removed");
   }
   const keepHooks = machine !== void 0 && !machine.revoked && toolFlag !== void 0;
-  for (const tool of tools) {
+  const credHosts = Object.keys(readCredentials().hosts);
+  const otherHosts = host === void 0 ? [] : credHosts.filter((h) => h !== host && !sameOrigin(h, host));
+  const disconnectsStoredHost = host !== void 0 && credHosts.some((h) => h === host || sameOrigin(h, host));
+  const lastHost = disconnectsStoredHost && otherHosts.length === 0;
+  const ownedHere = (owner) => host === void 0 || lastHost || typeof owner === "string" && owner.length > 0 && sameOrigin(owner, host);
+  const dropping = tools.filter((tool) => toolFlag !== void 0 || ownedHere(manifest.tools[tool]?.host));
+  const owners = Object.values(manifest.tools).map((e) => e?.host).filter((h) => typeof h === "string" && h.length > 0);
+  const rcOwnedHere = host === void 0 || lastHost || owners.length > 0 && owners.every((o) => sameOrigin(o, host));
+  const mixedOwners = owners.length > 1 && owners.some((o) => !sameOrigin(o, owners[0]));
+  if (host !== void 0 && !rcOwnedHere && mixedOwners && manifest.rc.length > 0) {
+    warnings.push(`shell export kept while tools point at more than one host; "hivefloor token" follows the last host, so it can still be a token for ${host} after this disconnect`);
+  }
+  for (const tool of dropping) {
     const entry = manifest.tools[tool];
     const viaCli = entry?.mcp === "cli";
     const legacyBak = tool === "claude" ? fs.existsSync(claudeJson() + ".hivefloor.bak") : tool === "gemini" ? fs.existsSync(geminiSettings() + ".hivefloor.bak") : false;
     const viaFile = entry ? entry.mcp === "file" : legacyBak;
     let r;
     try {
-      r = tool === "claude" ? await removeClaude(ctx, viaCli, keepHooks, viaFile) : tool === "codex" ? await removeCodex(ctx, viaCli, keepHooks) : tool === "cursor" ? await removeCursor() : tool === "gemini" ? await removeGemini(ctx, viaCli, viaFile) : await removeGrok(ctx, viaCli);
+      r = tool === "claude" ? await removeClaude(ctx, viaCli, keepHooks, viaFile) : tool === "codex" ? await removeCodex(ctx, viaCli, keepHooks) : tool === "cursor" ? await removeCursor() : tool === "gemini" ? await removeGemini(ctx, viaCli, viaFile) : await removeGrok(ctx, viaCli, viaFile);
     } catch (e) {
       if (!(e instanceof ConfigError)) throw e;
       warnings.push(e.message);
@@ -112,21 +132,22 @@ async function disconnect(ctx, p) {
     warnings.push(...r.warnings);
     if (viaCli && r.lines.length === 0) warnings.push(`${TOOL_LABEL[tool]}: could not run its CLI to remove the "hivefloor" MCP server; remove it by hand`);
   }
-  const n = await deleteCredentials(host, toolFlag);
+  const { removed: n, leftover } = await deleteCredentials(host, toolFlag);
   if (n > 0) lines.push(`Removed ${n} stored token${n === 1 ? "" : "s"}`);
+  for (const a of leftover) warnings.push(`keychain entry ${a} (service ${KEYCHAIN_SERVICE}) was not removed; delete it in your OS keychain app`);
   const left = Object.keys(readCredentials().hosts).length > 0;
-  if (!toolFlag || !left) {
+  if ((!toolFlag || !left) && rcOwnedHere) {
     const files = readManifest().rc;
     for (const f of files) if (removeRcLine(f)) lines.push(`Shell: removed the token export from ${f}`);
     updateManifest((m2) => m2.rc = []);
   }
   updateManifest((m2) => {
-    for (const t of tools) delete m2.tools[t];
+    for (const t of dropping) delete m2.tools[t];
   });
   const m = readManifest();
   if (Object.keys(m.tools).length === 0 && m.rc.length === 0) removeFile(manifestFile());
-  if (lines.length === 0) ctx.out("Nothing to remove: no Hivefloor entries found.\n");
-  else {
+  if (lines.length === 0 && warnings.length === 0) ctx.out("Nothing to remove: no HiveFloor entries found.\n");
+  else if (lines.length > 0) {
     ctx.out("Disconnected:\n");
     for (const l of lines) ctx.out(`  ${l}
 `);