agent.libx.js 0.94.19 → 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/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 ?? ""));
     }
   };
@@ -10000,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) => {
@@ -10104,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();
@@ -10342,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) => {