@mifune/agro 0.11.0 → 0.12.1

package/dist/oh.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { fileURLToPath } from "node:url";
-import { dirname as dirname8, join as join10, resolve as resolve10 } from "node:path";
-import { existsSync as existsSync16, mkdtempSync as mkdtempSync3, readFileSync as readFileSync11, rmSync as rmSync3 } from "node:fs";
+import { dirname as dirname10, join as join14, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync20, mkdtempSync as mkdtempSync4, readFileSync as readFileSync12, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 
 // src/commands/update.ts
@@ -230,6 +230,17 @@ function resolveRegistryHome(env = process.env, home = homedir(), warn) {
   if (configured !== void 0) return { path: resolve(configured), configured: true };
   return { path: home, configured: false };
 }
+function generationUserStateHome(generation, env, home, warn) {
+  const configured = aliasedEnvValue(env, "HOME", warn);
+  if (configured !== void 0) return resolve(configured);
+  return join(home, GENERATIONS[generation].userStateDir);
+}
+function resolveAgroUserStateHome(env = process.env, home = homedir(), warn) {
+  return generationUserStateHome("agro", env, home, warn);
+}
+function resolveLegacyUserStateHome(env = process.env, home = homedir(), warn) {
+  return generationUserStateHome("legacy", env, home, warn);
+}
 function resolveUserStateHome(env = process.env, home = homedir(), warn) {
   const configured = aliasedEnvValue(env, "HOME", warn);
   if (configured !== void 0) return resolve(configured);
@@ -1959,8 +1970,8 @@ function redact(token) {
 async function ask(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    return await new Promise((resolve11) => {
-      rl.question(`  ${question} `, (answer) => resolve11(answer.trim()));
+    return await new Promise((resolve15) => {
+      rl.question(`  ${question} `, (answer) => resolve15(answer.trim()));
     });
   } finally {
     rl.close();
@@ -1972,7 +1983,7 @@ async function askSecret(question) {
   process.stdin.setRawMode(true);
   process.stdin.resume();
   const bytes = [];
-  return await new Promise((resolve11) => {
+  return await new Promise((resolve15) => {
     const cleanup = () => {
       try {
         process.stdin.setRawMode(false);
@@ -1990,7 +2001,7 @@ async function askSecret(question) {
         } else if (byte === 13 || byte === 10) {
           cleanup();
           process.stdout.write("\n");
-          resolve11(Buffer.from(bytes).toString("utf8").trim());
+          resolve15(Buffer.from(bytes).toString("utf8").trim());
           return;
         } else if (byte === 127 || byte === 8) {
           if (bytes.length > 0) {
@@ -2040,10 +2051,10 @@ async function askSecretPiped(question) {
   };
   process.on("SIGINT", onSigint);
   try {
-    return await new Promise((resolve11) => {
+    return await new Promise((resolve15) => {
       rl.question(`  ${question} `, (answer) => {
         process.stdout.write("\n");
-        resolve11(answer.trim());
+        resolve15(answer.trim());
       });
     });
   } finally {
@@ -2976,6 +2987,20 @@ function defaultIdentity() {
   return { name: info.username, uid: info.uid };
 }
 
+// src/lib/execution/status.ts
+var RUNTIME_ABSENT_STATUS = "no container runtime";
+async function resolveTargetStatus(target) {
+  try {
+    return await target.status();
+  } catch (err) {
+    if (err instanceof ExecutionSpawnError) return RUNTIME_ABSENT_STATUS;
+    throw err;
+  }
+}
+function runtimeIsAbsent(status) {
+  return status === RUNTIME_ABSENT_STATUS;
+}
+
 // src/lib/execution/index.ts
 function resolveExecutionTarget(opts) {
   if (runningInsideSandbox(opts.env ?? process.env)) {
@@ -3984,6 +4009,11 @@ async function runSandboxList(opts, io) {
   return 0;
 }
 
+// src/commands/harness.ts
+import { existsSync as existsSync18 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { delimiter as delimiter2, join as join12, resolve as resolve12 } from "node:path";
+
 // src/lib/docs.ts
 var SOURCE_DOCS_BASE = "https://github.com/mifunedev/agro/blob/main/";
 function sourceDocsUrl(docsPath) {
@@ -3994,7 +4024,194 @@ function sourceDocsUrl(docsPath) {
   return new URL(segments.map(encodeURIComponent).join("/"), SOURCE_DOCS_BASE).toString();
 }
 
+// src/lib/host-config.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename6, dirname as dirname8, isAbsolute as isAbsolute2, join as join10, resolve as resolve10 } from "node:path";
+var HOST_CONFIG_MODE = 420;
+function hostConfigPath(env = process.env, home) {
+  return join10(resolveAgroUserStateHome(env, home), GENERATIONS.agro.configFile);
+}
+function legacyHostConfigPath(env = process.env, home) {
+  return join10(resolveLegacyUserStateHome(env, home), GENERATIONS.legacy.configFile);
+}
+function readableHostConfigPath(env, home) {
+  const path4 = hostConfigPath(env, home);
+  if (existsSync16(path4)) return path4;
+  const legacy = legacyHostConfigPath(env, home);
+  return existsSync16(legacy) ? legacy : path4;
+}
+function defaultHarnessRoot(env = process.env, home) {
+  return resolveAgroUserStateHome(env, home);
+}
+function validateHostConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${GENERATIONS.agro.configFile}: must contain a JSON object`);
+  }
+  const record = value;
+  if (record.version !== void 0 && record.version !== 1) {
+    throw fieldError2("version", "must be 1");
+  }
+  const harnessRoot = record.harnessRoot;
+  if (harnessRoot !== void 0) {
+    if (typeof harnessRoot !== "string" || harnessRoot === "") {
+      throw fieldError2("harnessRoot", "must be a non-empty string");
+    }
+    if (!isAbsolute2(harnessRoot)) {
+      throw fieldError2("harnessRoot", "must be an absolute path");
+    }
+  }
+  const hostHarnesses = record.hostHarnesses;
+  if (hostHarnesses !== void 0) validateReceipts(hostHarnesses, "hostHarnesses", "harness");
+  const hostTools = record.hostTools;
+  if (hostTools !== void 0) validateReceipts(hostTools, "hostTools", "tool");
+  return { ...record, version: 1 };
+}
+function absoluteField(value, path4) {
+  if (typeof value !== "string" || value === "") {
+    throw fieldError2(path4, "must be a non-empty string");
+  }
+  if (!isAbsolute2(value)) throw fieldError2(path4, "must be an absolute path");
+  return value;
+}
+function validateReceipts(value, field, noun) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw fieldError2(field, `must be a JSON object keyed by ${noun} id`);
+  }
+  for (const [id, receipt] of Object.entries(value)) {
+    if (id === "") throw fieldError2(field, `must use a non-empty ${noun} id as each key`);
+    const at = `${field}.${id}`;
+    if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) {
+      throw fieldError2(at, "must be a JSON object");
+    }
+    const entry = receipt;
+    absoluteField(entry.prefix, `${at}.prefix`);
+    absoluteField(entry.binPath, `${at}.binPath`);
+    if (typeof entry.binary !== "string" || entry.binary === "") {
+      throw fieldError2(`${at}.binary`, "must be a non-empty string");
+    }
+    if (typeof entry.installedAt !== "string" || entry.installedAt === "") {
+      throw fieldError2(`${at}.installedAt`, "must be a non-empty string");
+    }
+    if (entry.workspaceRoot !== void 0) {
+      absoluteField(entry.workspaceRoot, `${at}.workspaceRoot`);
+    }
+  }
+}
+function readHostConfig(env = process.env, home) {
+  const path4 = readableHostConfigPath(env, home);
+  if (!existsSync16(path4)) return { version: 1 };
+  let raw;
+  try {
+    raw = readFileSync11(path4, "utf8");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`could not read ${path4}: ${detail}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`${basename6(path4)} is not valid JSON: ${path4}`);
+  }
+  return validateHostConfig(parsed);
+}
+function writeHostConfig(config, env = process.env, home) {
+  const path4 = hostConfigPath(env, home);
+  const validated = validateHostConfig({ ...config, version: 1 });
+  const body = `${JSON.stringify(validated, null, 2)}
+`;
+  const tmp = `${path4}.tmp.${process.pid}`;
+  mkdirSync7(dirname8(path4), { recursive: true });
+  try {
+    writeFileSync8(tmp, body, { mode: HOST_CONFIG_MODE, encoding: "utf8" });
+    renameSync5(tmp, path4);
+    retireLegacyHostConfig(env, home, path4);
+  } catch (error) {
+    try {
+      unlinkSync5(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function resolveHarnessRoot(explicit, env = process.env, home) {
+  if (typeof explicit === "string" && explicit !== "") return resolve10(explicit);
+  const configured = readHostConfig(env, home).harnessRoot;
+  if (typeof configured === "string" && configured !== "") return resolve10(configured);
+  return defaultHarnessRoot(env, home);
+}
+function retireLegacyHostConfig(env, home, written) {
+  const legacy = legacyHostConfigPath(env, home);
+  if (legacy === written || !existsSync16(legacy)) return;
+  unlinkSync5(legacy);
+}
+function fieldError2(path4, requirement) {
+  return new Error(`${GENERATIONS.agro.configFile}: ${path4} ${requirement}`);
+}
+
+// src/lib/host-workspace.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readdirSync as readdirSync4, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
+import { dirname as dirname9, join as join11, resolve as resolve11 } from "node:path";
+var AGRO_REPO_URL = "https://github.com/mifunedev/agro.git";
+var IGNORABLE_ENTRIES = [
+  REGISTRY_SUBDIR,
+  "escalate",
+  GENERATIONS.agro.configFile,
+  GENERATIONS.legacy.configFile
+];
+function isIgnorableEntry(name) {
+  return name.startsWith(".") || IGNORABLE_ENTRIES.includes(name);
+}
+function assertCloned(result, root) {
+  const status = result.error ? result.error.code ?? "spawn failed" : result.status;
+  if (result.error || result.status !== 0) {
+    throw new Error(`could not clone ${AGRO_REPO_URL} into ${root} (exit status ${String(status)})`);
+  }
+}
+function cloneInto(target, run, root) {
+  assertCloned(run("git", ["clone", AGRO_REPO_URL, target], { stdio: "inherit" }), root);
+}
+function cloneThroughStaging(root, run) {
+  const staging = mkdtempSync3(join11(dirname9(root), "agro-clone-"));
+  try {
+    const checkout = join11(staging, "agro");
+    cloneInto(checkout, run, root);
+    for (const name of readdirSync4(checkout)) {
+      const destination = join11(root, name);
+      if (existsSync17(destination)) {
+        throw new Error(`could not move ${name} into ${root} \u2014 the path already exists`);
+      }
+      renameSync6(join11(checkout, name), destination);
+    }
+  } finally {
+    rmSync3(staging, { recursive: true, force: true });
+  }
+}
+function ensureHostWorkspace(path4, run = spawnRunner) {
+  const root = resolve11(path4);
+  if (existsSync17(join11(root, ".git"))) return { root, action: "reused" };
+  const stats = statSync5(root, { throwIfNoEntry: false });
+  if (stats === void 0) {
+    mkdirSync8(dirname9(root), { recursive: true });
+    cloneInto(root, run, root);
+    return { root, action: "cloned" };
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`${root} exists and is not a directory \u2014 choose another harness root`);
+  }
+  const blocking = readdirSync4(root).filter((name) => !isIgnorableEntry(name));
+  if (blocking.length > 0) {
+    throw new Error(
+      `${root} holds files but no git checkout (${blocking.sort().join(", ")}) \u2014 choose an empty directory or an existing AGRO checkout`
+    );
+  }
+  cloneThroughStaging(root, run);
+  return { root, action: "cloned" };
+}
+
 // src/lib/harnesses/catalog.ts
+var SANDBOX_HARNESS_PREFIX = "/home/sandbox/.local";
+var HARNESS_PREFIX_TOKEN = "{{prefix}}";
 var HARNESS_CATALOG = [
   {
     id: "claude-code",
@@ -4003,13 +4220,14 @@ var HARNESS_CATALOG = [
     installArgv: [
       "npm",
       "--prefix",
-      "/home/sandbox/.local",
+      HARNESS_PREFIX_TOKEN,
       "install",
       "-g",
       "@anthropic-ai/claude-code"
     ],
     installUser: "sandbox",
     verifyArgv: ["claude", "--version"],
+    uninstallArgv: ["npm", "--prefix", HARNESS_PREFIX_TOKEN, "uninstall", "-g", "@anthropic-ai/claude-code"],
     docsPath: "docs/harnesses/claude-code.md",
     kind: "installable"
   },
@@ -4020,13 +4238,14 @@ var HARNESS_CATALOG = [
     installArgv: [
       "npm",
       "--prefix",
-      "/home/sandbox/.local",
+      HARNESS_PREFIX_TOKEN,
       "install",
       "-g",
       "@openai/codex"
     ],
     installUser: "sandbox",
     verifyArgv: ["codex", "--version"],
+    uninstallArgv: ["npm", "--prefix", HARNESS_PREFIX_TOKEN, "uninstall", "-g", "@openai/codex"],
     docsPath: "docs/harnesses/codex.md",
     kind: "installable"
   },
@@ -4037,7 +4256,7 @@ var HARNESS_CATALOG = [
     installArgv: [
       "npm",
       "--prefix",
-      "/home/sandbox/.local",
+      HARNESS_PREFIX_TOKEN,
       "install",
       "-g",
       "--ignore-scripts",
@@ -4045,6 +4264,7 @@ var HARNESS_CATALOG = [
     ],
     installUser: "sandbox",
     verifyArgv: ["pi", "--version"],
+    uninstallArgv: ["npm", "--prefix", HARNESS_PREFIX_TOKEN, "uninstall", "-g", "@earendil-works/pi-coding-agent"],
     docsPath: "docs/harnesses/pi.md",
     kind: "installable"
   },
@@ -4055,13 +4275,14 @@ var HARNESS_CATALOG = [
     installArgv: [
       "npm",
       "--prefix",
-      "/home/sandbox/.local",
+      HARNESS_PREFIX_TOKEN,
       "install",
       "-g",
       "opencode-ai"
     ],
     installUser: "sandbox",
     verifyArgv: ["opencode", "--version"],
+    uninstallArgv: ["npm", "--prefix", HARNESS_PREFIX_TOKEN, "uninstall", "-g", "opencode-ai"],
     docsPath: "docs/harnesses/opencode.md",
     kind: "installable"
   },
@@ -4072,10 +4293,11 @@ var HARNESS_CATALOG = [
     installArgv: [
       "bash",
       "-lc",
-      'curl -fsSL https://x.ai/cli/install.sh | GROK_BIN_DIR="$HOME/.local/bin" bash -s 0.2.39 && rm -f "$HOME/.local/bin/agent"'
+      `curl -fsSL https://x.ai/cli/install.sh | GROK_BIN_DIR="${HARNESS_PREFIX_TOKEN}/bin" bash -s 0.2.39 && rm -f "${HARNESS_PREFIX_TOKEN}/bin/agent"`
     ],
     installUser: "sandbox",
     verifyArgv: ["grok", "--version"],
+    uninstallArgv: ["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/grok`],
     docsPath: "docs/harnesses/grok-build.md",
     kind: "installable"
   },
@@ -4086,10 +4308,11 @@ var HARNESS_CATALOG = [
     installArgv: [
       "bash",
       "-lc",
-      `curl -fsSL https://hermes-agent.nousresearch.com/install.sh | HERMES_INSTALL_DIR="$HOME/.local/lib/hermes-agent" bash -s -- --skip-setup --skip-browser && uv pip install --python "$HOME/.local/lib/hermes-agent/venv/bin/python" 'hermes-agent[slack,teams,web,pty]'`
+      `curl -fsSL https://hermes-agent.nousresearch.com/install.sh | HERMES_INSTALL_DIR="${HARNESS_PREFIX_TOKEN}/lib/hermes-agent" bash -s -- --skip-setup --skip-browser && uv pip install --python "${HARNESS_PREFIX_TOKEN}/lib/hermes-agent/venv/bin/python" 'hermes-agent[slack,teams,web,pty]'`
     ],
     installUser: "sandbox",
     verifyArgv: ["hermes", "--version"],
+    uninstallArgv: ["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/hermes`, `${HARNESS_PREFIX_TOKEN}/lib/hermes-agent`],
     docsPath: "docs/harnesses/hermes.md",
     kind: "installable"
   },
@@ -4100,10 +4323,11 @@ var HARNESS_CATALOG = [
     installArgv: [
       "bash",
       "-lc",
-      'set -o pipefail; curl -fsSL https://dev.meta.ai/install.sh | MUSE_INSTALL_DIR="$HOME/.local/bin" MUSE_NO_MODIFY_PATH=1 MUSE_LOGIN=0 bash'
+      `set -o pipefail; curl -fsSL https://dev.meta.ai/install.sh | MUSE_INSTALL_DIR="${HARNESS_PREFIX_TOKEN}/bin" MUSE_NO_MODIFY_PATH=1 MUSE_LOGIN=0 bash`
     ],
     installUser: "sandbox",
     verifyArgv: ["muse", "--version"],
+    uninstallArgv: ["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/muse`],
     docsPath: "docs/harnesses/muse-code.md",
     kind: "installable"
   },
@@ -4114,10 +4338,11 @@ var HARNESS_CATALOG = [
     installArgv: [
       "bash",
       "-lc",
-      'set -o pipefail; curl -fsSL https://antigravity.google/cli/install.sh | bash -s -- --dir "$HOME/.local/bin"'
+      `set -o pipefail; curl -fsSL https://antigravity.google/cli/install.sh | bash -s -- --dir "${HARNESS_PREFIX_TOKEN}/bin"`
     ],
     installUser: "sandbox",
     verifyArgv: ["agy", "--version"],
+    uninstallArgv: ["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/agy`],
     docsPath: "docs/harnesses/antigravity-cli.md",
     kind: "installable"
   },
@@ -4128,6 +4353,7 @@ var HARNESS_CATALOG = [
     installArgv: ["npx", "--yes", "t3", "--version"],
     installUser: "sandbox",
     verifyArgv: ["npx", "--no-install", "t3", "--version"],
+    uninstallArgv: null,
     docsPath: "docs/harnesses/t3code.md",
     kind: "on-demand"
   }
@@ -4138,6 +4364,21 @@ function findHarness(id) {
 function harnessIds() {
   return HARNESS_CATALOG.map((h) => h.id);
 }
+function substitute(argv, prefix) {
+  return argv.map((part) => part.split(HARNESS_PREFIX_TOKEN).join(prefix));
+}
+function resolveInstallArgv(entry, prefix) {
+  return substitute(entry.installArgv, prefix);
+}
+function resolveVerifyArgv(entry, prefix) {
+  return substitute(entry.verifyArgv, prefix);
+}
+function resolveUninstallArgv(entry, prefix) {
+  return entry.uninstallArgv === null ? null : substitute(entry.uninstallArgv, prefix);
+}
+function harnessBinPath(prefix) {
+  return `${prefix}/bin`;
+}
 
 // src/commands/harness.ts
 var PROBE_TIMEOUT_MS = 15e3;
@@ -4153,11 +4394,31 @@ function targetFor(root, run, env) {
     ...env ? { env } : {}
   });
 }
-async function probeInstalled(target, entry, env) {
+function hostPrefix(home) {
+  return join12(home, ".local");
+}
+function pathEntries(env) {
+  return (env.PATH ?? "").split(delimiter2).filter((part) => part !== "");
+}
+function onPath(prefix, env) {
+  return pathEntries(env).includes(harnessBinPath(prefix));
+}
+function hostTargetFor(root, prefix, run, env) {
+  const path4 = [harnessBinPath(prefix), ...pathEntries(env)].join(delimiter2);
+  return new LocalExecutionTarget({
+    projectRoot: root,
+    run,
+    env: { ...env, PATH: path4 }
+  });
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function probeInstalled(target, entry, prefix, user, env) {
   try {
     const r = await target.exec({
-      argv: [...entry.verifyArgv],
-      user: "sandbox",
+      argv: resolveVerifyArgv(entry, prefix),
+      ...user ? { user } : {},
       stdio: "capture",
       timeoutMs: PROBE_TIMEOUT_MS,
       ...env ? { env } : {}
@@ -4168,33 +4429,58 @@ async function probeInstalled(target, entry, env) {
     throw err;
   }
 }
-async function collectStates(root, run, env, only) {
+function stateOf(entry, installed, location) {
+  return {
+    id: entry.id,
+    title: entry.title,
+    binary: entry.binary,
+    kind: entry.kind,
+    installed,
+    location,
+    docs: sourceDocsUrl(entry.docsPath)
+  };
+}
+function probeableHost(env, home) {
+  let root;
+  try {
+    root = resolveHarnessRoot(void 0, env);
+  } catch {
+    return void 0;
+  }
+  const prefix = hostPrefix(home);
+  if (!existsSync18(join12(root, ".git")) && !existsSync18(prefix)) return void 0;
+  return { root, prefix };
+}
+async function collectStates(root, run, home, env, only) {
   const entries = only ? [...only] : [...HARNESS_CATALOG];
   const target = targetFor(root, run, env);
-  let reachable = false;
-  try {
-    reachable = isReachable(await target.status());
-  } catch (err) {
-    if (!(err instanceof ExecutionSpawnError)) throw err;
+  const reachable = isReachable(await resolveTargetStatus(target));
+  if (reachable) {
+    const states2 = [];
+    for (const entry of entries) {
+      const installed = await probeInstalled(target, entry, SANDBOX_HARNESS_PREFIX, "sandbox");
+      states2.push(stateOf(entry, installed, installed === null ? "unknown" : "sandbox"));
+    }
+    return { states: states2 };
+  }
+  const host = probeableHost(env ?? process.env, home);
+  if (host === void 0) {
+    return { states: entries.map((entry) => stateOf(entry, null, "unknown")) };
   }
+  const hostTarget = hostTargetFor(host.root, host.prefix, run, env ?? process.env);
   const states = [];
   for (const entry of entries) {
-    states.push({
-      id: entry.id,
-      title: entry.title,
-      binary: entry.binary,
-      kind: entry.kind,
-      installed: reachable ? await probeInstalled(target, entry) : null,
-      docs: sourceDocsUrl(entry.docsPath)
-    });
+    const installed = await probeInstalled(hostTarget, entry, host.prefix, void 0);
+    states.push(stateOf(entry, installed, installed === null ? "unknown" : "host"));
   }
-  return states;
+  return { states, hostPrefix: host.prefix };
 }
 function cell(value, absent) {
   if (value === null) return absent;
   return value ? "yes" : "no";
 }
-function renderTable(states, io, bin) {
+function renderTable(collected, io, bin) {
+  const states = collected.states;
   const header2 = ["HARNESS", "KIND", "INSTALLED"];
   const rows = states.map((s) => [s.id, s.kind, cell(s.installed, "?")]);
   const widths = header2.map(
@@ -4203,6 +4489,14 @@ function renderTable(states, io, bin) {
   const line = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("  ").trimEnd() + "\n";
   io.stdout(line(header2));
   for (const row of rows) io.stdout(line(row));
+  if (states.some((s) => s.location === "host")) {
+    io.stdout(
+      `
+INSTALLED reports the host prefix ${collected.hostPrefix} \u2014 the sandbox is not running.
+`
+    );
+    return;
+  }
   if (states.some((s) => s.installed === null)) {
     io.stdout(`
 INSTALLED is \`?\` \u2014 the sandbox is not running. Start it with \`${bin} sandbox\`.
@@ -4212,12 +4506,12 @@ INSTALLED is \`?\` \u2014 the sandbox is not running. Start it with \`${bin} san
 async function runHarnessList(opts, io) {
   const run = opts.run ?? spawnRunner;
   const root = resolveProjectRoot(opts.cwd);
-  const states = await collectStates(root, run, opts.env);
+  const collected = await collectStates(root, run, homeOf(opts), opts.env);
   if (opts.json) {
-    io.stdout(`${JSON.stringify(states, null, 2)}
+    io.stdout(`${JSON.stringify(collected.states, null, 2)}
 `);
   } else {
-    renderTable(states, io, opts.bin);
+    renderTable(collected, io, opts.bin);
   }
   return 0;
 }
@@ -4238,24 +4532,23 @@ async function runHarnessStatus(name, opts, io) {
     only = findHarness(name);
     if (!only) return unknownHarness(name, io, opts.bin);
   }
-  const states = await collectStates(root, run, opts.env, only ? [only] : void 0);
+  const collected = await collectStates(root, run, homeOf(opts), opts.env, only ? [only] : void 0);
   if (opts.json) {
-    io.stdout(`${JSON.stringify(only ? states[0] : states, null, 2)}
+    io.stdout(`${JSON.stringify(only ? collected.states[0] : collected.states, null, 2)}
 `);
   } else {
-    renderTable(states, io, opts.bin);
+    renderTable(collected, io, opts.bin);
   }
   return 0;
 }
 function hermesTargetRoot(target) {
   return target.kind === "docker-compose" ? "/home/sandbox/harness" : target.workspace.targetRoot;
 }
-async function reconcileHermes(target, io, bin) {
-  const root = hermesTargetRoot(target);
+async function reconcileHermes(target, io, bin, user, root = hermesTargetRoot(target)) {
   const result = await target.exec({
     argv: remoteControlDirScript(root, "scripts/link-providers.sh", ["--init", "--hermes-only"]),
     env: aliasedEnvPair("PROJECT_ROOT", root),
-    user: "sandbox",
+    ...user ? { user } : {},
     stdio: "inherit"
   });
   if (result.exitCode !== 0) {
@@ -4264,6 +4557,245 @@ async function reconcileHermes(target, io, bin) {
   }
   return result.exitCode;
 }
+function unreachableReason(status) {
+  return runtimeIsAbsent(status) ? "No container runtime is on PATH." : `The sandbox is not running (${status}).`;
+}
+function sandboxRefusal(bin, status) {
+  if (runtimeIsAbsent(status)) {
+    return `${bin} harness: no container runtime is on PATH.
+`;
+  }
+  return `${bin} harness: the sandbox is not running (${status}).
+Start it with \`${bin} sandbox\`, then re-run this command.
+`;
+}
+function homeOf(opts) {
+  return (opts.homedir ?? homedir2)();
+}
+function isInteractive(opts) {
+  return opts.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true);
+}
+async function installOnHost(entry, opts, io, run, status) {
+  const bin = opts.bin;
+  const env = opts.env ?? process.env;
+  const flagged = opts.host === true || opts.path !== void 0;
+  if (!flagged && !isInteractive(opts)) {
+    io.stderr(
+      sandboxRefusal(bin, status) + `Or install on the host with \`${bin} harness install ${entry.id} --host\`.
+`
+    );
+    return 1;
+  }
+  if (entry.kind === "on-demand") {
+    io.stdout(`${entry.id}: no installation is needed \u2014 npx fetches it at each run
+`);
+    return 0;
+  }
+  let root;
+  let recorded;
+  try {
+    recorded = readHostConfig(env).harnessRoot;
+    root = resolveHarnessRoot(opts.path, env);
+  } catch (err) {
+    io.stderr(`${bin} harness: ${messageOf(err)}
+`);
+    return 1;
+  }
+  const sticky = opts.path === void 0 && recorded !== void 0 && recorded !== "";
+  if (!flagged) {
+    const ask2 = io.ask ?? ask;
+    const answer = (await ask2(
+      `${unreachableReason(status)} Install ${entry.title} on the host? [y/N]`
+    )).trim().toLowerCase();
+    if (!/^y/.test(answer)) {
+      io.stderr(sandboxRefusal(bin, status));
+      return 1;
+    }
+    if (!sticky) {
+      const chosen = (await ask2(`Harness root [${root}]:`)).trim();
+      if (chosen !== "") root = resolve12(chosen);
+    }
+  }
+  if (sticky) io.stdout(`using the recorded harness root ${root}
+`);
+  try {
+    if (!existsSync18(join12(root, ".git"))) io.stdout(`cloning ${AGRO_REPO_URL} into ${root}\u2026
+`);
+    const workspace = ensureHostWorkspace(root, run);
+    root = workspace.root;
+    io.stdout(
+      workspace.action === "cloned" ? `host workspace cloned into ${root}
+` : `host workspace reused at ${root}
+`
+    );
+  } catch (err) {
+    io.stderr(`${bin} harness: ${messageOf(err)}
+`);
+    return 1;
+  }
+  const prefix = hostPrefix(homeOf(opts));
+  const target = hostTargetFor(root, prefix, run, env);
+  const hermes = entry.id === "hermes";
+  const installEnv = hermes ? {
+    ...aliasedEnvPair("PROJECT_ROOT", root),
+    HERMES_HOME: `${root}/.hermes`
+  } : void 0;
+  if (hermes) {
+    const code = await reconcileHermes(target, io, bin, void 0, root);
+    if (code !== 0) return code;
+  }
+  if (await probeInstalled(target, entry, prefix, void 0, installEnv) === true) {
+    io.stdout(`${entry.id}: already installed (${entry.binary})
+`);
+    return 0;
+  }
+  io.stdout(`installing ${entry.title} on the host\u2026
+`);
+  const r = await target.exec({
+    argv: resolveInstallArgv(entry, prefix),
+    stdio: "inherit",
+    ...installEnv ? { env: installEnv } : {}
+  });
+  if (r.exitCode !== 0) {
+    io.stderr(`${bin} harness: installing ${entry.id} failed (exit ${r.exitCode}).
+`);
+    return r.exitCode;
+  }
+  if (hermes) {
+    if (await probeInstalled(target, entry, prefix, void 0, installEnv) !== true) {
+      io.stderr(`${bin} harness: Hermes installation finished but executable verification failed.
+`);
+      return 1;
+    }
+    const code = await reconcileHermes(target, io, bin, void 0, root);
+    if (code !== 0) return code;
+  }
+  const receipt = {
+    prefix,
+    binary: entry.binary,
+    binPath: harnessBinPath(prefix),
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceRoot: root
+  };
+  try {
+    const config = readHostConfig(env);
+    writeHostConfig(
+      {
+        ...config,
+        harnessRoot: root,
+        hostHarnesses: { ...config.hostHarnesses ?? {}, [entry.id]: receipt }
+      },
+      env
+    );
+  } catch (err) {
+    io.stderr(`${bin} harness: could not record the install: ${messageOf(err)}
+`);
+    return 1;
+  }
+  io.stdout(`${entry.id}: installed at ${prefix} \u2014 see ${sourceDocsUrl(entry.docsPath)} for authentication
+`);
+  if (!onPath(prefix, env)) {
+    io.stdout(`Add this line to your shell profile: export PATH="${harnessBinPath(prefix)}:$PATH"
+`);
+  }
+  io.stdout(`Run ${entry.binary} from the AGRO workspace: cd ${root}
+`);
+  return 0;
+}
+async function removeHarness(entry, target, prefix, user, opts, io) {
+  const argv = resolveUninstallArgv(entry, prefix);
+  if (argv === null) {
+    io.stdout(`${entry.id}: nothing to remove \u2014 npx fetches it at each run
+`);
+    return { code: 0, dropReceipt: false };
+  }
+  if (await probeInstalled(target, entry, prefix, user) !== true) {
+    io.stdout(`${entry.id}: not installed (${entry.binary})
+`);
+    return { code: 0, dropReceipt: true };
+  }
+  if (isInteractive(opts)) {
+    const ask2 = io.ask ?? ask;
+    const answer = (await ask2(`Remove ${entry.title} from ${prefix}? [y/N]`)).trim().toLowerCase();
+    if (!/^y/.test(answer)) {
+      io.stderr(`${opts.bin} harness: removed nothing.
+`);
+      return { code: 1, dropReceipt: false };
+    }
+  }
+  io.stdout(`removing ${entry.title} from ${prefix}\u2026
+`);
+  const r = await target.exec({
+    argv,
+    ...user ? { user } : {},
+    stdio: "inherit"
+  });
+  if (r.exitCode !== 0) {
+    io.stderr(`${opts.bin} harness: removing ${entry.id} failed (exit ${r.exitCode}).
+`);
+    return { code: r.exitCode, dropReceipt: false };
+  }
+  io.stdout(`${entry.id}: removed from ${prefix}
+`);
+  return { code: 0, dropReceipt: true };
+}
+async function uninstallOnHost(entry, opts, io, run) {
+  const bin = opts.bin;
+  const env = opts.env ?? process.env;
+  const computed = hostPrefix(homeOf(opts));
+  if (resolveUninstallArgv(entry, computed) === null) {
+    io.stdout(`${entry.id}: nothing to remove \u2014 npx fetches it at each run
+`);
+    return 0;
+  }
+  let config;
+  let workspace;
+  try {
+    config = readHostConfig(env);
+    workspace = resolveHarnessRoot(void 0, env);
+  } catch (err) {
+    io.stderr(`${bin} harness: ${messageOf(err)}
+`);
+    return 1;
+  }
+  const receipt = config.hostHarnesses?.[entry.id];
+  if (receipt === void 0 && opts.force !== true) {
+    io.stderr(
+      `${bin} harness: no record of installing ${entry.id} on this host.
+Removing it could delete a harness you installed yourself. Re-run with \`--force\` to remove it from ${computed}.
+`
+    );
+    return 1;
+  }
+  const prefix = receipt?.prefix ?? computed;
+  const target = hostTargetFor(receipt?.workspaceRoot ?? workspace, prefix, run, env);
+  const outcome = await removeHarness(entry, target, prefix, void 0, opts, io);
+  if (outcome.dropReceipt && receipt !== void 0) {
+    const remaining = { ...config.hostHarnesses ?? {} };
+    delete remaining[entry.id];
+    try {
+      writeHostConfig({ ...config, hostHarnesses: remaining }, env);
+    } catch (err) {
+      io.stderr(`${bin} harness: could not clear the install record: ${messageOf(err)}
+`);
+      return 1;
+    }
+    io.stdout(`${entry.id}: cleared the host install record
+`);
+  }
+  return outcome.code;
+}
+async function runHarnessUninstall(name, opts, io) {
+  const run = opts.run ?? spawnRunner;
+  const root = resolveProjectRoot(opts.cwd);
+  const entry = findHarness(name);
+  if (!entry) return unknownHarness(name, io, opts.bin);
+  const target = targetFor(root, run, opts.env);
+  if (!isReachable(await resolveTargetStatus(target))) {
+    return await uninstallOnHost(entry, opts, io, run);
+  }
+  return (await removeHarness(entry, target, SANDBOX_HARNESS_PREFIX, "sandbox", opts, io)).code;
+}
 async function runHarnessInstall(name, opts, io) {
   const run = opts.run ?? spawnRunner;
   const env = opts.env ?? process.env;
@@ -4274,23 +4806,9 @@ async function runHarnessInstall(name, opts, io) {
   const entry = findHarness(name);
   if (!entry) return unknownHarness(name, io, opts.bin);
   const target = targetFor(root, run, opts.env);
-  let status;
-  try {
-    status = await target.status();
-  } catch (err) {
-    if (err instanceof ExecutionSpawnError && err.code === "ENOENT") {
-      io.stderr("docker is required to install into the running sandbox but was not found on PATH\n");
-      return 1;
-    }
-    throw err;
-  }
+  const status = await resolveTargetStatus(target);
   if (!isReachable(status)) {
-    io.stderr(
-      `${opts.bin} harness: the sandbox is not running (${status}).
-Start it with \`${opts.bin} sandbox\`, then re-run this command.
-`
-    );
-    return 1;
+    return await installOnHost(entry, opts, io, run, status);
   }
   const hermes = entry.id === "hermes";
   const installEnv = hermes ? {
@@ -4298,10 +4816,10 @@ Start it with \`${opts.bin} sandbox\`, then re-run this command.
     HERMES_HOME: `${hermesTargetRoot(target)}/.hermes`
   } : void 0;
   if (hermes) {
-    const code = await reconcileHermes(target, io, opts.bin);
+    const code = await reconcileHermes(target, io, opts.bin, "sandbox");
     if (code !== 0) return code;
   }
-  const already = await probeInstalled(target, entry, installEnv);
+  const already = await probeInstalled(target, entry, SANDBOX_HARNESS_PREFIX, "sandbox", installEnv);
   if (already === true) {
     io.stdout(`${entry.id}: already installed (${entry.binary})
 `);
@@ -4314,7 +4832,7 @@ Start it with \`${opts.bin} sandbox\`, then re-run this command.
   io.stdout(`installing ${entry.title} into the sandbox\u2026
 `);
   const r = await target.exec({
-    argv: [...entry.installArgv],
+    argv: resolveInstallArgv(entry, SANDBOX_HARNESS_PREFIX),
     user: entry.installUser,
     stdio: "inherit",
     ...installEnv ? { env: installEnv } : {}
@@ -4325,12 +4843,12 @@ Start it with \`${opts.bin} sandbox\`, then re-run this command.
     return r.exitCode;
   }
   if (hermes) {
-    if (await probeInstalled(target, entry, installEnv) !== true) {
+    if (await probeInstalled(target, entry, SANDBOX_HARNESS_PREFIX, "sandbox", installEnv) !== true) {
       io.stderr(`${opts.bin} harness: Hermes installation finished but executable verification failed.
 `);
       return 1;
     }
-    const code = await reconcileHermes(target, io, opts.bin);
+    const code = await reconcileHermes(target, io, opts.bin, "sandbox");
     if (code !== 0) return code;
   }
   io.stdout(`${entry.id}: installed \u2014 see ${sourceDocsUrl(entry.docsPath)} for authentication
@@ -4338,8 +4856,14 @@ Start it with \`${opts.bin} sandbox\`, then re-run this command.
   return 0;
 }
 
+// src/commands/tool.ts
+import { existsSync as existsSync19 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { delimiter as delimiter3, join as join13, resolve as resolve13 } from "node:path";
+
 // src/lib/tools/catalog.ts
 var TOOLS_DOC = "docs/installation.md";
+var TOOL_HOST_PLATFORM = "linux";
 var TOOL_CATALOG = Object.freeze([
   Object.freeze({
     id: "agent-browser",
@@ -4354,6 +4878,9 @@ var TOOL_CATALOG = Object.freeze([
     ]),
     installUser: "sandbox",
     downloadSize: "~1 GB",
+    hostCapable: false,
+    notHostCapableReason: () => "agent-browser runs `agent-browser install --with-deps`, which installs system packages with the operating system package manager. AGRO installs it into the sandbox only, where that stays contained.",
+    uninstallArgv: Object.freeze(["bash", "-lc", "pnpm remove -g agent-browser"]),
     docsPath: TOOLS_DOC
   }),
   Object.freeze({
@@ -4385,6 +4912,8 @@ var TOOL_CATALOG = Object.freeze([
       ].join("\n")
     ]),
     installUser: "sandbox",
+    hostCapable: true,
+    uninstallArgv: Object.freeze(["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/herdr`]),
     docsPath: TOOLS_DOC
   }),
   Object.freeze({
@@ -4417,6 +4946,8 @@ var TOOL_CATALOG = Object.freeze([
       ].join("\n")
     ]),
     installUser: "sandbox",
+    hostCapable: true,
+    uninstallArgv: Object.freeze(["rm", "-rf", `${HARNESS_PREFIX_TOKEN}/bin/cloudflared`]),
     docsPath: TOOLS_DOC
   }),
   Object.freeze({
@@ -4442,6 +4973,13 @@ var TOOL_CATALOG = Object.freeze([
       ].join("\n")
     ]),
     installUser: "sandbox",
+    hostCapable: true,
+    uninstallArgv: Object.freeze([
+      "rm",
+      "-rf",
+      `${HARNESS_PREFIX_TOKEN}/bin/msb`,
+      `${HARNESS_PREFIX_TOKEN}/microsandbox`
+    ]),
     docsPath: "docs/runtimes/microsandbox.md"
   }),
   Object.freeze({
@@ -4452,6 +4990,8 @@ var TOOL_CATALOG = Object.freeze([
     verifyArgv: Object.freeze(["bash", "-lc", "command -v docker >/dev/null"]),
     versionArgv: Object.freeze(["docker", "--version"]),
     notInstallableReason: (bin) => `The Docker CLI is installed in the base image. Note that the CLI being present says nothing about whether a daemon is reachable \u2014 \`${bin} ps <name>\` answers that.`,
+    hostCapable: false,
+    uninstallArgv: null,
     docsPath: TOOLS_DOC
   }),
   Object.freeze({
@@ -4462,6 +5002,8 @@ var TOOL_CATALOG = Object.freeze([
     verifyArgv: Object.freeze(["bash", "-lc", "command -v gh >/dev/null"]),
     versionArgv: Object.freeze(["gh", "--version"]),
     notInstallableReason: () => "The GitHub CLI is installed in the base image. Run `gh auth login` inside the sandbox to authenticate it.",
+    hostCapable: false,
+    uninstallArgv: null,
     docsPath: TOOLS_DOC
   }),
   Object.freeze({
@@ -4493,6 +5035,13 @@ install -m 0755 "$tmp/tailscale_1.102.3_$arch/tailscaled" "$prefix/bin/tailscale
 install -d -m 0700 "$HOME/.tailscale"`
     ]),
     installUser: "sandbox",
+    hostCapable: true,
+    uninstallArgv: Object.freeze([
+      "rm",
+      "-rf",
+      `${HARNESS_PREFIX_TOKEN}/bin/tailscale`,
+      `${HARNESS_PREFIX_TOKEN}/bin/tailscaled`
+    ]),
     docsPath: TOOLS_DOC
   })
 ]);
@@ -4505,6 +5054,12 @@ function toolIds() {
 function installableToolIds() {
   return TOOL_CATALOG.filter((t) => t.installArgv !== void 0).map((t) => t.id);
 }
+function hostCapableToolIds() {
+  return TOOL_CATALOG.filter((t) => t.hostCapable).map((t) => t.id);
+}
+function resolveToolUninstallArgv(entry, prefix) {
+  return entry.uninstallArgv === null ? null : entry.uninstallArgv.map((part) => part.split(HARNESS_PREFIX_TOKEN).join(prefix));
+}
 
 // src/commands/tool.ts
 function isReachable2(status) {
@@ -4519,56 +5074,116 @@ function targetFor2(root, run, env) {
     ...env ? { env } : {}
   });
 }
-async function tryExec(target, argv, user) {
+function hostPrefix2(home) {
+  return join13(home, ".local");
+}
+function pathEntries2(env) {
+  return (env.PATH ?? "").split(delimiter3).filter((part) => part !== "");
+}
+function onPath2(prefix, env) {
+  return pathEntries2(env).includes(harnessBinPath(prefix));
+}
+function hostTargetFor2(root, prefix, run, env) {
+  const path4 = [harnessBinPath(prefix), ...pathEntries2(env)].join(delimiter3);
+  return new LocalExecutionTarget({
+    projectRoot: root,
+    run,
+    env: { ...env, PATH: path4 }
+  });
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function homeOf2(opts) {
+  return (opts.homedir ?? homedir3)();
+}
+function platformOf(opts) {
+  return opts.platform ?? process.platform;
+}
+function isInteractive2(opts) {
+  return opts.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true);
+}
+async function tryExec(target, argv, user, env) {
   try {
-    const r = await target.exec({ argv: [...argv], user, stdio: "capture" });
+    const r = await target.exec({
+      argv: [...argv],
+      ...user ? { user } : {},
+      stdio: "capture",
+      ...env ? { env } : {}
+    });
     return { exitCode: r.exitCode, stdout: r.stdout };
   } catch (err) {
     if (err instanceof ExecutionSpawnError) return null;
     throw err;
   }
 }
-async function probeInstalled2(target, entry) {
-  const r = await tryExec(target, entry.verifyArgv, "sandbox");
+async function probeInstalled2(target, entry, user, env) {
+  const r = await tryExec(target, entry.verifyArgv, user, env);
   return r === null ? null : r.exitCode === 0;
 }
-async function probeVersion(target, entry) {
+async function probeVersion(target, entry, user) {
   if (entry.versionArgv === void 0) return null;
-  const r = await tryExec(target, entry.versionArgv, "sandbox");
+  const r = await tryExec(target, entry.versionArgv, user);
   if (r === null || r.exitCode !== 0) return null;
   const first = r.stdout.trim().split("\n")[0] ?? "";
   return first === "" ? null : first;
 }
-async function collectRows(root, run, env, only) {
+function rowOf(entry, installed, version, location) {
+  return {
+    id: entry.id,
+    title: entry.title,
+    binary: entry.binary,
+    kind: entry.kind,
+    installed,
+    version,
+    installable: entry.installArgv !== void 0,
+    hostCapable: entry.hostCapable,
+    location,
+    docs: sourceDocsUrl(entry.docsPath)
+  };
+}
+function probeableHost2(env, home) {
+  let root;
+  try {
+    root = resolveHarnessRoot(void 0, env);
+  } catch {
+    return void 0;
+  }
+  const prefix = hostPrefix2(home);
+  if (!existsSync19(join13(root, ".git")) && !existsSync19(prefix)) return void 0;
+  return { root, prefix };
+}
+async function collectRows(root, run, home, env, only) {
   const entries = only ? [...only] : [...TOOL_CATALOG];
   const target = targetFor2(root, run, env);
-  let reachable = false;
-  try {
-    reachable = isReachable2(await target.status());
-  } catch (err) {
-    if (!(err instanceof ExecutionSpawnError)) throw err;
+  if (isReachable2(await resolveTargetStatus(target))) {
+    const rows2 = [];
+    for (const entry of entries) {
+      const installed = await probeInstalled2(target, entry, "sandbox");
+      const version = installed === true ? await probeVersion(target, entry, "sandbox") : null;
+      rows2.push(rowOf(entry, installed, version, installed === null ? "unknown" : "sandbox"));
+    }
+    return { rows: rows2 };
   }
+  const host = probeableHost2(env ?? process.env, home);
+  if (host === void 0) {
+    return { rows: entries.map((entry) => rowOf(entry, null, null, "unknown")) };
+  }
+  const hostTarget = hostTargetFor2(host.root, host.prefix, run, env ?? process.env);
   const rows = [];
   for (const entry of entries) {
-    const installed = reachable ? await probeInstalled2(target, entry) : null;
-    rows.push({
-      id: entry.id,
-      title: entry.title,
-      binary: entry.binary,
-      kind: entry.kind,
-      installed,
-      version: reachable && installed === true ? await probeVersion(target, entry) : null,
-      installable: entry.installArgv !== void 0,
-      docs: sourceDocsUrl(entry.docsPath)
-    });
+    const installed = await probeInstalled2(hostTarget, entry, void 0);
+    const version = installed === true ? await probeVersion(hostTarget, entry, void 0) : null;
+    rows.push(rowOf(entry, installed, version, installed === null ? "unknown" : "host"));
   }
-  return rows;
+  return { rows, hostPrefix: host.prefix };
 }
 function cell2(value, absent) {
   if (value === null) return absent;
   return value ? "yes" : "no";
 }
-function renderTable2(rows, io, bin) {
+function renderTable2(collected, io, bin) {
+  const rows = collected.rows;
   const header2 = ["TOOL", "KIND", "INSTALLED"];
   const body = rows.map((r) => [r.id, r.kind, cell2(r.installed, "?")]);
   const widths = header2.map(
@@ -4577,21 +5192,31 @@ function renderTable2(rows, io, bin) {
   const line = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("  ").trimEnd() + "\n";
   io.stdout(line(header2));
   for (const row of body) io.stdout(line(row));
+  if (rows.some((r) => r.location === "host")) {
+    io.stdout(
+      `
+INSTALLED reports the host prefix ${collected.hostPrefix} \u2014 the sandbox is not running.
+`
+    );
+    return;
+  }
   if (rows.some((r) => r.installed === null)) {
     io.stdout(`
 INSTALLED is \`?\` \u2014 the sandbox is not running. Start it with \`${bin} sandbox\`.
 `);
   }
 }
-function renderDetail(rows, io, bin) {
-  renderTable2(rows, io, bin);
-  for (const r of rows) {
+function renderDetail(collected, io, bin) {
+  renderTable2(collected, io, bin);
+  for (const r of collected.rows) {
     io.stdout(`
 ${r.id} \u2014 ${r.title}
 `);
     io.stdout(`  version:    ${r.version ?? "\u2014"}
 `);
     io.stdout(`  installable: ${r.installable ? "yes" : "no"}
+`);
+    io.stdout(`  on the host: ${r.hostCapable ? "yes" : "no"}
 `);
     io.stdout(`  see ${r.docs}
 `);
@@ -4600,12 +5225,12 @@ ${r.id} \u2014 ${r.title}
 async function runToolList(opts, io) {
   const run = opts.run ?? spawnRunner;
   const root = resolveProjectRoot(opts.cwd);
-  const rows = await collectRows(root, run, opts.env);
+  const collected = await collectRows(root, run, homeOf2(opts), opts.env);
   if (opts.json) {
-    io.stdout(`${JSON.stringify(rows, null, 2)}
+    io.stdout(`${JSON.stringify(collected.rows, null, 2)}
 `);
   } else {
-    renderTable2(rows, io, opts.bin);
+    renderTable2(collected, io, opts.bin);
   }
   return 0;
 }
@@ -4626,12 +5251,12 @@ async function runToolStatus(name, opts, io) {
     only = findTool(name);
     if (!only) return unknownTool(name, io, opts.bin);
   }
-  const rows = await collectRows(root, run, opts.env, only ? [only] : void 0);
+  const collected = await collectRows(root, run, homeOf2(opts), opts.env, only ? [only] : void 0);
   if (opts.json) {
-    io.stdout(`${JSON.stringify(only ? rows[0] : rows, null, 2)}
+    io.stdout(`${JSON.stringify(only ? collected.rows[0] : collected.rows, null, 2)}
 `);
   } else {
-    renderDetail(rows, io, opts.bin);
+    renderDetail(collected, io, opts.bin);
   }
   return 0;
 }
@@ -4648,6 +5273,151 @@ Re-run with --yes to accept the download.
   );
   return false;
 }
+function unreachableReason2(status) {
+  return runtimeIsAbsent(status) ? "No container runtime is on PATH." : `The sandbox is not running (${status}).`;
+}
+function sandboxRefusal2(bin, status) {
+  if (runtimeIsAbsent(status)) {
+    return `${bin} tool: no container runtime is on PATH.
+`;
+  }
+  return `${bin} tool: the sandbox is not running (${status}).
+Start it with \`${bin} sandbox\`, then re-run this command.
+`;
+}
+function hostCapableList(bin) {
+  return `Tools that install on the host:
+${hostCapableToolIds().map((t) => `  ${bin} tool install ${t} --host`).join("\n")}
+`;
+}
+async function installOnHost2(entry, opts, io, run, status) {
+  const bin = opts.bin;
+  const env = opts.env ?? process.env;
+  const flagged = opts.host === true || opts.path !== void 0;
+  if (!entry.hostCapable) {
+    io.stderr(sandboxRefusal2(bin, status));
+    io.stderr(`
+${bin} tool: ${entry.id} cannot be installed on the host.
+`);
+    io.stderr(`${(entry.notHostCapableReason ?? entry.notInstallableReason)?.(bin) ?? ""}
+
+`);
+    io.stderr(hostCapableList(bin));
+    return 1;
+  }
+  const platform = platformOf(opts);
+  if (platform !== TOOL_HOST_PLATFORM) {
+    io.stderr(sandboxRefusal2(bin, status));
+    io.stderr(
+      `
+${bin} tool: a host install needs ${TOOL_HOST_PLATFORM}; this host is ${platform}.
+Every tool installer in the catalog is Debian-specific. Install ${entry.id} with your own package manager, or start the sandbox.
+`
+    );
+    return 1;
+  }
+  if (!flagged && !isInteractive2(opts)) {
+    io.stderr(
+      sandboxRefusal2(bin, status) + `Or install on the host with \`${bin} tool install ${entry.id} --host\`.
+`
+    );
+    return 1;
+  }
+  let root;
+  let recorded;
+  try {
+    recorded = readHostConfig(env).harnessRoot;
+    root = resolveHarnessRoot(opts.path, env);
+  } catch (err) {
+    io.stderr(`${bin} tool: ${messageOf2(err)}
+`);
+    return 1;
+  }
+  const sticky = opts.path === void 0 && recorded !== void 0 && recorded !== "";
+  if (!flagged) {
+    const ask2 = io.ask ?? ask;
+    const answer = (await ask2(
+      `${unreachableReason2(status)} Install ${entry.title} on the host? [y/N]`
+    )).trim().toLowerCase();
+    if (!/^y/.test(answer)) {
+      io.stderr(sandboxRefusal2(bin, status));
+      return 1;
+    }
+    if (!sticky) {
+      const chosen = (await ask2(`Harness root [${root}]:`)).trim();
+      if (chosen !== "") root = resolve13(chosen);
+    }
+  }
+  if (sticky) io.stdout(`using the recorded harness root ${root}
+`);
+  try {
+    if (!existsSync19(join13(root, ".git"))) io.stdout(`cloning ${AGRO_REPO_URL} into ${root}\u2026
+`);
+    const workspace = ensureHostWorkspace(root, run);
+    root = workspace.root;
+    io.stdout(
+      workspace.action === "cloned" ? `host workspace cloned into ${root}
+` : `host workspace reused at ${root}
+`
+    );
+  } catch (err) {
+    io.stderr(`${bin} tool: ${messageOf2(err)}
+`);
+    return 1;
+  }
+  const prefix = hostPrefix2(homeOf2(opts));
+  const installEnv = { NPM_USER_PREFIX: prefix };
+  const target = hostTargetFor2(root, prefix, run, env);
+  if (await probeInstalled2(target, entry, void 0, installEnv) === true) {
+    io.stdout(`${entry.id}: already installed (${entry.binary})
+`);
+    return 0;
+  }
+  if (!await confirmDownload(entry, opts, io)) return 1;
+  io.stdout(`installing ${entry.title} on the host\u2026
+`);
+  const r = await target.exec({
+    argv: [...entry.installArgv],
+    stdio: "inherit",
+    env: installEnv
+  });
+  if (r.exitCode !== 0) {
+    io.stderr(`${bin} tool: installing ${entry.id} failed (exit ${r.exitCode}).
+`);
+    return r.exitCode;
+  }
+  const receipt = {
+    prefix,
+    binary: entry.binary,
+    binPath: harnessBinPath(prefix),
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceRoot: root
+  };
+  try {
+    const config = readHostConfig(env);
+    writeHostConfig(
+      {
+        ...config,
+        harnessRoot: root,
+        hostTools: { ...config.hostTools ?? {}, [entry.id]: receipt }
+      },
+      env
+    );
+  } catch (err) {
+    io.stderr(`${bin} tool: could not record the install: ${messageOf2(err)}
+`);
+    return 1;
+  }
+  io.stdout(`${entry.id}: installed at ${prefix} \u2014 see ${sourceDocsUrl(entry.docsPath)}
+`);
+  if (!onPath2(prefix, env)) {
+    io.stdout(`Add this line to your shell profile: export PATH="${harnessBinPath(prefix)}:$PATH"
+`);
+  }
+  io.stdout(`Run ${entry.binary} from the AGRO workspace: cd ${root}
+`);
+  return 0;
+}
 async function runToolInstall(name, opts, io) {
   const run = opts.run ?? spawnRunner;
   const root = resolveProjectRoot(opts.cwd);
@@ -4666,25 +5436,11 @@ ${installableToolIds().map((t) => `  ${t}`).join("\n")}
     return 1;
   }
   const target = targetFor2(root, run, opts.env);
-  let status;
-  try {
-    status = await target.status();
-  } catch (err) {
-    if (err instanceof ExecutionSpawnError && err.code === "ENOENT") {
-      io.stderr("docker is required to install into the running sandbox but was not found on PATH\n");
-      return 1;
-    }
-    throw err;
-  }
+  const status = await resolveTargetStatus(target);
   if (!isReachable2(status)) {
-    io.stderr(
-      `${opts.bin} tool: the sandbox is not running (${status}).
-Start it with \`${opts.bin} sandbox\`, then re-run this command.
-`
-    );
-    return 1;
+    return await installOnHost2(entry, opts, io, run, status);
   }
-  const already = await probeInstalled2(target, entry);
+  const already = await probeInstalled2(target, entry, "sandbox");
   if (already === true) {
     io.stdout(`${entry.id}: already installed (${entry.binary})
 `);
@@ -4711,6 +5467,98 @@ Start it with \`${opts.bin} sandbox\`, then re-run this command.
 `);
   return 0;
 }
+async function removeTool(entry, target, prefix, user, opts, io) {
+  const argv = resolveToolUninstallArgv(entry, prefix);
+  if (await probeInstalled2(target, entry, user) !== true) {
+    io.stdout(`${entry.id}: not installed (${entry.binary})
+`);
+    return { code: 0, dropReceipt: true };
+  }
+  if (isInteractive2(opts)) {
+    const ask2 = io.ask ?? ask;
+    const answer = (await ask2(`Remove ${entry.title} from ${prefix}? [y/N]`)).trim().toLowerCase();
+    if (!/^y/.test(answer)) {
+      io.stderr(`${opts.bin} tool: removed nothing.
+`);
+      return { code: 1, dropReceipt: false };
+    }
+  }
+  io.stdout(`removing ${entry.title} from ${prefix}\u2026
+`);
+  const r = await target.exec({
+    argv,
+    ...user ? { user } : {},
+    stdio: "inherit"
+  });
+  if (r.exitCode !== 0) {
+    io.stderr(`${opts.bin} tool: removing ${entry.id} failed (exit ${r.exitCode}).
+`);
+    return { code: r.exitCode, dropReceipt: false };
+  }
+  io.stdout(`${entry.id}: removed from ${prefix}
+`);
+  return { code: 0, dropReceipt: true };
+}
+async function uninstallOnHost2(entry, opts, io, run) {
+  const bin = opts.bin;
+  const env = opts.env ?? process.env;
+  const computed = hostPrefix2(homeOf2(opts));
+  let config;
+  let workspace;
+  try {
+    config = readHostConfig(env);
+    workspace = resolveHarnessRoot(void 0, env);
+  } catch (err) {
+    io.stderr(`${bin} tool: ${messageOf2(err)}
+`);
+    return 1;
+  }
+  const receipt = config.hostTools?.[entry.id];
+  if (receipt === void 0 && opts.force !== true) {
+    io.stderr(
+      `${bin} tool: no record of installing ${entry.id} on this host.
+Removing it could delete a tool you installed yourself. Re-run with \`--force\` to remove it from ${computed}.
+`
+    );
+    return 1;
+  }
+  const prefix = receipt?.prefix ?? computed;
+  const target = hostTargetFor2(receipt?.workspaceRoot ?? workspace, prefix, run, env);
+  const outcome = await removeTool(entry, target, prefix, void 0, opts, io);
+  if (outcome.dropReceipt && receipt !== void 0) {
+    const remaining = { ...config.hostTools ?? {} };
+    delete remaining[entry.id];
+    try {
+      writeHostConfig({ ...config, hostTools: remaining }, env);
+    } catch (err) {
+      io.stderr(`${bin} tool: could not clear the install record: ${messageOf2(err)}
+`);
+      return 1;
+    }
+    io.stdout(`${entry.id}: cleared the host install record
+`);
+  }
+  return outcome.code;
+}
+async function runToolUninstall(name, opts, io) {
+  const run = opts.run ?? spawnRunner;
+  const root = resolveProjectRoot(opts.cwd);
+  const entry = findTool(name);
+  if (!entry) return unknownTool(name, io, opts.bin);
+  if (entry.uninstallArgv === null) {
+    io.stderr(`${opts.bin} tool: ${entry.id} cannot be removed by this command.
+
+`);
+    io.stderr(`${entry.notInstallableReason?.(opts.bin) ?? ""}
+`);
+    return 1;
+  }
+  const target = targetFor2(root, run, opts.env);
+  if (!isReachable2(await resolveTargetStatus(target))) {
+    return await uninstallOnHost2(entry, opts, io, run);
+  }
+  return (await removeTool(entry, target, SANDBOX_HARNESS_PREFIX, "sandbox", opts, io)).code;
+}
 
 // src/lib/remote.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -4776,9 +5624,9 @@ function fetchRemoteSource(opts) {
 }
 
 // src/cli.ts
-var VERSION = true ? "0.11.0" : "0.0.0-dev";
-var DEFAULT_SOURCE_OH_DIR = resolve10(
-  dirname8(fileURLToPath(import.meta.url)),
+var VERSION = true ? "0.12.1" : "0.0.0-dev";
+var DEFAULT_SOURCE_OH_DIR = resolve14(
+  dirname10(fileURLToPath(import.meta.url)),
   "../.."
 );
 var INTEGRATIONS = {};
@@ -5008,16 +5856,26 @@ function printHarnessHelp(bin = LEGACY_PRODUCT.bin) {
 
 Usage:
   ${bin} harness list                     List known harnesses and their state
-  ${bin} harness install <name>           Install a harness into the sandbox
+  ${bin} harness install <name>           Install a harness into the sandbox or the host
+  ${bin} harness uninstall <name>         Remove a harness the same way it was installed
   ${bin} harness status [name]            Show installed state
 
-\`install\` is the only door: it probes the running sandbox, installs the harness
-into the persistent home volume, and reports. It reads and writes no \`${stateNames(bin).configFile}\`
-field, and it never rebuilds or restarts the sandbox. It requires a running
-sandbox \u2014 start one with \`${bin} sandbox\` first.
+\`install\` and \`uninstall\` act on the running sandbox. When no sandbox is
+reachable they act on the host. A host install clones the AGRO workspace into the
+harness root, then installs the harness into \`~/.local\`. \`--path <dir>\` chooses
+the harness root; a successful install records it as \`harnessRoot\` in the host
+\`${stateNames(bin).configFile}\`. The default is \`~/.agro\`, and the install prefix is
+always \`~/.local\`.
+
+On the host, \`uninstall\` removes only the harness \`install\` recorded, from the
+prefix in that record. Without a record it refuses, and \`--force\` overrides. In
+the sandbox it needs no record. See \`docs/harnesses/overview.md\`.
 
 Flags:
   --json           Machine-readable output (list/status)
+  --host           Install on the host when the sandbox is not running (install)
+  --path <dir>     Harness root for the workspace clone; implies --host (install)
+  --force          Remove without a recorded host install (uninstall)
 
 Harnesses:
 ${harnessIds().map((h) => `  ${h}`).join("\n")}
@@ -5055,19 +5913,34 @@ tunnel client, the GitHub CLI, an isolation runtime's own binary.
 Usage:
   ${bin} tool list                      List known tools and their state
   ${bin} tool status [name]             Show installed state and version
-  ${bin} tool install <name>            Install a tool into the sandbox
+  ${bin} tool install <name>            Install a tool into the sandbox or the host
+  ${bin} tool uninstall <name>          Remove a tool the same way it was installed
 
 Most tools are baked into the image and are report-only; \`install\` works on:
 ${installableToolIds().map((t) => `  ${t}`).join("\n")}
 
 \`install\` is the only door: it probes the running sandbox, installs the tool
-into the persistent home volume, and reports. It reads and writes no \`${stateNames(bin).configFile}\`
-field, and it never rebuilds or restarts the sandbox. A large download is
-confirmed first, and a non-interactive run without --yes installs nothing.
+into the persistent home volume, and reports. It never rebuilds or restarts the
+sandbox. A large download is confirmed first, and a non-interactive run without
+--yes installs nothing.
+
+When no sandbox is reachable, \`install\` and \`uninstall\` act on the host. A host
+install needs Linux, because every installer is Debian-specific, and it works
+only on these tools:
+${hostCapableToolIds().map((t) => `  ${t}`).join("\n")}
+
+A host install clones the AGRO workspace into the harness root \u2014 \`--path <dir>\`,
+then \`harnessRoot\` in the host \`${stateNames(bin).configFile}\`, then \`~/.agro\` \u2014 and installs into
+\`~/.local\`. It records the install as \`hostTools\` in that same file. On the host,
+\`uninstall\` removes only what \`install\` recorded, from the prefix in that record.
+Without a record it refuses, and \`--force\` overrides.
 
 Flags:
   --yes            Accept a large download without prompting
   --json           Machine-readable output (list/status)
+  --host           Install on the host when the sandbox is not running (install)
+  --path <dir>     Harness root for the workspace clone; implies --host (install)
+  --force          Remove without a recorded host install (uninstall)
 
 Tools:
 ${toolIds().map((t) => `  ${t}`).join("\n")}
@@ -5449,72 +6322,117 @@ function parseShellArgs(rest, bin = LEGACY_PRODUCT.bin) {
 function parseHarnessArgs(rest, bin = LEGACY_PRODUCT.bin) {
   const args = {
     help: false,
-    json: false
+    json: false,
+    host: false,
+    force: false
   };
   if (rest.length === 0 || isHelpFlag(rest[0])) {
     return { ok: true, args: { ...args, help: true } };
   }
   const positionals = [];
+  let expectPath = false;
   for (const token of rest) {
-    if (token === "--json") {
+    if (expectPath) {
+      expectPath = false;
+      args.path = token;
+      args.host = true;
+    } else if (token === "--json") {
       args.json = true;
+    } else if (token === "--host") {
+      args.host = true;
+    } else if (token === "--force") {
+      args.force = true;
+    } else if (token === "--path") {
+      expectPath = true;
+    } else if (token.startsWith("--path=")) {
+      args.path = token.slice("--path=".length);
+      args.host = true;
     } else if (token.startsWith("-")) {
       return { ok: false, error: `${bin} harness: unknown flag "${token}"` };
     } else {
       positionals.push(token);
     }
   }
+  if (expectPath || args.path === "") {
+    return { ok: false, error: `${bin} harness: --path requires a directory` };
+  }
   const [sub, name, ...extra] = positionals;
-  if (sub !== "list" && sub !== "install" && sub !== "status") {
+  if (sub !== "list" && sub !== "install" && sub !== "status" && sub !== "uninstall") {
     return {
       ok: false,
-      error: `${bin} harness: unknown subcommand "${sub}" \u2014 expected list, install, or status`,
+      error: `${bin} harness: unknown subcommand "${sub}" \u2014 expected list, install, uninstall, or status`,
       showHelp: true
     };
   }
   if (extra.length > 0) {
     return { ok: false, error: `${bin} harness: unexpected argument "${extra[0]}"` };
   }
-  if (sub === "install" && name === void 0) {
-    return { ok: false, error: `${bin} harness install: a harness name is required`, showHelp: true };
+  if ((sub === "install" || sub === "uninstall") && name === void 0) {
+    return { ok: false, error: `${bin} harness ${sub}: a harness name is required`, showHelp: true };
   }
   if (sub === "list" && name !== void 0) {
     return { ok: false, error: `${bin} harness list: unexpected argument "${name}"` };
   }
+  if (sub !== "install" && args.host) {
+    return { ok: false, error: `${bin} harness ${sub}: --host and --path apply to install only` };
+  }
+  if (sub !== "uninstall" && args.force) {
+    return { ok: false, error: `${bin} harness ${sub}: --force applies to uninstall only` };
+  }
   args.subcommand = sub;
   if (name !== void 0) args.name = name;
   return { ok: true, args };
 }
 function parseToolArgs(rest, bin = LEGACY_PRODUCT.bin) {
-  const args = { help: false, yes: false, json: false };
+  const args = { help: false, yes: false, json: false, host: false, force: false };
   if (rest.length === 0 || isHelpFlag(rest[0])) {
     return { ok: true, args: { ...args, help: true } };
   }
   const positionals = [];
+  let expectPath = false;
   for (const token of rest) {
-    if (token === "--yes" || token === "-y") args.yes = true;
+    if (expectPath) {
+      expectPath = false;
+      args.path = token;
+      args.host = true;
+    } else if (token === "--yes" || token === "-y") args.yes = true;
     else if (token === "--json") args.json = true;
-    else if (token.startsWith("-")) {
+    else if (token === "--host") args.host = true;
+    else if (token === "--force") args.force = true;
+    else if (token === "--path") expectPath = true;
+    else if (token.startsWith("--path=")) {
+      args.path = token.slice("--path=".length);
+      args.host = true;
+    } else if (token.startsWith("-")) {
       return { ok: false, error: `${bin} tool: unknown flag "${token}"` };
     } else positionals.push(token);
   }
+  if (expectPath || args.path === "") {
+    return { ok: false, error: `${bin} tool: --path requires a directory` };
+  }
   const [sub, name, ...extra] = positionals;
-  if (sub !== "list" && sub !== "install" && sub !== "status") {
+  if (sub !== "list" && sub !== "install" && sub !== "status" && sub !== "uninstall") {
     return {
       ok: false,
-      error: `${bin} tool: unknown subcommand "${sub}" \u2014 expected list, install, or status`,
+      error: `${bin} tool: unknown subcommand "${sub}" \u2014 expected list, install, uninstall, or status`,
       showHelp: true
     };
   }
   if (extra.length > 0) {
     return { ok: false, error: `${bin} tool: unexpected argument "${extra[0]}"` };
   }
-  if (sub === "install" && name === void 0) {
-    return { ok: false, error: `${bin} tool install: a tool name is required`, showHelp: true };
+  if ((sub === "install" || sub === "uninstall") && name === void 0) {
+    return { ok: false, error: `${bin} tool ${sub}: a tool name is required`, showHelp: true };
   }
   if (sub === "list" && name !== void 0) {
     return { ok: false, error: `${bin} tool list: unexpected argument "${name}"` };
   }
+  if (sub !== "install" && args.host) {
+    return { ok: false, error: `${bin} tool ${sub}: --host and --path apply to install only` };
+  }
+  if (sub !== "uninstall" && args.force) {
+    return { ok: false, error: `${bin} tool ${sub}: --force applies to uninstall only` };
+  }
   args.subcommand = sub;
   if (name !== void 0) args.name = name;
   return { ok: true, args };
@@ -5525,19 +6443,19 @@ function parseGatewayArgs(rest) {
   }
   return { ok: true, args: { help: false, passthrough: [...rest] } };
 }
-function bundledPayloadExists(bundled, exists = existsSync16) {
-  return exists(join10(bundled.sourceOhDir, "manifest.json"));
+function bundledPayloadExists(bundled, exists = existsSync20) {
+  return exists(join14(bundled.sourceOhDir, "manifest.json"));
 }
 function resolveUpdateSource(args, bundled, bin = LEGACY_PRODUCT.bin) {
-  const exists = bundled.exists ?? existsSync16;
+  const exists = bundled.exists ?? existsSync20;
   if (args.fromDir !== void 0) {
-    return { kind: "local", fromDir: resolve10(args.fromDir) };
+    return { kind: "local", fromDir: resolve14(args.fromDir) };
   }
   if (args.fromRemote) {
     return { kind: "remote", ref: args.ref };
   }
   if (bundledPayloadExists(bundled, exists)) {
-    return { kind: "local", fromDir: resolve10(bundled.sourceOhDir, "..") };
+    return { kind: "local", fromDir: resolve14(bundled.sourceOhDir, "..") };
   }
   return {
     kind: "remote",
@@ -5549,7 +6467,7 @@ function resolveUpdateSource(args, bundled, bin = LEGACY_PRODUCT.bin) {
 function readPayloadVersion(checkoutDir) {
   try {
     const parsed = JSON.parse(
-      readFileSync11(join10(resolveControlDir(checkoutDir).path, "cli", "package.json"), "utf8")
+      readFileSync12(join14(resolveControlDir(checkoutDir).path, "cli", "package.json"), "utf8")
     );
     if (parsed && typeof parsed.version === "string") return parsed.version;
   } catch {
@@ -5558,8 +6476,8 @@ function readPayloadVersion(checkoutDir) {
 }
 async function runWithRemoteSource(hooks, fn) {
   const fetch2 = hooks.fetch ?? fetchRemoteSource;
-  const mkdtemp = hooks.mkdtemp ?? (() => mkdtempSync3(join10(tmpdir3(), "oh-remote-")));
-  const rm = hooks.rm ?? ((dir) => rmSync3(dir, { recursive: true, force: true }));
+  const mkdtemp = hooks.mkdtemp ?? (() => mkdtempSync4(join14(tmpdir3(), "oh-remote-")));
+  const rm = hooks.rm ?? ((dir) => rmSync4(dir, { recursive: true, force: true }));
   const out = hooks.stdout ?? ((s) => process.stdout.write(s));
   const checkoutDir = mkdtemp();
   try {
@@ -5824,7 +6742,14 @@ async function main(argv) {
     if (a.subcommand === "status") {
       return await runHarnessStatus(a.name, { bin, json: a.json }, io);
     }
-    return await runHarnessInstall(a.name, { bin }, io);
+    if (a.subcommand === "uninstall") {
+      return await runHarnessUninstall(a.name, { bin, force: a.force }, io);
+    }
+    return await runHarnessInstall(
+      a.name,
+      { bin, host: a.host, ...a.path !== void 0 ? { path: a.path } : {} },
+      io
+    );
   }
   if (first === "tool") {
     const parsed = parseToolArgs(argv.slice(1), bin);
@@ -5849,7 +6774,14 @@ async function main(argv) {
     if (a.subcommand === "status") {
       return await runToolStatus(a.name, { bin, json: a.json }, io);
     }
-    return await runToolInstall(a.name, { bin, yes: a.yes }, io);
+    if (a.subcommand === "uninstall") {
+      return await runToolUninstall(a.name, { bin, force: a.force }, io);
+    }
+    return await runToolInstall(
+      a.name,
+      { bin, yes: a.yes, host: a.host, ...a.path !== void 0 ? { path: a.path } : {} },
+      io
+    );
   }
   if (first === "gateway") {
     const parsed = parseGatewayArgs(argv.slice(1));