hostwares-cli 2.4.1 → 2.4.3

package/dist/index.js

@@ -1,199 +1,4024 @@
 #!/usr/bin/env node
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import { setVersion } from "./agent/run.js";
-import { reportError } from "./errors.js";
-import { login } from "./auth/device.js";
-import { startChat } from "./commands/chat.js";
-import { getConfig, saveConfig, clearConfig, isAuthenticated } from "./config.js";
-import { listSessions } from "./session/store.js";
-import { c, glyph, BANNER_LINES } from "./ui/theme.js";
-import * as ui from "./ui/render.js";
-import { isAborted } from "@hostwares/agent-client";
-/**
- * Entry point.
- *
- * Argument parsing is hand-rolled rather than pulled from commander. The old
- * CLI depended on commander purely to register a dozen subcommands that each
- * did `chat("Deploy a site named ...")` - they were natural-language prompts
- * wearing a subcommand costume, and the dependency bought nothing. What is left
- * here is either a real API call or a thin wrapper that says what it forwards.
- */
-const VERSION = readVersion();
-setVersion(VERSION);
-async function main(argv) {
-    const [cmd, ...rest] = argv;
-    switch (cmd) {
-        case undefined:
-            return interactive();
-        case "chat":
-            requireAuth();
-            return startChat({ resume: rest.includes("--resume") || rest.includes("-r") });
-        case "ask": {
-            requireAuth();
-            const message = rest.filter(a => !a.startsWith("-")).join(" ");
-            if (!message)
-                return startChat({});
-            return startChat({ oneShot: message });
-        }
-        case "login":
-            // --token skips the browser flow for CI and scripted installs.
-            if (rest[0] === "--token" && rest[1]) {
-                saveConfig({ apiKey: rest[1] });
-                ui.success("Signed in with the supplied token.");
-                return 0;
-            }
-            return (await login({ noBrowser: rest.includes("--no-browser") })) ? 0 : 1;
-        case "logout":
-            clearConfig();
-            ui.success("Signed out on this machine.");
-            return 0;
-        case "sessions":
-            return showSessions();
-        case "list":
-        case "ls":
-            requireAuth();
-            return listSites();
-        case "version":
-        case "--version":
-        case "-v":
-            console.log(VERSION);
-            return 0;
-        case "help":
-        case "--help":
-        case "-h":
-            showHelp();
-            return 0;
-        default:
-            // An unrecognised first word is far more likely to be a question than a
-            // typo'd command, so it is forwarded rather than rejected. `hw why is my
-            // site down` should work.
-            requireAuth();
-            return startChat({ oneShot: argv.join(" ") });
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@hostwares/agent-client/dist/esm/protocol/errors.js
+function isAborted(e) {
+  return e instanceof AbortedError || e instanceof Error && (e.name === "AbortError" || e.message === "Aborted");
+}
+async function apiErrorFromResponse(res) {
+  const raw = await res.text().catch(() => "");
+  let body = {};
+  try {
+    const parsed = raw ? JSON.parse(raw) : {};
+    if (parsed && typeof parsed === "object")
+      body = parsed;
+  } catch {
+  }
+  const code = typeof body.code === "string" ? body.code : typeof body.error === "string" ? body.error : null;
+  const message = typeof body.message === "string" ? body.message : typeof body.error === "string" ? body.error : raw.trim() && !raw.trimStart().startsWith("<") ? raw.trim().slice(0, 200) : defaultMessageFor(res.status);
+  return new ApiError(res.status, message, code, body);
+}
+function defaultMessageFor(status) {
+  if (status === 401)
+    return "Not signed in.";
+  if (status === 402)
+    return "Out of credits.";
+  if (status === 403)
+    return "Not allowed.";
+  if (status === 404)
+    return "Not found.";
+  if (status === 429)
+    return "Too many requests - slow down.";
+  if (status >= 500)
+    return "Hostwares is having trouble right now.";
+  return `Request failed (HTTP ${status}).`;
+}
+var ApiError, NetworkError, AbortedError;
+var init_errors = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/protocol/errors.js"() {
+    ApiError = class extends Error {
+      status;
+      /** Server-supplied machine code, e.g. "invalid_api_key", "rate_limited". */
+      code;
+      /** Whatever else the error body carried - `balance`, `limit`, `termsUrl`, ... */
+      body;
+      constructor(status, message, code, body = {}) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = code;
+        this.body = body;
+      }
+      /** The credential is dead or missing - re-authenticating can fix this. */
+      get isAuthFailure() {
+        return this.status === 401;
+      }
+      /** Worth retrying after a wait: rate limits and transient server faults. */
+      get isRetryable() {
+        return this.status === 429 || this.status >= 500 && this.status < 600;
+      }
+      /** Out of credits. Actionable by the user, not by a retry. */
+      get isOutOfCredits() {
+        return this.status === 402;
+      }
+    };
+    NetworkError = class extends Error {
+      /** The underlying fetch/DNS/socket error. Named `reason` rather than `cause`
+       *  so it does not shadow Error.cause, which Node uses when printing. */
+      reason;
+      constructor(message, reason) {
+        super(message, { cause: reason });
+        this.name = "NetworkError";
+        this.reason = reason;
+      }
+      get isRetryable() {
+        return true;
+      }
+    };
+    AbortedError = class extends Error {
+      constructor() {
+        super("Aborted");
+        this.name = "AbortedError";
+      }
+    };
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/protocol/sse.js
+async function readSse(body, onFrame, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const raw = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const frame = parseFrame(raw);
+        if (frame)
+          onFrame(frame);
+      }
     }
+  } finally {
+    reader.releaseLock();
+    if (signal?.aborted)
+      throw new AbortedError();
+  }
 }
-function interactive() {
-    showBanner();
-    if (!isAuthenticated()) {
-        ui.line(`  Run ${c.bold("hw login")} to get started.`);
-        ui.line();
-        return Promise.resolve(0);
+function parseFrame(raw) {
+  let event = "message";
+  const dataLines = [];
+  for (const line2 of raw.split("\n")) {
+    if (line2.startsWith(":"))
+      continue;
+    if (line2.startsWith("event:"))
+      event = line2.slice(6).trim();
+    else if (line2.startsWith("data:"))
+      dataLines.push(line2.slice(5).replace(/^ /, ""));
+  }
+  if (dataLines.length === 0)
+    return null;
+  try {
+    return { event, data: JSON.parse(dataLines.join("\n")) };
+  } catch {
+    return null;
+  }
+}
+var init_sse = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/protocol/sse.js"() {
+    init_errors();
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/protocol/client.js
+async function streamChat(creds, req, handlers, opts = {}) {
+  const base = (creds.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  let triedReauth = false;
+  for (; ; ) {
+    if (opts.signal?.aborted)
+      throw new AbortedError();
+    let res;
+    try {
+      res = await fetch(`${base}/api/chat/stream`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream",
+          ...creds.userAgent ? { "User-Agent": creds.userAgent } : {},
+          Authorization: `Bearer ${creds.apiKey}`
+        },
+        body: JSON.stringify(req),
+        signal: opts.signal
+      });
+    } catch (e) {
+      if (opts.signal?.aborted)
+        throw new AbortedError();
+      throw new NetworkError("Could not reach Hostwares. Check your connection.", e);
+    }
+    if (!res.ok) {
+      const err = await apiErrorFromResponse(res);
+      if (err.isAuthFailure && opts.onAuthFailure && !triedReauth) {
+        triedReauth = true;
+        if (await opts.onAuthFailure())
+          continue;
+      }
+      throw err;
     }
-    return startChat({});
+    if (!res.body)
+      throw new NetworkError("Server sent an empty response.", null);
+    return consume(res.body, handlers, opts.signal);
+  }
 }
-function requireAuth() {
-    if (isAuthenticated())
+async function consume(body, h, signal) {
+  let done = null;
+  let streamError = null;
+  await readSse(body, ({ event, data }) => {
+    switch (event) {
+      case "meta":
+        h.onMeta?.(data);
+        break;
+      case "text":
+        h.onText?.(data.content);
+        break;
+      case "tool_start":
+        h.onToolStart?.(data);
+        break;
+      case "tool_executing":
+        h.onToolExecuting?.(data);
+        break;
+      case "tool_done":
+        h.onToolDone?.(data);
+        break;
+      case "local_tool":
+        h.onLocalTool?.(data);
+        break;
+      case "done":
+        done = data;
+        h.onDone?.(done);
+        break;
+      case "error":
+        streamError = String(data?.message ?? "Unknown error");
+        h.onError?.(streamError);
+        break;
+    }
+  }, signal);
+  if (streamError && !done)
+    throw new ApiError(500, streamError, "stream_error");
+  return done;
+}
+async function listConversations(creds, opts = {}) {
+  const base = (creds.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const res = await fetch(`${base}/api/chat/conversations?limit=${opts.limit ?? 15}`, {
+    headers: { Authorization: `Bearer ${creds.apiKey}` },
+    signal: opts.signal
+  });
+  if (!res.ok)
+    throw await apiErrorFromResponse(res);
+  const body = await res.json();
+  const rows = Array.isArray(body) ? body : body.data ?? [];
+  return rows;
+}
+async function resolveAction(creds, action, opts = {}) {
+  const base = (creds.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const body = action.approve ? { confirmAction: action.id } : { rejectAction: action.id };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await fetch(`${base}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${creds.apiKey}` },
+      body: JSON.stringify(body),
+      signal: opts.signal
+    });
+    if (res.ok)
+      return await res.json();
+    const err = await apiErrorFromResponse(res);
+    if (err.isAuthFailure && opts.onAuthFailure && attempt === 0 && await opts.onAuthFailure())
+      continue;
+    throw err;
+  }
+  throw new NetworkError("Could not resolve the action.", null);
+}
+var DEFAULT_BASE_URL;
+var init_client = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/protocol/client.js"() {
+    init_sse();
+    init_errors();
+    DEFAULT_BASE_URL = "https://hostwares.com";
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/protocol/events.js
+var silentSink;
+var init_events = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/protocol/events.js"() {
+    silentSink = () => {
+    };
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/exec.js
+import { spawn } from "child_process";
+function exec(file, args, opts = {}) {
+  return run(file, args, false, opts);
+}
+function execShell(command, opts = {}) {
+  const isWin = process.platform === "win32";
+  const shell = isWin ? process.env.COMSPEC || "cmd.exe" : process.env.SHELL && !process.env.SHELL.includes("fish") ? process.env.SHELL : "/bin/sh";
+  const args = isWin ? ["/d", "/s", "/c", command] : ["-c", command];
+  return run(shell, args, true, opts);
+}
+function run(file, args, viaShell, opts) {
+  return new Promise((resolve2) => {
+    const spawnOpts = {
+      cwd: opts.cwd || process.cwd(),
+      env: opts.env ?? process.env,
+      // Never true: `args` would then be re-parsed by a shell and the argv array
+      // would buy nothing. execShell() runs the shell AS the program instead.
+      shell: false,
+      windowsHide: true
+    };
+    let child;
+    try {
+      child = spawn(file, args, spawnOpts);
+    } catch (e) {
+      return resolve2(failure(startupMessage(e, file, viaShell)));
+    }
+    const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    let stdout = "";
+    let stderr = "";
+    let truncated = false;
+    let timedOut = false;
+    let settled = false;
+    const append = (target, chunk) => {
+      opts.onOutput?.(chunk, target);
+      const current = target === "stdout" ? stdout : stderr;
+      if (current.length >= maxBuffer) {
+        truncated = true;
+        return;
+      }
+      const room = maxBuffer - current.length;
+      const slice = chunk.length > room ? chunk.slice(0, room) : chunk;
+      if (target === "stdout")
+        stdout += slice;
+      else
+        stderr += slice;
+      if (slice.length < chunk.length)
+        truncated = true;
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (c2) => append("stdout", c2));
+    child.stderr?.on("data", (c2) => append("stderr", c2));
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!settled)
+          child.kill("SIGKILL");
+      }, 2e3).unref?.();
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const finish2 = (result) => {
+      if (settled)
         return;
-    ui.error("Not signed in.");
-    ui.note("Run `hw login` first.");
-    process.exit(1);
+      settled = true;
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      resolve2(truncated ? { ...result, stdout: mark(result.stdout), stderr: mark(result.stderr) } : result);
+    };
+    child.on("error", (e) => finish2(failure(startupMessage(e, file, viaShell), stdout, stderr)));
+    child.on("close", (code, signal) => finish2({
+      stdout,
+      stderr,
+      code,
+      signal,
+      timedOut,
+      ok: code === 0 && !timedOut
+    }));
+  });
 }
