agent.libx.js 0.94.18 → 0.94.20

package/README.md

@@ -106,7 +106,7 @@ agentx --resume <id> "…"    # resume a specific session
 - **Filesystem + Shell** — by default the CLI has **full real-filesystem access like Claude Code** (root `/` is the machine root, the launch dir is the working dir, absolute host paths and above-cwd reach both work) with a **real `/bin/sh`** (`Shell` tool) so the agent can run git, bun, node, curl, and any installed binary. Secrets (`.env`, `.ssh`, keys, `.git`) stay hidden by the jail; env secrets are scrubbed from the child shell. `--sandbox` instead operates over an in-memory copy of the working dir with a VFS-only `bash` — the real disk is never touched. `--boddb <dir>` runs over a **persistent database workspace** (a bod-db store at `<dir>` — `meta.db` tree + `files/` bytes) that survives across runs while the real disk stays untouched; DB-native by default, or add `--seed` to hydrate it from cwd on the first run. `--no-shell` forces the VFS bash in disk mode. `--harden` OS-sandboxes the real shell (macOS `sandbox-exec` / Linux `bwrap`): writes confined to cwd+tmp, outbound network blocked (`--harden-net` keeps network); commands fail closed when no wrapper exists. (`/sandbox` shows the active mode.)
 - **Sessions** — every conversation persists to `./.agent/sessions/<id>.json`; `--continue`/`--resume` (and `/sessions`, `/resume`) pick it back up, *with memory across turns* — a REPL turn sees the previous one. A global symlink index at `~/.agent/sessions/` enables cross-project lookup: `--resume 090715-myproject` resolves from any directory, and `/sessions all` lists every project's sessions in one picker.
 - **Diffs** — every `Edit`/`Write`/`MultiEdit` renders a colorized `+/-` diff (TTY-gated; plain when piped).
