moshcode 0.92.0 → 0.94.0

package/README.md

@@ -26,7 +26,7 @@ or miss one that does. A test fails the build when it drifts.
 <!-- COMMANDS:START -->
 | command | group | what it does |
 |---|---|---|
-| `moshcode agents` | engines | list engines or launch one autonomously |
+| `moshcode agents` | engines | list engines, open their agent view, or launch autonomously |
 | `moshcode start` | engines | launch an engine with its native defaults |
 | `moshcode herd` | runtime | run agent sessions that outlive this terminal |
 | `moshcode ps` | runtime | list herd sessions and what each one is doing |
@@ -107,7 +107,7 @@ use this only in an isolated container, VM, or workspace you trust:
 moshcode agents claude      # claude agents --dangerously-skip-permissions  (agent view)
 moshcode agents opencode    # opencode --auto                              (autonomous)
 moshcode agents privacycode # privacycode --auto                           (autonomous)
-moshcode agents codex       # codex --dangerously-bypass-approvals-and-sandbox  (autonomous)
+moshcode agents codex       # codex --dangerously-bypass-approvals-and-sandbox agents (agent view)
 moshcode agents gemini      # gemini --approval-mode=yolo                       (autonomous)
 moshcode agents kimi        # kimi --yolo                                       (autonomous)
 moshcode agents qwen        # qwen --approval-mode=yolo                         (autonomous)
@@ -116,6 +116,25 @@ moshcode agents aider       # aider --yes-always
 moshcode agents openagents  # openagents                                        (dashboard)
 ```
 
+Codex's native agents overview requires a CLI with `codex agents` support
+(verified with 0.151.0) and, for the local daemon, the managed standalone
+installation. `moshcode install codex` / `moshcode upgrade codex` use Codex's
+official standalone installer on macOS/Linux; an npm-only install is not enough.
+Existing npm installations are preserved. Windows retains npm and requires
+`--remote <server>` for the agents overview.
+`/agents codex` opens the same live overview of sessions on Codex's shared local
+app-server daemon. The approval/sandbox bypass is passed for this invocation;
+moshcode does not rewrite your global Codex settings or stop existing sessions.
+Additional arguments are forwarded to the native `agents` subcommand, for example
+`moshcode agents codex --no-alt-screen`.
+
+For separate conversations, Codex's `/new` starts a fresh chat in the same CLI,
+`/resume` reopens a saved chat, and `/fork` branches a conversation while preserving
+the original. These commands are distinct from launching parallel subagents:
+ask Codex to delegate work, then use its `/agent` or `/subagents` picker to switch
+threads. See the [Codex command reference](https://learn.chatgpt.com/docs/developer-commands?surface=cli)
+and [subagent guide](https://learn.chatgpt.com/docs/agent-configuration/subagents).
+
 `start` is the explicit raw path. It injects nothing, so the native engine keeps
 its normal permission model and receives only your arguments:
 
@@ -723,6 +742,44 @@ login`. Publishing needs one, and `bo login` is a device-code exchange, so a
 terminal never handles a browser session. `bo mcp config` prints the MCP
 registration for a coding agent, which is the same graph over a different door.
 