-function showBanner() {
-    const tag = [
-        `  ${c.bold("Hostwares")} ${c.dim(`v${VERSION}`)}`,
-        `  ${c.dim("AI DevOps in your terminal")}`,
-        "",
-        isAuthenticated()
-            ? `  ${c.green(glyph.tick)} ${c.dim("Signed in")}`
-            : `  ${c.dim(`${glyph.arrow} Not signed in`)}`,
-    ];
-    ui.line();
-    BANNER_LINES.forEach((art, i) => ui.line(`  ${c.green(art)}${tag[i] ?? ""}`));
-    ui.line();
-    ui.line(c.dim(`  Ask anything. ${c.bold("/help")} for commands, ${c.bold("!cmd")} for a shell command.`));
-    ui.line();
+function mark(s) {
+  return s ? `${s}
+... (output truncated)` : s;
 }
-function showHelp() {
-    ui.line();
-    ui.line(`  ${c.bold("hw")} ${c.dim("— AI DevOps in your terminal")}`);
-    ui.line();
-    const rows = [
-        ["hw", "Start an interactive session"],
-        ["hw ask \"...\"", "Ask one question and exit"],
-        ["hw chat --resume", "Continue this folder's last conversation"],
-        ["hw list", "List your deployments"],
-        ["hw sessions", "Sessions saved on this machine"],
-        ["hw login", "Sign in (--token <key> for CI)"],
-        ["hw logout", "Sign out on this machine"],
-        ["hw version", "Print the version"],
+function startupMessage(e, file, viaShell) {
+  const code = e?.code;
+  if (code === "ENOENT")
+    return `${viaShell ? "shell" : file}: command not found`;
+  if (code === "EACCES")
+    return `${file}: permission denied`;
+  return e instanceof Error ? e.message : String(e);
+}
+function failure(message, stdout = "", stderr = "") {
+  return { stdout, stderr: stderr || message, code: null, signal: null, timedOut: false, ok: false };
+}
+function formatResult(r, opts = {}) {
+  const maxChars = opts.maxChars ?? 3e4;
+  const parts = [];
+  if (r.timedOut)
+    parts.push("[command timed out and was killed]");
+  else if (r.code === null && r.signal)
+    parts.push(`[killed by ${r.signal}]`);
+  else if (!r.ok)
+    parts.push(`[command failed: exit code ${r.code}]`);
+  const out = r.stdout.trimEnd();
+  const err = r.stderr.trimEnd();
+  if (out)
+    parts.push(out);
+  if (err)
+    parts.push(r.ok ? err : `stderr:
+${err}`);
+  if (parts.length === 0)
+    return r.ok ? "(no output)" : `[command failed: exit code ${r.code}]`;
+  const text = parts.join("\n");
+  return text.length > maxChars ? `${text.slice(0, maxChars)}
+... (truncated, ${text.length - maxChars} more characters)` : text;
+}
+var DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER;
+var init_exec = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/exec.js"() {
+    DEFAULT_TIMEOUT_MS = 12e4;
+    DEFAULT_MAX_BUFFER = 4 * 1024 * 1024;
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/tools.js
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, readdirSync, statSync, rmSync } from "fs";
+import { resolve as pathResolve, join, dirname } from "path";
+import { homedir, platform, arch, release, totalmem, freemem, cpus } from "os";
+import { spawn as spawn2 } from "child_process";
+function appendBg(p, chunk) {
+  p.output += chunk;
+  if (p.output.length > BG_MAX_OUTPUT) {
+    p.output = "... (earlier output trimmed)\n" + p.output.slice(p.output.length - BG_MAX_OUTPUT);
+  }
+}
+function str(input, key) {
+  const v = input[key];
+  if (v === void 0 || v === null)
+    return void 0;
+  const s = String(v);
+  return s.length ? s : void 0;
+}
+function num(input, key) {
+  const v = Number(input[key]);
+  return Number.isFinite(v) ? v : void 0;
+}
+function bool(input, key) {
+  return input[key] === true || input[key] === "true";
+}
+function required(input, key) {
+  const v = str(input, key);
+  if (v === void 0)
+    throw new ToolInputError(`Missing required argument "${key}".`);
+  return v;
+}
+function resolvePath(p) {
+  const expanded = p === "~" ? homedir() : p.startsWith("~/") ? join(homedir(), p.slice(2)) : p;
+  return pathResolve(expanded);
+}
+async function executeLocalTool(name, rawInput, runOpts = {}) {
+  const input = rawInput ?? {};
+  try {
+    return await run2(name, input, runOpts);
+  } catch (e) {
+    if (e instanceof ToolInputError)
+      return `Error: ${e.message}`;
+    return `Error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+async function run2(name, input, runOpts) {
+  const cwd = str(input, "workingDir") ?? str(input, "directory");
+  const dir = cwd ? resolvePath(cwd) : runOpts.cwd ?? process.cwd();
+  const execOpts = { signal: runOpts.signal, onOutput: runOpts.onOutput };
+  switch (name) {
+    // ── filesystem ──────────────────────────────────────────────────────────
+    case "read_file": {
+      const path = resolvePath(required(input, "path"));
+      if (!existsSync(path))
+        return `Error: no such file: ${path}`;
+      const st = statSync(path);
+      if (st.isDirectory())
+        return `Error: ${path} is a directory. Use list_directory.`;
+      if (st.size > MAX_READ_BYTES) {
+        return `Error: ${path} is ${(st.size / 1e6).toFixed(1)}MB, too large to read in full. Use search_files, or read part of it with run_command.`;
+      }
+      return readFileSync(path, "utf8") || "(empty file)";
+    }
+    case "write_file": {
+      const path = resolvePath(required(input, "path"));
+      const content = str(input, "content") ?? "";
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, content, "utf8");
+      return `Wrote ${content.length} characters to ${path}`;
+    }
+    // Internal: patch is computed in loop.ts via buildPatch, not here.
+    // This case is only reachable if loop bypasses (tests); keep minimal.
+    case "append_file": {
+      const path = resolvePath(required(input, "path"));
+      const content = str(input, "content") ?? "";
+      if (!existsSync(path))
+        return `Error: no such file: ${path}. Use write_file to create it.`;
+      appendFileSync(path, content, "utf8");
+      return `Appended ${content.length} characters to ${path}`;
+    }
+    case "str_replace_file": {
+      const path = resolvePath(required(input, "path"));
+      const oldStr = required(input, "oldStr");
+      const newStr = str(input, "newStr") ?? "";
+      if (!existsSync(path))
+        return `Error: no such file: ${path}`;
+      const body = readFileSync(path, "utf8");
+      const count = body.split(oldStr).length - 1;
+      if (count === 0)
+        return `Error: the text to replace was not found in ${path}. Read the file and match it exactly, including whitespace.`;
+      if (count > 1)
+        return `Error: found ${count} occurrences in ${path}. Include more surrounding context so the match is unique.`;
+      writeFileSync(path, body.replace(oldStr, newStr), "utf8");
+      return `Replaced 1 occurrence in ${path}`;
+    }
+    case "list_directory": {
+      const path = resolvePath(str(input, "path") ?? ".");
+      if (!existsSync(path))
+        return `Error: no such directory: ${path}`;
+      const entries = listDir(path, bool(input, "recursive"));
+      return entries.length ? entries.join("\n") : "(empty directory)";
+    }
+    case "delete_path": {
+      const path = resolvePath(required(input, "path"));
+      if (!existsSync(path))
+        return `Error: no such path: ${path}`;
+      const denied = ["/", "/usr", "/etc", "/var", "/bin", "/sbin", "/lib", "/System", "/Users", "/home", "C:\\", "C:\\Windows"];
+      if (path === homedir() || denied.some((d) => pathResolve(d) === path)) {
+        return `Error: refusing to delete ${path} - that is a system or home directory.`;
+      }
+      rmSync(path, { recursive: true, force: true });
+      return `Deleted ${path}`;
+    }
+    case "search_files": {
+      const pattern = required(input, "pattern");
+      const include = str(input, "include");
+      const args = ["-rn", "--binary-files=without-match"];
+      if (include)
+        args.push(`--include=${include}`);
+      args.push("-e", pattern, dir);
+      const r = await exec("grep", args, { cwd: dir, timeoutMs: 6e4 });
+      if (r.code === 1 && !r.stderr.trim())
+        return "No matches found.";
+      return formatResult(r, { maxChars: 2e4 });
+    }
+    case "file_search": {
+      const pattern = required(input, "pattern");
+      const args = [
+        dir,
+        "-type",
+        "f",
+        "-not",
+        "-path",
+        "*/node_modules/*",
+        "-not",
+        "-path",
+        "*/.git/*",
+        "-iname",
+        pattern.includes("*") ? pattern : `*${pattern}*`
+      ];
+      const r = await exec("find", args, { cwd: dir, timeoutMs: 3e4 });
+      if (!r.stdout.trim())
+        return "No files matched.";
+      const lines = r.stdout.trim().split("\n").slice(0, 200);
+      return lines.join("\n") + (lines.length === 200 ? "\n\u2026 (truncated at 200)" : "");
+    }
+    // ── shell ───────────────────────────────────────────────────────────────
+    case "run_command": {
+      const command = required(input, "command");
+      return formatResult(await execShell(command, { ...execOpts, cwd: dir, timeoutMs: num(input, "timeoutMs") ?? 12e4 }));
+    }
+    case "install_package":
+      return formatResult(await installPackage(required(input, "name"), execOpts));
+    case "get_system_info":
+      return systemInfo();
+    // ── git ─────────────────────────────────────────────────────────────────
+    case "git_status":
+      return formatResult(await exec("git", ["status", "--short", "--branch"], { cwd: dir }));
+    case "git_add": {
+      const files = required(input, "files");
+      const paths = files.trim() === "." ? ["."] : files.split(/\s+/).filter(Boolean);
+      return formatResult(await exec("git", ["add", "--", ...paths], { cwd: dir }));
+    }
+    case "git_commit": {
+      const message = required(input, "message");
+      return formatResult(await exec("git", ["commit", "-m", message], { cwd: dir }));
+    }
+    case "git_push": {
+      const args = ["push"];
+      const remote = str(input, "remote");
+      const branch = str(input, "branch");
+      if (remote)
+        args.push(remote);
+      if (branch)
+        args.push(branch);
+      return formatResult(await exec("git", args, { cwd: dir, timeoutMs: 18e4 }));
+    }
+    case "git_pull": {
+      const args = ["pull"];
+      const remote = str(input, "remote");
+      const branch = str(input, "branch");
+      if (remote)
+        args.push(remote);
+      if (branch)
+        args.push(branch);
+      return formatResult(await exec("git", args, { cwd: dir, timeoutMs: 18e4 }));
+    }
+    case "git_clone": {
+      const url = required(input, "url");
+      const target = str(input, "directory");
+      const args = ["clone", url];
+      if (target)
+        args.push(resolvePath(target));
+      return formatResult(await exec("git", args, { timeoutMs: 3e5 }));
+    }
+    case "git_log": {
+      const count = Math.min(Math.max(num(input, "count") ?? 10, 1), 200);
+      return formatResult(await exec("git", ["log", `-${count}`, "--oneline", "--decorate"], { cwd: dir }));
+    }
+    case "git_diff": {
+      const args = ["diff"];
+      if (bool(input, "staged"))
+        args.push("--staged");
+      const path = str(input, "path");
+      if (path)
+        args.push("--", path);
+      return formatResult(await exec("git", args, { cwd: dir }), { maxChars: 4e4 });
+    }
+    case "git_branch": {
+      const action = str(input, "action") ?? "list";
+      if (action === "list")
+        return formatResult(await exec("git", ["branch", "-vv"], { cwd: dir }));
+      const branch = str(input, "name");
+      if (!branch)
+        return `Error: "name" is required for git_branch action "${action}".`;
+      if (action === "create")
+        return formatResult(await exec("git", ["checkout", "-b", branch], { cwd: dir }));
+      if (action === "switch")
+        return formatResult(await exec("git", ["checkout", branch], { cwd: dir }));
+      if (action === "delete")
+        return formatResult(await exec("git", ["branch", "-d", branch], { cwd: dir }));
+      return `Error: unknown git_branch action "${action}". Use list, create, switch or delete.`;
+    }
+    case "check_github_auth": {
+      const gh = await exec("gh", ["auth", "status"], { cwd: dir, timeoutMs: 15e3 });
+      if (gh.code !== null)
+        return formatResult(gh);
+      const name2 = (await exec("git", ["config", "user.name"], { cwd: dir })).stdout.trim();
+      const email = (await exec("git", ["config", "user.email"], { cwd: dir })).stdout.trim();
+      return `GitHub CLI (gh) is not installed.
+git user.name: ${name2 || "(unset)"}
+git user.email: ${email || "(unset)"}`;
+    }
+    // ── ssh ─────────────────────────────────────────────────────────────────
+    case "ssh_run": {
+      const host = required(input, "host");
+      const user = required(input, "user");
+      const command = required(input, "command");
+      return formatResult(await sshRun(host, user, command, execOpts, str(input, "password"), str(input, "keyPath")));
+    }
+    case "ssh_upload":
+    case "ssh_download": {
+      const host = required(input, "host");
+      const user = required(input, "user");
+      const localPath = resolvePath(required(input, "localPath"));
+      const remotePath = required(input, "remotePath");
+      return formatResult(await scp(host, user, localPath, remotePath, name === "ssh_upload", execOpts, str(input, "password"), str(input, "keyPath")));
+    }
+    // ── processes ───────────────────────────────────────────────────────────
+    case "list_processes": {
+      const filter = str(input, "filter");
+      const ps = await exec("ps", ["aux"], { timeoutMs: 2e4 });
+      if (!ps.ok)
+        return formatResult(ps);
+      const lines = ps.stdout.split("\n");
+      const body = filter ? lines.filter((l, i) => i === 0 || l.toLowerCase().includes(filter.toLowerCase())) : lines.slice(0, 40);
+      return body.length > 1 ? body.join("\n") : `No processes matching "${filter}".`;
+    }
+    case "kill_process": {
+      const target = required(input, "target");
+      const r = await (/^\d+$/.test(target) ? exec("kill", [target]) : exec("pkill", ["-f", target]));
+      if (r.code === 1 && !r.stderr.trim())
+        return `No process matched "${target}".`;
+      return r.ok ? `Killed ${target}` : formatResult(r);
+    }
+    // ── background processes ──────────────────────────────────────────────────
+    case "start_process": {
+      const command = required(input, "command");
+      const label = str(input, "name") ?? command.split(/\s+/)[0] ?? "process";
+      if (BG.has(label) && BG.get(label).exitCode === null) {
+        return `A background process named "${label}" is already running (pid ${BG.get(label).pid}). Use get_process_output to watch it, or stop_process to stop it first.`;
+      }
+      const isWin = process.platform === "win32";
+      const shell = isWin ? process.env.COMSPEC || "cmd.exe" : process.env.SHELL && !process.env.SHELL.includes("fish") ? process.env.SHELL : "/bin/sh";
+      const args = isWin ? ["/d", "/s", "/c", command] : ["-c", command];
+      let child;
+      try {
+        child = spawn2(shell, args, { cwd: dir, env: process.env, detached: !isWin, windowsHide: true });
+      } catch (e) {
+        return `Error: could not start "${label}": ${e instanceof Error ? e.message : String(e)}`;
+      }
+      const proc = {
+        name: label,
+        command,
+        cwd: dir,
+        pid: child.pid,
+        startedAt: Date.now(),
+        output: "",
+        exitCode: null,
+        exitSignal: null,
+        child
+      };
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      child.stdout?.on("data", (c2) => appendBg(proc, c2));
+      child.stderr?.on("data", (c2) => appendBg(proc, c2));
+      child.on("error", (e) => appendBg(proc, `
+[spawn error] ${e instanceof Error ? e.message : String(e)}
+`));
+      child.on("close", (code, signal) => {
+        proc.exitCode = code ?? -1;
+        proc.exitSignal = signal;
+      });
+      BG.set(label, proc);
+      await new Promise((r) => setTimeout(r, 800));
+      const early = proc.output.slice(0, 4e3);
+      const status = proc.exitCode === null ? `started (pid ${proc.pid}), still running` : `exited immediately with code ${proc.exitCode}${proc.exitSignal ? ` (${proc.exitSignal})` : ""}`;
+      return `Background process "${label}": ${status}.
+Command: ${command}
+Dir: ${dir}
+` + (early ? `
+Early output:
+${early}` : `
+(no output yet - poll with get_process_output "${label}")`) + `
+
+Use get_process_output to read more, check_port to confirm it is listening, then open_browser to show the user.`;
+    }
+    case "get_process_output": {
+      const label = str(input, "name");
+      if (!label) {
+        if (!BG.size)
+          return "No background processes have been started.";
+        return "Background processes:\n" + [...BG.values()].map((p2) => `- ${p2.name} (pid ${p2.pid}): ${p2.exitCode === null ? "running" : `exited ${p2.exitCode}`} - ${p2.command}`).join("\n");
+      }
+      const p = BG.get(label);
+      if (!p)
+        return `Error: no background process named "${label}". Running: ${[...BG.keys()].join(", ") || "(none)"}.`;
+      const tail = str(input, "tail");
+      const body = tail === "false" ? p.output : p.output.slice(-8e3);
+      const status = p.exitCode === null ? `running (pid ${p.pid}, ${Math.round((Date.now() - p.startedAt) / 1e3)}s)` : `exited with code ${p.exitCode}${p.exitSignal ? ` (${p.exitSignal})` : ""}`;
+      return `"${label}" - ${status}.
+${body || "(no output yet)"}`;
+    }
+    case "stop_process": {
+      const label = required(input, "name");
+      const p = BG.get(label);
+      if (!p)
+        return `Error: no background process named "${label}". Running: ${[...BG.keys()].join(", ") || "(none)"}.`;
+      if (p.exitCode !== null) {
+        BG.delete(label);
+        return `"${label}" had already exited (code ${p.exitCode}).`;
+      }
+      try {
+        if (p.pid && process.platform !== "win32") {
+          try {
+            process.kill(-p.pid, "SIGTERM");
+          } catch {
+            p.child.kill("SIGTERM");
+          }
+        } else
+          p.child.kill("SIGTERM");
+      } catch (e) {
+        return `Error stopping "${label}": ${e instanceof Error ? e.message : String(e)}`;
+      }
+      BG.delete(label);
+      return `Stopped background process "${label}".`;
+    }
+    case "open_browser": {
+      const url = required(input, "url");
+      if (!/^https?:\/\//i.test(url) && !url.startsWith("file://")) {
+        return `Error: open_browser needs an http(s) or file URL, got "${url}".`;
+      }
+      const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+      const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+      const r = await exec(opener, args, { timeoutMs: 1e4 });
+      return r.ok || r.code === null ? `Opened ${url} in the user's browser. Ask them to confirm the preview looks right.` : `Could not open a browser (${formatResult(r)}). Tell the user to visit ${url} manually.`;
+    }
+    case "wait_for_url": {
+      const url = required(input, "url");
+      if (!/^https?:\/\//i.test(url))
+        return `Error: wait_for_url needs an http(s) URL, got "${url}".`;
+      const timeoutMs = Math.min(Math.max(num(input, "timeoutMs") ?? 3e4, 1e3), 12e4);
+      const deadline = Date.now() + timeoutMs;
+      let lastErr = "";
+      let attempts = 0;
+      while (Date.now() < deadline) {
+        if (runOpts.signal?.aborted)
+          return "Cancelled while waiting for the URL.";
+        attempts++;
+        try {
+          const ctrl = new AbortController();
+          const t = setTimeout(() => ctrl.abort(), 5e3);
+          const res = await fetch(url, { signal: ctrl.signal, redirect: "manual" });
+          clearTimeout(t);
+          const body = res.status < 400 ? await res.text().catch(() => "") : "";
+          const title = (body.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1] ?? "").trim();
+          const elapsed = timeoutMs - (deadline - Date.now());
+          return `${url} responded ${res.status}${title ? ` \u2014 "${title}"` : ""} after ${(elapsed / 1e3).toFixed(1)}s (${attempts} attempt${attempts === 1 ? "" : "s"}). The server is up.`;
+        } catch (e) {
+          lastErr = e instanceof Error ? e.message : String(e);
+          await new Promise((r) => setTimeout(r, 500));
+        }
+      }
+      return `${url} did not respond within ${(timeoutMs / 1e3).toFixed(0)}s (${attempts} attempts). Last error: ${lastErr}. Check the process output \u2014 it may have crashed on boot or bound a different port.`;
+    }
+    // ── docker ──────────────────────────────────────────────────────────────
+    case "docker_ps": {
+      const args = ["ps", "--format", "table {{.Names}}	{{.Status}}	{{.Ports}}"];
+      if (bool(input, "all"))
+        args.splice(1, 0, "-a");
+      return formatResult(await exec("docker", args, { timeoutMs: 3e4 }));
+    }
+    case "docker_logs": {
+      const container = required(input, "container");
+      const lines = Math.min(Math.max(num(input, "lines") ?? 50, 1), 2e3);
+      return formatResult(await exec("docker", ["logs", "--tail", String(lines), container], { timeoutMs: 3e4 }), { maxChars: 3e4 });
+    }
+    case "docker_exec": {
+      const container = required(input, "container");
+      const command = required(input, "command");
+      return formatResult(await exec("docker", ["exec", container, "sh", "-lc", command], { timeoutMs: 12e4 }));
+    }
+    // ── network ─────────────────────────────────────────────────────────────
+    case "check_port": {
+      const port = num(input, "port");
+      if (port === void 0)
+        return `Error: "port" must be a number.`;
+      const host = str(input, "host");
+      if (host && host !== "localhost" && host !== "127.0.0.1")
+        return probeRemotePort(host, port);
+      const r = await exec("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN"], { timeoutMs: 15e3 });
+      if (r.code === 1 && !r.stderr.trim())
+        return `Nothing is listening on port ${port}.`;
+      if (r.code === null)
+        return probeRemotePort("127.0.0.1", port);
+      return formatResult(r);
+    }
+    case "curl_request":
+      return httpRequest(input);
+    // ── web ─────────────────────────────────────────────────────────────────
+    case "web_search":
+      return webSearch(required(input, "query"));
+    case "web_fetch":
+      return webFetch(required(input, "url"));
+    case "spawn_subagents":
+      return "spawn_subagents is handled by the agent loop, not as a local tool.";
+    case "todo_list": {
+      const action = str(input, "action") ?? "list";
+      if (action === "create") {
+        const items = input.items;
+        if (Array.isArray(items))
+          TODOS = items.map((t) => ({ text: String(t), done: false }));
+        else if (str(input, "text"))
+          TODOS.push({ text: required(input, "text"), done: false });
+      } else if (action === "complete") {
+        const idx = num(input, "index");
+        if (idx !== void 0 && TODOS[idx])
+          TODOS[idx].done = true;
+        else {
+          const t = str(input, "text");
+          const found = TODOS.find((x) => x.text === t);
+          if (found)
+            found.done = true;
+        }
+      }
+      if (!TODOS.length)
+        return "(no todos)";
+      return TODOS.map((t, i) => `${t.done ? "[x]" : "[ ]"} ${i}. ${t.text}`).join("\n");
+    }
+    default:
+      return `Error: "${name}" is not a tool this CLI can run. It may need a newer CLI - run \`hw update\`.`;
+  }
+}
+function listDir(root2, recursive) {
+  const out = [];
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", "dist", "build", "__pycache__", ".venv", "vendor"]);
+  const MAX_ENTRIES = 500;
+  const walk = (dir, prefix, depth) => {
+    if (out.length >= MAX_ENTRIES || depth > 8)
+      return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (out.length >= MAX_ENTRIES) {
+        out.push(`... (truncated at ${MAX_ENTRIES} entries)`);
+        return;
+      }
+      if (e.name.startsWith(".") && e.name !== ".env.example")
+        continue;
+      const rel = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        out.push(`${rel}/`);
+        if (recursive && !SKIP.has(e.name))
+          walk(join(dir, e.name), rel, depth + 1);
+      } else {
+        let size = "";
+        try {
+          size = ` (${formatBytes(statSync(join(dir, e.name)).size)})`;
+        } catch {
+        }
+        out.push(`${rel}${size}`);
+      }
+    }
+  };
+  walk(root2, "", 0);
+  return out;
+}
+function formatBytes(n) {
+  if (n < 1024)
+    return `${n}B`;
+  if (n < 1024 * 1024)
+    return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+async function installPackage(pkg, opts) {
+  const os = platform();
+  const tries = os === "darwin" ? [["brew", ["install", pkg]], ["npm", ["install", "-g", pkg]]] : os === "win32" ? [["winget", ["install", "-e", "--id", pkg, "--silent"]], ["npm", ["install", "-g", pkg]]] : [
+    ["apt-get", ["install", "-y", pkg]],
+    ["dnf", ["install", "-y", pkg]],
+    ["yum", ["install", "-y", pkg]],
+    ["pacman", ["-S", "--noconfirm", pkg]],
+    ["npm", ["install", "-g", pkg]]
+  ];
+  let last = null;
+  for (const [bin, args] of tries) {
+    const r = await exec(bin, args, { ...opts, timeoutMs: 6e5 });
+    if (r.code !== null)
+      return r;
+    last = r;
+  }
+  return last ?? { stdout: "", stderr: "no package manager found", code: null, signal: null, timedOut: false, ok: false };
+}
+async function systemInfo() {
+  const v = async (bin, args) => {
+    const r = await exec(bin, args, { timeoutMs: 1e4 });
+    return r.ok ? r.stdout.trim().split("\n")[0] : "(not installed)";
+  };
+  const [npmV, gitV, dockerV, gitName, gitEmail] = await Promise.all([
+    v("npm", ["--version"]),
+    v("git", ["--version"]),
+    v("docker", ["--version"]),
+    exec("git", ["config", "user.name"]).then((r) => r.stdout.trim()),
+    exec("git", ["config", "user.email"]).then((r) => r.stdout.trim())
+  ]);
+  const gb = (n) => `${(n / 1024 ** 3).toFixed(1)}GB`;
+  return [
+    `OS: ${platform()} ${release()} (${arch()})`,
+    `CPU: ${cpus()[0]?.model ?? "unknown"} x${cpus().length}`,
+    `Memory: ${gb(totalmem() - freemem())} used / ${gb(totalmem())} total`,
+    `Node: ${process.version}`,
+    `npm: ${npmV}`,
+    `git: ${gitV}`,
+    `docker: ${dockerV}`,
+    `git user: ${gitName || "(unset)"} <${gitEmail || "unset"}>`,
+    `cwd: ${process.cwd()}`,
+    `home: ${homedir()}`
+  ].join("\n");
+}
+async function sshRun(host, user, command, opts, password, keyPath) {
+  const target = `${user}@${host}`;
+  if (password) {
+    if (!await hasBinary("sshpass")) {
+      return failed("sshpass is not installed, so password-based SSH is unavailable. Install it (macOS: brew install hudochenkov/sshpass/sshpass, Debian/Ubuntu: apt-get install sshpass) or connect with a key using keyPath.");
+    }
+    return exec("sshpass", ["-e", "ssh", ...SSH_OPTS, "-o", "PubkeyAuthentication=no", target, command], { ...opts, timeoutMs: 12e4, env: { ...process.env, SSHPASS: password } });
+  }
+  const args = [...SSH_OPTS, ...SSH_NONINTERACTIVE];
+  if (keyPath)
+    args.push("-i", resolvePath(keyPath));
+  args.push(target, command);
+  return exec("ssh", args, { ...opts, timeoutMs: 12e4 });
+}
+async function scp(host, user, localPath, remotePath, upload, opts, password, keyPath) {
+  const remote = `${user}@${host}:${remotePath}`;
+  const base = [...SSH_OPTS, "-r"];
+  if (keyPath)
+    base.push("-i", resolvePath(keyPath));
+  const paths = upload ? [localPath, remote] : [remote, localPath];
+  if (password) {
+    if (!await hasBinary("sshpass"))
+      return failed("sshpass is not installed, so password-based SCP is unavailable. Use a key with keyPath instead.");
+    return exec("sshpass", ["-e", "scp", ...base, ...paths], { ...opts, timeoutMs: 6e5, env: { ...process.env, SSHPASS: password } });
+  }
+  return exec("scp", [...base, ...SSH_NONINTERACTIVE, ...paths], { ...opts, timeoutMs: 6e5 });
+}
+async function hasBinary(bin) {
+  return (await (platform() === "win32" ? exec("where", [bin]) : exec("which", [bin]))).ok;
+}
+function failed(message) {
+  return { stdout: "", stderr: message, code: 1, signal: null, timedOut: false, ok: false };
+}
+async function probeRemotePort(host, port) {
+  const net = await import("net");
+  return new Promise((resolve2) => {
+    const socket = new net.Socket();
+    const done = (msg) => {
+      socket.destroy();
+      resolve2(msg);
+    };
+    socket.setTimeout(5e3);
+    socket.once("connect", () => done(`Port ${port} on ${host} is open.`));
+    socket.once("timeout", () => done(`Port ${port} on ${host} timed out (filtered or closed).`));
+    socket.once("error", (e) => done(`Port ${port} on ${host} is not reachable: ${e.code ?? e.message}`));
+    socket.connect(port, host);
+  });
+}
+async function httpRequest(input) {
+  const url = required(input, "url");
+  const method = (str(input, "method") ?? "GET").toUpperCase();
+  const body = str(input, "body");
+  let headers = {};
+  const rawHeaders = input.headers;
+  if (typeof rawHeaders === "string" && rawHeaders.trim()) {
+    try {
+      headers = JSON.parse(rawHeaders);
+    } catch {
+      for (const line2 of rawHeaders.split("\n")) {
+        const i = line2.indexOf(":");
+        if (i > 0)
+          headers[line2.slice(0, i).trim()] = line2.slice(i + 1).trim();
+      }
+    }
+  } else if (rawHeaders && typeof rawHeaders === "object") {
+    headers = Object.fromEntries(Object.entries(rawHeaders).map(([k, v]) => [k, String(v)]));
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const res = await fetch(url, { method, headers, body, signal: controller.signal, redirect: "follow" });
+    const text = await res.text();
+    const shown = text.length > 2e4 ? `${text.slice(0, 2e4)}
+... (truncated)` : text;
+    const headerLines = [...res.headers.entries()].filter(([k]) => ["content-type", "location", "server", "cache-control"].includes(k)).map(([k, v]) => `${k}: ${v}`);
+    return [`HTTP ${res.status} ${res.statusText}`, ...headerLines, "", shown].join("\n");
+  } catch (e) {
+    return `Error: request to ${url} failed: ${e instanceof Error ? e.message : String(e)}`;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function webSearch(query) {
+  const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 2e4);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok)
+      return `Error: search failed with HTTP ${res.status}.`;
+    const data = await res.json();
+    const parts = [];
+    if (data.Answer)
+      parts.push(String(data.Answer));
+    if (data.AbstractText)
+      parts.push(`${data.AbstractText}${data.AbstractURL ? `
+Source: ${data.AbstractURL}` : ""}`);
+    if (data.Definition)
+      parts.push(data.Definition);
+    const related = (data.RelatedTopics ?? []).filter((t) => t.Text).slice(0, 8).map((t) => `- ${t.Text}${t.FirstURL ? ` (${t.FirstURL})` : ""}`);
+    if (related.length)
+      parts.push(`Related:
+${related.join("\n")}`);
+    if (!parts.length) {
+      return `No instant answer for "${query}". This tool only returns DuckDuckGo instant answers, which are empty for most specific or recent queries - it is not a full web index. Try web_fetch on a known URL, or answer from what you already know and say it may be out of date.`;
+    }
+    return parts.join("\n\n");
+  } catch (e) {
+    return `Error: search failed: ${e instanceof Error ? e.message : String(e)}`;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function webFetch(url) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      redirect: "follow",
+      // Plenty of documentation sites return a JS shell or a 403 to an
+      // unrecognised agent.
+      headers: { "User-Agent": "Mozilla/5.0 (compatible; hostwares-cli)" }
+    });
+    if (!res.ok)
+      return `Error: ${url} returned HTTP ${res.status}.`;
+    const type = res.headers.get("content-type") ?? "";
+    const raw = await res.text();
+    const text = type.includes("html") ? htmlToText(raw) : raw;
+    return text.length > 3e4 ? `${text.slice(0, 3e4)}
+... (truncated)` : text || "(empty response)";
+  } catch (e) {
+    return `Error: could not fetch ${url}: ${e instanceof Error ? e.message : String(e)}`;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<noscript[\s\S]*?<\/noscript>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<\/(p|div|section|article|h[1-6]|li|tr|br)>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/[ \t]+/g, " ").replace(/\n\s*\n\s*\n+/g, "\n\n").trim();
+}
+var LOCAL_TOOL_NAMES, TODOS, BG, BG_MAX_OUTPUT, KNOWN, ToolInputError, MAX_READ_BYTES, SSH_OPTS, SSH_NONINTERACTIVE;
+var init_tools = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/tools.js"() {
+    init_exec();
+    LOCAL_TOOL_NAMES = [
+      "read_file",
+      "write_file",
+      "list_directory",
+      "search_files",
+      "file_search",
+      "delete_path",
+      "run_command",
+      "install_package",
+      "get_system_info",
+      "git_status",
+      "git_add",
+      "git_commit",
+      "git_push",
+      "git_pull",
+      "git_clone",
+      "git_log",
+      "git_diff",
+      "git_branch",
+      "check_github_auth",
+      "ssh_run",
+      "ssh_upload",
+      "ssh_download",
+      "str_replace_file",
+      "append_file",
+      "list_processes",
+      "kill_process",
+      "start_process",
+      "get_process_output",
+      "stop_process",
+      "open_browser",
+      "wait_for_url",
+      "spawn_subagents",
+      "docker_ps",
+      "docker_logs",
+      "docker_exec",
+      "check_port",
+      "curl_request",
+      "web_search",
+      "web_fetch",
+      "todo_list"
+    ];
+    TODOS = [];
+    BG = /* @__PURE__ */ new Map();
+    BG_MAX_OUTPUT = 256 * 1024;
+    KNOWN = new Set(LOCAL_TOOL_NAMES);
+    ToolInputError = class extends Error {
+    };
+    MAX_READ_BYTES = 2 * 1024 * 1024;
+    SSH_OPTS = [
+      "-o",
+      "StrictHostKeyChecking=no",
+      "-o",
+      "UserKnownHostsFile=/dev/null",
+      "-o",
+      "ConnectTimeout=10",
+      "-o",
+      "ServerAliveInterval=5",
+      "-o",
+      "ServerAliveCountMax=3"
     ];
