nexrall-code 0.5.126 → 0.5.127

package/dist/index.js

@@ -105415,6 +105415,490 @@ var require_modePolicy = __commonJS({
   }
 });
 
+// ../../../../../Users/henry/Documents/nexrall-code/packages/core/dist/permissions/destructiveTokens.js
+var require_destructiveTokens = __commonJS({
+  "../../../../../Users/henry/Documents/nexrall-code/packages/core/dist/permissions/destructiveTokens.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tokenize = tokenize3;
+    exports2.classifyTokens = classifyTokens;
+    var hit = (category, reason) => ({ category, reason });
+    function tokenize3(src) {
+      const cmds = [];
+      let cur = [];
+      let word = "";
+      let has2 = false;
+      let q = null;
+      const pushWord = () => {
+        if (has2)
+          cur.push(word);
+        word = "";
+        has2 = false;
+      };
+      const pushCmd = () => {
+        pushWord();
+        if (cur.length)
+          cmds.push(cur);
+        cur = [];
+      };
+      for (let i2 = 0; i2 < src.length; i2++) {
+        const ch = src[i2];
+        if (q === "'") {
+          if (ch === "'")
+            q = null;
+          else
+            word += ch;
+          continue;
+        }
+        if (q === '"') {
+          if (ch === "\\" && i2 + 1 < src.length) {
+            word += src[++i2];
+            continue;
+          }
+          if (ch === '"') {
+            q = null;
+            continue;
+          }
+          word += ch;
+          continue;
+        }
+        if (ch === "'" || ch === '"') {
+          q = ch;
+          has2 = true;
+          continue;
+        }
+        if (ch === "\\") {
+          if (i2 + 1 < src.length) {
+            word += src[++i2];
+            has2 = true;
+          }
+          continue;
+        }
+        if (ch === ";" || ch === "&" || ch === "|" || ch === "\n" || ch === "(" || ch === ")" || ch === "`") {
+          pushCmd();
+          continue;
+        }
+        if (ch === " " || ch === "	") {
+          pushWord();
+          continue;
+        }
+        word += ch;
+        has2 = true;
+      }
+      pushCmd();
+      return cmds;
+    }
+    var ENV_ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+    var CONTROL_WORDS = /* @__PURE__ */ new Set(["{", "}", "!", "if", "then", "else", "elif", "do", "while", "until", "fi", "done"]);
+    var SHELLS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "ksh"]);
+    var base = (w) => {
+      const b = w.includes("/") ? w.slice(w.lastIndexOf("/") + 1) : w;
+      return b;
+    };
+    function dropOpts(args, withArg = /* @__PURE__ */ new Set()) {
+      let i2 = 0;
+      while (i2 < args.length && args[i2].startsWith("-") && args[i2] !== "--") {
+        i2 += withArg.has(args[i2]) ? 2 : 1;
+      }
+      if (args[i2] === "--")
+        i2++;
+      return args.slice(i2);
+    }
+    function has(args, long, short) {
+      return args.some((a) => long !== null && (a === long || a.startsWith(long + "=")) || short !== null && /^-[A-Za-z]+$/.test(a) && a.includes(short));
+    }
+    var BROAD = /* @__PURE__ */ new Set([".", "./", "*", "./*", ":/", ":/", "..", "../", "/", "~", "~/", "$HOME", "${HOME}", ".*"]);
+    var DISPOSABLE = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      ".svelte-kit",
+      ".turbo",
+      ".cache",
+      ".parcel-cache",
+      "coverage",
+      ".nyc_output",
+      "target",
+      "__pycache__",
+      ".pytest_cache",
+      ".mypy_cache",
+      ".ruff_cache",
+      ".tox",
+      "venv",
+      ".venv",
+      ".gradle",
+      ".dart_tool",
+      "tmp",
+      ".tmp",
+      ".vite",
+      ".angular",
+      ".expo",
+      "DerivedData"
+    ]);
+    var SCRATCH_PREFIXES = ["/tmp/", "/private/tmp/", "/var/folders/", "/private/var/folders/"];
+    function isDisposableTarget(raw) {
+      let t2 = raw;
+      if (t2 === "")
+        return false;
+      if (/[$~`]/.test(t2) || t2.includes(".."))
+        return false;
+      if (t2.startsWith("/"))
+        return SCRATCH_PREFIXES.some((p) => t2.startsWith(p) && t2.length > p.length);
+      t2 = t2.replace(/^(?:\.\/)+/, "").replace(/\/+$/, "");
+      if (t2 === "" || t2 === ".")
+        return false;
+      const segs = t2.split("/").filter(Boolean);
+      if (segs.length === 0)
+        return false;
+      return DISPOSABLE.has(segs[0]) || DISPOSABLE.has(segs[segs.length - 1]);
+    }
+    function checkGit(argsIn) {
+      let i2 = 0;
+      while (i2 < argsIn.length && argsIn[i2].startsWith("-")) {
+        const a = argsIn[i2];
+        i2 += ["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path"].includes(a) ? 2 : 1;
+      }
+      const sub = argsIn[i2];
+      const args = argsIn.slice(i2 + 1);
+      const operands = args.filter((a) => !a.startsWith("-"));
+      switch (sub) {
+        case "push": {
+          if (has(args, "--force", "f") || operands.some((a) => a.startsWith("+"))) {
+            return hit("git-history", "force-pushes (can overwrite/destroy remote history)");
+          }
+          if (has(args, "--delete", "d") || operands.some((a) => a.startsWith(":"))) {
+            return hit("git-history", "deletes a remote branch or tag");
+          }
+          if (has(args, "--mirror", null)) {
+            return hit("git-history", "mirror-pushes (overwrites and deletes remote refs to match local)");
+          }
+          return null;
+        }
+        case "reset":
+          if (has(args, "--hard", null) || has(args, "--keep", null) || has(args, "--merge", null)) {
+            return hit("git-history", "hard-resets the working tree (discards uncommitted work)");
+          }
+          return null;
+        case "clean":
+          if (has(args, "--force", "f") && !has(args, "--dry-run", "n")) {
+            return hit("git-history", "deletes untracked files (git clean)");
+          }
+          return null;
+        case "branch":
+          if (args.some((a) => /^-[A-Za-z]*D/.test(a)) || has(args, "--delete", "d") && has(args, "--force", "f")) {
+            return hit("git-history", "force-deletes a git branch");
+          }
+          return null;
+        case "checkout":
+          if (has(args, "--force", "f"))
+            return hit("git-history", "git checkout --force discards local changes");
+          if (args.some((a) => BROAD.has(a)))
+            return hit("git-history", "discards every uncommitted change in the working tree");
+          return null;
+        case "restore": {
+          const stagedOnly = has(args, "--staged", "S") && !has(args, "--worktree", "W");
+          if (!stagedOnly && args.some((a) => BROAD.has(a))) {
+            return hit("git-history", "discards every uncommitted change in the working tree");
+          }
+          return null;
+        }
+        case "stash":
+          if (args[0] === "drop" || args[0] === "clear")
+            return hit("git-history", "drops stashed work (not recoverable without the commit hash)");
+          return null;
+        case "update-ref":
+          if (has(args, "-d", "d") || has(args, "--delete", null))
+            return hit("git-history", "deletes a git ref");
+          return null;
+        case "reflog":
+          if (args[0] === "delete" || args[0] === "expire")
+            return hit("git-history", "reflog expire / gc prune (permanently drops recoverable commits)");
+          return null;
+        case "gc":
+          if (args.some((a) => /^--prune=(?:now|all)$/.test(a)))
+            return hit("git-history", "reflog expire / gc prune (permanently drops recoverable commits)");
+          return null;
+        case "worktree":
+          if (args[0] === "remove" && has(args, "--force", "f"))
+            return hit("git-history", "force-removes a worktree (discards its uncommitted work)");
+          return null;
+        case "filter-branch":
+        case "filter-repo":
+          return hit("git-history", "rewrites git history (filter-branch/filter-repo)");
+        case "rm":
+          if (operands.some((a) => BROAD.has(a))) {
+            return hit("git-history", "removes every tracked file from the working tree and index");
+          }
+          return null;
+        default:
+          return null;
+      }
+    }
+    function checkRm(args) {
+      const targets = [];
+      let recursive = false;
+      let endOpts = false;
+      for (const a of args) {
+        if (!endOpts && a === "--") {
+          endOpts = true;
+          continue;
+        }
+        if (!endOpts && a.startsWith("-")) {
+          if (a === "--recursive" || /^-[A-Za-z]*[rR]/.test(a))
+            recursive = true;
+          continue;
+        }
+        targets.push(a);
+      }
+      if (targets.some((t2) => BROAD.has(t2)))
+        return hit("filesystem", "deletes the current directory, home, or everything matching a bare glob");
+      if (recursive && targets.some((t2) => !isDisposableTarget(t2))) {
+        return hit("filesystem", "recursively deletes files or directories that are not a known build artefact");
+      }
+      return null;
+    }
+    function checkFind(args) {
+      if (args.includes("-delete"))
+        return hit("filesystem", "find -delete removes every match");
+      for (let i2 = 0; i2 < args.length - 1; i2++) {
+        if ((args[i2] === "-exec" || args[i2] === "-execdir" || args[i2] === "-ok") && ["rm", "shred", "unlink"].includes(base(args[i2 + 1]))) {
+          return hit("filesystem", "find -exec rm removes every match");
+        }
+      }
+      return null;
+    }
+    function judge(bin, args) {
+      switch (bin) {
+        case "git":
+          return checkGit(args);
+        case "rm":
+        case "unlink":
+          return checkRm(args);
+        case "find":
+          return checkFind(args);
+        case "rsync":
+          if (args.some((a) => a === "--del" || /^--delete(?:-[a-z]+)?$/.test(a)))
+            return hit("filesystem", "rsync --delete removes destination files that are absent from the source");
+          return null;
+        case "truncate":
+          return hit("filesystem", "truncate cuts a file (contents lost)");
+        case "shred":
+          return hit("filesystem", "shred irrecoverably overwrites a file");
+        case "dd":
+          if (args.some((a) => /^of=\/dev\//.test(a)))
+            return hit("filesystem", "dd writing to a device (overwrites the disk)");
+          return null;
+        case "diskutil":
+          if (/^(?:erase|secureErase|zeroDisk|randomDisk|partitionDisk|reformat)/i.test(args[0] ?? ""))
+            return hit("filesystem", "diskutil erases or repartitions a disk");
+          return null;
+        case "chmod": {
+          if (!has(args, "--recursive", "R"))
+            return null;
+          const operands = args.filter((a) => !a.startsWith("-"));
+          if (operands.slice(1).some((t2) => BROAD.has(t2)))
+            return hit("filesystem", "recursive chmod over the current directory / home / root");
+          return null;
+        }
+        case "terraform":
+        case "tofu":
+        case "terragrunt":
+          if (args.includes("destroy") || args.includes("apply") && (args.includes("-destroy") || args.includes("-auto-approve"))) {
+            return hit("infra", "destroys or applies Terraform-managed infrastructure without a plan review");
+          }
+          return null;
+        case "kubectl":
+        case "oc": {
+          const a = dropOpts(args, /* @__PURE__ */ new Set(["-n", "--namespace", "--context", "--cluster", "--kubeconfig", "-s", "--server", "--user"]));
+          if (a[0] === "delete")
+            return hit("infra", "deletes Kubernetes resources");
+          if (a[0] === "drain")
+            return hit("infra", "drains a node (evicts every pod)");
+          if (a[0] === "replace" && has(a, "--force", null))
+            return hit("infra", "kubectl replace --force deletes and recreates the resource");
+          return null;
+        }
+        case "helm": {
+          const a = dropOpts(args, /* @__PURE__ */ new Set(["-n", "--namespace", "--kube-context", "--kubeconfig"]));
+          if (a[0] === "uninstall" || a[0] === "delete")
+            return hit("infra", "helm uninstall / delete (removes a release)");
+          return null;
+        }
+        case "aws":
+          if (args[0] === "s3" && args[1] === "sync" && has(args, "--delete", null))
+            return hit("cloud", "aws s3 sync --delete removes bucket objects missing locally");
+          return null;
+        case "vercel":
+          if (args[0] === "remove" || args[0] === "rm")
+            return hit("cloud", "removes a Vercel project or deployment");
+          return null;
+        case "fly":
+        case "flyctl":
+          if (args.includes("destroy"))
+            return hit("cloud", "destroys a Fly.io app, volume or machine");
+          return null;
+        case "heroku":
+          if (args.some((a) => /:destroy$/.test(a) || a === "pg:reset"))
+            return hit("cloud", "destroys a Heroku app or resets its database");
+          return null;
+        case "supabase":
+          if (args[0] === "db" && args[1] === "reset" || args[0] === "projects" && args[1] === "delete")
+            return hit("cloud", "resets a Supabase database or deletes a project");
+          return null;
+        case "firebase":
+          if (args.some((a) => /:delete$/.test(a)))
+            return hit("cloud", "deletes Firebase data or a project");
+          return null;
+        case "netlify":
+          if (args.some((a) => /:delete$/.test(a)))
+            return hit("cloud", "deletes a Netlify site");
+          return null;
+        case "npm":
+        case "pnpm":
+        case "yarn":
+          if (args[0] === "unpublish")
+            return hit("publish", "unpublishes a package version");
+          if (args[0] === "dist-tag" && (args[1] === "rm" || args[1] === "remove"))
+            return hit("publish", "removes an npm dist-tag (can break `npm i pkg@latest`)");
+          return null;
+        case "gh": {
+          if ((args[0] === "repo" || args[0] === "release") && args[1] === "delete")
+            return hit("cloud", "deletes a GitHub repository or release");
+          if (args[0] === "api") {
+            const m2 = args.findIndex((a) => a === "-X" || a === "--method");
+            const inline = args.find((a) => /^(?:-X|--method=)DELETE$/i.test(a));
+            if (m2 >= 0 && /^delete$/i.test(args[m2 + 1] ?? "") || inline)
+              return hit("cloud", "sends an HTTP DELETE to the GitHub API");
+          }
+          return null;
+        }
+        case "docker":
+        case "docker-compose":
+        case "podman": {
+          const a = bin === "docker-compose" ? ["compose", ...args] : dropOpts(args, /* @__PURE__ */ new Set(["-H", "--host", "--context", "-c"]));
+          const verb = a[0] === "container" ? a[1] : a[0];
+          const rest = a.slice(a[0] === "container" ? 2 : 1);
+          if (verb === "rm" && has(rest, "--force", "f") && rest.some((x2) => x2.startsWith("$")))
+            return hit("container", "force-removes many containers at once");
+          if (a[0] === "compose" && rest.includes("down") && has(rest, "--volumes", "v"))
+            return hit("container", "docker compose down with -v (deletes named volumes)");
+          return null;
+        }
+        case "dropdb":
+        case "dropuser":
+          return hit("database", "drops a Postgres database or role");
+        default:
+          if (bin.startsWith("mkfs"))
+            return hit("filesystem", "mkfs formats a filesystem (destroys its contents)");
+          return null;
+      }
+    }
+    var DB_BINS = /* @__PURE__ */ new Set([
+      "psql",
+      "mysql",
+      "mariadb",
+      "mongo",
+      "mongosh",
+      "sqlite3",
+      "cockroach",
+      "clickhouse-client",
+      "pgcli",
+      "mycli",
+      "usql",
+      "sqlcmd",
+      "redis-cli"
+    ]);
+    function classifyTokens(tokens, recurse, rawSql) {
+      let t2 = tokens.slice();
+      for (let guard = 0; guard < 12; guard++) {
+        while (t2.length && (ENV_ASSIGN.test(t2[0]) || CONTROL_WORDS.has(t2[0])))
+          t2 = t2.slice(1);
+        if (t2.length === 0)
+          return null;
+        {
+          const r2 = /^>(?![>&])/.test(t2[0]) ? t2 : (t2[0] === ":" || t2[0] === "true") && /^>(?![>&])/.test(t2[1] ?? "") ? t2.slice(1) : null;
+          if (r2) {
+            const target = r2[0].length > 1 ? r2[0].slice(1) : r2[1] ?? "";
+            if (!target.startsWith("/dev/"))
+              return hit("filesystem", "a bare `>` redirect truncates the file (contents lost)");
+            return null;
+          }
+        }
+        const bin = base(t2[0]);
+        const args = t2.slice(1);
+        if (DB_BINS.has(bin)) {
+          return rawSql(bin + " " + args.map((a) => JSON.stringify(a)).join(" "));
+        }
+        if (bin === "sudo" || bin === "doas") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-u", "-g", "-h", "-p", "-C", "-D", "-R", "-T", "-U"]));
+          continue;
+        }
+        if (bin === "env") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-u", "-C", "-S"]));
+          continue;
+        }
+        if (bin === "nice") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-n"]));
+          continue;
+        }
+        if (bin === "ionice") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-c", "-n", "-p"]));
+          continue;
+        }
+        if (bin === "timeout") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-s", "-k"])).slice(1);
+          continue;
+        }
+        if (bin === "xargs") {
+          t2 = dropOpts(args, /* @__PURE__ */ new Set(["-I", "-n", "-P", "-L", "-s", "-d", "-E", "-a", "-J"]));
+          continue;
+        }
+        if (["command", "builtin", "nohup", "exec", "time", "setsid", "caffeinate", "stdbuf", "unbuffer"].includes(bin)) {
+          t2 = dropOpts(args);
+          continue;
+        }
+        if (SHELLS.has(bin)) {
+          const i2 = args.findIndex((a) => /^-[A-Za-z]*c[A-Za-z]*$/.test(a));
+          if (i2 >= 0 && args[i2 + 1] !== void 0)
+            return recurse(args[i2 + 1]);
+          return null;
+        }
+        if (bin === "eval")
+          return recurse(args.join(" "));
+        if (bin === "ssh") {
+          const a = dropOpts(args, /* @__PURE__ */ new Set(["-p", "-i", "-l", "-o", "-F", "-J", "-L", "-R", "-D", "-b", "-c", "-E", "-e", "-I", "-m", "-O", "-Q", "-S", "-w", "-W"]));
+          return a.length > 1 ? recurse(a.slice(1).join(" ")) : null;
+        }
+        if (bin === "docker" || bin === "podman" || bin === "docker-compose") {
+          const a0 = bin === "docker-compose" ? ["compose", ...args] : dropOpts(args, /* @__PURE__ */ new Set(["-H", "--host", "--context", "-c"]));
+          const isExec = a0[0] === "exec" || a0[0] === "compose" && dropOpts(a0.slice(1), /* @__PURE__ */ new Set(["-f", "-p", "--project-name", "--file", "--profile"]))[0] === "exec";
+          if (isExec) {
+            const afterVerb = a0[0] === "exec" ? a0.slice(1) : dropOpts(a0.slice(1), /* @__PURE__ */ new Set(["-f", "-p", "--project-name", "--file", "--profile"])).slice(1);
+            const inner = dropOpts(afterVerb, /* @__PURE__ */ new Set(["-e", "-u", "-w", "--env", "--user", "--workdir", "--env-file", "--detach-keys", "--index"]));
+            if (inner.length > 1) {
+              t2 = inner.slice(1);
+              continue;
+            }
+            return null;
+          }
+        }
+        if (bin === "kubectl" || bin === "oc") {
+          const i2 = args.indexOf("--");
+          if (i2 >= 0 && args.includes("exec") && i2 + 1 < args.length) {
+            t2 = args.slice(i2 + 1);
+            continue;
+          }
+        }
+        return judge(bin, args);
+      }
+      return null;
+    }
+  }
+});
+
 // ../../../../../Users/henry/Documents/nexrall-code/packages/core/dist/permissions/destructive.js
 var require_destructive = __commonJS({
   "../../../../../Users/henry/Documents/nexrall-code/packages/core/dist/permissions/destructive.js"(exports2) {
@@ -105422,6 +105906,7 @@ var require_destructive = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.classifyDestructiveCommand = classifyDestructiveCommand;
     exports2.isDestructiveBash = isDestructiveBash3;
+    var destructiveTokens_1 = require_destructiveTokens();
     function stripHeredocs(command) {
       return command.replace(/<<-?\s*(['"]?)(\w+)\1[\s\S]*?\n\2(?=\s|;|&|$)/g, " ");
     }
@@ -105451,6 +105936,16 @@ var require_destructive = __commonJS({
         reason: "drops a Postgres/MySQL role or user",
         re: new RegExp(CMD_POS + DB_CLIENT + String.raw`\b[\s\S]*?\bdrop\s+(?:role|user)\b`, "i")
       },
+      {
+        category: "database",
+        reason: "UPDATE without a WHERE clause (rewrites every row)",
+        re: new RegExp(CMD_POS + DB_CLIENT + String.raw`\b[\s\S]*?\bupdate\s+[\w.` + "`" + String.raw`"]+\s+set\b(?![\s\S]*\bwhere\b)`, "i")
+      },
+      {
+        category: "database",
+        reason: "DELETE with a WHERE clause that is always true (deletes every row)",
+        re: new RegExp(CMD_POS + DB_CLIENT + String.raw`\b[\s\S]*?\bdelete\s+from\b[\s\S]*?\bwhere\s+(?:1\s*=\s*1|true)\b`, "i")
+      },
       {
         category: "database",
         reason: "drops a MongoDB database or collection",
@@ -105490,11 +105985,6 @@ var require_destructive = __commonJS({
         reason: "deletes untracked files (git clean)",
         re: /\bgit\s+clean\s+-[a-z]*f/i
       },
-      {
-        category: "git-history",
-        reason: "force-deletes a git branch",
-        re: /\bgit\s+branch\s+-[a-z]*D/i
-      },
       {
         category: "git-history",
         reason: "rewrites git history (filter-branch/filter-repo)",
@@ -105585,9 +106075,7 @@ var require_destructive = __commonJS({
         re: new RegExp(CMD_POS + String.raw`(?:npm\s+publish|yarn\s+publish|pnpm\s+publish|cargo\s+publish|twine\s+upload|gem\s+push)\b`, "i")
       }
     ];
-    function classifyDestructiveCommand(command) {
-      if (!command || typeof command !== "string")
-        return null;
+    function classifyRegex(command) {
       const raw = stripHeredocs(command);
       for (const rule of RAW_RULES) {
         if (rule.re.test(raw)) {
@@ -105602,6 +106090,33 @@ var require_destructive = __commonJS({
       }
       return null;
     }
+    function classifyRawSql(command) {
+      const raw = stripHeredocs(command);
+      for (const rule of RAW_RULES) {
+        if (rule.re.test(raw))
+          return { category: rule.category, reason: rule.reason };
+      }
+      return null;
+    }
+    var MAX_DEPTH = 4;
+    function classify(command, depth) {
+      if (depth > MAX_DEPTH)
+        return null;
+      const viaRegex = classifyRegex(command);
+      if (viaRegex)
+        return viaRegex;
+      for (const tokens of (0, destructiveTokens_1.tokenize)(stripHeredocs(command))) {
+        const m2 = (0, destructiveTokens_1.classifyTokens)(tokens, (inner) => classify(inner, depth + 1), classifyRawSql);
+        if (m2)
+          return m2;
+      }
+      return null;
+    }
+    function classifyDestructiveCommand(command) {
+      if (!command || typeof command !== "string")
+        return null;
+      return classify(command, 0);
+    }
     function isDestructiveBash3(tool, input) {
       if (tool !== "bash" && tool !== "run_command" && tool !== "execute_command")
         return null;
@@ -145676,6 +146191,67 @@ function padVis(s2, n) {
   const pad = n - visibleLen(s2);
   return pad > 0 ? s2 + " ".repeat(pad) : s2;
 }
+var graphemeSegmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function graphemes(s2) {
+  return graphemeSegmenter ? Array.from(graphemeSegmenter.segment(s2), (x2) => x2.segment) : Array.from(s2);
+}
+function truncateCells(s2, max) {
+  if (max <= 0)
+    return "";
+  if (visibleLen(s2) <= max)
+    return s2;
+  let out = "";
+  for (const g of graphemes(s2)) {
+    if (visibleLen(out + g) > max - 1)
+      break;
+    out += g;
+  }
+  return out + "\u2026";
+}
+function wrapCells(text, width) {
+  if (width < 1)
+    return [];
+  const rows = [];
+  let cur = "";
+  for (const w of text.split(/\s+/)) {
+    if (!w)
+      continue;
+    let word = w;
+    while (visibleLen(word) > width) {
+      if (cur) {
+        rows.push(cur);
+        cur = "";
+      }
+      const g = graphemes(word);
+      let chunk = "";
+      let i2 = 0;
+      for (; i2 < g.length; i2++) {
+        if (visibleLen(chunk + g[i2]) > width)
+          break;
+        chunk += g[i2];
+      }
+      if (!chunk) {
+        chunk = g[0];
+        i2 = 1;
+      }
+      rows.push(chunk);
+      word = g.slice(i2).join("");
+    }
+    if (!word)
+      continue;
+    if (!cur)
+      cur = word;
+    else if (visibleLen(cur) + 1 + visibleLen(word) <= width)
+      cur += " " + word;
+    else {
+      rows.push(cur);
+      cur = word;
+    }
+  }
+  if (cur)
+    rows.push(cur);
+  return rows;
+}
 function ruleWidth(max = 50, columns = process.stdout.columns || 80) {
   const MIN = 20;
   const indent = 2;
@@ -145904,11 +146480,9 @@ function formatToolResult(name, result, durationMs) {
   const sizeHint = lines > 1 ? `${lines} lines` : `${out.length} chars`;
   return source_default.green(icons.check) + " " + source_default.dim(name) + source_default.dim(` \xB7 ${sizeHint}`) + source_default.dim(` \xB7 ${durationMs}ms`);
 }
-function formatThinking(text, tokens) {
+function formatThinking(tokens) {
   const tokStr = tokens >= 1e3 ? `~${(tokens / 1e3).toFixed(1)}k tokens` : tokens > 0 ? `~${tokens} tokens` : "";
-  const header = source_default.dim(`${icons.thinking} Thought`) + (tokStr ? source_default.dim(` for ${tokStr}`) : "");
-  const preview = text.trim().split("\n").filter(Boolean).slice(0, 3).map((l2) => source_default.dim("  " + l2.slice(0, 100))).join("\n");
-  return "\n" + header + (preview ? "\n" + preview : "") + "\n";
+  return source_default.dim(`${icons.thinking} Thought`) + (tokStr ? source_default.dim(` \xB7 ${tokStr}`) : "");
 }
 function formatUsage(outputTokens) {
   const tok = outputTokens >= 1e3 ? `${(outputTokens / 1e3).toFixed(1)}k` : String(outputTokens);
@@ -157661,11 +158235,11 @@ function fillerContent(rows) {
   return "\n".repeat(rows - 1);
 }
 var IntlWithSegmenter2 = Intl;
-var graphemeSegmenter = typeof IntlWithSegmenter2.Segmenter === "function" ? new IntlWithSegmenter2.Segmenter(void 0, { granularity: "grapheme" }) : null;
+var graphemeSegmenter2 = typeof IntlWithSegmenter2.Segmenter === "function" ? new IntlWithSegmenter2.Segmenter(void 0, { granularity: "grapheme" }) : null;
 function graphemeBoundaries(text) {
-  if (graphemeSegmenter) {
+  if (graphemeSegmenter2) {
     const bounds2 = [0];
-    for (const { index } of graphemeSegmenter.segment(text)) {
+    for (const { index } of graphemeSegmenter2.segment(text)) {
       if (index > 0)
         bounds2.push(index);
     }
@@ -158965,7 +159539,95 @@ ${content}`);
   }
   return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
 }
