@divergeai/cli 0.1.11 → 0.1.13

package/README.md

@@ -57,7 +57,7 @@ the gateway, keeping everything else in the file:
 | `claude` | `~/.claude/settings.json` (or `./.claude/settings.local.json` with `--scope project`): the gateway base URL and `diverge token` as the key helper; `--project-id` adds the project header, `--model-discovery` lets Claude Code list the gateway's models |
 | `opencode` | `~/.config/opencode/opencode.json`: a `divergent-<surface>` provider reading `DIVERGENT_TOKEN` |
 | `codex` | `~/.codex/config.toml`: a `divergent` provider block with `diverge token` as its auth command; `--print` shows it instead |
-| `dsh` | `$DSH_HOME/divergent-<surface>.yml`: a patch overlay with the models the gateway serves, dsh's DeepSeek adapter, telemetry upload and search turned off, and the platform's web search served over `diverge tools bridge` (row `mcp-divergent`) |
+| `dsh` | `$DSH_HOME/divergent-<surface>.yml`: a patch overlay with the models the gateway serves and dsh's DeepSeek adapter, telemetry upload and vendor search turned off; the Divergent agent preset; and your skills in `$DSH_HOME/skills`, through which the agent reaches every platform tool, web search included, from dsh's shell with `diverge tools` |
 
 `diverge agents run dsh` launches DeepSeek Harness on the overlay and keeps
 its token fresh in dsh's own credentials file until it exits. With nothing
@@ -77,27 +77,39 @@ Claude Code and Codex search through their model vendor's own server tool,
 which the gateway forwards unchanged when the organization's upstream is
 Anthropic or OpenAI. Every other model, dsh included, searches through the
 platform's `search_online` tool: one key on the platform, metered and audited
-per organization. The dsh overlay wires it in as `mcp__divergent__search_online`
-(dsh's DeepSeek-backed `web_search` needs a vendor key and is off; `web_fetch`
-stays). dsh's web profile composes the model's tools per agent preset, where a
-patch cannot reach, so `diverge agents setup dsh` and `run dsh` also derive a
-**Divergent** preset from the installed dsh's `standard` one, with the vendor
-search left out of the model's tools, under `$DSH_HOME/.agent-presets/`, and
-make it the default for new web sessions once in `settings.yaml` (a preset you
-pick yourself there stays picked). To give Claude Code or Codex the same tool
-for a non-native upstream, register the bridge once:
+per organization. In dsh the agent reaches it the way it reaches every
+platform tool, from the shell: `diverge tools call search_online`, which the
+installed `diverge` skill names. dsh's DeepSeek-backed `web_search` needs a
+vendor key and is off; `web_fetch` stays. To give Claude Code or Codex the
+same tool for a non-native upstream, the stdio bridge is the opt-in for a
+client that wants it as a native tool:
 
 ```bash
 claude mcp add --scope user divergent -- diverge tools bridge --tools search_online
 ```
 
-```toml
-# ~/.codex/config.toml
-[mcp_servers.divergent]
-command = "diverge"
-args = ["tools", "bridge", "--tools", "search_online"]
+## Skills
+
+A skill is a procedure over the tools it names, in the Agent Skills format
+every harness reads (`<name>/SKILL.md`). The organization authors its skills
+on the platform; you get the ones whose every named tool you can run, plus
+the CLI's own `diverge` skill, which tells an agent how to reach the platform's
+tools from a shell.
+
+```bash
+diverge skills list       # what the platform serves you
+diverge skills install    # into ~/.claude/skills, ~/.codex/skills and $DSH_HOME/skills
+diverge skills status     # what each folder holds against the platform
 ```
 
+`agents setup claude|codex|dsh` and `agents run dsh` install them as well, so
+a harness the CLI set up has the skills from its first session. A refresh
+replaces the CLI's own folders, retires the ones the organization retired, and
+never touches a skill you authored beside them. The skills are the tool
+surface: an agent reaches every platform tool from its shell with `diverge
+tools`, which costs nothing until a tool is called, and the `diverge` skill
+shows it how, file-based arguments and batches included.
+
 ## Platform tools
 
 Every command takes the scope it acts in: `--organization-id` (or
@@ -108,8 +120,16 @@ resource inside a project, `--project-id` (or `DIVERGENT_PROJECT_ID`).
 diverge tools list --filter rbac             # find candidates
 diverge tools describe rbac_assign_role      # one schema, on demand
 diverge tools call rbac_list_roles --args-json '{}'
+diverge tools call inventory_lookup_stock --args-file args.json   # or --args-json - to read stdin
+diverge tools run calls.json --wait          # several calls from one file, one JSON line of outcome each
 ```
 
+Put arguments in a file or on stdin when a shell may touch them: Windows
+PowerShell strips the double quotes inside an inline argument. `run` takes a
+JSON array of `{"tool": "...", "args": {...}}` (or one per line), runs them in
+order, and exits with the worst outcome: 1 failed, 4 rejected, 5 expired,
+3 pending, else 0.
+
 A write that needs a human is not refused: it is persisted as a pending
 invocation, decided in the platform's approval inbox, and read back here by
 id. Branch on the exit code, never on text:

package/dist/diverge.mjs

@@ -114,17 +114,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path12) {
-      const ctrl = callVisitor(key, node, visitor, path12);
+    function visit_(key, node, visitor, path13) {
+      const ctrl = callVisitor(key, node, visitor, path13);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visit_(key, ctrl, visitor, path12);
+        replaceNode(key, path13, ctrl);
+        return visit_(key, ctrl, visitor, path13);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path13 = Object.freeze(path13.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path12);
+            const ci = visit_(i, node.items[i], visitor, path13);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -135,13 +135,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = visit_("key", node.key, visitor, path12);
+          path13 = Object.freeze(path13.concat(node));
+          const ck = visit_("key", node.key, visitor, path13);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path12);
+          const cv = visit_("value", node.value, visitor, path13);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -162,17 +162,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path12) {
-      const ctrl = await callVisitor(key, node, visitor, path12);
+    async function visitAsync_(key, node, visitor, path13) {
+      const ctrl = await callVisitor(key, node, visitor, path13);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visitAsync_(key, ctrl, visitor, path12);
+        replaceNode(key, path13, ctrl);
+        return visitAsync_(key, ctrl, visitor, path13);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path13 = Object.freeze(path13.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path12);
+            const ci = await visitAsync_(i, node.items[i], visitor, path13);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -183,13 +183,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path12);
+          path13 = Object.freeze(path13.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path13);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path12);
+          const cv = await visitAsync_("value", node.value, visitor, path13);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -216,23 +216,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path12) {
+    function callVisitor(key, node, visitor, path13) {
       if (typeof visitor === "function")
-        return visitor(key, node, path12);
+        return visitor(key, node, path13);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path12);
+        return visitor.Map?.(key, node, path13);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path12);
+        return visitor.Seq?.(key, node, path13);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path12);
+        return visitor.Pair?.(key, node, path13);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path12);
+        return visitor.Scalar?.(key, node, path13);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path12);
+        return visitor.Alias?.(key, node, path13);
       return void 0;
     }
