moshcode 0.92.0 → 0.93.0

package/README.md

@@ -1017,15 +1017,34 @@ Run a few engines at once on a box you also want to type on and you get the
 failure everyone knows: nothing crashed, but the machine stops answering.
 
 ```text
-/nice on          # nice -n10 + ionice -c2 -n7 for every engine started after
+/nice agents claude    # throttle this one engine
+/nice pnpm -r build    # …or this one shell line
+/nice merge            # …or any other pit command
+
+/nice on          # or throttle everything from here on
 /nice mem 2G      # a ceiling, so a runaway dies alone
 /nice cpu 15      # yield more (nice takes -20..19)
 /nice             # what it is set to
 /nice off         # back to normal priority (the default)
 ```
 
-It is off by default — a throttle nobody asked for is a slow engine nobody can
-explain — and it applies to engines started *after* you turn it on.
+`/nice <line>` is the form to reach for. It runs **anything the pit can already
+run** — a pit command, an engine, a tool, one of your aliases, or a bare shell
+line — at low priority, without changing any setting. It works on all of those
+because it hands the rest of the line back to the top of the dispatcher exactly
+as an alias expansion does, rather than keeping a list of its own that would
+drift. The leading slash is optional: `/nice agents claude` and
+`/nice /agents claude` are the same line.
+
+The throttle lasts exactly as long as the line that asked for it, including
+through an alias that expands into something else. The next thing you type is
+back to normal.
+
+`/nice on` is the other half, for when the box is shared all day and you would
+rather decide once. It is off by default — a throttle nobody asked for is a slow
+engine nobody can explain — and it applies to engines started *after* you turn
+it on. The settings words (`on`, `off`, `status`, `cpu`, `io`, `mem`) win the
+first position, so a program named `on` is not reachable through `/nice`.
 
 **`nice` alone is half a fix, and it is worth knowing which half.** It reorders
 CPU, so it buys back the part of a freeze you could have waited out. It does

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.92.0",
+  "version": "0.93.0",
   "type": "module",
   "description": "moshcode \u2014 a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/cli-schema.mjs

@@ -1596,20 +1596,23 @@ export const PIT_COMMANDS = [
     description: "show the current dir + git repo/branch/origin" },
   { name: "shell", aliases: ["sh"], args: "[cmd]", pitOnly: true,
     description: "drop into $SHELL (exit → back to the pit); also !cmd" },