-    for (const [name, help] of rows)
-        ui.line(`  ${c.green(name.padEnd(20))} ${c.dim(help)}`);
-    ui.line();
-    ui.line(c.dim("  Anything else is treated as a question: hw why is my deploy failing"));
-    ui.line();
+    SSH_NONINTERACTIVE = ["-o", "BatchMode=yes"];
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/steering.js
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, existsSync as existsSync2, statSync as statSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function steeringDirs(cwd) {
+  return [join2(cwd, ".hostwares", "steering"), join2(homedir2(), ".hostwares", "steering")];
 }
-function showSessions() {
-    const sessions = listSessions();
-    if (!sessions.length) {
-        ui.line(c.dim("  No saved sessions yet."));
-        return 0;
+function parseFrontMatter(raw) {
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m)
+    return { meta: {}, body: raw };
+  const meta = {};
+  for (const line2 of m[1].split(/\r?\n/)) {
+    const kv = line2.match(/^([A-Za-z0-9_]+)\s*:\s*(.*)$/);
+    if (kv)
+      meta[kv[1]] = kv[2].trim().replace(/^["']|["']$/g, "");
+  }
+  return { meta, body: m[2] };
+}
+function readSteeringDocs(cwd) {
+  const docs = [];
+  for (const dir of steeringDirs(cwd)) {
+    let entries;
+    try {
+      if (!existsSync2(dir))
+        continue;
+      entries = readdirSync2(dir).filter((f) => f.toLowerCase().endsWith(".md")).sort();
+    } catch {
+      continue;
     }
-    ui.line();
-    for (const s of sessions.slice(0, 25)) {
-        const here = s.cwd === process.cwd() ? c.green(`  ${glyph.tick} here`) : "";
-        ui.line(`  ${s.cwd}${here}`);
-        ui.line(c.dim(`    ${s.turnCount} turns · ${s.creditsSpent.toFixed(2)} credits`));
+    for (const file of entries) {
+      const full = join2(dir, file);
+      try {
+        if (statSync2(full).size > MAX_STEERING_BYTES)
+          continue;
+        const { meta, body } = parseFrontMatter(readFileSync2(full, "utf8"));
+        const inclusion = meta.inclusion === "fileMatch" || meta.inclusion === "manual" ? meta.inclusion : "always";
+        docs.push({
+          name: file.replace(/\.md$/i, ""),
+          path: full,
+          inclusion,
+          fileMatchPattern: meta.fileMatchPattern || meta.filematchpattern,
+          body: body.trim()
+        });
+      } catch {
+      }
     }
-    ui.line();
-    return 0;
+  }
+  return docs;
 }
-/**
- * A real API call, not a prompt in disguise.
- *
- * The sidebar calls these "Deployments" while the model and the route are still
- * "sites"; the user-facing word follows the product.
- */
-async function listSites() {
+function globToRe(glob) {
+  const esc = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(esc);
+}
+function buildSteeringContext(cwd, message) {
+  const docs = readSteeringDocs(cwd);
+  if (!docs.length)
+    return "";
+  const chosen = docs.filter((d) => {
+    if (d.inclusion === "always")
+      return true;
+    if (d.inclusion === "fileMatch" && d.fileMatchPattern) {
+      try {
+        return globToRe(d.fileMatchPattern).test(message);
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  });
+  if (!chosen.length)
+    return "";
+  const parts = [
+    "## PROJECT STEERING (persistent context for this workspace - treat as trusted background, not instructions to obey blindly)"
+  ];
+  let total = 0;
+  for (const d of chosen) {
+    const section = `
+### ${d.name}
+${d.body}`;
+    if (total + section.length > MAX_TOTAL_BYTES)
+      break;
+    total += section.length;
+    parts.push(section);
+  }
+  const manual = docs.filter((d) => d.inclusion === "manual").map((d) => d.name);
+  if (manual.length) {
+    parts.push(`
+(Manual steering available on request via read_file: ${manual.join(", ")}.)`);
+  }
+  return parts.join("\n");
+}
+function generateSteering(cwd) {
+  const dir = join2(cwd, ".hostwares", "steering");
+  const created = [];
+  const skipped = [];
+  mkdirSync2(dir, { recursive: true });
+  const write2 = (name, content) => {
+    const full = join2(dir, name);
+    if (existsSync2(full)) {
+      skipped.push(name);
+      return;
+    }
+    writeFileSync2(full, content, "utf8");
+    created.push(name);
+  };
+  const read = (f) => {
     try {
-        const cfg = getConfig();
-        const r = await fetch(`${cfg.baseUrl}/api/sites`, { headers: { Authorization: `Bearer ${cfg.apiKey}` } });
-        if (!r.ok) {
-            ui.error(r.status === 401 ? "Not signed in. Run `hw login`." : `Could not list deployments (HTTP ${r.status}).`);
-            return 1;
-        }
-        const res = await r.json();
-        const sites = Array.isArray(res) ? res : (res?.sites ?? []);
-        if (!sites.length) {
-            ui.line(c.dim("  No deployments yet. Ask me to deploy something to get started."));
-            return 0;
-        }
-        ui.line();
-        for (const s of sites) {
-            const dot = s.status === "RUNNING" ? c.green("●")
-                : s.status === "FAILED" ? c.red("●")
-                    : c.yellow("●");
-            ui.line(`  ${dot} ${c.bold((s.name ?? "unnamed").padEnd(24))} ${c.dim(s.domain ?? s.status ?? "")}`);
-        }
-        ui.line();
-        return 0;
+      return readFileSync2(join2(cwd, f), "utf8");
+    } catch {
+      return null;
     }
-    catch (e) {
-        reportError(e);
-        return 1;
+  };
+  let stack = "Unknown - fill this in.";
+  let projectName = cwd.split(/[/\\]/).filter(Boolean).pop() ?? "project";
+  const pkg = read("package.json");
+  if (pkg) {
+    try {
+      const j = JSON.parse(pkg);
+      projectName = j.name || projectName;
+      const deps = { ...j.dependencies || {}, ...j.devDependencies || {} };
+      const hints = [];
+      if (deps.next)
+        hints.push("Next.js");
+      else if (deps.react)
+        hints.push("React");
+      if (deps.vue)
+        hints.push("Vue");
+      if (deps.express || deps.fastify)
+        hints.push("Node HTTP server");
+      if (deps.prisma || deps["@prisma/client"])
+        hints.push("Prisma");
+      if (deps.typescript)
+        hints.push("TypeScript");
+      if (deps.vitest || deps.jest)
+        hints.push(`tests: ${deps.vitest ? "vitest" : "jest"}`);
+      stack = hints.length ? hints.join(", ") : "Node/JavaScript";
+    } catch {
     }
+  } else if (read("requirements.txt") || read("pyproject.toml"))
+    stack = "Python";
+  else if (read("go.mod"))
+    stack = "Go";
+  else if (read("composer.json"))
+    stack = "PHP";
+  else if (read("Cargo.toml"))
+    stack = "Rust";
+  let layout = "- (could not read directory)";
+  try {
+    const entries = readdirSync2(cwd).filter((e) => !e.startsWith(".") && e !== "node_modules").filter((e) => {
+      try {
+        return statSync2(join2(cwd, e)).isDirectory();
+      } catch {
+        return false;
+      }
+    }).slice(0, 12);
+    if (entries.length)
+      layout = entries.map((e) => `- ${e}/`).join("\n");
+  } catch {
+  }
+  write2("product.md", `---
+inclusion: always
+---
+# Product
+
+**${projectName}** - describe in one line what this project is and who it is for.
+
+## What it does
+(Fill in the core features. The agent uses this to make product-sensible choices.)
+
+## What it must not do
+(Any hard constraints - data that must never leave, actions that always need review.)
+`);
+  write2("tech.md", `---
+inclusion: always
+---
+# Tech
+
+**Stack (detected):** ${stack}
+
+## Conventions
+- (Formatting, naming, error handling the agent should match.)
+- (Preferred libraries; ones to avoid.)
+
+## Commands
+- Install: (e.g. npm install)
+- Dev: (e.g. npm run dev)
+- Test: (e.g. npm test)
+- Build: (e.g. npm run build)
+`);
+  write2("structure.md", `---
+inclusion: always
+---
+# Structure
+
+Top-level layout:
+${layout}
+
+## Where things go
+- (Where new routes / components / models belong, so the agent doesn't guess.)
+`);
+  return { created, skipped };
 }
-function readVersion() {
-    // Read from package.json rather than a literal. The banner used to hardcode
-    // "v1.1.0" beside a --version that read the manifest, so the two drifted the
-    // moment either changed - a bug that had already been fixed once for
-    // --version alone.
+var MAX_STEERING_BYTES, MAX_TOTAL_BYTES;
+var init_steering = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/steering.js"() {
+    MAX_STEERING_BYTES = 32 * 1024;
+    MAX_TOTAL_BYTES = 96 * 1024;
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/hooks.js
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
+function globToRe2(glob) {
+  const esc = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(esc);
+}
+function userHooks(cwd) {
+  const dir = join3(cwd, ".hostwares", "hooks");
+  if (!existsSync3(dir))
+    return [];
+  const out = [];
+  try {
+    for (const f of readdirSync3(dir).filter((x) => x.endsWith(".json"))) {
+      try {
+        const parsed = JSON.parse(readFileSync3(join3(dir, f), "utf8"));
+        const arr = Array.isArray(parsed) ? parsed : [parsed];
+        for (const h of arr)
+          if (h && h.event && h.run)
+            out.push(h);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function defaultPostWriteHook(cwd, file) {
+  const has = (f) => existsSync3(join3(cwd, f));
+  const lower = file.toLowerCase();
+  if (/\.(ts|tsx)$/.test(lower) && has("tsconfig.json")) {
+    return { event: "PostFileSave", name: "typecheck", run: "npx --no-install tsc --noEmit" };
+  }
+  if (/\.(js|jsx|mjs|cjs)$/.test(lower) && (has(".eslintrc") || has(".eslintrc.json") || has(".eslintrc.cjs") || has("eslint.config.js") || has("eslint.config.mjs"))) {
+    return { event: "PostFileSave", name: "lint", run: "npx --no-install eslint {file}" };
+  }
+  if (/\.(js|mjs|cjs)$/.test(lower)) {
+    return { event: "PostFileSave", name: "syntax", run: "node --check {file}" };
+  }
+  if (/\.py$/.test(lower)) {
+    if (has("mypy.ini") || has("pyproject.toml"))
+      return { event: "PostFileSave", name: "mypy", run: "python3 -m mypy {file}" };
+    return { event: "PostFileSave", name: "py-compile", run: "python3 -m py_compile {file}" };
+  }
+  if (/\.go$/.test(lower) && has("go.mod")) {
+    return { event: "PostFileSave", name: "go build", run: "go build ./..." };
+  }
+  if (/\.rs$/.test(lower) && has("Cargo.toml")) {
+    return { event: "PostFileSave", name: "cargo check", run: "cargo check --quiet" };
+  }
+  return null;
+}
+async function runPostWriteHooks(cwd, file) {
+  const custom = userHooks(cwd).filter((h) => h.event === "PostFileSave" && (!h.match || safeMatch(h.match, file)));
+  const hooks = [...custom];
+  const def = defaultPostWriteHook(cwd, file);
+  if (def && !custom.some((h) => h.name === def.name))
+    hooks.push(def);
+  if (!hooks.length)
+    return [];
+  const results = [];
+  for (const h of hooks) {
+    const cmd = h.run.replace(/\{file\}/g, shellQuote(file));
+    const r = await execShell(cmd, { cwd, timeoutMs: HOOK_TIMEOUT_MS });
+    if (r.code === null || /command not found|not recognized|could not determine executable/i.test(r.stderr)) {
+      continue;
+    }
+    results.push({
+      name: h.name ?? "check",
+      ok: r.ok,
+      output: formatResult(r, { maxChars: 6e3 })
+    });
+  }
+  return results;
+}
+function safeMatch(glob, file) {
+  try {
+    return globToRe2(glob).test(file);
+  } catch {
+    return true;
+  }
+}
+function shellQuote(p) {
+  if (process.platform === "win32")
+    return `"${p.replace(/"/g, '""')}"`;
+  return `'${p.replace(/'/g, `'\\''`)}'`;
+}
+var HOOK_TIMEOUT_MS;
+var init_hooks = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/hooks.js"() {
+    init_exec();
+    HOOK_TIMEOUT_MS = 6e4;
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/checkpoints.js
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, rmSync as rmSync2 } from "fs";
+import { join as join4, resolve, relative, dirname as dirname2 } from "path";
+function root(cwd) {
+  return join4(cwd, ".hostwares", "checkpoints");
+}
+function encodePath(p) {
+  return Buffer.from(p).toString("base64url");
+}
+function readManifest(dir) {
+  try {
+    return JSON.parse(readFileSync4(join4(dir, "manifest.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeManifest(dir, m) {
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(join4(dir, "manifest.json"), JSON.stringify(m, null, 2), "utf8");
+}
+function pruneOld(cwd) {
+  try {
+    const base = root(cwd);
+    const dirs = readdirSync4(base).map((d) => ({ d, m: readManifest(join4(base, d)) })).filter((x) => x.m).sort((a, b) => b.m.createdAt - a.m.createdAt);
+    for (const stale of dirs.slice(MAX_CHECKPOINTS)) {
+      rmSync2(join4(base, stale.d), { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+function listCheckpoints(cwd) {
+  try {
+    const base = root(cwd);
+    if (!existsSync4(base))
+      return [];
+    return readdirSync4(base).map((d) => readManifest(join4(base, d))).filter((m) => !!m).sort((a, b) => b.createdAt - a.createdAt).map((m) => ({ label: m.label, createdAt: m.createdAt, note: m.note, fileCount: m.entries.length }));
+  } catch {
+    return [];
+  }
+}
+function rewind(cwd, label) {
+  const base = root(cwd);
+  const all = listCheckpoints(cwd);
+  if (!all.length)
+    return { ok: false, restored: [], deleted: [], message: "No checkpoints to rewind to." };
+  const target = label ?? all[0].label;
+  const dir = join4(base, target);
+  const manifest = readManifest(dir);
+  if (!manifest)
+    return { ok: false, restored: [], deleted: [], message: `No checkpoint named "${target}".` };
+  const restored = [];
+  const deleted = [];
+  for (const e of manifest.entries) {
     try {
-        const here = dirname(fileURLToPath(import.meta.url));
-        const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8"));
-        return pkg.version ?? "0.0.0";
+      if (e.created) {
+        if (existsSync4(e.path)) {
+          rmSync2(e.path, { force: true });
+          deleted.push(relative(cwd, e.path));
+        }
+      } else if (e.backup) {
+        const saved = join4(dir, "files", e.backup);
+        if (existsSync4(saved)) {
+          mkdirSync3(dirname2(e.path), { recursive: true });
+          writeFileSync3(e.path, readFileSync4(saved));
+          restored.push(relative(cwd, e.path));
+        }
+      }
+    } catch {
     }
-    catch {
-        return "0.0.0";
+  }
+  try {
+    rmSync2(dir, { recursive: true, force: true });
+  } catch {
+  }
+  const parts = [];
+  if (restored.length)
+    parts.push(`restored ${restored.length} file${restored.length === 1 ? "" : "s"}`);
+  if (deleted.length)
+    parts.push(`deleted ${deleted.length} created file${deleted.length === 1 ? "" : "s"}`);
+  return {
+    ok: true,
+    restored,
+    deleted,
+    message: parts.length ? `Rewound "${target}": ${parts.join(", ")}.` : `Checkpoint "${target}" had nothing to undo.`
+  };
+}
+var MAX_CHECKPOINTS, MAX_BACKUP_BYTES, Checkpoint;
+var init_checkpoints = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/checkpoints.js"() {
+    MAX_CHECKPOINTS = 20;
+    MAX_BACKUP_BYTES = 5 * 1024 * 1024;
+    Checkpoint = class {
+      cwd;
+      dir;
+      manifest;
+      seen = /* @__PURE__ */ new Set();
+      constructor(cwd, label, note2) {
+        this.cwd = cwd;
+        this.dir = join4(root(cwd), label);
+        this.manifest = { label, createdAt: Date.now(), note: note2, entries: [] };
+      }
+      /** Snapshot a file's current state before it is changed. Idempotent per path. */
+      record(filePath) {
+        const abs = resolve(this.cwd, filePath);
+        if (this.seen.has(abs))
+          return;
+        this.seen.add(abs);
+        try {
+          if (!existsSync4(abs)) {
+            this.manifest.entries.push({ path: abs, created: true });
+          } else {
+            const st = statSync3(abs);
+            if (st.isDirectory() || st.size > MAX_BACKUP_BYTES)
+              return;
+            const backup = encodePath(abs);
+            mkdirSync3(join4(this.dir, "files"), { recursive: true });
+            writeFileSync3(join4(this.dir, "files", backup), readFileSync4(abs));
+            this.manifest.entries.push({ path: abs, created: false, backup });
+          }
+          writeManifest(this.dir, this.manifest);
+        } catch {
+        }
+      }
+      /** True once anything has been recorded - so we don't leave empty dirs. */
+      get hasEntries() {
+        return this.manifest.entries.length > 0;
+      }
+      /** Discard this checkpoint (e.g. the turn made no changes). */
+      discard() {
+        try {
+          rmSync2(this.dir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      finalize() {
+        if (!this.hasEntries) {
+          this.discard();
+          return;
+        }
+        pruneOld(this.cwd);
+      }
+    };
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/subagents.js
+function parseTasks(input) {
+  const raw = input?.tasks ?? input?.subagents;
+  const arr = Array.isArray(raw) ? raw : [];
+  const tasks = [];
+  for (const t of arr) {
+    if (typeof t === "string" && t.trim())
+      tasks.push({ task: t.trim() });
+    else if (t && typeof t === "object" && typeof t.task === "string") {
+      tasks.push({ task: String(t.task), label: t.label ? String(t.label) : void 0 });
+    }
+    if (tasks.length >= MAX_TASKS)
+      break;
+  }
+  return tasks;
+}
+async function runSubagents(input, deps, emit) {
+  if (deps.depth >= 2) {
+    return "Sub-agents cannot be nested this deep. Do this subtask yourself in the current turn.";
+  }
+  const tasks = parseTasks(input);
+  if (!tasks.length) {
+    return `No tasks given. Call spawn_subagents with tasks: ["do X and report", "do Y and report"] - each task must be independent and self-contained.`;
+  }
+  const results = [];
+  for (let i = 0; i < tasks.length; i += MAX_PARALLEL) {
+    if (deps.signal.aborted)
+      break;
+    const wave = tasks.slice(i, i + MAX_PARALLEL);
+    const settled = await Promise.all(wave.map(async (t, j) => {
+      const label = t.label ?? `subagent ${i + j + 1}`;
+      emit({ type: "tool:output", id: "spawn_subagents", chunk: `\u21B3 ${label}: ${t.task.slice(0, 80)}
+`, stream: "stdout" });
+      try {
+        const res = await deps.runTurn({
+          credentials: deps.credentials,
+          message: t.task,
+          conversationId: null,
+          // isolated context - a fresh conversation
+          model: deps.model,
+          signal: deps.signal,
+          // The child inherits the parent's permission host so writes are still
+          // governed, but draws no activity of its own - only its result
+          // surfaces, keeping the parent's view (and window) clean.
+          host: { ...deps.host, onActivity: silentSink, subagentDepth: deps.depth + 1 }
+        });
+        return { label, text: (res.text || "(no output)").trim(), ok: !res.error && !res.aborted };
+      } catch (e) {
+        return { label, text: `failed: ${e instanceof Error ? e.message : String(e)}`, ok: false };
+      }
+    }));
+    results.push(...settled);
+  }
+  const okCount = results.filter((r) => r.ok).length;
+  const header = `${results.length} sub-agent${results.length === 1 ? "" : "s"} finished (${okCount} ok).`;
+  const body = results.map((r) => `
+### ${r.label} ${r.ok ? "\u2713" : "\u2717"}
+${r.text.slice(0, 4e3)}`).join("\n");
+  return `${header}${body}
+
+Use these results to finish the task. Do not re-do work a sub-agent already completed.`;
+}
+var MAX_PARALLEL, MAX_TASKS;
+var init_subagents = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/subagents.js"() {
+    init_events();
+    MAX_PARALLEL = 4;
+    MAX_TASKS = 6;
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/safety.js
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+function canRunUnprompted(tool, trust = "none", destructive = false) {
+  if (destructive || ALWAYS_ASK.has(tool))
+    return false;
+  if (AUTO_APPROVED.has(tool))
+    return true;
+  return trust !== "none";
+}
+function primaryArg(tool, input) {
+  const s = (k) => input?.[k] === void 0 ? "" : String(input[k]);
+  switch (tool) {
+    case "run_command":
+    case "start_process":
+      return s("command");
+    case "curl_request":
+    case "web_fetch":
+    case "open_browser":
+    case "wait_for_url":
+      return s("url");
+    case "ssh_run":
+      return s("command");
+    case "install_package":
+      return s("name");
+    default:
+      return s("path") || s("pattern") || s("target") || s("container") || "";
+  }
+}
+function permGlobToRe(glob) {
+  const esc = glob.trim().replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${esc}$`);
+}
+function ruleMatches(rule, tool, arg) {
+  if (rule.tool !== "*" && rule.tool !== tool)
+    return false;
+  if (!rule.match)
+    return true;
+  try {
+    return permGlobToRe(rule.match).test(arg);
+  } catch {
+    return false;
+  }
+}
+function resolvePermission(rules, tool, input) {
+  const arg = primaryArg(tool, input);
+  let verdict = null;
+  const rank = { allow: 1, ask: 2, deny: 3 };
+  for (const r of rules) {
+    if (!ruleMatches(r, tool, arg))
+      continue;
+    if (verdict === null || rank[r.effect] > rank[verdict])
+      verdict = r.effect;
+  }
+  return verdict;
+}
+function decidePermission(tool, input, rules, trust = "none", destructive = false) {
+  const hard = resolvePermission(HARD_DENY, tool, input);
+  if (hard === "deny")
+    return "deny";
+  const user = resolvePermission(rules, tool, input);
+  if (user)
+    return user;
+  return canRunUnprompted(tool, trust, destructive) ? "allow" : "ask";
+}
+function loadPermissionRules(cwd) {
+  const files = [
+    join5(homedir3(), ".hostwares", "permissions.json"),
+    join5(cwd, ".hostwares", "permissions.json")
+  ];
+  const rules = [];
+  for (const f of files) {
+    try {
+      if (!existsSync5(f))
+        continue;
+      const parsed = JSON.parse(readFileSync5(f, "utf8"));
+      const arr = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.rules) ? parsed.rules : [];
+      for (const r of arr) {
+        if (r && typeof r.tool === "string" && ["allow", "ask", "deny"].includes(r.effect)) {
+          rules.push({ tool: r.tool, match: typeof r.match === "string" ? r.match : void 0, effect: r.effect });
+        }
+      }
+    } catch {
+    }
+  }
+  return rules;
+}
+function describeEffect(tool, input) {
+  const s = (k) => input?.[k] === void 0 ? void 0 : String(input[k]);
+  switch (tool) {
+    case "write_file":
+      return { kind: "wrote", path: s("path") ?? "" };
+    case "append_file":
+    case "str_replace_file":
+      return { kind: "modified", path: s("path") ?? "" };
+    case "delete_path":
+      return { kind: "deleted", path: s("path") ?? "" };
+    case "run_command":
+      return { kind: "ran", command: s("command") ?? "" };
+    case "read_file":
+      return { kind: "read", path: s("path") ?? "" };
+    default:
+      return { kind: "other" };
+  }
+}
+function buildPatch(oldContent, newContent, filePath, maxLines = 40) {
+  if (oldContent === newContent)
+    return void 0;
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  let start = 0;
+  while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start])
+    start++;
+  let oldEnd = oldLines.length - 1;
+  let newEnd = newLines.length - 1;
+  while (oldEnd >= start && newEnd >= start && oldLines[oldEnd] === newLines[newEnd]) {
+    oldEnd--;
+    newEnd--;
+  }
+  const ctxBefore = Math.max(0, start - 2);
+  const ctxAfterOld = Math.min(oldLines.length, oldEnd + 3);
+  const ctxAfterNew = Math.min(newLines.length, newEnd + 3);
+  const lines = [];
+  for (let i = ctxBefore; i < start; i++) {
+    lines.push({ kind: "ctx", text: oldLines[i], oldLine: i + 1, newLine: i + 1 });
+  }
+  for (let i = start; i <= oldEnd; i++) {
+    lines.push({ kind: "del", text: oldLines[i], oldLine: i + 1 });
+  }
+  for (let i = start; i <= newEnd; i++) {
+    lines.push({ kind: "add", text: newLines[i], newLine: i + 1 });
+  }
+  for (let i = oldEnd + 1; i < ctxAfterOld; i++) {
+    const newIdx = newEnd + 1 + (i - (oldEnd + 1));
+    if (newIdx < ctxAfterNew) {
+      lines.push({ kind: "ctx", text: oldLines[i], oldLine: i + 1, newLine: newIdx + 1 });
     }
+  }
+  if (lines.length > maxLines) {
+    return { path: filePath, lines: lines.slice(0, maxLines), truncated: lines.length - maxLines };
+  }
+  return { path: filePath, lines };
 }
-main(process.argv.slice(2))
-    .then(code => process.exit(code))
-    .catch(e => {
-    // Ctrl-C during startup is a normal exit, not a crash to report.
+var AUTO_APPROVED, ALWAYS_ASK, HARD_DENY;
+var init_safety = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/safety.js"() {
+    AUTO_APPROVED = /* @__PURE__ */ new Set([
+      "read_file",
+      "list_directory",
+      "get_system_info",
+      "git_status",
+      "git_log",
+      "git_diff",
+      "check_github_auth",
+      "docker_ps",
+      "list_processes",
+      "check_port"
+    ]);
+    ALWAYS_ASK = /* @__PURE__ */ new Set([
+      "delete_path",
+      "kill_process",
+      "git_push",
+      "ssh_run",
+      "ssh_upload",
+      "ssh_download"
+    ]);
+    HARD_DENY = [
+      { tool: "run_command", match: "*rm -rf /*", effect: "deny" },
+      { tool: "run_command", match: "*rm -rf ~*", effect: "deny" },
+      { tool: "run_command", match: "*mkfs*", effect: "deny" },
+      { tool: "run_command", match: "*:(){:|:&};:*", effect: "deny" },
+      // fork bomb
+      { tool: "start_process", match: "*rm -rf /*", effect: "deny" }
+    ];
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/agent/loop.js
+async function runTurn(opts) {
+  const { credentials, signal, host } = opts;
+  const emit = host.onActivity ?? silentSink;
+  const startedAt = Date.now();
+  let conversationId = opts.conversationId ?? null;
+  let turnId = null;
+  let turnCredits = 0;
+  let balance = 0;
+  let text = "";
+  let lastDone = null;
+  let assistantContent = null;
+  let toolResults = [];
+  let firstHop = true;
+  const callCounts = /* @__PURE__ */ new Map();
+  const writeCounts = /* @__PURE__ */ new Map();
+  let stalledHops = 0;
+  let totalGuardHits = 0;
+  let emptyHops = 0;
+  const MAX_EMPTY_RETRIES = 1;
+  const steering = buildSteeringContext(host.cwd ?? process.cwd(), opts.message);
+  const firstMessage = steering ? `${steering}
+
+---
+
+${opts.message}` : opts.message;
+  const checkpointLabel = `turn-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  const checkpoint = new Checkpoint(host.cwd ?? process.cwd(), checkpointLabel, opts.message.slice(0, 120));
+  try {
+    for (let hop = 0; hop < MAX_HOPS; hop++) {
+      if (signal.aborted)
+        throw new AbortedError();
+      emit({ type: "thinking" });
+      const pending = [];
+      const textBefore = text.length;
+      const done = await streamChat(credentials, {
+        ...firstHop ? { message: firstMessage, images: opts.images } : { toolResults, assistantContent },
+        conversationId,
+        turnId,
+        agentMode: true,
+        model: opts.model
+      }, {
+        onMeta: (d) => {
+          conversationId = d.conversationId;
+        },
+        onText: (chunk) => {
+          text += chunk;
+          emit({ type: "text", chunk });
+        },
+        // Cloud tools run on our infrastructure; they are narrated, not executed.
+        onToolExecuting: (d) => emit({ type: "tool:start", id: d.id ?? d.name, tool: d.name, target: d.target, location: "cloud" }),
+        onToolDone: (d) => emit({
+          type: "tool:end",
+          id: d.id ?? d.name,
+          tool: d.name,
+          ok: d.status === "success" || d.status === "executed",
+          durationMs: d.durationMs ?? 0,
+          summary: d.result ?? d.error
+        }),
+        onLocalTool: (d) => {
+          pending.push({ id: d.id, name: d.name, input: d.input, destructive: d.destructive });
+          emit({ type: "tool:pending", id: d.id, tool: d.name, target: d.target, location: "local", destructive: d.destructive });
+        },
+        onError: (message) => emit({ type: "error", message })
+      }, {
+        signal,
+        onAuthFailure: opts.onAuthFailure ? async () => {
+          emit({ type: "reauth" });
+          return opts.onAuthFailure();
+        } : void 0
+      });
+      if (done) {
+        lastDone = done;
+        conversationId = done.conversationId ?? conversationId;
+        turnId = done.turnId ?? turnId;
+        turnCredits = done.turnCredits ?? turnCredits + (done.creditsUsed ?? 0);
+        balance = done.balance ?? balance;
+        assistantContent = done.assistantContent ?? assistantContent;
+        for (const call of done.localToolCalls ?? []) {
+          if (!pending.some((p) => p.id === call.id)) {
+            pending.push(call);
+            emit({ type: "tool:pending", id: call.id, tool: call.name, target: targetOf(call), location: "local", destructive: call.destructive });
+          }
+        }
+        if (done.pendingActions?.length) {
+          await handleActions(done.pendingActions, opts, emit);
+        }
+      }
+      firstHop = false;
+      if (!pending.length) {
+        const producedText = text.length > textBefore;
+        if (!producedText && hop > 0 && emptyHops < MAX_EMPTY_RETRIES) {
+          emptyHops++;
+          toolResults = [{
+            id: `empty-${hop}`,
+            result: `[continue] Your last turn was empty \u2014 no message and no tool call. Do NOT stop here. Look at what has been done so far in this conversation and take the NEXT concrete step toward the goal: create the next file, run the next command, or if the task is genuinely complete, give a short final answer stating what you built and how to run it. Act now.`
+          }];
+          assistantContent = assistantContent ?? "";
+          continue;
+        }
+        if (!producedText && emptyHops >= MAX_EMPTY_RETRIES) {
+          const wroteSomething = writeCounts.size > 0;
+          emit({ type: "error", message: wroteSomething ? `Stopping: the last steps returned nothing new. What I changed is saved \u2014 tell me the specific next change and I'll make it directly.` : `Stopping: I couldn't make progress on that. Tell me the specific step you want (e.g. "create the server file") and I'll do it directly.` });
+        }
+        break;
+      }
+      emptyHops = 0;
+      const toRun = [];
+      const shortCircuited = [];
+      for (const call of pending) {
+        const fp = `${call.name}:${stableStringify(call.input)}`;
+        const seen = (callCounts.get(fp) ?? 0) + 1;
+        callCounts.set(fp, seen);
+        const path = typeof call.input?.path === "string" ? call.input.path : void 0;
+        if (seen > MAX_IDENTICAL_CALLS && isReadOnlyTool(call.name)) {
+          shortCircuited.push({
+            id: call.id,
+            result: `[loop guard] You already ran ${call.name}(${compactArgs(call.input)}) and nothing has changed since \u2014 re-reading it will keep returning the same thing. This call was NOT executed. STOP re-inspecting and DECIDE from what you already know: if a file the task needs does not exist yet, WRITE it now (write_file) \u2014 an empty or missing directory means the file has not been created, not that you should look again. If every file the task needs already exists and has been run/verified, give your final answer now (what you built + how to run it) and end. Do NOT read or list again.`
+          });
+          emit({ type: "tool:end", id: call.id, tool: call.name, ok: false, durationMs: 0, summary: "loop guard: repeated read skipped" });
+        } else if (WRITE_TOOLS.has(call.name) && path && (writeCounts.get(path) ?? 0) >= MAX_WRITES_PER_FILE) {
+          shortCircuited.push({
+            id: call.id,
+            result: `[loop guard] You have already written ${path} ${writeCounts.get(path)} times this turn \u2014 its content is on disk. This write was NOT executed. Stop rewriting it: verify it (run it / typecheck it) or give your final answer. Do not write this file again unless you are making a specific, different change.`
+          });
+          emit({ type: "tool:end", id: call.id, tool: call.name, ok: false, durationMs: 0, summary: "loop guard: write thrash skipped" });
+        } else {
+          toRun.push(call);
+        }
+      }
+      totalGuardHits += shortCircuited.length;
+      if (toRun.length === 0 && shortCircuited.length > 0)
+        stalledHops++;
+      else
+        stalledHops = 0;
+      const wroteThisHop = toRun.some((c2) => WRITE_TOOLS.has(c2.name));
+      if (wroteThisHop) {
+        stalledHops = 0;
+      }
+      const filesWritten = writeCounts.size;
+      const guardHitCeiling = 6 + filesWritten * 3;
+      const stallCeiling = filesWritten > 0 ? 4 : 2;
+      if (stalledHops >= stallCeiling || totalGuardHits >= guardHitCeiling) {
+        const wroteSomething = filesWritten > 0;
+        emit({ type: "error", message: wroteSomething ? `Stopping: I kept re-reading the same files without making new progress. What I built so far is saved. Tell me the specific next change (e.g. "write the UI file" / "start it") and I'll do it directly.` : `Stopping: I kept re-reading the same files without writing anything. I have enough context now \u2014 tell me the specific change you want and I'll make it directly.` });
+        return finish({ conversationId, turnCredits, balance, text, aborted: false });
+      }
+      for (const c2 of toRun) {
+        if (!MUTATION_TOOLS.has(c2.name))
+          continue;
+        const p = typeof c2.input?.path === "string" ? c2.input.path : void 0;
+        if (!p)
+          continue;
+        if (WRITE_TOOLS.has(c2.name))
+          writeCounts.set(p, (writeCounts.get(p) ?? 0) + 1);
+        for (const key of [...callCounts.keys()]) {
+          if (key.includes(JSON.stringify(p)))
+            callCounts.delete(key);
+        }
+      }
+      let results = shortCircuited;
+      if (toRun.length) {
+        const ran = await executePending(toRun, opts, emit, checkpoint);
+        if (ran === null) {
+          return finish({ conversationId, turnCredits, balance, text, aborted: true });
+        }
+        for (const call of toRun) {
+          if (!WRITE_TOOLS.has(call.name))
+            continue;
+          const res = ran.find((r) => r.id === call.id);
+          if (!res || /^Error:/i.test(res.result))
+            continue;
+          const path = String(call.input?.path ?? "");
+          if (!path)
+            continue;
+          let hookResults;
+          try {
+            hookResults = await runPostWriteHooks(host.cwd ?? process.cwd(), path);
+          } catch {
+            hookResults = [];
+          }
+          for (const h of hookResults) {
+            emit({ type: "tool:end", id: `${call.id}:${h.name}`, tool: h.name, ok: h.ok, durationMs: 0, summary: h.ok ? `${h.name} passed` : `${h.name} failed` });
+            res.result += h.ok ? `
+
+[${h.name}] passed on ${path}.` : `
+
+[${h.name}] FAILED after this write \u2014 fix before continuing:
+${h.output}`;
+          }
+        }
+        results = [...shortCircuited, ...ran];
+      }
+      toolResults = results;
+      if (hop === MAX_HOPS - 1) {
+        emit({ type: "error", message: `Paused after ${MAX_HOPS} steps to check in - this is a long task, not necessarily a finished one. Say "continue" and I'll pick up exactly where I left off.` });
+      }
+    }
+    emit({
+      type: "turn:end",
+      usage: {
+        credits: turnCredits,
+        balance,
+        model: lastDone?.model ?? "",
+        elapsedMs: Date.now() - startedAt,
+        promptTokens: lastDone?.usage?.promptTokens,
+        maxTokens: lastDone?.usage?.maxTokens,
+        usagePercent: lastDone?.usage?.usagePercent
+      }
+    });
+    return finish({ conversationId, turnCredits, balance, text, aborted: false });
+  } catch (e) {
     if (isAborted(e))
-        process.exit(130);
+      return finish({ conversationId, turnCredits, balance, text, aborted: true });
+    const message = e instanceof ApiError ? e.message : e instanceof Error ? e.message : String(e);
+    emit({ type: "error", message });
+    return finish({ conversationId, turnCredits, balance, text, aborted: false, error: message });
+  } finally {
+    try {
+      checkpoint.finalize();
+    } catch {
+    }
+  }
+}
+function finish(r) {
+  return {
+    conversationId: r.conversationId,
+    creditsSpent: r.turnCredits,
+    balance: r.balance,
+    text: r.text,
+    aborted: r.aborted,
+    error: r.error
+  };
+}
+function isReadOnlyTool(name) {
+  return READ_ONLY_TOOLS.has(name);
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object")
+    return JSON.stringify(v);
+  if (Array.isArray(v))
+    return `[${v.map(stableStringify).join(",")}]`;
+  const o = v;
+  return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
+}
+function compactArgs(input) {
+  const s = Object.entries(input).map(([k, val]) => `${k}: ${JSON.stringify(val)}`).join(", ");
+  return s.length > 120 ? `${s.slice(0, 117)}...` : s;
+}
+async function executePending(calls, opts, emit, checkpoint) {
+  const results = [];
+  for (const call of calls) {
+    if (opts.signal.aborted)
+      return null;
+    if (call.name === "spawn_subagents") {
+      emit({ type: "tool:start", id: call.id, tool: call.name, target: "parallel subtasks", location: "local" });
+      const started2 = Date.now();
+      const out = await runSubagents(call.input, {
+        credentials: opts.credentials,
+        host: opts.host,
+        model: opts.model,
+        signal: opts.signal,
+        depth: opts.host.subagentDepth ?? 0,
+        runTurn: (o) => runTurn(o).then((r) => ({ text: r.text, aborted: r.aborted, error: r.error }))
+      }, emit);
+      emit({ type: "tool:end", id: call.id, tool: call.name, ok: true, durationMs: Date.now() - started2 });
+      results.push({ id: call.id, result: truncate(out) });
+      continue;
+    }
+    const trust = opts.host.trustLevel?.() ?? "none";
+    const decision = canRunUnprompted(call.name, trust, call.destructive) ? "allow" : await opts.host.askPermission(call);
+    if (decision === "abort")
+      return null;
+    if (decision === "deny") {
+      emit({ type: "tool:denied", id: call.id, tool: call.name });
+      results.push({ id: call.id, result: "The user declined to run this. Do not retry it; suggest an alternative or ask what they would prefer." });
+      continue;
+    }
+    emit({ type: "tool:start", id: call.id, tool: call.name, target: targetOf(call), location: "local" });
+    const started = Date.now();
+    if (checkpoint && MUTATION_TOOLS.has(call.name)) {
+      const p = call.input?.path;
+      if (typeof p === "string" && p)
+        checkpoint.record(p);
+    }
+    let oldContent = null;
+    if (WRITE_TOOLS.has(call.name) && typeof call.input?.path === "string" && call.input.path) {
+      try {
+        const { readFileSync: readFileSync9, existsSync: existsSync8 } = await import("fs");
+        const { resolve: pathResolve2, join: join9 } = await import("path");
+        const { homedir: homedir5 } = await import("os");
+        const raw = String(call.input.path);
+        const expanded = raw === "~" ? homedir5() : raw.startsWith("~/") ? join9(homedir5(), raw.slice(2)) : raw;
+        const abs = pathResolve2(expanded);
+        if (existsSync8(abs))
+          oldContent = readFileSync9(abs, "utf8");
+        else
+          oldContent = "";
+      } catch {
+        oldContent = null;
+      }
+    }
+    let output;
+    try {
+      output = await executeLocalTool(call.name, call.input, {
+        cwd: opts.host.cwd,
+        signal: opts.signal,
+        // The live view: output reaches the UI while the command is still
+        // running, so a long build is visibly progressing rather than hung.
+        onOutput: (chunk, stream) => emit({ type: "tool:output", id: call.id, chunk, stream })
+      });
+    } catch (e) {
+      output = `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    const failed2 = output.startsWith("Error:") || output.includes("[command failed") || output.includes("[command timed out");
+    const effect = describeEffect(call.name, call.input);
+    if (!failed2 && oldContent !== null && (effect.kind === "wrote" || effect.kind === "modified")) {
+      try {
+        const filePath = String(call.input?.path ?? "");
+        let patchSourceOld = oldContent;
+        let patchSourceNew = null;
+        if (call.name === "str_replace_file" && typeof call.input?.oldStr === "string" && typeof call.input?.newStr === "string") {
+          patchSourceNew = oldContent.replace(String(call.input.oldStr), String(call.input.newStr));
+        } else if (typeof call.input?.content === "string") {
+          patchSourceNew = String(call.input.content);
+        }
+        if (patchSourceNew !== null) {
+          const patch = buildPatch(patchSourceOld, patchSourceNew, filePath);
+          if (patch)
+            effect.patch = patch;
+        }
+      } catch {
+      }
+    }
+    const bytes = effect.kind === "wrote" || effect.kind === "modified" ? byteLength(call.input?.content) : void 0;
+    emit({ type: "tool:end", id: call.id, tool: call.name, ok: !failed2, durationMs: Date.now() - started, effect, bytes });
+    results.push({ id: call.id, result: truncate(output) });
+  }
+  return results;
+}
+async function handleActions(actions, opts, emit) {
+  for (const action of actions) {
+    if (opts.signal.aborted)
+      return;
+    emit({ type: "action:pending", id: action.id, description: action.description, risk: normaliseRisk(action.risk) });
+    const approve = opts.host.confirmAction ? await opts.host.confirmAction(action) : false;
+    try {
+      const res = await resolveAction(opts.credentials, { id: action.id, approve }, {
+        signal: opts.signal,
+        onAuthFailure: opts.onAuthFailure
+      });
+      emit({
+        type: "action:done",
+        id: action.id,
+        ok: approve && Boolean(res?.success),
+        detail: approve ? res?.result ?? res?.error : "Cancelled"
+      });
+    } catch (e) {
+      emit({ type: "action:done", id: action.id, ok: false, detail: e instanceof Error ? e.message : String(e) });
+    }
+  }
+}
+function normaliseRisk(risk) {
+  return risk === "critical" || risk === "high" || risk === "medium" ? risk : "low";
+}
+function truncate(s) {
+  return s.length <= MAX_RESULT_CHARS ? s : `${s.slice(0, MAX_RESULT_CHARS)}
+... (truncated, ${s.length - MAX_RESULT_CHARS} more characters)`;
+}
+function byteLength(content) {
+  if (typeof content !== "string")
+    return void 0;
+  return Buffer.byteLength(content, "utf8");
+}
+function targetOf(call) {
+  const i = call.input ?? {};
+  const raw = i.command ?? i.path ?? i.url ?? i.pattern ?? i.name ?? i.container ?? i.host ?? i.files;
+  if (raw == null)
+    return void 0;
+  const s = String(raw).trim();
+  if (!s)
+    return void 0;
+  return s.length > 60 ? `${s.slice(0, 57)}\u2026` : s;
+}
+var MAX_HOPS, MAX_IDENTICAL_CALLS, MAX_WRITES_PER_FILE, MAX_RESULT_CHARS, READ_ONLY_TOOLS, MUTATION_TOOLS, WRITE_TOOLS;
+var init_loop = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/agent/loop.js"() {
+    init_client();
+    init_errors();
+    init_tools();
+    init_steering();
+    init_hooks();
+    init_checkpoints();
+    init_subagents();
+    init_safety();
+    init_events();
+    MAX_HOPS = 50;
+    MAX_IDENTICAL_CALLS = 2;
+    MAX_WRITES_PER_FILE = 2;
+    MAX_RESULT_CHARS = 3e4;
+    READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+      "read_file",
+      "list_directory",
+      "search_files",
+      "file_search",
+      "get_system_info",
+      "list_processes",
+      "get_process_output",
+      "check_port",
+      "git_status",
+      "git_log",
+      "git_diff",
+      "docker_ps"
+    ]);
+    MUTATION_TOOLS = /* @__PURE__ */ new Set([
+      "write_file",
+      "str_replace_file",
+      "append_file",
+      "delete_path",
+      "git_commit",
+      "git_add",
+      "git_push",
+      "install_package",
+      "start_process",
+      "stop_process",
+      "kill_process"
+    ]);
+    WRITE_TOOLS = /* @__PURE__ */ new Set(["write_file", "str_replace_file", "append_file"]);
+  }
+});
+
+// node_modules/@hostwares/agent-client/dist/esm/index.js
+var init_esm = __esm({
+  "node_modules/@hostwares/agent-client/dist/esm/index.js"() {
+    init_client();
+    init_sse();
+    init_errors();
+    init_events();
+    init_loop();
+    init_tools();
+    init_safety();
+    init_tools();
+    init_steering();
+    init_hooks();
+    init_checkpoints();
+    init_exec();
+  }
+});
+
+// src/config.ts
+import { homedir as homedir4 } from "os";
+import { join as join6, dirname as dirname3 } from "path";
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync4,
+  mkdirSync as mkdirSync4,
+  renameSync,
+  chmodSync,
+  unlinkSync
+} from "fs";
+function getConfig() {
+  if (_cache) return _cache;
+  _cache = readConfigFromDisk();
+  return _cache;
+}
+function reloadConfig() {
+  _cache = readConfigFromDisk();
+  return _cache;
+}
+function readConfigFromDisk() {
+  if (!existsSync6(CONFIG_FILE)) return { ...EMPTY };
+  try {
+    const parsed = JSON.parse(readFileSync6(CONFIG_FILE, "utf8"));
+    return {
+      // A truncated or hand-edited config must degrade to "logged out", never
+      // to a crash on startup.
+      apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : "",
+      baseUrl: typeof parsed.baseUrl === "string" && parsed.baseUrl ? parsed.baseUrl : DEFAULT_BASE_URL2,
+      trustedProjects: Array.isArray(parsed.trustedProjects) ? parsed.trustedProjects.filter((p) => typeof p === "string") : [],
+      model: typeof parsed.model === "string" ? parsed.model : void 0
+    };
+  } catch {
+    return { ...EMPTY };
+  }
+}
+function saveConfig(patch) {
+  const next = { ...getConfig(), ...patch };
+  writeJsonSecure(CONFIG_FILE, next);
+  _cache = next;
+  return next;
+}
+function clearConfig() {
+  try {
+    unlinkSync(CONFIG_FILE);
+  } catch {
+  }
+  _cache = { ...EMPTY };
+}
+function isAuthenticated() {
+  return Boolean(getConfig().apiKey);
+}
+function writeJsonSecure(file, value) {
+  const dir = dirname3(file);
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync4(tmp, JSON.stringify(value, null, 2), { mode: 384 });
+  try {
+    chmodSync(tmp, 384);
+  } catch {
+  }
+  renameSync(tmp, file);
+}
+var HW_DIR, CONFIG_FILE, DEFAULT_BASE_URL2, EMPTY, _cache;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    HW_DIR = join6(homedir4(), ".hostwares");
+    CONFIG_FILE = join6(HW_DIR, "config.json");
+    DEFAULT_BASE_URL2 = "https://hostwares.com";
+    EMPTY = { apiKey: "", baseUrl: DEFAULT_BASE_URL2 };
+    _cache = null;
+  }
+});
+
+// src/ui/theme.ts
+var useColor, wrap, c, unicode, glyph, BANNER_LINES;
+var init_theme = __esm({
+  "src/ui/theme.ts"() {
+    "use strict";
+    useColor = process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb" && process.stdout.isTTY === true;
+    wrap = (open, close) => (s) => useColor ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+    c = {
+      reset: "\x1B[0m",
+      bold: wrap("1", "22"),
+      dim: wrap("2", "22"),
+      italic: wrap("3", "23"),
+      under: wrap("4", "24"),
+      // Brand green, matching the web product. Never violet - see the platform
+      // design rules; the old banner used purple in install.sh and green in the CLI.
+      green: wrap("32", "39"),
+      cyan: wrap("36", "39"),
+      yellow: wrap("33", "39"),
+      red: wrap("31", "39"),
+      gray: wrap("90", "39"),
+      white: wrap("37", "39")
+    };
+    unicode = process.platform !== "win32" || process.env.WT_SESSION !== void 0;
+    glyph = {
+      tick: unicode ? "\u2713" : "OK",
+      cross: unicode ? "\u2717" : "X",
+      arrow: unicode ? "\u2192" : "->",
+      bullet: unicode ? "\u2022" : "*",
+      run: unicode ? "\u27F3" : "~",
+      skip: unicode ? "\u2298" : "-",
+      warn: unicode ? "\u26A0" : "!",
+      caret: unicode ? "\u25B8" : ">",
+      spinner: unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["|", "/", "-", "\\"]
+    };
+    BANNER_LINES = [
+      "\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557    \u2588\u2588\u2557",
+      "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551    \u2588\u2588\u2551",
+      "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551",
+      "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551",
+      "\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D",
+      "\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D "
+    ];
+  }
+});
+
+// src/ui/render.ts
+function write(text) {
+  if (!text) return;
+  process.stdout.write(text);
+  atLineStart = text.endsWith("\n");
+}
+function line(text = "") {
+  if (!atLineStart) process.stdout.write("\n");
+  process.stdout.write(`${text}
+`);
+  atLineStart = true;
+}
+function breakLine() {
+  if (!atLineStart) {
+    process.stdout.write("\n");
+    atLineStart = true;
+  }
+}
+function toolBucket(name) {
+  if (["run_command", "start_process", "stop_process", "open_browser", "wait_for_url", "ssh_run", "ssh_upload", "ssh_download", "docker_exec", "docker_ps", "docker_logs", "install_package", "kill_process", "check_port", "list_processes", "get_process_output", "curl_request", "check_github_auth"].includes(name)) return "shell";
+  if (["read_file", "write_file", "str_replace_file", "append_file", "delete_path", "list_directory", "file_search"].includes(name)) return "fs";
+  if (["git_status", "git_diff", "git_log", "git_add", "git_commit", "git_push", "git_pull", "git_branch", "git_clone"].includes(name)) return "git";
+  if (["search_files"].includes(name)) return "code";
+  if (["web_search", "web_fetch"].includes(name)) return "web";
+  if (["spawn_subagents"].includes(name)) return "agent";
+  if (["todo_list"].includes(name)) return "session";
+  return name;
+}
+function shortPath(p) {
+  if (!p) return "";
+  const cwd = process.cwd();
+  if (p.startsWith(cwd + "/")) return p.slice(cwd.length + 1);
+  const home = process.env.HOME;
+  if (home && p.startsWith(home + "/")) return "~/" + p.slice(home.length + 1);
+  return p;
+}
+function headerFor(name, target) {
+  switch (name) {
+    // shell — command echoed verbatim
+    case "run_command":
+      return { head: "I will run the following command:", command: target };
+    case "ssh_run":
+      return { head: `I will run the following command${target ? ` on ${target}` : ""}:`, command: target };
+    case "docker_exec":
+      return { head: `I will run the following command in ${target ?? "the container"}:`, command: target };
+    case "curl_request":
+      return { head: "Making an HTTP request", command: target };
+    case "install_package":
+      return { head: `Installing package: ${target ?? ""}`.trimEnd() };
+    case "kill_process":
+      return { head: `Stopping process: ${target ?? ""}`.trimEnd() };
+    // background processes
+    case "start_process":
+      return { head: "I will start the following in the background:", command: target };
+    case "stop_process":
+      return { head: `Stopping background process: ${target ?? ""}`.trimEnd() };
+    case "get_process_output":
+      return { head: `Reading process output${target ? `: ${target}` : ""}` };
+    case "open_browser":
+      return { head: `Opening in the browser: ${target ?? ""}`.trimEnd() };
+    case "wait_for_url":
+      return { head: `Waiting for ${target ?? "the server"} to respond` };
+    // file writes — one neutral verb before; the completion line says created/updated
+    case "write_file":
+      return { head: `Writing: ${shortPath(target)}`.trimEnd() };
+    case "str_replace_file":
+      return { head: `Editing: ${shortPath(target)}`.trimEnd() };
+    case "append_file":
+      return { head: `Appending to: ${shortPath(target)}`.trimEnd() };
+    case "delete_path":
+      return { head: `Deleting: ${shortPath(target)}`.trimEnd() };
+    // file reads
+    case "read_file":
+      return { head: `Reading file: ${shortPath(target)}`.trimEnd() };
+    case "list_directory":
+      return { head: `Reading directory: ${shortPath(target) || "."}` };
+    case "search_files":
+      return { head: `Searching for: ${target ?? ""}`.trimEnd() };
+    case "file_search":
+      return { head: `Searching for files: ${target ?? ""}`.trimEnd() };
+    // inspection
+    case "get_system_info":
+      return { head: "Inspecting the system" };
+    case "check_port":
+      return { head: `Checking port${target ? ` ${target}` : ""}` };
+    case "list_processes":
+      return { head: "Listing running processes" };
+    // git
+    case "git_status":
+      return { head: "Checking git status" };
+    case "git_diff":
+      return { head: "Reading the git diff" };
+    case "git_log":
+      return { head: "Reading the git log" };
+    case "git_add":
+      return { head: `Staging${target ? ` ${target}` : " changes"}` };
+    case "git_commit":
+      return { head: "Creating a commit" };
+    case "git_push":
+      return { head: "Pushing to the remote" };
+    case "git_pull":
+      return { head: "Pulling from the remote" };
+    case "git_branch":
+      return { head: "Managing branches" };
+    case "git_clone":
+      return { head: `Cloning ${target ?? "repository"}` };
+    case "check_github_auth":
+      return { head: "Checking GitHub auth" };
+    // docker
+    case "docker_ps":
+      return { head: "Listing containers" };
+    case "docker_logs":
+      return { head: `Reading container logs${target ? `: ${target}` : ""}` };
+    // ssh transfer
+    case "ssh_upload":
+      return { head: `Uploading to ${target ?? "the remote host"}` };
+    case "ssh_download":
+      return { head: `Downloading from ${target ?? "the remote host"}` };
+    // web
+    case "web_search":
+      return { head: `Searching the web for: ${target ?? ""}`.trimEnd() };
+    case "web_fetch":
+      return { head: `Fetching: ${target ?? ""}`.trimEnd() };
+    case "todo_list":
+      return { head: "Updating the task list" };
+    case "spawn_subagents":
+      return { head: "Running independent tasks in parallel" };
+    default:
+      return { head: humanTool(name) };
+  }
+}
+function toolRunning(name, target) {
+  breakLine();
+  const { head, command } = headerFor(name, target);
+  const suffix = c.dim(` (using tool: ${toolBucket(name)})`);
+  if (command) {
+    process.stdout.write(`${c.bold(head)} ${c.cyan(command)}${suffix}
+`);
+  } else {
+    process.stdout.write(`${c.bold(head)}${suffix}
+`);
+  }
+  atLineStart = true;
+}
+function toolDone(name, status, durationMs, effect, bytes) {
+  breakLine();
+  const time = durationMs !== void 0 ? formatMs(durationMs) : "0ms";
+  if (status === "success" || status === "executed") {
+    const patch = effect?.patch;
+    if (patch) {
+      for (const l of patch.lines) {
+        if (l.kind === "ctx") {
+          const nums = `${String(l.oldLine ?? "").padStart(3)},${String(l.newLine ?? "").padStart(3)}:`;
+          process.stdout.write(`  ${c.dim(nums)} ${c.dim(l.text)}
+`);
+        } else if (l.kind === "del") {
+          const nums = `-${String(l.oldLine ?? "").padStart(3)}   :`;
+          process.stdout.write(`  ${c.red(nums)} ${c.red(l.text)}
+`);
+        } else if (l.kind === "add") {
+          const nums = `+${String(l.newLine ?? "").padStart(3)}   :`;
+          process.stdout.write(`  ${c.green(nums)} ${c.green(l.text)}
+`);
+        }
+      }
+      if (patch.truncated) process.stdout.write(`  ${c.dim(`\u2026 +${patch.truncated} more lines`)}
+`);
+    }
+    if (effect && (effect.kind === "wrote" || effect.kind === "modified" || effect.kind === "deleted")) {
+      const verb = effect.kind === "wrote" ? "Created" : effect.kind === "modified" ? "Updated" : "Deleted";
+      const size = bytes && effect.kind !== "deleted" ? ` ${formatBytes3(bytes)}` : "";
+      process.stdout.write(c.dim(` \u2014 ${verb}${size} in ${time}
+`));
+    } else {
+      process.stdout.write(c.dim(` \u2014 Completed in ${time}
+`));
+    }
+  } else if (status === "queued") {
+    process.stdout.write(`  ${c.yellow(glyph.caret)} ${c.dim("Queued for approval")}
+`);
+  } else {
+    process.stdout.write(`  ${c.red(glyph.cross)} ${c.red("Failed")} ${c.dim(`after ${time}`)}
+`);
+  }
+  atLineStart = true;
+}
+function toolOutputLine(line2) {
+  breakLine();
+  const trimmed = line2.length > 200 ? `${line2.slice(0, 197)}\u2026` : line2;
+  process.stdout.write(`  ${c.dim(trimmed)}
+`);
+  atLineStart = true;
+}
+function dim(text) {
+  return c.dim(text);
+}
+function formatBytes3(n) {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+function toolSkipped(name) {
+  breakLine();
+  process.stdout.write(`  ${c.dim(glyph.skip)} ${c.dim(`${humanTool(name)} \u2014 skipped`)}
+`);
+  atLineStart = true;
+}
+function note(text) {
+  line(c.dim(`  ${text}`));
+}
+function error(text) {
+  line(`${c.red(glyph.cross)} ${text}`);
+}
+function success(text) {
+  line(`${c.green(glyph.tick)} ${text}`);
+}
+function humanTool(name) {
+  return name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function formatMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.round(ms / 6e4)}m`;
+}
+function statusLine(s) {
+  const parts = [
+    `${c.dim("cost")} ${s.turnCredits.toFixed(2)}`,
+    `${c.dim("left")} ${s.balance.toFixed(2)}`,
+    `${c.dim("took")} ${formatMs(s.elapsedMs)}`
+  ];
+  const ctx = s.context;
+  if (ctx?.promptTokens !== void 0 && ctx.usagePercent !== void 0) {
+    const k = (ctx.promptTokens / 1e3).toFixed(1);
+    const pct = ctx.usagePercent;
+    const gauge = `${k}K (${pct}%)`;
+    parts.push(`${c.dim("ctx")} ${pct >= 75 ? c.yellow(gauge) : c.dim(gauge)}`);
+  }
+  if (s.model) parts.push(c.dim(shortModel(s.model)));
+  breakLine();
+  process.stdout.write(`${c.dim(`  ${glyph.caret} `)}${parts.join(c.dim(" \xB7 "))}
+
+`);
+  atLineStart = true;
+}
+function shortModel(id) {
+  return id.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+}
+var atLineStart, Spinner;
+var init_render = __esm({
+  "src/ui/render.ts"() {
+    "use strict";
+    init_theme();
+    atLineStart = true;
+    Spinner = class {
+      timer = null;
+      frame = 0;
+      text = "";
+      active = false;
+      start(text) {
+        this.text = text;
+        if (!process.stdout.isTTY) return;
+        if (this.active) {
+          this.update(text);
+          return;
+        }
+        breakLine();
+        this.active = true;
+        this.timer = setInterval(() => {
+          const f = glyph.spinner[this.frame++ % glyph.spinner.length];
+          process.stdout.write(`\r${c.green(f)} ${c.dim(this.text)}\x1B[K`);
+        }, 80);
+        this.timer.unref?.();
+      }
+      update(text) {
+        this.text = text;
+      }
+      /** Stop and erase the line, leaving the cursor where the spinner began. */
+      stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+        const erased = this.active && process.stdout.isTTY === true;
+        if (erased) process.stdout.write("\r\x1B[K");
+        this.active = false;
+        if (erased) atLineStart = true;
+      }
+    };
+  }
+});
+
+// src/auth/device.ts
+var device_exports = {};
+__export(device_exports, {
+  login: () => login,
+  reauthenticate: () => reauthenticate
+});
+async function login(opts = {}) {
+  const base = getConfig().baseUrl || DEFAULT_BASE_URL2;
+  let start;
+  try {
+    const res = await fetch(`${base}/api/auth/device`, { method: "POST", signal: opts.signal });
+    if (!res.ok) {
+      error(`Could not start login (HTTP ${res.status}). Try again in a moment.`);
+      return false;
+    }
+    start = await res.json();
+  } catch (e) {
+    if (opts.signal?.aborted) throw new AbortedError();
+    error("Could not reach Hostwares to start login. Check your connection.");
+    return false;
+  }
+  if (!start.device_code || !start.user_code || !start.verification_url) {
+    error("Login response from the server was incomplete. Please report this.");
+    return false;
+  }
+  if (!opts.quiet) line();
+  line(`  Open this URL to authorise:`);
+  line(`  ${c.cyan(start.verification_url)}`);
+  line();
+  line(`  Confirmation code: ${c.bold(start.user_code)}`);
+  line();
+  if (!opts.noBrowser) openBrowser(start.verification_url);
+  const intervalMs = Math.max(1e3, (start.interval ?? 3) * 1e3);
+  const deadline = Date.now() + (start.expires_in ?? 600) * 1e3;
+  note(`Waiting for authorisation\u2026 ${c.dim("(Ctrl-C to cancel)")}`);
+  while (Date.now() < deadline) {
+    if (opts.signal?.aborted) throw new AbortedError();
+    await sleep(intervalMs, opts.signal);
+    let poll;
+    try {
+      poll = await fetch(
+        `${base}/api/auth/device-poll?code=${encodeURIComponent(start.device_code)}`,
+        { signal: opts.signal }
+      );
+    } catch {
+      continue;
+    }
+    if (poll.status === 429) {
+      await sleep(intervalMs, opts.signal);
+      continue;
+    }
+    let data;
+    try {
+      data = await poll.json();
+    } catch {
+      continue;
+    }
+    if (data.status === "approved" && data.token) {
+      saveConfig({ apiKey: data.token, baseUrl: base });
+      reloadConfig();
+      if (!opts.quiet) success("Signed in.");
+      return true;
+    }
+    if (data.error === "expired" || poll.status === 410) {
+      error("That code expired. Run `hw login` again.");
+      return false;
+    }
+    if (poll.status === 404) {
+      error("That login request is no longer valid. Run `hw login` again.");
+      return false;
+    }
+  }
+  error("Login timed out. Run `hw login` to try again.");
+  return false;
+}
+async function reauthenticate(signal) {
+  line();
+  note(`${glyph.warn} Your sign-in expired. Reconnecting\u2026`);
+  const ok = await login({ quiet: true, signal });
+  if (ok) note(`${glyph.tick} Reconnected \u2014 carrying on.`);
+  return ok;
+}
+function openBrowser(url) {
+  const [bin, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    exec(bin, args, { timeoutMs: 5e3 });
+  } catch {
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    const t = setTimeout(resolve2, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      reject(new AbortedError());
+    }, { once: true });
+  });
+}
+var init_device = __esm({
+  "src/auth/device.ts"() {
+    "use strict";
+    init_esm();
+    init_config();
+    init_theme();
+    init_render();
+    init_esm();
+  }
+});
+
+// src/index.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname4, join as join8 } from "path";
+
+// src/agent/run.ts
+init_esm();
+init_config();
+init_device();
+
+// src/agent/permissions.ts
+init_config();
+
+// src/ui/input.ts
+init_theme();
+import { createInterface } from "readline";
+var repl = null;
+var queue = Promise.resolve();
+function createReplInterface(prompt) {
+  repl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt,
+    // Ctrl-C is handled explicitly via the SIGINT event so an in-flight
+    // request can be aborted without killing the process.
+    terminal: process.stdout.isTTY === true,
+    historySize: 500
+  });
+  return repl;
+}
+function closeRepl() {
+  repl?.close();
+  repl = null;
+}
+async function withExclusiveStdin(fn) {
+  const run3 = queue.then(async () => {
+    const wasRepl = repl;
+    const stdin = process.stdin;
+    const dataListeners = stdin.listeners("data");
+    const keypressListeners = stdin.listeners("keypress");
+    wasRepl?.pause();
+    for (const l of dataListeners) stdin.removeListener("data", l);
+    for (const l of keypressListeners) stdin.removeListener("keypress", l);
+    try {
+      return await fn();
+    } finally {
+      for (const l of dataListeners) stdin.on("data", l);
+      for (const l of keypressListeners) stdin.on("keypress", l);
+      if (wasRepl) {
+        wasRepl.resume();
+      }
+    }
+  });
+  queue = run3.catch(() => void 0);
+  return run3;
+}
+async function readKey(allowed) {
+  if (!process.stdin.isTTY) {
+    return "";
+  }
+  return withExclusiveStdin(() => new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw === true;
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY) stdin.setRawMode(wasRaw);
+      if (!wasRaw) stdin.pause();
+    };
+    const onData = (buf) => {
+      const seq = buf.toString("utf8");
+      let key;
+      if (seq === "") key = "ctrl-c";
+      else if (seq === "\x1B[A") key = "up";
+      else if (seq === "\x1B[B") key = "down";
+      else if (seq === "\x1B[C") key = "right";
+      else if (seq === "\x1B[D") key = "left";
+      else if (seq === "\x1B") key = "escape";
+      else if (seq === "\r" || seq === "\n") key = "enter";
+      else key = seq[0]?.toLowerCase() ?? "";
+      if (allowed && !allowed.includes(key) && key !== "ctrl-c" && key !== "escape") return;
+      cleanup();
+      if (key.length === 1) process.stdout.write(key);
+      process.stdout.write("\n");
+      resolve2(key);
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+  }));
+}
+async function confirm(prompt, defaultAnswer = false) {
+  const hint = defaultAnswer ? "[Y/n]" : "[y/N]";
+  process.stdout.write(`${prompt} ${c.dim(hint)} `);
+  const key = await readKey();
+  if (key === "ctrl-c" || key === "escape") return false;
+  if (key === "enter" || key === "") return defaultAnswer;
+  return key === "y";
+}
+async function pickScope(options) {
+  if (!process.stdin.isTTY) return 0;
+  return withExclusiveStdin(() => new Promise((resolve2) => {
+    let idx = 0;
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw === true;
+    const render = () => {
+      process.stdout.write(`
+ ${c.dim("Press")} ${c.bold("(\u2191\u2193)")} ${c.dim("to navigate \xB7")} ${c.bold("(\u21B5)")} ${c.dim("to select scope")}
+`);
+      for (let i = 0; i < options.length; i++) {
+        const sel = i === idx;
+        const arrow = sel ? c.cyan(">") : " ";
+        const txt = sel ? c.bold(c.cyan(options[i])) : c.dim(options[i]);
+        process.stdout.write(`${arrow} ${txt}
+`);
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY) stdin.setRawMode(wasRaw);
+      if (!wasRaw) stdin.pause();
+    };
+    const onData = (buf) => {
+      const seq = buf.toString("utf8");
+      if (seq === "") {
+        cleanup();
+        resolve2(-1);
+        return;
+      }
+      if (seq === "\x1B") {
+        cleanup();
+        resolve2(-1);
+        return;
+      }
+      if (seq === "\x1B[A") {
+        idx = (idx - 1 + options.length) % options.length;
+        process.stdout.write(`\x1B[${options.length + 1}A\x1B[J`);
+        render();
+        return;
+      }
+      if (seq === "\x1B[B") {
+        idx = (idx + 1) % options.length;
+        process.stdout.write(`\x1B[${options.length + 1}A\x1B[J`);
+        render();
+        return;
+      }
+      if (seq === "\r" || seq === "\n") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve2(idx);
+        return;
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+    render();
+  }));
+}
+
+// src/agent/permissions.ts
+init_theme();
+init_render();
+init_esm();
+var READ_ONLY = /* @__PURE__ */ new Set([
+  "read_file",
+  "list_directory",
+  "get_system_info",
+  "git_status",
+  "git_log",
+  "git_diff",
+  "check_github_auth",
+  "docker_ps",
+  "list_processes",
+  "check_port",
+  "get_process_output",
+  "open_browser",
+  "wait_for_url",
+  "web_search",
+  "web_fetch"
+]);
+var ALWAYS_ASK2 = /* @__PURE__ */ new Set(["delete_path", "kill_process", "ssh_run", "git_push"]);
+var sessionTrust = false;
+var sessionRules = [];
+function isSessionTrusted() {
+  return sessionTrust;
+}
+function setSessionTrust(on) {
+  sessionTrust = on;
+}
+function addSessionRule(rule) {
+  sessionRules.push(rule);
+}
+var cachedRules = null;
+function permissionRules() {
+  if (cachedRules === null) {
+    try {
+      cachedRules = loadPermissionRules(process.cwd());
+    } catch {
+      cachedRules = [];
+    }
+  }
+  return cachedRules;
+}
+function isProjectTrusted(cwd = process.cwd()) {
+  return (getConfig().trustedProjects ?? []).includes(cwd);
+}
+function setProjectTrust(on, cwd = process.cwd()) {
+  const current = new Set(getConfig().trustedProjects ?? []);
+  if (on) current.add(cwd);
+  else current.delete(cwd);
+  saveConfig({ trustedProjects: [...current] });
+}
+async function askPermission(tool) {
+  if (sessionRules.length) {
+    const v = decidePermission(tool.name, tool.input, sessionRules, "none", tool.destructive);
+    if (v === "allow") return "allow";
+    if (v === "deny") return "deny";
+  }
+  const trust = sessionTrust ? "session" : isProjectTrusted() ? "project" : "none";
+  const verdict = decidePermission(tool.name, tool.input, permissionRules(), trust, tool.destructive);
+  if (verdict === "deny") {
+    process.stdout.write(`
+${c.red(glyph.warn)} ${c.red("Refused:")} ${describe(tool)} ${c.dim("(blocked by a permission rule)")}
+`);
+    return "deny";
+  }
+  if (verdict === "allow") return "allow";
+  if (READ_ONLY.has(tool.name)) return "allow";
+  const alwaysAsk = ALWAYS_ASK2.has(tool.name) || tool.destructive;
+  if (!alwaysAsk && (sessionTrust || isProjectTrusted())) return "allow";
+  breakLine();
+  process.stdout.write(`
+${c.yellow(glyph.caret)} ${describe(tool)}
+`);
+  const consequence = consequenceOf(tool);
+  if (consequence) process.stdout.write(`  ${c.red(glyph.warn)} ${c.dim(consequence)}
+`);
+  const options = alwaysAsk ? `${c.bold("y")} yes  ${c.bold("n")} no  ${c.dim("esc cancel")}` : `${c.bold("y")} yes  ${c.bold("n")} no  ${c.bold("t")} trust this session  ${c.bold("a")} always in this project  ${c.dim("esc cancel")}`;
+  process.stdout.write(`  ${c.dim(options)}: `);
+  const key = await readKey(alwaysAsk ? ["y", "n"] : ["y", "n", "t", "a"]);
+  switch (key) {
+    case "y":
+      return "allow";
+    case "t": {
+      const toolPath = String(tool.input.path ?? tool.input.localPath ?? "");
+      const rel = toolPath ? shortRel(toolPath) : "";
+      const dir = rel ? rel.split("/").slice(0, -1).join("/") || "." : "";
+      const scopeOpts = [
+        `Specific paths      \u2192 ${rel || tool.name}  ${c.dim("(this file only)")}`,
+        `Complete directory  \u2192 ${dir || "."}  ${c.dim("(all files here)")}`,
+        `Entire Tool         \u2192 *  ${c.dim(`(always allow '${tool.name}')`)}`
+      ];
+      const displayOpts = [
+        `Specific paths      \u2192 ${rel || tool.name}`,
+        `Complete directory  \u2192 ${dir || "."}`,
+        `Entire Tool         \u2192 *`
+      ];
+      const choice = await pickScope(displayOpts);
+      if (choice === -1) return "abort";
+      if (choice === 0) {
+        const match = rel || "*";
+        addSessionRule({ tool: tool.name, match, effect: "allow" });
+        process.stdout.write(`  ${c.dim(`Trusted '${tool.name}' for ${match} this session.`)}
+`);
+      } else if (choice === 1) {
+        const match = dir ? `${dir}/*` : "*";
+        addSessionRule({ tool: tool.name, match, effect: "allow" });
+        process.stdout.write(`  ${c.dim(`Trusted '${tool.name}' for ${match} this session.`)}
+`);
+      } else {
+        addSessionRule({ tool: tool.name, match: "*", effect: "allow" });
+        process.stdout.write(`  ${c.dim(`Trusted '${tool.name}' (*) this session.`)}
+`);
+      }
+      return "allow";
+    }
+    case "a":
+      setProjectTrust(true);
+      process.stdout.write(`  ${c.dim(`Always allowed in ${process.cwd()}.`)}
+`);
+      return "allow";
+    case "ctrl-c":
+    case "escape":
+      return "abort";
+    // Includes "" from a non-TTY: with no interactive user there is nobody to
+    // grant permission, and defaulting to allow would let a piped script run
+    // arbitrary commands unattended.
+    default:
+      return "deny";
+  }
+}
+function shortRel(absPath) {
+  const cwd = process.cwd();
+  if (absPath.startsWith(cwd + "/")) return absPath.slice(cwd.length + 1);
+  const home = process.env.HOME;
+  if (home && absPath.startsWith(home + "/")) return "~/" + absPath.slice(home.length + 1);
+  return absPath;
+}
+function describe(tool) {
+  const i = tool.input;
+  const s = (k) => i[k] === void 0 ? "" : String(i[k]);
+  const t = (v, n = 70) => v.length > n ? `${v.slice(0, n - 1)}\u2026` : v;
+  switch (tool.name) {
+    case "run_command":
+      return `Run ${c.bold(t(s("command"), 90))}`;
+    case "start_process":
+      return `Start in background ${c.bold(t(s("command"), 80))}${s("name") ? c.dim(` (as ${s("name")})`) : ""}`;
+    case "stop_process":
+      return `Stop background process ${c.bold(s("name"))}`;
+    case "write_file":
+      return `Write ${c.bold(s("path"))} ${c.dim(`(${String(i.content ?? "").length} chars)`)}`;
+    case "append_file":
+      return `Append to ${c.bold(s("path"))}`;
+    case "str_replace_file": {
+      const old = String(i.oldStr ?? "").split("\n")[0]?.slice(0, 60) ?? "";
+      return `Edit ${c.bold(s("path"))}${old ? c.dim(` \u2014 replace "${old}\u2026"`) : ""}`;
+    }
+    case "delete_path":
+      return `Delete ${c.bold(s("path"))}`;
+    case "search_files":
+      return `Search for ${c.bold(t(s("pattern")))}`;
+    case "install_package":
+      return `Install package ${c.bold(s("name"))}`;
+    case "git_add":
+      return `Stage ${c.bold(s("files"))}`;
+    case "git_commit":
+      return `Commit: ${c.bold(t(s("message")))}`;
+    case "git_push":
+      return `Push to ${c.bold(s("remote") || "origin")}${s("branch") ? `/${s("branch")}` : ""}`;
+    case "git_pull":
+      return `Pull from ${c.bold(s("remote") || "origin")}`;
+    case "git_clone":
+      return `Clone ${c.bold(s("url"))}`;
+    case "git_branch":
+      return `Branch: ${c.bold(s("action"))}${s("name") ? ` ${s("name")}` : ""}`;
+    case "ssh_run":
+      return `Run on ${c.bold(`${s("user")}@${s("host")}`)}: ${c.bold(t(s("command")))}`;
+    case "ssh_upload":
+      return `Upload ${c.bold(s("localPath"))} to ${c.bold(`${s("user")}@${s("host")}:${s("remotePath")}`)}`;
+    case "ssh_download":
+      return `Download ${c.bold(`${s("user")}@${s("host")}:${s("remotePath")}`)}`;
+    case "kill_process":
+      return `Kill process ${c.bold(s("target"))}`;
+    case "docker_exec":
+      return `Run in container ${c.bold(s("container"))}: ${c.bold(t(s("command")))}`;
+    case "docker_logs":
+      return `Read logs from ${c.bold(s("container"))}`;
+    case "curl_request":
+      return `${c.bold(s("method") || "GET")} ${c.bold(t(s("url")))}`;
+    default:
+      return humanTool(tool.name);
+  }
+}
+function consequenceOf(tool) {
+  const i = tool.input;
+  switch (tool.name) {
+    case "delete_path":
+      return "Permanently removes this path and everything under it. There is no recycle bin.";
+    case "git_push":
+      return "Publishes commits to the remote, where others may already have pulled from it.";
+    case "git_branch":
+      return i.action === "delete" ? "Deletes the branch. Unmerged commits on it become unreachable." : null;
+    case "ssh_run":
+      return "Runs on a remote server, outside this machine.";
+    case "kill_process":
+      return "Terminates the process immediately; unsaved work in it is lost.";
+    case "write_file":
+      return "Overwrites the file if it already exists.";
+    case "docker_exec":
+      return "Runs inside a container, which may hold live data.";
+    default:
+      return null;
+  }
+}
+
+// src/agent/run.ts
+init_theme();
+init_render();
+async function runCliTurn(opts) {
+  const config = getConfig();
+  const spinner = new Spinner();
+  const promptedIds = /* @__PURE__ */ new Set();
+  const MAX_LIVE_LINES = 12;
+  const live = /* @__PURE__ */ new Map();
+  const track = (id) => {
+    let s = live.get(id);
+    if (!s) {
+      s = { shown: 0, total: 0, partial: "" };
+      live.set(id, s);
+    }
+    return s;
+  };
+  const feed = (id, chunk) => {
+    const st = track(id);
+    st.partial += chunk;
+    const lines = st.partial.split("\n");
+    st.partial = lines.pop() ?? "";
+    for (const line2 of lines) {
+      st.total++;
+      if (st.shown < MAX_LIVE_LINES) {
+        toolOutputLine(line2);
+        st.shown++;
+      } else if (st.shown === MAX_LIVE_LINES) {
+        toolOutputLine(dim("\u2026 still running, output hidden"));
+        st.shown++;
+      }
+    }
+  };
+  const finish2 = (id) => {
+    const st = live.get(id);
+    if (!st) return { hidden: 0 };
+    if (st.partial.trim()) {
+      st.total++;
+      if (st.shown < MAX_LIVE_LINES) {
+        toolOutputLine(st.partial);
+        st.shown++;
+      }
+    }
+    live.delete(id);
+    return { hidden: Math.max(0, st.total - Math.min(st.shown, MAX_LIVE_LINES)) };
+  };
+  const host = {
+    cwd: process.cwd(),
+    askPermission: (call) => {
+      promptedIds.add(call.id);
+      return askPermission(call);
+    },
+    confirmAction: async (action) => {
+      breakLine();
+      const risk = action.risk === "critical" ? c.red(action.risk) : action.risk === "high" ? c.yellow(action.risk) : c.dim(action.risk);
+      line(`${c.yellow("\u25B8")} ${action.description} ${c.dim(`(${risk})`)}`);
+      return confirm("  Run this?", false);
+    },
+    trustLevel: () => isSessionTrusted() || isProjectTrusted() ? "session" : "none",
+    onActivity: (e) => {
+      switch (e.type) {
+        case "thinking":
+          spinner.start("Working");
+          break;
+        case "text":
+          spinner.stop();
+          write(e.chunk);
+          break;
+        case "tool:start":
+          spinner.stop();
+          if (promptedIds.has(e.id)) {
+            promptedIds.delete(e.id);
+          } else {
+            toolRunning(e.tool, e.target);
+          }
+          break;
+        case "tool:output":
+          spinner.stop();
+          feed(e.id, e.chunk);
+          break;
+        case "tool:end": {
+          if (e.summary && /loop guard/i.test(e.summary)) {
+            spinner.stop();
+            note("Skipped a repeated read (already have it) \u2014 moving on.");
+            break;
+          }
+          const { hidden } = finish2(e.id);
+          if (hidden > 0) toolOutputLine(dim(`\u2026 +${hidden} more line${hidden === 1 ? "" : "s"}`));
+          toolDone(e.tool, e.ok ? "success" : "failed", e.durationMs, e.effect, e.bytes);
+          break;
+        }
+        case "tool:denied":
+          toolSkipped(e.tool);
+          break;
+        case "action:done":
+          if (e.ok) success(e.detail?.split("\n")[0] ?? "Done");
+          else note(e.detail ?? "Cancelled");
+          break;
+        case "turn:end":
+          spinner.stop();
+          breakLine();
+          statusLine({
+            balance: e.usage.balance,
+            turnCredits: e.usage.credits,
+            elapsedMs: e.usage.elapsedMs,
+            context: e.usage,
+            model: e.usage.model
+          });
+          break;
+        case "reauth":
+          spinner.stop();
+          break;
+        case "error":
+          spinner.stop();
+          error(e.message);
+          break;
+        case "tool:pending":
+          spinner.stop();
+          break;
+      }
+    }
+  };
+  try {
+    const result = await runTurn({
+      credentials: { apiKey: config.apiKey, baseUrl: config.baseUrl, userAgent: `hostwares-cli/${VERSION}` },
+      message: opts.message,
+      conversationId: opts.session.conversationId,
+      model: config.model,
+      signal: opts.signal,
+      host,
+      onAuthFailure: () => reauthenticate(opts.signal)
+    });
+    if (result.aborted) {
+      breakLine();
+      note("Stopped.");
+    }
+    return {
+      conversationId: result.conversationId,
+      creditsSpent: result.creditsSpent,
+      aborted: result.aborted
+    };
+  } finally {
+    spinner.stop();
+  }
+}
+var VERSION = "0.0.0";
+function setVersion(v) {
+  VERSION = v;
+}
+
+// src/errors.ts
+init_esm();
+init_render();
+function reportError(e) {
+  breakLine();
+  if (e instanceof ApiError) {
+    if (e.isOutOfCredits) {
+      error("You're out of credits.");
+      note("Ask me to buy credits \u2014 billing and support messages are free.");
+      return;
+    }
+    if (e.status === 429) {
+      error("Too many requests in a row.");
+      note("Wait a few seconds and try again.");
+      return;
+    }
+    if (e.code === "ai_terms_required") {
+      error("You need to accept the AI agent terms before using this.");
+      note(String(e.body.termsUrl ?? "https://hostwares.com/terms#ai-agent"));
+      return;
+    }
+    if (e.isAuthFailure) {
+      error("Not signed in. Run `hw login`.");
+      return;
+    }
+    error(e.message);
+    return;
+  }
+  error(e instanceof Error ? e.message : String(e));
+}
+
+// src/index.ts
+init_device();
+
+// src/commands/slash.ts
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_config();
+
+// src/session/store.ts
+init_config();
+import { createHash } from "crypto";
+import { join as join7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync5, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "fs";
+var SESSION_DIR = join7(HW_DIR, "sessions");
+var SCHEMA_VERSION = 2;
+function sessionPath(cwd) {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 24);
+  return join7(SESSION_DIR, `${hash}.json`);
+}
+function newSession(cwd = process.cwd()) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: SCHEMA_VERSION,
+    cwd,
+    conversationId: null,
+    createdAt: now,
+    updatedAt: now,
+    turns: [],
+    creditsSpent: 0
+  };
+}
+function loadSession(cwd = process.cwd()) {
+  const file = sessionPath(cwd);
+  if (!existsSync7(file)) return null;
+  try {
+    const data = JSON.parse(readFileSync7(file, "utf8"));
+    if (data.version !== SCHEMA_VERSION) return null;
+    if (data.cwd !== cwd) return null;
+    if (!Array.isArray(data.turns)) return null;
+    return {
+      version: SCHEMA_VERSION,
+      cwd,
+      conversationId: typeof data.conversationId === "string" ? data.conversationId : null,
+      createdAt: data.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: data.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      turns: data.turns.filter(isTurn),
+      creditsSpent: typeof data.creditsSpent === "number" ? data.creditsSpent : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function isTurn(t) {
+  return Boolean(t) && typeof t === "object" && typeof t.content === "string" && (t.role === "user" || t.role === "assistant");
+}
+var MAX_LOCAL_TURNS = 200;
+function saveSession(session) {
+  mkdirSync5(SESSION_DIR, { recursive: true, mode: 448 });
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (session.turns.length > MAX_LOCAL_TURNS) {
+    session.turns = session.turns.slice(-MAX_LOCAL_TURNS);
+  }
+  writeJsonSecure(sessionPath(session.cwd), session);
+}
+function appendTurn(session, role, content) {
+  session.turns.push({ role, content, at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function listSessions() {
+  if (!existsSync7(SESSION_DIR)) return [];
+  const out = [];
+  for (const name of readdirSync5(SESSION_DIR)) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const data = JSON.parse(readFileSync7(join7(SESSION_DIR, name), "utf8"));
+      if (data.version !== SCHEMA_VERSION || !data.cwd) continue;
+      out.push({
+        cwd: data.cwd,
+        conversationId: data.conversationId ?? null,
+        updatedAt: data.updatedAt,
+        turnCount: Array.isArray(data.turns) ? data.turns.length : 0,
+        creditsSpent: data.creditsSpent ?? 0
+      });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+// src/commands/slash.ts
+init_theme();
+init_render();
+var COMMANDS = [
+  { name: "/help", help: "Show this list" },
+  { name: "/new", help: "Start a fresh conversation" },
+  { name: "/resume", args: "[n]", help: "List recent conversations, or resume the nth" },
+  { name: "/chat", args: "resume", help: "Same as /resume" },
+  { name: "/sessions", help: "Show sessions saved on this machine" },
+  { name: "/context", help: "Context usage for this conversation" },
+  { name: "/tools", help: "Tools that run on this machine" },
+  { name: "/steering", help: "Create .hostwares/steering/*.md so HW knows this project" },
+  { name: "/rewind", args: "[n]", help: "Undo the last change (or the nth checkpoint). Lists them with no arg." },
+  { name: "/trust", help: "Stop asking permission this session" },
+  { name: "/untrust", help: "Ask permission again" },
+  { name: "/model", args: "[name]", help: "Show or set the model" },
+  { name: "/credits", help: "Credit balance" },
+  { name: "/login", help: "Sign in again" },
+  { name: "/logout", help: "Sign out on this machine" },
+  { name: "/exit", help: "Leave" }
+];
+async function handleSlash(input, ctx) {
+  const [cmd, ...rest] = input.trim().split(/\s+/);
+  const arg = rest.join(" ");
+  switch (cmd) {
+    case "/help":
+      showHelp();
+      return "handled";
+    case "/exit":
+    case "/quit":
+      ctx.quit();
+      return "handled";
+    case "/new": {
+      const fresh = newSession(ctx.session.cwd);
+      ctx.session.conversationId = null;
+      ctx.session.turns = [];
+      ctx.session.createdAt = fresh.createdAt;
+      saveSession(ctx.session);
+      line(c.dim("  Started a new conversation."));
+      return "handled";
+    }
+    case "/resume":
+    case "/chat":
+      await resume(arg.replace(/^resume\s*/, ""), ctx);
+      return "handled";
+    case "/sessions":
+      showSessions();
+      return "handled";
+    case "/context":
+      showContext(ctx.session);
+      return "handled";
+    case "/tools":
+      showTools();
+      return "handled";
+    case "/steering":
+      scaffoldSteering(ctx.session.cwd);
+      return "handled";
+    case "/rewind":
+      rewindCheckpoint(ctx.session.cwd, arg);
+      return "handled";
+    case "/trust":
+      setSessionTrust(true);
+      line(c.dim("  Won't ask again this session. Deletes, kills, pushes and SSH still ask."));
+      return "handled";
+    case "/untrust":
+      setSessionTrust(false);
+      if (isProjectTrusted()) {
+        setProjectTrust(false);
+        line(c.dim(`  Will ask again, and removed the saved trust for ${process.cwd()}.`));
+      } else {
+        line(c.dim("  Will ask again."));
+      }
+      return "handled";
+    case "/model":
+      setModel(arg);
+      return "handled";
+    case "/credits":
+      await showCredits(ctx.signal);
+      return "handled";
+    case "/login":
+      await (await Promise.resolve().then(() => (init_device(), device_exports))).login({ signal: ctx.signal });
+      return "handled";
+    case "/logout":
+      clearConfig();
+      line(c.dim("  Signed out. Run `hw login` to sign back in."));
+      ctx.quit();
+      return "handled";
+    default:
+      return "unknown";
+  }
+}
+function showHelp() {
+  line();
+  for (const { name, args, help } of COMMANDS) {
+    const label = args ? `${name} ${c.dim(args)}` : name;
+    line(`  ${c.green(label.padEnd(hasArgsPad(name, args)))}  ${c.dim(help)}`);
+  }
+  line();
+  line(c.dim(`  ${glyph.bullet} Start a line with ! to run a shell command directly`));
+  line(c.dim(`  ${glyph.bullet} Ctrl-C stops the current reply, twice to leave`));
+  line();
+}
+function hasArgsPad(name, args) {
+  return 22 + (args ? `${args}`.length + 9 : 0);
+}
+async function resume(arg, ctx) {
+  let rows;
+  try {
+    rows = await listConversations(
+      { apiKey: getConfig().apiKey, baseUrl: getConfig().baseUrl },
+      { limit: 15, signal: ctx.signal }
+    );
+  } catch (e) {
+    reportError(e);
+    return;
+  }
+  if (!rows.length) {
+    line(c.dim("  No previous conversations."));
+    return;
+  }
+  const pick = Number(arg);
+  if (Number.isInteger(pick) && pick >= 1 && pick <= rows.length) {
+    const chosen = rows[pick - 1];
+    ctx.session.conversationId = chosen.id;
+    ctx.session.turns = [];
+    saveSession(ctx.session);
+    line(c.dim(`  Resumed "${chosen.title}" (${chosen.messageCount} messages).`));
+    return;
+  }
+  line();
+  rows.forEach((r, i) => {
+    const when = relativeTime(r.updatedAt);
+    line(`  ${c.bold(String(i + 1).padStart(2))}  ${r.title.slice(0, 52).padEnd(52)} ${c.dim(`${r.messageCount} msg \xB7 ${when}`)}`);
+  });
+  line();
+  line(c.dim("  /resume <number> to continue one"));
+  line();
+}
+function showSessions() {
+  const sessions = listSessions();
+  if (!sessions.length) {
+    line(c.dim("  No saved sessions."));
+    return;
+  }
+  line();
+  for (const s of sessions.slice(0, 20)) {
+    const here = s.cwd === process.cwd() ? c.green(` ${glyph.tick} here`) : "";
+    line(`  ${s.cwd}${here}`);
+    line(c.dim(`    ${s.turnCount} turns \xB7 ${s.creditsSpent.toFixed(2)} credits \xB7 ${relativeTime(s.updatedAt)}`));
+  }
+  line();
+}
+function showContext(session) {
+  line();
+  line(`  Conversation: ${session.conversationId ? c.dim(session.conversationId) : c.dim("not started yet")}`);
+  line(`  Turns here:   ${session.turns.length}`);
+  line(`  Project:      ${c.dim(session.cwd)}`);
+  line();
+  line(c.dim("  Context size is reported by the server after each reply \u2014 see the ctx"));
+  line(c.dim("  figure in the status line. When a session grows past the window the"));
+  line(c.dim("  earlier part is summarised automatically and work continues \u2014 you do"));
+  line(c.dim("  not need to start over."));
+  line();
+}
+function showTools() {
+  line();
+  line(`  ${c.bold(`${LOCAL_TOOL_NAMES.length} tools run on this machine:`)}`);
+  line();
+  const sorted = [...LOCAL_TOOL_NAMES].sort();
+  const rows = Math.ceil(sorted.length / 4);
+  for (let r = 0; r < rows; r++) {
+    const cells = [0, 1, 2, 3].map((col) => sorted[col * rows + r]).filter(Boolean).map((n) => c.dim(n.padEnd(20)));
+    line(`  ${cells.join("")}`);
+  }
+  line();
+  line(c.dim("  Hostwares account tools (sites, databases, DNS, billing) run on the server."));
+  line();
+}
+function scaffoldSteering(cwd) {
+  line();
+  try {
+    const { created, skipped } = generateSteering(cwd);
+    if (created.length) {
+      line(`  ${c.bold("Created steering files")} ${c.dim("in .hostwares/steering/")}`);
+      for (const f of created) line(`    ${c.green(glyph.tick)} ${f}`);
+      line();
+      line(c.dim("  Edit them to describe your project \u2014 they load into every session so HW"));
+      line(c.dim("  stops re-deriving your conventions."));
+    }
+    if (skipped.length) {
+      line(c.dim(`  Left alone (already exist): ${skipped.join(", ")}`));
+    }
+  } catch (e) {
+    line(`  ${c.red(glyph.warn)} Could not create steering files: ${e.message}`);
+  }
+  line();
+}
+function rewindCheckpoint(cwd, arg) {
+  line();
+  const checkpoints = listCheckpoints(cwd);
+  if (!checkpoints.length) {
+    line(c.dim("  Nothing to rewind \u2014 no changes have been checkpointed in this project yet."));
+    line();
+    return;
+  }
+  if (!arg.trim()) {
+    line(`  ${c.bold("Checkpoints")} ${c.dim("(newest first \u2014 /rewind undoes #1, /rewind N undoes the Nth)")}`);
+    line();
+    checkpoints.slice(0, 10).forEach((cp, i) => {
+      const when = new Date(cp.createdAt).toLocaleString();
+      const note2 = cp.note ? ` \u2014 ${cp.note.slice(0, 50)}` : "";
+      line(`    ${c.bold(String(i + 1))}. ${c.dim(`${cp.fileCount} file${cp.fileCount === 1 ? "" : "s"} \xB7 ${when}`)}${c.dim(note2)}`);
+    });
+    line();
+    return;
+  }
+  const n = parseInt(arg.trim(), 10);
+  const label = Number.isFinite(n) && n >= 1 && checkpoints[n - 1] ? checkpoints[n - 1].label : void 0;
+  const result = rewind(cwd, label);
+  if (result.ok) {
+    line(`  ${c.green(glyph.tick)} ${result.message}`);
+    for (const f of result.restored) line(c.dim(`    restored ${f}`));
+    for (const f of result.deleted) line(c.dim(`    removed ${f}`));
+  } else {
+    line(`  ${c.red(glyph.warn)} ${result.message}`);
+  }
+  line();
+}
+function setModel(arg) {
+  const ALLOWED = ["auto", "claude-sonnet-5", "claude-opus-5"];
+  if (!arg) {
+    line(`  Model: ${c.bold(getConfig().model ?? "auto")}`);
+    line(c.dim(`  Options: ${ALLOWED.join(", ")}`));
+    line(c.dim("  auto picks per task \u2014 cheaper for lookups, stronger for debugging."));
+    return;
+  }
+  if (!ALLOWED.includes(arg)) {
+    line(c.red(`  Unknown model "${arg}".`));
+    line(c.dim(`  Options: ${ALLOWED.join(", ")}`));
+    return;
+  }
+  saveConfig({ model: arg });
+  line(c.dim(`  Model set to ${arg}.`));
+  if (arg === "claude-opus-5") line(c.dim("  Opus needs a Business plan; other plans fall back to Sonnet."));
+}
+async function showCredits(signal) {
+  try {
+    const cfg = getConfig();
+    const r = await fetch(`${cfg.baseUrl}/api/credits`, {
+      headers: { Authorization: `Bearer ${cfg.apiKey}` },
+      signal
+    });
+    const res = r.ok ? await r.json() : null;
+    const balance = res?.total ?? res?.balance;
+    if (typeof balance === "number") line(`  Credits: ${c.bold(balance.toFixed(2))}`);
+    else line(c.dim("  Could not read your balance."));
+  } catch (e) {
+    reportError(e);
+  }
+}
+function relativeTime(iso) {
+  const diff = Date.now() - Date.parse(iso);
+  if (!Number.isFinite(diff)) return "unknown";
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+var SLASH_NAMES = COMMANDS.map((c2) => c2.name);
+
+// src/commands/chat.ts
+init_esm();
+init_theme();
+init_render();
+async function startChat(opts = {}) {
+  const cwd = process.cwd();
+  const session = loadSession(cwd) ?? newSession(cwd);
+  if (!opts.resume) session.conversationId = null;
+  if (opts.oneShot) {
+    const code = await sendOne(opts.oneShot, session);
+    return code;
+  }
+  if (opts.resume && session.conversationId) {
+    note(`Continuing where you left off (${session.turns.length} turns). /new to start over.`);
+  } else if (session.turns.length) {
+    note(`${session.turns.length} earlier turns in this folder \u2014 /resume to continue one.`);
+  }
+  return repl2(session);
+}
+async function sendOne(message, session) {
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.on("SIGINT", onSigint);
+  try {
+    const result = await runCliTurn({ message, session, signal: controller.signal });
+    persist(session, message, result.conversationId, result.creditsSpent);
+    return result.aborted ? 130 : 0;
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+}
+async function repl2(session) {
+  const prompt = `${c.green("you")} ${c.dim(glyph.arrow)} `;
+  const rl = createReplInterface(prompt);
+  let leaving = false;
+  let busy = null;
+  let sigintArmed = false;
+  const onSigint = () => {
+    if (busy) {
+      busy.abort();
+      return;
+    }
+    if (sigintArmed) {
+      leaving = true;
+      rl.close();
+      return;
+    }
+    sigintArmed = true;
+    line(c.dim("  (Ctrl-C again to leave, or type /exit)"));
+    rl.prompt();
+  };
+  rl.on("SIGINT", onSigint);
+  rl.prompt();
+  for await (const raw of rl) {
+    const input = raw.trim();
+    sigintArmed = false;
+    if (!input) {
+      rl.prompt();
+      continue;
+    }
+    if (input.startsWith("!")) {
+      const command = input.slice(1).trim();
+      if (command) {
+        breakLine();
+        line(formatResult(await execShell(command, { timeoutMs: 12e4 })));
+      }
+      rl.prompt();
+      continue;
+    }
+    if (input.startsWith("/")) {
+      const controller = new AbortController();
+      const result = await handleSlash(input, {
+        session,
+        quit: () => {
+          leaving = true;
+          rl.close();
+        },
+        signal: controller.signal
+      });
+      if (result === "unknown") {
+        line(c.dim(`  Unknown command. Try ${SLASH_NAMES.slice(0, 4).join(", ")} or /help`));
+      }
+      if (leaving) break;
+      rl.prompt();
+      continue;
+    }
+    busy = new AbortController();
+    try {
+      breakLine();
+      const result = await runCliTurn({ message: input, session, signal: busy.signal });
+      persist(session, input, result.conversationId, result.creditsSpent);
+    } finally {
+      busy = null;
+    }
+    if (leaving) break;
+    rl.prompt();
+  }
+  closeRepl();
+  saveSession(session);
+  if (session.turns.length) {
+    line();
+    line(c.dim(`  ${session.turns.filter((t) => t.role === "user").length} messages \xB7 ${session.creditsSpent.toFixed(2)} credits this session`));
+  }
+  return 0;
+}
+function persist(session, message, conversationId, credits) {
+  if (conversationId) session.conversationId = conversationId;
+  appendTurn(session, "user", message);
+  session.creditsSpent += credits;
+  saveSession(session);
+}
+
+// src/index.ts
+init_config();
+init_theme();
+init_render();
+init_esm();
+var VERSION2 = readVersion();
+setVersion(VERSION2);
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case void 0:
+      return interactive();
+    case "chat":
+      requireAuth();
+      return startChat({ resume: rest.includes("--resume") || rest.includes("-r") });
+    case "ask": {
+      requireAuth();
+      const message = rest.filter((a) => !a.startsWith("-")).join(" ");
+      if (!message) return startChat({});
+      return startChat({ oneShot: message });
+    }
+    case "login":
+      if (rest[0] === "--token" && rest[1]) {
+        saveConfig({ apiKey: rest[1] });
+        success("Signed in with the supplied token.");
+        return 0;
+      }
+      return await login({ noBrowser: rest.includes("--no-browser") }) ? 0 : 1;
+    case "logout":
+      clearConfig();
+      success("Signed out on this machine.");
+      return 0;
+    case "sessions":
+      return showSessions2();
+    case "list":
+    case "ls":
+      requireAuth();
+      return listSites();
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(VERSION2);
+      return 0;
+    case "help":
+    case "--help":
+    case "-h":
+      showHelp2();
+      return 0;
+    default:
+      requireAuth();
+      return startChat({ oneShot: argv.join(" ") });
+  }
+}
+function interactive() {
+  showBanner();
+  if (!isAuthenticated()) {
+    line(`  Run ${c.bold("hw login")} to get started.`);
+    line();
+    return Promise.resolve(0);
+  }
+  return startChat({});
+}
+function requireAuth() {
+  if (isAuthenticated()) return;
+  error("Not signed in.");
+  note("Run `hw login` first.");
+  process.exit(1);
+}
+function showBanner() {
+  const tag = [
+    `  ${c.bold("Hostwares")} ${c.dim(`v${VERSION2}`)}`,
+    `  ${c.dim("AI DevOps in your terminal")}`,
+    "",
+    isAuthenticated() ? `  ${c.green(glyph.tick)} ${c.dim("Signed in")}` : `  ${c.dim(`${glyph.arrow} Not signed in`)}`
+  ];
+  line();
+  BANNER_LINES.forEach((art, i) => line(`  ${c.green(art)}${tag[i] ?? ""}`));
+  line();
+  line(c.dim(`  Ask anything. ${c.bold("/help")} for commands, ${c.bold("!cmd")} for a shell command.`));
+  line();
+}
+function showHelp2() {
+  line();
+  line(`  ${c.bold("hw")} ${c.dim("\u2014 AI DevOps in your terminal")}`);
+  line();
+  const rows = [
+    ["hw", "Start an interactive session"],
+    ['hw ask "..."', "Ask one question and exit"],
+    ["hw chat --resume", "Continue this folder's last conversation"],
+    ["hw list", "List your deployments"],
+    ["hw sessions", "Sessions saved on this machine"],
+    ["hw login", "Sign in (--token <key> for CI)"],
+    ["hw logout", "Sign out on this machine"],
+    ["hw version", "Print the version"]
+  ];
+  for (const [name, help] of rows) line(`  ${c.green(name.padEnd(20))} ${c.dim(help)}`);
+  line();
+  line(c.dim("  Anything else is treated as a question: hw why is my deploy failing"));
+  line();
+}
+function showSessions2() {
+  const sessions = listSessions();
+  if (!sessions.length) {
+    line(c.dim("  No saved sessions yet."));
+    return 0;
+  }
+  line();
+  for (const s of sessions.slice(0, 25)) {
+    const here = s.cwd === process.cwd() ? c.green(`  ${glyph.tick} here`) : "";
+    line(`  ${s.cwd}${here}`);
+    line(c.dim(`    ${s.turnCount} turns \xB7 ${s.creditsSpent.toFixed(2)} credits`));
+  }
+  line();
+  return 0;
+}
+async function listSites() {
+  try {
+    const cfg = getConfig();
+    const r = await fetch(`${cfg.baseUrl}/api/sites`, { headers: { Authorization: `Bearer ${cfg.apiKey}` } });
+    if (!r.ok) {
+      error(r.status === 401 ? "Not signed in. Run `hw login`." : `Could not list deployments (HTTP ${r.status}).`);
+      return 1;
+    }
+    const res = await r.json();
+    const sites = Array.isArray(res) ? res : res?.sites ?? [];
+    if (!sites.length) {
+      line(c.dim("  No deployments yet. Ask me to deploy something to get started."));
+      return 0;
+    }
+    line();
+    for (const s of sites) {
+      const dot = s.status === "RUNNING" ? c.green("\u25CF") : s.status === "FAILED" ? c.red("\u25CF") : c.yellow("\u25CF");
+      line(`  ${dot} ${c.bold((s.name ?? "unnamed").padEnd(24))} ${c.dim(s.domain ?? s.status ?? "")}`);
+    }
+    line();
+    return 0;
+  } catch (e) {
     reportError(e);
-    process.exit(1);
+    return 1;
+  }
+}
+function readVersion() {
+  try {
+    const here = dirname4(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync8(join8(here, "..", "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+main(process.argv.slice(2)).then((code) => process.exit(code)).catch((e) => {
+  if (isAborted(e)) process.exit(130);
+  reportError(e);
+  process.exit(1);
 });