switchroom 0.13.44 → 0.13.45

package/dist/cli/switchroom.js

@@ -39600,7 +39600,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve44) => setTimeout(resolve44, pollInterval));
+        await new Promise((resolve47) => setTimeout(resolve47, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -39612,7 +39612,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve44, reject) => {
+    return new Promise((resolve47, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -39690,7 +39690,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve44(parseResult.data);
+            resolve47(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -39881,12 +39881,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve44, reject) => {
+    return new Promise((resolve47, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode2.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve44, interval);
+      const timeoutId = setTimeout(resolve47, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode2.InvalidRequest, "Request cancelled"));
@@ -42871,7 +42871,7 @@ var require_compile = __commonJS((exports2) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve44.call(this, root, ref);
+    let _sch = resolve47.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -42898,7 +42898,7 @@ var require_compile = __commonJS((exports2) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve44(root, ref) {
+  function resolve47(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -43428,55 +43428,55 @@ var require_fast_uri = __commonJS((exports2, module) => {
     }
     return uri;
   }
-  function resolve44(baseURI, relativeURI, options) {
+  function resolve47(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
-  function resolveComponent(base, relative2, options, skipNormalization) {
+  function resolveComponent(base, relative4, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse6(serialize(base, options), options);
-      relative2 = parse6(serialize(relative2, options), options);
+      relative4 = parse6(serialize(relative4, options), options);
     }
     options = options || {};
-    if (!options.tolerant && relative2.scheme) {
-      target.scheme = relative2.scheme;
-      target.userinfo = relative2.userinfo;
-      target.host = relative2.host;
-      target.port = relative2.port;
-      target.path = removeDotSegments(relative2.path || "");
-      target.query = relative2.query;
+    if (!options.tolerant && relative4.scheme) {
+      target.scheme = relative4.scheme;
+      target.userinfo = relative4.userinfo;
+      target.host = relative4.host;
+      target.port = relative4.port;
+      target.path = removeDotSegments(relative4.path || "");
+      target.query = relative4.query;
     } else {
-      if (relative2.userinfo !== undefined || relative2.host !== undefined || relative2.port !== undefined) {
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (relative4.userinfo !== undefined || relative4.host !== undefined || relative4.port !== undefined) {
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (!relative2.path) {
+        if (!relative4.path) {
           target.path = base.path;
-          if (relative2.query !== undefined) {
-            target.query = relative2.query;
+          if (relative4.query !== undefined) {
+            target.query = relative4.query;
           } else {
             target.query = base.query;
           }
         } else {
-          if (relative2.path[0] === "/") {
-            target.path = removeDotSegments(relative2.path);
+          if (relative4.path[0] === "/") {
+            target.path = removeDotSegments(relative4.path);
           } else {
             if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
-              target.path = "/" + relative2.path;
+              target.path = "/" + relative4.path;
             } else if (!base.path) {
-              target.path = relative2.path;
+              target.path = relative4.path;
             } else {
-              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
             }
             target.path = removeDotSegments(target.path);
           }
-          target.query = relative2.query;
+          target.query = relative4.query;
         }
         target.userinfo = base.userinfo;
         target.host = base.host;
@@ -43484,7 +43484,7 @@ var require_fast_uri = __commonJS((exports2, module) => {
       }
       target.scheme = base.scheme;
     }
-    target.fragment = relative2.fragment;
+    target.fragment = relative4.fragment;
     return target;
   }
   function equal(uriA, uriB, options) {
@@ -43656,7 +43656,7 @@ var require_fast_uri = __commonJS((exports2, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve44,
+    resolve: resolve47,
     resolveComponent,
     equal,
     serialize,
@@ -47039,12 +47039,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve44) => {
+    return new Promise((resolve47) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve44();
+        resolve47();
       } else {
-        this._stdout.once("drain", resolve44);
+        this._stdout.once("drain", resolve47);
       }
     });
   }
@@ -47061,12 +47061,13 @@ __export(exports_server, {
   dispatchTool: () => dispatchTool,
   TOOLS: () => TOOLS
 });
-import { spawnSync as spawnSync10 } from "node:child_process";
-function execCli(args) {
-  const r = spawnSync10(CLI_BIN, args, {
+import { spawnSync as spawnSync12 } from "node:child_process";
+function execCli(args, stdin) {
+  const r = spawnSync12(CLI_BIN, args, {
     encoding: "utf-8",
     env: process.env,
-    timeout: 15000
+    timeout: 15000,
+    ...stdin !== undefined ? { input: stdin } : {}
   });
   return {
     stdout: r.stdout ?? "",
@@ -47094,6 +47095,7 @@ function buildArgs(base, a) {
 function dispatchTool(name, args) {
   let cliArgs;
   let parseMode;
+  let stdinJson;
   switch (name) {
     case "config_get":
       cliArgs = buildArgs(["config", "get"], args);
@@ -47182,10 +47184,64 @@ function dispatchTool(name, args) {
       parseMode = "json";
       break;
     }
+    case "skill_init_personal":
+    case "skill_edit_personal": {
+      const a = args;
+      if (!a.name || typeof a.name !== "string") {
+        return errorText(`${name}: name is required`);
+      }
+      if (!a.files || typeof a.files !== "object" || Array.isArray(a.files)) {
+        return errorText(`${name}: files object is required`);
+      }
+      const verb = name === "skill_init_personal" ? "init-personal" : "edit-personal";
+      const base = ["skill", verb, a.name];
+      if (a.agent)
+        base.push("--agent", a.agent);
+      cliArgs = base;
+      parseMode = "json";
+      stdinJson = JSON.stringify(a.files);
+      break;
+    }
+    case "skill_remove_personal": {
+      const a = args;
+      if (!a.name) {
+        return errorText("skill_remove_personal: name is required");
+      }
+      const base = ["skill", "remove-personal", a.name];
+      if (a.agent)
+        base.push("--agent", a.agent);
+      cliArgs = base;
+      parseMode = "json";
+      break;
+    }
+    case "skill_list_personal": {
+      const a = args;
+      const base = ["skill", "list-personal"];
+      if (a.agent)
+        base.push("--agent", a.agent);
+      cliArgs = base;
+      parseMode = "json";
+      break;
+    }
+    case "skill_search": {
+      const a = args;
+      const base = ["skill", "search"];
+      if (a.agent)
+        base.push("--agent", a.agent);
+      if (a.query)
+        base.push("--query", a.query);
+      if (a.tier)
+        base.push("--tier", a.tier);
+      if (typeof a.limit === "number")
+        base.push("--limit", String(a.limit));
+      cliArgs = base;
+      parseMode = "json";
+      break;
+    }
     default:
       return errorText(`unknown tool: ${name}`);
   }
-  const r = execCli(cliArgs);
+  const r = execCli(cliArgs, stdinJson);
   if (r.status !== 0) {
     return errorText(`CLI exit ${r.status}: ${r.stderr.trim() || r.stdout.trim()}`);
   }
@@ -47324,6 +47380,28 @@ var init_server3 = __esm(() => {
         }
       }
     },
+    {
+      name: "skill_search",
+      description: "Enumerate skills the calling agent can see, across three tiers: " + "`personal` (own .claude/skills/personal-* workspace), `shared` " + "(operator-curated pool at ~/.switchroom/skills/), `bundled` " + "(shipped with switchroom). Read-only \u2014 no approval, no write, no " + "fleet exposure. Returns SKILL.md frontmatter + path + size + " + "mtime per match, with stable sort (personal \u2192 shared \u2192 bundled, " + "then name). Use this BEFORE authoring a new skill \u2014 odds are it " + "exists already, possibly in bundled.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Case-insensitive substring match against name, description, jtbd."
+          },
+          tier: {
+            type: "string",
+            enum: ["personal", "shared", "bundled", "any"],
+            description: "Filter to one tier; default `any`."
+          },
+          limit: {
+            type: "number",
+            description: "Cap result count (default 50, max 500)."
+          }
+        }
+      }
+    },
     {
       name: "skill_remove",
       description: "Remove an overlay-installed skill by slug. The agent's " + "`.claude/skills/<name>` symlink is removed on next reconcile. " + "Does NOT affect operator-installed skills listed directly in " + "switchroom.yaml \u2014 those are removed by the operator only.",
@@ -47338,6 +47416,67 @@ var init_server3 = __esm(() => {
           }
         }
       }
+    },
+    {
+      name: "skill_init_personal",
+      description: "Create a personal skill in this agent's writable workspace " + "(`<agentDir>/.claude/skills/personal-<name>/`). Multi-file " + "payload via `files: {path: content}`. Validates against the " + "same gates an operator-driven `switchroom skill apply` would " + "\u2014 name regex, path allowlist, SKILL.md frontmatter, bundle " + "size, banned-headless-phrase content scan, bash -n / py_compile. " + "No operator approval \u2014 agent owns its workspace.",
+      inputSchema: {
+        type: "object",
+        required: ["name", "files"],
+        properties: {
+          name: {
+            type: "string",
+            pattern: "^[a-z0-9][a-z0-9_-]{0,62}$",
+            description: "Skill slug (becomes the dir name `personal-<slug>`)."
+          },
+          files: {
+            type: "object",
+            description: "Multi-file payload \u2014 keys are relative paths under the skill " + "dir (must match the SKILL.md allowlist: SKILL.md, README.md, " + "scripts/*.{sh,py}, assets/..., reference/*.md). Values are " + "the file contents (strings)."
+          }
+        }
+      }
+    },
+    {
+      name: "skill_edit_personal",
+      description: "Overwrite an existing personal skill. Same gates as " + "skill_init_personal. Fails if the skill doesn't already exist " + "(use skill_init_personal first).",
+      inputSchema: {
+        type: "object",
+        required: ["name", "files"],
+        properties: {
+          name: {
+            type: "string",
+            pattern: "^[a-z0-9][a-z0-9_-]{0,62}$",
+            description: "Skill slug to overwrite."
+          },
+          files: {
+            type: "object",
+            description: "Multi-file payload (see skill_init_personal)."
+          }
+        }
+      }
+    },
+    {
+      name: "skill_remove_personal",
+      description: "Soft-remove a personal skill. The dir moves to " + "`<agentDir>/.claude/skills-trash/<name>-<unix-ts>/` for 24h " + "recovery. Lazy sweep on next personal-skill op deletes " + "entries older than 24h.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: {
+            type: "string",
+            pattern: "^[a-z0-9][a-z0-9_-]{0,62}$",
+            description: "Skill slug to remove."
+          }
+        }
+      }
+    },
+    {
+      name: "skill_list_personal",
+      description: "List personal skills owned by this agent. Returns name, on-disk " + "path, file count, and total bytes per skill. Read-only.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
     }
   ];
 });
@@ -47352,7 +47491,7 @@ __export(exports_server2, {
   TOOLS: () => TOOLS2
 });
 import { randomBytes as randomBytes14 } from "node:crypto";
-import { existsSync as existsSync75, readFileSync as readFileSync60 } from "node:fs";
+import { existsSync as existsSync78, readFileSync as readFileSync63 } from "node:fs";
 function selfSocketPath() {
   return `/run/switchroom/hostd/${SELF_AGENT}/sock`;
 }
@@ -47367,7 +47506,7 @@ async function dispatchTool2(name, args) {
     return errorText2("hostd MCP: SWITCHROOM_AGENT_NAME env var is not set \u2014 cannot " + "determine which per-agent socket to talk to.");
   }
   const sockPath = selfSocketPath();
-  if (!existsSync75(sockPath)) {
+  if (!existsSync78(sockPath)) {
     return errorText2(`hostd MCP: socket not bound at ${sockPath}. The host-control ` + `daemon is either not installed (run \`switchroom hostd install\`) ` + `or this agent isn't admin-flagged in switchroom.yaml. RFC C ` + `bind-mounts the per-agent socket only when host_control.enabled ` + `is true AND the agent has admin: true.`);
   }
   let req;
@@ -47519,18 +47658,18 @@ function resolveAuditLogPath() {
   if (process.env.HOSTD_AUDIT_LOG_PATH)
     return process.env.HOSTD_AUDIT_LOG_PATH;
   const bindMounted = "/host-home/.switchroom/host-control-audit.log";
-  if (existsSync75(bindMounted))
+  if (existsSync78(bindMounted))
     return bindMounted;
   return defaultAuditLogPath2();
 }
 function getLastUpdateApplyStatus() {
   const path8 = resolveAuditLogPath();
-  if (!existsSync75(path8)) {
+  if (!existsSync78(path8)) {
     return errorText2(`get_status: audit log not found at ${path8}. No update_apply has run yet?`);
   }
   let raw;
   try {
-    raw = readFileSync60(path8, "utf-8");
+    raw = readFileSync63(path8, "utf-8");
   } catch (err2) {
     return errorText2(`get_status: failed to read audit log at ${path8}: ${err2.message}`);
   }
@@ -47763,8 +47902,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.44";
-var COMMIT_SHA = "fa99d4de";
+var VERSION = "0.13.45";
+var COMMIT_SHA = "e6c3e655";
 
 // src/cli/agent.ts
 init_source();
@@ -75660,7 +75799,7 @@ function registerAgentConfigCommands(program3) {
       process.exit(1);
     }
   }));
-  const skill = program3.command("skill").description("Read-only access to an agent's skill list");
+  const skill = program3.commands.find((c) => c.name() === "skill") ?? program3.command("skill").description("Read-only access to an agent's skill list");
   skill.command("list").description("List the agent's configured skills as JSON").option("--agent <name>", "Target agent (defaults to $SWITCHROOM_AGENT_NAME)").action(withConfigError(async (opts) => {
     let agent;
     try {
@@ -76887,6 +77026,1223 @@ function registerAgentConfigSkillWriteCommands(program3) {
   });
 }
 
+// src/cli/skill.ts
+import {
+  closeSync as closeSync15,
+  existsSync as existsSync75,
+  lstatSync as lstatSync8,
+  mkdirSync as mkdirSync40,
+  mkdtempSync as mkdtempSync5,
+  openSync as openSync15,
+  readFileSync as readFileSync60,
+  readdirSync as readdirSync29,
+  realpathSync as realpathSync7,
+  renameSync as renameSync16,
+  rmSync as rmSync16,
+  statSync as statSync29,
+  writeFileSync as writeFileSync34
+} from "node:fs";
+import { tmpdir as tmpdir4, homedir as homedir38 } from "node:os";
+import { dirname as dirname20, join as join68, relative as relative2, resolve as resolve44 } from "node:path";
+import { spawnSync as spawnSync10 } from "node:child_process";
+
+// src/cli/skill-common.ts
+var import_yaml17 = __toESM(require_dist(), 1);
+var MAX_FILE_BYTES = 256 * 1024;
+var MAX_SKILL_BYTES = 2 * 1024 * 1024;
+var MAX_FILES_PER_SKILL = 50;
+var MAX_PATH_DEPTH = 3;
+var MAX_DESCRIPTION_LEN = 1024;
+function authorExitCodeFor(code) {
+  switch (code) {
+    case "E_SKILL_ALREADY_EXISTS":
+      return 13;
+    case "E_SKILL_NOT_FOUND":
+      return 14;
+    case "E_SKILL_FILE_TOO_LARGE":
+    case "E_SKILL_BUNDLE_TOO_LARGE":
+      return 15;
+    case "E_SKILL_INVALID_NAME":
+    case "E_SKILL_INVALID_PATH":
+    case "E_SKILL_INVALID_FRONTMATTER":
+    case "E_SKILL_SCOPE_DENIED":
+      return 9;
+    case "E_AGENT_PIN_REQUIRED":
+      return 16;
+    case "E_SKILL_GLOBAL_MOUNT_UNCONFIGURED":
+      return 17;
+    case "E_SKILL_OPERATOR_OWNED":
+      return 18;
+  }
+}
+function authorErr(code, message) {
+  return { ok: false, code, message, exit: authorExitCodeFor(code) };
+}
+function validateRelPath(p) {
+  if (typeof p !== "string" || p.length === 0)
+    return false;
+  if (p.includes("\x00"))
+    return false;
+  if (p.startsWith("/") || p.startsWith("\\"))
+    return false;
+  if (/^[a-zA-Z]:[\\/]/.test(p))
+    return false;
+  const norm = p.replace(/\\/g, "/");
+  const parts = norm.split("/");
+  if (parts.length > MAX_PATH_DEPTH)
+    return false;
+  for (const seg of parts) {
+    if (seg === "" || seg === "." || seg === "..")
+      return false;
+    if (seg.startsWith("."))
+      return false;
+  }
+  if (parts.length === 1) {
+    return parts[0] === "SKILL.md" || parts[0] === "README.md";
+  }
+  if (parts.length === 2) {
+    const [dir, file] = parts;
+    if (dir === "scripts")
+      return /^[A-Za-z0-9_.-]+\.(sh|py)$/.test(file);
+    if (dir === "assets")
+      return /^[A-Za-z0-9_.-]+$/.test(file);
+    if (dir === "reference")
+      return /^[A-Za-z0-9_.-]+\.md$/.test(file);
+    return false;
+  }
+  if (parts.length === 3) {
+    if (parts[0] !== "assets")
+      return false;
+    if (!/^[A-Za-z0-9_.-]+$/.test(parts[1]))
+      return false;
+    if (!/^[A-Za-z0-9_.-]+$/.test(parts[2]))
+      return false;
+    return true;
+  }
+  return false;
+}
+function validateSkillMd(content, expectedName) {
+  if (typeof content !== "string" || content.length === 0) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", "SKILL.md is empty");
+  }
+  if (!content.startsWith(`---
+`) && !content.startsWith(`---\r
+`)) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", "SKILL.md must begin with YAML frontmatter delimited by `---`");
+  }
+  const rest = content.slice(content.indexOf(`
+`) + 1);
+  const endIdx = rest.indexOf(`
+---`);
+  if (endIdx < 0) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", "SKILL.md frontmatter has no closing `---`");
+  }
+  const fmText = rest.slice(0, endIdx);
+  const seen = new Set;
+  for (const line of fmText.split(/\r?\n/)) {
+    const m = /^([A-Za-z0-9_-]+)\s*:/.exec(line);
+    if (!m)
+      continue;
+    const key = m[1];
+    if (seen.has(key)) {
+      return authorErr("E_SKILL_INVALID_FRONTMATTER", `duplicate frontmatter key: ${key}`);
+    }
+    seen.add(key);
+  }
+  let parsed;
+  try {
+    parsed = import_yaml17.parse(fmText);
+  } catch (e) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", `frontmatter is not valid YAML: ${e.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", "frontmatter must be a YAML mapping");
+  }
+  const fm = parsed;
+  if (fm.name !== expectedName) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", `frontmatter name=${JSON.stringify(fm.name)} must equal the skill slug ${JSON.stringify(expectedName)}`);
+  }
+  const desc = fm.description;
+  if (typeof desc !== "string" || desc.length < 1 || desc.length > MAX_DESCRIPTION_LEN) {
+    return authorErr("E_SKILL_INVALID_FRONTMATTER", `frontmatter description must be a string 1..${MAX_DESCRIPTION_LEN} chars`);
+  }
+  return { ok: true, frontmatter: fm };
+}
+var BANNED_PHRASE = "claude" + " -p";
+var CLAUDE_P_LITERAL_RE = /\bclaude\s+-p\b/m;
+function scanForClaudeP(content) {
+  const normalised = content.replace(/\\\r?\n\s*/g, " ");
+  return CLAUDE_P_LITERAL_RE.test(normalised);
+}
+var SH_SCRIPT_RE = /^scripts\/[A-Za-z0-9_.-]+\.sh$/;
+var PY_SCRIPT_RE = /^scripts\/[A-Za-z0-9_.-]+\.py$/;
+var SKILL_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+function validateSkillBundle(name, files) {
+  const errors2 = [];
+  if (!SKILL_SLUG_RE.test(name)) {
+    errors2.push(`skill name must match ${SKILL_SLUG_RE.source}: got ${JSON.stringify(name)}`);
+  }
+  for (const path8 of Object.keys(files)) {
+    if (!validateRelPath(path8)) {
+      errors2.push(`disallowed file path: ${JSON.stringify(path8)}`);
+    }
+  }
+  const skillMd = files["SKILL.md"];
+  if (skillMd === undefined) {
+    errors2.push("payload is missing SKILL.md (required)");
+  } else {
+    const r = validateSkillMd(skillMd, name);
+    if (!r.ok) {
+      errors2.push(`SKILL.md validation failed: ${r.message}`);
+    }
+  }
+  const fileCount = Object.keys(files).length;
+  if (fileCount > MAX_FILES_PER_SKILL) {
+    errors2.push(`bundle has ${fileCount} files; max is ${MAX_FILES_PER_SKILL}`);
+  }
+  let totalBytes = 0;
+  for (const [path8, content] of Object.entries(files)) {
+    const bytes = Buffer.byteLength(content, "utf-8");
+    if (bytes > MAX_FILE_BYTES) {
+      errors2.push(`${path8} is ${bytes} bytes; max per file is ${MAX_FILE_BYTES}`);
+    }
+    totalBytes += bytes;
+  }
+  if (totalBytes > MAX_SKILL_BYTES) {
+    errors2.push(`bundle total ${totalBytes} bytes; max per skill is ${MAX_SKILL_BYTES}`);
+  }
+  for (const [path8, content] of Object.entries(files)) {
+    if (SH_SCRIPT_RE.test(path8) || PY_SCRIPT_RE.test(path8)) {
+      if (scanForClaudeP(content)) {
+        errors2.push(`${path8} contains the banned ${BANNED_PHRASE} invocation \u2014 ` + `programmatic usage under Anthropic 2026-06-15 policy. ` + `Route via inject_inbound IPC into the live session instead.`);
+      }
+    }
+  }
+  return { ok: errors2.length === 0, errors: errors2 };
+}
+
+// src/cli/skill.ts
+init_loader();
+init_helpers();
+init_source();
+var SKILL_NAME_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+var SH_SCRIPT_RE2 = /^scripts\/[A-Za-z0-9_.-]+\.sh$/;
+var PY_SCRIPT_RE2 = /^scripts\/[A-Za-z0-9_.-]+\.py$/;
+var BANNED_PHRASE2 = "claude" + " -p";
+var CLAUDE_P_LITERAL_RE2 = /\bclaude\s+-p\b/m;
+function scanForClaudeP2(content) {
+  const normalised = content.replace(/\\\r?\n\s*/g, " ");
+  return CLAUDE_P_LITERAL_RE2.test(normalised);
+}
+function resolveSkillsPoolDir2(override) {
+  const raw = override ?? "~/.switchroom/skills";
+  if (raw.startsWith("~/")) {
+    return join68(homedir38(), raw.slice(2));
+  }
+  if (raw === "~")
+    return homedir38();
+  return resolve44(raw);
+}
+function readStdinSync() {
+  const chunks = [];
+  const buf = Buffer.alloc(64 * 1024);
+  while (true) {
+    let n = 0;
+    try {
+      const fs5 = __require("node:fs");
+      n = fs5.readSync(0, buf, 0, buf.length, null);
+    } catch (e) {
+      const err2 = e;
+      if (err2.code === "EAGAIN")
+        continue;
+      break;
+    }
+    if (n <= 0)
+      break;
+    chunks.push(Buffer.from(buf.subarray(0, n)));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function isTarballPath(p) {
+  const lower = p.toLowerCase();
+  return lower.endsWith(".tar") || lower.endsWith(".tar.gz") || lower.endsWith(".tgz");
+}
+function loadFromDir(dir) {
+  const abs = realpathSync7(dir);
+  if (!statSync29(abs).isDirectory()) {
+    fail2(`--from path is not a directory: ${dir}`);
+  }
+  const files = {};
+  const walk2 = (sub) => {
+    const entries = readdirSync29(sub, { withFileTypes: true });
+    for (const ent of entries) {
+      const full = join68(sub, ent.name);
+      const rel = relative2(abs, full);
+      if (ent.isSymbolicLink()) {
+        fail2(`refusing to read symlink inside --from dir: ${rel}`);
+      }
+      if (ent.isDirectory()) {
+        walk2(full);
+        continue;
+      }
+      if (ent.isFile()) {
+        const buf = readFileSync60(full);
+        files[rel.replace(/\\/g, "/")] = buf.toString("utf-8");
+      }
+    }
+  };
+  walk2(abs);
+  return files;
+}
+function loadFromTarball(tarPath) {
+  const isGz = tarPath.endsWith(".gz") || tarPath.endsWith(".tgz");
+  const listFlags = isGz ? ["-tzf"] : ["-tf"];
+  const list2 = spawnSync10("tar", [...listFlags, tarPath], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (list2.status !== 0) {
+    fail2(`tar list failed (exit ${list2.status}): ${(list2.stderr ?? "").trim()}`);
+  }
+  const entries = (list2.stdout ?? "").split(`
+`).map((s) => s.trim()).filter((s) => s.length > 0 && !s.endsWith("/"));
+  for (const entry of entries) {
+    if (!validateRelPath(entry)) {
+      fail2(`tarball contains disallowed path: ${JSON.stringify(entry)} \u2014 ` + `refusing to extract before any file is written`);
+    }
+  }
+  const staging = mkdtempSync5(join68(tmpdir4(), "skill-apply-extract-"));
+  try {
+    const flags = isGz ? ["-xzf"] : ["-xf"];
+    const r = spawnSync10("tar", [
+      ...flags,
+      tarPath,
+      "-C",
+      staging,
+      "--no-same-owner",
+      "--no-same-permissions",
+      "--no-absolute-names"
+    ], { stdio: "pipe" });
+    if (r.status !== 0) {
+      const stderr = r.stderr?.toString("utf-8") ?? "(no stderr)";
+      fail2(`tar extraction failed (exit ${r.status}): ${stderr.trim()}`);
+    }
+    return loadFromDir(staging);
+  } finally {
+    try {
+      rmSync16(staging, { recursive: true, force: true });
+    } catch {}
+  }
+}
+function loadSingleFile(filePath) {
+  const content = readFileSync60(filePath, "utf-8");
+  return { "SKILL.md": content };
+}
+function loadFromStdin() {
+  const content = readStdinSync();
+  if (content.length === 0) {
+    fail2("no content on stdin; either pipe SKILL.md content in or pass --from");
+  }
+  return { "SKILL.md": content };
+}
+function validatePayload(name, files) {
+  const errors2 = [];
+  if (!SKILL_NAME_RE.test(name)) {
+    errors2.push(`skill name must match ${SKILL_NAME_RE.source}: got ${JSON.stringify(name)}`);
+  }
+  for (const path8 of Object.keys(files)) {
+    if (!validateRelPath(path8)) {
+      errors2.push(`disallowed file path: ${JSON.stringify(path8)}`);
+    }
+  }
+  const skillMd = files["SKILL.md"];
+  if (skillMd === undefined) {
+    errors2.push("payload is missing SKILL.md (required)");
+  } else {
+    const r = validateSkillMd(skillMd, name);
+    if (!r.ok) {
+      errors2.push(`SKILL.md validation failed: ${r.message}`);
+    }
+  }
+  const fileCount = Object.keys(files).length;
+  if (fileCount > MAX_FILES_PER_SKILL) {
+    errors2.push(`bundle has ${fileCount} files; max is ${MAX_FILES_PER_SKILL}`);
+  }
+  let totalBytes = 0;
+  for (const [path8, content] of Object.entries(files)) {
+    const bytes = Buffer.byteLength(content, "utf-8");
+    if (bytes > MAX_FILE_BYTES) {
+      errors2.push(`${path8} is ${bytes} bytes; max per file is ${MAX_FILE_BYTES}`);
+    }
+    totalBytes += bytes;
+  }
+  if (totalBytes > MAX_SKILL_BYTES) {
+    errors2.push(`bundle total ${totalBytes} bytes; max per skill is ${MAX_SKILL_BYTES}`);
+  }
+  for (const [path8, content] of Object.entries(files)) {
+    if (SH_SCRIPT_RE2.test(path8) || PY_SCRIPT_RE2.test(path8)) {
+      if (scanForClaudeP2(content)) {
+        errors2.push(`${path8} contains the banned ${BANNED_PHRASE2} invocation \u2014 ` + `programmatic usage under Anthropic 2026-06-15 policy. ` + `Route via inject_inbound IPC into the live session instead.`);
+      }
+    }
+  }
+  if (errors2.length === 0) {
+    for (const [path8, content] of Object.entries(files)) {
+      if (SH_SCRIPT_RE2.test(path8)) {
+        const r = spawnSync10("bash", ["-n"], {
+          input: content,
+          encoding: "utf-8"
+        });
+        if (r.status !== 0) {
+          errors2.push(`${path8} fails \`bash -n\` syntax check: ${(r.stderr ?? "").trim()}`);
+        }
+      } else if (PY_SCRIPT_RE2.test(path8)) {
+        const tmp = mkdtempSync5(join68(tmpdir4(), "skill-apply-py-"));
+        const tmpPy = join68(tmp, "check.py");
+        try {
+          writeFileSync34(tmpPy, content);
+          const r = spawnSync10("python3", ["-m", "py_compile", tmpPy], {
+            encoding: "utf-8"
+          });
+          if (r.status !== 0) {
+            errors2.push(`${path8} fails \`python3 -m py_compile\` syntax check: ${(r.stderr ?? "").trim()}`);
+          }
+        } finally {
+          rmSync16(tmp, { recursive: true, force: true });
+        }
+      }
+    }
+  }
+  return { ok: errors2.length === 0, errors: errors2 };
+}
+function diffSummary(currentDir, files) {
+  const lines = [];
+  const currentFiles = {};
+  if (existsSync75(currentDir)) {
+    const walk2 = (sub) => {
+      for (const ent of readdirSync29(sub, { withFileTypes: true })) {
+        const full = join68(sub, ent.name);
+        const rel = relative2(currentDir, full);
+        if (ent.isDirectory()) {
+          walk2(full);
+        } else if (ent.isFile()) {
+          currentFiles[rel.replace(/\\/g, "/")] = readFileSync60(full, "utf-8");
+        }
+      }
+    };
+    walk2(currentDir);
+  }
+  const allPaths = new Set([
+    ...Object.keys(currentFiles),
+    ...Object.keys(files)
+  ]);
+  for (const path8 of [...allPaths].sort()) {
+    const before = currentFiles[path8];
+    const after = files[path8];
+    if (before === undefined && after !== undefined) {
+      lines.push(source_default.green(`  + ${path8}  (${Buffer.byteLength(after, "utf-8")} bytes)`));
+    } else if (before !== undefined && after === undefined) {
+      lines.push(source_default.red(`  - ${path8}  (was ${Buffer.byteLength(before, "utf-8")} bytes)`));
+    } else if (before !== after) {
+      lines.push(source_default.yellow(`  ~ ${path8}  (${Buffer.byteLength(before, "utf-8")} \u2192 ${Buffer.byteLength(after, "utf-8")} bytes)`));
+    }
+  }
+  if (lines.length === 0) {
+    return "  (no changes \u2014 payload matches current pool content)";
+  }
+  return lines.join(`
+`);
+}
+function writePayload(poolDir, name, files) {
+  if (!existsSync75(poolDir)) {
+    mkdirSync40(poolDir, { recursive: true, mode: 493 });
+  }
+  const target = join68(poolDir, name);
+  let targetIsSymlink = false;
+  try {
+    const st = lstatSync8(target);
+    if (st.isSymbolicLink()) {
+      targetIsSymlink = true;
+    }
+  } catch {}
+  if (targetIsSymlink) {
+    fail2(`refusing to overwrite symlink at ${target}; investigate manually`);
+  }
+  const staging = mkdtempSync5(join68(poolDir, `.skill-apply-stage-${name}-`));
+  let oldRename = null;
+  try {
+    for (const [path8, content] of Object.entries(files)) {
+      const full = join68(staging, path8);
+      mkdirSync40(dirname20(full), { recursive: true, mode: 493 });
+      const fd = openSync15(full, "wx");
+      try {
+        writeFileSync34(fd, content);
+      } finally {
+        closeSync15(fd);
+      }
+      if (SH_SCRIPT_RE2.test(path8) || PY_SCRIPT_RE2.test(path8)) {
+        const fs5 = __require("node:fs");
+        fs5.chmodSync(full, 493);
+      }
+    }
+    let targetExists = false;
+    try {
+      lstatSync8(target);
+      targetExists = true;
+    } catch {}
+    if (targetExists) {
+      oldRename = `${target}.skill-apply-old-${Date.now()}`;
+      renameSync16(target, oldRename);
+    }
+    renameSync16(staging, target);
+    if (oldRename) {
+      rmSync16(oldRename, { recursive: true, force: true });
+      oldRename = null;
+    }
+  } catch (err2) {
+    try {
+      rmSync16(staging, { recursive: true, force: true });
+    } catch {}
+    if (oldRename && existsSync75(oldRename)) {
+      try {
+        if (existsSync75(target)) {
+          rmSync16(target, { recursive: true, force: true });
+        }
+        renameSync16(oldRename, target);
+      } catch {}
+    }
+    throw err2;
+  }
+}
+function fail2(msg) {
+  console.error(source_default.red(`error: ${msg}`));
+  process.exit(2);
+}
+function registerSkillCommand(program3) {
+  const skill = program3.commands.find((c) => c.name() === "skill") ?? program3.command("skill").description("Skill pool management.");
+  skill.command("apply <name>").description("Apply (write or update) a skill in the global pool. Reads SKILL.md " + "content from stdin by default, or a file/dir/tarball via --from. " + "Validates against the same gates an agent-proposed publish would " + "(name regex, path allowlist, SKILL.md frontmatter, bundle size, " + "bash -n / py_compile script checks, banned-headless-phrase scan).").option("--from <path>", "Source path. Single .md \u2192 SKILL.md content; directory \u2192 multi-file; " + ".tar / .tar.gz / .tgz \u2192 extracted multi-file. Omit to read SKILL.md " + "from stdin.").option("--dry-run", "Validate + show diff vs current pool content. No writes.", false).action(withConfigError(async (name, opts) => {
+    let files;
+    if (opts.from === undefined) {
+      files = loadFromStdin();
+    } else {
+      const fromPath = resolve44(opts.from);
+      if (!existsSync75(fromPath)) {
+        fail2(`--from path does not exist: ${opts.from}`);
+      }
+      const st = statSync29(fromPath);
+      if (st.isDirectory()) {
+        files = loadFromDir(fromPath);
+      } else if (isTarballPath(fromPath)) {
+        files = loadFromTarball(fromPath);
+      } else if (fromPath.endsWith(".md")) {
+        files = loadSingleFile(fromPath);
+      } else {
+        fail2(`--from must be a directory, a .tar/.tar.gz/.tgz tarball, or a ` + `.md file. Got: ${opts.from}`);
+      }
+    }
+    const v = validatePayload(name, files);
+    if (!v.ok) {
+      console.error(source_default.red("Validation failed:"));
+      for (const e of v.errors) {
+        console.error(source_default.red(`  - ${e}`));
+      }
+      process.exit(3);
+    }
+    const config = loadConfig();
+    const poolDir = resolveSkillsPoolDir2(config.switchroom?.skills_dir);
+    const currentDir = join68(poolDir, name);
+    console.log(source_default.bold(`Skill: ${name}`) + source_default.gray(` (${Object.keys(files).length} files, ${sumBytes(files)} bytes)`));
+    console.log(source_default.bold("Diff vs current pool content:"));
+    console.log(diffSummary(currentDir, files));
+    if (opts.dryRun) {
+      console.log(source_default.gray(`
+(--dry-run; no writes performed)`));
+      return;
+    }
+    writePayload(poolDir, name, files);
+    console.log(source_default.green(`
+\u2713 Wrote ${name} to ${currentDir}`));
+    const applyBin = process.argv[1] ?? "switchroom";
+    console.log(source_default.gray(`Running \`switchroom apply --non-interactive\`...`));
+    const r = spawnSync10(process.argv0, [applyBin, "apply", "--non-interactive"], { stdio: "inherit" });
+    if (r.status !== 0) {
+      console.error(source_default.yellow(`(warning: \`switchroom apply\` exited ${r.status} \u2014 skill is ` + `in the pool but symlinks may not be refreshed. Re-run manually.)`));
+    }
+  }));
+}
+function sumBytes(files) {
+  let n = 0;
+  for (const c of Object.values(files)) {
+    n += Buffer.byteLength(c, "utf-8");
+  }
+  return n;
+}
+
+// src/cli/skill-personal.ts
+import {
+  closeSync as closeSync16,
+  existsSync as existsSync76,
+  lstatSync as lstatSync9,
+  mkdirSync as mkdirSync41,
+  mkdtempSync as mkdtempSync6,
+  openSync as openSync16,
+  readFileSync as readFileSync61,
+  readdirSync as readdirSync30,
+  renameSync as renameSync17,
+  rmSync as rmSync17,
+  statSync as statSync30,
+  utimesSync,
+  writeFileSync as writeFileSync35
+} from "node:fs";
+import { dirname as dirname21, join as join69, relative as relative3, resolve as resolve45 } from "node:path";
+import { homedir as homedir39, tmpdir as tmpdir5 } from "node:os";
+import { spawnSync as spawnSync11 } from "node:child_process";
+init_helpers();
+init_source();
+var PERSONAL_PREFIX = "personal-";
+var TRASH_DIRNAME = "skills-trash";
+var TRASH_TTL_MS = 24 * 60 * 60 * 1000;
+function fail3(msg, exit = 2) {
+  console.error(source_default.red(`error: ${msg}`));
+  process.exit(exit);
+}
+function resolveAgent(opts) {
+  const fromEnv = process.env.SWITCHROOM_AGENT_NAME;
+  const agent = opts.agent ?? fromEnv;
+  if (!agent) {
+    fail3("agent name required: pass --agent <name>, or set SWITCHROOM_AGENT_NAME " + "in the calling environment (set by switchroom for in-container agents).");
+  }
+  if (!SKILL_SLUG_RE.test(agent)) {
+    fail3(`agent name has invalid shape: ${JSON.stringify(agent)}`);
+  }
+  return agent;
+}
+function resolveAgentsRoot(opts) {
+  if (opts.root)
+    return resolve45(opts.root);
+  return join69(homedir39(), ".switchroom", "agents");
+}
+function personalSkillDir(agentsRoot, agent, name) {
+  return join69(agentsRoot, agent, ".claude", "skills", PERSONAL_PREFIX + name);
+}
+function trashDir(agentsRoot, agent) {
+  return join69(agentsRoot, agent, ".claude", TRASH_DIRNAME);
+}
+function readStdinSync2() {
+  const chunks = [];
+  const buf = Buffer.alloc(64 * 1024);
+  while (true) {
+    let n = 0;
+    try {
+      const fs5 = __require("node:fs");
+      n = fs5.readSync(0, buf, 0, buf.length, null);
+    } catch (e) {
+      const err2 = e;
+      if (err2.code === "EAGAIN")
+        continue;
+      break;
+    }
+    if (n <= 0)
+      break;
+    chunks.push(Buffer.from(buf.subarray(0, n)));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function loadFromDir2(dir) {
+  const abs = resolve45(dir);
+  if (!statSync30(abs).isDirectory()) {
+    fail3(`--from path is not a directory: ${dir}`);
+  }
+  const files = {};
+  const walk2 = (sub) => {
+    for (const ent of readdirSync30(sub, { withFileTypes: true })) {
+      const full = join69(sub, ent.name);
+      if (ent.isSymbolicLink()) {
+        fail3(`refusing to read symlink in --from dir: ${relative3(abs, full)}`);
+      }
+      if (ent.isDirectory()) {
+        walk2(full);
+        continue;
+      }
+      if (ent.isFile()) {
+        const rel = relative3(abs, full).replace(/\\/g, "/");
+        files[rel] = readFileSync61(full, "utf-8");
+      }
+    }
+  };
+  walk2(abs);
+  return files;
+}
+function loadFromStdin2() {
+  const raw = readStdinSync2();
+  if (raw.length === 0) {
+    fail3("no content on stdin; pipe a SKILL.md or JSON file-map");
+  }
+  const trimmed = raw.trimStart();
+  if (trimmed.startsWith("{")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err2) {
+      fail3(`stdin starts with '{' but is not valid JSON: ${err2.message}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      fail3("stdin JSON must be an object of {path: content, ...}");
+    }
+    const files = {};
+    for (const [k, v] of Object.entries(parsed)) {
+      if (typeof v !== "string") {
+        fail3(`stdin JSON: value for ${JSON.stringify(k)} must be a string`);
+      }
+      files[k] = v;
+    }
+    return files;
+  }
+  return { "SKILL.md": raw };
+}
+function behavioralValidate(files) {
+  const errors2 = [];
+  for (const [path8, content] of Object.entries(files)) {
+    if (SH_SCRIPT_RE.test(path8)) {
+      const r = spawnSync11("bash", ["-n"], { input: content, encoding: "utf-8" });
+      if (r.status !== 0) {
+        errors2.push(`${path8} fails \`bash -n\`: ${(r.stderr ?? "").trim()}`);
+      }
+    } else if (PY_SCRIPT_RE.test(path8)) {
+      const tmp = mkdtempSync6(join69(tmpdir5(), "skill-personal-py-"));
+      const tmpPy = join69(tmp, "check.py");
+      try {
+        writeFileSync35(tmpPy, content);
+        const r = spawnSync11("python3", ["-m", "py_compile", tmpPy], {
+          encoding: "utf-8"
+        });
+        if (r.status !== 0) {
+          errors2.push(`${path8} fails \`python3 -m py_compile\`: ${(r.stderr ?? "").trim()}`);
+        }
+      } finally {
+        rmSync17(tmp, { recursive: true, force: true });
+      }
+    }
+  }
+  return errors2;
+}
+function sweepTrash(agentsRoot, agent) {
+  const trash = trashDir(agentsRoot, agent);
+  if (!existsSync76(trash))
+    return;
+  const now = Date.now();
+  for (const ent of readdirSync30(trash, { withFileTypes: true })) {
+    if (!ent.isDirectory())
+      continue;
+    const entPath = join69(trash, ent.name);
+    try {
+      const st = statSync30(entPath);
+      if (now - st.mtimeMs > TRASH_TTL_MS) {
+        rmSync17(entPath, { recursive: true, force: true });
+      }
+    } catch {}
+  }
+}
+function writePersonalSkill(targetDir, files) {
+  let targetIsSymlink = false;
+  try {
+    const st = lstatSync9(targetDir);
+    if (st.isSymbolicLink()) {
+      targetIsSymlink = true;
+    }
+  } catch {}
+  if (targetIsSymlink) {
+    fail3(`refusing to overwrite symlink at ${targetDir}; investigate manually`);
+  }
+  mkdirSync41(dirname21(targetDir), { recursive: true, mode: 493 });
+  const staging = mkdtempSync6(join69(dirname21(targetDir), `.skill-personal-stage-`));
+  let oldRename = null;
+  try {
+    for (const [path8, content] of Object.entries(files)) {
+      const full = join69(staging, path8);
+      mkdirSync41(dirname21(full), { recursive: true, mode: 493 });
+      const fd = openSync16(full, "wx");
+      try {
+        writeFileSync35(fd, content);
+      } finally {
+        closeSync16(fd);
+      }
+      if (SH_SCRIPT_RE.test(path8) || PY_SCRIPT_RE.test(path8)) {
+        const fs5 = __require("node:fs");
+        fs5.chmodSync(full, 493);
+      }
+    }
+    let targetExists = false;
+    try {
+      lstatSync9(targetDir);
+      targetExists = true;
+    } catch {}
+    if (targetExists) {
+      oldRename = `${targetDir}.personal-old-${Date.now()}`;
+      renameSync17(targetDir, oldRename);
+    }
+    renameSync17(staging, targetDir);
+    if (oldRename) {
+      rmSync17(oldRename, { recursive: true, force: true });
+      oldRename = null;
+    }
+  } catch (err2) {
+    try {
+      rmSync17(staging, { recursive: true, force: true });
+    } catch {}
+    if (oldRename && existsSync76(oldRename)) {
+      try {
+        if (existsSync76(targetDir)) {
+          rmSync17(targetDir, { recursive: true, force: true });
+        }
+        renameSync17(oldRename, targetDir);
+      } catch {}
+    }
+    throw err2;
+  }
+}
+function loadValidateWrite(agentsRoot, agent, name, files, ensureNew) {
+  sweepTrash(agentsRoot, agent);
+  if (!SKILL_SLUG_RE.test(name)) {
+    fail3(`skill name must match ${SKILL_SLUG_RE.source}: got ${JSON.stringify(name)}`);
+  }
+  const target = personalSkillDir(agentsRoot, agent, name);
+  const exists = (() => {
+    try {
+      lstatSync9(target);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (ensureNew && exists) {
+    fail3(`personal skill ${JSON.stringify(name)} already exists for agent ${JSON.stringify(agent)}. ` + `Use \`skill edit-personal\` to overwrite, or \`skill remove-personal\` first.`, 9);
+  }
+  if (!ensureNew && !exists) {
+    fail3(`personal skill ${JSON.stringify(name)} does not exist for agent ${JSON.stringify(agent)}. ` + `Use \`skill init-personal\` to create it.`, 9);
+  }
+  const v = validateSkillBundle(name, files);
+  if (!v.ok) {
+    console.error(source_default.red("Validation failed:"));
+    for (const e of v.errors) {
+      console.error(source_default.red(`  - ${e}`));
+    }
+    process.exit(3);
+  }
+  const behavioral = behavioralValidate(files);
+  if (behavioral.length > 0) {
+    console.error(source_default.red("Behavioural validation failed:"));
+    for (const e of behavioral) {
+      console.error(source_default.red(`  - ${e}`));
+    }
+    process.exit(3);
+  }
+  writePersonalSkill(target, files);
+  console.log(JSON.stringify({
+    ok: true,
+    action: ensureNew ? "init" : "edit",
+    agent,
+    name,
+    path: target,
+    files: Object.keys(files).length
+  }));
+}
+function loadFiles(opts) {
+  if (opts.from === undefined) {
+    return loadFromStdin2();
+  }
+  const p = resolve45(opts.from);
+  if (!existsSync76(p)) {
+    fail3(`--from path does not exist: ${opts.from}`);
+  }
+  const st = statSync30(p);
+  if (st.isDirectory()) {
+    return loadFromDir2(p);
+  }
+  if (p.endsWith(".md")) {
+    return { "SKILL.md": readFileSync61(p, "utf-8") };
+  }
+  fail3(`--from must be a directory or a .md file. Got: ${opts.from}`);
+}
+function initPersonalAction(name, opts) {
+  const agent = resolveAgent(opts);
+  const agentsRoot = resolveAgentsRoot(opts);
+  const files = loadFiles(opts);
+  loadValidateWrite(agentsRoot, agent, name, files, true);
+}
+function editPersonalAction(name, opts) {
+  const agent = resolveAgent(opts);
+  const agentsRoot = resolveAgentsRoot(opts);
+  const files = loadFiles(opts);
+  loadValidateWrite(agentsRoot, agent, name, files, false);
+}
+function removePersonalAction(name, opts) {
+  const agent = resolveAgent(opts);
+  const agentsRoot = resolveAgentsRoot(opts);
+  sweepTrash(agentsRoot, agent);
+  if (!SKILL_SLUG_RE.test(name)) {
+    fail3(`skill name must match ${SKILL_SLUG_RE.source}: got ${JSON.stringify(name)}`);
+  }
+  const target = personalSkillDir(agentsRoot, agent, name);
+  try {
+    const st = lstatSync9(target);
+    if (st.isSymbolicLink()) {
+      fail3(`refusing to remove symlink at ${target}; investigate manually`);
+    }
+  } catch (err2) {
+    const e = err2;
+    if (e.code === "ENOENT") {
+      fail3(`personal skill ${JSON.stringify(name)} does not exist for agent ${JSON.stringify(agent)}`, 1);
+    }
+    throw err2;
+  }
+  const trashRoot = trashDir(agentsRoot, agent);
+  mkdirSync41(trashRoot, { recursive: true, mode: 493 });
+  const ts = Date.now();
+  const trashTarget = join69(trashRoot, `${name}-${ts}`);
+  renameSync17(target, trashTarget);
+  const now = new Date(ts);
+  utimesSync(trashTarget, now, now);
+  console.log(JSON.stringify({
+    ok: true,
+    action: "remove",
+    agent,
+    name,
+    trash_path: trashTarget,
+    recoverable_until: new Date(ts + TRASH_TTL_MS).toISOString()
+  }));
+}
+function listPersonalAction(opts) {
+  const agent = resolveAgent(opts);
+  const agentsRoot = resolveAgentsRoot(opts);
+  sweepTrash(agentsRoot, agent);
+  const skillsDir = join69(agentsRoot, agent, ".claude", "skills");
+  const personal = [];
+  if (existsSync76(skillsDir)) {
+    for (const ent of readdirSync30(skillsDir, { withFileTypes: true })) {
+      if (!ent.isDirectory())
+        continue;
+      if (!ent.name.startsWith(PERSONAL_PREFIX))
+        continue;
+      const skillName = ent.name.slice(PERSONAL_PREFIX.length);
+      const skillPath = join69(skillsDir, ent.name);
+      let fileCount = 0;
+      let totalBytes = 0;
+      const walk2 = (sub) => {
+        for (const e of readdirSync30(sub, { withFileTypes: true })) {
+          if (e.isFile()) {
+            fileCount += 1;
+            try {
+              totalBytes += statSync30(join69(sub, e.name)).size;
+            } catch {}
+          } else if (e.isDirectory()) {
+            walk2(join69(sub, e.name));
+          }
+        }
+      };
+      try {
+        walk2(skillPath);
+      } catch {}
+      personal.push({
+        name: skillName,
+        path: skillPath,
+        files: fileCount,
+        size_bytes: totalBytes
+      });
+    }
+  }
+  console.log(JSON.stringify({ ok: true, agent, personal }, null, 2));
+}
+function registerSkillPersonalCommands(program3) {
+  const parent = program3.commands.find((c) => c.name() === "skill") ?? program3.command("skill").description("Skill pool management.");
+  parent.command("init-personal <name>").description("Create a personal skill in this agent's writable workspace " + "(<agentDir>/.claude/skills/personal-<name>/). Reads SKILL.md from " + "stdin, or multi-file JSON {path: content} from stdin, or a single " + "SKILL.md file via --from, or a directory via --from. No operator " + "approval \u2014 agent's own workspace.").option("--agent <name>", "Agent name (defaults to $SWITCHROOM_AGENT_NAME)").option("--from <path>", "Source path: .md file or directory").option("--root <path>", "Test-only override for agents-root dir").action(withConfigError(async (name, opts) => {
+    initPersonalAction(name, opts);
+  }));
+  parent.command("edit-personal <name>").description("Overwrite an existing personal skill. Same input modes as " + "init-personal. Fails if the skill doesn't already exist.").option("--agent <name>", "Agent name (defaults to $SWITCHROOM_AGENT_NAME)").option("--from <path>", "Source path: .md file or directory").option("--root <path>", "Test-only override for agents-root dir").action(withConfigError(async (name, opts) => {
+    editPersonalAction(name, opts);
+  }));
+  parent.command("remove-personal <name>").description("Soft-remove a personal skill. Moves the dir to " + "<agentDir>/.claude/skills-trash/<name>-<unix-ts>/ for 24h " + "recoverability. Lazy sweep on next op deletes entries older " + "than 24h.").option("--agent <name>", "Agent name (defaults to $SWITCHROOM_AGENT_NAME)").option("--root <path>", "Test-only override for agents-root dir").action(withConfigError(async (name, opts) => {
+    removePersonalAction(name, opts);
+  }));
+  parent.command("list-personal").description("List personal skills owned by this agent. JSON output by default.").option("--agent <name>", "Agent name (defaults to $SWITCHROOM_AGENT_NAME)").option("--root <path>", "Test-only override for agents-root dir").action(withConfigError(async (opts) => {
+    listPersonalAction(opts);
+  }));
+}
+
+// src/cli/skill-search.ts
+init_helpers();
+var import_yaml18 = __toESM(require_dist(), 1);
+import { existsSync as existsSync77, readdirSync as readdirSync31, readFileSync as readFileSync62, statSync as statSync31 } from "node:fs";
+import { homedir as homedir40 } from "node:os";
+import { join as join70, resolve as resolve46 } from "node:path";
+var PERSONAL_PREFIX2 = "personal-";
+var BUNDLED_SUBDIR = "_bundled";
+var AGENT_NAME_RE3 = /^[a-z][a-z0-9_-]{0,62}$/;
+function defaultAgentsRoot() {
+  return resolve46(homedir40(), ".switchroom/agents");
+}
+function defaultSharedRoot() {
+  return resolve46(homedir40(), ".switchroom/skills");
+}
+function defaultBundledRoot() {
+  return resolve46(homedir40(), ".switchroom/skills/_bundled");
+}
+function readSkillFrontmatter(skillDir) {
+  const mdPath = join70(skillDir, "SKILL.md");
+  if (!existsSync77(mdPath))
+    return null;
+  let content;
+  try {
+    content = readFileSync62(mdPath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!content.startsWith(`---
+`) && !content.startsWith(`---\r
+`)) {
+    return { error: "no leading `---` frontmatter delimiter" };
+  }
+  const rest = content.slice(content.indexOf(`
+`) + 1);
+  const endIdx = rest.indexOf(`
+---`);
+  if (endIdx < 0)
+    return { error: "no closing `---` delimiter" };
+  const fmText = rest.slice(0, endIdx);
+  let parsed;
+  try {
+    parsed = import_yaml18.parse(fmText);
+  } catch (e) {
+    return { error: `yaml parse: ${e.message}` };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { error: "frontmatter is not a mapping" };
+  }
+  return { fm: parsed };
+}
+function statSkillMd(skillDir) {
+  const mdPath = join70(skillDir, "SKILL.md");
+  try {
+    const st = statSync31(mdPath);
+    return { size: st.size, mtime: st.mtime.toISOString() };
+  } catch {
+    return null;
+  }
+}
+function listPersonalSkills(agent, agentsRoot = defaultAgentsRoot()) {
+  if (!AGENT_NAME_RE3.test(agent))
+    return [];
+  const skillsDir = join70(agentsRoot, agent, ".claude/skills");
+  if (!existsSync77(skillsDir))
+    return [];
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync31(skillsDir);
+  } catch {
+    return [];
+  }
+  for (const ent of entries) {
+    if (!ent.startsWith(PERSONAL_PREFIX2))
+      continue;
+    const dirPath = join70(skillsDir, ent);
+    try {
+      if (!statSync31(dirPath).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const name = ent.slice(PERSONAL_PREFIX2.length);
+    const fmr = readSkillFrontmatter(dirPath);
+    const stat3 = statSkillMd(dirPath);
+    if (!stat3)
+      continue;
+    out.push({
+      name,
+      tier: "personal",
+      path: dirPath,
+      size: stat3.size,
+      mtime: stat3.mtime,
+      frontmatter: fmr?.fm ?? {},
+      error: fmr?.error,
+      agent
+    });
+  }
+  return out;
+}
+function listSharedSkills(sharedRoot = defaultSharedRoot()) {
+  if (!existsSync77(sharedRoot))
+    return [];
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync31(sharedRoot);
+  } catch {
+    return [];
+  }
+  for (const ent of entries) {
+    if (ent === BUNDLED_SUBDIR)
+      continue;
+    if (ent.startsWith("."))
+      continue;
+    const dirPath = join70(sharedRoot, ent);
+    try {
+      if (!statSync31(dirPath).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const fmr = readSkillFrontmatter(dirPath);
+    const stat3 = statSkillMd(dirPath);
+    if (!stat3)
+      continue;
+    out.push({
+      name: ent,
+      tier: "shared",
+      path: dirPath,
+      size: stat3.size,
+      mtime: stat3.mtime,
+      frontmatter: fmr?.fm ?? {},
+      error: fmr?.error
+    });
+  }
+  return out;
+}
+function listBundledSkills(bundledRoot = defaultBundledRoot()) {
+  if (!existsSync77(bundledRoot))
+    return [];
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync31(bundledRoot);
+  } catch {
+    return [];
+  }
+  for (const ent of entries) {
+    if (ent.startsWith("."))
+      continue;
+    const dirPath = join70(bundledRoot, ent);
+    try {
+      if (!statSync31(dirPath).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const fmr = readSkillFrontmatter(dirPath);
+    const stat3 = statSkillMd(dirPath);
+    if (!stat3)
+      continue;
+    out.push({
+      name: ent,
+      tier: "bundled",
+      path: dirPath,
+      size: stat3.size,
+      mtime: stat3.mtime,
+      frontmatter: fmr?.fm ?? {},
+      error: fmr?.error
+    });
+  }
+  return out;
+}
+function matchesQuery(entry, q) {
+  const needle = q.toLowerCase();
+  if (entry.name.toLowerCase().includes(needle))
+    return true;
+  const desc = entry.frontmatter["description"];
+  if (typeof desc === "string" && desc.toLowerCase().includes(needle)) {
+    return true;
+  }
+  const jtbd = entry.frontmatter["jtbd"];
+  if (typeof jtbd === "string" && jtbd.toLowerCase().includes(needle)) {
+    return true;
+  }
+  return false;
+}
+function searchSkills(opts) {
+  const tier = opts.tier ?? "any";
+  const wanted = tier === "any" ? ["personal", "shared", "bundled"] : [tier];
+  let results = [];
+  if (wanted.includes("personal")) {
+    if (opts.agent) {
+      results.push(...listPersonalSkills(opts.agent, opts.agentsRoot));
+    }
+  }
+  if (wanted.includes("shared")) {
+    results.push(...listSharedSkills(opts.sharedRoot));
+  }
+  if (wanted.includes("bundled")) {
+    results.push(...listBundledSkills(opts.bundledRoot));
+  }
+  if (opts.query && opts.query.length > 0) {
+    results = results.filter((e) => matchesQuery(e, opts.query));
+  }
+  const tierOrder = {
+    personal: 0,
+    shared: 1,
+    bundled: 2
+  };
+  results.sort((a, b) => {
+    const t = tierOrder[a.tier] - tierOrder[b.tier];
+    if (t !== 0)
+      return t;
+    return a.name.localeCompare(b.name);
+  });
+  const limit = Math.max(1, Math.min(opts.limit ?? 50, 500));
+  return results.slice(0, limit);
+}
+function searchAction(opts) {
+  let tier = "any";
+  if (opts.tier) {
+    if (opts.tier !== "personal" && opts.tier !== "shared" && opts.tier !== "bundled" && opts.tier !== "any") {
+      process.stderr.write(`error: --tier must be one of personal|shared|bundled|any (got ${opts.tier})
+`);
+      process.exit(2);
+    }
+    tier = opts.tier;
+  }
+  let limit;
+  if (opts.limit !== undefined) {
+    const n = Number(opts.limit);
+    if (!Number.isFinite(n) || n < 1) {
+      process.stderr.write(`error: --limit must be a positive integer
+`);
+      process.exit(2);
+    }
+    limit = Math.floor(n);
+  }
+  const results = searchSkills({
+    agent: opts.agent,
+    query: opts.query,
+    tier,
+    limit,
+    agentsRoot: opts.root,
+    sharedRoot: opts.sharedRoot,
+    bundledRoot: opts.bundledRoot
+  });
+  if (opts.json !== false) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  if (results.length === 0) {
+    console.log("(no skills matched)");
+    return;
+  }
+  for (const r of results) {
+    const desc = typeof r.frontmatter["description"] === "string" ? r.frontmatter["description"].slice(0, 80) : r.error ? `<broken: ${r.error}>` : "";
+    const where = r.agent ? `${r.tier}/${r.agent}` : r.tier;
+    console.log(`${r.name.padEnd(40)} ${where.padEnd(16)} ${desc}`);
+  }
+}
+function registerSkillSearchCommand(program3) {
+  let skill = program3.commands.find((c) => c.name() === "skill");
+  if (!skill) {
+    skill = program3.command("skill").description("Manage switchroom skills.");
+  }
+  skill.command("search").description("Enumerate skills across personal (per-agent), shared (operator pool), " + "and bundled (shipped) tiers. Read-only. Returns JSON by default " + "(stable shape for MCP callers); use --no-json for a human table.").option("-a, --agent <name>", "Caller agent (required for personal tier).").option("-q, --query <text>", "Case-insensitive substring match against name, description, jtbd.").option("-t, --tier <tier>", "Filter to one tier: personal | shared | bundled | any (default any).").option("-l, --limit <n>", "Cap result count (default 50, max 500).").option("--no-json", "Render as human table instead of JSON.").addOption(new Option("--root <path>").hideHelp()).addOption(new Option("--shared-root <path>").hideHelp()).addOption(new Option("--bundled-root <path>").hideHelp()).action(withConfigError(async (opts) => {
+    searchAction(opts);
+  }));
+}
+
 // src/cli/mcp-agent-config.ts
 function registerAgentConfigMcpCommand(program3) {
   const mcp = program3.commands.find((c) => c.name() === "mcp") ?? program3.command("mcp").description("MCP server entry points");
@@ -76908,10 +78264,10 @@ function registerHostdMcpCommand(program3) {
 // src/cli/hostd.ts
 init_source();
 init_helpers();
-import { existsSync as existsSync76, mkdirSync as mkdirSync40, readdirSync as readdirSync29, readFileSync as readFileSync61, writeFileSync as writeFileSync34, statSync as statSync29, copyFileSync as copyFileSync12 } from "node:fs";
-import { homedir as homedir38 } from "node:os";
-import { join as join68 } from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { existsSync as existsSync79, mkdirSync as mkdirSync42, readdirSync as readdirSync32, readFileSync as readFileSync64, writeFileSync as writeFileSync36, statSync as statSync32, copyFileSync as copyFileSync12 } from "node:fs";
+import { homedir as homedir41 } from "node:os";
+import { join as join71 } from "node:path";
+import { spawnSync as spawnSync13 } from "node:child_process";
 init_audit_reader();
 var DEFAULT_IMAGE_TAG = "latest";
 var HOSTD_COMPOSE_PROJECT = "switchroom-hostd";
@@ -77001,14 +78357,14 @@ networks:
 `;
 }
 function hostdDir() {
-  return join68(homedir38(), ".switchroom", "hostd");
+  return join71(homedir41(), ".switchroom", "hostd");
 }
 function hostdComposePath() {
-  return join68(hostdDir(), "docker-compose.yml");
+  return join71(hostdDir(), "docker-compose.yml");
 }
 function backupExistingCompose() {
   const p = hostdComposePath();
-  if (!existsSync76(p))
+  if (!existsSync79(p))
     return null;
   const ts = new Date().toISOString().replace(/[:.]/g, "-");
   const bak = `${p}.bak-${ts}`;
@@ -77016,7 +78372,7 @@ function backupExistingCompose() {
   return bak;
 }
 function runDocker(args) {
-  const r = spawnSync11("docker", args, { encoding: "utf8" });
+  const r = spawnSync13("docker", args, { encoding: "utf8" });
   return {
     ok: r.status === 0,
     stdout: r.stdout ?? "",
@@ -77041,9 +78397,9 @@ async function doInstall(opts, program3) {
   }
   const dir = hostdDir();
   const composePath = hostdComposePath();
-  mkdirSync40(dir, { recursive: true });
+  mkdirSync42(dir, { recursive: true });
   const yaml = renderHostdComposeFile({
-    hostHome: homedir38(),
+    hostHome: homedir41(),
     imageTag: opts.tag ?? DEFAULT_IMAGE_TAG,
     operatorUid: resolveOperatorUid()
   });
@@ -77056,7 +78412,7 @@ async function doInstall(opts, program3) {
   const bak = backupExistingCompose();
   if (bak)
     console.log(source_default.dim(`  Backed up existing compose to ${bak}`));
-  writeFileSync34(composePath, yaml, "utf8");
+  writeFileSync36(composePath, yaml, "utf8");
   console.log(source_default.green(`  \u2713 Wrote ${composePath}`));
   console.log(source_default.dim(`    admin agents: ${adminAgents.length === 0 ? "(none)" : adminAgents.join(", ")}`));
   console.log(source_default.dim(`    Pulling ghcr.io/switchroom/switchroom-hostd:${opts.tag ?? DEFAULT_IMAGE_TAG}\u2026`));
@@ -77085,7 +78441,7 @@ function doStatus() {
   const composeYml = hostdComposePath();
   console.log(source_default.bold("switchroom-hostd"));
   console.log("");
-  if (!existsSync76(composeYml)) {
+  if (!existsSync79(composeYml)) {
     console.log(source_default.yellow("  compose:    not installed"));
     console.log(source_default.dim("              run `switchroom hostd install` to set up."));
     return;
@@ -77106,15 +78462,15 @@ function doStatus() {
   } else {
     console.log(source_default.green(`  container:  ${ps.stdout.trim()}`));
   }
-  if (existsSync76(dir)) {
+  if (existsSync79(dir)) {
     const entries = [];
     try {
-      for (const name of readdirSync29(dir)) {
+      for (const name of readdirSync32(dir)) {
         if (name === "docker-compose.yml" || name.startsWith("docker-compose.yml."))
           continue;
-        const sockPath = join68(dir, name, "sock");
-        if (existsSync76(sockPath)) {
-          const st = statSync29(sockPath);
+        const sockPath = join71(dir, name, "sock");
+        if (existsSync79(sockPath)) {
+          const st = statSync32(sockPath);
           if ((st.mode & 61440) === 49152) {
             entries.push(`${name} \u2192 ${sockPath}`);
           }
@@ -77132,7 +78488,7 @@ function doStatus() {
 }
 function doUninstall() {
   const composeYml = hostdComposePath();
-  if (!existsSync76(composeYml)) {
+  if (!existsSync79(composeYml)) {
     console.log(source_default.yellow("  No hostd install detected (no compose file at this path)."));
     return;
   }
@@ -77156,12 +78512,12 @@ function registerHostdCommand(program3) {
   hostd.command("uninstall").description("Stop the hostd container. Leaves the compose file in place for re-install.").action(() => doUninstall());
   hostd.command("audit").description("Tail and filter the hostd audit log (privileged-verb call history)").option("--tail <n>", "Number of matching entries to show (default: 50)", "50").option("--agent <name>", "Filter to a specific caller agent").option("--op <verb>", "Filter to a specific hostd verb (e.g. update_apply, agent_restart)").option("--error", "Show only failed (error/denied) entries").option("--verbose", "Show the captured stderr / error tail under each failed row").option("--path <file>", "Override audit log path (for debugging)").action((opts) => {
     const logPath = opts.path ?? defaultAuditLogPath2();
-    if (!existsSync76(logPath)) {
+    if (!existsSync79(logPath)) {
       console.error(source_default.yellow(`Audit log not found at ${logPath}.`) + source_default.gray(`
 The log is created when hostd handles its first privileged-verb request.`));
       return;
     }
-    const raw = readFileSync61(logPath, "utf-8");
+    const raw = readFileSync64(logPath, "utf-8");
     const limit = Math.max(1, parseInt(opts.tail ?? "50", 10) || 50);
     const filters = {
       agent: opts.agent,
@@ -77238,6 +78594,9 @@ registerStatusAskCommand(program3);
 registerAgentConfigCommands(program3);
 registerAgentConfigWriteCommands(program3);
 registerAgentConfigSkillWriteCommands(program3);
+registerSkillCommand(program3);
+registerSkillPersonalCommands(program3);
+registerSkillSearchCommand(program3);
 registerAgentConfigMcpCommand(program3);
 registerHostdMcpCommand(program3);
 registerHostdCommand(program3);