+### CrawlProof — what the fleet costs and what it returns
+
+[CrawlProof](https://crawlproof.com) knows who arrived on your sites and what
+your ads delivered. `crawlproof` joins that to what the bank actually did, so
+the terminal can answer the question a dashboard usually cannot: is any of this
+paying for itself.
+
+```sh
+moshcode install crawlproof       # npm i -g @profullstack/crawlproof
+
+moshcode crawlproof               # the live dashboard, last day, humans
+moshcode crawlproof dashboard --range=1m
+moshcode crawlproof stats site.com
+moshcode crawlproof dashboard --json | jq .roi.derived
+```
+
+Five screens: ROI, Traffic, Ads, Money, Spend. Two rules run through the
+arithmetic and both exist because breaking either produces a nicer number that
+is false. Where an account advertises on its own slots, ad spend and ad earnings
+are one dollar moving between two pockets, so they are reported under *Internal*
+and counted as neither cost nor revenue. And a bank feed carries groceries next
+to servers, so cost is the business scope only.
+
+It also says what it does not know, next to the number: a site that did not
+answer is missing rather than zero, and a fleet whose visits run far above its
+pageviews says so and offers the per-pageview figure instead.
+
+Needs a CrawlProof API token in `CRAWLPROOF_TOKEN` or the `token` field of
+`~/.crawlproof.json`. The money screens want a CoinPay merchant session as well;
+without one the other four still work and the money panels say what is missing.
+The dashboard is a TUI and wants Node 22.6+, while `stats` and `--json` run
+anywhere.
+
+`crawlproof` also ships in the `cli-tools` set, which symlinks a wrapper of the
+same name that vendors this package. Installing both is fine: the wrapper hands
+over to a `crawlproof` on PATH that is not its own, and refuses to follow one
+that is.
+
 ### Cloud + infra CLIs
 
 ```sh
@@ -1017,15 +1074,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.94.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

@@ -35,7 +35,7 @@ export const CORE_CLI_COMMANDS = [
   {
     name: "agents",
     group: "engines",
-    description: "list engines or launch one autonomously",
+    description: "list engines, open their agent view, or launch autonomously",
     synopsis: [
       ["moshcode agents", "list engines and their install status"],
       ["moshcode agents --json", "list engine status as machine-readable JSON"],
@@ -48,6 +48,7 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode agents", "which engines are here"],
       ["moshcode agents --json", "pipe engine status into a script"],
       ["moshcode agents claude", "claude's agent list"],
+      ["moshcode agents codex", "Codex's shared-daemon agents overview (CLI 0.151.0+)"],
     ],
     seeAlso: ["start", "engines", "install"],
     note: "autonomous modes bypass approval prompts — use them in a container or a workspace you trust.",
@@ -1518,7 +1519,7 @@ export const PIT_COMMANDS = [
   { name: "new", pitOnly: true,
     description: "open and switch to another moshcode tab" },
   { name: "agents", aliases: ["agent", "engines"], args: "[name]", cli: "agents",
-    description: "list engines, or launch one autonomously" },
+    description: "list engines, open their agent view, or launch autonomously" },
   { name: "start", args: "<engine> [args…]", cli: "start",
     description: "raw launch; inject no engine arguments" },
   { name: "herd", args: "[verb] [args…]", cli: "herd",
@@ -1596,20 +1597,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/commands.mjs

@@ -826,7 +826,7 @@ const COMMANDS = [
   cliVerb("run", "run another .mosh file (include)"),
   // shortcut: ai() runs an engine headlessly and RETURNS its output (see PRD R17)
   aiVerb,
-  cliVerb("agents", "launch an autonomous agent session (moshcode agents <engine>)"),
+  cliVerb("agents", "open the native agent view or launch autonomously (moshcode agents <engine>)"),
   cliVerb("herd", "drive the herd (moshcode herd <verb>) — see herdStart/herdWait for values"),
   cliVerb("ps", "print the herd roster"),
   cliVerb("cost", "print what the herd is spending (moshcode cost [name] [--all])"),

package/src/engines.mjs

@@ -5,8 +5,8 @@
 //
 // `agentsView` (optional) is the exact argv that opens the engine's native
 // agent list/view — used by `/agents <name>` when the engine actually has one
-// (currently claude). It's the FULL leading args (subcommand + any flags that
-// subcommand accepts). Engines without an `agentsView` fall back to
+// (currently Claude and Codex). It's the FULL leading args, including root
+// flags before the subcommand when required. Engines without an `agentsView` fall back to
 // `agentArgs` — an autonomous session with native approvals
 // bypassed/auto-approved. Do not use a machine-readable, one-shot list command
 // as an agents view: `/agents` promises to hand the terminal to a live session.
@@ -131,7 +131,16 @@ export const ENGINES = {
     desc: "Codex — OpenAI's coding CLI",
     bin: "codex",
     agentArgs: ["--dangerously-bypass-approvals-and-sandbox"],
-    install: { cmd: "npm", args: ["install", "-g", "@openai/codex"] },
+    // Codex 0.151.0+: live shared-daemon session overview. The bypass option
+    // belongs to the root command, not the `agents` subcommand.
+    agentsView: ["--dangerously-bypass-approvals-and-sandbox", "agents"],
+    // The local agents daemon requires the installer-managed standalone
+    // package; npm alone can launch chats but cannot bootstrap that daemon.
+    // Windows uses a remote agents server and retains its npm installation.
+    install: process.platform === "win32"
+      ? { cmd: "npm", args: ["install", "-g", "@openai/codex"] }
+      : { cmd: "bash", args: ["-o", "pipefail", "-c", "curl -fsSL https://chatgpt.com/codex/install.sh | CODEX_NON_INTERACTIVE=1 sh"] },
+    binDirs: [path.join(homedir(), ".local", "bin")],
     resume: ["resume", "--last"],
     state: {
       blocked: [/\ballow (?:this )?command\b/i, /\bapprove this (?:command|edit|change)\b/i],

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/tools.mjs

@@ -88,6 +88,23 @@ export const TOOLS = {
     // where those words mean something else entirely.
     aliases: { cmd: "cli-tools", args: ["aliases", "--json"] },
   },
+  crawlproof: {
+    desc: "CrawlProof \u2014 what the fleet costs and what it returns: traffic, ad delivery and the bank behind it",
+    bin: "crawlproof",
+    // Reachable two ways on purpose. The `cli-tools` set above symlinks a
+    // wrapper of the same name, and this entry installs the package that
+    // wrapper vendors. Having both is safe: the wrapper hands over to a
+    // `crawlproof` on PATH that is not its own, and refuses to follow one that
+    // is, which would be an exec loop. It is its own entry because
+    // `/install crawlproof` should install CrawlProof rather than seven other
+    // commands that happen to travel with it.
+    //
+    // The dashboard is a TUI and wants Node 22.6+; `crawlproof stats` and
+    // `--json` run anywhere. An ordinary global npm package, and
+    // `npm install -g` is idempotent, so the install is also the upgrade \u2014
+    // no `upgrade` key, the same as bo and railway.
+    install: { cmd: "npm", args: ["install", "-g", "@profullstack/crawlproof"] },
+  },
   timer: {
     desc: "Profullstack timer - track time against projects, for people and for agents",
     bin: "timer",

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");