-  { name: "nice", aliases: ["throttle"], args: "on | off | cpu <n> | io <n> | mem <size>", pitOnly: true,
-    description: "run engines at low priority so the box stays usable",
+  { name: "nice", aliases: ["throttle"], args: "<command> | on | off | cpu <n> | io <n> | mem <size>", pitOnly: true,
+    description: "run something at low priority so the box stays usable",
     synopsis: [
+      ["/nice <command> [args]", "run one line throttled — a pit command, engine, tool, alias or shell line"],
       ["/nice [status]", "what the throttle is set to"],
-      ["/nice on | off", "toggle it (off by default)"],
+      ["/nice on | off", "throttle everything from here on (off by default)"],
       ["/nice cpu <-20..19>", "nice level — higher yields more CPU"],
       ["/nice io <0..7>", "ionice best-effort level"],
       ["/nice mem <size> | off", "memory ceiling per engine (needs systemd)"],
     ],
     examples: [
+      ["/nice agents claude", "throttle this engine, leave the setting alone"],
+      ["/nice pnpm -r build", "a shell line works too"],
       ["/nice on", "nice -n10 + ionice -c2 -n7 for every engine started after"],
       ["/nice mem 2G", "the ceiling nice(1) can't give you — a runaway dies alone"],
     ],
-    seeAlso: ["agents", "start"] },
+    seeAlso: ["agents", "start", "alias"] },
   { name: "alias", aliases: ["aliases"], args: 'set <name> "<cmd>" | list | get | rm | install <tool>', pitOnly: true,
     description: "name a line you keep retyping; /<name> runs it",
     synopsis: [

package/src/nice.mjs

@@ -52,6 +52,42 @@ export function niceFile() {
   return path.join(os.homedir(), ".moshcode", "nice.json");
 }
 
+/**
+ * `/nice <line>` throttles one line without changing the saved setting.
+ *
+ * Module-level rather than threaded through every call because the thing being
+ * throttled is not a function argument -- it is whatever that line eventually
+ * spawns, which may be an alias that expands to a pit command that starts an
+ * engine, three dispatch rounds later. The pit reads one line at a time and
+ * fully awaits it, so "armed until the next line the user types" is both the
+ * simplest implementation and exactly the intent.
+ */
+let oneShot = false;
+
+/** Throttle whatever the current line ends up spawning. */
+export function armOneShot() { oneShot = true; }
+
+/**
+ * Stop throttling. The pit calls this when it reads a fresh line, NOT when a
+ * command finishes: one typed line can dispatch several times through alias
+ * expansion, and all of it is the line the user asked to be nice.
+ */
+export function disarmOneShot() { oneShot = false; }
+
+/** Is a one-shot throttle in force? */
+export function oneShotArmed() { return oneShot; }
+
+/**
+ * The settings a spawn should actually use: what is saved, plus a one-shot.
+ *
+ * `/nice on` and `/nice <cmd>` end in the same place by design -- a spawn does
+ * not need to know which of the two asked for it.
+ */
+export function effectiveNice() {
+  const saved = loadNice();
+  return oneShot ? { ...saved, on: true } : saved;
+}
+
 /**
  * The current settings, always a complete object.
  *
@@ -135,7 +171,7 @@ export function canCapMemory({ has = haveBin, env = process.env } = {}) {
  * rather than a wrong guess.
  */
 export function throttleSpec(spec, {
-  settings = loadNice(),
+  settings = effectiveNice(),
   has = haveBin,
   env = process.env,
   platform = process.platform,

package/src/tui.mjs

@@ -22,7 +22,10 @@ import { activeChildInput, createMirror, pressKey, setActiveSink, teeOutput } fr
 import { fetchMotdAd } from "./ads.mjs";
 import { runScript } from "./runtime.mjs";
 import { moshVocabulary } from "./commands.mjs";
-import { loadNice, saveNice, describeNice, canCapMemory, parseMemory } from "./nice.mjs";
+import {
+  loadNice, saveNice, describeNice, canCapMemory, parseMemory,
+  armOneShot, disarmOneShot,
+} from "./nice.mjs";
 import { mcpCommand, pluginCommand, skillCommand } from "./integrations.mjs";
 import { stocksCommand } from "./advisor.mjs";
 import { cryptoCommand } from "./crypto.mjs";
@@ -389,6 +392,16 @@ function isInstalledTool(key) {
  * line, not an argument list: re-joining tokens would drop the quoting that the
  * shell still has to read.
  */
+/**
+ * The words that mean "configure the throttle" rather than "run this".
+ *
+ * Kept next to the command that implements them so the two cannot drift: every
+ * other first word after `/nice` is a line to run, so adding a verb here
+ * without teaching niceCommand about it would make that word silently
+ * unrunnable rather than produce an error.
+ */
+const NICE_SETTING_VERBS = new Set(["on", "off", "status", "cpu", "io", "mem", "memory"]);
+
 /**
  * `/nice` — run the CLIs the pit starts at a lower priority than your terminal.
  *
@@ -929,6 +942,11 @@ export async function tui() {
       finally { atPrompt(null); }
       if (line == null) break; // Ctrl-D
       expansions = 0;
+      // A one-shot `/nice <line>` lasts exactly as long as the line that asked
+      // for it. Cleared here, where a REAL line is read, and not when a command
+      // returns: one typed line can dispatch several times through alias
+      // expansion, and all of that is still the line the user said to be nice.
+      disarmOneShot();
       line = line.trim();
       if (!line) continue;
       saveHistory(); // readline just recorded this line into the shared history
@@ -994,7 +1012,31 @@ export async function tui() {
       continue;
     }
     if (cmd === "alias" || cmd === "aliases") { aliasCommand(rest, line); continue; }
-    if (cmd === "nice" || cmd === "throttle") { niceCommand(rest); continue; }
+    if (cmd === "nice" || cmd === "throttle") {
+      // `/nice <line>` runs one line throttled without touching the setting --
+      // the form anyone who has used nice(1) reaches for first. The settings
+      // verbs win the name, so a command called `on` is unreachable this way;
+      // that is the right trade for `/nice on` meaning what it obviously means.
+      const sub = String(rest[0] ?? "").toLowerCase().replace(/^\//, "");
+      // A leading flag (`/nice --json`) is asking about the throttle, not
+      // naming a program: no line the pit runs starts with a dash.
+      if (!rest.length || sub.startsWith("-") || NICE_SETTING_VERBS.has(sub)) {
+        niceCommand(rest);
+        continue;
+      }
+
+      // Hand the remainder back to the top of this loop rather than dispatching
+      // it here, exactly as alias expansion does. That is what makes `/nice`
+      // work on anything the pit can already run -- a pit command, an engine, a
+      // tool, an alias, or a bare shell line -- with no roster of its own to
+      // drift out of date. The leading slash is optional because the dispatcher
+      // strips one anyway, so `/nice agents claude` and `/nice /agents claude`
+      // are the same line.
+      armOneShot();
+      pending = commandRemainder(line);
+      console.log(ash(`  ▸ throttled: ${pending}`));
+      continue;
+    }
     if (cmd === "pwd" || cmd === "where") { printPwd(); continue; }
     if (cmd === "login") {
       const device = rest.includes("--device") || rest.includes("device") || rest.includes("-d");