clixad 0.0.1-beta.14 → 0.0.1-beta.16

package/README.md

@@ -19,6 +19,10 @@ npm install -g clixad
 
 Requires Node.js >= 20.
 
+## Community
+
+Discord: <https://discord.gg/pwxPM3QyF> — bug reports and feature requests are read there.
+
 ## What it does
 
 It reads, searches and edits files and runs shell commands in the directory you start it in, asking

package/dist/clixad.mjs

@@ -101,6 +101,52 @@ function grantRangeLabel(range) {
   const n = (v) => v.toLocaleString("en-US");
   return low === high ? `${n(low)} credits on completion` : `${n(low)}\u2013${n(high)} credits on completion`;
 }
+function streakLabel(streak) {
+  if (streak.length <= 0 || streak.day <= 0) return null;
+  const n = (x) => x.toLocaleString("en-US");
+  const where = `day ${streak.day} of ${streak.length}`;
+  if (!streak.claimed) return `daily streak: ${where} \xB7 today's already counted`;
+  const tomorrow = streak.schedule[Math.min(streak.day, streak.length - 1)];
+  const next = tomorrow === void 0 ? "" : ` \xB7 tomorrow ${n(tomorrow)}`;
+  return `daily streak: ${where} \xB7 +${n(streak.credits)} credits${next}`;
+}
+function referLines(info) {
+  const n = (x) => x.toLocaleString("en-US");
+  const lines = [
+    `your code: ${info.code}`,
+    `share it: clixad login --invite ${info.code}`,
+    `you both get ${n(info.inviterCredits)} credits once they complete their first offer`
+  ];
+  if (info.invited === 0) {
+    lines.push("nobody has signed up with it yet");
+    return lines;
+  }
+  const waiting = info.invited - info.credited;
+  lines.push(
+    `${n(info.invited)} signed up \xB7 ${n(info.credited)} completed an offer \xB7 ${n(info.creditsEarned)} credits earned`
+  );
+  if (waiting > 0) {
+    lines.push(`${n(waiting)} haven't completed an offer yet \u2014 that pays nothing until they do`);
+  }
+  if (info.remaining === 0 && info.maxCredited > 0) {
+    lines.push(`you've been paid for the maximum of ${n(info.maxCredited)} referrals`);
+  }
+  return lines;
+}
+function redeemMessage(result) {
+  switch (result.status) {
+    case "redeemed":
+      return { ok: true, text: `+${result.credited.toLocaleString("en-US")} credits` };
+    case "used":
+      return { ok: false, text: "that code has already been used" };
+    case "expired":
+      return { ok: false, text: "that code has expired" };
+    case "wrong_account":
+      return { ok: false, text: "that code belongs to a different account \u2014 check who you're signed in as" };
+    default:
+      return { ok: false, text: "that isn't a code we recognise \u2014 check it for typos" };
+  }
+}
 function ledgerReasonLabel(reason) {
   return LEDGER_REASONS[reason] ?? reason.replace(/_/g, " ");
 }
