clixad 0.0.1-beta.0

package/dist/clixad.mjs

@@ -0,0 +1,3018 @@
+#!/usr/bin/env node
+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 });
+};
+
+// src/client.ts
+function adsPerTaskLabel(estAdsPerTask) {
+  const effort = estAdsPerTask >= 1 ? `~${estAdsPerTask} ads/task` : "<1 ad/task";
+  return `${effort} on completion`;
+}
+async function authFailure(res, what) {
+  const body = await res.text().catch(() => "");
+  const isJson = (res.headers.get("content-type") ?? "").includes("json");
+  if (isJson) {
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed.error === "string") return new AuthError();
+    } catch {
+    }
+  }
+  return new Error(
+    `${what}: the gateway returned 401 without a Clixad error body. The gateway URL may be pointing at something else \u2014 a login/SSO page, a proxy, or a stale deployment. Check it, or set CLIXAD_GATEWAY_URL.`
+  );
+}
+function accumulateToolCall(calls, part, fallbackIndex) {
+  const index = part.index ?? fallbackIndex;
+  const current = calls.get(index) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
+  if (part.id) current.id = part.id;
+  if (part.function?.name) current.function.name = part.function.name;
+  if (part.function?.arguments) current.function.arguments += part.function.arguments;
+  calls.set(index, current);
+}
+async function* parseSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf("\n\n")) !== -1) {
+      const frame = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      for (const line2 of frame.split("\n")) {
+        if (line2.startsWith("data:")) yield line2.slice(5).trim();
+      }
+    }
+  }
+}
+var PaywallError, AuthError, GatewayClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    PaywallError = class extends Error {
+      constructor(balance, estimatedCost, grantPerAd) {
+        super("Out of credits");
+        this.balance = balance;
+        this.estimatedCost = estimatedCost;
+        this.grantPerAd = grantPerAd;
+        this.name = "PaywallError";
+      }
+      balance;
+      estimatedCost;
+      grantPerAd;
+    };
+    AuthError = class extends Error {
+      constructor() {
+        super("Not logged in. Run `clixad login` first.");
+        this.name = "AuthError";
+      }
+    };
+    GatewayClient = class {
+      constructor(config) {
+        this.config = config;
+      }
+      config;
+      headers(auth = true) {
+        const h = { "Content-Type": "application/json" };
+        if (auth) {
+          if (!this.config.token) throw new AuthError();
+          h.Authorization = `Bearer ${this.config.token}`;
+        }
+        return h;
+      }
+      /** Dev-only signup shortcut (production replaces this with GitHub OAuth). */
+      async signupDev(email) {
+        const res = await fetch(`${this.config.gatewayUrl}/dev/users`, {
+          method: "POST",
+          headers: this.headers(false),
+          body: JSON.stringify(email ? { email } : {})
+        });
+        if (!res.ok) throw new Error(`signup failed: ${res.status} ${await res.text()}`);
+        return res.json();
+      }
+      /** Begin GitHub device-flow login. Returns null if the gateway has no GitHub
+       *  configured (501), so the caller can fall back to the dev shortcut. */
+      async deviceStart() {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/auth/device/start`, {
+          method: "POST",
+          headers: this.headers(false)
+        });
+        if (res.status === 501) return null;
+        if (!res.ok) throw new Error(`device start failed: ${res.status} ${await res.text()}`);
+        return res.json();
+      }
+      /** Poll once for device-flow completion. */
+      async devicePoll(session) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/auth/device/poll`, {
+          method: "POST",
+          headers: this.headers(false),
+          body: JSON.stringify({ session })
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok && !("status" in data && data.status)) {
+          return { status: "error", error: `http ${res.status}` };
+        }
+        return data;
+      }
+      /**
+       * Mint a single-use code the ad wall can trade for a session, so opening the
+       * dashboard doesn't ask the user to paste a token by hand. Returns undefined if
+       * the gateway can't issue one — the caller still opens the wall, just unsigned.
+       */
+      async handoffCode() {
+        try {
+          const res = await fetch(`${this.config.gatewayUrl}/v1/auth/handoff`, {
+            method: "POST",
+            headers: this.headers()
+          });
+          if (!res.ok) return void 0;
+          return (await res.json()).code;
+        } catch {
+          return void 0;
+        }
+      }
+      async creditPacks() {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/billing/packs`);
+        if (!res.ok) throw new Error(`packs failed: ${res.status}`);
+        return res.json();
+      }
+      async checkout(pack) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/billing/checkout`, {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({ pack })
+        });
+        if (res.status === 401) throw await authFailure(res, "checkout");
+        if (res.status === 501) throw new Error("Buying credits isn't enabled (Stripe not configured on the gateway).");
+        if (!res.ok) throw new Error(`checkout failed: ${res.status} ${await res.text()}`);
+        return res.json();
+      }
+      async models() {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/models`);
+        if (!res.ok) throw new Error(`models failed: ${res.status}`);
+        const data = await res.json();
+        return data.data;
+      }
+      async wallet() {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/wallet`, { headers: this.headers() });
+        if (res.status === 401) throw await authFailure(res, "wallet");
+        if (!res.ok) throw new Error(`wallet failed: ${res.status}`);
+        return res.json();
+      }
+      // There is deliberately no `earnAd` here any more. It posted to
+      // `/v1/ads/reward`, the gateway's CLIXAD_DEV-only reward simulator, which is
+      // 404 in any real deployment — so both `clixad earn` and the REPL's `/earn`
+      // were broken in production while working perfectly against a dev gateway.
+      // Earning now goes through the browser handoff (`handoffCode` above) to the ad
+      // wall, and the reward arrives as a signed postback from the network to the
+      // gateway. Nothing comes back to the CLI; a rising balance is the only signal,
+      // which is why both callers poll `wallet()`.
+      /** Non-streaming chat. Kept for scripted/one-shot paths; the REPL streams. */
+      async chat(messages, model, tools, signal) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({ model, messages, stream: false, ...tools ? { tools } : {} }),
+          signal
+        });
+        if (res.status === 401) throw await authFailure(res, "chat");
+        if (res.status === 402) {
+          const body = await res.json();
+          throw new PaywallError(body.balance, body.estimated_cost, body.grant_per_ad);
+        }
+        if (!res.ok) throw new Error(`chat failed: ${res.status} ${await res.text()}`);
+        const data = await res.json();
+        const choice = data.choices[0];
+        if (!choice) throw new Error("chat: no choices in response");
+        return {
+          message: choice.message,
+          finishReason: choice.finish_reason,
+          creditsCharged: data.clixad.credits_charged,
+          balance: data.clixad.balance
+        };
+      }
+      /**
+       * Streaming chat. Calls `opts.onDelta` for each content chunk and assembles
+       * the whole assistant turn — including `tool_calls`, which the gateway streams
+       * with a per-call `index` (OpenAI style, see server.ts `streamCompletion`), so
+       * the agent loop can stream *and* use tools in the same request.
+       */
+      async chatStream(messages, model, opts = {}) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: this.headers(),
+          body: JSON.stringify({ model, messages, stream: true, ...opts.tools ? { tools: opts.tools } : {} }),
+          signal: opts.signal
+        });
+        if (res.status === 401) throw await authFailure(res, "chat");
+        if (res.status === 402) {
+          const body = await res.json();
+          throw new PaywallError(body.balance, body.estimated_cost, body.grant_per_ad);
+        }
+        if (!res.ok || !res.body) throw new Error(`chat failed: ${res.status} ${await res.text()}`);
+        let content = "";
+        let finishReason = "stop";
+        let creditsCharged = 0;
+        let balance = 0;
+        let streamError;
+        const calls = /* @__PURE__ */ new Map();
+        for await (const evt of parseSSE(res.body)) {
+          if (evt === "[DONE]") break;
+          const json = JSON.parse(evt);
+          const choice = json.choices?.[0];
+          const delta = choice?.delta?.content;
+          if (delta) {
+            content += delta;
+            opts.onDelta?.(delta);
+          }
+          for (const [index, part] of (choice?.delta?.tool_calls ?? []).entries()) {
+            accumulateToolCall(calls, part, index);
+          }
+          if (choice?.finish_reason) finishReason = choice.finish_reason;
+          if (json.error) streamError = json.error.message || "the model stream failed";
+          if (json.clixad) {
+            creditsCharged = json.clixad.credits_charged;
+            balance = json.clixad.balance;
+          }
+        }
+        if (streamError) throw new Error(streamError);
+        const message = { role: "assistant", content: content || null };
+        if (calls.size > 0) {
+          message.tool_calls = [...calls.entries()].sort(([a], [b]) => a - b).map(([, c2]) => c2);
+        }
+        return { message, finishReason, creditsCharged, balance };
+      }
+    };
+  }
+});
+
+// src/config.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function loadConfig() {
+  let stored = {};
+  try {
+    stored = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+  }
+  for (const [key, stale] of Object.entries(SUPERSEDED_DEFAULTS)) {
+    const value = stored[key];
+    if (typeof value === "string" && stale.includes(value) && value !== DEFAULTS[key]) {
+      delete stored[key];
+    }
+  }
+  const config = { ...DEFAULTS, ...stored };
+  for (const [key, envVar] of ENV_OVERRIDES) {
+    const value = process.env[envVar];
+    if (value) config[key] = value;
+  }
+  return config;
+}
+function saveConfig(config) {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+function configPath() {
+  return CONFIG_PATH;
+}
+var CONFIG_PATH, DEFAULTS, ENV_OVERRIDES, SUPERSEDED_DEFAULTS;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    CONFIG_PATH = join(homedir(), ".clixad", "config.json");
+    DEFAULTS = {
+      gatewayUrl: "https://clixad.onrender.com",
+      // Same origin as the gateway: the ad wall is served by the gateway process
+      // itself now (apps/gateway/src/dashboard.ts), not by a second service. The two
+      // fields stay separate so either can be pointed elsewhere, but they no longer
+      // diverge by default.
+      dashboardUrl: "https://clixad.onrender.com",
+      model: "gemini-2.5-flash-lite"
+    };
+    ENV_OVERRIDES = [
+      ["gatewayUrl", "CLIXAD_GATEWAY_URL"],
+      ["dashboardUrl", "CLIXAD_DASHBOARD_URL"]
+    ];
+    SUPERSEDED_DEFAULTS = {
+      gatewayUrl: ["http://127.0.0.1:8787", "http://localhost:8787"],
+      dashboardUrl: ["http://127.0.0.1:8788", "http://localhost:8788"]
+    };
+  }
+});
+
+// src/diff.ts
+function splitLines(text) {
+  const lines = text.split("\n");
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function diffLines(a, b) {
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) {
+    tail++;
+  }
+  const midA = a.slice(head, a.length - tail);
+  const midB = b.slice(head, b.length - tail);
+  const out = [];
+  for (let i = 0; i < head; i++) out.push({ kind: "ctx", text: a[i], line: i + 1 });
+  if (midA.length * midB.length > LCS_LIMIT * LCS_LIMIT || midA.length * midB.length > 4e6) {
+    midA.forEach((text, i) => out.push({ kind: "del", text, line: head + i + 1 }));
+    midB.forEach((text, i) => out.push({ kind: "add", text, line: head + i + 1 }));
+  } else {
+    out.push(...lcsDiff(midA, midB, head));
+  }
+  for (let i = 0; i < tail; i++) {
+    const idx = b.length - tail + i;
+    out.push({ kind: "ctx", text: b[idx], line: idx + 1 });
+  }
+  return out;
+}
+function lcsDiff(a, b, offset2) {
+  const n = a.length;
+  const m = b.length;
+  const width = m + 1;
+  const dp = new Uint32Array((n + 1) * width);
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2 * width + j2] = a[i2] === b[j2] ? dp[(i2 + 1) * width + j2 + 1] + 1 : Math.max(dp[(i2 + 1) * width + j2], dp[i2 * width + j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      out.push({ kind: "ctx", text: b[j], line: offset2 + j + 1 });
+      i++;
+      j++;
+    } else if (dp[(i + 1) * width + j] >= dp[i * width + j + 1]) {
+      out.push({ kind: "del", text: a[i], line: offset2 + i + 1 });
+      i++;
+    } else {
+      out.push({ kind: "add", text: b[j], line: offset2 + j + 1 });
+      j++;
+    }
+  }
+  while (i < n) out.push({ kind: "del", text: a[i], line: offset2 + i++ + 1 });
+  while (j < m) out.push({ kind: "add", text: b[j], line: offset2 + j++ + 1 });
+  return out;
+}
+function diffStat(lines) {
+  let added = 0;
+  let removed = 0;
+  for (const l of lines) {
+    if (l.kind === "add") added++;
+    else if (l.kind === "del") removed++;
+  }
+  return { added, removed };
+}
+function renderDiff(oldText, newText, opts = {}) {
+  const context = opts.context ?? 3;
+  const maxLines = opts.maxLines ?? 40;
+  const maxWidth = opts.maxWidth ?? 200;
+  const lines = diffLines(splitLines(oldText), splitLines(newText));
+  const { added, removed } = diffStat(lines);
+  if (added === 0 && removed === 0) return "";
+  const keep = new Array(lines.length).fill(false);
+  lines.forEach((l, i) => {
+    if (l.kind === "ctx") return;
+    for (let k = Math.max(0, i - context); k <= Math.min(lines.length - 1, i + context); k++) {
+      keep[k] = true;
+    }
+  });
+  const out = [];
+  let skipped = 0;
+  let truncated = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (!keep[i]) {
+      skipped++;
+      continue;
+    }
+    if (skipped > 0) {
+      out.push(`${DIM}   \u22EF ${skipped} unchanged line${skipped === 1 ? "" : "s"}${R}`);
+      skipped = 0;
+    }
+    if (out.length >= maxLines) {
+      truncated++;
+      continue;
+    }
+    const l = lines[i];
+    const text = l.text.length > maxWidth ? l.text.slice(0, maxWidth - 1) + "\u2026" : l.text;
+    const no = String(l.line).padStart(4);
+    if (l.kind === "add") out.push(`${GREEN}${no} + ${text}${R}`);
+    else if (l.kind === "del") out.push(`${RED}${no} - ${text}${R}`);
+    else out.push(`${DIM}${no}   ${text}${R}`);
+  }
+  if (truncated > 0) out.push(`${DIM}   \u22EF ${truncated} more changed line${truncated === 1 ? "" : "s"}${R}`);
+  const stat = `${GREEN}+${added}${R} ${RED}-${removed}${R}`;
+  return `${stat}
+${out.join("\n")}`;
+}
+var R, GREEN, RED, DIM, LCS_LIMIT;
+var init_diff = __esm({
+  "src/diff.ts"() {
+    "use strict";
+    R = "\x1B[0m";
+    GREEN = "\x1B[32m";
+    RED = "\x1B[31m";
+    DIM = "\x1B[2m";
+    LCS_LIMIT = 3e3;
+  }
+});
+
+// src/tools.ts
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { isAbsolute, relative, resolve, dirname as dirname2, join as join2, sep } from "node:path";
+function safeResolve(root, p) {
+  const abs = isAbsolute(p) ? p : resolve(root, p);
+  const rel2 = relative(root, abs);
+  if (rel2 === ".." || rel2.startsWith(".." + sep) || isAbsolute(rel2)) {
+    throw new ToolError(`path escapes workspace: ${p}`);
+  }
+  return abs;
+}
+function rel(root, abs) {
+  return relative(root, abs).replace(/\\/g, "/") || ".";
+}
+async function gate(ctx, req) {
+  if (!ctx.permit) return;
+  const res = await ctx.permit(req);
+  if (!res.allowed) throw new ToolError(res.reason);
+}
+function commandSignature(command) {
+  return `run:${command.replace(/\s+/g, " ").trim()}`;
+}
+function occurrences(haystack, needle) {
+  if (!needle) return 0;
+  let n = 0;
+  let i = haystack.indexOf(needle);
+  while (i !== -1) {
+    n++;
+    i = haystack.indexOf(needle, i + needle.length);
+  }
+  return n;
+}
+function killTree(child) {
+  if (child.pid === void 0) {
+    child.kill("SIGKILL");
+    return;
+  }
+  if (process.platform === "win32") {
+    spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+  } else {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+  }
+}
+function execute(ctx, command, timeout) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, {
+      cwd: ctx.root,
+      shell: true,
+      windowsHide: true,
+      // Own process group on POSIX so killTree can take the children with it.
+      detached: process.platform !== "win32"
+    });
+    let out = "";
+    let total = 0;
+    let timedOut = false;
+    const collect = (buf) => {
+      const chunk = buf.toString("utf8");
+      ctx.onOutput?.(chunk);
+      total += chunk.length;
+      if (out.length < MAX_OUTPUT_CHARS) out += chunk;
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    const onAbort = () => killTree(child);
+    ctx.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree(child);
+    }, timeout);
+    let settled = false;
+    const finish = (summary) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      ctx.signal?.removeEventListener("abort", onAbort);
+      const body = out.slice(0, MAX_OUTPUT_CHARS).trimEnd();
+      const note = total > MAX_OUTPUT_CHARS ? `
+\u2026 [output capped: showing ${MAX_OUTPUT_CHARS} of ${total} chars]` : "";
+      resolvePromise(`${summary}
+${body || "(no output)"}${note}`);
+    };
+    child.on("error", (err) => finish(`command failed to start: ${err.message}`));
+    child.on("close", (code) => {
+      if (ctx.signal?.aborted) return finish("command cancelled by the user");
+      if (timedOut) return finish(`command killed after ${timeout} ms`);
+      finish(`exit ${code ?? 0}`);
+    });
+  });
+}
+function listWorkspaceFiles(root, limit = 5e3) {
+  const files = [];
+  walk(root, root, (abs) => {
+    files.push(rel(root, abs));
+    return files.length < limit;
+  });
+  return files.sort();
+}
+function walk(dir, root, visit) {
+  let seen = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        stack.push(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (++seen > MAX_WALK_FILES) return;
+      if (!visit(abs)) return;
+    }
+  }
+  void root;
+}
+function globToRegExp(pattern) {
+  const p = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+  let re = "";
+  for (let i = 0; i < p.length; i++) {
+    const ch = p[i];
+    if (ch === "*") {
+      if (p[i + 1] === "*") {
+        if (p[i + 2] === "/") {
+          re += "(?:.*/)?";
+          i += 2;
+        } else {
+          re += ".*";
+          i += 1;
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (ch === "?") re += "[^/]";
+    else if (ch === "{") re += "(?:";
+    else if (ch === "}") re += ")";
+    else if (ch === ",") re += "|";
+    else if (".+^$()[]|\\".includes(ch)) re += "\\" + ch;
+    else re += ch;
+  }
+  const anchored = p.includes("/") ? `^${re}$` : `^(?:.*/)?${re}$`;
+  return new RegExp(anchored);
+}
+var ToolError, MAX_FILE_BYTES, MAX_OUTPUT_CHARS, MAX_GLOB_RESULTS, MAX_GREP_MATCHES, MAX_WALK_FILES, DEFAULT_COMMAND_TIMEOUT, SKIP_DIRS, TOOLS, TOOL_SCHEMA;
+var init_tools = __esm({
+  "src/tools.ts"() {
+    "use strict";
+    init_diff();
+    ToolError = class extends Error {
+    };
+    MAX_FILE_BYTES = 4e5;
+    MAX_OUTPUT_CHARS = 3e4;
+    MAX_GLOB_RESULTS = 200;
+    MAX_GREP_MATCHES = 100;
+    MAX_WALK_FILES = 2e4;
+    DEFAULT_COMMAND_TIMEOUT = 12e4;
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      ".git",
+      "node_modules",
+      "dist",
+      "build",
+      "coverage",
+      ".next",
+      ".turbo",
+      ".cache",
+      "__pycache__",
+      ".venv"
+    ]);
+    TOOLS = {
+      read_file(ctx, args) {
+        const abs = safeResolve(ctx.root, args.path);
+        if (!existsSync(abs)) throw new ToolError(`not found: ${args.path}`);
+        if (statSync(abs).isDirectory()) throw new ToolError(`${args.path} is a directory \u2014 use list_dir`);
+        const content = readFileSync2(abs, "utf8");
+        if (content.length > MAX_FILE_BYTES) {
+          return content.slice(0, MAX_FILE_BYTES) + `
+\u2026 [truncated at ${MAX_FILE_BYTES} chars]`;
+        }
+        return content;
+      },
+      list_dir(ctx, args) {
+        const abs = safeResolve(ctx.root, args.path ?? ".");
+        if (!existsSync(abs)) throw new ToolError(`not found: ${args.path ?? "."}`);
+        const entries = readdirSync(abs).map((name) => {
+          const isDir = statSync(resolve(abs, name)).isDirectory();
+          return { name: isDir ? `${name}/` : name, isDir };
+        });
+        entries.sort((a, b) => Number(b.isDir) - Number(a.isDir) || a.name.localeCompare(b.name));
+        return entries.map((e) => e.name).join("\n") || "(empty)";
+      },
+      /** Find files by glob, e.g. `src/**\/*.ts`. Cheap orientation before reading. */
+      glob(ctx, args) {
+        if (!args.pattern) throw new ToolError("glob needs a pattern");
+        const base = safeResolve(ctx.root, args.path ?? ".");
+        const re = globToRegExp(args.pattern);
+        const hits = [];
+        walk(base, ctx.root, (abs) => {
+          const r = rel(ctx.root, abs);
+          if (re.test(r)) hits.push(r);
+          return hits.length < MAX_GLOB_RESULTS;
+        });
+        if (hits.length === 0) return `no files match ${args.pattern}`;
+        hits.sort();
+        const more = hits.length >= MAX_GLOB_RESULTS ? `
+\u2026 [capped at ${MAX_GLOB_RESULTS}]` : "";
+        return hits.join("\n") + more;
+      },
+      /** Search file contents with a regular expression; returns path:line: text. */
+      grep(ctx, args) {
+        if (!args.pattern) throw new ToolError("grep needs a pattern");
+        let re;
+        try {
+          re = new RegExp(args.pattern);
+        } catch (err) {
+          throw new ToolError(`invalid regular expression: ${err.message}`);
+        }
+        const base = safeResolve(ctx.root, args.path ?? ".");
+        const filter = args.glob ? globToRegExp(args.glob) : void 0;
+        const out = [];
+        walk(base, ctx.root, (abs) => {
+          const r = rel(ctx.root, abs);
+          if (filter && !filter.test(r)) return true;
+          let content;
+          try {
+            content = readFileSync2(abs, "utf8");
+          } catch {
+            return true;
+          }
+          if (content.includes("\0")) return true;
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            const line2 = lines[i];
+            if (!re.test(line2)) continue;
+            out.push(`${r}:${i + 1}: ${line2.trim().slice(0, 200)}`);
+            if (out.length >= MAX_GREP_MATCHES) return false;
+          }
+          return true;
+        });
+        if (out.length === 0) return `no matches for ${args.pattern}`;
+        const more = out.length >= MAX_GREP_MATCHES ? `
+\u2026 [capped at ${MAX_GREP_MATCHES} matches]` : "";
+        return out.join("\n") + more;
+      },
+      async write_file(ctx, args) {
+        const abs = safeResolve(ctx.root, args.path);
+        const before = existsSync(abs) ? readFileSync2(abs, "utf8") : "";
+        const preview = renderDiff(before, args.content) || "(no change)";
+        await gate(ctx, {
+          tool: "write_file",
+          signature: `write:${rel(ctx.root, abs)}`,
+          summary: `${before ? "overwrite" : "create"} ${rel(ctx.root, abs)}`,
+          preview
+        });
+        mkdirSync2(dirname2(abs), { recursive: true });
+        writeFileSync2(abs, args.content, "utf8");
+        return `wrote ${args.content.length} bytes to ${rel(ctx.root, abs)}`;
+      },
+      /**
+       * Replace an exact snippet in a file. Preferred over write_file: it keeps the
+       * rest of the file untouched and costs a fraction of the tokens (= credits).
+       * An ambiguous match is an error rather than a guess.
+       */
+      async edit_file(ctx, args) {
+        const abs = safeResolve(ctx.root, args.path);
+        if (!existsSync(abs)) throw new ToolError(`not found: ${args.path}`);
+        if (typeof args.old_string !== "string" || typeof args.new_string !== "string") {
+          throw new ToolError("edit_file needs old_string and new_string");
+        }
+        if (args.old_string === args.new_string) throw new ToolError("old_string and new_string are identical");
+        const before = readFileSync2(abs, "utf8");
+        const count = occurrences(before, args.old_string);
+        if (count === 0) throw new ToolError(`old_string not found in ${args.path} \u2014 read the file and copy the exact text`);
+        if (count > 1 && !args.replace_all) {
+          throw new ToolError(
+            `old_string appears ${count} times in ${args.path} \u2014 add more surrounding context, or pass replace_all: true`
+          );
+        }
+        const after = before.split(args.old_string).join(args.new_string);
+        const preview = renderDiff(before, after) || "(no change)";
+        await gate(ctx, {
+          tool: "edit_file",
+          signature: `write:${rel(ctx.root, abs)}`,
+          summary: `edit ${rel(ctx.root, abs)}`,
+          preview
+        });
+        writeFileSync2(abs, after, "utf8");
+        return `edited ${rel(ctx.root, abs)} (${count > 1 ? `${count} occurrences` : "1 occurrence"})`;
+      },
+      /**
+       * Run a shell command in the workspace. Streams output to `ctx.onOutput` as it
+       * arrives and dies with `ctx.signal`, so a runaway build can be interrupted.
+       */
+      async run_command(ctx, args) {
+        const command = (args.command ?? "").trim();
+        if (!command) throw new ToolError("run_command needs a command");
+        await gate(ctx, {
+          tool: "run_command",
+          signature: commandSignature(command),
+          summary: `run ${command.length > 60 ? command.slice(0, 59) + "\u2026" : command}`,
+          preview: command
+        });
+        return execute(ctx, command, args.timeout ?? DEFAULT_COMMAND_TIMEOUT);
+      }
+    };
+    TOOL_SCHEMA = [
+      {
+        type: "function",
+        function: {
+          name: "read_file",
+          description: "Read a UTF-8 text file from the workspace.",
+          parameters: {
+            type: "object",
+            properties: { path: { type: "string" } },
+            required: ["path"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "list_dir",
+          description: "List files and directories at a workspace path.",
+          parameters: { type: "object", properties: { path: { type: "string" } } }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "glob",
+          description: "Find files by glob pattern (e.g. 'src/**/*.ts', '*.json'). Use this to locate files instead of shell commands.",
+          parameters: {
+            type: "object",
+            properties: {
+              pattern: { type: "string" },
+              path: { type: "string", description: "Directory to search in; defaults to the workspace root." }
+            },
+            required: ["pattern"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "grep",
+          description: "Search file contents with a regular expression. Returns 'path:line: text'. Use this to find code instead of shell commands.",
+          parameters: {
+            type: "object",
+            properties: {
+              pattern: { type: "string" },
+              path: { type: "string", description: "Directory to search in; defaults to the workspace root." },
+              glob: { type: "string", description: "Only search files matching this glob." }
+            },
+            required: ["pattern"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "edit_file",
+          description: "Replace an exact snippet in an existing file. Prefer this over write_file for changes to existing files. old_string must match exactly once unless replace_all is true.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string" },
+              old_string: { type: "string" },
+              new_string: { type: "string" },
+              replace_all: { type: "boolean" }
+            },
+            required: ["path", "old_string", "new_string"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "write_file",
+          description: "Create a new file, or overwrite one completely. Use edit_file for partial changes.",
+          parameters: {
+            type: "object",
+            properties: { path: { type: "string" }, content: { type: "string" } },
+            required: ["path", "content"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "run_command",
+          description: "Run a shell command in the workspace (build, test, git, etc.).",
+          parameters: {
+            type: "object",
+            properties: {
+              command: { type: "string" },
+              timeout: { type: "number", description: "Milliseconds before the command is killed." }
+            },
+            required: ["command"]
+          }
+        }
+      }
+    ];
+  }
+});
+
+// src/agent.ts
+async function runAgent(client, task, opts) {
+  const maxSteps = opts.maxSteps ?? 16;
+  const emit = (e) => opts.onEvent?.(e);
+  const ctx = {
+    root: opts.root,
+    permit: opts.permit,
+    signal: opts.signal
+  };
+  const messages = [
+    { role: "system", content: opts.systemPrompt ?? SYSTEM_PROMPT },
+    ...opts.history ?? [],
+    { role: "user", content: task }
+  ];
+  let creditsCharged = 0;
+  let balance = 0;
+  let lastText = "";
+  for (let step = 0; step < maxSteps; step++) {
+    if (opts.signal?.aborted) return stop("aborted");
+    let turn;
+    try {
+      turn = await client.chatStream(messages, opts.model, {
+        tools: TOOL_SCHEMA,
+        signal: opts.signal,
+        onDelta: (text) => emit({ type: "delta", text })
+      });
+    } catch (err) {
+      if (isAbort(err) || opts.signal?.aborted) return stop("aborted");
+      throw err;
+    }
+    creditsCharged += turn.creditsCharged;
+    balance = turn.balance;
+    emit({ type: "usage", creditsCharged: turn.creditsCharged, balance: turn.balance });
+    messages.push(turn.message);
+    const content = turn.message.content ?? "";
+    if (content) lastText = content;
+    const calls = turn.message.tool_calls ?? [];
+    if (calls.length === 0) {
+      emit({ type: "final", content, creditsCharged, balance });
+      return { content, messages, creditsCharged, balance, steps: step + 1 };
+    }
+    if (content) emit({ type: "message", content });
+    for (const [i, call] of calls.entries()) {
+      if (opts.signal?.aborted) {
+        for (const rest of calls.slice(i)) messages.push(toolMessage(rest, "cancelled by the user"));
+        return stop("aborted");
+      }
+      const result = await executeToolCall(ctx, call, emit);
+      messages.push(toolMessage(call, result));
+    }
+  }
+  emit({ type: "max_steps" });
+  return {
+    content: lastText || "(stopped: reached max steps)",
+    messages,
+    creditsCharged,
+    balance,
+    steps: maxSteps,
+    stopped: "max_steps"
+  };
+  function stop(reason) {
+    emit({ type: reason });
+    return { content: lastText, messages, creditsCharged, balance, steps: 0, stopped: reason };
+  }
+}
+function toolMessage(call, content) {
+  return { role: "tool", tool_call_id: call.id, name: call.function.name, content };
+}
+function isAbort(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+async function executeToolCall(ctx, call, emit) {
+  const name = call.function.name;
+  const id = call.id;
+  let args;
+  try {
+    args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+  } catch {
+    return `error: invalid JSON arguments for ${name}`;
+  }
+  emit({ type: "tool_call", id, name, args });
+  const scoped = { ...ctx, onOutput: (chunk) => emit({ type: "tool_output", id, chunk }) };
+  try {
+    const result = await dispatch(scoped, name, args);
+    emit({ type: "tool_result", id, name, result, ok: true });
+    return result;
+  } catch (err) {
+    if (err instanceof ToolError) {
+      const msg = `error: ${err.message}`;
+      emit({ type: "tool_result", id, name, result: msg, ok: false });
+      return msg;
+    }
+    throw err;
+  }
+}
+async function dispatch(ctx, name, args) {
+  switch (name) {
+    case "read_file":
+      return TOOLS.read_file(ctx, args);
+    case "list_dir":
+      return TOOLS.list_dir(ctx, args);
+    case "glob":
+      return TOOLS.glob(ctx, args);
+    case "grep":
+      return TOOLS.grep(ctx, args);
+    case "edit_file":
+      return TOOLS.edit_file(ctx, args);
+    case "write_file":
+      return TOOLS.write_file(ctx, args);
+    case "run_command":
+      return TOOLS.run_command(ctx, args);
+    default:
+      return `error: unknown tool ${name}`;
+  }
+}
+var SYSTEM_PROMPT;
+var init_agent = __esm({
+  "src/agent.ts"() {
+    "use strict";
+    init_tools();
+    SYSTEM_PROMPT = "You are Clixad, a terminal coding agent. You can read, search, write and edit files and run shell commands, all confined to the user's workspace. Find your way around with glob and grep before reading whole files. Prefer edit_file over write_file for existing files. Make minimal correct edits, verify them when a test or build command is available, and stop when the task is complete. Keep your final message short: say what you changed and why.";
+  }
+});
+
+// src/context.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2, platform } from "node:os";
+import { join as join3 } from "node:path";
+function contextFileCandidates(root) {
+  return [join3(homedir2(), ".clixad", "CLIXAD.md"), join3(root, "AGENTS.md"), join3(root, "CLIXAD.md")];
+}
+function collectContext(root, base = SYSTEM_PROMPT) {
+  const parts = [base, environmentBlock(root)];
+  const files = [];
+  for (const path of contextFileCandidates(root)) {
+    if (!existsSync2(path)) continue;
+    let text;
+    try {
+      text = readFileSync3(path, "utf8").trim();
+    } catch {
+      continue;
+    }
+    if (!text) continue;
+    files.push(path);
+    parts.push(
+      `# Project instructions (${path.replace(homedir2(), "~")})
+These come from the user and take precedence over your defaults.
+
+` + text.slice(0, MAX_CONTEXT_FILE_CHARS)
+    );
+  }
+  return { systemPrompt: parts.join("\n\n"), files };
+}
+function environmentBlock(root) {
+  const lines = [
+    "# Environment",
+    `working directory: ${root}`,
+    `platform: ${platform()}`,
+    `shell: ${platform() === "win32" ? "cmd/powershell (Windows)" : "sh"}`
+  ];
+  const branch = gitBranch(root);
+  if (branch) lines.push(`git branch: ${branch}`);
+  const top = topLevel(root);
+  if (top) lines.push(`top level: ${top}`);
+  return lines.join("\n");
+}
+function gitBranch(root) {
+  try {
+    const res = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 2e3,
+      windowsHide: true
+    });
+    if (res.status !== 0) return void 0;
+    return res.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function topLevel(root) {
+  try {
+    const entries = readdirSync2(root, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").slice(0, 40).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+    return entries.length ? entries.join(" ") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var MAX_CONTEXT_FILE_CHARS, INIT_PROMPT;
+var init_context = __esm({
+  "src/context.ts"() {
+    "use strict";
+    init_agent();
+    MAX_CONTEXT_FILE_CHARS = 2e4;
+    INIT_PROMPT = "Create a CLIXAD.md file in the workspace root that tells a future coding agent how to work in this project. Explore the repository first (glob, grep, read the README and package manifests). Keep it under 60 lines and cover: what the project is, the layout, how to build/test/run it, and the conventions a newcomer would otherwise get wrong. If CLIXAD.md already exists, improve it instead of replacing it wholesale.";
+  }
+});
+
+// src/permissions.ts
+function isEdit(tool) {
+  return tool === "write_file" || tool === "edit_file";
+}
+function createState(mode = "normal") {
+  return { mode, allowed: /* @__PURE__ */ new Set() };
+}
+function nextMode(mode) {
+  const i = MODES.indexOf(mode);
+  return MODES[(i + 1) % MODES.length];
+}
+function decide(state, req) {
+  if (state.mode === "plan") {
+    return {
+      kind: "deny",
+      reason: `plan mode is on, so ${req.summary} was not executed. Do not attempt further writes or commands \u2014 describe the plan instead and let the user approve it.`
+    };
+  }
+  if (state.allowed.has(req.signature)) return { kind: "allow" };
+  if (state.mode === "acceptEdits" && isEdit(req.tool)) return { kind: "allow" };
+  return { kind: "ask" };
+}
+function createPermit(getState, ask2) {
+  return async (req) => {
+    const state = getState();
+    const verdict = decide(state, req);
+    if (verdict.kind === "allow") return { allowed: true };
+    if (verdict.kind === "deny") return { allowed: false, reason: verdict.reason };
+    const answer = await ask2(req);
+    if (answer === "always") {
+      state.allowed.add(req.signature);
+      return { allowed: true };
+    }
+    if (answer === "once") return { allowed: true };
+    return { allowed: false, reason: `the user denied ${req.summary}` };
+  };
+}
+var MODES, MODE_LABEL, denyAll;
+var init_permissions = __esm({
+  "src/permissions.ts"() {
+    "use strict";
+    MODES = ["normal", "acceptEdits", "plan"];
+    MODE_LABEL = {
+      plan: "plan mode (read-only)",
+      normal: "ask before edits",
+      acceptEdits: "auto-accept edits"
+    };
+    denyAll = async (req) => ({
+      allowed: false,
+      reason: `${req.summary} needs approval, but this run is non-interactive (use the REPL to approve it)`
+    });
+  }
+});
+
+// src/session.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, rmSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+function newSessionId() {
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "");
+  return `${now}-${Math.random().toString(16).slice(2, 6)}`;
+}
+function saveSession(session) {
+  try {
+    mkdirSync3(SESSION_DIR, { recursive: true });
+    writeFileSync3(join4(SESSION_DIR, `${session.id}.json`), JSON.stringify(session), "utf8");
+    prune();
+  } catch {
+  }
+}
+function loadSession(id) {
+  try {
+    return JSON.parse(readFileSync4(join4(SESSION_DIR, `${id}.json`), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function listSessions(cwd, limit = 20) {
+  if (!existsSync3(SESSION_DIR)) return [];
+  const metas = [];
+  for (const name of readdirSync3(SESSION_DIR)) {
+    if (!name.endsWith(".json")) continue;
+    const s = loadSession(name.slice(0, -5));
+    if (!s) continue;
+    if (cwd && s.cwd !== cwd) continue;
+    const { messages: _messages, ...meta } = s;
+    metas.push(meta);
+  }
+  metas.sort((a, b) => b.updated.localeCompare(a.updated));
+  return metas.slice(0, limit);
+}
+function latestSession(cwd) {
+  const [meta] = listSessions(cwd, 1);
+  return meta ? loadSession(meta.id) : void 0;
+}
+function prune() {
+  const files = readdirSync3(SESSION_DIR).filter((n) => n.endsWith(".json")).map((n) => ({ n, t: statSync2(join4(SESSION_DIR, n)).mtimeMs })).sort((a, b) => b.t - a.t);
+  for (const { n } of files.slice(MAX_SESSIONS)) {
+    try {
+      rmSync(join4(SESSION_DIR, n));
+    } catch {
+    }
+  }
+}
+function loadHistory() {
+  try {
+    return readFileSync4(HISTORY_FILE, "utf8").split("\n").filter(Boolean).slice(-MAX_HISTORY).reverse();
+  } catch {
+    return [];
+  }
+}
+function saveHistory(entries) {
+  try {
+    mkdirSync3(ROOT, { recursive: true });
+    writeFileSync3(HISTORY_FILE, entries.slice(0, MAX_HISTORY).reverse().join("\n") + "\n", "utf8");
+  } catch {
+  }
+}
+var ROOT, SESSION_DIR, HISTORY_FILE, MAX_HISTORY, MAX_SESSIONS;
+var init_session = __esm({
+  "src/session.ts"() {
+    "use strict";
+    ROOT = join4(homedir3(), ".clixad");
+    SESSION_DIR = join4(ROOT, "sessions");
+    HISTORY_FILE = join4(ROOT, "history");
+    MAX_HISTORY = 200;
+    MAX_SESSIONS = 50;
+  }
+});
+
+// src/kimi.ts
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+function contextTokensFor(modelId) {
+  return CONTEXT_TOKENS[modelId] ?? DEFAULT_CONTEXT_TOKENS;
+}
+function toml(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildKimiConfig({ gatewayUrl, token, modelId }) {
+  const baseUrl = `${gatewayUrl.replace(/\/+$/, "")}/v1`;
+  const context = contextTokensFor(modelId);
+  return [
+    "# Clixad Code \u2014 auto-generated. Points Kimi CLI at the Clixad gateway",
+    "# (OpenAI-compatible). Regenerated on every `clixad code` run.",
+    `default_model = ${toml(modelId)}`,
+    "default_yolo = false",
+    "telemetry = false",
+    "",
+    "[providers.clixad]",
+    'type = "openai_legacy"',
+    `base_url = ${toml(baseUrl)}`,
+    `api_key = ${toml(token)}`,
+    "",
+    `[models.${toml(modelId)}]`,
+    'provider = "clixad"',
+    `model = ${toml(modelId)}`,
+    `max_context_size = ${context}`,
+    ""
+  ].join("\n");
+}
+function kimiConfigPath() {
+  return join5(homedir4(), ".clixad", "kimi.config.toml");
+}
+function runKimiCode(config, task, opts = {}) {
+  if (!config.token) {
+    console.log("Not logged in. Run `clixad login` first.");
+    return Promise.resolve(1);
+  }
+  const path = kimiConfigPath();
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, buildKimiConfig({ gatewayUrl: config.gatewayUrl, token: config.token, modelId: config.model }), "utf8");
+  const bin = process.env.CLIXAD_KIMI_BIN || "kimi";
+  if (!binExists(bin)) {
+    console.log("\n" + INSTALL_HELP);
+    return Promise.resolve(127);
+  }
+  const args = ["--config-file", path];
+  if (task) args.push("-p", task);
+  if (opts.passthrough?.length) args.push(...opts.passthrough);
+  const env = {
+    ...process.env,
+    OPENAI_BASE_URL: `${config.gatewayUrl.replace(/\/+$/, "")}/v1`,
+    OPENAI_API_KEY: config.token
+  };
+  return new Promise((resolve2) => {
+    const child = process.platform === "win32" ? spawn2([bin, ...args].map(quoteWin).join(" "), { stdio: "inherit", env, shell: true }) : spawn2(bin, args, { stdio: "inherit", env });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") console.log("\n" + INSTALL_HELP);
+      else console.error(`failed to launch Kimi CLI: ${err.message}`);
+      resolve2(127);
+    });
+    child.on("exit", (code) => resolve2(code ?? 0));
+  });
+}
+function quoteWin(s) {
+  return /[\s"]/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
+}
+function binExists(bin) {
+  if (bin.includes("/") || bin.includes("\\")) {
+    return existsSync4(bin) || existsSync4(`${bin}.exe`) || existsSync4(`${bin}.cmd`);
+  }
+  const probe = process.platform === "win32" ? spawnSync2("where", [bin], { stdio: "ignore" }) : spawnSync2("sh", ["-c", `command -v "${bin}"`], { stdio: "ignore" });
+  return probe.status === 0;
+}
+var CONTEXT_TOKENS, DEFAULT_CONTEXT_TOKENS, INSTALL_HELP;
+var init_kimi = __esm({
+  "src/kimi.ts"() {
+    "use strict";
+    CONTEXT_TOKENS = {
+      "gpt-5-nano": 4e5,
+      "gemini-2.5-flash-lite": 1e6,
+      "deepseek-v4-flash": 1048576,
+      "gemini-3.1-flash-lite": 1048576,
+      "kimi-k2": 131072,
+      "kimi-k2.7-code": 262144,
+      "claude-haiku-4.5": 2e5,
+      "gemini-3.6-flash": 1048576,
+      "claude-sonnet-5": 1e6,
+      "gpt-5.2": 4e5,
+      "kimi-k3": 1048576,
+      "claude-opus-5": 1e6,
+      "gpt-5.5": 105e4,
+      "gpt-5.2-pro": 4e5
+    };
+    DEFAULT_CONTEXT_TOKENS = 256e3;
+    INSTALL_HELP = `Kimi CLI is not installed (or not on PATH).
+
+Clixad Code runs the open-source Kimi CLI (MoonshotAI, Apache-2.0) against your
+Clixad gateway. Install it once, then re-run \`clixad code\`:
+
+  uv tool install kimi-cli        # recommended (https://docs.astral.sh/uv/)
+  # or:
+  pipx install kimi-cli
+
+If it's installed under a different name/path, set CLIXAD_KIMI_BIN.`;
+  }
+});
+
+// src/banner.ts
+import { homedir as homedir5 } from "node:os";
+function duckLines() {
+  const lines = [];
+  for (let row = 0; row < DUCK.length; row += 2) {
+    const top = DUCK[row];
+    const bot = DUCK[row + 1] ?? "..............";
+    let out = "";
+    for (let col = 0; col < DUCK_W; col++) {
+      const t = PAL[top[col] ?? "."];
+      const b = PAL[bot[col] ?? "."];
+      if (t && b) out += fg(...t) + bg(...b) + "\u2580" + R2;
+      else if (t) out += fg(...t) + "\u2580" + R2;
+      else if (b) out += fg(...b) + "\u2584" + R2;
+      else out += " ";
+    }
+    lines.push(out);
+  }
+  return lines;
+}
+function centered(rendered, visibleW, colW) {
+  const lead = Math.max(0, Math.floor((colW - visibleW) / 2));
+  return cell(" ".repeat(lead) + rendered, lead + visibleW);
+}
+function earnedLabel(opts) {
+  return `$${opts.earnedUsdToday.toFixed(2)}/$${opts.maxRewardUsd.toFixed(2)} today`;
+}
+function welcomeBanner(opts) {
+  const width = Math.max(MIN_BANNER_WIDTH, opts.width ?? MIN_BANNER_WIDTH);
+  const inner = width - 7;
+  const rightW = Math.min(RIGHT_MAX, Math.max(26, inner - 30));
+  const leftW = inner - rightW;
+  const cwd = opts.cwd.replace(homedir5(), "~").replace(/\\/g, "/");
+  const welcome = opts.name ? `Welcome back, ${truncate(opts.name, 18)}!` : "Welcome to Clixad!";
+  const duck = duckLines();
+  const model = truncate(opts.model, leftW - 4);
+  const home = truncate(cwd, leftW);
+  const left = [
+    centered(BOLD + TEXT + welcome + R2, welcome.length, leftW),
+    cell("", 0),
+    ...duck.map((d) => centered(d, DUCK_W, leftW)),
+    cell("", 0),
+    centered(MANGO + "\u25C6 " + R2 + TEXT + model + R2, 2 + model.length, leftW),
+    centered(FAINT + home + R2, home.length, leftW)
+  ];
+  const tip = (k, d) => cell(MANGO + k + R2 + FAINT + " " + d + R2, k.length + 1 + d.length);
+  const right = [
+    cell(BOLD + MANGO + "Getting started" + R2, 15),
+    tip("/help", "commands"),
+    tip("/model", "switch model"),
+    tip("/earn", "earn credits"),
+    tip("/wallet", "balance & ads"),
+    cell("", 0),
+    cell(BOLD + MANGO + "Wallet" + R2, 6),
+    cell(TEXT + `${opts.balance.toLocaleString("en-US")} credits` + R2, `${opts.balance.toLocaleString("en-US")} credits`.length),
+    cell(MUTED + earnedLabel(opts) + R2, earnedLabel(opts).length)
+  ];
+  const rows = Math.max(left.length, right.length);
+  const out = [];
+  const label = `Clixad ${opts.version}`;
+  const topPrefixLen = 3 + label.length + 1;
+  const topDashes = width - topPrefixLen - 1;
+  out.push(MANGO + `\u256D\u2500 ${BOLD}${label}${R2}${MANGO} ` + "\u2500".repeat(Math.max(0, topDashes)) + "\u256E" + R2);
+  for (let i = 0; i < rows; i++) {
+    const l = padTo(left[i], leftW);
+    const r = padTo(right[i], rightW);
+    out.push(`${MANGO}\u2502${R2} ${l} ${MANGO}\u2502${R2} ${r} ${MANGO}\u2502${R2}`);
+  }
+  out.push(MANGO + "\u2570" + "\u2500".repeat(width - 2) + "\u256F" + R2);
+  return out.join("\n");
+}
+function compactBanner(opts) {
+  const welcome = opts.name ? `Welcome back, ${opts.name}!` : "Welcome to Clixad!";
+  return duckLines().map((d) => "  " + d).join("\n") + `
+
+  ${BOLD}${TEXT}${welcome}${R2}
+  ${MANGO}\u25C6${R2} ${opts.model}  ${FAINT}\xB7${R2} ${opts.balance.toLocaleString("en-US")} credits
+`;
+}
+function clearScreen() {
+  const out = process.stdout;
+  if (!out.isTTY && !process.stdin.isTTY) return;
+  out.write("\n".repeat(out.rows ?? 40));
+  out.write("\x1B[2J\x1B[3J\x1B[H\x1B[0f");
+}
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+var R2, BOLD, fg, bg, MANGO, TEXT, MUTED, FAINT, PAL, DUCK, DUCK_W, cell, padTo, truncate, MIN_BANNER_WIDTH, RIGHT_MAX;
+var init_banner = __esm({
+  "src/banner.ts"() {
+    "use strict";
+    R2 = "\x1B[0m";
+    BOLD = "\x1B[1m";
+    fg = (r, g, b) => `\x1B[38;2;${r};${g};${b}m`;
+    bg = (r, g, b) => `\x1B[48;2;${r};${g};${b}m`;
+    MANGO = fg(245, 184, 65);
+    TEXT = fg(232, 240, 251);
+    MUTED = fg(150, 165, 195);
+    FAINT = fg(95, 112, 148);
+    PAL = {
+      Y: [245, 184, 65],
+      // mango body
+      y: [255, 210, 115],
+      // highlight
+      O: [226, 126, 42],
+      // beak / feet
+      k: [30, 26, 40]
+      // eye
+    };
+    DUCK = [
+      "....yYYYY.....",
+      "...yYYYYYY....",
+      "..YYYYYYYYY...",
+      "..YYYYYYkYY...",
+      "..YYYYYYYYYOO.",
+      "..YYYYYYYYYOO.",
+      ".YYYYYYYYYYY..",
+      "YYYYYYYYYYYYY.",
+      "YYYYYYYYYYYYYY",
+      "YYYYYYYYYYYYYY",
+      ".YYYYYYYYYYYY.",
+      "..YYYYYYYYYY..",
+      "...OO....OO...",
+      ".............."
+    ];
+    DUCK_W = 14;
+    cell = (text, w) => ({ text, w });
+    padTo = (c2, width) => (c2?.text ?? "") + " ".repeat(Math.max(0, width - (c2?.w ?? 0)));
+    truncate = (s, max) => s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+    MIN_BANNER_WIDTH = 66;
+    RIGHT_MAX = 34;
+  }
+});
+
+// src/browser.ts
+import { spawn as spawn3 } from "node:child_process";
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn3(cmd, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+}
+var init_browser = __esm({
+  "src/browser.ts"() {
+    "use strict";
+  }
+});
+
+// src/compact.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function conversationTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    total += estimateTokens(m.content ?? "");
+    for (const call of m.tool_calls ?? []) total += estimateTokens(call.function.arguments) + 8;
+    total += 4;
+  }
+  return total;
+}
+function shouldCompact(messages, contextTokens, threshold = COMPACT_THRESHOLD) {
+  return conversationTokens(messages) > contextTokens * threshold;
+}
+function cutPoint(messages, keepTurns = 2) {
+  let seen = 0;
+  for (let i = messages.length - 1; i > 0; i--) {
+    if (messages[i].role !== "user") continue;
+    seen++;
+    if (seen >= keepTurns) return i;
+  }
+  return 0;
+}
+async function compact(client, model, messages, opts = {}) {
+  const cut = cutPoint(messages, opts.keepTurns ?? 2);
+  if (cut <= 1) return void 0;
+  const before = conversationTokens(messages);
+  const turn = await client.chatStream(
+    [...messages.slice(0, cut), { role: "user", content: SUMMARY_PROMPT }],
+    model,
+    { signal: opts.signal }
+  );
+  const summary = turn.message.content?.trim() || "(no summary returned)";
+  const compacted = [
+    messages[0],
+    { role: "user", content: `Summary of the earlier conversation:
+
+${summary}` },
+    { role: "assistant", content: "Understood \u2014 continuing from that summary." },
+    ...messages.slice(cut)
+  ];
+  return {
+    messages: compacted,
+    summary,
+    creditsCharged: turn.creditsCharged,
+    balance: turn.balance,
+    before,
+    after: conversationTokens(compacted)
+  };
+}
+var COMPACT_THRESHOLD, SUMMARY_PROMPT;
+var init_compact = __esm({
+  "src/compact.ts"() {
+    "use strict";
+    COMPACT_THRESHOLD = 0.75;
+    SUMMARY_PROMPT = "Summarise the conversation above for your future self, which will continue the work without seeing it. Cover: what the user asked for, what was already changed (files and the reasoning), what was learned about the codebase, and what is still open. Be specific about file paths and names. No preamble.";
+  }
+});
+
+// src/tui/commands.ts
+function commandLabel(c2) {
+  return `/${c2.name}${c2.args ? ` ${c2.args}` : ""}`;
+}
+function helpText() {
+  const w = Math.max(...COMMANDS.map((c2) => commandLabel(c2).length));
+  return COMMANDS.map((c2) => `  ${commandLabel(c2).padEnd(w + 2)}${c2.desc}`).join("\n") + "\n\n" + [
+    "  @path        reference a file (tab completes)",
+    "  shift+tab    cycle permission mode \xB7 esc  stop the current turn",
+    "  ctrl+o       expand the last tool output \xB7 ctrl+c twice  quit",
+    "  \\ + enter    continue on a new line"
+  ].join("\n");
+}
+var COMMANDS;
+var init_commands = __esm({
+  "src/tui/commands.ts"() {
+    "use strict";
+    COMMANDS = [
+      { name: "help", desc: "list the commands" },
+      { name: "model", desc: "switch model" },
+      { name: "models", desc: "list models + prices" },
+      { name: "mode", args: "[name]", desc: "permission mode (or press shift+tab)" },
+      { name: "wallet", desc: "balance & ads today" },
+      { name: "earn", desc: "earn credits (watch an ad)" },
+      { name: "compact", desc: "summarise the conversation to free context" },
+      { name: "clear", desc: "clear the conversation context" },
+      { name: "init", desc: "write a CLIXAD.md for this project" },
+      { name: "exit", desc: "quit clixad" }
+    ];
+  }
+});
+
+// src/tui/editor.ts
+function fromText(text, cursorAtEnd = true) {
+  const lines = text.split("\n");
+  const row = cursorAtEnd ? lines.length - 1 : 0;
+  return { lines, row, col: cursorAtEnd ? lines[row].length : 0 };
+}
+function fromTextAt(text, cursor) {
+  const before = text.slice(0, cursor).split("\n");
+  return { lines: text.split("\n"), row: before.length - 1, col: before[before.length - 1].length };
+}
+function toText(state) {
+  return state.lines.join("\n");
+}
+function isEmpty(state) {
+  return state.lines.length === 1 && state.lines[0] === "";
+}
+function offset(state) {
+  let n = 0;
+  for (let i = 0; i < state.row; i++) n += state.lines[i].length + 1;
+  return n + state.col;
+}
+function endsWithContinuation(state) {
+  const line2 = state.lines[state.row] ?? "";
+  return state.col === line2.length && /(^|[^\\])(\\\\)*\\$/.test(line2);
+}
+function apply(state, key) {
+  if (key.ctrl) {
+    switch (key.input) {
+      case "a":
+        return { ...state, col: 0 };
+      case "e":
+        return { ...state, col: line(state).length };
+      case "k":
+        return replaceLine(state, line(state).slice(0, state.col));
+      case "u":
+        return { ...replaceLine(state, line(state).slice(state.col)), col: 0 };
+      case "w":
+        return deleteWordLeft(state);
+      default:
+        break;
+    }
+  }
+  if (key.meta && (key.name === "left" || key.name === "right")) {
+    const col = key.name === "left" ? wordLeft(line(state), state.col) : wordRight(line(state), state.col);
+    return { ...state, col };
+  }
+  switch (key.name) {
+    case "left":
+      if (state.col > 0) return { ...state, col: state.col - 1 };
+      if (state.row > 0) return { ...state, row: state.row - 1, col: state.lines[state.row - 1].length };
+      return state;
+    case "right":
+      if (state.col < line(state).length) return { ...state, col: state.col + 1 };
+      if (state.row < state.lines.length - 1) return { ...state, row: state.row + 1, col: 0 };
+      return state;
+    case "up": {
+      if (state.row === 0) return state;
+      const row = state.row - 1;
+      return { ...state, row, col: Math.min(state.col, state.lines[row].length) };
+    }
+    case "down": {
+      if (state.row >= state.lines.length - 1) return state;
+      const row = state.row + 1;
+      return { ...state, row, col: Math.min(state.col, state.lines[row].length) };
+    }
+    case "home":
+      return { ...state, col: 0 };
+    case "end":
+      return { ...state, col: line(state).length };
+    case "backspace":
+      return backspace(state);
+    case "delete":
+      return del(state);
+    case "newline":
+      return newline(state);
+    default:
+      break;
+  }
+  if (key.input && !key.ctrl && !key.meta) return insert(state, key.input);
+  return state;
+}
+function insert(state, text) {
+  const clean = text.replace(/\r\n?/g, "\n").replace(/\t/g, "  ");
+  const safe = [...clean].filter((ch) => ch === "\n" || isPrintable(ch)).join("");
+  if (!safe) return state;
+  const current = line(state);
+  const head = current.slice(0, state.col) + safe;
+  const tail = current.slice(state.col);
+  const inserted = (head + tail).split("\n");
+  const lines = [...state.lines.slice(0, state.row), ...inserted, ...state.lines.slice(state.row + 1)];
+  const row = state.row + inserted.length - 1;
+  const col = inserted[inserted.length - 1].length - tail.length;
+  return { lines, row, col };
+}
+function newline(state) {
+  const current = line(state);
+  const lines = [
+    ...state.lines.slice(0, state.row),
+    current.slice(0, state.col),
+    current.slice(state.col),
+    ...state.lines.slice(state.row + 1)
+  ];
+  return { lines, row: state.row + 1, col: 0 };
+}
+function continueLine(state) {
+  const current = line(state);
+  const trimmed = { ...replaceLine(state, current.slice(0, -1)), col: current.length - 1 };
+  return newline(trimmed);
+}
+function backspace(state) {
+  if (state.col > 0) {
+    const current = line(state);
+    return { ...replaceLine(state, current.slice(0, state.col - 1) + current.slice(state.col)), col: state.col - 1 };
+  }
+  if (state.row === 0) return state;
+  const prev = state.lines[state.row - 1];
+  const lines = [
+    ...state.lines.slice(0, state.row - 1),
+    prev + line(state),
+    ...state.lines.slice(state.row + 1)
+  ];
+  return { lines, row: state.row - 1, col: prev.length };
+}
+function del(state) {
+  const current = line(state);
+  if (state.col < current.length) {
+    return replaceLine(state, current.slice(0, state.col) + current.slice(state.col + 1));
+  }
+  if (state.row >= state.lines.length - 1) return state;
+  const lines = [
+    ...state.lines.slice(0, state.row),
+    current + state.lines[state.row + 1],
+    ...state.lines.slice(state.row + 2)
+  ];
+  return { ...state, lines };
+}
+function deleteWordLeft(state) {
+  if (state.col === 0) return backspace(state);
+  const current = line(state);
+  const start = wordLeft(current, state.col);
+  return { ...replaceLine(state, current.slice(0, start) + current.slice(state.col)), col: start };
+}
+function wordLeft(text, col) {
+  let i = col;
+  while (i > 0 && isSep(text[i - 1])) i--;
+  while (i > 0 && !isSep(text[i - 1])) i--;
+  return i;
+}
+function wordRight(text, col) {
+  let i = col;
+  while (i < text.length && isSep(text[i])) i++;
+  while (i < text.length && !isSep(text[i])) i++;
+  return i;
+}
+function isPrintable(ch) {
+  const code = ch.codePointAt(0) ?? 0;
+  return code >= 32 && code !== 127;
+}
+function isSep(ch) {
+  return /[\s/\\.,:;()[\]{}'"`]/.test(ch);
+}
+function line(state) {
+  return state.lines[state.row] ?? "";
+}
+function replaceLine(state, text) {
+  const lines = [...state.lines];
+  lines[state.row] = text;
+  return { ...state, lines, col: Math.min(state.col, text.length) };
+}
+var EMPTY;
+var init_editor = __esm({
+  "src/tui/editor.ts"() {
+    "use strict";
+    EMPTY = { lines: [""], row: 0, col: 0 };
+  }
+});
+
+// src/tui/suggest.ts
+function findToken(text, cursor) {
+  const upto = text.slice(0, cursor);
+  const start = Math.max(upto.lastIndexOf(" "), upto.lastIndexOf("\n")) + 1;
+  const token = upto.slice(start);
+  if (token.startsWith("/")) {
+    return start === 0 ? { kind: "command", start, term: token.slice(1) } : void 0;
+  }
+  if (token.startsWith("@")) return { kind: "file", start, term: token.slice(1) };
+  return void 0;
+}
+function suggestCommands(term) {
+  const lower = term.toLowerCase();
+  return COMMANDS.filter((c2) => c2.name.startsWith(lower)).map(toSuggestion);
+}
+function toSuggestion(c2) {
+  return {
+    kind: "command",
+    value: `/${c2.name}`,
+    label: commandLabel(c2),
+    hint: c2.desc,
+    takesArgs: Boolean(c2.args)
+  };
+}
+function suggestFiles(term, files) {
+  const lower = term.toLowerCase();
+  const scored = [];
+  for (const path of files) {
+    const lowerPath = path.toLowerCase();
+    const name = lowerPath.slice(lowerPath.lastIndexOf("/") + 1);
+    let score;
+    if (!lower) score = 2;
+    else if (name.startsWith(lower)) score = 0;
+    else if (lowerPath.startsWith(lower)) score = 1;
+    else if (lowerPath.includes(lower)) score = 2;
+    else continue;
+    scored.push({ path, score });
+  }
+  scored.sort((a, b) => a.score - b.score || a.path.length - b.path.length || a.path.localeCompare(b.path));
+  return scored.slice(0, MAX_SUGGESTIONS).map(({ path }) => ({
+    kind: "file",
+    value: `@${path}`,
+    label: path.slice(path.lastIndexOf("/") + 1),
+    hint: path
+  }));
+}
+function suggest(query, sources) {
+  return query.kind === "command" ? suggestCommands(query.term).slice(0, MAX_SUGGESTIONS) : suggestFiles(query.term, sources.files());
+}
+function applySuggestion(text, cursor, query, choice) {
+  const head = text.slice(0, query.start) + choice.value + " ";
+  return { text: head + text.slice(cursor), cursor: head.length };
+}
+var MAX_SUGGESTIONS;
+var init_suggest = __esm({
+  "src/tui/suggest.ts"() {
+    "use strict";
+    init_commands();
+    MAX_SUGGESTIONS = 10;
+  }
+});
+
+// src/tui/markdown.ts
+function renderMarkdown(text) {
+  const out = [];
+  let inFence = false;
+  let fenceLang = "";
+  for (const raw of text.split("\n")) {
+    const fence = /^\s*```(.*)$/.exec(raw);
+    if (fence) {
+      if (!inFence) {
+        inFence = true;
+        fenceLang = fence[1].trim();
+        if (fenceLang) out.push(`${DIM2}  \u250C\u2500 ${fenceLang}${R3}`);
+        else out.push(`${DIM2}  \u250C\u2500${R3}`);
+      } else {
+        inFence = false;
+        out.push(`${DIM2}  \u2514\u2500${R3}`);
+      }
+      continue;
+    }
+    if (inFence) {
+      out.push(`${DIM2}  \u2502 ${R3}${CODE}${raw}${R3}`);
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
+    if (heading) {
+      out.push(`${BOLD2}${MANGO2}${heading[2]}${R3}`);
+      continue;
+    }
+    const rule = /^\s*(-{3,}|\*{3,}|_{3,})\s*$/.exec(raw);
+    if (rule) {
+      out.push(`${DIM2}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${R3}`);
+      continue;
+    }
+    const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(raw);
+    if (bullet) {
+      out.push(`${bullet[1]}${MANGO2}\u2022${R3} ${inline(bullet[2])}`);
+      continue;
+    }
+    if (/^\s*>\s?/.test(raw)) {
+      out.push(`${DIM2}${raw.replace(/^\s*>\s?/, "\u258F ")}${R3}`);
+      continue;
+    }
+    out.push(inline(raw));
+  }
+  return out.join("\n");
+}
+function inline(text) {
+  return text.replace(/`([^`]+)`/g, (_m, code) => `${CODE}${code}${R3}`).replace(/\*\*([^*]+)\*\*/g, (_m, bold) => `${BOLD2}${bold}${R3}`).replace(/(^|[\s(])\*([^*\s][^*]*)\*/g, (_m, pre, it) => `${pre}${ITALIC}${it}${R3}`);
+}
+var R3, BOLD2, DIM2, ITALIC, MANGO2, CODE;
+var init_markdown = __esm({
+  "src/tui/markdown.ts"() {
+    "use strict";
+    R3 = "\x1B[0m";
+    BOLD2 = "\x1B[1m";
+    DIM2 = "\x1B[2m";
+    ITALIC = "\x1B[3m";
+    MANGO2 = "\x1B[38;2;245;184;65m";
+    CODE = "\x1B[38;2;150;200;255m";
+  }
+});
+
+// src/tui/views.tsx
+import "react";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function lineCount(text, cols) {
+  return text.split("\n").reduce((n, line2) => n + Math.max(1, Math.ceil(visibleLength(line2) / Math.max(1, cols))), 0);
+}
+function entryHeight(entry, cols) {
+  const margin = entry.kind === "banner" ? 0 : 1;
+  switch (entry.kind) {
+    case "assistant":
+      return margin + lineCount(renderMarkdown(entry.text), cols) + (entry.meta ? 1 : 0);
+    case "tool":
+      return margin + 1 + (entry.output ? lineCount(entry.output, cols - 4) : 0) + (entry.outputMore ? 1 : 0);
+    default:
+      return margin + lineCount(entry.text, cols);
+  }
+}
+function EntryView({ entry }) {
+  switch (entry.kind) {
+    case "banner":
+      return /* @__PURE__ */ jsx(Text, { children: entry.text });
+    case "user":
+      return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: MANGO_BRIGHT, children: "\u276F " }),
+        /* @__PURE__ */ jsx(Text, { bold: true, children: entry.text })
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Text, { children: renderMarkdown(entry.text) }),
+        entry.meta ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${entry.meta}` }) : null
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: entry.ok === false ? "red" : MANGO3, children: "\u23FA " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: entry.name }),
+          entry.summary ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` ${entry.summary}` }) : null
+        ] }),
+        entry.output ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.output.split("\n").map((l) => `    ${l}`).join("\n") }) : null,
+        entry.outputMore ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `    \u2026 +${entry.outputMore} lines (ctrl+o)` }) : null
+      ] });
+    default:
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(
+        Text,
+        {
+          color: entry.tone === "error" ? "red" : entry.tone === "warn" ? "yellow" : entry.tone === "good" ? "green" : void 0,
+          dimColor: !entry.tone,
+          children: entry.text
+        }
+      ) });
+  }
+}
+var MANGO3, MANGO_BRIGHT;
+var init_views = __esm({
+  "src/tui/views.tsx"() {
+    "use strict";
+    init_banner();
+    init_markdown();
+    MANGO3 = "#f5b841";
+    MANGO_BRIGHT = "#ffcf6b";
+  }
+});
+
+// src/tui/app.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box as Box2, Static, Text as Text2, useApp, useInput } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function useTerminalSize() {
+  const [size, setSize] = useState({
+    rows: process.stdout.rows ?? 24,
+    cols: process.stdout.columns ?? 80
+  });
+  useEffect(() => {
+    const onResize = () => setSize({ rows: process.stdout.rows ?? 24, cols: process.stdout.columns ?? 80 });
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  return size;
+}
+function App({ client, config, wallet, session, initialTask }) {
+  const { exit } = useApp();
+  const idRef = useRef(1);
+  const { rows, cols } = useTerminalSize();
+  const root = process.cwd();
+  const [entries, setEntries] = useState(() => [
+    {
+      id: 0,
+      kind: "banner",
+      text: ((process.stdout.columns ?? 80) >= MIN_BANNER_WIDTH ? welcomeBanner : compactBanner)({
+        width: process.stdout.columns ?? 80,
+        name: config.login ?? config.email?.split("@")[0],
+        model: config.model,
+        balance: wallet?.balance ?? 0,
+        adsToday: wallet?.ads_today ?? 0,
+        earnedUsdToday: wallet?.earned_usd_today ?? 0,
+        maxRewardUsd: wallet?.max_reward_usd_per_day ?? 0,
+        cwd: process.cwd(),
+        version: "v0.0.1"
+      })
+    }
+  ]);
+  const [messages, setMessages] = useState(session?.messages ?? []);
+  const [editor, setEditor] = useState(EMPTY);
+  const [busy, setBusy] = useState(false);
+  const [live, setLive] = useState(null);
+  const [balance, setBalance] = useState(wallet?.balance ?? 0);
+  const [spent, setSpent] = useState(0);
+  const [model, setModel2] = useState(config.model);
+  const [mode, setMode] = useState("normal");
+  const [hist, setHist] = useState(() => loadHistory());
+  const [histIdx, setHistIdx] = useState(-1);
+  const [sel, setSel] = useState(0);
+  const [menuOff, setMenuOff] = useState(false);
+  const [ask2, setAsk] = useState(null);
+  const [picker, setPicker] = useState(null);
+  const [pickerSel, setPickerSel] = useState(0);
+  const [tick, setTick] = useState(0);
+  const [startedAt, setStartedAt] = useState(0);
+  const [quitHint, setQuitHint] = useState(false);
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  const permRef = useRef(createState("normal"));
+  const abortRef = useRef(null);
+  const filesRef = useRef(null);
+  const ctrlCRef = useRef(0);
+  const sessionRef = useRef(session ?? { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() });
+  const runStartedAtRef = useRef(Date.now());
+  const contextRef = useRef(collectContext(root));
+  const catalogRef = useRef([]);
+  const lastOutputRef = useRef("");
+  const runningToolRef = useRef(null);
+  const pendingTaskRef = useRef(null);
+  const push = useCallback((e) => {
+    setEntries((prev) => [...prev, { ...e, id: idRef.current++ }]);
+  }, []);
+  useEffect(() => {
+    const files = contextRef.current.files;
+    if (files.length) push({ kind: "notice", text: `  context: ${files.join(", ")}` });
+    if (session?.messages.length) {
+      push({ kind: "notice", text: `  resumed session ${session.id} (${session.messages.length} messages)` });
+    }
+    client.models().then((m) => catalogRef.current = m).catch(() => void 0);
+  }, []);
+  useEffect(() => {
+    if (!busy) return;
+    const t = setInterval(() => setTick((n) => n + 1), 120);
+    return () => clearInterval(t);
+  }, [busy]);
+  const contextWindow = useCallback(
+    (id) => catalogRef.current.find((m) => m.id === id)?.context_window ?? contextTokensFor(id),
+    []
+  );
+  const askUser = useCallback(
+    (req) => new Promise((resolve2) => setAsk({ req, resolve: resolve2 })),
+    []
+  );
+  const permit = useMemo(() => createPermit(() => permRef.current, askUser), [askUser]);
+  const cycleMode = useCallback(() => {
+    const next = nextMode(permRef.current.mode);
+    permRef.current.mode = next;
+    setMode(next);
+  }, []);
+  const handleEvent = useCallback(
+    (event) => {
+      switch (event.type) {
+        case "delta":
+          setLive((l) => ({ ...l ?? { text: "" }, text: (l?.text ?? "") + event.text }));
+          return;
+        case "message":
+          push({ kind: "assistant", text: event.content });
+          setLive((l) => ({ ...l ?? { text: "" }, text: "" }));
+          return;
+        case "tool_call": {
+          const summary = toolSummary(event.name, event.args);
+          runningToolRef.current = { name: event.name, summary };
+          setLive((l) => ({ text: l?.text ?? "", tool: { name: event.name, summary, output: "" } }));
+          return;
+        }
+        case "tool_output":
+          setLive(
+            (l) => l?.tool ? { ...l, tool: { ...l.tool, output: tailLines(l.tool.output + event.chunk, LIVE_OUTPUT_LINES) } } : l
+          );
+          return;
+        case "tool_result": {
+          lastOutputRef.current = event.result;
+          const lines = event.result.split("\n").filter((l) => l.trim() !== "");
+          const shown = lines.slice(0, COMMITTED_OUTPUT_LINES).map((l) => l.slice(0, Math.max(20, cols - 8)));
+          setLive((l) => l ? { text: l.text, tool: void 0 } : l);
+          push({
+            kind: "tool",
+            name: event.name,
+            summary: runningToolRef.current?.summary ?? "",
+            output: shown.join("\n"),
+            outputMore: Math.max(0, lines.length - shown.length),
+            ok: event.ok
+          });
+          runningToolRef.current = null;
+          return;
+        }
+        case "usage":
+          setBalance(event.balance);
+          setSpent((s) => s + event.creditsCharged);
+          return;
+        default:
+          return;
+      }
+    },
+    [cols, push]
+  );
+  const runTurn2 = useCallback(
+    async (task) => {
+      const ac = new AbortController();
+      abortRef.current = ac;
+      setBusy(true);
+      setStartedAt(Date.now());
+      setLive({ text: "" });
+      let history = messagesRef.current;
+      try {
+        const window = contextWindow(model);
+        if (shouldCompact([{ role: "system", content: contextRef.current.systemPrompt }, ...history], window)) {
+          const res = await compact(client, model, [
+            { role: "system", content: contextRef.current.systemPrompt },
+            ...history
+          ], { signal: ac.signal });
+          if (res) {
+            history = res.messages.slice(1);
+            setMessages(history);
+            setBalance(res.balance);
+            setSpent((s) => s + res.creditsCharged);
+            push({
+              kind: "notice",
+              text: `  compacted context: ~${Math.round(res.before / 1e3)}k \u2192 ~${Math.round(res.after / 1e3)}k tokens (${res.creditsCharged} credits)`
+            });
+          }
+        }
+        const result = await runAgent(client, task, {
+          model,
+          root,
+          history,
+          systemPrompt: contextRef.current.systemPrompt,
+          permit,
+          signal: ac.signal,
+          onEvent: handleEvent
+        });
+        const next = result.messages.slice(1);
+        setMessages(next);
+        saveSession({
+          id: sessionRef.current.id,
+          started: sessionRef.current.started,
+          updated: (/* @__PURE__ */ new Date()).toISOString(),
+          cwd: root,
+          model,
+          title: (session?.title || task).slice(0, 80),
+          messages: next
+        });
+        if (result.stopped === "aborted") {
+          push({ kind: "notice", tone: "warn", text: "  (stopped)" });
+          const w = await client.wallet().catch(() => void 0);
+          if (w) setBalance(w.balance);
+        } else if (result.stopped === "max_steps") {
+          push({ kind: "notice", tone: "warn", text: "  (stopped: reached the step limit \u2014 ask me to continue)" });
+        } else if (result.content) {
+          push({
+            kind: "assistant",
+            text: result.content,
+            meta: `[${result.creditsCharged} credits \xB7 balance ${result.balance.toLocaleString("en-US")}]`
+          });
+        }
+      } catch (err) {
+        if (err instanceof PaywallError) {
+          pendingTaskRef.current = task;
+          push({
+            kind: "notice",
+            tone: "warn",
+            text: `  Out of credits (balance ${err.balance}, need ~${err.estimatedCost}).
+  Press enter to open the ad wall (+${err.grantPerAd} credits on completion) \u2014 I'll continue automatically.
+  Offers you are screened out of pay nothing; that is normal, just start another.`
+          });
+        } else if (err instanceof AuthError) {
+          push({ kind: "notice", tone: "error", text: `  ${err.message}` });
+        } else {
+          push({ kind: "notice", tone: "error", text: `  error: ${err.message}` });
+        }
+      } finally {
+        abortRef.current = null;
+        setLive(null);
+        setBusy(false);
+      }
+    },
+    [client, contextWindow, handleEvent, model, permit, push, root, session?.title]
+  );
+  const runAdWall = useCallback(async () => {
+    const task = pendingTaskRef.current;
+    pendingTaskRef.current = null;
+    const before = balance;
+    const code = await client.handoffCode();
+    const base = config.dashboardUrl.replace(/\/+$/, "");
+    openBrowser(code ? `${base}/?c=${encodeURIComponent(code)}` : base);
+    push({
+      kind: "notice",
+      text: (code ? `  opened ${base} (signed in) \u2014 waiting for the reward\u2026
+` : `  opened ${base} \u2014 paste your token there; waiting for the reward\u2026
+`) + `  Credits land on completion; being screened out of an offer pays nothing and is normal.`
+    });
+    setBusy(true);
+    const deadline = Date.now() + 5 * 6e4;
+    let credited = false;
+    while (Date.now() < deadline && !credited) {
+      await new Promise((r) => setTimeout(r, 3e3));
+      const w = await client.wallet().catch(() => void 0);
+      if (w && w.balance > before) {
+        setBalance(w.balance);
+        credited = true;
+      }
+    }
+    setBusy(false);
+    if (!credited)
+      return push({
+        kind: "notice",
+        tone: "warn",
+        text: "  no credit yet \u2014 offers take a while to confirm, and a screenout pays nothing.\n  That is normal: start another with /earn, or check /wallet later."
+      });
+    push({ kind: "notice", tone: "good", text: "  credits added \u2014 continuing" });
+    if (task) await runTurn2(task);
+  }, [balance, client, config.dashboardUrl, push, runTurn2]);
+  const runCommand = useCallback(
+    async (line2) => {
+      const [cmd, ...rest] = line2.slice(1).split(" ");
+      const arg = rest.join(" ").trim();
+      switch (cmd) {
+        case "exit":
+        case "quit":
+          exit();
+          return;
+        case "help":
+          push({ kind: "notice", text: helpText() });
+          return;
+        case "clear":
+          setMessages([]);
+          sessionRef.current = { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() };
+          push({ kind: "notice", text: "  (context cleared)" });
+          return;
+        case "mode": {
+          const wanted = MODES.find((m) => m.toLowerCase() === arg.toLowerCase().replace(/[-\s]/g, ""));
+          if (arg && !wanted) {
+            push({ kind: "notice", tone: "warn", text: `  unknown mode: ${arg} \u2014 try ${MODES.join(", ")}` });
+            return;
+          }
+          if (wanted) {
+            permRef.current.mode = wanted;
+            setMode(wanted);
+          } else {
+            cycleMode();
+          }
+          push({ kind: "notice", text: `  mode \u2192 ${MODE_LABEL[permRef.current.mode]}` });
+          return;
+        }
+        case "compact": {
+          setBusy(true);
+          try {
+            const res = await compact(client, model, [
+              { role: "system", content: contextRef.current.systemPrompt },
+              ...messagesRef.current
+            ]);
+            if (!res) push({ kind: "notice", text: "  nothing to compact yet" });
+            else {
+              setMessages(res.messages.slice(1));
+              setBalance(res.balance);
+              setSpent((s) => s + res.creditsCharged);
+              push({
+                kind: "notice",
+                text: `  compacted: ~${Math.round(res.before / 1e3)}k \u2192 ~${Math.round(res.after / 1e3)}k tokens (${res.creditsCharged} credits)`
+              });
+            }
+          } catch (err) {
+            push({ kind: "notice", tone: "error", text: `  ${err.message}` });
+          }
+          setBusy(false);
+          return;
+        }
+        case "init":
+          await runTurn2(INIT_PROMPT);
+          return;
+        // Always the picker — an id you have to remember and type is exactly
+        // what a picker is for. A typed id only preselects a row.
+        case "model": {
+          setBusy(true);
+          const models = catalogRef.current.length ? catalogRef.current : await client.models().catch(() => []);
+          catalogRef.current = models;
+          setBusy(false);
+          if (!models.length) return push({ kind: "notice", tone: "error", text: "  could not load the model list" });
+          if (arg && !models.some((m) => m.id === arg)) {
+            push({ kind: "notice", tone: "warn", text: `  unknown model: ${arg}` });
+          }
+          const items = models.map((m) => ({
+            value: m.id,
+            label: m.id,
+            hint: `${m.tier.padEnd(8)}${adsPerTaskLabel(m.est_ads_per_task)}`,
+            current: m.id === model
+          }));
+          const preselect = items.findIndex((i) => i.value === arg);
+          setPickerSel(preselect >= 0 ? preselect : Math.max(0, items.findIndex((i) => i.current)));
+          setPicker({
+            title: "Select model",
+            subtitle: "Applies to this session and is saved as your default.",
+            items,
+            onPick: (choice) => {
+              config.model = choice.value;
+              saveConfig(config);
+              setModel2(choice.value);
+              push({ kind: "notice", text: `  model \u2192 ${choice.value}` });
+            }
+          });
+          return;
+        }
+        case "models": {
+          setBusy(true);
+          try {
+            const ms = await client.models();
+            catalogRef.current = ms;
+            push({
+              kind: "notice",
+              text: ms.map((m) => `  ${m.id.padEnd(24)} ${adsPerTaskLabel(m.est_ads_per_task)}`).join("\n")
+            });
+          } catch (err) {
+            push({ kind: "notice", tone: "error", text: `  ${err.message}` });
+          }
+          setBusy(false);
+          return;
+        }
+        case "wallet": {
+          setBusy(true);
+          try {
+            const w = await client.wallet();
+            setBalance(w.balance);
+            push({
+              kind: "notice",
+              text: `  balance ${w.balance.toLocaleString("en-US")} credits \xB7 ${w.ads_today} offers today \xB7 $${w.earned_usd_today.toFixed(2)}/$${w.max_reward_usd_per_day.toFixed(2)} earned`
+            });
+          } catch (err) {
+            push({ kind: "notice", tone: "error", text: `  ${err.message}` });
+          }
+          setBusy(false);
+          return;
+        }
+        // The same browser handoff the paywall takes, rather than a second way of
+        // doing it: /earn used to call the dev-only /v1/ads/reward simulator, so
+        // in production the slash command the paywall itself recommends was a 404.
+        case "earn":
+          await runAdWall();
+          return;
+        default:
+          push({ kind: "notice", tone: "warn", text: `  unknown command: /${cmd} \u2014 try /help` });
+      }
+    },
+    [client, config, cycleMode, exit, model, push, runTurn2]
+  );
+  const submit = useCallback(
+    async (raw) => {
+      const line2 = raw.trim();
+      setEditor(EMPTY);
+      setHistIdx(-1);
+      setMenuOff(false);
+      if (!line2) return;
+      setHist((h) => {
+        const next = [line2, ...h.filter((x) => x !== line2)].slice(0, 200);
+        saveHistory(next);
+        return next;
+      });
+      push({ kind: "user", text: line2 });
+      if (line2.startsWith("/")) return runCommand(line2);
+      return runTurn2(line2);
+    },
+    [push, runCommand, runTurn2]
+  );
+  useEffect(() => {
+    if (!initialTask) return;
+    push({ kind: "user", text: initialTask });
+    void runTurn2(initialTask);
+  }, []);
+  const text = toText(editor);
+  const cursor = offset(editor);
+  const query = useMemo(() => findToken(text, cursor), [text, cursor]);
+  const matches = useMemo(
+    () => query ? suggest(query, {
+      files: () => filesRef.current ??= listWorkspaceFiles(root)
+    }) : [],
+    [query, root]
+  );
+  const menu = menuOff || busy || ask2 || picker ? [] : matches;
+  useEffect(() => {
+    setSel(0);
+    setMenuOff(false);
+  }, [text]);
+  const accept = useCallback(
+    (choice) => {
+      if (!query) return;
+      const { text: nextText, cursor: nextCursor } = applySuggestion(text, cursor, query, choice);
+      setEditor(fromTextAt(nextText, nextCursor));
+    },
+    [cursor, query, text]
+  );
+  useInput((ch, key) => {
+    if (key.ctrl && ch === "c") {
+      if (busy) return abortRef.current?.abort();
+      if (!isEmpty(editor)) return setEditor(EMPTY);
+      if (Date.now() - ctrlCRef.current < 2e3) return exit();
+      ctrlCRef.current = Date.now();
+      setQuitHint(true);
+      return;
+    }
+    if (quitHint) setQuitHint(false);
+    if (ask2) {
+      const answer = ch === "y" || ch === "j" || key.return ? "once" : ch === "a" ? "always" : ch === "n" || key.escape ? "deny" : void 0;
+      if (!answer) return;
+      setAsk(null);
+      ask2.resolve(answer);
+      push({
+        kind: "notice",
+        tone: answer === "deny" ? "warn" : void 0,
+        text: `  ${answer === "deny" ? "denied" : answer === "always" ? "allowed (always)" : "allowed"}: ${ask2.req.summary}`
+      });
+      return;
+    }
+    if (picker) {
+      const n = picker.items.length;
+      if (key.escape) return setPicker(null);
+      if (key.upArrow) return setPickerSel((s) => (s - 1 + n) % n);
+      if (key.downArrow) return setPickerSel((s) => (s + 1) % n);
+      if (/^[1-9]$/.test(ch)) {
+        const choice = picker.items[Number(ch) - 1];
+        if (!choice) return;
+        setPicker(null);
+        return picker.onPick(choice);
+      }
+      if (key.return) {
+        const choice = picker.items[Math.min(pickerSel, n - 1)];
+        setPicker(null);
+        if (choice) picker.onPick(choice);
+      }
+      return;
+    }
+    if (busy) {
+      if (key.escape) abortRef.current?.abort();
+      return;
+    }
+    if (key.tab && key.shift) return cycleMode();
+    if (key.ctrl && ch === "o") {
+      const out = lastOutputRef.current;
+      if (out) push({ kind: "notice", text: out.split("\n").map((l) => `  ${l}`).join("\n") });
+      return;
+    }
+    if (menu.length > 0) {
+      if (key.upArrow) return setSel((s) => (s - 1 + menu.length) % menu.length);
+      if (key.downArrow) return setSel((s) => (s + 1) % menu.length);
+      if (key.escape) return setMenuOff(true);
+      if (key.return || key.tab) {
+        const choice = menu[Math.min(sel, menu.length - 1)];
+        if (key.tab || choice.takesArgs || choice.kind === "file") return accept(choice);
+        return void submit(choice.value);
+      }
+    }
+    if (key.return) {
+      if (key.meta || key.shift) return setEditor(newline(editor));
+      if (endsWithContinuation(editor)) return setEditor(continueLine(editor));
+      if (pendingTaskRef.current && isEmpty(editor)) return void runAdWall();
+      return void submit(toText(editor));
+    }
+    if (key.ctrl && ch === "j") return setEditor(newline(editor));
+    if (key.upArrow && editor.row === 0) {
+      const n = Math.min(histIdx + 1, hist.length - 1);
+      const v = hist[n];
+      if (v !== void 0) {
+        setHistIdx(n);
+        setEditor(fromText(v));
+      }
+      return;
+    }
+    if (key.downArrow && editor.row === editor.lines.length - 1 && histIdx >= 0) {
+      const n = histIdx - 1;
+      setHistIdx(n < 0 ? -1 : n);
+      setEditor(n < 0 ? EMPTY : fromText(hist[n] ?? ""));
+      return;
+    }
+    setEditor(apply(editor, toEditorKey(ch, key)));
+  });
+  const elapsed = busy && startedAt ? Math.floor((Date.now() - startedAt) / 1e3) : 0;
+  const spinner = SPINNER[tick % SPINNER.length];
+  const liveText = live?.text ? tailLines(live.text, Math.max(4, rows - 12)) : "";
+  const liveBlock = [
+    liveText,
+    live?.tool ? `\u23FA ${live.tool.name} ${live.tool.summary}` : "",
+    live?.tool?.output ?? ""
+  ].filter(Boolean).join("\n");
+  const askBlock = ask2 ? [ask2.req.summary, ask2.req.preview ?? ""].filter(Boolean).join("\n") : "";
+  const pickerHeight = picker ? picker.items.length + 8 : 0;
+  const pickerLabelW = picker ? picker.items.reduce((w, i) => Math.max(w, i.label.length), 0) : 0;
+  const inputBoxHeight = 2 + editor.lines.length;
+  const chromeHeight = inputBoxHeight + 2;
+  const liveHeight = liveBlock ? lineCount(liveBlock, cols) + 1 : 0;
+  const askHeight = ask2 ? lineCount(askBlock, cols) + 2 : 0;
+  const printed = useMemo(() => entries.reduce((n, e) => n + entryHeight(e, cols), 0), [entries, cols]);
+  const spacer = Math.max(
+    0,
+    rows - 1 - printed - chromeHeight - menu.length - pickerHeight - liveHeight - askHeight
+  );
+  const labelW = menu.reduce((w, c2) => Math.max(w, c2.label.length), 0);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Static, { items: entries, children: (entry) => /* @__PURE__ */ jsx2(EntryView, { entry }, entry.id) }),
+    spacer > 0 ? /* @__PURE__ */ jsx2(Box2, { height: spacer }) : null,
+    liveBlock ? /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { children: liveBlock }) }) : null,
+    ask2 ? /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: "yellow", children: ask2.req.summary }),
+      ask2.req.preview ? /* @__PURE__ */ jsx2(Text2, { children: ask2.req.preview }) : null,
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "[y/\u23CE] once \xB7 [a] always \xB7 [n] no \xB7 esc cancels" })
+    ] }) : null,
+    picker ? /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: MANGO3, paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: MANGO_BRIGHT, children: picker.title }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: picker.subtitle }),
+      /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+      picker.items.map((item, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: i === pickerSel ? MANGO_BRIGHT : void 0, bold: i === pickerSel, children: [
+          i === pickerSel ? "\u276F " : "  ",
+          `${i + 1}. `,
+          item.label.padEnd(pickerLabelW + 2)
+        ] }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: item.hint }),
+        item.current ? /* @__PURE__ */ jsx2(Text2, { color: "green", children: "  \u2190 current" }) : null
+      ] }, item.value)),
+      /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2191\u2193 choose \xB7 1-9 jump straight to a row \xB7 \u23CE confirm \xB7 esc cancel" })
+    ] }) : null,
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs2(Box2, { borderStyle: "round", borderColor: busy ? MANGO_BRIGHT : MANGO3, paddingX: 1, children: [
+        /* @__PURE__ */ jsx2(Text2, { color: MANGO_BRIGHT, children: "\u276F " }),
+        busy ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          spinner,
+          " working\u2026 ",
+          elapsed,
+          "s \xB7 esc to stop"
+        ] }) : /* @__PURE__ */ jsx2(Text2, { children: renderInput(editor) })
+      ] }),
+      menu.map((item, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: i === sel ? MANGO_BRIGHT : MANGO3, bold: i === sel, children: [
+          i === sel ? "  \u276F " : "    ",
+          item.label.padEnd(labelW + 2)
+        ] }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: i !== sel, children: item.hint })
+      ] }, item.value)),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  ",
+        statusLine({
+          menu: menu.length > 0,
+          quitHint,
+          model,
+          balance,
+          spent,
+          mode,
+          minutes: (Date.now() - runStartedAtRef.current) / 6e4
+        })
+      ] })
+    ] })
+  ] });
+}
+function renderInput(state) {
+  return state.lines.map((line2, row) => {
+    const prefix = row === 0 ? "" : "\n";
+    if (row !== state.row) return /* @__PURE__ */ jsx2(Text2, { children: prefix + line2 }, row);
+    const before = line2.slice(0, state.col);
+    const at = line2.slice(state.col, state.col + 1) || " ";
+    const after = line2.slice(state.col + 1);
+    return /* @__PURE__ */ jsxs2(Text2, { children: [
+      prefix + before,
+      /* @__PURE__ */ jsx2(Text2, { inverse: true, children: at }),
+      after
+    ] }, row);
+  });
+}
+function statusLine(o) {
+  if (o.quitHint) return "press ctrl+c again to quit";
+  if (o.menu) return "\u2191\u2193 choose \xB7 \u23CE run \xB7 tab complete \xB7 esc close";
+  const burn = o.spent > 0 && o.minutes >= 1 ? `${Math.round(o.spent / o.minutes).toLocaleString("en-US")} cr/min` : void 0;
+  const parts = [
+    o.model,
+    `${o.balance.toLocaleString("en-US")} cr`,
+    o.spent > 0 ? `\u2212${o.spent.toLocaleString("en-US")} this session` : void 0,
+    burn,
+    MODE_LABEL[o.mode],
+    "/help"
+  ].filter(Boolean);
+  return parts.join(" \xB7 ");
+}
+function toEditorKey(ch, key) {
+  const name = key.leftArrow ? "left" : key.rightArrow ? "right" : key.upArrow ? "up" : key.downArrow ? "down" : key.backspace ? "backspace" : key.delete ? "delete" : void 0;
+  return {
+    input: name || key.escape || key.tab ? void 0 : ch,
+    name,
+    ctrl: key.ctrl,
+    meta: key.meta
+  };
+}
+function toolSummary(name, args) {
+  const str = (v) => typeof v === "string" ? v : "";
+  switch (name) {
+    case "read_file":
+    case "write_file":
+    case "edit_file":
+      return str(args.path);
+    case "list_dir":
+      return str(args.path) || ".";
+    case "glob":
+      return str(args.pattern);
+    case "grep":
+      return str(args.pattern) + (args.path ? ` in ${str(args.path)}` : "");
+    case "run_command":
+      return str(args.command);
+    default:
+      return "";
+  }
+}
+function tailLines(text, max) {
+  const lines = text.split("\n");
+  return lines.length <= max ? text : lines.slice(-max).join("\n");
+}
+var SPINNER, LIVE_OUTPUT_LINES, COMMITTED_OUTPUT_LINES;
+var init_app = __esm({
+  "src/tui/app.tsx"() {
+    "use strict";
+    init_client();
+    init_config();
+    init_banner();
+    init_agent();
+    init_context();
+    init_compact();
+    init_kimi();
+    init_browser();
+    init_tools();
+    init_permissions();
+    init_session();
+    init_commands();
+    init_editor();
+    init_suggest();
+    init_views();
+    SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    LIVE_OUTPUT_LINES = 5;
+    COMMITTED_OUTPUT_LINES = 4;
+  }
+});
+
+// src/tui/index.tsx
+var tui_exports = {};
+__export(tui_exports, {
+  startTui: () => startTui
+});
+import "react";
+import { render } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+async function startTui(props) {
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx3(App, { ...props }), { patchConsole: false });
+  await waitUntilExit();
+}
+var init_tui = __esm({
+  "src/tui/index.tsx"() {
+    "use strict";
+    init_app();
+  }
+});
+
+// src/main.ts
+init_client();
+init_config();
+init_agent();
+init_context();
+init_permissions();
+init_session();
+init_kimi();
+init_banner();
+init_browser();
+var c = {
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  dim: (s) => `\x1B[2m${s}\x1B[0m`,
+  bold: (s) => `\x1B[1m${s}\x1B[0m`
+};
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  const config = loadConfig();
+  const client = new GatewayClient(config);
+  switch (cmd) {
+    case "login":
+      return login(client, config, rest[0]);
+    case "logout":
+      return logout(config);
+    case "whoami":
+      return whoami(client, config);
+    case "models":
+      return listModels(client);
+    case "model":
+      return setModel(client, config, rest[0]);
+    case "wallet":
+      return showWallet(client);
+    case "earn":
+      return earn(client, config);
+    case "buy":
+      return buyCmd(client, config, rest[0]);
+    case "ask":
+      return ask(client, config, rest.join(" "));
+    case "agent":
+      return repl(client, config, { task: rest.join(" ").trim() || void 0 });
+    case "-p":
+    case "--print":
+      return printCmd(client, config, rest.join(" ").trim());
+    case "-c":
+    case "--continue":
+      return repl(client, config, { resume: "latest" });
+    case "--resume":
+      return repl(client, config, { resume: rest[0] ?? "pick" });
+    case "code":
+      return codeCmd(client, config, rest);
+    case "help":
+    case "--help":
+    case "-h":
+      return printHelp();
+    case void 0:
+      return repl(client, config);
+    default:
+      console.error(c.red(`unknown command: ${cmd}`));
+      printHelp();
+      process.exitCode = 1;
+  }
+}
+async function login(client, config, email) {
+  if (!email) {
+    const start = await client.deviceStart().catch(() => null);
+    if (start) return githubLogin(client, config, start);
+  }
+  return devLogin(client, config, email);
+}
+async function githubLogin(client, config, start) {
+  console.log(`
+  Open ${c.cyan(start.verification_uri)} and enter code: ${c.bold(start.user_code)}
+`);
+  openBrowser(start.verification_uri);
+  process.stdout.write(c.dim("  waiting for GitHub authorization\u2026 (Ctrl+C to cancel)"));
+  const deadline = Date.now() + start.expires_in * 1e3;
+  let interval = Math.max(start.interval, 1);
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    process.stdout.write(c.dim("."));
+    const poll = await client.devicePoll(start.session);
+    if (poll.status === "pending") {
+      if (poll.interval) interval = poll.interval;
+      continue;
+    }
+    if (poll.status === "complete") {
+      config.token = poll.token;
+      config.userId = poll.userId;
+      config.email = poll.email;
+      config.login = poll.login;
+      saveConfig(config);
+      console.log(c.green(`
+\u2713 logged in as ${poll.login}`) + c.dim(poll.email ? ` (${poll.email})` : ""));
+      const bonus = poll.created ? c.dim(` (signup bonus ${poll.signupBonus})`) : "";
+      console.log(`  balance: ${c.bold(String(poll.balance))} credits${bonus}`);
+      console.log(c.dim(`  token stored in ${configPath()}`));
+      return;
+    }
+    console.log(c.red(`
+  login failed: ${poll.error ?? poll.status}`));
+    return;
+  }
+  console.log(c.red("\n  login timed out \u2014 run `clixad login` again."));
+}
+async function devLogin(client, config, email) {
+  const res = await client.signupDev(email);
+  config.token = res.token;
+  config.userId = res.userId;
+  config.email = res.email;
+  saveConfig(config);
+  console.log(c.green(`\u2713 logged in as ${res.email}`));
+  console.log(`  balance: ${c.bold(String(res.balance))} credits (signup bonus)`);
+  console.log(c.dim(`  token stored in ${configPath()}`));
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function logout(config) {
+  delete config.token;
+  delete config.userId;
+  delete config.email;
+  saveConfig(config);
+  console.log(c.green("\u2713 logged out"));
+}
+async function whoami(client, config) {
+  if (!config.token) return console.log(c.yellow("not logged in \u2014 run `clixad login`"));
+  const w = await client.wallet();
+  console.log(`${c.bold(config.email ?? "unknown")}  \xB7  model ${c.cyan(config.model)}`);
+  console.log(`balance: ${c.bold(String(w.balance))} credits  \xB7  ${earnedToday(w)}`);
+}
+function earnedToday(w) {
+  const offers = `${w.ads_today} offer${w.ads_today === 1 ? "" : "s"}`;
+  return `earned today: ${offers} \xB7 $${w.earned_usd_today.toFixed(2)}/$${w.max_reward_usd_per_day.toFixed(2)}`;
+}
+async function listModels(client) {
+  const models = await client.models();
+  console.log(c.bold("Models  (credit prices per 1M tokens)"));
+  for (const m of models) {
+    const tag = m.ad_fundable ? "" : c.dim(" [paid/BYOK]");
+    console.log(
+      `  ${c.cyan(m.id.padEnd(22))} ${m.tier.padEnd(8)} in ${String(m.credits_per_mtoken_input).padStart(9)}  out ${String(m.credits_per_mtoken_output).padStart(9)}  ${adsPerTaskLabel(m.est_ads_per_task)}${tag}`
+    );
+  }
+}
+async function setModel(client, config, model) {
+  if (!model) return console.log(`current model: ${c.cyan(config.model)}`);
+  const known = await client.models().catch(() => void 0);
+  if (known && !known.some((m) => m.id === model)) {
+    console.error(c.red(`unknown model: ${model}`));
+    console.error(c.dim(`  available: ${known.map((m) => m.id).join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  if (!known) console.log(c.yellow("  (couldn't reach the gateway to verify the id)"));
+  config.model = model;
+  saveConfig(config);
+  console.log(c.green(`\u2713 model set to ${model}`));
+}
+async function showWallet(client) {
+  const w = await client.wallet();
+  console.log(`balance: ${c.bold(String(w.balance))} credits`);
+  console.log(`${earnedToday(w)}  \xB7  typical grant: ${w.grant_per_ad} on completion`);
+  if (w.ledger.length) {
+    console.log(c.dim("recent:"));
+    for (const e of w.ledger.slice(0, 8)) {
+      const sign = e.delta >= 0 ? c.green(`+${e.delta}`) : c.red(String(e.delta));
+      console.log(c.dim(`  ${sign.padEnd(18)} ${e.reason.padEnd(14)} -> ${e.balanceAfter}`));
+    }
+  }
+}
+async function earn(client, config) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  const before = (await safeWallet(client))?.balance ?? 0;
+  const code = await client.handoffCode();
+  const base = config.dashboardUrl.replace(/\/+$/, "");
+  const url = code ? `${base}/?c=${encodeURIComponent(code)}` : base;
+  openBrowser(url);
+  console.log(`
+  Ad wall: ${c.dim(base)}`);
+  if (!code) console.log(c.yellow("  (couldn't sign you in automatically \u2014 paste your token there)"));
+  console.log(
+    c.dim("  Credits are granted on completion. Surveys screen people out part way through \u2014\n") + c.dim("  that pays nothing and is the normal case, so just start another one.")
+  );
+  process.stdout.write(c.dim("  waiting for an offer to clear"));
+  const deadline = Date.now() + 5 * 60 * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(3e3);
+    process.stdout.write(c.dim("."));
+    const balance = (await safeWallet(client))?.balance ?? before;
+    if (balance > before) {
+      console.log(
+        c.green(`
+\u2713 +${(balance - before).toLocaleString("en-US")} credits`) + `  \xB7  balance ${c.bold(balance.toLocaleString("en-US"))}`
+      );
+      return;
+    }
+  }
+  console.log(
+    c.yellow("\n  Nothing yet \u2014 offers can take a while to confirm, and being screened out of one")
+  );
+  console.log(c.yellow("  pays nothing and is normal. Start another, or check `clixad wallet` later."));
+}
+async function buyCmd(client, config, pack) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  const { enabled, packs } = await client.creditPacks();
+  if (!enabled) return console.log(c.yellow("Buying credits isn't available (Stripe not configured on the gateway)."));
+  if (!pack) {
+    console.log(c.bold("Credit packs:"));
+    for (const p of packs) {
+      console.log(
+        `  ${c.cyan(p.id.padEnd(9))} ${p.credits.toLocaleString("en-US").padStart(11)} credits   ${c.bold("$" + p.price_usd.toFixed(2))}`
+      );
+    }
+    console.log(c.dim("\n  buy one with: clixad buy <id>"));
+    return;
+  }
+  let checkout;
+  try {
+    checkout = await client.checkout(pack);
+  } catch (err) {
+    return console.log(c.red(err.message));
+  }
+  const before = (await safeWallet(client))?.balance ?? 0;
+  console.log(`
+  Stripe Checkout: ${c.bold(checkout.pack)} \u2014 ${checkout.credits.toLocaleString("en-US")} credits for ${c.bold("$" + checkout.price_usd.toFixed(2))}`);
+  console.log(c.dim(`  ${checkout.url}`));
+  console.log(c.dim("  Test card: 4242 4242 4242 4242 \xB7 any future expiry \xB7 any CVC \xB7 any ZIP\n"));
+  openBrowser(checkout.url);
+  process.stdout.write(c.dim("  waiting for payment to clear"));
+  const deadline = Date.now() + 5 * 60 * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(3e3);
+    process.stdout.write(c.dim("."));
+    const balance = (await safeWallet(client))?.balance ?? before;
+    if (balance > before) {
+      console.log(c.green(`
+\u2713 +${(balance - before).toLocaleString("en-US")} credits`) + `  \xB7  balance ${c.bold(String(balance))}`);
+      return;
+    }
+  }
+  console.log(c.yellow("\n  No credits yet \u2014 the webhook may be delayed. Check `clixad wallet`."));
+}
+async function ask(client, config, prompt) {
+  if (!prompt) return console.error(c.red('usage: clixad ask "your prompt"'));
+  const messages = [{ role: "user", content: prompt }];
+  await runTurn(client, config, messages);
+}
+async function printCmd(client, config, task) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  if (!task) return console.error(c.red('usage: clixad -p "describe a task"'));
+  try {
+    const res = await runAgent(client, task, {
+      model: config.model,
+      root: process.cwd(),
+      systemPrompt: collectContext(process.cwd()).systemPrompt,
+      permit: denyAll,
+      onEvent: printAgentEvent
+    });
+    console.log(
+      c.dim(`
+  [${res.creditsCharged} credits \xB7 balance ${res.balance} \xB7 ${res.steps} step(s)]`)
+    );
+  } catch (err) {
+    if (err instanceof PaywallError) {
+      console.log(c.yellow(`
+Out of credits (balance ${err.balance}, need ~${err.estimatedCost}).`));
+      console.log(
+        c.yellow(
+          `Run \`clixad earn\` to open the offerwall (+${err.grantPerAd} credits on completion) or buy credits.`
+        )
+      );
+      console.log(c.dim("  Offers you are screened out of pay nothing \u2014 that is normal, just start another."));
+    } else if (err instanceof AuthError) {
+      console.log(c.red(err.message));
+    } else {
+      console.log(c.red(`
+agent error: ${err.message}`));
+    }
+    process.exitCode = 1;
+  }
+}
+function printAgentEvent(event) {
+  switch (event.type) {
+    case "delta":
+      process.stdout.write(event.text);
+      break;
+    case "tool_call":
+      console.log(c.cyan(`
+  \u2192 ${event.name}`) + c.dim(` ${JSON.stringify(event.args).slice(0, 200)}`));
+      break;
+    case "tool_result": {
+      const preview = event.result.split("\n").slice(0, 4).join("\n    ");
+      console.log(c.dim(`    ${preview.slice(0, 400)}`));
+      break;
+    }
+    case "final":
+      process.stdout.write("\n");
+      break;
+    case "max_steps":
+      console.log(c.yellow("  (stopped: reached max steps)"));
+      break;
+  }
+}
+async function codeCmd(client, config, rest) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  const w = await safeWallet(client);
+  if (w) {
+    console.log(
+      c.dim(`  wallet: ${w.balance} credits \xB7 model ${config.model} \xB7 gateway ${config.gatewayUrl}`)
+    );
+    if (w.balance <= 0) {
+      console.log(c.yellow("  You're out of credits \u2014 run `clixad earn` first, or the agent will hit a paywall."));
+    }
+  }
+  console.log(c.dim("  launching Kimi CLI (Clixad-configured)\u2026\n"));
+  const task = rest.join(" ").trim();
+  const code = await runKimiCode(config, task || void 0);
+  if (code !== 0) process.exitCode = code;
+}
+async function repl(client, config, opts = {}) {
+  if (!config.token) {
+    console.log(c.yellow("Not logged in. Run `clixad login` first.\n"));
+    return;
+  }
+  if (opts.resume === "pick") {
+    const sessions = listSessions(void 0, 10);
+    if (!sessions.length) return console.log(c.yellow("no saved sessions yet"));
+    console.log(c.bold("Sessions:"));
+    for (const s of sessions) {
+      console.log(`  ${c.cyan(s.id)}  ${s.updated.slice(0, 16).replace("T", " ")}  ${s.title}`);
+    }
+    console.log(c.dim("\n  resume one with: clixad --resume <id>"));
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    console.log(c.yellow('Interactive mode needs a terminal. Use `clixad -p "..."` for scripted runs.'));
+    return;
+  }
+  let session;
+  if (opts.resume === "latest") {
+    session = latestSession(process.cwd());
+    if (!session) console.log(c.dim("  no previous session here \u2014 starting a new one"));
+  } else if (opts.resume) {
+    session = loadSession(opts.resume);
+    if (!session) return console.log(c.red(`no such session: ${opts.resume}`));
+  }
+  const wallet = await safeWallet(client);
+  clearScreen();
+  const { startTui: startTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+  await startTui2({ client, config, wallet, session, initialTask: opts.task });
+}
+async function runTurn(client, config, messages) {
+  try {
+    process.stdout.write(c.green("assistant ") + "");
+    const result = await client.chatStream(messages, config.model, {
+      onDelta: (chunk) => process.stdout.write(chunk)
+    });
+    process.stdout.write("\n");
+    console.log(c.dim(`  [${result.creditsCharged} credits \xB7 balance ${result.balance}]`));
+    return result;
+  } catch (err) {
+    process.stdout.write("\n");
+    if (err instanceof PaywallError) {
+      console.log(c.yellow(`Out of credits (balance ${err.balance}, need ~${err.estimatedCost}).`));
+      console.log(
+        c.yellow(`Run /earn to open the offerwall (+${err.grantPerAd} credits on completion) or buy credits.`)
+      );
+      console.log(c.dim("  Offers you are screened out of pay nothing \u2014 that is normal, just start another."));
+    } else if (err instanceof AuthError) {
+      console.log(c.red(err.message));
+    } else {
+      console.log(c.red(`error: ${err.message}`));
+    }
+    return void 0;
+  }
+}
+async function safeWallet(client) {
+  try {
+    return await client.wallet();
+  } catch {
+    return void 0;
+  }
+}
+function printHelp() {
+  console.log(`${c.bold("clixad")} \u2014 free AI coding in your terminal, funded by ads
+
+  ${c.cyan("login")} [email]      create/attach an account
+  ${c.cyan("logout")}            forget the stored token
+  ${c.cyan("whoami")}            show account + balance
+  ${c.cyan("models")}            list models with credit prices
+  ${c.cyan("model")} <id>        set default model
+  ${c.cyan("wallet")}            balance, ads today, ledger
+  ${c.cyan("earn")}              open the ad wall to earn credits
+  ${c.cyan("buy")} [pack]         list credit packs / buy one via Stripe
+  ${c.cyan("ask")} "<prompt>"    one-shot completion (no tools)
+  ${c.cyan("agent")} "<task>"    open the REPL with a task already running
+  ${c.cyan("-p")} "<task>"       headless agent run (read-only tools)
+  ${c.cyan("code")} ["<task>"]   launch the full Kimi CLI coding agent on the current dir
+  ${c.cyan("--continue")}        resume the last session in this directory
+  ${c.cyan("--resume")} [id]     list saved sessions, or resume one
+  (no command)        interactive coding REPL`);
+}
+main().catch((err) => {
+  console.error(c.red(err.message));
+  process.exitCode = 1;
+});