@agentsky/sky 2.7.3 → 2.9.0

package/dist/index.js

@@ -16,10 +16,10 @@ import {
   skillRefSchema,
   splitMcpServers,
   supersededBy
-} from "./chunk-IC4N2ZPL.js";
+} from "./chunk-NRTKH367.js";
 
 // src/index.ts
-import { existsSync as existsSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename3, resolve as resolve4 } from "path";
 import { createInterface as createInterface4 } from "readline";
 import { Command } from "commander";
@@ -64,7 +64,7 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.7.3";
+var CLI_VERSION = "2.9.0";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 // src/api.ts
@@ -148,6 +148,24 @@ async function downloadFile(fileId) {
   if (!res.ok) await parseError(res);
   return { bytes: new Uint8Array(await res.arrayBuffer()), mediaType: res.headers.get("content-type") ?? "application/octet-stream" };
 }
+async function apiBytes(method, path, body) {
+  const res = await fetch(`${apiBase()}${path}`, {
+    method,
+    headers: {
+      "user-agent": USER_AGENT,
+      ...authHeaders(),
+      ...body ? { "content-type": body.mediaType } : {}
+    },
+    body: body ? new Uint8Array(body.bytes) : void 0
+  });
+  if (!res.ok) await parseError(res);
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  return {
+    bytes,
+    mediaType: res.headers.get("content-type") ?? "application/octet-stream",
+    json: () => JSON.parse(new TextDecoder().decode(bytes))
+  };
+}
 async function resolveSessionRef(ref) {
   if (ref.startsWith("sess-")) return ref;
   const { agent: agent2 } = await api(
@@ -167,7 +185,7 @@ async function resolveSessionRef(ref) {
   return agent2.defaultSessionId;
 }
 async function* streamEvents(sessionId, signal) {
-  const { parseSseStream } = await import("./src-S76Y7GHZ.js");
+  const { parseSseStream } = await import("./src-OEZ7BT2L.js");
   const res = await fetch(
     `${apiBase()}/sessions/${encodeURIComponent(sessionId)}/stream`,
     {
@@ -390,7 +408,7 @@ function scaffoldAgentFile(path, name) {
     path,
     `# agent.toml \u2014 everything the create wizard can set. Only \`name\` is required.
 name = "${name}"
-# type = "hermes"              # hermes | claude_code | codex | openclaw | pi | dsh | kimi_code | opencode
+# type = "pi"                  # pi (default) | hermes | claude_code | codex | openclaw | pi | dsh | kimi_code | opencode
 # llm = "deepseek-flash"       # must be compatible with type
 # reasoning_effort = "high"    # per harness \u2014 ${reasoningEffortDocLine()}
 # capabilities = []
@@ -608,7 +626,7 @@ async function createClone(local, opts) {
   if (local.truncated) console.log("  note: instructions exceeded 100k chars and were truncated");
   if (local.droppedServers.length) {
     console.log(
-      `Dropped (need credentials \u2014 not supported yet): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}`
+      `Left out (need a key): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}. Run \`sky setup secrets\` to choose which keys to save to your vault.`
     );
   }
   if (opts.dryRun) {
@@ -722,7 +740,7 @@ async function syncClone(local, link, opts) {
   }
   if (local.droppedServers.length) {
     console.log(
-      `  dropped (need credentials \u2014 not supported yet): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}`
+      `  left out (need a key): ${local.droppedServers.map((n) => `${n} MCP`).join(", ")}. Run \`sky setup secrets\` to choose which keys to save to your vault.`
     );
   }
   writeLink(local.configRoot, { ...link, lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString() });
@@ -827,10 +845,10 @@ function listClaudeCodeSessions(limit) {
         continue;
       }
       const workspace = decodeWorkspace(encoded);
-      for (const entry of entries) {
-        if (!entry.endsWith(".jsonl")) continue;
-        const sessionId = entry.slice(0, -6);
-        const mainFile = join3(projectDir, entry);
+      for (const entry2 of entries) {
+        if (!entry2.endsWith(".jsonl")) continue;
+        const sessionId = entry2.slice(0, -6);
+        const mainFile = join3(projectDir, entry2);
         let stat;
         try {
           stat = statSync(mainFile);
@@ -876,13 +894,13 @@ function listCodexSessions(limit) {
     } catch {
       return;
     }
-    for (const entry of entries) {
-      const full = join3(dir, entry.name);
-      if (entry.isDirectory()) {
+    for (const entry2 of entries) {
+      const full = join3(dir, entry2.name);
+      if (entry2.isDirectory()) {
         walk(full);
         continue;
       }
-      if (!entry.isFile() || !entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) continue;
+      if (!entry2.isFile() || !entry2.name.startsWith("rollout-") || !entry2.name.endsWith(".jsonl")) continue;
       try {
         const first = readPrefix(full).split("\n", 1)[0];
         const meta = JSON.parse(first);
@@ -1251,92 +1269,179 @@ import { mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync a
 import { dirname as dirname4, join as join8 } from "path";
 import { createInterface as createInterface3 } from "readline";
 
-// src/setup-local.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname3, isAbsolute, join as join6, resolve as resolve3 } from "path";
-import { parse as parseToml2 } from "smol-toml";
+// src/mcp-register.ts
+import { spawnSync } from "child_process";
 
 // src/skill.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
+
+// src/catalog-file.ts
+var CATALOG_FILE = "catalog.md";
+var CATEGORY_ORDER = ["websites", "content", "video", "code", "research", "general"];
+function categoryOf(agent2) {
+  return CATEGORY_ORDER.find((category) => agent2.categories.includes(category)) ?? agent2.categories[0] ?? "general";
+}
+function describe(value) {
+  const parts = Object.entries(value).filter(([, item]) => item !== null && item !== void 0 && item !== false && item !== "").map(([key, item]) => item === true ? key : `${key}: ${typeof item === "string" ? item : JSON.stringify(item)}`);
+  return parts.length ? parts.join(", ") : null;
+}
+function entry(agent2) {
+  const engine = agent2.engine_type ? ` \xB7 engine ${agent2.engine_type}` : "";
+  const lines = [`### @${agent2.handle} \u2014 ${agent2.name}${engine}`, "", agent2.tagline];
+  if (agent2.does.length) lines.push("", `Does: ${agent2.does.join("; ")}`);
+  if (agent2.does_not.length) lines.push(`Does not: ${agent2.does_not.join("; ")}`);
+  const { mcp_servers: mcpServers, ...rest } = agent2.requirements;
+  if (typeof mcpServers === "boolean") lines.push(mcpServers ? "Can use MCP servers." : "Cannot use MCP servers.");
+  const details = describe(rest);
+  if (details) lines.push(`Details: ${details}`);
+  const pricing = describe(agent2.pricing);
+  if (pricing) lines.push(`Pricing: ${pricing}`);
+  return lines.join("\n");
+}
+function renderCatalog(agents, generatedAt) {
+  const header = [
+    "# AgentSky agent catalog",
+    "",
+    `Every agent you can hire, as of ${generatedAt.toISOString()}. Start one with \`start_session\` and its handle, written with the @.`,
+    "Run `npx @agentsky/sky setup` again to refresh this file; `search_catalog` always has the current list."
+  ];
+  if (!agents.length) return [...header, "", "The catalog was empty when this file was written. Use `search_catalog`.", ""].join("\n");
+  const own = agents.filter((agent2) => agent2.visibility === "workspace");
+  const shared = agents.filter((agent2) => agent2.visibility !== "workspace");
+  const sections = [];
+  if (own.length) sections.push(["## Your workspace's agents", ...own.map(entry)].join("\n\n"));
+  const groups = /* @__PURE__ */ new Map();
+  for (const agent2 of shared) groups.set(categoryOf(agent2), [...groups.get(categoryOf(agent2)) ?? [], agent2]);
+  const ordered = [...groups.keys()].sort((a, b) => {
+    const rank = (category) => CATEGORY_ORDER.includes(category) ? CATEGORY_ORDER.indexOf(category) : CATEGORY_ORDER.length;
+    return rank(a) - rank(b) || a.localeCompare(b);
+  });
+  for (const category of ordered) {
+    const title = category.charAt(0).toUpperCase() + category.slice(1);
+    sections.push([`## ${title}`, ...groups.get(category).map(entry)].join("\n\n"));
+  }
+  return [...header, "", sections.join("\n\n"), ""].join("\n");
+}
+
+// src/skill.ts
 var SKILL_NAME = "agentsky";
 var SKILL_MARKER = ".agentsky.json";
 function skillDocument() {
   return `---
 name: ${SKILL_NAME}
-description: Hand part of a job to another agent running in the cloud through AgentSky, and bring its result back. Use when the person asks for another agent or a named engine (Claude Code, Codex, Hermes, OpenClaw and others) to do, test or review something, or when independent work could run in parallel.
+description: "Hire cloud agents from the AgentSky catalog (included as ${CATALOG_FILE}) and coordinate them on one task. Use when the person names an agent by @handle, asks to have another agent (or another engine such as Codex, Claude Code, Gemini or Hermes) do, test or review part of the work, wants work to keep running in the cloud, or the work splits into independent parts that can run at the same time. Works through the agentsky MCP server, or the sky command where those tools are missing."
 ---
 
 # Working with other agents through AgentSky
 
-AgentSky runs long-lived agents in the cloud. With the \`sky\` command you can
-find one, give it a job, and read what it produced. You stay responsible for
-the result.
-
-If the \`agentsky\` MCP tools are available in this session (\`search_catalog\`,
-\`start_session\`, \`read_session\`, \`send_message\`), use them instead of the
-commands below; they do the same things.
-
-## Before you start
+AgentSky runs long-lived agents in the cloud. You can hire them from its
+catalog, give each a part of the work, and collect what they produce. Agents you
+hire for the same piece of work share one task: a shared \`task/\` folder they all
+read and write, listed as one task in the person's AgentSky account. You stay
+responsible for the result.
 
-Run \`sky auth whoami\`. If it says you are not logged in, ask the person to run
-\`sky auth login\` and stop there. Never ask them for a token.
+Everything below is a tool of the \`agentsky\` MCP server. If those tools are
+missing in this session, use the \`sky\` commands under "Without the MCP tools"
+at the end; they do the same things, one agent at a time.
 
-## When to hand work over
+## When to hire
 
-- When the person asks another agent to do, test or review something, do that.
-  Honor an agent or engine they name.
-- Otherwise, hand over work another agent is better suited to, or independent
-  parts that can run at the same time as your own.
-- Do the work yourself when it is small, when it depends on what you already
-  have in front of you, or when explaining it would take as long as doing it.
+- When the person names an agent (\`@handle\`) or an engine, or asks another agent
+  to test, review or do part of the work, do that. Do not substitute another one
+  silently.
+- Otherwise hire for work another agent is better suited to than you are, for
+  independent parts that can run at the same time, or for work that should keep
+  going after this conversation ends.
+- Do the work yourself when it is small, when it depends on what you already have
+  in front of you, or when explaining it would take as long as doing it.
+- Every hire spends the person's AgentSky balance. Say what you are about to hire
+  and roughly what it may cost before the first one, unless they already asked
+  for it.
 
 ## How to pick
 
-\`sky catalog search <words for the work> --json\`
+Read \`${CATALOG_FILE}\` in this skill's folder. It lists every agent you can hire,
+your own workspace's first, then by category: its \`@handle\`, its engine, what it
+does and does not do, whether it can use MCP servers, and how it is paid. Pick by
+the work, not by the name, and respect what an agent says it does not do.
 
-Each result has a \`handle\`, what the agent does, its \`engine_type\`, its
-categories, how it is paid, and what it needs. If the person names an engine,
-match its \`engine_type\` and do not substitute another one silently. Run the
-command with no words to see every agent. If nothing fits, do the work
-yourself and say so.
+Call \`search_catalog\` (with words for the work, or none to list everything)
+when \`${CATALOG_FILE}\` is missing, when nothing in it fits, or when the person names
+a handle it does not list: the catalog file is a snapshot from when the skill
+was installed. If nothing fits, do the work yourself and say so.
 
 ## How to brief
 
-\`sky session create @<handle> --title "<short name>" --message "<brief>" --json\`
+Start the first agent with \`start_session\`:
 
-It prints the new session's \`id\`. The agent starts working at once, on its own
-computer in the cloud. It cannot see this conversation or this machine, so a
-brief is one self-contained message that states:
+- \`agent_id\`: the handle, with its \`@\`.
+- \`message\`: the brief.
+- \`title\`: a short name for its part.
+- \`budget_cents\`: the most it may spend, in US cents. Always set one. When it is
+  reached the agent pauses instead of spending more.
+- \`idempotency_key\`: a new unique value for this hire. Reuse it only to retry
+  the exact same call after a timeout.
 
-1. what to produce,
-2. what "done" means,
-3. anything it must not do.
+The agent cannot see this conversation or your files. A brief is one
+self-contained paragraph that says:
 
-To give it a file, add \`--file <path>\`. Never put a password, key or token in a
-brief.
+1. what to produce;
+2. where to write it: a path under \`task/<its part>/\`;
+3. what "done" means;
+4. anything it must not do.
 
-## How to collect
+Never put a password, key or token in a brief.
 
-\`sky session read <session id> --wait --json\`
+Its task id is the first session's id. Start every other agent for the same work
+with that \`task_id\`, so it sees the same \`task/\` folder and the person sees one
+task. To hand an agent a file, write it with \`write_task_file\` before you brief
+it, and name its path in the brief.
 
-It waits until the agent finishes its turn and prints its messages, with
-\`finished\` true or false. If \`finished\` is false the wait timed out: run it
-again. A first turn can take a minute to begin while the agent's computer
-starts.
+## How to supervise
 
-To correct it, answer it or ask for more:
+- Call \`read_session\` with the \`session_id\`, \`cursor\` and \`message_id\` that
+  \`start_session\` or \`send_message\` returned and \`wait_seconds: 50\`. Call again
+  with the returned cursor until \`turn_finished\` is true, and at once whenever
+  \`has_more\` is true. The first turn also boots the agent's sandbox, which can
+  take a minute.
+- Run independent agents at the same time: start them all, then read each.
+- To steer or answer an agent, \`send_message\` once its turn is finished.
+- If \`get_task\` shows a request waiting on the person (a question, an approval,
+  or an app to connect with its link), show it to them and pass their answer with
+  \`answer_request\`. Never approve spending or access on their behalf.
+- An agent that finishes its first turn with no reply did not start properly:
+  \`stop_session\` it and hire again, or do that part yourself.
 
-\`sky session message <session id> "<text>" --detach\`
+## How to finish
 
-then read again. An agent saying it is done is not evidence: check what it
-produced before you rely on it.
+1. \`collect_result\` for each agent: its last reply and the files it wrote.
+2. Read the files with \`read_task_file\` and check each one exists and does what
+   was asked. An agent saying "done" is not evidence.
+3. Put the pieces together.
+4. If the person should be able to open or share the result, \`publish_artifact\`
+   the files; \`share_artifact\` only when they asked for a link.
+5. \`stop_session\` every agent you no longer need.
+6. Tell the person what was done, which agent did which part, and what it cost
+   (\`get_task\` reports the task's cost).
 
-## How to finish
+## Without the MCP tools
+
+Run \`sky auth whoami\`. If it says you are not logged in, ask the person to run
+\`sky auth login\` and stop there. Never ask them for a token.
 
-Tell the person what was done and which agent did which part. Every agent you
-start is paid for by the person, so start only what the job needs.
+- Pick: \`sky catalog search <words for the work> --json\`. Each result has a
+  \`handle\`, what the agent does, its \`engine_type\`, its categories, how it is
+  paid, and what it needs. Run it with no words to see every agent.
+- Brief: \`sky session create @<handle> --title "<short name>" --message "<brief>" --json\`
+  prints the new session's \`id\`. To give it a file, add \`--file <path>:/<name>\`:
+  the file is in the agent's working directory under that name, read-only, so
+  call it by that name in the brief.
+- Collect: \`sky session read <session id> --wait --json\` waits until the agent
+  finishes its turn and prints its messages, with \`finished\` true or false. If
+  \`finished\` is false the wait timed out: run it again. To correct it, answer it
+  or ask for more, \`sky session message <session id> "<text>" --detach\`, then
+  read again.
 `;
 }
 function installedVersion(dir) {
@@ -1354,16 +1459,71 @@ function installSkill(agent2, opts = {}) {
   const dir = join5(agent2.skillsDir, SKILL_NAME);
   const previous = installedVersion(dir);
   const outcome = previous === CLI_VERSION ? "current" : previous ? "updated" : "installed";
-  if (outcome !== "current" && !opts.dryRun) {
+  if (opts.dryRun) return { agent: agent2.id, path: dir, outcome };
+  if (outcome !== "current") {
     mkdirSync2(dir, { recursive: true });
     writeFileSync4(join5(dir, "SKILL.md"), skillDocument());
     writeFileSync4(join5(dir, SKILL_MARKER), `${JSON.stringify({ version: CLI_VERSION }, null, 2)}
 `);
   }
+  if (opts.catalog) {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync4(join5(dir, CATALOG_FILE), renderCatalog(opts.catalog, opts.now ?? /* @__PURE__ */ new Date()));
+  }
   return { agent: agent2.id, path: dir, outcome };
 }
 
+// src/mcp-register.ts
+var MCP_SERVER_NAME = SKILL_NAME;
+var CODEX_TOKEN_ENV = "AGENTSKY_API_KEY";
+function systemCommandRunner() {
+  return {
+    has: (command) => spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0,
+    run: (command, args) => {
+      const result = spawnSync(command, args, { encoding: "utf8" });
+      return { status: result.status, stderr: result.stderr ?? "" };
+    }
+  };
+}
+function mcpUrlFor(apiBase2) {
+  return `${apiBase2.replace(/\/$/, "")}/mcp`;
+}
+function mcpCommands(agent2, opts) {
+  if (agent2 === "claude_code") {
+    return {
+      command: "claude",
+      remove: ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME],
+      add: ["mcp", "add", "--scope", "user", "--transport", "http", MCP_SERVER_NAME, opts.mcpUrl, "--header", `Authorization: Bearer ${opts.token}`]
+    };
+  }
+  if (agent2 === "codex") {
+    return {
+      command: "codex",
+      remove: ["mcp", "remove", MCP_SERVER_NAME],
+      add: ["mcp", "add", MCP_SERVER_NAME, "--url", opts.mcpUrl, "--bearer-token-env-var", CODEX_TOKEN_ENV]
+    };
+  }
+  return null;
+}
+function redact(text, token) {
+  return text.split(token).join(`${token.slice(0, 10)}\u2026`);
+}
+function registerMcpServer(agent2, opts, runner = systemCommandRunner()) {
+  const commands = mcpCommands(agent2.id, opts);
+  if (!commands) return { agent: agent2.id, outcome: "unsupported" };
+  if (!runner.has(commands.command)) return { agent: agent2.id, outcome: "no_command", detail: `${commands.command} is not on PATH` };
+  if (opts.dryRun) return { agent: agent2.id, outcome: "planned", detail: redact([commands.command, ...commands.add].join(" "), opts.token) };
+  runner.run(commands.command, commands.remove);
+  const added = runner.run(commands.command, commands.add);
+  if (added.status !== 0) return { agent: agent2.id, outcome: "failed", detail: redact(added.stderr.trim() || `exit ${added.status}`, opts.token) };
+  return agent2.id === "codex" ? { agent: agent2.id, outcome: "registered", detail: `set ${CODEX_TOKEN_ENV} to an AgentSky API token in the shell that runs codex` } : { agent: agent2.id, outcome: "registered" };
+}
+
 // src/setup-local.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, isAbsolute, join as join6, resolve as resolve3 } from "path";
+import { parse as parseToml2 } from "smol-toml";
 var MAX_SKILL_FILE_BYTES = 1024 * 1024;
 var MAX_IMPORT_DEPTH = 5;
 var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
@@ -1377,12 +1537,12 @@ function sensitive(name) {
 }
 function skillFiles(root, prefix) {
   const files2 = [];
-  for (const entry of readdirSync2(root, { withFileTypes: true })) {
-    const path = join6(root, entry.name);
-    if (entry.isDirectory()) {
-      if (!SKIPPED_DIRS.has(entry.name)) files2.push(...skillFiles(path, `${prefix}/${entry.name}`));
-    } else if (entry.isFile() && !sensitive(entry.name) && statSync2(path).size <= MAX_SKILL_FILE_BYTES) {
-      files2.push({ path: `${prefix}/${entry.name}`, bytes: new Uint8Array(readFileSync7(path)) });
+  for (const entry2 of readdirSync2(root, { withFileTypes: true })) {
+    const path = join6(root, entry2.name);
+    if (entry2.isDirectory()) {
+      if (!SKIPPED_DIRS.has(entry2.name)) files2.push(...skillFiles(path, `${prefix}/${entry2.name}`));
+    } else if (entry2.isFile() && !sensitive(entry2.name) && statSync2(path).size <= MAX_SKILL_FILE_BYTES) {
+      files2.push({ path: `${prefix}/${entry2.name}`, bytes: new Uint8Array(readFileSync7(path)) });
     }
   }
   return files2;
@@ -1392,10 +1552,10 @@ function readLocalSkills(agents) {
   const ignored = [];
   for (const agent2 of agents) {
     if (!existsSync5(agent2.skillsDir)) continue;
-    for (const entry of readdirSync2(agent2.skillsDir, { withFileTypes: true })) {
-      const dir = join6(agent2.skillsDir, entry.name);
-      let isDir = entry.isDirectory();
-      if (entry.isSymbolicLink()) {
+    for (const entry2 of readdirSync2(agent2.skillsDir, { withFileTypes: true })) {
+      const dir = join6(agent2.skillsDir, entry2.name);
+      let isDir = entry2.isDirectory();
+      if (entry2.isSymbolicLink()) {
         try {
           isDir = statSync2(dir).isDirectory();
         } catch {
@@ -1413,7 +1573,7 @@ function readLocalSkills(agents) {
         ignored.push({ agent: agent2.id, dir, reason: `${taken.agent} already has a skill named ${name}` });
         continue;
       }
-      const files2 = skillFiles(dir, entry.name);
+      const files2 = skillFiles(dir, entry2.name);
       skills.push({ name, agent: agent2.id, dir, files: files2, bytes: files2.reduce((sum, file) => sum + file.bytes.length, 0) });
     }
   }
@@ -1479,8 +1639,8 @@ function bearerOf(def) {
   if (typeof def.bearer_token === "string" && def.bearer_token.trim()) return def.bearer_token.trim();
   const headers = def.headers ?? def.http_headers;
   if (!headers || typeof headers !== "object") return null;
-  const entry = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization");
-  const match = typeof entry?.[1] === "string" ? /^Bearer\s+(\S+)$/i.exec(entry[1].trim()) : null;
+  const entry2 = Object.entries(headers).find(([name]) => name.toLowerCase() === "authorization");
+  const match = typeof entry2?.[1] === "string" ? /^Bearer\s+(\S+)$/i.exec(entry2[1].trim()) : null;
   return match?.[1] ?? null;
 }
 function serversOf(agent2, home) {
@@ -1725,12 +1885,25 @@ function confirm3(question) {
 function kb2(bytes) {
   return `${Math.max(1, Math.round(bytes / 1024))} KB`;
 }
-function describe(event) {
+function describe2(event) {
   switch (event.type) {
     case "agents":
       return event.agents.length ? `Found on this computer: ${event.agents.map((agent2) => agent2.name).join(", ")}` : "No agent found on this computer (looked for Claude Code, Codex and Cursor).";
+    case "catalog":
+      return event.outcome === "read" ? `  agent catalog: ${event.agents} agent${event.agents === 1 ? "" : "s"}` : `  agent catalog: not read${event.detail ? ` (${event.detail})` : ""}; the skill looks agents up with search_catalog`;
     case "skill":
       return `  AgentSky skill ${event.outcome === "current" ? "already up to date" : event.outcome} for ${event.agent}`;
+    case "mcp":
+      switch (event.outcome) {
+        case "registered":
+          return `  agentsky MCP server registered for ${event.agent}${event.detail ? ` (${event.detail})` : ""}`;
+        case "planned":
+          return `  would run: ${event.detail}`;
+        case "unsupported":
+          return null;
+        default:
+          return `  agentsky MCP server not registered for ${event.agent}: ${event.detail ?? event.outcome}`;
+      }
     case "plan":
       return `  ${event.provider} plan: ${event.outcome === "already" ? "already connected" : event.outcome}${event.detail ? ` (${event.detail})` : ""}`;
     case "found": {
@@ -1781,22 +1954,40 @@ async function connectedProviders() {
   const { modelSubscriptions } = await api("GET", "/model-subscriptions");
   return new Set(modelSubscriptions.map((subscription) => subscription.provider));
 }
-async function defaultVaultId() {
+var WORKSPACE_VAULT_NAME = "default";
+async function findWorkspaceVault() {
   const { vaults } = await api("GET", "/vaults");
-  const existing = vaults.find((vault) => vault.display_name === "default");
-  if (existing) return existing.id;
-  return (await api("POST", "/vaults", { display_name: "default" })).vault.id;
+  return vaults.find((vault) => vault.display_name === WORKSPACE_VAULT_NAME)?.id ?? null;
+}
+async function workspaceVaultId() {
+  const existing = await findWorkspaceVault();
+  if (existing) return existing;
+  try {
+    return (await api("POST", "/vaults", { display_name: WORKSPACE_VAULT_NAME })).vault.id;
+  } catch (error) {
+    const raced = error instanceof ApiError && error.status === 409 ? await findWorkspaceVault() : null;
+    if (!raced) throw error;
+    return raced;
+  }
 }
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
+async function readCatalog() {
+  if (!apiToken()) return { catalog: null, detail: "not logged in" };
+  try {
+    return { catalog: (await api("GET", "/catalog/agents")).agents };
+  } catch (error) {
+    return { catalog: null, detail: message(error) };
+  }
+}
 async function runSetup(opts) {
   const steps = opts.steps?.length ? opts.steps : [...SETUP_STEPS];
   const interactive = !opts.json && !opts.yes && !opts.dryRun;
   const emit = (event) => {
     if (opts.json) console.log(JSON.stringify(event));
     else {
-      const line = describe(event);
+      const line = describe2(event);
       if (line) console.log(line);
     }
   };
@@ -1804,7 +1995,7 @@ async function runSetup(opts) {
   const has = (step) => steps.includes(step);
   const agents = selectLocalAgents(opts.agents);
   emit({ type: "agents", agents: agents.map((agent2) => ({ id: agent2.id, name: agent2.name })) });
-  const needsToken = !opts.dryRun && (has("logins") || has("secrets") || has("import") && !opts.key);
+  const needsToken = !opts.dryRun && (has("skill") || has("logins") || has("secrets") || has("import") && !opts.key);
   if (needsToken && !apiToken()) {
     if (opts.json) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
     console.log("First, sign this computer in to AgentSky.");
@@ -1825,17 +2016,23 @@ async function runSetup(opts) {
     held = new Map((claimed.body.skills ?? []).map((skill) => [skill.name, skill.fingerprint]));
   };
   await tell();
-  if (has("skill") && agents.length && await agreed("Add the AgentSky skill to these agents, so they can hand work to others?")) {
+  if (has("skill") && agents.length && await agreed("Add the AgentSky skill and MCP server to these agents, so they can hand work to others?")) {
+    const { catalog: catalog2, detail } = await readCatalog();
+    emit(catalog2 ? { type: "catalog", outcome: "read", agents: catalog2.length } : { type: "catalog", outcome: "unavailable", ...detail ? { detail } : {} });
+    const token = apiToken();
     for (const agent2 of agents) {
       try {
-        const installed = installSkill(agent2, { dryRun: opts.dryRun });
+        const installed = installSkill(agent2, { dryRun: opts.dryRun, catalog: catalog2 });
         emit({ type: "skill", agent: agent2.id, outcome: installed.outcome, path: installed.path });
         if (!opts.dryRun) run2.agents.push({ id: agent2.id, skill: installed.outcome });
       } catch (error) {
         emit({ type: "skill", agent: agent2.id, outcome: "failed", path: agent2.skillsDir });
         emit({ type: "error", code: "skill_install_failed", message: message(error) });
         run2.agents.push({ id: agent2.id, skill: "failed" });
+        continue;
       }
+      const registered = token ? registerMcpServer(agent2, { token, mcpUrl: mcpUrlFor(apiBase()), dryRun: opts.dryRun }) : { agent: agent2.id, outcome: "skipped", detail: "not logged in" };
+      emit({ type: "mcp", agent: agent2.id, outcome: registered.outcome, ...registered.detail ? { detail: registered.detail } : {} });
     }
     await tell();
   }
@@ -1929,7 +2126,7 @@ async function saveSecrets(found, opts, interactive, emit) {
       continue;
     }
     try {
-      vaultId ??= await defaultVaultId();
+      vaultId ??= await workspaceVaultId();
       await api("POST", `/vaults/${encodeURIComponent(vaultId)}/secrets`, {
         display_name: secret.name,
         auth: { type: "static_bearer", mcp_server_url: secret.url, token: secret.token }
@@ -1977,6 +2174,144 @@ async function importToWorkspace(key, held, skills, instructions, emit) {
   if (!finished.ok) emit({ type: "error", code: finished.code, message: finished.message });
 }
 
+// src/task-files.ts
+function encodePath(path) {
+  return path.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+var filesPath = (task2) => `/tasks/${encodeURIComponent(task2)}/files`;
+async function listTaskFiles(task2) {
+  return (await api("GET", filesPath(task2))).files;
+}
+async function readTaskFile(task2, path) {
+  return (await apiBytes("GET", `${filesPath(task2)}/${encodePath(path)}`)).bytes;
+}
+async function writeTaskFile(task2, path, bytes, mediaType) {
+  return (await apiBytes("PUT", `${filesPath(task2)}/${encodePath(path)}`, { bytes, mediaType })).json();
+}
+async function deleteTaskFile(task2, path) {
+  await api("DELETE", `${filesPath(task2)}/${encodePath(path)}`);
+}
+async function listArtifacts(task2) {
+  const query = task2 ? `?task_id=${encodeURIComponent(task2)}` : "";
+  return (await api("GET", `/artifacts${query}`)).artifacts;
+}
+function publishBody(task2, options) {
+  return { task_id: task2, name: options.name, paths: options.path, ...options.entry ? { entry: options.entry } : {} };
+}
+async function publishArtifact(task2, options) {
+  return (await api("POST", "/artifacts", publishBody(task2, options))).artifact;
+}
+async function readArtifactFile(id, path) {
+  return (await apiBytes("GET", `/artifacts/${encodeURIComponent(id)}/files/${encodePath(path)}`)).bytes;
+}
+async function shareArtifact(id, enabled) {
+  return (await api("POST", `/artifacts/${encodeURIComponent(id)}/share`, { enabled })).share_url;
+}
+async function deleteArtifact(id) {
+  await api("DELETE", `/artifacts/${encodeURIComponent(id)}`);
+}
+function renderTaskFile(file) {
+  return `${file.path}  ${file.size_bytes} bytes  ${file.updated_at}${file.updated_by_session ? `  by ${file.updated_by_session}` : ""}`;
+}
+function renderArtifact(artifact2) {
+  const files2 = `${artifact2.files.length} ${artifact2.files.length === 1 ? "file" : "files"}`;
+  return `${artifact2.id}  ${artifact2.name}  v${artifact2.version}  ${files2}  entry ${artifact2.entry}${artifact2.share_url ? `  shared ${artifact2.share_url}` : ""}`;
+}
+
+// src/workspace.ts
+var KINDS = ["TOOL_CALL", "SPEND_CAP", "CALL_COUNT", "CAPABILITY"];
+async function workspaceSlug(explicit) {
+  if (explicit) return explicit;
+  const current = currentUniverse();
+  if (current) return current;
+  return (await api("GET", "/whoami")).universe.slug;
+}
+var workspacePath = (slug) => `/universes/${encodeURIComponent(slug)}`;
+async function listMembers(slug) {
+  return api("GET", `${workspacePath(slug)}/members`);
+}
+function findMember(members, ref) {
+  const needle = ref.toLowerCase();
+  const found = members.find((m) => m.user_id === ref || m.email?.toLowerCase() === needle);
+  if (!found) throw new ApiError(404, "not_found", `no member ${ref} in this workspace`);
+  return found;
+}
+function inviteBody(emails, options) {
+  if (options.role && options.role !== "admin" && options.role !== "member") {
+    throw new ApiError(400, "invalid_request", "--role is admin or member");
+  }
+  return {
+    emails,
+    ...options.role ? { role: options.role } : {},
+    ...options.sendEmail ? { send_email: true } : {}
+  };
+}
+async function invite(slug, emails, options) {
+  return api("POST", `${workspacePath(slug)}/invites`, inviteBody(emails, options));
+}
+async function withdrawInvite(slug, inviteId) {
+  await api("DELETE", `${workspacePath(slug)}/invites/${encodeURIComponent(inviteId)}`);
+}
+async function setRole(slug, memberRef, role) {
+  if (role !== "admin" && role !== "member") throw new ApiError(400, "invalid_request", "a role is admin or member");
+  const member = findMember((await listMembers(slug)).members, memberRef);
+  await api("PATCH", `${workspacePath(slug)}/members/${encodeURIComponent(member.user_id)}`, { role });
+  return member;
+}
+async function removeMember(slug, memberRef) {
+  const member = findMember((await listMembers(slug)).members, memberRef);
+  await api("DELETE", `${workspacePath(slug)}/members/${encodeURIComponent(member.user_id)}`);
+  return member;
+}
+async function joinWorkspace(token) {
+  return (await api("POST", `/invites/${encodeURIComponent(token)}`)).workspace;
+}
+function renderMembers(page) {
+  const lines = page.members.map((m) => `${m.role.padEnd(6)}  ${m.email ?? m.user_id}${m.name ? `  (${m.name})` : ""}  ${m.user_id}`);
+  for (const i of page.invites) lines.push(`invited ${i.email} as ${i.role} by ${i.invited_by} until ${i.expires_at.slice(0, 10)}  ${i.id}`);
+  return lines;
+}
+function policyRuleBody(options) {
+  const kind = options.kind.toUpperCase().replace(/-/g, "_");
+  if (!KINDS.includes(kind)) throw new ApiError(400, "invalid_request", `--kind is one of ${KINDS.join(", ")}`);
+  let config;
+  try {
+    config = JSON.parse(options.config);
+  } catch {
+    throw new ApiError(400, "invalid_request", "--config must be a JSON object");
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new ApiError(400, "invalid_request", "--config must be a JSON object");
+  }
+  const position = options.position === void 0 ? void 0 : Number(options.position);
+  if (position !== void 0 && !Number.isInteger(position)) throw new ApiError(400, "invalid_request", "--position is a whole number");
+  return {
+    name: options.name,
+    kind,
+    config,
+    ...position !== void 0 ? { position } : {},
+    ...options.disabled ? { enabled: false } : {}
+  };
+}
+var policiesPath = (scope) => "session" in scope ? `/sessions/${encodeURIComponent(scope.session)}/policies` : `${workspacePath(scope.slug)}/policies`;
+async function listPolicies(scope, effective = false) {
+  if (effective && "session" in scope) return api("GET", `/sessions/${encodeURIComponent(scope.session)}/effective-policy`);
+  return api("GET", policiesPath(scope));
+}
+async function addPolicy(scope, options) {
+  return (await api("POST", policiesPath(scope), policyRuleBody(options))).rule;
+}
+async function setPolicyEnabled(scope, ruleId, enabled) {
+  return (await api("PATCH", `${policiesPath(scope)}/${encodeURIComponent(ruleId)}`, { enabled })).rule;
+}
+async function removePolicy(scope, ruleId) {
+  await api("DELETE", `${policiesPath(scope)}/${encodeURIComponent(ruleId)}`);
+}
+function renderPolicy(rule) {
+  const state = rule.enabled ? "on " : "off";
+  return `${state}  ${rule.layer.padEnd(9)}  ${rule.kind.padEnd(10)}  ${rule.name}  ${JSON.stringify(rule.config)}  ${rule.id}`;
+}
+
 // src/index.ts
 function printModelBilling(session2) {
   if (session2.modelBilling !== "account") return;
@@ -2055,6 +2390,84 @@ universe.command("show").action(
     }
   })
 );
+universe.command("members [slug]").description("who is in the workspace, and who is invited (owners and admins)").action(
+  run(async (slug) => {
+    for (const line of renderMembers(await listMembers(await workspaceSlug(slug)))) console.log(line);
+  })
+);
+universe.command("invite <emails...>").description("invite people by email; prints each person's join link token").option("--role <role>", "admin | member (default member; admin needs the owner)").option("--send-email", "also email each invitation").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (emails, opts) => {
+    const result = await invite(await workspaceSlug(opts.universe), emails, opts);
+    for (const i of result.invites) console.log(`invited ${i.email} as ${i.role}  ${i.id}`);
+    for (const link of result.links) console.log(`  ${link.email} joins with: sky universe join ${link.token}`);
+    if (!result.invites.length) console.log("nobody new to invite \u2014 everyone listed is already a member");
+  })
+);
+universe.command("uninvite <inviteId>").description("withdraw an invitation that has not been taken up").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (inviteId, opts) => {
+    await withdrawInvite(await workspaceSlug(opts.universe), inviteId);
+    console.log(`Withdrew ${inviteId}`);
+  })
+);
+universe.command("role <member> <role>").description("make a member (user id or email) an admin or a member (owner only)").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (memberRef, role, opts) => {
+    const member = await setRole(await workspaceSlug(opts.universe), memberRef, role);
+    console.log(`${member.email ?? member.user_id} is now ${role}`);
+  })
+);
+universe.command("remove <member>").description("remove a member (user id or email) from the workspace (owner only)").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (memberRef, opts) => {
+    const member = await removeMember(await workspaceSlug(opts.universe), memberRef);
+    console.log(`Removed ${member.email ?? member.user_id}`);
+  })
+);
+universe.command("join <token>").description("accept an invitation sent to your verified email").action(
+  run(async (token) => {
+    const workspace = await joinWorkspace(token);
+    console.log(`Joined ${workspace.slug} (${workspace.name}) \u2014 sky universe switch ${workspace.slug}`);
+  })
+);
+var policy = program.command("policy").description("policy rules: tool calls, spend caps, call counts, capabilities");
+async function policyScope(opts) {
+  return opts.session ? { session: await resolveSessionRef(opts.session) } : { slug: await workspaceSlug(opts.universe) };
+}
+var scopeOptions = (command) => command.option("--session <ref>", "one session's rules instead of the workspace's").option("--universe <slug>", "the workspace (default: the current one)");
+scopeOptions(
+  policy.command("list").description("the workspace's rules, or one session's; --effective merges every layer").option("--effective", "with --session: every rule the session runs under")
+).action(
+  run(async (opts) => {
+    const { rules, note } = await listPolicies(await policyScope(opts), opts.effective);
+    if (!rules.length) console.log("no policy rules");
+    for (const rule of rules) console.log(renderPolicy(rule));
+    if (note) console.log(note);
+  })
+);
+scopeOptions(
+  policy.command("add").description("add a rule (workspace owner, or the session's owner with --session)").requiredOption("--name <name>", "what the rule is for").requiredOption("--kind <kind>", "TOOL_CALL | SPEND_CAP | CALL_COUNT | CAPABILITY").requiredOption(
+    "--config <json>",
+    `e.g. '{"action":"deny","matcher":"Bash","commandPatterns":["rm -rf *"]}', '{"hardCapUsdMicros":5000000}', '{"limitPerSession":200}', '{"platform.orchestration":"deny"}'`
+  ).option("--position <n>", "evaluation order, lowest first (default 0)").option("--disabled", "create it switched off")
+).action(
+  run(async (opts) => {
+    console.log(renderPolicy(await addPolicy(await policyScope(opts), opts)));
+  })
+);
+for (const [verb, enabled, description] of [
+  ["enable", true, "switch a rule on"],
+  ["disable", false, "switch a rule off (kept, so it can be switched on again)"]
+]) {
+  scopeOptions(policy.command(`${verb} <ruleId>`).description(description)).action(
+    run(async (ruleId, opts) => {
+      console.log(renderPolicy(await setPolicyEnabled(await policyScope(opts), ruleId, enabled)));
+    })
+  );
+}
+scopeOptions(policy.command("rm <ruleId>").description("delete a rule")).action(
+  run(async (ruleId, opts) => {
+    await removePolicy(await policyScope(opts), ruleId);
+    console.log(`Deleted ${ruleId}`);
+  })
+);
 var agent = program.command("agent").description("agent specs: create, inspect, talk (via the default session)");
 agent.command("create").description("create an agent spec \u2014 no runtime; `sky session create` starts one").option("--type <type>", "hermes | claude_code | codex | openclaw | pi | dsh | kimi_code | opencode").option("--llm <llm>", "model id (defaults per type)").option(
   "--reasoning-effort <level>",
@@ -2449,7 +2862,7 @@ program.command("skill").description("the AgentSky skill for the agents on this
     for (const i of installs) console.log(`${i.agent.padEnd(12)} ${verb[i.outcome].padEnd(14)} ${i.path}`);
   })
 );
-program.command("setup [steps...]").description("bring this machine's agents to AgentSky: the skill, your plans, your skills and instructions, your tool keys").addHelpText("after", `
+program.command("setup [steps...]").description("bring this machine's agents to AgentSky: the skill and its MCP server, your plans, your skills and instructions, your tool keys").addHelpText("after", `
 Steps (all when none is named): ${SETUP_STEPS.join(" | ")}`).option("--key <key>", "a setup key from agentsky.dev/setup").option("--agent <id...>", "only these agents: claude_code | codex | cursor").option("--secret <name...>", "save these tool keys to your vault (asked one by one when omitted)").option("--no-claude", "leave the Claude plan alone").option("--plan <name...>", "connect only these plans: claude | chatgpt | cursor").option("--dry-run", "say what would be done; write and send nothing").option("-y, --yes", "do not ask before each step").option("--json", "print progress as one JSON object per line; never asks").action(
   run(async (steps, opts) => {
     const unknown = steps.find((step) => !SETUP_STEPS.includes(step));
@@ -2700,6 +3113,69 @@ files.command("download <id>").description("download a session file's bytes").re
     console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
   })
 );
+var task = program.command("task").description("a task's shared files (the task is its first session's id)");
+task.command("files <task>").description("list the task's current files").action(
+  run(async (taskId) => {
+    const list = await listTaskFiles(taskId);
+    if (!list.length) console.log("no files");
+    for (const file of list) console.log(renderTaskFile(file));
+  })
+);
+task.command("get <task> <path>").description("read one task file; prints it, or writes it with -o").option("-o, --out <path>", "where to write the bytes").action(
+  run(async (taskId, path, opts) => {
+    const bytes = await readTaskFile(taskId, path);
+    if (opts.out) {
+      writeFileSync6(opts.out, bytes);
+      console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
+    } else process.stdout.write(bytes);
+  })
+);
+task.command("put <task> <path> <local>").description("write a local file to <path> in the task's files (every session of the task sees it)").action(
+  run(async (taskId, path, local) => {
+    const { file, conflict } = await writeTaskFile(taskId, path, readFileSync10(local), mediaTypeFor(local));
+    console.log(`${renderTaskFile(file)}${conflict ? "  (replaced a version you had not seen)" : ""}`);
+  })
+);
+task.command("rm <task> <path>").description("remove a path from the task's files (its history is kept)").action(
+  run(async (taskId, path) => {
+    await deleteTaskFile(taskId, path);
+    console.log(`Removed ${path}`);
+  })
+);
+var artifact = program.command("artifact").description("artifacts: publish a task's files as a named, shareable result");
+artifact.command("list").description("the workspace's artifacts, or one task's with --task").option("--task <task>", "only this task's artifacts").action(
+  run(async (opts) => {
+    const list = await listArtifacts(opts.task);
+    if (!list.length) console.log("no artifacts");
+    for (const a of list) console.log(renderArtifact(a));
+  })
+);
+artifact.command("publish <task>").description("publish paths from the task's files as a new version of the named artifact").requiredOption("--name <name>", "the artifact's name; publishing the same name again adds a version").requiredOption("--path <path...>", "task file paths to include").option("--entry <path>", "the file a viewer opens first (default: the first path)").action(
+  run(async (taskId, opts) => {
+    console.log(renderArtifact(await publishArtifact(taskId, opts)));
+  })
+);
+artifact.command("get <id> <path>").description("read one file of an artifact; prints it, or writes it with -o").option("-o, --out <path>", "where to write the bytes").action(
+  run(async (id, path, opts) => {
+    const bytes = await readArtifactFile(id, path);
+    if (opts.out) {
+      writeFileSync6(opts.out, bytes);
+      console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
+    } else process.stdout.write(bytes);
+  })
+);
+artifact.command("share <id>").description("turn on a public link anyone can open; --off turns it off (the old link stops working)").option("--off", "stop sharing").action(
+  run(async (id, opts) => {
+    const url = await shareArtifact(id, !opts.off);
+    console.log(url ?? `Stopped sharing ${id}`);
+  })
+);
+artifact.command("rm <id>").description("delete an artifact").action(
+  run(async (id) => {
+    await deleteArtifact(id);
+    console.log(`Deleted ${id}`);
+  })
+);
 function routineLine(r) {
   const target = r.target.type === "session" ? `\u2192 ${r.target.session_id}` : `+ ${r.target.agent}`;
   const cron = r.schedule ? `${r.schedule.expression} ${r.schedule.timezone}` : "manual-only";