-var THINK_TAIL_CHARS = 48;
+var THINK_PREVIEW_ROWS = 3;
+var THINK_BUFFER_CHARS = 1200;
+var VERB_ROTATE_SEC = 3;
+var WORKING_VERBS = [
+  "Accomplishing",
+  "Actualizing",
+  "Baking",
+  "Brewing",
+  "Calculating",
+  "Cerebrating",
+  "Churning",
+  "Coalescing",
+  "Cogitating",
+  "Computing",
+  "Concocting",
+  "Conjuring",
+  "Considering",
+  "Contemplating",
+  "Cooking",
+  "Crafting",
+  "Creating",
+  "Crunching",
+  "Deliberating",
+  "Determining",
+  "Digesting",
+  "Distilling",
+  "Divining",
+  "Effecting",
+  "Elaborating",
+  "Envisioning",
+  "Fabricating",
+  "Fermenting",
+  "Finagling",
+  "Forging",
+  "Formulating",
+  "Generating",
+  "Germinating",
+  "Hatching",
+  "Herding",
+  "Hustling",
+  "Ideating",
+  "Imagining",
+  "Incubating",
+  "Inferring",
+  "Manifesting",
+  "Marinating",
+  "Meandering",
+  "Mulling",
+  "Musing",
+  "Noodling",
+  "Percolating",
+  "Pondering",
+  "Processing",
+  "Puzzling",
+  "Reticulating",
+  "Ruminating",
+  "Simmering",
+  "Smelting",
+  "Spinning",
+  "Stewing",
+  "Sussing",
+  "Synthesizing",
+  "Thinking",
+  "Tinkering",
+  "Transmuting",
+  "Unfurling",
+  "Vibing",
+  "Wandering",
+  "Weaving",
+  "Whirring",
+  "Working"
+];
+function composeThinkingBlock(opts) {
+  const tok = formatProgressTokens(opts.tokens);
+  const flat = opts.text.replace(/\s+/g, " ").trim();
+  if (!tok && !flat)
+    return [];
+  const columns = Math.max(20, opts.columns | 0 || 80);
+  const termRows = opts.rows && opts.rows > 0 ? opts.rows : 24;
+  const maxRows = Math.max(0, Math.min(opts.maxRows ?? THINK_PREVIEW_ROWS, termRows - 12));
+  const lines = [source_default.dim(truncateCells(`${icons.thinking} Thinking\u2026${tok ? " " + tok : ""}`, columns - 1))];
+  if (flat && maxRows > 0) {
+    const indent = "  ";
+    const wrapped = wrapCells(flat, columns - 1 - indent.length);
+    for (const row of wrapped.slice(-maxRows))
+      lines.push(source_default.dim.italic(indent + row));
+  }
+  return lines;
+}
 function composeStatusLine(opts) {
   const timer = source_default.dim(` (${opts.elapsedSec}s)`);
   const hint = opts.hint !== false && !opts.detail && opts.elapsedSec >= 15 ? source_default.dim("  \xB7 still running, no output yet is normal for quiet commands") : "";
@@ -158994,10 +159656,21 @@ var Spinner = class {
   // already explained by the detail text (e.g. a live token counter is itself
   // proof of life, so "no output yet is normal" would be noise).
   hintEnabled = true;
+  // Model-working phases (before the first token, and between tool rounds) show a rotating
+  // verb instead of a fixed label, plus the live reasoning block above it. Tool phases
+  // ("running bash…") keep their literal label: a verb there would hide what is running.
+  verbs = false;
+  verbIdx = 0;
+  thinkTokens = 0;
+  thinkText = "";
   start(text, opts) {
     this.stop();
     this.baseText = text;
     this.detail = "";
+    this.thinkTokens = 0;
+    this.thinkText = "";
+    this.verbs = opts?.verbs === true;
+    this.verbIdx = Math.floor(Math.random() * WORKING_VERBS.length);
     this.hintEnabled = opts?.hint !== false;
     this.startedAt = Date.now();
     this.render();
@@ -159027,6 +159700,17 @@ var Spinner = class {
       return;
     this.detail = detail;
   }
+  /**
+   * Feed the live reasoning block (token count + streamed text). Like setDetail, this only
+   * records state — the 100 ms tick renders it, so a burst of deltas cannot add redraws.
+   * The text is capped to THINK_BUFFER_CHARS: only its last rows are ever displayed.
+   */
+  setThinking(tokens, text) {
+    if (this.interval === null)
+      return;
+    this.thinkTokens = tokens;
+    this.thinkText = text.slice(-THINK_BUFFER_CHARS);
+  }
   /** Swap the label without resetting the elapsed timer (phase change within one turn). Same reasoning as setDetail() above: no immediate render, the interval tick picks it up. */
   setText(text) {
     if (this.interval === null)
@@ -159034,20 +159718,36 @@ var Spinner = class {
     this.baseText = text;
   }
   render() {
-    getInkTerminal()?.setLive(composeStatusLine({
+    const elapsedSec = Math.floor((Date.now() - this.startedAt) / 1e3);
+    if (this.verbs && elapsedSec > 0 && elapsedSec % VERB_ROTATE_SEC === 0 && this.lastRotateSec !== elapsedSec) {
+      this.lastRotateSec = elapsedSec;
+      this.verbIdx++;
+    }
+    const label = this.verbs ? `${WORKING_VERBS[this.verbIdx % WORKING_VERBS.length]}\u2026` : this.baseText;
+    const status = composeStatusLine({
       frame: this.frames[this.i % this.frames.length],
-      text: this.baseText,
-      elapsedSec: Math.floor((Date.now() - this.startedAt) / 1e3),
+      text: label,
+      elapsedSec,
       detail: this.detail,
       hint: this.hintEnabled
-    }));
+    });
+    const block = this.verbs ? composeThinkingBlock({
+      tokens: this.thinkTokens,
+      text: this.thinkText,
+      columns: process.stdout.columns || 80,
+      rows: process.stdout.rows || 24
+    }) : [];
+    getInkTerminal()?.setLive(block.length ? block.join("\n") + "\n" + status : status);
     this.i++;
   }
+  lastRotateSec = -1;
   stop() {
     if (this.interval !== null) {
       clearInterval(this.interval);
       this.interval = null;
       this.detail = "";
+      this.thinkTokens = 0;
+      this.thinkText = "";
       getInkTerminal()?.setLive("");
     }
   }
@@ -159142,26 +159842,20 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env4, nexrall
   const toolCalls = /* @__PURE__ */ new Map();
   const subPrefix = (meta) => source_default.dim(`  \u21B3 ${meta?.agentName ?? "sub-agent"} `);
   let thinkingTokens = 0;
-  let liveThinkTail = "";
+  let liveThinkText = "";
   const pushStatus = () => {
-    const parts = [];
-    const tok = formatProgressTokens(thinkingTokens);
-    if (tok)
-      parts.push(tok);
-    if (liveThinkTail)
-      parts.push(liveThinkTail);
-    spinner.setDetail(parts.join("  \xB7 "));
+    spinner.setThinking(thinkingTokens, liveThinkText);
   };
   const resumeWorking = (label = "working\u2026") => {
     if (abortSignal.aborted)
       return;
     thinkingTokens = 0;
-    liveThinkTail = "";
-    spinner.start(label, { hint: false });
+    liveThinkText = "";
+    spinner.start(label, { hint: false, verbs: true });
   };
   setMode(mode);
   console.log();
-  spinner.start("thinking\u2026", { hint: false });
+  spinner.start("thinking\u2026", { hint: false, verbs: true });
   const result = await (0, import_code_core7.runAgentLoop)(messages, {
     workDir,
     model: modelAlias,
@@ -159213,17 +159907,16 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env4, nexrall
     onThinkingDelta: (text) => {
       if (abortSignal.aborted)
         return;
-      const flat = text.replace(/\s+/g, " ");
-      liveThinkTail = (liveThinkTail + flat).slice(-THINK_TAIL_CHARS);
+      liveThinkText = (liveThinkText + text).slice(-THINK_BUFFER_CHARS);
       pushStatus();
     },
     onThinking: (text) => {
       if (abortSignal.aborted)
         return;
       spinner.stop();
-      console.log(formatThinking(text, thinkingTokens));
+      console.log(formatThinking(thinkingTokens));
       thinkingTokens = 0;
-      liveThinkTail = "";
+      liveThinkText = "";
       resumeWorking();
     },
     onText: (text) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.126",
+  "version": "0.5.127",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",