-- **Slash commands** — `/help /tools /model /compact /memory /clear /sessions /resume /commands /init`; `/compact <focus>` preserves matching lines from the folded span; `/memory` opens the memory index in `$EDITOR`; user-defined `./.agent/commands/<name>.md` are invokable directly as `/<name>` (the same registry the model's `SlashCommand` tool uses).
+- **Slash commands** — `/help /tools /model /compact /memory /clear /sessions /resume /commands /init`; `/compact <focus>` preserves matching lines from the folded span; `/memory` opens the memory index in `$EDITOR`; user-defined `./.agent/commands/<name>.md` are invokable directly as `/<name>` (the same registry the model's `SlashCommand` tool uses). Skills/commands created **mid-session** are picked up automatically each turn (delivered as a cache-friendly `<system-reminder>` delta, like Claude Code) and the `Skill`/`SlashCommand` tools rescan on a name miss; `/reload` forces a full catalog + system-prompt rebuild.
 - **Live chrome** — the thinking spinner shows elapsed seconds + `esc to interrupt`; the terminal tab title tracks the session topic; a bell rings when a long (>10s) turn finishes in a backgrounded tab; the footer warns at 80%/90% context pressure and auto-trims announce themselves.
 - **`/transcript [n]`** — the full session transcript including complete tool-result bodies (the past-turn equivalent of Ctrl-O live verbose), paged through `less`; **`/doctor`** — one-shot environment sanity check (keys, model pricing, config, session-store writability, memory, MCP mounts).
 - **Syntax-highlighted code fences** — ```` ```ts ```` (and js/py/sh/go/rust/…) blocks render with keywords bold, strings green, numbers cyan, comments dim; unknown languages keep the plain cyan body. **TodoWrite plans** pin a compact `☑ 2/5 · current step` line into the idle footer.

package/dist/{Agent-COa80xYy.d.ts → Agent-DmsB5hzp.d.ts}

@@ -1,5 +1,5 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, e as MessageContent } from './tools-GPWp7oXq.js';
+import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, e as MessageContent } from './tools-9AUK6SG2.js';
 
 /**
  * Hooks — deterministic interception points around tool execution, run by the
@@ -209,7 +209,8 @@ declare class AgentOptions {
     systemPrompt: string;
     tools: AgentTool[];
     maxSteps: number;
-    /** Hard ceiling on accumulated tokens (prompt+completion) across the run. 0 = unbounded. */
+    /** Hard ceiling on accumulated tokens (prompt+completion) across the run; cache READS count at 0.1×
+     *  (their real price) so a fat cached context doesn't trip the guard on healthy turns. 0 = unbounded. */
     maxTokens: number;
     /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
     timeoutMs: number;
@@ -317,6 +318,10 @@ declare class Agent {
     private prepared;
     private systemPromptCache;
     private started;
+    private parkedMs;
+    /** Time a human-blocking await (a permission/plan prompt) and bank it in `parkedMs` so idle prompt
+     *  time never trips the wall-clock kill-switch. The agent did no work while parked on the user. */
+    private park;
     /** Force the next `send()`/`run()` to rebuild the system prompt, tools, plan-mode and permission hooks
      *  from `options` — apply mid-conversation changes to `planMode`/`permissions`/`model` etc. (prepare()
      *  is otherwise memoized per conversation). */

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
-import { h as RunResult, R as ReasoningEffort } from './Agent-COa80xYy.js';
+import { h as RunResult, R as ReasoningEffort } from './Agent-DmsB5hzp.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, c as ContentPart } from './tools-GPWp7oXq.js';
+import { M as Message, c as ContentPart } from './tools-9AUK6SG2.js';
 
 /**
  * On-disk session store for the CLI: each conversation is one JSON file at

package/dist/cli.js

@@ -1984,7 +1984,7 @@ function parseFrontmatter(md) {
   const b = block || md.slice(0, 600);
   return { name: grabField(b, "name"), description: grabField(b, "description") };
 }
-async function loadSkills(fs, dir, opts = {}) {
+async function scanSkills(fs, dir) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   for (const d of Array.isArray(dir) ? dir : [dir]) {
@@ -1999,6 +1999,10 @@ async function loadSkills(fs, dir, opts = {}) {
       }
     }
   }
+  return skills;
+}
+async function loadSkills(fs, dir, opts = {}) {
+  const skills = await scanSkills(fs, dir);
   if (skills.length === 0) return { skills, catalog: "" };
   const { kept, rest } = topByRelevance(skills, opts.relevanceHint ?? "", (s) => `${s.name} ${s.description}`, opts.max ?? MAX_CATALOG);
   const catalog = "## Skills (load one before acting on a matching task)\n" + kept.map((s) => `- **${s.name}** \u2014 ${s.description} (\`${s.path}\`)`).join("\n") + (rest.length ? `
@@ -2008,8 +2012,13 @@ async function loadSkills(fs, dir, opts = {}) {
     description: "Load a skill by name \u2014 returns its full instructions (SKILL.md). Use when a task matches a listed skill.",
     parameters: { type: "object", required: ["name"], properties: { name: { type: "string" } } },
     async run({ name }, ctx) {
-      const s = skills.find((x) => x.name === name);
-      if (!s) return `Error: no skill named '${name}'. Available: ${skills.map((x) => x.name).join(", ")}`;
+      let s = skills.find((x) => x.name === name);
+      if (!s) {
+        const fresh = await scanSkills(ctx.fs, dir);
+        s = fresh.find((x) => x.name === name);
+        if (!s) return `Error: no skill named '${name}'. Available: ${fresh.map((x) => x.name).join(", ")}`;
+        skills.push(s);
+      }
       return ctx.fs.readFile(s.path);
     }
   };
@@ -2050,7 +2059,7 @@ async function expandCommand(fs, cmd, args) {
   const { body } = parseFrontmatter2(await fs.readFile(cmd.path));
   return embedFiles(expandTemplate(body, args), fs);
 }
-async function loadCommands(fs, dir, opts = {}) {
+async function scanCommands(fs, dir) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
   for (const d of Array.isArray(dir) ? dir : [dir]) {
@@ -2065,6 +2074,10 @@ async function loadCommands(fs, dir, opts = {}) {
       commands.push({ name, description: fm.description || "", path });
     }
   }
+  return commands;
+}
+async function loadCommands(fs, dir, opts = {}) {
+  const commands = await scanCommands(fs, dir);
   if (commands.length === 0) return { commands, catalog: "" };
   const { kept, rest } = topByRelevance(commands, opts.relevanceHint ?? "", (c) => `${c.name} ${c.description}`, opts.max ?? MAX_CATALOG2);
   const catalog = "## Slash commands (reusable prompt templates)\n" + kept.map((c) => `- **/${c.name}** \u2014 ${c.description} (\`${c.path}\`)`).join("\n") + (rest.length ? `
@@ -2079,8 +2092,13 @@ async function loadCommands(fs, dir, opts = {}) {
     },
     async run({ name, args }, ctx) {
       const slug2 = String(name ?? "").replace(/^\//, "");
-      const c = commands.find((x) => x.name === slug2);
-      if (!c) return `Error: no command named '${slug2}'. Available: ${commands.map((x) => x.name).join(", ")}`;
+      let c = commands.find((x) => x.name === slug2);
+      if (!c) {
+        const fresh = await scanCommands(ctx.fs, dir);
+        c = fresh.find((x) => x.name === slug2);
+        if (!c) return `Error: no command named '${slug2}'. Available: ${fresh.map((x) => x.name).join(", ")}`;
+        commands.push(c);
+      }
       return expandCommand(ctx.fs, c, String(args ?? ""));
     }
   };
@@ -2590,9 +2608,10 @@ function planMode(opts) {
     parameters: { type: "object", required: ["plan"], properties: { plan: { type: "string", description: "the concrete steps you will take" } } },
     async run({ plan }, _ctx) {
       if (opts?.host?.confirm) {
-        const ok = await opts.host.confirm(`Approve this plan?
+        const confirm = opts.host.confirm(`Approve this plan?
 
 ${String(plan ?? "")}`);
+        const ok = await (_ctx?.parkHuman ? _ctx.parkHuman(confirm) : confirm);
         if (!ok) return "Plan not approved. Revise it and call ExitPlanMode again.";
       }
       approved = true;
@@ -2748,7 +2767,8 @@ var AgentOptions = class {
   tools = defaultTools();
   maxSteps = 25;
   // --- automatic kill-switches (always on; protect the API budget against runaway loops/abuse) ---
-  /** Hard ceiling on accumulated tokens (prompt+completion) across the run. 0 = unbounded. */
+  /** Hard ceiling on accumulated tokens (prompt+completion) across the run; cache READS count at 0.1×
+   *  (their real price) so a fat cached context doesn't trip the guard on healthy turns. 0 = unbounded. */
   maxTokens = 2e5;
   /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
   timeoutMs = 12e4;
@@ -2850,6 +2870,18 @@ var Agent = class _Agent {
   // the assembled system prompt from the last prepare()
   started = false;
   // session-start lifecycle hook fires once per conversation
+  parkedMs = 0;
+  // cumulative time blocked on the HUMAN (permission/plan prompts) — excluded from the timeout
+  /** Time a human-blocking await (a permission/plan prompt) and bank it in `parkedMs` so idle prompt
+   *  time never trips the wall-clock kill-switch. The agent did no work while parked on the user. */
+  async park(p) {
+    const t = Date.now();
+    try {
+      return await p;
+    } finally {
+      this.parkedMs += Date.now() - t;
+    }
+  }
   /** Force the next `send()`/`run()` to rebuild the system prompt, tools, plan-mode and permission hooks
    *  from `options` — apply mid-conversation changes to `planMode`/`permissions`/`model` etc. (prepare()
    *  is otherwise memoized per conversation). */
@@ -2878,6 +2910,7 @@ var Agent = class _Agent {
     if (this.options.lintOnWrite) this.ctx.lint = checkSyntax;
     this.ctx.ai = this.options.ai;
     this.ctx.model = this.options.model;
+    this.ctx.parkHuman = (p) => this.park(p);
     if (this.options.backgroundJobs) this.ctx.jobs = new SandboxJobRegistry();
   }
   /**
@@ -3023,19 +3056,21 @@ var Agent = class _Agent {
     const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
     let usageEstimated = false;
     const start = Date.now();
+    this.parkedMs = 0;
     let toolCallsTotal = 0;
     let lastFp = "";
     let repeats = 0;
     const kill = (finishReason) => {
-      log3.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, ms=${Date.now() - start})`);
+      log3.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
       this.ctx.jobs?.killAll();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated };
     };
     while (true) {
       if (o.signal?.aborted) return kill("aborted");
       if (steps >= o.maxSteps) return kill("max_steps");
-      if (o.timeoutMs && Date.now() - start >= o.timeoutMs) return kill("timeout");
-      if (o.maxTokens && usage.totalTokens >= o.maxTokens) return kill("budget");
+      if (o.timeoutMs && Date.now() - start - this.parkedMs >= o.timeoutMs) return kill("timeout");
+      const budgetTokens = usage.totalTokens - 0.9 * usage.cacheReadTokens;
+      if (o.maxTokens && budgetTokens >= o.maxTokens) return kill("budget");
       steps++;
       this.options.host?.notify?.({ kind: "turn_start", message: `step ${steps}` });
       let res;
@@ -3170,7 +3205,7 @@ var Agent = class _Agent {
     const hooks = this.activeHooks;
     const call = { name: tc.function.name, args };
     const meta = { id: tc.id };
-    const decision = await hooks?.preToolUse?.(call, meta);
+    const decision = await this.park(Promise.resolve(hooks?.preToolUse?.(call, meta)));
     if (decision?.block) {
       const blocked = `Blocked by hook: ${decision.reason ?? "no reason given"}`;
       log3.debug(`${tc.function.name} -> ${blocked}`);
@@ -3212,6 +3247,7 @@ var Agent = class _Agent {
       this.ctx.emit = void 0;
     }
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
+    if (images?.length && !result) result = `[${images.length} image${images.length > 1 ? "s" : ""} attached]`;
     const cap = this.options.maxToolResultBytes ?? 0;
     if (!threw && cap > 0 && result.length > cap) {
       const info = { tool: tc.function.name, args };
@@ -7457,6 +7493,12 @@ var EditorState = class _EditorState {
   pasteChar(c) {
     this.pasteBuf += c;
   }
+  /** Actively grab a clipboard image and attach it (Ctrl-V; same hook as the empty-paste path). */
+  grabClipboard() {
+    const att = this.onEmptyPaste?.();
+    if (att) this.attach(att.display, att.ref);
+    return !!att;
+  }
   endPaste() {
     this.pasting = false;
     const text = this.pasteBuf;
@@ -7887,6 +7929,10 @@ function applyKey(s, key, str) {
   if (key?.ctrl && k === "u") return s.killToStart(), "none";
   if (key?.ctrl && k === "k") return s.killToEnd(), "none";
   if (key?.ctrl && k === "y") return s.yank(), "none";
+  if (key?.ctrl && k === "v") {
+    s.grabClipboard();
+    return "none";
+  }
   if (str === "") return s.undo(), "none";
   if (key?.meta && k === "b") return s.wordLeft(), "none";
   if (key?.meta && k === "f") return s.wordRight(), "none";
@@ -8774,7 +8820,7 @@ REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to co
 REPL shortcuts: Shift+Tab cycles permission posture (ask \u2192 accept-edits \u2192 plan) \xB7 Alt+T toggles reasoning \xB7 Alt+P switches model \xB7 Ctrl+O toggles verbose tool output \xB7 \u2192 or Tab accepts the dim history ghost-suggestion \xB7 Alt+S/Ctrl+S stash/unstash.
 REPL stash: type while a turn is running \u2192 Enter queues it (auto-submits when the turn finishes). Alt+S (or Ctrl+S) with text stashes it; on an empty prompt pops the next entry for editing.
 REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Ctrl-_ undo \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen. Set editorMode:'vim' (or /config) for modal vim editing.
-REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; /paste grabs a clipboard image (macOS).`;
+REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; Ctrl-V or /paste grabs a clipboard image (macOS).`;
 function newestModel() {
   return listModels().slice().sort((a, b) => (getModelInfo(b)?.releaseDate ?? "").localeCompare(getModelInfo(a)?.releaseDate ?? ""))[0] ?? "";
 }
@@ -9972,6 +10018,25 @@ async function repl(args, ai, cfg, cwd) {
   const adots = (sub) => [adot(sub), `${fsBase}/.claude/${sub}`, `${homedir6()}/.agent/${sub}`, `${homedir6()}/.claude/${sub}`];
   const cmds = (await loadCommands(fs, adots("commands"))).commands;
   const skills = (await loadSkills(fs, adots("skills"))).skills;
+  const refreshCatalogs = async () => {
+    const [freshSkills, freshCmds] = await Promise.all([scanSkills(fs, adots("skills")), scanCommands(fs, adots("commands"))]);
+    const diff = (kind, old, fresh) => {
+      const had = new Set(old.map((x) => x.name)), has = new Set(fresh.map((x) => x.name));
+      const added = fresh.filter((x) => !had.has(x.name)), removed = old.filter((x) => !has.has(x.name));
+      old.splice(0, old.length, ...fresh);
+      return [
+        ...added.map((x) => `+ ${kind} **${x.name}** \u2014 ${x.description}`),
+        ...removed.map((x) => `- ${kind} ${x.name} (removed)`)
+      ];
+    };
+    const lines = [...diff("skill", skills, freshSkills), ...diff("command", cmds, freshCmds)];
+    if (!lines.length) return "";
+    return `<system-reminder>
+The skill/command catalog changed on disk since the session started:
+${lines.join("\n")}
+Added entries are loadable now via the Skill/SlashCommand tools; removed ones are gone even if still listed in the system prompt.
+</system-reminder>`;
+  };
   const histPath = join9(cwd, ".agent", "history");
   const history = existsSync8(histPath) ? readFileSync5(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
   const remember = (line) => {
@@ -10076,6 +10141,14 @@ async function repl(args, ai, cfg, cwd) {
   };
   const announcedTasks = /* @__PURE__ */ new Set();
   const turn = async (task) => {
+    const delta = await refreshCatalogs().catch((e) => {
+      log17.debug("catalog refresh failed", e);
+      return "";
+    });
+    if (delta) {
+      err(dim("  \u27F3 skill/command catalog changed \u2014 delta attached to this turn\n"));
+      task += "\n\n" + delta;
+    }
     const r = await runTurn(face, store, session, task, duplex ? void 0 : checkpoints, cwd, sendVia);
     if (voiceIO) {
       voiceEchoEnd();
@@ -10314,6 +10387,17 @@ ${extra}` : body);
         if (hookCount) ok(`hooks: ${hookCount} configured`);
       }
     },
+    reload: {
+      desc: "rescan skills/commands dirs and rebuild the system prompt (one cache miss) \u2014 picks up entries created mid-session",
+      run: async () => {
+        await refreshCatalogs().catch((e) => {
+          log17.debug("catalog refresh failed", e);
+        });
+        face.reprepare();
+        err(green(`  \u2713 reloaded \u2014 ${skills.length} skill(s), ${cmds.length} command(s); system prompt rebuilds on next message
+`));
+      }
+    },
     cwd: {
       desc: "print the working directory (to switch, relaunch with -C <dir>)",
       run: (a) => {
@@ -10949,7 +11033,7 @@ ${extra}` : body);
     },
     init: { desc: "scaffold ./AGENTS.md project instructions", run: () => initInstructions(cwd) },
     paste: {
-      desc: "attach an image from the clipboard (macOS) \u2014 /paste [message] sends now, /paste alone attaches to your next message",
+      desc: "attach an image from the clipboard (macOS, = Ctrl-V) \u2014 /paste [message] sends now, /paste alone attaches to your next message",
       run: async (a) => {
         const att = grabClipboardAttachment();
         if (!att) {