@@ -195,6 +241,10 @@ var init_client = __esm({
     CHAT_ENCODED_CONTENT_TYPE = "application/vnd.clixad.chat+gzip";
     LEDGER_REASONS = {
       signup_bonus: "signup bonus",
+      login_streak: "daily streak",
+      feedback_bonus: "thanks for the feedback",
+      referral_bonus: "referral bonus",
+      redeem_code: "code redeemed",
       ad_reward: "offer reward",
       ad_screenout_bonus: "screenout bonus (didn't qualify)",
       ad_sponsor_impression: "sponsored line shown",
@@ -323,6 +373,138 @@ var init_client = __esm({
           return void 0;
         }
       }
+      /**
+       * Claim today's login-streak grant, or find out that today is already claimed.
+       *
+       * Safe to call from anywhere and as often as you like: the gateway keys it on
+       * `(account, UTC day)`, so the second call of the day credits nothing and
+       * answers with the same day number. That is what lets every surface which
+       * might be somebody's first contact today — a login, the REPL opening,
+       * `wallet` — claim without coordinating.
+       *
+       * **Never throws.** Like `sponsorConfig`, every caller is decorating something
+       * that already works: a gateway too old to have the route, a cold start, a
+       * dropped connection and an expired token all mean the same thing here, which
+       * is "say nothing about a streak". A missed grant is claimed by the next
+       * command; a session that died over one would be a real loss.
+       */
+      async claimStreak(signal) {
+        try {
+          const res = await fetch(`${this.config.gatewayUrl}/v1/streak/claim`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {}
+          });
+          if (!res.ok) return null;
+          const body = await res.json();
+          if (typeof body.day !== "number" || typeof body.credits !== "number") return null;
+          return {
+            day: body.day,
+            credits: body.credits,
+            claimed: body.claimed === true,
+            balance: typeof body.balance === "number" ? body.balance : 0,
+            schedule: Array.isArray(body.schedule) ? body.schedule : [],
+            length: typeof body.length === "number" ? body.length : 0
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Send one rating, and answer what it was paid.
+       *
+       * **Never throws**, for `claimStreak`'s reason and one of its own: this is
+       * called from a prompt that has already interrupted somebody, and the worst
+       * possible outcome is that answering it takes the session down. A gateway too
+       * old for the route, a cold start and an expired token all mean the same thing
+       * — the rating is lost, which costs the user nothing and us one data point.
+       *
+       * `null` for "nothing to say"; an outcome with `credited: 0` for "recorded,
+       * unpaid", which is what the daily ceiling looks like from here and is worth
+       * telling the user apart from a grant.
+       */
+      async sendFeedback(report, signal) {
+        try {
+          const res = await fetch(`${this.config.gatewayUrl}/v1/feedback`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {},
+            body: JSON.stringify({
+              session_id: report.session,
+              turn: report.turn,
+              rating: report.rating,
+              model: report.model,
+              prompt: report.prompt,
+              response: report.response,
+              ...report.steps === void 0 ? {} : { steps: report.steps }
+            })
+          });
+          if (!res.ok) return null;
+          const body = await res.json();
+          return {
+            recorded: body.recorded === true,
+            credited: typeof body.credited === "number" ? body.credited : 0,
+            balance: typeof body.balance === "number" ? body.balance : 0
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * This account's referral code and standing, minting the code if it has none.
+       *
+       * **This one throws**, unlike `claimStreak` and `sendFeedback`. Those two
+       * decorate something that already works and a failure costs a line of chrome;
+       * this *is* the command — `clixad refer` with nothing to print is a command
+       * that did not run, and saying so beats printing an empty summary.
+       */
+      async referral(signal) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/referrals`, {
+          headers: this.headers(),
+          ...signal ? { signal } : {}
+        });
+        if (res.status === 401) throw await authFailure(res, "referrals");
+        if (!res.ok) throw new Error(await httpFailure(res, "referrals"));
+        const body = await res.json();
+        const num = (value) => typeof value === "number" ? value : 0;
+        if (typeof body.code !== "string" || !body.code) {
+          throw new Error("the gateway did not return a referral code");
+        }
+        return {
+          code: body.code,
+          invited: num(body.invited),
+          credited: num(body.credited),
+          creditsEarned: num(body.credits_earned),
+          remaining: num(body.remaining),
+          maxCredited: num(body.max_credited),
+          inviterCredits: num(body.inviter_credits),
+          inviteeCredits: num(body.invitee_credits)
+        };
+      }
+      /**
+       * Spend a redeem code.
+       *
+       * **Throws**, like `referral` and unlike `claimStreak`: this is the command
+       * itself, and somebody who typed a code and got silence has been told nothing.
+       * A refusal is not a throw though — an expired or already-spent code answers
+       * 200 with a status, because that is an answer rather than a failure.
+       */
+      async redeem(code, signal) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/redeem`, {
+          method: "POST",
+          headers: this.headers(),
+          ...signal ? { signal } : {},
+          body: JSON.stringify({ code })
+        });
+        if (res.status === 401) throw await authFailure(res, "redeem");
+        if (!res.ok) throw new Error(await httpFailure(res, "redeem"));
+        const body = await res.json();
+        return {
+          status: body.status ?? "unknown",
+          credited: typeof body.credited === "number" ? body.credited : 0,
+          balance: typeof body.balance === "number" ? body.balance : 0
+        };
+      }
       async creditPacks() {
         const res = await fetch(`${this.config.gatewayUrl}/v1/billing/packs`);
         if (!res.ok) throw new Error(`packs failed: ${res.status}`);
@@ -604,7 +786,12 @@ var init_client = __esm({
         const calls = /* @__PURE__ */ new Map();
         for await (const evt of parseSSE(res.body)) {
           if (evt === "[DONE]") break;
-          const json = JSON.parse(evt);
+          let json;
+          try {
+            json = JSON.parse(evt);
+          } catch {
+            continue;
+          }
           const choice = json.choices?.[0];
           const delta = choice?.delta?.content;
           if (delta) {
@@ -1239,12 +1426,13 @@ function installExitHook(registry) {
     });
   }
 }
-var MAX_SHELL_BUFFER, MAX_SHELLS, ShellError, ShellRegistry, shells, hookInstalled;
+var MAX_SHELL_BUFFER, MAX_SHELLS, MAX_FINISHED_SHELLS, ShellError, ShellRegistry, shells, hookInstalled;
 var init_shells = __esm({
   "src/shells.ts"() {
     "use strict";
     MAX_SHELL_BUFFER = 2e5;
     MAX_SHELLS = 8;
+    MAX_FINISHED_SHELLS = 8;
     ShellError = class extends Error {
     };
     ShellRegistry = class {
@@ -1252,21 +1440,27 @@ var init_shells = __esm({
       seq = 0;
       /** Start a command in the background and return it before it has finished. */
       start(root, command, now = Date.now()) {
+        this.pruneFinished();
         const live = [...this.entries.values()].filter((e) => e.status === "running");
         if (live.length >= MAX_SHELLS) {
           throw new ShellError(
             `${MAX_SHELLS} background commands are already running (${live.map((e) => e.id).join(", ")}) \u2014 stop one with kill_shell before starting another`
           );
         }
-        const child = spawn2(command, {
-          cwd: root,
-          shell: true,
-          windowsHide: true,
-          detached: process.platform !== "win32",
-          // Nothing types at a background command, and leaving stdin inherited lets
-          // it steal the keystrokes meant for the REPL.
-          stdio: ["ignore", "pipe", "pipe"]
-        });
+        let child;
+        try {
+          child = spawn2(command, {
+            cwd: root,
+            shell: true,
+            windowsHide: true,
+            detached: process.platform !== "win32",
+            // Nothing types at a background command, and leaving stdin inherited
+            // lets it steal the keystrokes meant for the REPL.
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+        } catch (err) {
+          throw new ShellError(`could not start that command: ${err.message}`);
+        }
         const entry = {
           id: `bash_${++this.seq}`,
           command,
@@ -1339,10 +1533,23 @@ var init_shells = __esm({
       list(now = Date.now()) {
         return [...this.entries.values()].map((e) => snapshot(e, now));
       }
-      /** Forget a finished shell. Running ones are kept — see `killAll`. */
-      forget(id) {
-        const entry = this.entries.get(id);
-        if (entry && entry.status !== "running") this.entries.delete(id);
+      /**
+       * Forget all but the most recent `MAX_FINISHED_SHELLS` finished commands.
+       *
+       * Run when a new one starts, which is the only moment the registry grows.
+       * Running commands are never touched — those are `killAll`'s and
+       * `kill`'s — and the Map's insertion order is the start order, so "oldest"
+       * needs no timestamp.
+       *
+       * This replaces a `forget(id)` that nothing ever called: an explicit
+       * single-entry drop is only useful to a caller who knows a shell is finished
+       * with, and neither the tools nor the REPL is in a position to know that.
+       */
+      pruneFinished() {
+        const finished = [...this.entries.values()].filter((e) => e.status !== "running");
+        for (const entry of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_SHELLS))) {
+          this.entries.delete(entry.id);
+        }
       }
       /** Stop everything. Called on exit; safe to call more than once. */
       killAll() {
@@ -2189,6 +2396,64 @@ function passesThrough(err) {
   if (err instanceof PaywallError) return true;
   return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
+function fsCall(what, run) {
+  try {
+    return run();
+  } catch (err) {
+    if (passesThrough(err)) throw err;
+    const code = err.code ?? "";
+    throw new ToolError(`${what}: ${FS_REASON[code] ?? err.message}`);
+  }
+}
+function countArg(raw, fallback) {
+  const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : Number.NaN;
+  return Number.isFinite(n) ? Math.max(1, Math.floor(n)) : fallback;
+}
+function requireString(value, tool, field) {
+  const text = readString(value);
+  if (text === void 0) {
+    throw new ToolError(`${tool}: ${field} must be a string, got ${describeValue(value)}`);
+  }
+  return text;
+}
+function optionalString(value, tool, field) {
+  if (value === void 0 || value === null) return void 0;
+  return requireString(value, tool, field);
+}
+function readString(value) {
+  if (typeof value === "string") return value;
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "nothing";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "number") return "an unusable number";
+  return typeof value === "object" ? "an object" : `a ${typeof value}`;
+}
+function entryKind(entry, abs) {
+  if (entry.isDirectory()) return "dir";
+  if (entry.isFile()) return "file";
+  if (!entry.isSymbolicLink()) return "other";
+  try {
+    const stat = statSync(abs);
+    return stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other";
+  } catch {
+    return "other";
+  }
+}
+function isFilePath(abs) {
+  try {
+    return statSync(abs).isFile();
+  } catch {
+    return false;
+  }
+}
+function searchBase(ctx, path) {
+  const abs = safeResolve(ctx.root, path ?? ".");
+  if (!existsSync2(abs)) throw new ToolError(`not found: ${path ?? "."}`);
+  return abs;
+}
 function commandSignature(command) {
   return `run:${command.replace(/\s+/g, " ").trim()}`;
 }
@@ -2299,13 +2564,19 @@ async function runMcpTool(ctx, name, args) {
 }
 function execute(ctx, command, timeout) {
   return new Promise((resolvePromise) => {
-    const child = spawn4(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 child;
+    try {
+      child = spawn4(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"
+      });
+    } catch (err) {
+      return resolvePromise(`command failed to start: ${err.message}
+(no output)`);
+    }
     let out = "";
     let total = 0;
     let timedOut = false;
@@ -2352,6 +2623,10 @@ function listWorkspaceFiles(root, limit = 5e3) {
   return files.sort();
 }
 function walk(dir, root, visit) {
+  if (isFilePath(dir)) {
+    visit(dir);
+    return;
+  }
   let seen = 0;
   const stack = [dir];
   while (stack.length > 0) {
@@ -2364,12 +2639,13 @@ function walk(dir, root, visit) {
     }
     for (const entry of entries) {
       const abs = join3(current, entry.name);
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const kind = entryKind(entry, abs);
+      if (kind === "dir") {
+        if (entry.isSymbolicLink() || SKIP_DIRS.has(entry.name)) continue;
         stack.push(abs);
         continue;
       }
-      if (!entry.isFile()) continue;
+      if (kind !== "file") continue;
       if (++seen > MAX_WALK_FILES) return;
       if (!visit(abs)) return;
     }
@@ -2377,8 +2653,9 @@ function walk(dir, root, visit) {
   void root;
 }
 function globToRegExp(pattern) {
-  const p = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+  const p = requireString(pattern, "glob", "pattern").replace(/\\/g, "/").replace(/^\.\//, "");
   let re = "";
+  let depth = 0;
   for (let i = 0; i < p.length; i++) {
     const ch = p[i];
     if (ch === "*") {
@@ -2394,14 +2671,23 @@ function globToRegExp(pattern) {
         re += "[^/]*";
       }
     } else if (ch === "?") re += "[^/]";
-    else if (ch === "{") re += "(?:";
-    else if (ch === "}") re += ")";
-    else if (ch === ",") re += "|";
-    else if (".+^$()[]|\\".includes(ch)) re += "\\" + ch;
+    else if (ch === "{") {
+      re += "(?:";
+      depth++;
+    } else if (ch === "}" && depth > 0) {
+      re += ")";
+      depth--;
+    } else if (ch === "," && depth > 0) re += "|";
+    else if (".+^$()[]|\\{}".includes(ch)) re += "\\" + ch;
     else re += ch;
   }
+  re += ")".repeat(depth);
   const anchored = p.includes("/") ? `^${re}$` : `^(?:.*/)?${re}$`;
-  return new RegExp(anchored);
+  try {
+    return new RegExp(anchored);
+  } catch (err) {
+    throw new ToolError(`not a usable glob pattern: ${pattern} \u2014 ${err.message}`);
+  }
 }
 function toolSchemaFor(mode, mcpSchemas = [], available = {}) {
   const usable = (t) => t.function.name !== "web_search" || available.webSearch === true;
@@ -2416,7 +2702,7 @@ function subagentToolSchema(available = {}) {
     (t) => SUBAGENT_TOOLS.includes(t.function.name) && (t.function.name !== "web_search" || available.webSearch === true)
   );
 }
-var ToolError, PermissionDeniedError, MAX_FILE_BYTES, MAX_READ_LINES, MAX_READ_LINE_CHARS, MAX_OUTPUT_CHARS, MAX_GLOB_RESULTS, MAX_GREP_MATCHES, MAX_WALK_FILES, DEFAULT_COMMAND_TIMEOUT, MAX_IMAGE_BYTES, DEFAULT_SEARCH_RESULTS, MAX_SEARCH_RESULTS, MAX_ASK_OPTIONS, BACKGROUND_SETTLE_MS, SKIP_DIRS, TOOLS, READ_ONLY_TOOLS, EXIT_PLAN_MODE_SCHEMA, SUBAGENT_TOOLS, TOOL_SCHEMA;
+var ToolError, PermissionDeniedError, FS_REASON, MAX_FILE_BYTES, MAX_READ_LINES, MAX_READ_LINE_CHARS, MAX_OUTPUT_CHARS, MAX_GLOB_RESULTS, MAX_GREP_MATCHES, MAX_WALK_FILES, DEFAULT_COMMAND_TIMEOUT, MAX_IMAGE_BYTES, DEFAULT_SEARCH_RESULTS, MAX_SEARCH_RESULTS, MAX_ASK_OPTIONS, BACKGROUND_SETTLE_MS, SKIP_DIRS, TOOLS, READ_ONLY_TOOLS, EXIT_PLAN_MODE_SCHEMA, SUBAGENT_TOOLS, TOOL_SCHEMA;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -2436,6 +2722,19 @@ var init_tools = __esm({
         this.notice = notice;
       }
     };
+    FS_REASON = {
+      ENOTDIR: "it is a file, not a directory \u2014 use read_file",
+      EISDIR: "it is a directory, not a file \u2014 use list_dir, or edit a file inside it",
+      ENOENT: "it does not exist (a symlink pointing at nothing looks like this too)",
+      EACCES: "permission denied",
+      EPERM: "permission denied",
+      ELOOP: "the path goes through a symlink loop",
+      ENAMETOOLONG: "the path is too long",
+      EMFILE: "this process has too many files open \u2014 try again",
+      ENFILE: "the system has too many files open \u2014 try again",
+      ENOSPC: "the disk is full",
+      EROFS: "the filesystem is read-only"
+    };
     MAX_FILE_BYTES = 4e5;
     MAX_READ_LINES = 2e3;
     MAX_READ_LINE_CHARS = 2e3;
@@ -2450,16 +2749,37 @@ var init_tools = __esm({
     MAX_ASK_OPTIONS = 6;
     BACKGROUND_SETTLE_MS = 500;
     SKIP_DIRS = /* @__PURE__ */ new Set([
+      // Version control.
       ".git",
+      ".hg",
+      ".svn",
+      // Dependencies and their caches.
       "node_modules",
+      ".yarn",
+      ".pnpm-store",
+      ".venv",
+      ".tox",
+      // Build output.
       "dist",
       "build",
       "coverage",
       ".next",
+      ".nuxt",
+      ".svelte-kit",
+      ".output",
+      ".angular",
+      ".dart_tool",
+      // Tool caches.
       ".turbo",
+      ".nx",
       ".cache",
+      ".parcel-cache",
+      ".gradle",
       "__pycache__",
-      ".venv"
+      ".mypy_cache",
+      ".pytest_cache",
+      ".ruff_cache",
+      ".terraform"
     ]);
     TOOLS = {
       /**
@@ -2478,11 +2798,14 @@ var init_tools = __esm({
        * is told precisely what went wrong instead of guessing.
        */
       read_file(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path);
-        if (!existsSync2(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 bytes = readFileSync3(abs);
+        const path = requireString(args.path, "read_file", "path");
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
         const name = rel(ctx.root, abs);
+        if (fsCall(`cannot read ${name}`, () => statSync(abs)).isDirectory()) {
+          throw new ToolError(`${path} is a directory \u2014 use list_dir`);
+        }
+        const bytes = fsCall(`cannot read ${name}`, () => readFileSync3(abs));
         const image = imageType(bytes);
         if (image) return readImage(ctx, bytes, name, image);
         if (looksLikePdf(bytes)) {
@@ -2503,11 +2826,11 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
         const raw = bytes.toString("utf8");
         const all = raw.split("\n");
         const total = all.length > 1 && all[all.length - 1] === "" ? all.length - 1 : all.length;
-        const first = Math.max(1, Math.floor(args.offset ?? 1));
-        const want = Math.max(1, Math.floor(args.limit ?? MAX_READ_LINES));
+        const first = countArg(args.offset, 1);
+        const want = countArg(args.limit, MAX_READ_LINES);
         const last = Math.min(total, first + want - 1);
         if (first > total) {
-          return `${args.path} has ${total} lines; offset ${first} is past the end`;
+          return `${path} has ${total} lines; offset ${first} is past the end`;
         }
         const body = all.slice(first - 1, last).map((line2, i) => {
           const n = String(first + i).padStart(5, " ");
@@ -2523,27 +2846,35 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
         return body + note;
       },
       list_dir(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path ?? ".");
-        if (!existsSync2(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 };
-        });
+        const path = optionalString(args.path, "list_dir", "path") ?? ".";
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
+        const name = rel(ctx.root, abs);
+        if (!fsCall(`cannot list ${name}`, () => statSync(abs)).isDirectory()) {
+          throw new ToolError(`${path} is a file \u2014 use read_file`);
+        }
+        const entries = fsCall(`cannot list ${name}`, () => readdirSync(abs, { withFileTypes: true })).map(
+          (entry) => {
+            const isDir = entryKind(entry, resolve(abs, entry.name)) === "dir";
+            return { name: isDir ? `${entry.name}/` : entry.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 pattern = optionalString(args.pattern, "glob", "pattern");
+        if (!pattern) throw new ToolError("glob needs a pattern");
+        const base = searchBase(ctx, optionalString(args.path, "glob", "path"));
+        const re = globToRegExp(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}`;
+        if (hits.length === 0) return `no files match ${pattern}`;
         hits.sort();
         const more = hits.length >= MAX_GLOB_RESULTS ? `
 \u2026 [capped at ${MAX_GLOB_RESULTS}]` : "";
@@ -2551,15 +2882,17 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
       },
       /** Search file contents with a regular expression; returns path:line: text. */
       grep(ctx, args) {
-        if (!args.pattern) throw new ToolError("grep needs a pattern");
+        const pattern = optionalString(args.pattern, "grep", "pattern");
+        if (!pattern) throw new ToolError("grep needs a pattern");
         let re;
         try {
-          re = new RegExp(args.pattern);
+          re = new RegExp(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 base = searchBase(ctx, optionalString(args.path, "grep", "path"));
+        const globArg = optionalString(args.glob, "grep", "glob");
+        const filter = globArg ? globToRegExp(globArg) : void 0;
         const out = [];
         walk(base, ctx.root, (abs) => {
           const r = rel(ctx.root, abs);
@@ -2580,24 +2913,28 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
           }
           return true;
         });
-        if (out.length === 0) return `no matches for ${args.pattern}`;
+        if (out.length === 0) return `no matches for ${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 = existsSync2(abs) ? readFileSync3(abs, "utf8") : "";
-        const preview = renderDiff(before, args.content) || "(no change)";
+        const abs = safeResolve(ctx.root, requireString(args.path, "write_file", "path"));
+        const content = requireString(args.content, "write_file", "content");
+        const name = rel(ctx.root, abs);
+        const before = existsSync2(abs) ? fsCall(`cannot write ${name}`, () => readFileSync3(abs, "utf8")) : "";
+        const preview = renderDiff(before, content) || "(no change)";
         await gate(ctx, {
           tool: "write_file",
-          signature: `write:${rel(ctx.root, abs)}`,
-          summary: `${before ? "overwrite" : "create"} ${rel(ctx.root, abs)}`,
+          signature: `write:${name}`,
+          summary: `${before ? "overwrite" : "create"} ${name}`,
           preview
         });
-        mkdirSync2(dirname2(abs), { recursive: true });
-        writeFileSync2(abs, args.content, "utf8");
-        return `wrote ${args.content.length} bytes to ${rel(ctx.root, abs)}`;
+        fsCall(`cannot write ${name}`, () => {
+          mkdirSync2(dirname2(abs), { recursive: true });
+          writeFileSync2(abs, content, "utf8");
+        });
+        return `wrote ${content.length} bytes to ${name}`;
       },
       /**
        * Replace an exact snippet in a file. Preferred over write_file: it keeps the
@@ -2605,41 +2942,42 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
        * An ambiguous match is an error rather than a guess.
        */
       async edit_file(ctx, args) {
-        const abs = safeResolve(ctx.root, args.path);
-        if (!existsSync2(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 = readFileSync3(abs, "utf8");
-        const count = occurrences(before, args.old_string);
+        const path = requireString(args.path, "edit_file", "path");
+        const abs = safeResolve(ctx.root, path);
+        if (!existsSync2(abs)) throw new ToolError(`not found: ${path}`);
+        const oldString = requireString(args.old_string, "edit_file", "old_string");
+        const newString = requireString(args.new_string, "edit_file", "new_string");
+        if (oldString === newString) throw new ToolError("old_string and new_string are identical");
+        const name = rel(ctx.root, abs);
+        const before = fsCall(`cannot edit ${name}`, () => readFileSync3(abs, "utf8"));
+        const count = occurrences(before, oldString);
         if (count === 0) {
           throw new ToolError(
-            `old_string not found in ${args.path} \u2014 read the file and copy the exact text, without the line numbers read_file puts in front of each line`
+            `old_string not found in ${path} \u2014 read the file and copy the exact text, without the line numbers read_file puts in front of each line`
           );
         }
         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`
+            `old_string appears ${count} times in ${path} \u2014 add more surrounding context, or pass replace_all: true`
           );
         }
-        const after = before.split(args.old_string).join(args.new_string);
+        const after = before.split(oldString).join(newString);
         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)}`,
+          signature: `write:${name}`,
+          summary: `edit ${name}`,
           preview
         });
-        writeFileSync2(abs, after, "utf8");
-        return `edited ${rel(ctx.root, abs)} (${count > 1 ? `${count} occurrences` : "1 occurrence"})`;
+        fsCall(`cannot edit ${name}`, () => writeFileSync2(abs, after, "utf8"));
+        return `edited ${name} (${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();
+        const command = (optionalString(args.command, "run_command", "command") ?? "").trim();
         if (!command) throw new ToolError("run_command needs a command");
         const background = args.background === true;
         await gate(ctx, {
@@ -2651,7 +2989,7 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
           summary: `${background ? "run in the background" : "run"} ${command.length > 60 ? command.slice(0, 59) + "\u2026" : command}`,
           preview: command
         });
-        if (!background) return execute(ctx, command, args.timeout ?? DEFAULT_COMMAND_TIMEOUT);
+        if (!background) return execute(ctx, command, countArg(args.timeout, DEFAULT_COMMAND_TIMEOUT));
         const registry = ctx.shells ?? shells;
         let started;
         try {
@@ -2671,7 +3009,7 @@ ${first.output.trim().slice(0, 4e3)}` : "");
       /** Whatever a background command has printed since it was last read. */
       read_output(ctx, args) {
         const registry = ctx.shells ?? shells;
-        const id = (args.shell_id ?? "").trim();
+        const id = (optionalString(args.shell_id, "read_output", "shell_id") ?? "").trim();
         if (!id) {
           const running = registry.list();
           throw new ToolError(
@@ -2680,7 +3018,8 @@ ${first.output.trim().slice(0, 4e3)}` : "");
         }
         let read;
         try {
-          read = registry.read(id, args.filter ? { filter: args.filter } : {});
+          const filter = optionalString(args.filter, "read_output", "filter");
+          read = registry.read(id, filter ? { filter } : {});
         } catch (err) {
           asToolError(err);
         }
@@ -2696,7 +3035,7 @@ ${body || "(nothing new since the last read)"}`;
       },
       async kill_shell(ctx, args) {
         const registry = ctx.shells ?? shells;
-        const id = (args.shell_id ?? "").trim();
+        const id = (optionalString(args.shell_id, "kill_shell", "shell_id") ?? "").trim();
         if (!id) throw new ToolError("kill_shell needs a shell_id");
         await gate(ctx, {
           tool: "kill_shell",
@@ -2719,14 +3058,14 @@ ${body || "(nothing new since the last read)"}`;
        * a context that is billed by the token.
        */
       async web_search(ctx, args) {
-        const query = (args.query ?? "").trim();
+        const query = (optionalString(args.query, "web_search", "query") ?? "").trim();
         if (!query) throw new ToolError("web_search needs a query");
         if (!ctx.webSearch) {
           throw new ToolError(
             "web search is not available in this run \u2014 use web_fetch on a URL you already know instead"
           );
         }
-        const count = Math.max(1, Math.min(MAX_SEARCH_RESULTS, Math.floor(args.count ?? DEFAULT_SEARCH_RESULTS)));
+        const count = Math.min(MAX_SEARCH_RESULTS, countArg(args.count, DEFAULT_SEARCH_RESULTS));
         let results;
         try {
           results = await ctx.webSearch(query, { count, ...ctx.signal ? { signal: ctx.signal } : {} });
@@ -2754,9 +3093,9 @@ ${body || "(nothing new since the last read)"}`;
       async web_fetch(ctx, args) {
         let page;
         try {
-          page = await fetchPage(args.url ?? "", {
+          page = await fetchPage(optionalString(args.url, "web_fetch", "url") ?? "", {
             ...ctx.signal ? { signal: ctx.signal } : {},
-            ...typeof args.max_chars === "number" ? { maxChars: Math.max(1e3, Math.floor(args.max_chars)) } : {}
+            ...args.max_chars === void 0 ? {} : { maxChars: Math.max(1e3, countArg(args.max_chars, MAX_FILE_BYTES)) }
           });
         } catch (err) {
           networkToolError(err);
@@ -2783,8 +3122,8 @@ ${page.text}`;
        * the credits it saves do not pay for that.
        */
       async task(ctx, args) {
-        const prompt = (args.prompt ?? "").trim();
-        const description = (args.description ?? "").trim() || "subagent";
+        const prompt = (optionalString(args.prompt, "task", "prompt") ?? "").trim();
+        const description = (optionalString(args.description, "task", "description") ?? "").trim() || "subagent";
         if (!prompt) throw new ToolError("task needs a prompt describing what to find out");
         if (!ctx.spawn) {
           throw new ToolError(
@@ -2821,7 +3160,7 @@ ${page.text}`;
        * be told something that was not on the list.
        */
       async ask_user(ctx, args) {
-        const question = (args.question ?? "").trim();
+        const question = (optionalString(args.question, "ask_user", "question") ?? "").trim();
         if (!question) throw new ToolError("ask_user needs a question");
         if (!ctx.askUser) {
           throw new ToolError(
@@ -2846,7 +3185,7 @@ ${page.text}`;
        * able to grant itself write access.
        */
       async exit_plan_mode(ctx, args) {
-        const plan = (args.plan ?? "").trim();
+        const plan = (optionalString(args.plan, "exit_plan_mode", "plan") ?? "").trim();
         if (!plan) throw new ToolError("exit_plan_mode needs a plan");
         if (!ctx.approvePlan) {
           throw new ToolError(
@@ -3337,8 +3676,6 @@ var init_agent = __esm({
     "use strict";
     init_tools();
     init_mcp();
-    init_shells();
-    init_web();
     init_client();
     SUBAGENT_MAX_STEPS = 12;
     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 did and why.\n\nNot every message is a task. If the user asks a question, or asks you to say something, answer in plain text and call no tools at all. Reach for a file or a command only when the request is actually about one, and when a message is ambiguous, prefer the reading of it that changes nothing.\n\nA tool call that was refused did not happen. Never describe it as done, and do not repeat it on a later message unless the user asks for it again.\n\nReach outside the workspace when the answer is outside it: web_search for current documentation, releases and error messages, then web_fetch to read the page. Do not guess at an API you could look up.\n\nStart anything that does not exit on its own \u2014 dev servers, watchers, tailed logs \u2014 with run_command background: true, and read it with read_output. A foreground command is killed after its timeout.\n\nWhen finding something out means opening many files, give it to task instead: the sub-agent reads them in its own context and reports back, which keeps this conversation short. Use todo_write for work with several distinct steps, and keep it current as you go.";
@@ -4297,6 +4634,15 @@ var init_commands = __esm({
       // forms, surveys and app trials, and describing the top-up as a video costs
       // the user the one expectation that makes a screenout make sense.
       { name: "earn", desc: "open the offer wall to earn credits" },
+      // Deliberately *no* `args`, for /login's reason: an arg hint makes enter
+      // complete the command instead of running it, and printing the code is the
+      // whole command.
+      { name: "refer", desc: "your invite code, and what it has earned" },
+      // This one *does* carry an `args` hint, unlike /refer and /login: the code is
+      // the whole command, and `/redeem` on its own has nothing to do — so enter
+      // completing to "/redeem " is the helpful outcome rather than the surprising
+      // one.
+      { name: "redeem", args: "<code>", desc: "spend a code you were given" },
       // Reachable from inside the REPL because that is where the 401 is printed.
       // "Run `clixad login` first" is not a runnable instruction at this prompt —
       // anything without a leading slash is a prompt, so it went to the model and
@@ -4771,7 +5117,7 @@ function useTerminalSize() {
   }, [stdout]);
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
-function App({ client, config, wallet, session, initialTask, sponsorServe }) {
+function App({ client, config, wallet, streak, session, initialTask, sponsorServe }) {
   const { exit } = useApp();
   const { stdout, write: writeToStdout } = useStdout();
   const idRef = useRef(1);
@@ -4831,7 +5177,9 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
   const busyAbortRef = useRef(null);
   const filesRef = useRef(null);
   const ctrlCRef = useRef(0);
-  const sessionRef = useRef(session ?? { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() });
+  const sessionRef = useRef(
+    session ?? { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() }
+  );
   const runStartedAtRef = useRef(Date.now());
   const contextRef = useRef(collectContext(root));
   const catalogRef = useRef([]);
@@ -4844,6 +5192,8 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
   const pendingTaskRef = useRef(null);
   const mcpRef = useRef(McpHub.empty());
   const todosRef = useRef(new TodoList());
+  const lastTurnRef = useRef(null);
+  const turnCountRef = useRef(config.turns ?? 0);
   const deltaBufRef = useRef("");
   const deltaTimerRef = useRef(null);
   const sponsorRef = useRef(sponsorSource());
@@ -4923,6 +5273,8 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
     client.onNotice = (text2) => push({ kind: "notice", tone: "warn", text: text2 });
     const files = contextRef.current.files;
     if (files.length) push({ kind: "notice", text: `  context: ${files.join(", ")}` });
+    const streakLine = streak && streak.claimed ? streakLabel(streak) : null;
+    if (streakLine) push({ kind: "notice", tone: "good", text: `  ${streakLine}` });
     if (session?.messages.length) {
       push({ kind: "notice", text: `  resumed session ${session.id} (${session.messages.length} messages)` });
     }
@@ -5185,16 +5537,14 @@ ${NO_SEARCH_INSTRUCTION}`),
         });
         const next = result.messages.slice(1);
         setMessages(next);
+        sessionRef.current.title ??= (task.split("\n")[0] || task).slice(0, 80);
         saveSession({
           id: sessionRef.current.id,
           started: sessionRef.current.started,
           updated: (/* @__PURE__ */ new Date()).toISOString(),
           cwd: root,
           model,
-          // The first line only: an `@path` message carries the whole file after
-          // a blank line, and a session titled with a file's contents is not a
-          // title. What the user typed is always the first line.
-          title: (session?.title || task.split("\n")[0] || task).slice(0, 80),
+          title: sessionRef.current.title,
           messages: next
         });
         if (result.stopped === "aborted") {
@@ -5209,6 +5559,16 @@ ${NO_SEARCH_INSTRUCTION}`),
             text: result.content,
             meta: `[${result.creditsCharged} credits \xB7 balance ${result.balance.toLocaleString("en-US")}]`
           });
+          lastTurnRef.current = {
+            turn: turnCountRef.current,
+            model,
+            prompt: task,
+            response: result.content,
+            steps: result.steps
+          };
+          turnCountRef.current += 1;
+          config.turns = turnCountRef.current;
+          saveConfig(config);
         }
       } catch (err) {
         if (err instanceof PaywallError) {
@@ -5248,8 +5608,7 @@ ${NO_SEARCH_INSTRUCTION}`),
       nextSponsor,
       permit,
       push,
-      root,
-      session?.title
+      root
     ]
   );
   const stopCurrent = useCallback(() => {
@@ -5304,6 +5663,10 @@ ${NO_SEARCH_INSTRUCTION}`),
               tone: "good",
               text: `  signed in as ${account.login ?? account.email ?? "you"} \xB7 balance ${account.balance.toLocaleString("en-US")} credits` + (account.created ? " (signup bonus)" : "")
             });
+            const claimed = await client.claimStreak(signal);
+            const line2 = claimed?.claimed ? streakLabel(claimed) : null;
+            if (claimed?.claimed) setBalance(claimed.balance);
+            if (line2) push({ kind: "notice", tone: "good", text: `  ${line2}` });
             return;
           }
           case "closed":
@@ -5395,6 +5758,7 @@ ${NO_SEARCH_INSTRUCTION}`),
           expandedRef.current = /* @__PURE__ */ new Set();
           heightCacheRef.current = /* @__PURE__ */ new Map();
           todosRef.current = new TodoList();
+          lastTurnRef.current = null;
           sessionRef.current = { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() };
           writeToStdout("\x1B[2J\x1B[3J\x1B[H");
           push({ kind: "notice", text: "  cleared \u2014 new session, empty context" });
@@ -5481,16 +5845,19 @@ ${NO_SEARCH_INSTRUCTION}`),
           return;
         case "wallet":
           await runBusy(LOADING, async (signal) => {
+            const streakNow = await client.claimStreak(signal);
             const w = await client.wallet(signal);
             setBalance(w.balance);
             const reversals = w.ledger.filter((e) => e.reason === "ad_reversal");
             const reversed = reversals.reduce((sum, e) => sum + Math.abs(e.delta), 0);
             const screenouts = w.screenouts_today ?? 0;
             const screenoutCredits = w.screenout_credits_today ?? 0;
+            const streakLine = streakNow && streakLabel(streakNow);
             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` + (screenouts ? `
-  plus ${screenoutCredits.toLocaleString("en-US")} credits from ${screenouts} screenout bonus${screenouts === 1 ? "" : "es"} \u2014 attempts that didn't qualify, which CPX pays a little for anyway.` : "") + (reversals.length ? `
+  plus ${screenoutCredits.toLocaleString("en-US")} credits from ${screenouts} screenout bonus${screenouts === 1 ? "" : "es"} \u2014 attempts that didn't qualify, which CPX pays a little for anyway.` : "") + (streakLine ? `
+  ${streakLine}` : "") + (reversals.length ? `
   recently: ${reversed.toLocaleString("en-US")} credits from ${reversals.length} offer${reversals.length === 1 ? "" : "s"} were reversed by the provider. Run \`clixad wallet\` for the full ledger.` : "")
             });
           });
@@ -5515,7 +5882,7 @@ ${NO_SEARCH_INSTRUCTION}`),
               return;
             }
             setMessages(found.messages);
-            sessionRef.current = { id: found.id, started: found.started };
+            sessionRef.current = { id: found.id, started: found.started, title: found.title };
             push({
               kind: "notice",
               tone: "good",
@@ -5598,6 +5965,32 @@ ${NO_SEARCH_INSTRUCTION}`),
         case "earn":
           await runAdWall();
           return;
+        // Through `runBusy` like every other gateway call: the free instance can
+        // cold-start for the better part of a minute, and the box says "esc to
+        // stop" whenever it is locked.
+        case "refer":
+          await runBusy(LOADING, async (signal) => {
+            const info = await client.referral(signal);
+            push({ kind: "notice", text: referLines(info).map((line3) => `  ${line3}`).join("\n") });
+          });
+          return;
+        case "redeem": {
+          if (!arg) {
+            push({ kind: "notice", tone: "warn", text: "  usage: /redeem <code>" });
+            return;
+          }
+          await runBusy(LOADING, async (signal) => {
+            const result = await client.redeem(arg, signal);
+            const { ok, text: text2 } = redeemMessage(result);
+            if (ok) setBalance(result.balance);
+            push({
+              kind: "notice",
+              tone: ok ? "good" : "warn",
+              text: ok ? `  ${text2} \xB7 balance ${result.balance.toLocaleString("en-US")}` : `  ${text2}`
+            });
+          });
+          return;
+        }
         case "login":
           await runLogin(arg);
           return;
@@ -5665,14 +6058,58 @@ ${output}` }
     },
     [push, root, runCommand, runShell, runTurn2]
   );
+  const askFeedback = useCallback(async () => {
+    const turn = lastTurnRef.current;
+    if (!turn) return;
+    lastTurnRef.current = null;
+    const amount = wallet?.rewards?.feedback_credits;
+    const pay = amount ? `Both answers pay ${amount.toLocaleString("en-US")} credits` : "Both answers pay the same";
+    const choice = await new Promise((resolve2) => {
+      setPickerSel(0);
+      setPicker({
+        title: "Was that last answer any good?",
+        subtitle: `${pay} \xB7 we keep that exchange to test against \xB7 esc skips`,
+        items: [
+          { value: "up", label: "yes \u2014 that worked", hint: "" },
+          { value: "down", label: "no \u2014 that missed", hint: "" },
+          { value: "skip", label: "skip", hint: "nothing is sent, nothing is stored" }
+        ],
+        onPick: (item) => resolve2(item.value),
+        // Esc and "skip" are the same outcome and must stay that way: a skip
+        // that cost something is a prompt people stop reading.
+        onCancel: () => resolve2(null)
+      });
+    });
+    if (choice !== "up" && choice !== "down") return;
+    await runBusy(SENDING_FEEDBACK, async (signal) => {
+      const outcome = await client.sendFeedback(
+        { ...turn, session: sessionRef.current.id, rating: choice },
+        signal
+      );
+      if (!outcome) return;
+      if (outcome.credited > 0) setBalance(outcome.balance);
+      push({
+        kind: "notice",
+        tone: "good",
+        text: outcome.credited > 0 ? `  thanks \u2014 +${outcome.credited.toLocaleString("en-US")} credits` : (
+          // Recorded and unpaid: the daily ceiling, or a turn already rated.
+          // Worth saying, because the offer of credits was made a moment ago.
+          "  thanks \u2014 noted (today's feedback credits are already in)"
+        )
+      });
+    });
+  }, [client, push, runBusy, wallet]);
   const runSerially = useCallback(
     async (line2) => {
       await dispatchLine(line2);
       for (let next = dequeue(); next !== void 0; next = dequeue()) {
         await dispatchLine(next);
       }
+      if (lastTurnRef.current && turnCountRef.current % FEEDBACK_TURN_INTERVAL === 0) {
+        await askFeedback();
+      }
     },
-    [dequeue, dispatchLine]
+    [askFeedback, dequeue, dispatchLine]
   );
   const submit = useCallback(
     async (raw) => {
@@ -5722,9 +6159,27 @@ ${output}` }
     setEditor((state) => insert(state, text2));
     setHistIdx(-1);
   });
+  const dismissModals = useCallback(() => {
+    if (plan) {
+      setPlan(null);
+      plan.resolve("keepPlanning");
+    }
+    if (ask2) {
+      setAsk(null);
+      ask2.resolve("deny");
+    }
+    if (picker) {
+      const cancel = picker.onCancel;
+      setPicker(null);
+      cancel?.();
+    }
+  }, [ask2, picker, plan]);
   useInput((ch, key) => {
     if (key.ctrl && ch === "c") {
-      if (busy) return stopCurrent();
+      if (busy) {
+        dismissModals();
+        return stopCurrent();
+      }
       if (!isEmpty(editor)) return setEditor(EMPTY);
       if (Date.now() - ctrlCRef.current < 2e3) return exit();
       ctrlCRef.current = Date.now();
@@ -6154,7 +6609,7 @@ function tailLines(text, max) {
   const lines = text.split("\n");
   return lines.length <= max ? text : lines.slice(-max).join("\n");
 }
-var WORKING, WAITING_FOR_REWARD, LOADING, COMPACTING, SIGNING_IN, RUNNING, NOT_SIGNED_IN, LIVE_OUTPUT_LINES, COMMITTED_OUTPUT_LINES, DELTA_FLUSH_MS, MAX_INPUT_ROWS, MAX_PICKER_ROWS, MAX_QUEUE_ROWS, QUEUE_MARKER, PICKER_CURRENT, MIN_PICKER_LABEL_COLS, PICKER_CHROME, PICKER_CHROME_COMPACT, ASK_CHROME, PLAN_CHROME, ASK_HINT, PLAN_HINT, EXPAND_MAX_LINES, FALLBACK_ROWS, FALLBACK_COLS, CONTEXT_NOTICE_AT, KEEP_ALWAYS;
+var WORKING, WAITING_FOR_REWARD, LOADING, COMPACTING, SIGNING_IN, RUNNING, SENDING_FEEDBACK, FEEDBACK_TURN_INTERVAL, NOT_SIGNED_IN, LIVE_OUTPUT_LINES, COMMITTED_OUTPUT_LINES, DELTA_FLUSH_MS, MAX_INPUT_ROWS, MAX_PICKER_ROWS, MAX_QUEUE_ROWS, QUEUE_MARKER, PICKER_CURRENT, MIN_PICKER_LABEL_COLS, PICKER_CHROME, PICKER_CHROME_COMPACT, ASK_CHROME, PLAN_CHROME, ASK_HINT, PLAN_HINT, EXPAND_MAX_LINES, FALLBACK_ROWS, FALLBACK_COLS, CONTEXT_NOTICE_AT, KEEP_ALWAYS;
 var init_app = __esm({
   "src/tui/app.tsx"() {
     "use strict";
@@ -6191,6 +6646,8 @@ var init_app = __esm({
     COMPACTING = "compacting\u2026";
     SIGNING_IN = "signing in\u2026";
     RUNNING = "running\u2026";
+    SENDING_FEEDBACK = "sending\u2026";
+    FEEDBACK_TURN_INTERVAL = 50;
     NOT_SIGNED_IN = "  Not signed in, or the stored token isn't valid for this gateway.\n  Run /login to sign in.";
     LIVE_OUTPUT_LINES = 5;
     COMMITTED_OUTPUT_LINES = 4;
@@ -6313,6 +6770,10 @@ async function main() {
       return showWallet(client);
     case "earn":
       return earn(client, config);
+    case "refer":
+      return refer(client, config);
+    case "redeem":
+      return redeem(client, config, rest[0]);
     case "buy":
       return buyCmd(client, config, rest[0]);
     case "ask":
@@ -6374,6 +6835,7 @@ async function login(client, config, args) {
 \u2713 logged in as ${who}`) + suffix);
       const bonus = account.created ? c.dim(account.signupBonus === void 0 ? " (signup bonus)" : ` (signup bonus ${credits(account.signupBonus)})`) : "";
       console.log(`  balance: ${c.bold(credits(account.balance))} credits${bonus}`);
+      await showStreak(client);
       console.log(c.dim(`  token stored in ${configPath()}`));
       return;
     }
@@ -6419,6 +6881,7 @@ function logout(config) {
   delete config.token;
   delete config.userId;
   delete config.email;
+  delete config.login;
   saveConfig(config);
   console.log(c.green("\u2713 logged out"));
 }
@@ -6457,9 +6920,12 @@ async function setModel(client, config, model) {
   console.log(c.green(`\u2713 model set to ${model}`));
 }
 async function showWallet(client) {
+  const streak = await client.claimStreak();
   const w = await client.wallet();
   console.log(`balance: ${c.bold(w.balance.toLocaleString("en-US"))} credits`);
   console.log(`${earnedToday(w)}  \xB7  offers pay ${grantRangeLabel(w.grant_per_ad_range)}`);
+  const line2 = streak && streakLabel(streak);
+  if (line2) console.log(streak.claimed ? c.green(line2) : c.dim(line2));
   if (w.ledger.length) {
     console.log(c.dim("recent:"));
     const label = (e) => ledgerReasonLabel(e.reason);
@@ -6506,6 +6972,40 @@ async function earn(client, config) {
   );
   console.log(c.yellow("  pays nothing and is normal. Start another, or check `clixad wallet` later."));
 }
+async function refer(client, config) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  let info;
+  try {
+    info = await client.referral();
+  } catch (err) {
+    console.error(c.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+  const [code, share, deal, ...rest] = referLines(info);
+  console.log(`
+  ${c.bold(code)}`);
+  console.log(`  ${c.cyan(share)}`);
+  console.log(c.dim(`  ${deal}`));
+  for (const line2 of rest) console.log(c.dim(`  ${line2}`));
+  console.log("");
+}
+async function redeem(client, config, code) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  if (!code) return console.error(c.red("usage: clixad redeem <code>"));
+  let result;
+  try {
+    result = await client.redeem(code);
+  } catch (err) {
+    console.error(c.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+  const { ok, text } = redeemMessage(result);
+  if (!ok) return console.log(c.yellow(`  ${text}`));
+  console.log(c.green(`
+\u2713 ${text}`) + `  \xB7  balance ${c.bold(credits(result.balance))}`);
+}
 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();
@@ -6672,10 +7172,11 @@ async function repl(client, config, opts = {}) {
     session = loadSession(opts.resume);
     if (!session) return console.log(c.red(`no such session: ${opts.resume}`));
   }
+  const streak = await client.claimStreak();
   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 });
+  await startTui2({ client, config, wallet, streak, session, initialTask: opts.task });
 }
 async function runTurn(client, config, messages) {
   try {
@@ -6702,6 +7203,13 @@ async function runTurn(client, config, messages) {
     return void 0;
   }
 }
+async function showStreak(client) {
+  const streak = await client.claimStreak();
+  const line2 = streak && streakLabel(streak);
+  if (!line2) return streak;
+  console.log(streak.claimed ? c.green(`  ${line2}`) : c.dim(`  ${line2}`));
+  return streak;
+}
 async function safeWallet(client) {
   try {
     return await client.wallet();
@@ -6719,6 +7227,8 @@ function printHelp() {
   ${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("refer")}             your invite code, and what it has earned
+  ${c.cyan("redeem")} <code>     spend a code you were given
   ${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
@@ -6728,7 +7238,9 @@ function printHelp() {
   ${c.cyan("--resume")} [id]     list saved sessions, or resume one
   ${c.cyan("--version")}         print the version and exit
   (no command)        interactive coding REPL ${c.dim("(signs you in if needed)")}
-  "<task>"            same as ${c.cyan("agent")} \u2014 anything that is not a command is a task`);
+  "<task>"            same as ${c.cyan("agent")} \u2014 anything that is not a command is a task
+
+  ${c.dim("Discord: https://discord.gg/pwxPM3QyF \u2014 bugs and feature requests are read there")}`);
 }
 main().catch((err) => {
   console.error(c.red(err.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.14",
+  "version": "0.0.1-beta.16",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",