-    function replaceNode(key, path12, node) {
-      const parent = path12[path12.length - 1];
+    function replaceNode(key, path13, node) {
+      const parent = path13[path13.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -842,10 +842,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path12, value) {
+    function collectionFromPath(schema, path13, value) {
       let v = value;
-      for (let i = path12.length - 1; i >= 0; --i) {
-        const k = path12[i];
+      for (let i = path13.length - 1; i >= 0; --i) {
+        const k = path13[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -864,7 +864,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[Symbol.iterator]().next().done;
+    var isEmptyPath = (path13) => path13 == null || typeof path13 === "object" && !!path13[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -894,11 +894,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path12, value) {
-        if (isEmptyPath(path12))
+      addIn(path13, value) {
+        if (isEmptyPath(path13))
           this.add(value);
         else {
-          const [key, ...rest] = path12;
+          const [key, ...rest] = path13;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -912,8 +912,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        const [key, ...rest] = path12;
+      deleteIn(path13) {
+        const [key, ...rest] = path13;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -927,8 +927,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        const [key, ...rest] = path12;
+      getIn(path13, keepScalar) {
+        const [key, ...rest] = path13;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -946,8 +946,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path12) {
-        const [key, ...rest] = path12;
+      hasIn(path13) {
+        const [key, ...rest] = path13;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -957,8 +957,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        const [key, ...rest] = path12;
+      setIn(path13, value) {
+        const [key, ...rest] = path13;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3473,9 +3473,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path12, value) {
+      addIn(path13, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path12, value);
+          this.contents.addIn(path13, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3550,14 +3550,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        if (Collection.isEmptyPath(path12)) {
+      deleteIn(path13) {
+        if (Collection.isEmptyPath(path13)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path13) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3572,10 +3572,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        if (Collection.isEmptyPath(path12))
+      getIn(path13, keepScalar) {
+        if (Collection.isEmptyPath(path13))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path13, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3586,10 +3586,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path12) {
-        if (Collection.isEmptyPath(path12))
+      hasIn(path13) {
+        if (Collection.isEmptyPath(path13))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path13) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3606,13 +3606,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value) {
-        if (Collection.isEmptyPath(path12)) {
+      setIn(path13, value) {
+        if (Collection.isEmptyPath(path13)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path13), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path12, value);
+          this.contents.setIn(path13, value);
         }
       }
       /**
@@ -5572,9 +5572,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path12) => {
+    visit.itemAtPath = (cst, path13) => {
       let item = cst;
-      for (const [field, index] of path12) {
+      for (const [field, index] of path13) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5583,23 +5583,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path12) => {
-      const parent = visit.itemAtPath(cst, path12.slice(0, -1));
-      const field = path12[path12.length - 1][0];
+    visit.parentCollection = (cst, path13) => {
+      const parent = visit.itemAtPath(cst, path13.slice(0, -1));
+      const field = path13[path13.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path12, item, visitor) {
-      let ctrl = visitor(item, path12);
+    function _visit(path13, item, visitor) {
+      let ctrl = visitor(item, path13);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path12.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path13.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5610,10 +5610,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path12);
+            ctrl = ctrl(item, path13);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path13) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6915,14 +6915,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs10 = this.flowScalar(this.type);
+              const fs13 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs10, sep: [] });
+                map.items.push({ start, key: fs13, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs10);
+                this.stack.push(fs13);
               } else {
-                Object.assign(it, { key: fs10, sep: [] });
+                Object.assign(it, { key: fs13, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7050,13 +7050,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs10 = this.flowScalar(this.type);
+              const fs13 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs10, sep: [] });
+                fc.items.push({ start: [], key: fs13, sep: [] });
               else if (it.sep)
-                this.stack.push(fs10);
+                this.stack.push(fs13);
               else
-                Object.assign(it, { key: fs10, sep: [] });
+                Object.assign(it, { key: fs13, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7382,12 +7382,12 @@ var CliError = class extends Error {
 };
 
 // src/commands/agents.ts
-import fs7 from "node:fs";
-import path10 from "node:path";
-import { parseArgs } from "node:util";
+import fs8 from "node:fs";
+import path11 from "node:path";
+import { parseArgs as parseArgs2 } from "node:util";
 
 // src/version.ts
-var VERSION = true ? "0.1.11" : "dev";
+var VERSION = true ? "0.1.13" : "dev";
 var USER_AGENT = `diverge/${VERSION}`;
 
 // src/http.ts
@@ -7928,7 +7928,6 @@ function dshDefaultModel(models, requested) {
   if (requested) return requested;
   return models.includes(DSH_SHIPPED_DEFAULT_MODEL) ? DSH_SHIPPED_DEFAULT_MODEL : models[0];
 }
-var DSH_BRIDGE_TOOLS = ["search_online"];
 function dshPatchYaml(options) {
   const tokenEnv = options.tokenEnv ?? "DIVERGENT_TOKEN";
   const route = `divergent-${options.surface}`;
@@ -7961,42 +7960,20 @@ function dshPatchYaml(options) {
     "  disabled: true",
     "- id: session-telemetry-otel",
     "  disabled: true",
-    ...options.bridge ? dshSearchRows(options.bridge) : [],
+    ...dshSearchRows(),
     ""
   ].join("\n");
 }
-function dshSearchRows(bridge) {
-  const rows = [
+function dshSearchRows() {
+  return [
     "- id: web-search-deepseek",
     "  disabled: true",
     "- id: tool-web",
     "  config:",
     "    search: false",
     "    fetch: true",
-    "    searchTimeoutMs: 60000",
-    "- insert:",
-    "    - id: mcp-divergent",
-    "      name: '@deepseek-ai/dsh-mcp-client'",
-    "      config:",
-    "        serverName: divergent",
-    "        transport: stdio",
-    `        command: ${JSON.stringify(bridge.command)}`,
-    `        args: [${bridge.args.map((arg) => JSON.stringify(arg)).join(", ")}]`
+    "    searchTimeoutMs: 60000"
   ];
-  const env = Object.entries(bridge.env ?? {});
-  if (env.length) {
-    rows.push("        env:");
-    for (const [key, value] of env) rows.push(`          ${key}: ${JSON.stringify(value)}`);
-  }
-  return rows;
-}
-function dshBridge(self, env = process.env) {
-  const passthrough = {};
-  for (const key of ["DIVERGE_HOME", "DIVERGENT_API_URL", "DIVERGENT_DIVERGE_CLIENT_ID"]) {
-    const value = env[key]?.trim();
-    if (value) passthrough[key] = value;
-  }
-  return { command: self.command, args: [...self.args, "tools", "bridge", "--tools", DSH_BRIDGE_TOOLS.join(",")], env: Object.keys(passthrough).length ? passthrough : void 0 };
 }
 function servedIds(overlay) {
   const rows = (0, import_yaml.parse)(overlay) ?? [];
@@ -8079,8 +8056,8 @@ function divergentPreset(shippedComposition) {
   }
   return [
     `# The Divergent agent preset: dsh's shipped "standard" preset with the vendor web`,
-    "# search left out of the model's tools; the platform's search_online arrives over the",
-    "# bridge (row mcp-divergent). Derived from the installed dsh by `diverge agents",
+    "# search left out of the model's tools; platform tools, search included, are reached",
+    "# from the shell through `diverge tools`. Derived from the installed dsh by `diverge agents",
     "# setup dsh` and `diverge agents run dsh` on every run; edits do not survive.",
     ...lines.slice(0, start),
     ...row,
@@ -8237,11 +8214,229 @@ function runDsh(options) {
   });
 }
 
-// src/agents/rotate.ts
+// src/commands/skills.ts
+import { parseArgs } from "node:util";
+
+// src/skills/bundled.ts
+var DIVERGE_SKILL = {
+  name: "diverge",
+  description: "Reach the Divergent platform's tools from a shell with the diverge CLI: discover, read one schema, call, and read back a call that waits on a person. Use when a task needs the organization's records, diagnostics, documents or governed actions, which the platform holds and this skill's siblings name.",
+  tools: [],
+  updatedAt: `diverge/${VERSION}`,
+  content: `---
+name: diverge
+description: Reach the Divergent platform's tools from a shell with the diverge CLI - discover, read one schema, call, and read back a call that waits on a person. Use when a task needs the organization's records, diagnostics, documents or governed actions, which the platform holds and this skill's siblings name.
+---
+
+# diverge: the platform's tools from a shell
+
+The organization's tools run on the platform, as the signed-in person, with
+their permissions and audit trail. Nothing runs locally; the CLI is the
+transport. Keep the catalog out of context: pull the one schema you need.
+
+\`\`\`bash
+diverge tools list --filter <word>     # find candidates by name or capability
+diverge tools describe <tool>          # the one schema, on demand
+diverge tools call <tool> --args-file args.json   # arguments from a file (see below)
+diverge tools call search_online --args-json '{"query": "..."}'   # web search is a platform tool too
+\`\`\`
+
+The other skills installed beside this one are the organization's own
+procedures; each names the tools it is about. Prefer a procedure over
+guessing a tool.
+
+## Arguments: write them to a file
+
+Shells mangle JSON. Windows PowerShell strips the double quotes inside an
+inline argument, so \`--args-json '{"a":"b"}'\` can arrive as \`{a:b}\`.
+Write the object to a file and pass \`--args-file\`, or pipe it with
+\`--args-json -\`; both are exact on every shell. A worked call:
+
+\`\`\`bash
+diverge tools describe divix-mcp_implementation_search_source
+cat > /tmp/args.json <<'JSON'
+{"query": "cr9b5_serial", "limit": 20}
+JSON
+diverge tools call divix-mcp_implementation_search_source --args-file /tmp/args.json
+\`\`\`
+
+## Several calls at once
+
+When a task needs a sequence of calls, write them to one file and run it
+once instead of one round trip each: \`diverge tools run calls.json\`, a JSON
+array of \`{"tool": "...", "args": {...}}\` (or one per line). Calls run in
+order; each prints one JSON line of outcome; the exit code is the worst of
+them.
+
+## Exit codes are the contract
+
+| Code | Meaning | Do |
+| --- | --- | --- |
+| 0 | executed | use the result |
+| 3 | pending: a person must decide it in Compass | hand over the printed link, keep working, read it back later |
+| 4 | rejected, with the person's reason | re-plan; the reason is data |
+| 5 | expired: nobody decided in time | raise a fresh call if still needed |
+| 1 | executed but failed, or a transport error | read the message; do not re-raise blindly |
+
+A pending call prints its invocation id and a link. Read the outcome with
+\`diverge tools invocation <id>\` (add \`--wait\` to poll at the platform's
+cadence). Never decide your own invocation from any surface you can drive.
+
+## Session
+
+- \`diverge status\` says who is signed in and at which organization; every
+  call runs there. \`diverge org use <id|name>\` moves the session.
+- A missing login or scope prints the command to run; \`diverge login\` opens
+  the browser.
+- \`--json\` on \`list\`, \`describe\` and \`invocation\` gives raw records.
+`
+};
+
+// src/skills/install.ts
+import fs6 from "node:fs";
 import os6 from "node:os";
 import path8 from "node:path";
+var HARNESSES = ["claude", "codex", "dsh"];
+var SKILLS_MANIFEST = ".diverge-skills.json";
+function skillsRoot(harness, env = process.env) {
+  switch (harness) {
+    case "claude":
+      return path8.join(env.CLAUDE_CONFIG_DIR?.trim() || path8.join(os6.homedir(), ".claude"), "skills");
+    case "codex":
+      return path8.join(env.CODEX_HOME?.trim() || path8.join(os6.homedir(), ".codex"), "skills");
+    case "dsh":
+      return path8.join(dshHome(env), "skills");
+  }
+}
+function readSkillsManifest(root) {
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(path8.join(root, SKILLS_MANIFEST), "utf8"));
+    if (parsed && typeof parsed === "object" && typeof parsed.skills === "object") return parsed;
+  } catch {
+  }
+  return null;
+}
+function installSkills(root, skills, source, now = () => /* @__PURE__ */ new Date()) {
+  const previous = readSkillsManifest(root);
+  const written = [];
+  for (const skill of skills) {
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(skill.name)) throw new Error(`skill name ${JSON.stringify(skill.name)} is not a folder name`);
+    writeTextAtomic(path8.join(root, skill.name, "SKILL.md"), skill.content, 420);
+    written.push(skill.name);
+  }
+  const removed = [];
+  for (const name of Object.keys(previous?.skills ?? {})) {
+    if (skills.some((skill) => skill.name === name)) continue;
+    fs6.rmSync(path8.join(root, name), { recursive: true, force: true });
+    removed.push(name);
+  }
+  const manifest = {
+    installedAt: now().toISOString(),
+    source,
+    skills: Object.fromEntries(skills.map((skill) => [skill.name, skill.updatedAt]))
+  };
+  writeJsonAtomic(path8.join(root, SKILLS_MANIFEST), manifest, 420);
+  return { root, written, removed };
+}
+function skillsStatus(root, skills) {
+  const manifest = readSkillsManifest(root);
+  const held = manifest?.skills ?? {};
+  const current = [];
+  const behind = [];
+  const missing = [];
+  for (const skill of skills) {
+    if (!(skill.name in held) || !fs6.existsSync(path8.join(root, skill.name, "SKILL.md"))) missing.push(skill.name);
+    else if (held[skill.name] !== skill.updatedAt) behind.push(skill.name);
+    else current.push(skill.name);
+  }
+  const retired = Object.keys(held).filter((name) => !skills.some((skill) => skill.name === name));
+  return { root, installedAt: manifest?.installedAt ?? null, current, behind, missing, retired };
+}
+
+// src/skills/installable.ts
+async function fetchInstallableSkills(baseUrl, accessToken) {
+  const body = await fetchJson(
+    `${baseUrl.replace(/\/+$/, "")}/api/plugins/symphony/skills/installable`,
+    { headers: { Authorization: `Bearer ${accessToken}` } }
+  );
+  if (!body.success || !body.data) throw new CliError(body.error ?? "The platform answered without skills");
+  return body.data;
+}
+
+// src/commands/skills.ts
+var skillsUsage = `diverge skills <list|install|status> [--harness claude,codex,dsh] [--into <dir>]
+
+  list      the skills the platform serves you: your organization's skills whose tools you can run
+  install   write them, and the CLI's own "diverge" skill, into each harness's user skill folder
+            (~/.claude/skills, ~/.codex/skills, $DSH_HOME/skills); retires the ones the organization retired
+  status    what each folder holds against what the platform serves now
+
+A skill is a procedure over the tools it names; you get the ones whose every
+tool you may run. Re-run install after the organization changes its skills.`;
+async function installableSkillSet(apiUrl, env) {
+  const source = { tokenFile: tokenFile(env), baseUrl: apiUrl, clientId: clientId(env) };
+  const token = await getUserToken(source);
+  const organizationId = tokenClaims(token.access_token).organizationId;
+  if (!organizationId) throw new CliError("The login is not bound to an organization; run: diverge org use <id|name>");
+  const served = await fetchInstallableSkills(apiUrl, token.access_token);
+  return { skills: [DIVERGE_SKILL, ...served.skills], organizationId };
+}
+function harnessesOf(flag) {
+  if (!flag) return [...HARNESSES];
+  const chosen = flag.split(",").map((name) => name.trim()).filter(Boolean);
+  for (const name of chosen) if (!HARNESSES.includes(name)) throw new CliError(`--harness must name some of: ${HARNESSES.join(", ")}`);
+  return chosen;
+}
+function installForHarness(io, harness, skills, apiUrl, into) {
+  const root = into ?? skillsRoot(harness, io.env);
+  const result = installSkills(root, skills, apiUrl);
+  const retired = result.removed.length ? `; retired ${result.removed.join(", ")}` : "";
+  io.stdout(`${harness}: ${result.written.length} skills in ${root} (${result.written.join(", ")})${retired}`);
+}
+async function runSkills(args, io) {
+  const [verb, ...rest] = args;
+  const { values } = parseArgs({ args: rest, options: { harness: { type: "string" }, into: { type: "string" } }, strict: true });
+  const apiUrl = resolveApiUrl(void 0, io.env);
+  switch (verb) {
+    case "list": {
+      const { skills, organizationId } = await installableSkillSet(apiUrl, io.env);
+      io.stdout(`Skills the platform serves you at organization ${organizationId}:`);
+      for (const skill of skills) io.stdout(`  ${skill.name.padEnd(36)} ${skill.tools.length ? skill.tools.join(", ") : "(the CLI itself)"}`);
+      return ExitCode.Ok;
+    }
+    case "install": {
+      const { skills } = await installableSkillSet(apiUrl, io.env);
+      const harnesses = values.into ? [harnessesOf(values.harness)[0]] : harnessesOf(values.harness);
+      for (const harness of harnesses) installForHarness(io, harness, skills, apiUrl, values.into);
+      return ExitCode.Ok;
+    }
+    case "status": {
+      const { skills } = await installableSkillSet(apiUrl, io.env);
+      let behind = false;
+      for (const harness of harnessesOf(values.harness)) {
+        const status2 = skillsStatus(values.into ?? skillsRoot(harness, io.env), skills);
+        const parts = [`${status2.current.length} current`];
+        if (status2.behind.length) parts.push(`${status2.behind.length} behind (${status2.behind.join(", ")})`);
+        if (status2.missing.length) parts.push(`${status2.missing.length} missing (${status2.missing.join(", ")})`);
+        if (status2.retired.length) parts.push(`${status2.retired.length} retired (${status2.retired.join(", ")})`);
+        behind ||= status2.behind.length + status2.missing.length + status2.retired.length > 0;
+        io.stdout(`${harness}: ${parts.join(", ")} in ${status2.root}${status2.installedAt ? ` (installed ${status2.installedAt})` : " (never installed)"}`);
+      }
+      if (behind) io.stdout("Run: diverge skills install");
+      return ExitCode.Ok;
+    }
+    default:
+      throw new CliError(`skills needs one of: list, install, status
+
+${skillsUsage}`);
+  }
+}
+
+// src/agents/rotate.ts
+import os7 from "node:os";
+import path9 from "node:path";
 function defaultTokenFilePath() {
-  return path8.join(os6.homedir(), ".divergent", "token");
+  return path9.join(os7.homedir(), ".divergent", "token");
 }
 var MIN_ROTATE_INTERVAL_SECONDS = 60;
 async function rotateTokenFile(loop) {
@@ -8256,19 +8451,19 @@ async function rotateTokenFile(loop) {
 }
 
 // src/agents/self-command.ts
-import fs6 from "node:fs";
-import path9 from "node:path";
+import fs7 from "node:fs";
+import path10 from "node:path";
 function resolveSelfCommand(argv = process.argv, platform = process.platform, execPath = process.execPath) {
   const script = argv[1];
   if (!script) return { command: execPath, args: [] };
   if (platform !== "win32") {
     try {
-      fs6.accessSync(script, fs6.constants.X_OK);
-      return { command: path9.resolve(script), args: [] };
+      fs7.accessSync(script, fs7.constants.X_OK);
+      return { command: path10.resolve(script), args: [] };
     } catch {
     }
   }
-  return { command: execPath, args: [fs6.realpathSync(script)] };
+  return { command: execPath, args: [fs7.realpathSync(script)] };
 }
 function shellCommand(self, ...trailing) {
   return [self.command, ...self.args, ...trailing].map((part) => /[\s"]/.test(part) ? `"${part.replace(/"/g, '\\"')}"` : part).join(" ");
@@ -8295,8 +8490,8 @@ function surfaceOf(value, fallback) {
   throw new CliError(`--surface must be one of: ${SURFACES.join(", ")}`);
 }
 function readJson(file) {
-  if (!fs7.existsSync(file)) return null;
-  return JSON.parse(fs7.readFileSync(file, "utf8"));
+  if (!fs8.existsSync(file)) return null;
+  return JSON.parse(fs8.readFileSync(file, "utf8"));
 }
 async function servedModels(apiUrl, token, surface) {
   return (await listModels(apiUrl, token.access_token, surface)).map((entry) => entry.id);
@@ -8313,25 +8508,32 @@ function syncDivergentPreset(io, binary, home) {
     return;
   }
   const dir = writeDivergentPreset(home, shipped);
-  const settingsPath = path10.join(home, "settings.yaml");
-  const settings = withDivergentPresetDefault(fs7.existsSync(settingsPath) ? fs7.readFileSync(settingsPath, "utf8") : null);
+  const settingsPath = path11.join(home, "settings.yaml");
+  const settings = withDivergentPresetDefault(fs8.existsSync(settingsPath) ? fs8.readFileSync(settingsPath, "utf8") : null);
   if (settings !== null) writeTextAtomic(settingsPath, settings);
   io.stderr(`Agent preset "${DIVERGENT_PRESET_ID}" (${dir}): web sessions search through the platform${settings !== null ? "; set as the default preset in settings.yaml" : ""}.`);
 }
+async function skillsFor(io, apiUrl, harness) {
+  try {
+    const { skills } = await installableSkillSet(apiUrl, io.env);
+    installForHarness(io, harness, skills, apiUrl);
+  } catch (error) {
+    io.stderr(`warning: skills not installed (${error instanceof Error ? error.message : String(error)}); run: diverge skills install`);
+  }
+}
 async function overlayAndDefault(apiUrl, token, surface, io, requested) {
   const models = await servedModels(apiUrl, token, surface);
   if (models.length === 0) throw new CliError(`the gateway serves no models on the ${surface} surface for this organization`);
   if (requested && !models.includes(requested)) throw new CliError(`${requested} is not served on the ${surface} surface; choose one of: ${models.join(", ")}`);
   const defaultModel = dshDefaultModel(models, requested);
-  const bridge = dshBridge(resolveSelfCommand(), io.env);
-  return { overlay: dshPatchYaml({ baseUrl: surfaceBaseUrl(apiUrl, surface), surface, models, defaultModel, bridge }), defaultModel, models };
+  return { overlay: dshPatchYaml({ baseUrl: surfaceBaseUrl(apiUrl, surface), surface, models, defaultModel }), defaultModel, models };
 }
 async function setup(args, io) {
   const [agent, ...rest] = args;
   const apiUrl = resolveApiUrl(void 0, io.env);
   switch (agent) {
     case "claude": {
-      const { values } = parseArgs({ args: rest, options: { scope: { type: "string", default: "user" }, "project-id": { type: "string" }, "organization-id": { type: "string" }, "model-discovery": { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs2({ args: rest, options: { scope: { type: "string", default: "user" }, "project-id": { type: "string" }, "organization-id": { type: "string" }, "model-discovery": { type: "boolean", default: false } }, strict: true });
       if (values.scope !== "user" && values.scope !== "project") throw new CliError("--scope must be user or project");
       const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
       const file = claudeSettingsPath(values.scope);
@@ -8344,10 +8546,11 @@ async function setup(args, io) {
       writeJsonAtomic(file, settings);
       io.stdout(`Claude Code \u2192 ${anthropicBaseUrl(apiUrl)} as you, organization ${tokenClaims(token.access_token).organizationId}. Wrote ${file}.`);
       for (const warning of warnings) io.stderr(`warning: ${warning}`);
+      await skillsFor(io, apiUrl, "claude");
       return ExitCode.Ok;
     }
     case "opencode": {
-      const { values } = parseArgs({ args: rest, options: { surface: { type: "string" }, "organization-id": { type: "string" }, config: { type: "string" } }, strict: true });
+      const { values } = parseArgs2({ args: rest, options: { surface: { type: "string" }, "organization-id": { type: "string" }, config: { type: "string" } }, strict: true });
       const surface = surfaceOf(values.surface, "anthropic");
       const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
       const baseUrl = surfaceBaseUrl(apiUrl, surface);
@@ -8365,7 +8568,7 @@ async function setup(args, io) {
       return ExitCode.Ok;
     }
     case "codex": {
-      const { values } = parseArgs({ args: rest, options: { "project-id": { type: "string" }, "organization-id": { type: "string" }, config: { type: "string" }, print: { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs2({ args: rest, options: { "project-id": { type: "string" }, "organization-id": { type: "string" }, config: { type: "string" }, print: { type: "boolean", default: false } }, strict: true });
       const block = codexProviderToml({ openaiBaseUrl: openaiBaseUrl(apiUrl), self: resolveSelfCommand(), projectId: values["project-id"] });
       if (values.print) {
         io.stdout(block.trimEnd());
@@ -8373,25 +8576,27 @@ async function setup(args, io) {
       }
       const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
       const file = values.config ?? codexConfigPath();
-      const existing = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : null;
+      const existing = fs8.existsSync(file) ? fs8.readFileSync(file, "utf8") : null;
       writeTextAtomic(file, mergeCodexConfig(existing, block));
       io.stdout(`Codex provider divergent \u2192 ${openaiBaseUrl(apiUrl)} as you, organization ${tokenClaims(token.access_token).organizationId}. Wrote ${file}.`);
       io.stdout('Select it per run with: codex -c model_provider=divergent   (or set model_provider = "divergent" in the config)');
+      await skillsFor(io, apiUrl, "codex");
       return ExitCode.Ok;
     }
     case "dsh": {
-      const { values } = parseArgs({ args: rest, options: { surface: { type: "string" }, model: { type: "string" }, "organization-id": { type: "string" }, into: { type: "string" }, print: { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs2({ args: rest, options: { surface: { type: "string" }, model: { type: "string" }, "organization-id": { type: "string" }, into: { type: "string" }, print: { type: "boolean", default: false } }, strict: true });
       const surface = surfaceOf(values.surface, "openai");
       const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
+      if (!values.print) await skillsFor(io, apiUrl, "dsh");
       const { overlay, defaultModel } = await overlayAndDefault(apiUrl, token, surface, io, values.model);
       if (values.print) {
         io.stdout(overlay.trimEnd());
         return ExitCode.Ok;
       }
-      const file = values.into ?? path10.join(dshHome(io.env), `divergent-${surface}.yml`);
+      const file = values.into ?? path11.join(dshHome(io.env), `divergent-${surface}.yml`);
       writeTextAtomic(file, overlay);
       io.stdout(`dsh route divergent-${surface} \u2192 ${surfaceBaseUrl(apiUrl, surface)} as you, organization ${tokenClaims(token.access_token).organizationId}, default model ${defaultModel}. Wrote ${file}.`);
-      io.stdout("Web search is the platform tool search_online over `diverge tools bridge` (row mcp-divergent); dsh's DeepSeek search is off.");
+      io.stdout("Platform tools, web search included, are reached from dsh's shell through `diverge tools`; the installed skills say when and how. dsh's DeepSeek search is off.");
       syncDivergentPreset(io, findOnPath("dsh", io.env), dshHome(io.env));
       io.stdout("Boot a profile with the overlay and the token in its environment (user tokens expire; the login refreshes):");
       io.stdout(`  DIVERGENT_TOKEN="$(diverge token)" dsh --profile headless --patch ${file} "<task>"`);
@@ -8412,24 +8617,25 @@ ${agentsUsage}`);
   const terminator = rest.indexOf("--");
   const flags = terminator === -1 ? rest : rest.slice(0, terminator);
   const passthrough = terminator === -1 ? [] : rest.slice(terminator + 1);
-  const { values } = parseArgs({ args: flags, options: { surface: { type: "string" }, model: { type: "string" }, "organization-id": { type: "string" } }, strict: true });
+  const { values } = parseArgs2({ args: flags, options: { surface: { type: "string" }, model: { type: "string" }, "organization-id": { type: "string" } }, strict: true });
   const surface = surfaceOf(values.surface, "openai");
   const apiUrl = resolveApiUrl(void 0, io.env);
   const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
   const binary = findOnPath("dsh", io.env);
   if (!binary) throw new CliError("dsh is not on PATH (install: npm install -g @deepseek-ai/dsh)");
+  await skillsFor(io, apiUrl, "dsh");
   const { overlay, defaultModel } = await overlayAndDefault(apiUrl, token, surface, io, values.model);
   const home = dshHome(io.env);
-  const settingsPath = path10.join(home, "settings.yaml");
+  const settingsPath = path11.join(home, "settings.yaml");
   let pinned;
   try {
-    pinned = dshSettingsDefaultModel(fs7.existsSync(settingsPath) ? fs7.readFileSync(settingsPath, "utf8") : null, surface);
+    pinned = dshSettingsDefaultModel(fs8.existsSync(settingsPath) ? fs8.readFileSync(settingsPath, "utf8") : null, surface);
   } catch (error) {
     throw new CliError(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`);
   }
   const served = servedIds(overlay);
   if (pinned && !served.includes(pinned)) throw new CliError(stalePinMessage(settingsPath, pinned, surface, served));
-  const overlayPath = path10.join(home, `divergent-${surface}.yml`);
+  const overlayPath = path11.join(home, `divergent-${surface}.yml`);
   writeTextAtomic(overlayPath, overlay);
   syncDivergentPreset(io, binary, home);
   io.stderr(`dsh on divergent-${surface} as you (organization ${tokenClaims(token.access_token).organizationId}), default model ${defaultModel}`);
@@ -8438,7 +8644,7 @@ ${agentsUsage}`);
   return runDsh({
     binary,
     overlayPath,
-    credentialsPath: path10.join(home, ".credentials.yaml"),
+    credentialsPath: path11.join(home, ".credentials.yaml"),
     args: passthrough,
     env: io.env,
     initialToken: token.access_token,
@@ -8453,7 +8659,7 @@ ${agentsUsage}`);
   });
 }
 async function status(args, io) {
-  const { values } = parseArgs({ args, options: { "organization-id": { type: "string" } }, strict: true });
+  const { values } = parseArgs2({ args, options: { "organization-id": { type: "string" } }, strict: true });
   const apiUrl = resolveApiUrl(void 0, io.env);
   const token = await ensureInferenceLogin(io, apiUrl, values["organization-id"]);
   const claims = tokenClaims(token.access_token);
@@ -8467,7 +8673,7 @@ async function status(args, io) {
   return ExitCode.Ok;
 }
 async function rotate(args, io) {
-  const { values } = parseArgs({ args, options: { into: { type: "string" }, interval: { type: "string", default: "600" }, once: { type: "boolean", default: false }, "organization-id": { type: "string" } }, strict: true });
+  const { values } = parseArgs2({ args, options: { into: { type: "string" }, interval: { type: "string", default: "600" }, once: { type: "boolean", default: false }, "organization-id": { type: "string" } }, strict: true });
   const interval = Number(values.interval);
   if (!Number.isFinite(interval) || interval <= 0) throw new CliError("--interval must be a positive number of seconds");
   const apiUrl = resolveApiUrl(void 0, io.env);
@@ -8513,7 +8719,7 @@ ${agentsUsage}`);
 }
 
 // src/commands/login.ts
-import { parseArgs as parseArgs2 } from "node:util";
+import { parseArgs as parseArgs3 } from "node:util";
 
 // src/auth/organizations.ts
 function chooseOrganization(input) {
@@ -8597,7 +8803,7 @@ function resolveLoginHint(flag, config) {
   return remembered || void 0;
 }
 async function runLogin(args, io) {
-  const { values } = parseArgs2({
+  const { values } = parseArgs3({
     args,
     options: {
       "organization-id": { type: "string" },
@@ -8667,7 +8873,7 @@ ${organizationMenu(choice.options).join("\n")}`);
 }
 
 // src/commands/org.ts
-import { parseArgs as parseArgs3 } from "node:util";
+import { parseArgs as parseArgs4 } from "node:util";
 var orgUsage = `diverge org [use <id|name>]
 
 Without a verb: the organizations you may act in, the bound one marked.
@@ -8675,7 +8881,7 @@ use <id|name>: bind the login to that organization on the platform, without a
 browser; every later command acts there. A platform actor may name an
 organization they are not a member of.`;
 async function runOrg(args, io) {
-  const { positionals } = parseArgs3({ args, options: {}, strict: true, allowPositionals: true });
+  const { positionals } = parseArgs4({ args, options: {}, strict: true, allowPositionals: true });
   const apiUrl = resolveApiUrl(void 0, io.env);
   const source = { tokenFile: tokenFile(io.env), baseUrl: apiUrl, clientId: clientId(io.env) };
   const token = await getUserToken(source);
@@ -8835,7 +9041,7 @@ async function runToken(_args, io) {
 }
 
 // src/commands/tools.ts
-import { parseArgs as parseArgs4 } from "node:util";
+import { parseArgs as parseArgs5 } from "node:util";
 
 // src/mcp/bridge.ts
 import readline2 from "node:readline";
@@ -8891,10 +9097,10 @@ var ToolsClient = class {
     if (this.settings.mode === "service") headers["x-divergent-user-id"] = this.settings.delegatedUserId;
     return headers;
   }
-  scoped(path12) {
+  scoped(path13) {
     const query = new URLSearchParams({ organizationId: this.settings.organizationId });
     if (this.settings.projectId) query.set("projectId", this.settings.projectId);
-    return `${this.settings.apiUrl}${path12}?${query.toString()}`;
+    return `${this.settings.apiUrl}${path13}?${query.toString()}`;
   }
   async send(method, url, body) {
     return this.request(method, url, body, void 0);
@@ -9161,6 +9367,98 @@ async function waitForInvocation(id, options, deps) {
   }
 }
 
+// src/tools/call-args.ts
+import fs9 from "node:fs";
+function resolveCallArgs(options, readStdin = () => fs9.readFileSync(0, "utf8")) {
+  if (options.argsJson !== void 0 && options.argsJson !== "{}" && options.argsFile !== void 0) {
+    throw new CliError("give the arguments once: --args-json or --args-file");
+  }
+  let text;
+  let source;
+  if (options.argsFile !== void 0) {
+    source = `--args-file ${options.argsFile}`;
+    try {
+      text = fs9.readFileSync(options.argsFile, "utf8");
+    } catch (error) {
+      throw new CliError(`${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else if (options.argsJson === "-") {
+    source = "--args-json - (stdin)";
+    text = readStdin();
+  } else {
+    source = "--args-json";
+    text = options.argsJson ?? "{}";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text.trim() === "" ? "{}" : text);
+  } catch (error) {
+    throw new CliError(`${source} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new CliError(`${source} must be a JSON object`);
+  return parsed;
+}
+
+// src/tools/batch.ts
+function parseBatch(text) {
+  const trimmed = text.trim();
+  if (!trimmed) throw new Error("the batch file is empty");
+  const raw = trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  if (!Array.isArray(raw)) throw new Error("the batch file must hold a JSON array or one JSON object per line");
+  return raw.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw new Error(`entry ${index + 1} is not an object`);
+    const { tool, args } = entry;
+    if (typeof tool !== "string" || !tool) throw new Error(`entry ${index + 1} names no tool`);
+    if (args !== void 0 && (!args || typeof args !== "object" || Array.isArray(args))) throw new Error(`entry ${index + 1}: args must be an object`);
+    return { tool, args: args ?? {} };
+  });
+}
+async function runBatch(entries, deps) {
+  const outcomes = [];
+  for (const entry of entries) {
+    const outcome = await runOne(entry, deps);
+    outcomes.push(outcome);
+    deps.onOutcome?.(outcome);
+  }
+  return { outcomes, exitCode: worstExitCode(outcomes) };
+}
+async function runOne(entry, deps) {
+  let body;
+  try {
+    body = await deps.callTool(entry.tool, entry.args);
+  } catch (error) {
+    return { tool: entry.tool, status: "failed", error: error instanceof Error ? error.message : String(error) };
+  }
+  if (body.success === false) return { tool: entry.tool, status: "failed", error: body.error || "Tool execution failed" };
+  if (!isPending(body.result)) return { tool: entry.tool, status: "executed", result: body.result ?? null };
+  const pending = { tool: entry.tool, status: "pending", invocationId: body.result.invocationId, decideAt: deps.decideAt(body.result) };
+  if (!deps.waitFor) return pending;
+  const settled = await deps.waitFor(body.result);
+  switch (settled?.status) {
+    case "succeeded":
+      return { tool: entry.tool, status: "executed", result: settled.result ?? null, invocationId: pending.invocationId };
+    case "rejected":
+      return { tool: entry.tool, status: "rejected", invocationId: pending.invocationId, error: settled.decisionReason ?? void 0 };
+    case "expired":
+      return { tool: entry.tool, status: "expired", invocationId: pending.invocationId };
+    case "failed":
+      return { tool: entry.tool, status: "failed", invocationId: pending.invocationId, error: settled.errorMessage || "execution failed" };
+    default:
+      return pending;
+  }
+}
+function worstExitCode(outcomes) {
+  const has = (status2) => outcomes.some((outcome) => outcome.status === status2);
+  if (has("failed")) return ExitCode.Failure;
+  if (has("rejected")) return ExitCode.Rejected;
+  if (has("expired")) return ExitCode.Expired;
+  if (has("pending")) return ExitCode.Pending;
+  return ExitCode.Ok;
+}
+
+// src/commands/tools.ts
+import fs10 from "node:fs";
+
 // src/tools/print.ts
 function matchesCapability(selector, capability) {
   if (!capability) return false;
@@ -9241,12 +9539,16 @@ function settledOutcome(invocation) {
 }
 
 // src/commands/tools.ts
-var toolsUsage = `diverge tools <list|capabilities|describe|call|invocation|bridge> [--organization-id <id>] [--project-id <id>] ...
+var toolsUsage = `diverge tools <list|capabilities|describe|call|run|invocation|bridge> [--organization-id <id>] [--project-id <id>] ...
 
   list         [--filter <substring>] [--capability <selector>] [--json]
   capabilities [--json]
   describe <name> [--json]
-  call <name> [--args-json '{...}'] [--wait] [--timeout <seconds>]
+  call <name> [--args-json '{...}' | --args-json - | --args-file <path>] [--wait] [--timeout <seconds>]
+               arguments inline, from stdin (-), or from a file: PowerShell strips quotes inside inline JSON
+  run <file>  [--wait] [--timeout <seconds>]
+               several calls from one file (a JSON array of {tool, args}, or one per line), in order,
+               one JSON line of outcome each; exit code is the worst: 1 failed, 4 rejected, 5 expired, 3 pending
   invocation <id> [--wait] [--timeout <seconds>] [--json]
   bridge       [--tools <name,name>]   (stdio MCP server; the allowlist keeps a harness to the tools it was given)
 
@@ -9282,7 +9584,7 @@ async function runTools(args, io) {
   }
   switch (verb) {
     case "list": {
-      const { values } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, filter: { type: "string" }, capability: { type: "string" }, json: { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, filter: { type: "string" }, capability: { type: "string" }, json: { type: "boolean", default: false } }, strict: true });
       const { client: tools } = await client(values, io);
       let list = await tools.listTools();
       if (values.filter) list = list.filter((tool) => tool.name.includes(values.filter));
@@ -9292,7 +9594,7 @@ async function runTools(args, io) {
       return ExitCode.Ok;
     }
     case "capabilities": {
-      const { values } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, json: { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, json: { type: "boolean", default: false } }, strict: true });
       const { client: tools } = await client(values, io);
       const list = await tools.listTools();
       if (values.json) io.stdout(JSON.stringify(capabilityClusters(list), null, 2));
@@ -9300,7 +9602,7 @@ async function runTools(args, io) {
       return ExitCode.Ok;
     }
     case "describe": {
-      const { values, positionals } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, json: { type: "boolean", default: false } }, strict: true, allowPositionals: true });
+      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, json: { type: "boolean", default: false } }, strict: true, allowPositionals: true });
       const name = positionals[0];
       if (!name) throw new CliError("describe needs a tool name");
       const { settings, client: tools } = await client(values, io);
@@ -9315,16 +9617,10 @@ async function runTools(args, io) {
       return ExitCode.Ok;
     }
     case "call": {
-      const { values, positionals } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, "args-json": { type: "string", default: "{}" }, wait: { type: "boolean", default: false }, timeout: { type: "string", default: "600" } }, strict: true, allowPositionals: true });
+      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, "args-json": { type: "string" }, "args-file": { type: "string" }, wait: { type: "boolean", default: false }, timeout: { type: "string", default: "600" } }, strict: true, allowPositionals: true });
       const name = positionals[0];
       if (!name) throw new CliError("call needs a tool name");
-      let parsedArgs;
-      try {
-        parsedArgs = JSON.parse(values["args-json"]);
-      } catch (error) {
-        throw new CliError(`--args-json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      if (!parsedArgs || typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) throw new CliError("--args-json must be a JSON object");
+      const parsedArgs = resolveCallArgs({ argsJson: values["args-json"], argsFile: values["args-file"] });
       const timeoutMs = Number(values.timeout) * 1e3;
       if (!Number.isFinite(timeoutMs) || timeoutMs < 0) throw new CliError("--timeout must be a number of seconds");
       const { settings, client: tools } = await client(values, io);
@@ -9343,8 +9639,34 @@ async function runTools(args, io) {
       }
       return emit(io, settledOutcome(invocation));
     }
+    case "run": {
+      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, wait: { type: "boolean", default: false }, timeout: { type: "string", default: "600" } }, strict: true, allowPositionals: true });
+      const file = positionals[0];
+      if (!file) throw new CliError("run needs a file of calls");
+      let entries;
+      try {
+        entries = parseBatch(fs10.readFileSync(file, "utf8"));
+      } catch (error) {
+        throw new CliError(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      const timeoutMs = Number(values.timeout) * 1e3;
+      if (!Number.isFinite(timeoutMs) || timeoutMs < 0) throw new CliError("--timeout must be a number of seconds");
+      const { settings, client: tools } = await client(values, io);
+      const { exitCode } = await runBatch(entries, {
+        callTool: (tool, args2) => tools.callTool(tool, args2),
+        decideAt: (pending) => `${settings.apiUrl}${pending.approvalUrl ?? ""}`,
+        onOutcome: (outcome) => io.stdout(JSON.stringify(outcome)),
+        ...values.wait ? {
+          waitFor: async (pending) => {
+            const invocation = await waitForInvocation(pending.invocationId ?? "", { pollAfterMs: pending.pollAfterMs, timeoutMs }, { getInvocation: (id) => tools.getInvocation(id), sleep: realSleep, now: Date.now });
+            return PENDING_INVOCATION_STATUSES.includes(invocation.status ?? "") ? null : invocation;
+          }
+        } : {}
+      });
+      return exitCode;
+    }
     case "invocation": {
-      const { values, positionals } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, wait: { type: "boolean", default: false }, timeout: { type: "string", default: "600" }, json: { type: "boolean", default: false } }, strict: true, allowPositionals: true });
+      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, wait: { type: "boolean", default: false }, timeout: { type: "string", default: "600" }, json: { type: "boolean", default: false } }, strict: true, allowPositionals: true });
       const id = positionals[0];
       if (!id) throw new CliError("invocation needs an id");
       const { client: tools } = await client(values, io);
@@ -9362,21 +9684,21 @@ async function runTools(args, io) {
       return emit(io, settledOutcome(invocation));
     }
     case "bridge": {
-      const { values } = parseArgs4({ args: rest, options: { ...SCOPE_OPTIONS, tools: { type: "string" } }, strict: true });
+      const { values } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS, tools: { type: "string" } }, strict: true });
       const { client: tools } = await client(values, io);
       const allow = (values.tools ?? "").split(",").map((name) => name.trim()).filter(Boolean);
       return serveBridge(new BridgeServer(tools, { tools: allow }), process.stdin, process.stdout);
     }
     default:
-      throw new CliError(`tools needs one of: list, capabilities, describe, call, invocation, bridge
+      throw new CliError(`tools needs one of: list, capabilities, describe, call, run, invocation, bridge
 
 ${toolsUsage}`);
   }
 }
 
 // src/commands/plugins.ts
-import fs8 from "node:fs";
-import { parseArgs as parseArgs5 } from "node:util";
+import fs11 from "node:fs";
+import { parseArgs as parseArgs6 } from "node:util";
 var pluginsUsage = `diverge plugins <validate|publish|list|retire> [--organization-id <id>] ...
 
   validate <manifest.json>            (dry run: the platform's full validation, nothing stored)
@@ -9402,7 +9724,7 @@ function readManifest(file) {
 ${pluginsUsage}`);
   let text;
   try {
-    text = fs8.readFileSync(file, "utf8");
+    text = fs11.readFileSync(file, "utf8");
   } catch (error) {
     throw new CliError(`Cannot read ${file}: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -9439,7 +9761,7 @@ async function runPlugins(args, io) {
   }
   switch (verb) {
     case "validate": {
-      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, allowPositionals: true, strict: true });
+      const { values, positionals } = parseArgs6({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, allowPositionals: true, strict: true });
       const manifest = readManifest(positionals[0]);
       const tools = await client2(values, io);
       const outcome = await tools.publishPlugin(manifest, { dryRun: true });
@@ -9456,7 +9778,7 @@ async function runPlugins(args, io) {
       return ExitCode.Ok;
     }
     case "publish": {
-      const { values, positionals } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, allowPositionals: true, strict: true });
+      const { values, positionals } = parseArgs6({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, allowPositionals: true, strict: true });
       const manifest = readManifest(positionals[0]);
       const tools = await client2(values, io);
       const outcome = await tools.publishPlugin(manifest, { dryRun: false });
@@ -9474,7 +9796,7 @@ async function runPlugins(args, io) {
       return ExitCode.Ok;
     }
     case "list": {
-      const { values } = parseArgs5({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, strict: true });
+      const { values } = parseArgs6({ args: rest, options: { ...SCOPE_OPTIONS2, json: { type: "boolean", default: false } }, strict: true });
       const tools = await client2(values, io);
       const plugins = await tools.listPlugins();
       if (values.json) io.stdout(JSON.stringify(plugins, null, 2));
@@ -9483,7 +9805,7 @@ async function runPlugins(args, io) {
       return ExitCode.Ok;
     }
     case "retire": {
-      const { values, positionals } = parseArgs5({ args: rest, options: SCOPE_OPTIONS2, allowPositionals: true, strict: true });
+      const { values, positionals } = parseArgs6({ args: rest, options: SCOPE_OPTIONS2, allowPositionals: true, strict: true });
       const pluginId = positionals[0];
       if (!pluginId) throw new CliError(`A plugin id is required.
 
@@ -9505,16 +9827,16 @@ import { spawn as spawn4 } from "node:child_process";
 
 // src/update-notice.ts
 import { spawn as spawn3 } from "node:child_process";
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path12 from "node:path";
 var UPDATE_CHECK_FILE = "update-check.json";
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function updateCheckFile(env) {
-  return path11.join(configDir(env), UPDATE_CHECK_FILE);
+  return path12.join(configDir(env), UPDATE_CHECK_FILE);
 }
 function readUpdateCheck(env) {
   try {
-    const parsed = JSON.parse(fs9.readFileSync(updateCheckFile(env), "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(updateCheckFile(env), "utf8"));
     if (parsed && typeof parsed === "object" && typeof parsed.checkedAt === "number" && typeof parsed.latest === "string") return parsed;
   } catch {
   }
@@ -9615,6 +9937,7 @@ var COMMANDS = [
   { name: "agents", summary: "Point a coding agent at the model gateway (setup, run, status)", usage: agentsUsage, run: runAgents },
   { name: "tools", summary: "Discover and execute platform tools; raise and read approvals", usage: toolsUsage, run: runTools },
   { name: "plugins", summary: "Validate, publish, list and retire tenant plugins for your organization", usage: pluginsUsage, run: runPlugins },
+  { name: "skills", summary: "Install your organization's skills into Claude Code, Codex and dsh", usage: skillsUsage, run: runSkills },
   { name: "update", summary: "Install the latest release", usage: updateUsage, run: (args, io) => runUpdate(args, io) }
 ];
 function usage() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divergeai/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Divergent platform CLI: sign in, wire coding agents to the inference gateway, call platform tools",
   "license": "UNLICENSED",
   "type": "module",