yourskills 0.1.0

package/dist/main.js

@@ -0,0 +1,4313 @@
+#!/usr/bin/env node
+
+// src/main.tsx
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { render } from "ink";
+
+// src/auth/auth.ts
+import { setTimeout as sleep } from "node:timers/promises";
+
+// src/settings/store.ts
+import { chmodSync, mkdirSync, rmSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_URL = "http://localhost:3000";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return join(xdg && xdg.length > 0 ? xdg : join(homedir(), ".config"), "yourskills");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+async function readConfig() {
+  try {
+    return JSON.parse(await readFile(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  await writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+`);
+  chmodSync(configPath(), 384);
+}
+function clearConfig() {
+  rmSync(configPath(), { force: true });
+}
+function serverUrl(config = {}, override) {
+  return override || process.env.YOURSKILLS_URL || config.serverUrl || DEFAULT_URL;
+}
+
+// src/settings/agents.ts
+async function resolveAgents(flagAgents) {
+  if (flagAgents && flagAgents.length > 0)
+    return flagAgents;
+  const config = await readConfig();
+  return config.agents ?? [];
+}
+// src/settings/keys.ts
+var CONFIG_KEYS = ["scope", "agents", "server", "track"];
+function isConfigKey(key) {
+  return CONFIG_KEYS.includes(key);
+}
+var REDACTED = "<redacted>";
+var UNSET = "(unset)";
+function configValue(config, key) {
+  switch (key) {
+    case "scope":
+      return config.defaultScope ?? UNSET;
+    case "agents":
+      return config.agents?.length ? config.agents.join(",") : UNSET;
+    case "server":
+      return config.serverUrl ?? UNSET;
+    case "track":
+      return config.track === undefined ? UNSET : String(config.track);
+  }
+}
+function setConfigValue(config, key, value) {
+  if (!isConfigKey(key)) {
+    return {
+      ok: false,
+      message: `Unknown config key: ${key}. Known keys: ${CONFIG_KEYS.join(", ")}.`
+    };
+  }
+  switch (key) {
+    case "scope": {
+      if (value !== "global" && value !== "project") {
+        return {
+          ok: false,
+          message: "scope must be `global` or `project`."
+        };
+      }
+      return {
+        ok: true,
+        config: { ...config, defaultScope: value },
+        shown: value
+      };
+    }
+    case "agents": {
+      const agents = value.split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+      if (agents.length === 0) {
+        return {
+          ok: false,
+          message: "agents must be a comma separated list, for example `claude-code,codex`."
+        };
+      }
+      return {
+        ok: true,
+        config: { ...config, agents },
+        shown: agents.join(",")
+      };
+    }
+    case "server": {
+      let url;
+      try {
+        url = new URL(value);
+      } catch {
+        return {
+          ok: false,
+          message: `server must be a URL, for example \`https://skills.acme.dev\`. Got: ${value}`
+        };
+      }
+      if (url.protocol !== "http:" && url.protocol !== "https:") {
+        return { ok: false, message: "server must be an http or https URL." };
+      }
+      const serverUrl2 = url.toString().replace(/\/$/, "");
+      return { ok: true, config: { ...config, serverUrl: serverUrl2 }, shown: serverUrl2 };
+    }
+    case "track": {
+      if (value !== "true" && value !== "false") {
+        return { ok: false, message: "track must be `true` or `false`." };
+      }
+      const track = value === "true";
+      return { ok: true, config: { ...config, track }, shown: String(track) };
+    }
+  }
+}
+function configLines(config) {
+  const width = Math.max(...CONFIG_KEYS.map((k) => k.length), "user".length);
+  const lines = CONFIG_KEYS.map((key) => ({
+    mark: "none",
+    text: `${key.padEnd(width)}  ${configValue(config, key)}`
+  }));
+  lines.push({
+    mark: "none",
+    text: `${"user".padEnd(width)}  ${config.userEmail ?? UNSET}`
+  });
+  lines.push({
+    mark: "none",
+    text: `${"token".padEnd(width)}  ${config.token ? REDACTED : UNSET}`
+  });
+  return lines;
+}
+function configGetReport(config, key, path) {
+  if (key === undefined) {
+    return {
+      title: "config",
+      lines: configLines(config),
+      json: {
+        path,
+        ...Object.fromEntries(CONFIG_KEYS.map((k) => [k, configValue(config, k)])),
+        user: config.userEmail ?? null,
+        token: config.token ? REDACTED : null
+      }
+    };
+  }
+  if (!isConfigKey(key)) {
+    return {
+      title: "config",
+      lines: [
+        {
+          mark: "fail",
+          text: `Unknown config key: ${key}`,
+          note: `Known keys: ${CONFIG_KEYS.join(", ")}`
+        }
+      ],
+      json: { path, error: `unknown key: ${key}`, keys: CONFIG_KEYS },
+      failed: true
+    };
+  }
+  const value = configValue(config, key);
+  return {
+    title: "config",
+    lines: [{ mark: "none", text: value }],
+    json: { path, key, value }
+  };
+}
+
+// src/settings/command.ts
+async function configGet(key) {
+  return configGetReport(await readConfig(), key, configPath());
+}
+async function configSet(key, value) {
+  const path = configPath();
+  const config = await readConfig();
+  const result = setConfigValue(config, key, value);
+  if (!result.ok) {
+    return {
+      title: "config",
+      lines: [{ mark: "fail", text: result.message }],
+      json: { path, error: result.message },
+      failed: true
+    };
+  }
+  await writeConfig(result.config);
+  return {
+    title: "config",
+    lines: [{ mark: "ok", text: `${key} = ${result.shown}`, note: path }],
+    json: { path, key, value: result.shown }
+  };
+}
+// src/settings/scope.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { dirname, join as join2, resolve } from "node:path";
+var PROJECT_MANIFEST = "yourskills.json";
+function findProjectManifest(from) {
+  let dir = resolve(from ?? process.cwd());
+  for (;; ) {
+    const candidate = join2(dir, PROJECT_MANIFEST);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+async function scopeInManifest(path) {
+  try {
+    const parsed = JSON.parse(await readFile2(path, "utf8"));
+    return parsed.scope === "global" || parsed.scope === "project" ? parsed.scope : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveScope(opts = {}) {
+  const manifestPath = findProjectManifest(opts.cwd);
+  if (opts.flag)
+    return { scope: opts.flag, source: "flag", manifestPath };
+  if (manifestPath) {
+    const declared = await scopeInManifest(manifestPath);
+    if (declared)
+      return { scope: declared, source: "project", manifestPath };
+  }
+  const config = await readConfig();
+  if (config.defaultScope)
+    return { scope: config.defaultScope, source: "config", manifestPath };
+  return { scope: "global", source: "default", manifestPath };
+}
+// src/auth/auth.ts
+var CLIENT_ID = "yourskills-cli";
+var GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var SLOW_DOWN_STEP_MS = 5000;
+var authBase = (base) => `${base.replace(/\/$/, "")}/api/auth`;
+async function post(url, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {
+      error: "invalid_response",
+      error_description: text.slice(0, 200) || res.statusText
+    };
+  }
+  if (res.ok)
+    return { ok: true, data: parsed };
+  const err = parsed;
+  return {
+    error: err.error ?? `http_${res.status}`,
+    error_description: err.error_description
+  };
+}
+async function* login() {
+  const config = await readConfig();
+  const base = serverUrl(config);
+  const start = await post(`${authBase(base)}/device/code`, {
+    client_id: CLIENT_ID
+  });
+  if (!("ok" in start)) {
+    throw new Error(`Could not start device login: ${start.error_description ?? start.error}`);
+  }
+  const device = start.data;
+  const deadline = Date.now() + device.expires_in * 1000;
+  yield {
+    kind: "prompt",
+    userCode: device.user_code,
+    verificationUri: device.verification_uri_complete ?? device.verification_uri,
+    expiresAt: deadline
+  };
+  let intervalMs = Math.max(device.interval, 1) * 1000;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    const poll = await post(`${authBase(base)}/device/token`, {
+      grant_type: GRANT_TYPE,
+      device_code: device.device_code,
+      client_id: CLIENT_ID
+    });
+    if ("ok" in poll) {
+      const token = poll.data.access_token;
+      const who = await fetchSession(base, token);
+      await writeConfig({
+        ...config,
+        token,
+        serverUrl: base,
+        userEmail: who?.user?.email
+      });
+      yield { kind: "done", email: who?.user?.email };
+      return;
+    }
+    switch (poll.error) {
+      case "authorization_pending":
+        yield { kind: "waiting" };
+        break;
+      case "slow_down":
+        intervalMs += SLOW_DOWN_STEP_MS;
+        yield { kind: "waiting" };
+        break;
+      case "access_denied":
+        throw new Error("Login was denied.");
+      case "expired_token":
+        throw new Error("The device code expired. Run `yourskills login` again.");
+      default:
+        throw new Error(`Login failed: ${poll.error_description ?? poll.error}`);
+    }
+  }
+  throw new Error("The device code expired. Run `yourskills login` again.");
+}
+async function logout() {
+  const config = await readConfig();
+  if (config.token) {
+    await fetch(`${authBase(serverUrl(config))}/sign-out`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${config.token}` }
+    }).catch(() => {
+      return;
+    });
+  }
+  clearConfig();
+}
+async function fetchSession(base, token) {
+  const res = await fetch(`${authBase(base)}/get-session`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (!res.ok)
+    return null;
+  return await res.json();
+}
+async function whoami(server) {
+  const config = await readConfig();
+  if (!config.token)
+    throw new Error("Not logged in. Run `yourskills login`.");
+  const base = serverUrl(config, server);
+  const session = await fetchSession(base, config.token);
+  if (!session?.user)
+    throw new Error("Session is no longer valid. Run `yourskills login`.");
+  return {
+    user: session.user.email ?? session.user.id,
+    org: session.session?.activeOrganizationId ?? null,
+    server: base
+  };
+}
+async function requireToken(server) {
+  const config = await readConfig();
+  if (!config.token)
+    throw new Error("Not logged in. Run `yourskills login`.");
+  return { token: config.token, base: serverUrl(config, server) };
+}
+async function hasSession() {
+  return Boolean((await readConfig()).token);
+}
+// src/auth/screens/gate.tsx
+import { Box as Box5, Text as Text7, useApp as useApp2, useInput } from "ink";
+import {
+  useCallback,
+  useEffect as useEffect3,
+  useMemo,
+  useState as useState3
+} from "react";
+
+// src/ui/command.tsx
+import { Box as Box2, Text as Text3 } from "ink";
+
+// ../../packages/ui/src/lib/ascii.ts
+var DEFAULT_ASCII_CHARS = {
+  top: "-",
+  bottom: "-",
+  left: "|",
+  right: "|",
+  divider: "-",
+  junction: "+"
+};
+function fill(n, seq = "-") {
+  const count = Math.max(n, 0);
+  if (count === 0) {
+    return "";
+  }
+  const unit = seq.length > 0 ? seq : " ";
+  return unit.repeat(Math.ceil(count / unit.length)).slice(0, count);
+}
+function junctionGlyph(chars) {
+  return chars.junction.length > 0 ? chars.junction[0] : DEFAULT_ASCII_CHARS.junction;
+}
+function topBorder(width, title, chars = DEFAULT_ASCII_CHARS) {
+  const j = junctionGlyph(chars);
+  if (!title) {
+    return `${j}${fill(width - 2, chars.top)}${j}`;
+  }
+  const label = ` ${title} `;
+  const left = 2;
+  const right = Math.max(width - 2 - left - label.length, 1);
+  return `${j}${fill(left, chars.top)}${label}${fill(right, chars.top)}${j}`;
+}
+
+// src/ui/frame.tsx
+import { Box, Text, useWindowSize } from "ink";
+
+// src/ui/theme.ts
+var tone = {
+  primary: "cyan",
+  notice: "yellow",
+  danger: "red"
+};
+var stateTone = {
+  "state-active": undefined,
+  "state-experimental": "yellow",
+  "state-deprecated": "red"
+};
+var mark = {
+  ok: "+",
+  fail: "x",
+  pending: ".",
+  cursor: ">",
+  selected: "*",
+  unselected: " "
+};
+
+// src/ui/frame.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var MAX_WIDTH = 96;
+var MIN_WIDTH = 44;
+var FRAME_CHROME = 4;
+function useFrameWidth() {
+  const { columns } = useWindowSize();
+  return Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, columns - 2));
+}
+var j = DEFAULT_ASCII_CHARS.junction;
+var BORDER = {
+  topLeft: j,
+  top: DEFAULT_ASCII_CHARS.top,
+  topRight: j,
+  right: DEFAULT_ASCII_CHARS.right,
+  bottomRight: j,
+  bottom: DEFAULT_ASCII_CHARS.bottom,
+  bottomLeft: j,
+  left: DEFAULT_ASCII_CHARS.left
+};
+function Frame({
+  title,
+  width,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(Box, {
+    flexDirection: "column",
+    width,
+    children: [
+      /* @__PURE__ */ jsx(Text, {
+        color: tone.primary,
+        children: topBorder(width, title)
+      }),
+      /* @__PURE__ */ jsx(Box, {
+        flexDirection: "column",
+        width,
+        paddingLeft: 1,
+        paddingRight: 1,
+        borderStyle: BORDER,
+        borderColor: tone.primary,
+        borderTop: false,
+        children
+      })
+    ]
+  });
+}
+function Divider({ width }) {
+  return /* @__PURE__ */ jsx(Box, {
+    marginLeft: -1,
+    marginRight: -1,
+    children: /* @__PURE__ */ jsx(Text, {
+      color: tone.primary,
+      children: fill(width - 2, DEFAULT_ASCII_CHARS.divider)
+    })
+  });
+}
+function Blank() {
+  return /* @__PURE__ */ jsx(Text, {
+    children: " "
+  });
+}
+function clip(text, width) {
+  if (width <= 0)
+    return "";
+  if (text.length <= width)
+    return text;
+  return width <= 1 ? text.slice(0, width) : `${text.slice(0, width - 1)}~`;
+}
+
+// src/ui/text-input.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SearchInput({
+  value,
+  placeholder = "",
+  focus = true
+}) {
+  return /* @__PURE__ */ jsxs2(Text2, {
+    children: [
+      value.length > 0 ? /* @__PURE__ */ jsx2(Text2, {
+        children: value
+      }) : /* @__PURE__ */ jsx2(Text2, {
+        dimColor: true,
+        children: placeholder
+      }),
+      focus ? /* @__PURE__ */ jsx2(Text2, {
+        color: tone.primary,
+        children: "_"
+      }) : null
+    ]
+  });
+}
+
+// src/ui/command.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function filterCommands(groups, query) {
+  if (query.length === 0)
+    return groups;
+  const q = query.toLowerCase();
+  return groups.map((group) => ({
+    group: group.group,
+    items: group.items.filter((item) => item.label.toLowerCase().includes(q) || (item.hint ?? "").toLowerCase().includes(q))
+  })).filter((group) => group.items.length > 0);
+}
+function flattenCommands(groups) {
+  return groups.flatMap((group) => group.items);
+}
+var POINTER = 2;
+var GAP = 2;
+function CommandRow({
+  item,
+  width,
+  active
+}) {
+  const hint = item.hint ?? "";
+  const room = width - POINTER - (hint ? hint.length + GAP : 0);
+  const label = clip(item.label, Math.max(room, 0));
+  const gap = Math.max(width - POINTER - label.length - hint.length, hint ? 1 : 0);
+  return /* @__PURE__ */ jsxs3(Text3, {
+    children: [
+      /* @__PURE__ */ jsx3(Text3, {
+        color: tone.primary,
+        children: `${active ? mark.cursor : " "} `
+      }),
+      /* @__PURE__ */ jsx3(Text3, {
+        bold: active,
+        color: active ? tone.primary : undefined,
+        children: label
+      }),
+      /* @__PURE__ */ jsx3(Text3, {
+        dimColor: true,
+        children: `${" ".repeat(gap)}${hint}`
+      })
+    ]
+  });
+}
+function CommandPalette({
+  groups,
+  query,
+  cursor,
+  width,
+  placeholder = "type a command or search",
+  emptyMessage = "No matching commands."
+}) {
+  const visible = filterCommands(groups, query);
+  const rows = flattenCommands(visible);
+  const current = rows[cursor];
+  const interior = width - FRAME_CHROME;
+  return /* @__PURE__ */ jsxs3(Box2, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxs3(Box2, {
+        children: [
+          /* @__PURE__ */ jsx3(Text3, {
+            color: tone.primary,
+            children: "> "
+          }),
+          /* @__PURE__ */ jsx3(SearchInput, {
+            value: query,
+            placeholder
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx3(Divider, {
+        width
+      }),
+      rows.length === 0 ? /* @__PURE__ */ jsx3(Text3, {
+        dimColor: true,
+        children: emptyMessage
+      }) : visible.map((group, i) => /* @__PURE__ */ jsxs3(Box2, {
+        flexDirection: "column",
+        children: [
+          i > 0 ? /* @__PURE__ */ jsx3(Divider, {
+            width
+          }) : null,
+          /* @__PURE__ */ jsx3(Text3, {
+            dimColor: true,
+            children: group.group.toUpperCase()
+          }),
+          group.items.map((item) => /* @__PURE__ */ jsx3(CommandRow, {
+            item,
+            width: interior,
+            active: item.value === current?.value
+          }, item.value))
+        ]
+      }, group.group))
+    ]
+  });
+}
+// ../../packages/skills/src/lifecycle.ts
+var LIFECYCLES = [
+  { status: "active", word: "active", glyph: "#", tone: "state-active" },
+  {
+    status: "experimental",
+    word: "experimental",
+    glyph: "?",
+    tone: "state-experimental"
+  },
+  {
+    status: "deprecated",
+    word: "deprecated",
+    glyph: "x",
+    tone: "state-deprecated"
+  }
+];
+var LIFECYCLE_ORDER = LIFECYCLES.map((lifecycle) => lifecycle.status);
+var BY_STATUS = new Map(LIFECYCLES.map((lifecycle) => [lifecycle.status, lifecycle]));
+function lifecycleOf(status) {
+  const lifecycle = BY_STATUS.get(status);
+  if (!lifecycle) {
+    throw new Error(`No lifecycle vocabulary for "${status}". Add it to LIFECYCLES.`);
+  }
+  return lifecycle;
+}
+// src/ui/rows.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4, Fragment } from "react/jsx-runtime";
+function lifecycleTag(status) {
+  if (!status || status === "active")
+    return "";
+  return `[${lifecycleOf(status).word}]`;
+}
+function lifecycleColor(status) {
+  return stateTone[lifecycleOf(status ?? "active").tone];
+}
+var GUTTER = 4;
+var GAP2 = 2;
+function nameWidth(rows, max = 28) {
+  return Math.min(max, Math.max(8, ...rows.map((r) => r.name.length)));
+}
+function SkillRow({
+  row,
+  width,
+  names,
+  cursor,
+  selected,
+  selectable = false
+}) {
+  const tag = lifecycleTag(row.status);
+  const meta = row.count !== undefined ? `${row.count} skills` : tag;
+  const gutter = selectable ? GUTTER : 0;
+  const rest = width - gutter - names - GAP2 - (meta ? meta.length + GAP2 : 0);
+  return /* @__PURE__ */ jsxs4(Box3, {
+    children: [
+      selectable ? /* @__PURE__ */ jsx4(Text4, {
+        color: cursor ? "cyan" : undefined,
+        children: `${cursor ? mark.cursor : " "} ${selected ? mark.selected : mark.unselected} `
+      }) : null,
+      /* @__PURE__ */ jsx4(Text4, {
+        bold: cursor,
+        color: lifecycleColor(row.status),
+        children: clip(row.name, names).padEnd(names)
+      }),
+      /* @__PURE__ */ jsx4(Text4, {
+        children: " ".repeat(GAP2)
+      }),
+      /* @__PURE__ */ jsx4(Text4, {
+        dimColor: true,
+        children: clip(row.description ?? "", Math.max(rest, 0))
+      }),
+      meta ? /* @__PURE__ */ jsxs4(Fragment, {
+        children: [
+          /* @__PURE__ */ jsx4(Text4, {
+            children: " ".repeat(GAP2)
+          }),
+          /* @__PURE__ */ jsx4(Text4, {
+            color: lifecycleColor(row.status),
+            dimColor: !tag,
+            children: meta
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+function Hints({ hints }) {
+  return /* @__PURE__ */ jsx4(Box3, {
+    children: hints.map(([key, label], i) => /* @__PURE__ */ jsxs4(Text4, {
+      children: [
+        i > 0 ? /* @__PURE__ */ jsx4(Text4, {
+          dimColor: true,
+          children: "   "
+        }) : null,
+        /* @__PURE__ */ jsx4(Text4, {
+          color: "cyan",
+          children: key
+        }),
+        /* @__PURE__ */ jsx4(Text4, {
+          dimColor: true,
+          children: ` ${label}`
+        })
+      ]
+    }, key))
+  });
+}
+// src/ui/spinner.tsx
+import { Text as Text5 } from "ink";
+import { useEffect, useState } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var FRAMES = ["-", "\\", "|", "/"];
+var INTERVAL_MS = 90;
+function Spinner() {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsx5(Text5, {
+    color: tone.primary,
+    children: FRAMES[frame]
+  });
+}
+// src/auth/screens/login.tsx
+import { Box as Box4, Text as Text6, useApp } from "ink";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function minutesLeft(expiresAt) {
+  return Math.max(0, Math.ceil((expiresAt - Date.now()) / 60000));
+}
+function LoginScreen({
+  onError,
+  onDone
+}) {
+  const { exit } = useApp();
+  const width = useFrameWidth();
+  const [state, setState] = useState2({ phase: "starting" });
+  useEffect2(() => {
+    let live = true;
+    (async () => {
+      try {
+        for await (const event of login()) {
+          if (!live)
+            return;
+          if (event.kind === "prompt") {
+            setState({ phase: "waiting", prompt: event });
+          } else if (event.kind === "done") {
+            setState({ phase: "done", email: event.email });
+          }
+        }
+      } catch (error) {
+        if (live)
+          onError(error);
+        return;
+      }
+      if (!live)
+        return;
+      if (onDone)
+        onDone();
+      else
+        exit();
+    })();
+    return () => {
+      live = false;
+    };
+  }, [exit, onError, onDone]);
+  if (state.phase === "done") {
+    return /* @__PURE__ */ jsx6(Frame, {
+      title: "login",
+      width,
+      children: /* @__PURE__ */ jsxs5(Text6, {
+        children: [
+          /* @__PURE__ */ jsx6(Text6, {
+            color: "green",
+            children: mark.ok
+          }),
+          /* @__PURE__ */ jsx6(Text6, {
+            children: ` Logged in${state.email ? ` as ${state.email}` : ""}.`
+          })
+        ]
+      })
+    });
+  }
+  if (state.phase === "starting") {
+    return /* @__PURE__ */ jsx6(Frame, {
+      title: "login",
+      width,
+      children: /* @__PURE__ */ jsxs5(Text6, {
+        children: [
+          /* @__PURE__ */ jsx6(Spinner, {}),
+          /* @__PURE__ */ jsx6(Text6, {
+            dimColor: true,
+            children: " Requesting a device code..."
+          })
+        ]
+      })
+    });
+  }
+  const { prompt } = state;
+  return /* @__PURE__ */ jsx6(Frame, {
+    title: "login",
+    width,
+    children: /* @__PURE__ */ jsxs5(Box4, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx6(Text6, {
+          dimColor: true,
+          children: "Open this URL in your browser:"
+        }),
+        /* @__PURE__ */ jsx6(Text6, {
+          color: tone.primary,
+          children: prompt.verificationUri
+        }),
+        /* @__PURE__ */ jsx6(Box4, {
+          height: 1
+        }),
+        /* @__PURE__ */ jsx6(Text6, {
+          dimColor: true,
+          children: "and enter the code:"
+        }),
+        /* @__PURE__ */ jsx6(Text6, {
+          bold: true,
+          color: tone.notice,
+          children: prompt.userCode
+        }),
+        /* @__PURE__ */ jsx6(Box4, {
+          height: 1
+        }),
+        /* @__PURE__ */ jsxs5(Text6, {
+          children: [
+            /* @__PURE__ */ jsx6(Spinner, {}),
+            /* @__PURE__ */ jsx6(Text6, {
+              dimColor: true,
+              children: ` Waiting for approval — expires in ${minutesLeft(prompt.expiresAt)} min`
+            })
+          ]
+        })
+      ]
+    })
+  });
+}
+
+// src/auth/screens/gate.tsx
+import { jsx as jsx7, jsxs as jsxs6, Fragment as Fragment2 } from "react/jsx-runtime";
+function AuthGate({
+  title,
+  build,
+  onError,
+  check = hasSession,
+  connect
+}) {
+  const { exit } = useApp2();
+  const width = useFrameWidth();
+  const [phase, setPhase] = useState3({ kind: "checking" });
+  const open = useCallback(() => {
+    connect().then((client) => {
+      process.exitCode = 0;
+      setPhase({ kind: "ready", client });
+    }).catch((error) => onError(error));
+  }, [connect, onError]);
+  useEffect3(() => {
+    let live = true;
+    check().then((ok) => {
+      if (!live)
+        return;
+      if (ok)
+        return open();
+      process.exitCode = 1;
+      setPhase({ kind: "blocked" });
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [check, open, onError]);
+  useInput((input, key) => {
+    if (input === "l")
+      setPhase({ kind: "logging-in" });
+    if (input === "q" || key.escape)
+      exit();
+  }, { isActive: phase.kind === "blocked" });
+  const child = useMemo(() => phase.kind === "ready" ? build(phase.client) : null, [phase, build]);
+  if (phase.kind === "ready")
+    return /* @__PURE__ */ jsx7(Fragment2, {
+      children: child
+    });
+  if (phase.kind === "logging-in")
+    return /* @__PURE__ */ jsx7(LoginScreen, {
+      onError,
+      onDone: open
+    });
+  if (phase.kind === "checking")
+    return /* @__PURE__ */ jsx7(Frame, {
+      title,
+      width,
+      children: /* @__PURE__ */ jsxs6(Text7, {
+        children: [
+          /* @__PURE__ */ jsx7(Spinner, {}),
+          /* @__PURE__ */ jsx7(Text7, {
+            dimColor: true,
+            children: " Checking session..."
+          })
+        ]
+      })
+    });
+  return /* @__PURE__ */ jsx7(Frame, {
+    title,
+    width,
+    children: /* @__PURE__ */ jsxs6(Box5, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs6(Text7, {
+          children: [
+            /* @__PURE__ */ jsx7(Text7, {
+              color: tone.notice,
+              children: mark.fail
+            }),
+            /* @__PURE__ */ jsx7(Text7, {
+              children: ` Not signed in — ${title} needs a session.`
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsx7(Blank, {}),
+        /* @__PURE__ */ jsxs6(Text7, {
+          dimColor: true,
+          children: [
+            "press ",
+            /* @__PURE__ */ jsx7(Text7, {
+              color: tone.primary,
+              children: "l"
+            }),
+            " to log in, ",
+            /* @__PURE__ */ jsx7(Text7, {
+              color: tone.primary,
+              children: "q"
+            }),
+            " to quit"
+          ]
+        }),
+        /* @__PURE__ */ jsxs6(Text7, {
+          dimColor: true,
+          children: [
+            "or run ",
+            /* @__PURE__ */ jsx7(Text7, {
+              color: tone.primary,
+              children: "yourskills login"
+            }),
+            " elsewhere"
+          ]
+        })
+      ]
+    })
+  });
+}
+// src/catalog/screens/browser.tsx
+import { Box as Box7, Text as Text9, useApp as useApp4, useInput as useInput2, useWindowSize as useWindowSize2 } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo2, useState as useState5 } from "react";
+
+// src/install/install.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname as dirname3, join as join4 } from "node:path";
+
+// src/manifest/manifest.ts
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+function emptyManifest(scope) {
+  return { version: 1, scope, agents: [], bundles: {}, skills: {} };
+}
+function manifestPathFor(scope, cwd) {
+  return scope === "global" ? join3(configDir(), "installed.json") : join3(resolve2(cwd ?? process.cwd()), PROJECT_MANIFEST);
+}
+function readManifest(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return emptyManifest(path.endsWith(PROJECT_MANIFEST) ? "project" : "global");
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return emptyManifest(path.endsWith(PROJECT_MANIFEST) ? "project" : "global");
+  }
+  const raw = parsed;
+  const scope = raw.scope === "project" ? "project" : "global";
+  return {
+    version: 1,
+    scope,
+    agents: Array.isArray(raw.agents) ? raw.agents : [],
+    bundles: raw.bundles && typeof raw.bundles === "object" ? raw.bundles : {},
+    skills: raw.skills && typeof raw.skills === "object" ? raw.skills : {}
+  };
+}
+function writeManifest(path, m) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(m, null, 2)}
+`);
+}
+function recordSkill(m, entry) {
+  return { ...m, skills: { ...m.skills, [entry.name]: entry } };
+}
+function recordBundle(m, name, ref) {
+  return { ...m, bundles: { ...m.bundles, [name]: ref } };
+}
+function forgetSkill(m, name) {
+  const { [name]: _removed, ...rest } = m.skills;
+  return { ...m, skills: rest };
+}
+// src/manifest/nearest.ts
+async function nearestManifest(flag, cwd) {
+  const { scope, source, manifestPath } = await resolveScope({ flag, cwd });
+  const path = scope === "project" && manifestPath ? manifestPath : manifestPathFor(scope, cwd);
+  return { path, scope, source, manifest: readManifest(path) };
+}
+// src/install/install.ts
+function skillsAddArgv(location, opts = {}) {
+  const path = location.path.replace(/^\/+|\/+$/g, "");
+  const spec = `${location.source}${path ? `/${path}` : ""}#${location.ref}`;
+  const argv = ["add", spec, "--yes"];
+  if (opts.scope !== "project")
+    argv.push("--global");
+  for (const agent of opts.agents ?? [])
+    argv.push("--agent", agent);
+  return argv;
+}
+function childEnv(base = process.env) {
+  const env = {};
+  for (const [k, v] of Object.entries(base))
+    if (v !== undefined)
+      env[k] = v;
+  env.DISABLE_TELEMETRY = "1";
+  env.DO_NOT_TRACK = "1";
+  return env;
+}
+var nodeRequire = createRequire(import.meta.url);
+function skillsBin() {
+  let pkgPath;
+  try {
+    pkgPath = nodeRequire.resolve("skills/package.json");
+  } catch {
+    throw new Error("The bundled `skills` CLI could not be resolved. Re-install yourskills; its `skills` dependency is missing.");
+  }
+  const pkg = nodeRequire(pkgPath);
+  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.skills;
+  if (!bin) {
+    throw new Error("The bundled `skills` package declares no `skills` binary. Re-install yourskills.");
+  }
+  return join4(dirname3(pkgPath), bin);
+}
+function runSkills(argv) {
+  const bin = skillsBin();
+  return new Promise((settle) => {
+    const child = spawn(process.execPath, [bin, ...argv], {
+      env: childEnv(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const fail = (message) => settle({ ok: false, message, detail: `${stdout}${stderr}`.trim() });
+    child.on("error", (error) => fail(`skills ${argv.join(" ")} could not be started: ${error.message}`));
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        settle({ ok: true });
+        return;
+      }
+      fail(`skills ${argv.join(" ")} exited ${code ?? `on ${signal}`}`);
+    });
+  });
+}
+function pendingMessage(pending) {
+  const where = `${pending.repo}/${pending.path}`;
+  return pending.prUrl ? `${pending.skillName}  not in your registry yet — opened a pull request against ${where}
+` + `  ${pending.prUrl}
+` + "  Merge it, then run this command again." : `${pending.skillName}  not in your registry yet — written to ${where}. ` + "Re-run once your registry has indexed it.";
+}
+function manifestEntryFor(location, opts = {}, bundle) {
+  const path = location.path.replace(/^\/+|\/+$/g, "");
+  return {
+    name: location.skillName,
+    externalId: location.externalId,
+    ref: location.ref,
+    source: location.source,
+    path,
+    ...bundle ? { bundle } : {},
+    agents: opts.agents ?? [],
+    installedAt: new Date().toISOString()
+  };
+}
+function record(opts, location, bundle) {
+  const target = opts.manifest;
+  if (!target)
+    return;
+  let manifest = readManifest(target.path);
+  manifest = {
+    ...manifest,
+    scope: target.scope,
+    agents: opts.agents?.length ? opts.agents : manifest.agents
+  };
+  if (bundle && !manifest.bundles[bundle]) {
+    manifest = recordBundle(manifest, bundle, location.ref);
+  }
+  manifest = recordSkill(manifest, manifestEntryFor(location, opts, bundle));
+  writeManifest(target.path, manifest);
+}
+async function* installTargets(targets, opts, bundle) {
+  for (const location of targets) {
+    if (location.deprecated)
+      yield { kind: "deprecated", location };
+    yield { kind: "installing", location };
+    const result = await runSkills(skillsAddArgv(location, opts));
+    if (result.ok)
+      record(opts, location, bundle);
+    yield result.ok ? { kind: "installed", location } : {
+      kind: "failed",
+      name: location.skillName,
+      message: result.message,
+      detail: result.detail
+    };
+  }
+}
+async function* install(client, names, opts = {}) {
+  for (const name of names)
+    yield { kind: "resolving", name };
+  let resolution;
+  try {
+    resolution = await client.resolve.skill.mutate({ names });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const name of names)
+      yield { kind: "failed", name, message };
+    return;
+  }
+  yield* installResolution(resolution.entries, opts);
+}
+async function* installBundle(client, name, opts = {}) {
+  yield { kind: "resolving", name };
+  let resolution;
+  try {
+    resolution = await client.resolve.bundle.mutate({ name });
+  } catch (error) {
+    yield {
+      kind: "failed",
+      name,
+      message: error instanceof Error ? error.message : String(error)
+    };
+    return;
+  }
+  yield* installResolution(resolution.entries, opts, name);
+}
+async function* installResolution(entries, opts, bundle) {
+  for (const entry of entries) {
+    if (entry.state === "failed") {
+      yield { kind: "failed", name: entry.name, message: entry.message };
+      continue;
+    }
+    if (entry.state === "vendoring") {
+      yield { kind: "pending", vendor: entry.vendor };
+      continue;
+    }
+    yield* installTargets(entry.locations, opts, bundle);
+  }
+}
+// src/install/reinstall.ts
+function targetOf(entry) {
+  return {
+    skillName: entry.name,
+    externalId: entry.externalId,
+    source: entry.source,
+    path: entry.path,
+    ref: entry.ref,
+    deprecated: false
+  };
+}
+async function* reinstall(manifest, opts = {}) {
+  const entries = Object.values(manifest.skills);
+  for (const entry of entries) {
+    yield* installTargets([targetOf(entry)], opts, entry.bundle);
+  }
+}
+// src/install/remove.ts
+function skillsRemoveArgv(name, opts = {}) {
+  const argv = ["remove", name, "--yes"];
+  if (opts.scope !== "project")
+    argv.push("--global");
+  for (const agent of opts.agents ?? [])
+    argv.push("--agent", agent);
+  return argv;
+}
+async function removeSkills(names, manifest, manifestPath, opts = {}) {
+  const lines = [];
+  const removed = [];
+  let next = manifest;
+  let failed = false;
+  for (const name of names) {
+    const entry = next.skills[name];
+    if (!entry) {
+      failed = true;
+      lines.push({
+        mark: "fail",
+        text: name,
+        note: "not in the manifest — nothing to remove"
+      });
+      continue;
+    }
+    const result = await runSkills(skillsRemoveArgv(name, opts));
+    if (!result.ok) {
+      failed = true;
+      lines.push({ mark: "fail", text: name, note: result.message });
+      continue;
+    }
+    next = forgetSkill(next, name);
+    removed.push(name);
+    lines.push({ mark: "ok", text: name, note: "removed" });
+  }
+  if (removed.length > 0)
+    writeManifest(manifestPath, next);
+  return {
+    title: "remove",
+    lines,
+    json: { manifest: manifestPath, removed, failed },
+    failed
+  };
+}
+// src/install/screens/installer.tsx
+import { Box as Box6, Text as Text8, useApp as useApp3 } from "ink";
+import { useEffect as useEffect4, useState as useState4 } from "react";
+import { jsx as jsx8, jsxs as jsxs7, Fragment as Fragment3 } from "react/jsx-runtime";
+function where(location) {
+  return `${location.source}/${location.path}@${location.ref.slice(0, 8)}`;
+}
+function reduce(lines, event) {
+  const replace = (name, next) => {
+    const at = lines.findIndex((l) => l.name === name);
+    if (at === -1)
+      return [...lines, next];
+    return lines.map((l, i) => i === at ? next : l);
+  };
+  switch (event.kind) {
+    case "resolving":
+      return replace(event.name, { state: "resolving", name: event.name });
+    case "deprecated":
+      return lines;
+    case "installing":
+      return replace(event.location.skillName, {
+        state: "installing",
+        name: event.location.skillName,
+        where: where(event.location)
+      });
+    case "installed":
+      return replace(event.location.skillName, {
+        state: "installed",
+        name: event.location.skillName,
+        where: where(event.location),
+        deprecated: event.location.deprecated
+      });
+    case "pending":
+      return replace(event.vendor.skillName, {
+        state: "pending",
+        name: event.vendor.skillName,
+        vendor: event.vendor
+      });
+    case "failed":
+      return replace(event.name, {
+        state: "failed",
+        name: event.name,
+        message: event.message,
+        detail: event.detail
+      });
+  }
+}
+function InstallLine({ line, width }) {
+  const names = 24;
+  const name = clip(line.name, names).padEnd(names);
+  switch (line.state) {
+    case "resolving":
+      return /* @__PURE__ */ jsxs7(Text8, {
+        children: [
+          /* @__PURE__ */ jsx8(Spinner, {}),
+          /* @__PURE__ */ jsx8(Text8, {
+            children: ` ${name}`
+          }),
+          /* @__PURE__ */ jsx8(Text8, {
+            dimColor: true,
+            children: "resolving..."
+          })
+        ]
+      });
+    case "installing":
+      return /* @__PURE__ */ jsxs7(Text8, {
+        children: [
+          /* @__PURE__ */ jsx8(Spinner, {}),
+          /* @__PURE__ */ jsx8(Text8, {
+            children: ` ${name}`
+          }),
+          /* @__PURE__ */ jsx8(Text8, {
+            dimColor: true,
+            children: clip(line.where, width - names - 3)
+          })
+        ]
+      });
+    case "installed":
+      return /* @__PURE__ */ jsxs7(Text8, {
+        children: [
+          /* @__PURE__ */ jsx8(Text8, {
+            color: "green",
+            children: mark.ok
+          }),
+          /* @__PURE__ */ jsx8(Text8, {
+            children: ` ${name}`
+          }),
+          /* @__PURE__ */ jsx8(Text8, {
+            dimColor: true,
+            children: clip(line.where, width - names - 3)
+          }),
+          line.deprecated ? /* @__PURE__ */ jsx8(Text8, {
+            color: lifecycleColor("deprecated"),
+            children: `  ${lifecycleTag("deprecated")}`
+          }) : null
+        ]
+      });
+    case "pending":
+      return /* @__PURE__ */ jsxs7(Box6, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxs7(Text8, {
+            children: [
+              /* @__PURE__ */ jsx8(Text8, {
+                color: tone.notice,
+                children: mark.pending
+              }),
+              /* @__PURE__ */ jsx8(Text8, {
+                children: ` ${name}`
+              }),
+              /* @__PURE__ */ jsx8(Text8, {
+                color: tone.notice,
+                children: "not in your registry yet"
+              })
+            ]
+          }),
+          line.vendor.prUrl ? /* @__PURE__ */ jsxs7(Text8, {
+            children: [
+              /* @__PURE__ */ jsx8(Text8, {
+                children: "    "
+              }),
+              /* @__PURE__ */ jsx8(Text8, {
+                color: tone.primary,
+                children: line.vendor.prUrl
+              })
+            ]
+          }) : null
+        ]
+      });
+    case "failed":
+      return /* @__PURE__ */ jsxs7(Box6, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxs7(Text8, {
+            children: [
+              /* @__PURE__ */ jsx8(Text8, {
+                color: tone.danger,
+                children: mark.fail
+              }),
+              /* @__PURE__ */ jsx8(Text8, {
+                children: ` ${name}`
+              }),
+              /* @__PURE__ */ jsx8(Text8, {
+                color: tone.danger,
+                children: clip(line.message, width - names - 3)
+              })
+            ]
+          }),
+          line.detail ? line.detail.split(`
+`).slice(-3).map((d) => /* @__PURE__ */ jsx8(Text8, {
+            dimColor: true,
+            children: clip(`    ${d}`, width)
+          }, d)) : null
+        ]
+      });
+  }
+}
+function Installer({
+  title,
+  stream,
+  onDone,
+  exitWhenDone = true
+}) {
+  const { exit } = useApp3();
+  const width = useFrameWidth();
+  const [lines, setLines] = useState4([]);
+  const [error, setError] = useState4(null);
+  const [done, setDone] = useState4(false);
+  useEffect4(() => {
+    let live = true;
+    (async () => {
+      let current = [];
+      try {
+        for await (const event of stream()) {
+          if (!live)
+            return;
+          current = reduce(current, event);
+          setLines(current);
+        }
+      } catch (e) {
+        if (live)
+          setError(e instanceof Error ? e.message : String(e));
+      }
+      if (!live)
+        return;
+      setDone(true);
+      onDone?.({
+        pending: current.filter((l) => l.state === "pending").map((l) => l.vendor),
+        failed: current.filter((l) => l.state === "failed").length
+      });
+      if (exitWhenDone)
+        exit();
+    })();
+    return () => {
+      live = false;
+    };
+  }, [stream, onDone, exit, exitWhenDone]);
+  const pending = lines.filter((l) => l.state === "pending");
+  return /* @__PURE__ */ jsx8(Frame, {
+    title,
+    width,
+    children: /* @__PURE__ */ jsxs7(Box6, {
+      flexDirection: "column",
+      children: [
+        lines.length === 0 && !error ? /* @__PURE__ */ jsxs7(Text8, {
+          children: [
+            /* @__PURE__ */ jsx8(Spinner, {}),
+            /* @__PURE__ */ jsx8(Text8, {
+              dimColor: true,
+              children: " Resolving..."
+            })
+          ]
+        }) : null,
+        lines.map((line) => /* @__PURE__ */ jsx8(InstallLine, {
+          line,
+          width: width - 2
+        }, line.name)),
+        error ? /* @__PURE__ */ jsx8(Text8, {
+          color: tone.danger,
+          children: `${mark.fail} ${error}`
+        }) : null,
+        done && pending.length > 0 ? /* @__PURE__ */ jsxs7(Fragment3, {
+          children: [
+            /* @__PURE__ */ jsx8(Divider, {
+              width
+            }),
+            /* @__PURE__ */ jsx8(Text8, {
+              color: tone.notice,
+              children: pending.length === 1 ? "1 skill is waiting on a pull request." : `${pending.length} skills are waiting on a pull request.`
+            }),
+            /* @__PURE__ */ jsx8(Text8, {
+              dimColor: true,
+              children: "Merge it, then run this command again."
+            })
+          ]
+        }) : null
+      ]
+    })
+  });
+}
+async function installPlain(stream) {
+  const pending = [];
+  let failed = 0;
+  for await (const event of stream) {
+    switch (event.kind) {
+      case "resolving":
+        break;
+      case "deprecated":
+        console.warn(`warning: "${event.location.skillName}" is deprecated — installing anyway.`);
+        break;
+      case "installing":
+        console.log(`${event.location.skillName}  ${where(event.location)}`);
+        break;
+      case "installed":
+        break;
+      case "pending":
+        console.log(pendingMessage(event.vendor));
+        pending.push(event.vendor);
+        break;
+      case "failed":
+        failed += 1;
+        console.error(`error: ${event.name}: ${event.message}`);
+        if (event.detail)
+          console.error(event.detail);
+        break;
+    }
+  }
+  return { pending, failed };
+}
+// src/install/update.ts
+function update(client, bundle, opts = {}) {
+  return installBundle(client, bundle, opts);
+}
+function looseSkills(manifest) {
+  return Object.values(manifest.skills).filter((entry) => !entry.bundle).map((entry) => entry.name);
+}
+async function* updateTracked(client, manifest, opts = {}, all = false) {
+  for (const bundle of Object.keys(manifest.bundles)) {
+    yield* installBundle(client, bundle, opts);
+  }
+  const loose = all ? looseSkills(manifest) : [];
+  if (loose.length > 0)
+    yield* install(client, loose, opts);
+}
+// src/catalog/screens/browser.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+var TABS = ["bundles", "skills"];
+function pageSize(rows) {
+  return Math.max(3, Math.min(20, rows - 11));
+}
+function matches(row, query) {
+  if (query.length === 0)
+    return true;
+  const q = query.toLowerCase();
+  return row.name.toLowerCase().includes(q) || (row.description ?? "").toLowerCase().includes(q);
+}
+function TabBar({ active }) {
+  return /* @__PURE__ */ jsx9(Box7, {
+    children: TABS.map((tab, i) => /* @__PURE__ */ jsxs8(Text9, {
+      children: [
+        i > 0 ? /* @__PURE__ */ jsx9(Text9, {
+          dimColor: true,
+          children: "  "
+        }) : null,
+        tab === active ? /* @__PURE__ */ jsx9(Text9, {
+          bold: true,
+          color: tone.primary,
+          children: `[${tab}]`
+        }) : /* @__PURE__ */ jsx9(Text9, {
+          dimColor: true,
+          children: ` ${tab} `
+        })
+      ]
+    }, tab))
+  });
+}
+function BrowserScreen({
+  client,
+  opts,
+  onError,
+  onSummary,
+  onExit
+}) {
+  const { exit } = useApp4();
+  const width = useFrameWidth();
+  const { rows: terminalRows } = useWindowSize2();
+  const [catalog, setCatalog] = useState5(null);
+  const [tab, setTab] = useState5("bundles");
+  const [query, setQuery] = useState5("");
+  const [cursor, setCursor] = useState5(0);
+  const [picked, setPicked] = useState5({
+    bundles: new Set,
+    skills: new Set
+  });
+  const [running, setRunning] = useState5(null);
+  useEffect5(() => {
+    let live = true;
+    Promise.all([client.skills.list.query({}), client.bundles.list.query()]).then(([skills, bundles]) => {
+      if (!live)
+        return;
+      setCatalog({
+        skills: skills.map((s) => ({
+          name: s.name,
+          description: s.description,
+          status: s.status
+        })),
+        bundles: bundles.map((b) => ({
+          name: b.name,
+          description: b.description
+        }))
+      });
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [client, onError]);
+  const visible = useMemo2(() => {
+    if (!catalog)
+      return [];
+    return catalog[tab].filter((row) => matches(row, query));
+  }, [catalog, tab, query]);
+  useEffect5(() => {
+    setCursor((c) => Math.max(0, Math.min(c, visible.length - 1)));
+  }, [visible.length]);
+  const selected = picked[tab];
+  const start = useCallback2(() => {
+    const names2 = selected.size > 0 ? [...selected] : visible[cursor] ? [visible[cursor].name] : [];
+    if (names2.length === 0)
+      return;
+    setRunning({
+      title: tab === "bundles" ? `bundle: ${names2[0]}` : "add",
+      names: names2
+    });
+  }, [selected, visible, cursor, tab]);
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+    } else if (key.downArrow) {
+      setCursor((c) => Math.min(visible.length - 1, c + 1));
+    } else if (key.pageUp) {
+      setCursor((c) => Math.max(0, c - pageSize(terminalRows)));
+    } else if (key.pageDown) {
+      setCursor((c) => Math.min(visible.length - 1, c + pageSize(terminalRows)));
+    } else if (key.tab) {
+      setTab((t) => t === "bundles" ? "skills" : "bundles");
+      setCursor(0);
+    } else if (key.return) {
+      start();
+    } else if (key.escape) {
+      if (query.length > 0)
+        setQuery("");
+      else
+        (onExit ?? exit)();
+    } else if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setCursor(0);
+    } else if (input === " ") {
+      const row = visible[cursor];
+      if (!row)
+        return;
+      setPicked((current) => {
+        const next = new Set(current[tab]);
+        if (tab === "bundles")
+          next.clear();
+        if (current[tab].has(row.name))
+          next.delete(row.name);
+        else
+          next.add(row.name);
+        return { ...current, [tab]: next };
+      });
+    } else if (input && !key.ctrl && !key.meta) {
+      setQuery((q) => q + input);
+      setCursor(0);
+    }
+  }, { isActive: running === null });
+  if (running) {
+    const names2 = running.names;
+    const stream = tab === "bundles" ? () => installBundle(client, names2[0], opts) : () => install(client, names2, opts);
+    return /* @__PURE__ */ jsx9(Installer, {
+      title: running.title,
+      stream,
+      exitWhenDone: true,
+      onDone: onSummary
+    });
+  }
+  if (!catalog) {
+    return /* @__PURE__ */ jsx9(Frame, {
+      title: "yourskills",
+      width,
+      children: /* @__PURE__ */ jsxs8(Text9, {
+        children: [
+          /* @__PURE__ */ jsx9(Spinner, {}),
+          /* @__PURE__ */ jsx9(Text9, {
+            dimColor: true,
+            children: " Loading your registry..."
+          })
+        ]
+      })
+    });
+  }
+  const size = pageSize(terminalRows);
+  const first = Math.max(0, Math.min(cursor - Math.floor(size / 2), visible.length - size));
+  const page = visible.slice(Math.max(0, first), Math.max(0, first) + size);
+  const names = nameWidth(visible.length > 0 ? visible : catalog[tab]);
+  return /* @__PURE__ */ jsx9(Frame, {
+    title: "yourskills",
+    width,
+    children: /* @__PURE__ */ jsxs8(Box7, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx9(TabBar, {
+          active: tab
+        }),
+        /* @__PURE__ */ jsx9(Divider, {
+          width
+        }),
+        /* @__PURE__ */ jsxs8(Box7, {
+          children: [
+            /* @__PURE__ */ jsx9(Text9, {
+              color: tone.primary,
+              children: "search> "
+            }),
+            /* @__PURE__ */ jsx9(SearchInput, {
+              value: query,
+              placeholder: "type to filter"
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsx9(Divider, {
+          width
+        }),
+        page.length === 0 ? /* @__PURE__ */ jsx9(Text9, {
+          dimColor: true,
+          children: `No ${tab} match "${query}".`
+        }) : page.map((row, i) => /* @__PURE__ */ jsx9(SkillRow, {
+          row,
+          width: width - 2,
+          names,
+          selectable: true,
+          cursor: Math.max(0, first) + i === cursor,
+          selected: selected.has(row.name)
+        }, row.name)),
+        /* @__PURE__ */ jsx9(Divider, {
+          width
+        }),
+        /* @__PURE__ */ jsxs8(Box7, {
+          children: [
+            /* @__PURE__ */ jsx9(Text9, {
+              dimColor: true,
+              children: `${visible.length > 0 ? cursor + 1 : 0}/${visible.length}`
+            }),
+            selected.size > 0 ? /* @__PURE__ */ jsx9(Text9, {
+              color: tone.notice,
+              children: `  ${selected.size} selected`
+            }) : null,
+            /* @__PURE__ */ jsx9(Text9, {
+              children: "   "
+            }),
+            /* @__PURE__ */ jsx9(Hints, {
+              hints: [
+                ["^v", "move"],
+                ["space", "select"],
+                ["enter", "install"],
+                ["tab", tab === "bundles" ? "skills" : "bundles"],
+                ["esc", query ? "clear" : onExit ? "back" : "quit"]
+              ]
+            })
+          ]
+        })
+      ]
+    })
+  });
+}
+// src/catalog/screens/catalog.tsx
+import { Box as Box8, Text as Text10, useApp as useApp5 } from "ink";
+import { useEffect as useEffect6, useState as useState6 } from "react";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function CatalogScreen({
+  title,
+  load,
+  onError
+}) {
+  const { exit } = useApp5();
+  const width = useFrameWidth();
+  const [rows, setRows] = useState6(null);
+  useEffect6(() => {
+    let live = true;
+    load().then((result) => {
+      if (!live)
+        return;
+      setRows(result);
+      exit();
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [load, exit, onError]);
+  if (rows === null) {
+    return /* @__PURE__ */ jsx10(Frame, {
+      title,
+      width,
+      children: /* @__PURE__ */ jsxs9(Text10, {
+        children: [
+          /* @__PURE__ */ jsx10(Spinner, {}),
+          /* @__PURE__ */ jsx10(Text10, {
+            dimColor: true,
+            children: " Loading..."
+          })
+        ]
+      })
+    });
+  }
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsx10(Frame, {
+      title,
+      width,
+      children: /* @__PURE__ */ jsx10(Text10, {
+        dimColor: true,
+        children: "No skills found."
+      })
+    });
+  }
+  const names = nameWidth(rows);
+  return /* @__PURE__ */ jsx10(Frame, {
+    title,
+    width,
+    children: /* @__PURE__ */ jsx10(Box8, {
+      flexDirection: "column",
+      children: rows.map((row) => /* @__PURE__ */ jsx10(SkillRow, {
+        row,
+        width: width - 2,
+        names
+      }, row.name))
+    })
+  });
+}
+// src/doctor/doctor.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, join as join5 } from "node:path";
+var REACH_TIMEOUT_MS = 5000;
+async function reachable(base) {
+  const url = `${base.replace(/\/$/, "")}/api/auth/ok`;
+  try {
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(REACH_TIMEOUT_MS)
+    });
+    return {
+      name: "server reachable",
+      ok: true,
+      detail: `${base} (${res.status})`
+    };
+  } catch (error) {
+    return {
+      name: "server reachable",
+      ok: false,
+      detail: `${base}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function session(server) {
+  try {
+    const who = await whoami(server);
+    return [
+      { name: "session valid", ok: true, detail: who.user },
+      {
+        name: "active organization",
+        ok: who.org !== null,
+        detail: who.org ?? "none — pick one with `yourskills org <name>` or in the web UI"
+      }
+    ];
+  } catch (error) {
+    return [
+      {
+        name: "session valid",
+        ok: false,
+        detail: error instanceof Error ? error.message : String(error)
+      },
+      {
+        name: "active organization",
+        ok: false,
+        detail: "unknown until you are logged in"
+      }
+    ];
+  }
+}
+function skillsResolvable() {
+  try {
+    const bin = skillsBin();
+    return existsSync2(bin) ? { name: "skills dependency", ok: true, detail: bin } : { name: "skills dependency", ok: false, detail: `missing: ${bin}` };
+  } catch (error) {
+    return {
+      name: "skills dependency",
+      ok: false,
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function detectedAgents() {
+  let bin;
+  try {
+    bin = skillsBin();
+  } catch {
+    return Promise.resolve([]);
+  }
+  return new Promise((settle) => {
+    const child = spawn2(process.execPath, [bin, "list", "--json", "--global"], {
+      env: childEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let out = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", () => settle([]));
+    child.on("close", () => {
+      try {
+        const found = new Set;
+        for (const row of JSON.parse(out)) {
+          for (const agent of row.agents ?? [])
+            found.add(agent);
+        }
+        settle([...found]);
+      } catch {
+        settle([]);
+      }
+    });
+  });
+}
+async function agents() {
+  const pinned = await resolveAgents();
+  const found = new Set(pinned);
+  for (const agent of await detectedAgents())
+    found.add(agent);
+  const all = [...found];
+  return {
+    name: "agents",
+    ok: all.length > 0,
+    detail: all.length > 0 ? all.join(", ") : "none — pin one with `yourskills config set agents claude-code`"
+  };
+}
+function manifestParses(nearest) {
+  if (!existsSync2(nearest.path)) {
+    return {
+      name: "manifest",
+      ok: true,
+      detail: `${nearest.path} (not created yet)`
+    };
+  }
+  try {
+    const raw = JSON.parse(readFileSync2(nearest.path, "utf8"));
+    return raw && typeof raw === "object" ? {
+      name: "manifest",
+      ok: true,
+      detail: `${nearest.path} (${nearest.scope})`
+    } : {
+      name: "manifest",
+      ok: false,
+      detail: `${nearest.path}: not an object`
+    };
+  } catch (error) {
+    return {
+      name: "manifest",
+      ok: false,
+      detail: `${nearest.path}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function onDisk(nearest, name) {
+  const root = nearest.scope === "project" ? dirname4(nearest.path) : homedir2();
+  return existsSync2(join5(root, ".agents", "skills", name));
+}
+function manifestMatchesDisk(nearest) {
+  const names = Object.keys(nearest.manifest.skills);
+  const missing = names.filter((name) => !onDisk(nearest, name));
+  return {
+    name: "manifest matches disk",
+    ok: missing.length === 0,
+    detail: missing.length === 0 ? `${names.length} skill(s) recorded` : `missing: ${missing.join(", ")} — run \`yourskills install\``
+  };
+}
+async function doctorReport(nearest, server) {
+  const config = await readConfig();
+  const base = serverUrl(config, server);
+  const checks = [
+    await reachable(base),
+    ...await session(server),
+    skillsResolvable(),
+    await agents(),
+    manifestParses(nearest),
+    manifestMatchesDisk(nearest)
+  ];
+  const width = Math.max(...checks.map((check) => check.name.length));
+  const lines = checks.map((check) => ({
+    mark: check.ok ? "ok" : "fail",
+    text: check.name.padEnd(width),
+    note: check.detail
+  }));
+  return {
+    title: "doctor",
+    lines,
+    json: { manifest: nearest.path, checks },
+    failed: checks.some((check) => !check.ok)
+  };
+}
+// src/hooks/adapters.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join6 } from "node:path";
+var BINARY = "yourskills";
+function claudeHome() {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  return override && override.length > 0 ? override : join6(homedir3(), ".claude");
+}
+function opencodeHome() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return join6(xdg && xdg.length > 0 ? xdg : join6(homedir3(), ".config"), "opencode");
+}
+var UPDATE_CHECK_ENTRY = {
+  kind: "update-check",
+  event: "SessionStart",
+  matcher: "startup|resume",
+  command: `${BINARY} hook session-start`
+};
+var USAGE_ENTRY = {
+  kind: "usage",
+  event: "PostToolUse",
+  matcher: "Skill",
+  command: `${BINARY} hook post-tool-use`
+};
+var HOOK_ADAPTERS = [
+  {
+    agent: "claude-code",
+    supports: ["update-check", "usage"],
+    home: claudeHome,
+    settingsPath: () => join6(claudeHome(), "settings.json"),
+    entries: [UPDATE_CHECK_ENTRY, USAGE_ENTRY]
+  },
+  {
+    agent: "opencode",
+    supports: ["update-check"],
+    home: opencodeHome,
+    settingsPath: () => null,
+    entries: [],
+    limitation: "opencode hooks are JavaScript plugin modules, not commands in a settings file — yourskills cannot register one yet"
+  }
+];
+function adapterFor(agent) {
+  return HOOK_ADAPTERS.find((adapter) => adapter.agent === agent);
+}
+function agentsToReport(configured) {
+  const names = new Set(HOOK_ADAPTERS.map((adapter) => adapter.agent));
+  for (const agent of configured)
+    names.add(agent);
+  return [...names].sort();
+}
+function agentForEvent(kind, event) {
+  const owner = HOOK_ADAPTERS.find((adapter) => adapter.entries.some((entry) => entry.kind === kind && entry.event === event));
+  return owner?.agent ?? "unknown";
+}
+// src/hooks/ensure.ts
+import { existsSync as existsSync3 } from "node:fs";
+
+// src/usage/queue.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { appendFile, readFile as readFile3, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+
+// src/client.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+async function createClient(server) {
+  const { token, base } = await requireToken(server);
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${base.replace(/\/$/, "")}/trpc`,
+        headers: () => ({ authorization: `Bearer ${token}` })
+      })
+    ]
+  });
+}
+
+// src/usage/queue.ts
+var USAGE_BATCH_MAX = 100;
+var QUEUE_MAX_EVENTS = 5000;
+var TRIM_ABOVE_BYTES = QUEUE_MAX_EVENTS * 80;
+function queuePath() {
+  return join7(configDir(), "queue.jsonl");
+}
+function parseLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed?.skillExternalId !== "string" || typeof parsed.ref !== "string" || typeof parsed.agent !== "string" || typeof parsed.occurredAt !== "string") {
+      return null;
+    }
+    return {
+      skillExternalId: parsed.skillExternalId,
+      ref: parsed.ref,
+      agent: parsed.agent,
+      occurredAt: parsed.occurredAt
+    };
+  } catch {
+    return null;
+  }
+}
+async function readRaw(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function readQueue() {
+  const events = [];
+  for (const line of (await readRaw(queuePath())).split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    const event = parseLine(line);
+    if (event)
+      events.push(event);
+  }
+  return events;
+}
+async function trim(path) {
+  const events = await readQueue();
+  if (events.length <= QUEUE_MAX_EVENTS)
+    return;
+  const kept = events.slice(events.length - QUEUE_MAX_EVENTS);
+  await writeFile2(path, kept.map(line).join(""));
+}
+function line(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+async function appendEvent(event) {
+  const path = queuePath();
+  mkdirSync3(configDir(), { recursive: true, mode: 448 });
+  await appendFile(path, line(event));
+  try {
+    const info = await stat(path);
+    if (info.size > TRIM_ABOVE_BYTES)
+      await trim(path);
+  } catch {}
+}
+async function keepFrom(path, before, sent) {
+  const lines = before.split(`
+`);
+  let seen = 0;
+  let cut = lines.length;
+  for (let i = 0;i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw.trim().length === 0)
+      continue;
+    if (parseLine(raw) === null)
+      continue;
+    seen++;
+    if (seen === sent) {
+      cut = i + 1;
+      break;
+    }
+  }
+  const remainder = lines.slice(cut).join(`
+`);
+  const current = await readRaw(path);
+  const appended = current.length > before.length ? current.slice(before.length) : "";
+  const text = `${remainder}${appended}`;
+  if (text.trim().length === 0) {
+    await rm(path, { force: true });
+    return;
+  }
+  await writeFile2(path, text.endsWith(`
+`) ? text : `${text}
+`);
+}
+async function flush(client) {
+  const path = queuePath();
+  const before = await readRaw(path);
+  const events = [];
+  for (const raw of before.split(`
+`)) {
+    if (raw.trim().length === 0)
+      continue;
+    const event = parseLine(raw);
+    if (event)
+      events.push(event);
+  }
+  if (events.length === 0) {
+    if (before.trim().length > 0)
+      await rm(path, { force: true });
+    return { sent: 0, remaining: 0 };
+  }
+  let sent = 0;
+  try {
+    for (let i = 0;i < events.length; i += USAGE_BATCH_MAX) {
+      const batch = events.slice(i, i + USAGE_BATCH_MAX);
+      await client.usage.record.mutate({ events: batch });
+      sent += batch.length;
+    }
+  } catch {}
+  if (sent > 0)
+    await keepFrom(path, before, sent);
+  return { sent, remaining: events.length - sent };
+}
+function trackingDisabledByEnv() {
+  const value = process.env.YOURSKILLS_NO_TRACK;
+  return value !== undefined && value !== "" && value !== "0";
+}
+async function trackingEnabled() {
+  if (trackingDisabledByEnv())
+    return false;
+  return (await readConfig()).track === true;
+}
+async function flushQuietly(server) {
+  try {
+    if (!await trackingEnabled())
+      return 0;
+    if ((await readQueue()).length === 0)
+      return 0;
+    const { sent } = await flush(await createClient(server));
+    return sent;
+  } catch {
+    return 0;
+  }
+}
+// src/hooks/settings.ts
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+function binaryName(command) {
+  const parts = command.split(/[\\/]/);
+  return (parts[parts.length - 1] ?? "").replace(/\.(js|mjs|cjs|exe)$/i, "");
+}
+function isOurCommand(command) {
+  if (typeof command !== "string")
+    return false;
+  const match = command.trim().match(/^(?:"([^"]+)"|'([^']+)'|(\S+))\s+hook\s+\S/);
+  if (!match)
+    return false;
+  return binaryName(match[1] ?? match[2] ?? match[3] ?? "") === BINARY;
+}
+function groupIsOurs(group) {
+  return (group.hooks ?? []).some((hook) => isOurCommand(hook.command));
+}
+function addHooks(settings, entries) {
+  let next = { ...settings };
+  for (const entry of entries) {
+    const hooks = { ...next.hooks ?? {} };
+    const groups = [...hooks[entry.event] ?? []];
+    const ours = groups.findIndex((group) => group.matcher === entry.matcher && groupIsOurs(group));
+    if (ours === -1) {
+      groups.push({
+        matcher: entry.matcher,
+        hooks: [{ type: "command", command: entry.command }]
+      });
+    } else {
+      const group = groups[ours];
+      const commands = [...group.hooks ?? []];
+      if (commands.some((hook) => hook.command === entry.command))
+        continue;
+      commands.push({ type: "command", command: entry.command });
+      groups[ours] = { ...group, hooks: commands };
+    }
+    hooks[entry.event] = groups;
+    next = { ...next, hooks };
+  }
+  return next;
+}
+function removeHooks(settings) {
+  if (!settings.hooks || typeof settings.hooks !== "object")
+    return { ...settings };
+  const hooks = {};
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(groups)) {
+      hooks[event] = groups;
+      continue;
+    }
+    const kept = [];
+    let changed = false;
+    for (const group of groups) {
+      const commands = group?.hooks;
+      if (!Array.isArray(commands) || !groupIsOurs(group)) {
+        kept.push(group);
+        continue;
+      }
+      changed = true;
+      const rest = commands.filter((hook) => !isOurCommand(hook.command));
+      if (rest.length > 0)
+        kept.push({ ...group, hooks: rest });
+    }
+    if (!changed) {
+      hooks[event] = groups;
+      continue;
+    }
+    if (kept.length > 0)
+      hooks[event] = kept;
+  }
+  return { ...settings, hooks };
+}
+function registeredEntries(settings, entries) {
+  return entries.filter((entry) => (settings.hooks?.[entry.event] ?? []).some((group) => group.matcher === entry.matcher && (group.hooks ?? []).some((hook) => hook.command === entry.command)));
+}
+function detectIndent(text) {
+  const match = text.match(/\n([\t ]+)\S/);
+  if (!match?.[1])
+    return "  ";
+  return match[1].includes("\t") ? "\t" : match[1];
+}
+async function readSettingsFile(path) {
+  let text;
+  try {
+    text = await readFile4(path, "utf8");
+  } catch {
+    return { ok: true, settings: {}, indent: "  ", existed: false };
+  }
+  if (text.trim().length === 0) {
+    return { ok: true, settings: {}, indent: "  ", existed: true };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `${path}: not valid JSON (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, error: `${path}: not a JSON object` };
+  }
+  return {
+    ok: true,
+    settings: parsed,
+    indent: detectIndent(text),
+    existed: true
+  };
+}
+function serialiseSettings(settings, indent) {
+  return `${JSON.stringify(settings, null, indent)}
+`;
+}
+async function writeSettingsFile(path, settings, indent) {
+  mkdirSync4(dirname5(path), { recursive: true });
+  await writeFile3(path, serialiseSettings(settings, indent));
+}
+
+// src/hooks/ensure.ts
+async function registerInto(adapter) {
+  const wanted = adapter.entries.filter((entry) => entry.kind === "update-check");
+  if (wanted.length === 0)
+    return null;
+  const path = adapter.settingsPath();
+  if (!path)
+    return null;
+  if (!existsSync3(adapter.home()))
+    return null;
+  const file = await readSettingsFile(path);
+  if (!file.ok)
+    return null;
+  const merged = addHooks(file.settings, wanted);
+  if (serialiseSettings(merged, file.indent) === serialiseSettings(file.settings, file.indent)) {
+    return null;
+  }
+  await writeSettingsFile(path, merged, file.indent);
+  return { agent: adapter.agent, path, entries: wanted };
+}
+function linesFor(registered) {
+  const lines = [
+    "yourskills registered its update-check hook so your agent can tell you when an installed skill has moved:"
+  ];
+  for (const { agent, path, entries } of registered) {
+    for (const entry of entries) {
+      lines.push(`  ${agent}  ${entry.event}(${entry.matcher})  ${path}`);
+    }
+  }
+  lines.push("  undo any time with `yourskills hooks uninstall`");
+  if (!trackingDisabledByEnv()) {
+    lines.push("  usage counting stays off; `yourskills hooks install --track` turns it on");
+  }
+  return lines;
+}
+async function ensureHooksRegistered() {
+  try {
+    const config = await readConfig();
+    if (config.hooksOffered)
+      return [];
+    if (!config.token)
+      return [];
+    const registered = [];
+    for (const adapter of HOOK_ADAPTERS) {
+      try {
+        const result = await registerInto(adapter);
+        if (result)
+          registered.push(result);
+      } catch {}
+    }
+    await writeConfig({ ...config, hooksOffered: new Date().toISOString() });
+    return registered.length > 0 ? linesFor(registered) : [];
+  } catch {
+    return [];
+  }
+}
+// src/hooks/install.ts
+import { existsSync as existsSync4 } from "node:fs";
+var PAYLOAD_DISCLOSURE = [
+  { mark: "none", text: "Usage tracking sends, once per skill invocation:" },
+  { mark: "none", text: "  skillExternalId", note: "the skill's registry id" },
+  { mark: "none", text: "  ref", note: "the commit you installed it at" },
+  { mark: "none", text: "  agent", note: "which agent ran it" },
+  { mark: "none", text: "  occurredAt", note: "when it ran" },
+  {
+    mark: "none",
+    text: "  (nothing else)",
+    note: "the server adds a keyed hash of you; the CLI never sends a user id"
+  }
+];
+function trackNote(track) {
+  if (trackingDisabledByEnv())
+    return "off (YOURSKILLS_NO_TRACK is set)";
+  return track ? "on" : "off — enable with `yourskills hooks install --track`";
+}
+function selectAdapters(agent) {
+  if (agent) {
+    const found = adapterFor(agent);
+    return found ? { adapters: [found], unknown: [] } : { adapters: [], unknown: [agent] };
+  }
+  return {
+    adapters: HOOK_ADAPTERS.filter((a) => existsSync4(a.home())),
+    unknown: []
+  };
+}
+async function pinnedAdapters() {
+  const pinned = await resolveAgents();
+  if (pinned.length === 0)
+    return null;
+  const adapters = pinned.map((name) => adapterFor(name)).filter((a) => a !== undefined);
+  return adapters.length > 0 ? adapters : null;
+}
+async function installInto(adapter, optedIn) {
+  const path = adapter.settingsPath();
+  const result = {
+    agent: adapter.agent,
+    path,
+    installed: [],
+    already: [],
+    skipped: []
+  };
+  if (!path) {
+    for (const kind of adapter.supports) {
+      result.skipped.push({
+        kind,
+        why: adapter.limitation ?? "not supported yet"
+      });
+    }
+    return result;
+  }
+  const wanted = [];
+  for (const entry of adapter.entries) {
+    if (entry.kind === "usage" && !optedIn) {
+      result.skipped.push({ kind: entry.kind, why: trackNote(false) });
+      continue;
+    }
+    wanted.push(entry);
+  }
+  const file = await readSettingsFile(path);
+  if (!file.ok) {
+    result.error = file.error;
+    return result;
+  }
+  const present = new Set(registeredEntries(file.settings, wanted).map((entry) => entry.kind));
+  for (const entry of wanted) {
+    if (present.has(entry.kind))
+      result.already.push(entry.kind);
+    else
+      result.installed.push(entry.kind);
+  }
+  const merged = addHooks(file.settings, wanted);
+  if (serialiseSettings(merged, file.indent) !== serialiseSettings(file.settings, file.indent)) {
+    await writeSettingsFile(path, merged, file.indent);
+  }
+  return result;
+}
+function linesFor2(result) {
+  const lines = [];
+  if (result.error) {
+    lines.push({
+      mark: "fail",
+      text: `${result.agent}: left untouched`,
+      note: result.error
+    });
+    return lines;
+  }
+  for (const kind of result.installed) {
+    lines.push({
+      mark: "ok",
+      text: `${result.agent}  ${kind}`,
+      note: result.path ?? ""
+    });
+  }
+  for (const kind of result.already) {
+    lines.push({
+      mark: "ok",
+      text: `${result.agent}  ${kind}`,
+      note: `already registered  ${result.path ?? ""}`.trim()
+    });
+  }
+  for (const skip of result.skipped) {
+    lines.push({
+      mark: "pending",
+      text: `${result.agent}  ${skip.kind}`,
+      note: `skipped: ${skip.why}`
+    });
+  }
+  return lines;
+}
+async function hooksInstall(opts = {}) {
+  if (opts.track !== undefined) {
+    const config2 = await readConfig();
+    await writeConfig({ ...config2, track: opts.track });
+  }
+  const config = await readConfig();
+  const optedIn = !trackingDisabledByEnv() && config.track === true;
+  const { adapters: selected, unknown } = selectAdapters(opts.agent);
+  const adapters = opts.agent === undefined ? await pinnedAdapters() ?? selected : selected;
+  const lines = [...PAYLOAD_DISCLOSURE];
+  lines.push({ mark: "none", text: "tracking", note: trackNote(optedIn) });
+  for (const agent of unknown) {
+    lines.push({
+      mark: "fail",
+      text: agent,
+      note: "no yourskills hook support — see `yourskills hooks status`"
+    });
+  }
+  const results = [];
+  for (const adapter of adapters) {
+    const result = await installInto(adapter, optedIn);
+    results.push(result);
+    lines.push(...linesFor2(result));
+  }
+  if (adapters.length === 0 && unknown.length === 0) {
+    lines.push({
+      mark: "pending",
+      text: "No agent found that can carry yourskills hooks.",
+      note: "pin one with `yourskills config set agents claude-code`"
+    });
+  }
+  return {
+    title: "hooks install",
+    lines,
+    json: { track: optedIn, agents: results, unknown },
+    failed: unknown.length > 0 || results.some((r) => r.error !== undefined)
+  };
+}
+async function hooksUninstall(opts = {}) {
+  const { adapters: selected, unknown } = selectAdapters(opts.agent);
+  const adapters = opts.agent ? selected : HOOK_ADAPTERS;
+  const lines = [];
+  const results = [];
+  for (const agent of unknown) {
+    lines.push({ mark: "fail", text: agent, note: "unknown agent" });
+  }
+  for (const adapter of adapters) {
+    const path = adapter.settingsPath();
+    if (!path)
+      continue;
+    const file = await readSettingsFile(path);
+    if (!file.ok) {
+      results.push({
+        agent: adapter.agent,
+        path,
+        removed: false,
+        error: file.error
+      });
+      lines.push({
+        mark: "fail",
+        text: `${adapter.agent}: left untouched`,
+        note: file.error
+      });
+      continue;
+    }
+    const stripped = removeHooks(file.settings);
+    const changed = serialiseSettings(stripped, file.indent) !== serialiseSettings(file.settings, file.indent);
+    if (changed)
+      await writeSettingsFile(path, stripped, file.indent);
+    results.push({ agent: adapter.agent, path, removed: changed });
+    lines.push({
+      mark: changed ? "ok" : "none",
+      text: `${adapter.agent}  ${changed ? "removed" : "nothing registered"}`,
+      note: path
+    });
+  }
+  return {
+    title: "hooks uninstall",
+    lines,
+    json: { agents: results, unknown },
+    failed: unknown.length > 0 || results.some((r) => r.error !== undefined)
+  };
+}
+async function hooksStatus() {
+  const config = await readConfig();
+  const optedIn = !trackingDisabledByEnv() && config.track === true;
+  const lines = [
+    { mark: "none", text: "tracking", note: trackNote(optedIn) }
+  ];
+  const agents2 = [];
+  for (const agent of agentsToReport(config.agents ?? [])) {
+    const adapter = adapterFor(agent);
+    if (!adapter) {
+      lines.push({
+        mark: "none",
+        text: agent,
+        note: "no yourskills hook support"
+      });
+      agents2.push({ agent, supported: false });
+      continue;
+    }
+    const path = adapter.settingsPath();
+    if (!path) {
+      lines.push({
+        mark: "none",
+        text: agent,
+        note: adapter.limitation ?? "not supported yet"
+      });
+      agents2.push({
+        agent,
+        supported: false,
+        supports: adapter.supports,
+        limitation: adapter.limitation
+      });
+      continue;
+    }
+    const file = await readSettingsFile(path);
+    if (!file.ok) {
+      lines.push({ mark: "fail", text: agent, note: file.error });
+      agents2.push({ agent, supported: true, path, error: file.error });
+      continue;
+    }
+    const registered = new Set(registeredEntries(file.settings, adapter.entries).map((e) => e.kind));
+    for (const entry of adapter.entries) {
+      const on = registered.has(entry.kind);
+      lines.push({
+        mark: on ? "ok" : "pending",
+        text: `${agent}  ${entry.kind}`,
+        note: on ? `${entry.event}(${entry.matcher})  ${path}` : "not registered — run `yourskills hooks install`"
+      });
+    }
+    agents2.push({
+      agent,
+      supported: true,
+      path,
+      registered: [...registered],
+      supports: adapter.supports
+    });
+  }
+  return {
+    title: "hooks status",
+    lines,
+    json: { track: optedIn, agents: agents2 }
+  };
+}
+// ../../packages/bundles/src/drift.ts
+var SHORT_SHA = 7;
+function namesSameCommit(prefix, full) {
+  const short = prefix.trim().toLowerCase();
+  const long = full.trim().toLowerCase();
+  if (short === long)
+    return true;
+  return short.length >= SHORT_SHA && long.startsWith(short);
+}
+
+// src/installed/installed.ts
+var shortRef = (ref) => ref.slice(0, SHORT_SHA);
+function installedRows(nearest) {
+  return Object.values(nearest.manifest.skills).map((entry) => ({
+    name: entry.name,
+    ref: entry.ref,
+    bundle: entry.bundle ?? null,
+    scope: nearest.manifest.scope
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function columns(rows) {
+  const names = Math.max(...rows.map((r) => r.name.length));
+  const bundles = Math.max(...rows.map((r) => (r.bundle ?? "-").length));
+  return rows.map((row) => ({
+    mark: "none",
+    text: `${row.name.padEnd(names)}  ${shortRef(row.ref)}`,
+    note: `${(row.bundle ?? "-").padEnd(bundles)}  ${row.scope}`
+  }));
+}
+function installedReport(nearest) {
+  const rows = installedRows(nearest);
+  const lines = rows.length === 0 ? [
+    {
+      mark: "none",
+      text: "Nothing installed. Run `yourskills bundle <name>` or `yourskills add <skill>`.",
+      note: nearest.path
+    }
+  ] : columns(rows);
+  return {
+    title: "installed",
+    lines,
+    json: {
+      manifest: nearest.path,
+      scope: nearest.manifest.scope,
+      skills: rows
+    }
+  };
+}
+// src/installed/outdated.ts
+function hasMoved(installed, available) {
+  return !(namesSameCommit(available, installed) || namesSameCommit(installed, available));
+}
+function drift(manifest, pins, catalog) {
+  const byExternalId = new Map(catalog.map((row) => [row.externalId, row]));
+  const byName = new Map(catalog.map((row) => [row.name, row]));
+  const moved = [];
+  const unknown = [];
+  for (const entry of Object.values(manifest.skills)) {
+    const row = byExternalId.get(entry.externalId) ?? byName.get(entry.name);
+    if (!row) {
+      unknown.push(entry.name);
+      continue;
+    }
+    const pin = entry.bundle ? pins.find((p) => p.bundle === entry.bundle && p.skillId === row.id) : undefined;
+    const available = pin?.pinnedSha ?? row.currentSha;
+    if (!hasMoved(entry.ref, available))
+      continue;
+    moved.push({
+      name: entry.name,
+      bundle: entry.bundle ?? null,
+      installed: entry.ref,
+      available,
+      deprecated: pin?.deprecated ?? row.status === "deprecated"
+    });
+  }
+  moved.sort((a, b) => a.name.localeCompare(b.name));
+  return { moved, unknown };
+}
+async function outdatedReport(client, nearest, quiet = false) {
+  let pins;
+  let catalog;
+  try {
+    [pins, catalog] = await Promise.all([
+      client.bundles.pins.query(),
+      client.skills.list.query({})
+    ]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      title: "outdated",
+      lines: [
+        { mark: "fail", text: "Could not reach the registry.", note: message }
+      ],
+      json: { manifest: nearest.path, error: message },
+      silent: quiet
+    };
+  }
+  const report = drift(nearest.manifest, pins, catalog);
+  const lines = report.moved.map((row) => ({
+    mark: "pending",
+    text: `${row.name}  ${shortRef(row.installed)} -> ${shortRef(row.available)}`,
+    note: [row.bundle ?? "-", row.deprecated ? "[deprecated]" : ""].filter(Boolean).join("  ")
+  }));
+  for (const name of report.unknown) {
+    lines.push({
+      mark: "fail",
+      text: name,
+      note: "no longer in your registry"
+    });
+  }
+  const current = report.moved.length === 0 && report.unknown.length === 0;
+  if (current && !quiet) {
+    lines.push({
+      mark: "ok",
+      text: "Everything is at the ref your registry pins."
+    });
+  }
+  return {
+    title: "outdated",
+    lines,
+    json: {
+      manifest: nearest.path,
+      outdated: report.moved,
+      unknown: report.unknown
+    },
+    silent: quiet && current
+  };
+}
+// src/hooks/run.ts
+function isHookEventName(value) {
+  return value === "session-start" || value === "post-tool-use";
+}
+var STDIN_BUDGET_MS = 2000;
+var SESSION_BUDGET_MS = 5000;
+var DAY_MS = 86400000;
+async function readStdin() {
+  if (process.stdin.isTTY)
+    return {};
+  const text = await Promise.race([
+    (async () => {
+      let raw = "";
+      process.stdin.setEncoding("utf8");
+      for await (const chunk of process.stdin)
+        raw += chunk;
+      return raw;
+    })(),
+    new Promise((resolve3) => {
+      const timer = setTimeout(() => resolve3(""), STDIN_BUDGET_MS);
+      timer.unref?.();
+    })
+  ]);
+  if (text.trim().length === 0)
+    return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+async function lookup(name, cwd) {
+  const nearest = await nearestManifest(undefined, cwd);
+  const found = nearest.manifest.skills[name];
+  if (found)
+    return found;
+  if (nearest.scope === "global")
+    return;
+  const global = readManifest(manifestPathFor("global"));
+  return global.skills[name];
+}
+async function queueInvocation(payload, now = new Date) {
+  if (!await trackingEnabled())
+    return null;
+  const name = payload.tool_input?.skill;
+  if (typeof name !== "string" || name.length === 0)
+    return null;
+  const entry = await lookup(name, payload.cwd);
+  if (!entry)
+    return null;
+  const event = {
+    skillExternalId: entry.externalId,
+    ref: entry.ref,
+    agent: agentForEvent("usage", "PostToolUse"),
+    occurredAt: now.toISOString()
+  };
+  await appendEvent(event);
+  return event;
+}
+function updateCheckDue(last, now = Date.now()) {
+  if (!last)
+    return true;
+  const at = Date.parse(last);
+  return Number.isNaN(at) || now - at >= DAY_MS;
+}
+async function sessionStart() {
+  const config = await readConfig();
+  if (!updateCheckDue(config.lastUpdateCheck))
+    return;
+  await writeConfig({ ...config, lastUpdateCheck: new Date().toISOString() });
+  const client = await createClient();
+  const nearest = await nearestManifest();
+  const report = await outdatedReport(client, nearest, true);
+  if (!report.silent && report.lines.length > 0) {
+    const moved = report.json.outdated?.length ?? 0;
+    if (moved > 0) {
+      console.log(`yourskills: ${moved} skill(s) behind your registry — run \`yourskills update\``);
+    }
+  }
+  if (await trackingEnabled())
+    await flush(client);
+}
+async function runHook(event) {
+  try {
+    const payload = await readStdin();
+    if (event === "post-tool-use")
+      await queueInvocation(payload);
+    else
+      await withBudget(sessionStart(), SESSION_BUDGET_MS);
+  } catch {}
+  process.exitCode = 0;
+}
+function withBudget(work, ms) {
+  return Promise.race([
+    work,
+    new Promise((resolve3) => {
+      const timer = setTimeout(() => resolve3(undefined), ms);
+      timer.unref?.();
+    })
+  ]);
+}
+// src/org/org.ts
+var authBase2 = (base) => `${base.replace(/\/$/, "")}/api/auth`;
+async function activeOrganizationId(base, token) {
+  const res = await fetch(`${authBase2(base)}/get-session`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (!res.ok)
+    return null;
+  const body = await res.json();
+  return body?.session?.activeOrganizationId ?? null;
+}
+async function listOrganizations(base, token) {
+  let res;
+  try {
+    res = await fetch(`${authBase2(base)}/organization/list`, {
+      headers: { authorization: `Bearer ${token}` }
+    });
+  } catch (error) {
+    throw new Error(`Could not reach ${base}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!res.ok) {
+    throw new Error(`Could not list organizations: ${res.status} ${res.statusText}`);
+  }
+  return await res.json();
+}
+function rows(orgs, active) {
+  if (orgs.length === 0) {
+    return [
+      {
+        mark: "none",
+        text: "You are not a member of any organization yet."
+      }
+    ];
+  }
+  const width = Math.max(...orgs.map((o) => o.name.length));
+  return orgs.map((org) => ({
+    mark: org.id === active ? "ok" : "none",
+    text: `${org.id === active ? "" : "  "}${org.name.padEnd(width)}`,
+    note: org.slug ?? org.id
+  }));
+}
+async function orgListReport(server) {
+  const { token, base } = await requireToken(server);
+  const [orgs, active] = await Promise.all([
+    listOrganizations(base, token),
+    activeOrganizationId(base, token)
+  ]);
+  return {
+    title: "org",
+    lines: rows(orgs, active),
+    json: {
+      active,
+      organizations: orgs.map((o) => ({
+        id: o.id,
+        name: o.name,
+        slug: o.slug ?? null,
+        active: o.id === active
+      }))
+    }
+  };
+}
+async function orgSwitchReport(name, server) {
+  const { token, base } = await requireToken(server);
+  const orgs = await listOrganizations(base, token);
+  const wanted = name.toLowerCase();
+  const match = orgs.find((o) => o.name.toLowerCase() === wanted || o.slug?.toLowerCase() === wanted);
+  if (!match) {
+    return {
+      title: "org",
+      lines: [
+        {
+          mark: "fail",
+          text: `No organization called ${name}.`,
+          note: orgs.map((o) => o.name).join(", ") || "you are in none"
+        }
+      ],
+      json: { error: `unknown organization: ${name}` },
+      failed: true
+    };
+  }
+  const res = await fetch(`${authBase2(base)}/organization/set-active`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ organizationId: match.id })
+  });
+  if (!res.ok) {
+    const detail = (await res.text()).slice(0, 200);
+    return {
+      title: "org",
+      lines: [
+        {
+          mark: "fail",
+          text: `Could not switch to ${match.name}.`,
+          note: detail || `${res.status} ${res.statusText}`
+        }
+      ],
+      json: { error: detail || res.statusText },
+      failed: true
+    };
+  }
+  return {
+    title: "org",
+    lines: [{ mark: "ok", text: `Active organization: ${match.name}` }],
+    json: { active: match.id, name: match.name, slug: match.slug ?? null }
+  };
+}
+// src/report.ts
+function plainLine(line2, glyph) {
+  const head = line2.mark === "none" ? "" : `${glyph[line2.mark]} `;
+  return `${head}${line2.text}${line2.note ? `  ${line2.note}` : ""}`;
+}
+// src/shell/commands.ts
+function paletteGroups() {
+  return [
+    {
+      group: "Catalog",
+      items: [
+        { value: "catalog.bundles", label: "browse bundles", hint: "browse" },
+        { value: "catalog.skills", label: "browse skills", hint: "list" },
+        { value: "catalog.search", label: "search", hint: "search <query>" }
+      ]
+    },
+    {
+      group: "Installed",
+      items: [
+        { value: "installed.list", label: "list installed", hint: "installed" },
+        {
+          value: "installed.update",
+          label: "update all",
+          hint: "update --all"
+        },
+        { value: "installed.outdated", label: "outdated", hint: "outdated" },
+        { value: "installed.remove", label: "remove", hint: "remove <skill>" }
+      ]
+    },
+    {
+      group: "Account",
+      items: [
+        { value: "account.login", label: "login", hint: "login" },
+        { value: "account.logout", label: "logout", hint: "logout" },
+        { value: "account.whoami", label: "whoami", hint: "whoami" },
+        { value: "account.org", label: "switch org", hint: "org <name>" }
+      ]
+    },
+    {
+      group: "Setup",
+      items: [
+        {
+          value: "setup.scope",
+          label: "scope",
+          hint: "config set scope project"
+        },
+        {
+          value: "setup.agents",
+          label: "agents",
+          hint: "config set agents <name>"
+        },
+        { value: "setup.doctor", label: "doctor", hint: "doctor" }
+      ]
+    }
+  ];
+}
+// src/shell/screens/home.tsx
+import { Box as Box10, Text as Text12, useApp as useApp7, useInput as useInput3 } from "ink";
+import { useCallback as useCallback3, useEffect as useEffect8, useMemo as useMemo3, useRef, useState as useState8 } from "react";
+// src/screens.tsx
+import { Box as Box9, Text as Text11, useApp as useApp6 } from "ink";
+import { useEffect as useEffect7, useState as useState7 } from "react";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var MARKS = {
+  ok: { glyph: mark.ok, color: "green" },
+  fail: { glyph: mark.fail, color: tone.danger },
+  pending: { glyph: mark.pending, color: tone.notice },
+  none: { glyph: "" }
+};
+function ReportRow({ line: line2, width }) {
+  const { glyph, color } = MARKS[line2.mark];
+  const head = line2.mark === "none" ? "" : `${glyph} `;
+  const room = width - FRAME_CHROME - head.length;
+  return /* @__PURE__ */ jsxs10(Text11, {
+    children: [
+      head ? /* @__PURE__ */ jsx11(Text11, {
+        color,
+        children: head
+      }) : null,
+      /* @__PURE__ */ jsx11(Text11, {
+        children: clip(line2.text, room)
+      }),
+      line2.note ? /* @__PURE__ */ jsx11(Text11, {
+        dimColor: true,
+        children: clip(`  ${line2.note}`, Math.max(room - line2.text.length, 0))
+      }) : null
+    ]
+  });
+}
+function ReportScreen({
+  title,
+  load,
+  onError,
+  onReport,
+  exitWhenDone = true
+}) {
+  const { exit } = useApp6();
+  const width = useFrameWidth();
+  const [report, setReport] = useState7(null);
+  useEffect7(() => {
+    let live = true;
+    load().then((result) => {
+      if (!live)
+        return;
+      setReport(result);
+      onReport?.(result);
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [load, onError, onReport]);
+  useEffect7(() => {
+    if (report && exitWhenDone)
+      exit();
+  }, [report, exit, exitWhenDone]);
+  return /* @__PURE__ */ jsx11(Frame, {
+    title,
+    width,
+    children: report ? /* @__PURE__ */ jsx11(Box9, {
+      flexDirection: "column",
+      children: report.lines.map((line2) => /* @__PURE__ */ jsx11(ReportRow, {
+        line: line2,
+        width
+      }, `${line2.mark}:${line2.text}`))
+    }) : /* @__PURE__ */ jsxs10(Text11, {
+      children: [
+        /* @__PURE__ */ jsx11(Spinner, {}),
+        /* @__PURE__ */ jsx11(Text11, {
+          dimColor: true,
+          children: " Working..."
+        })
+      ]
+    })
+  });
+}
+
+// src/shell/screens/home.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+function failure(title, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    title,
+    lines: [{ mark: "fail", text: message }],
+    json: { error: message }
+  };
+}
+function identityReport(who) {
+  const label = (text) => text.padEnd(7);
+  return {
+    title: "whoami",
+    lines: [
+      { mark: "none", text: `${label("user")}${who.user}` },
+      {
+        mark: "none",
+        text: `${label("org")}${who.org ?? "none — set an active organization in the web UI"}`
+      },
+      { mark: "none", text: `${label("server")}${who.server}` }
+    ],
+    json: { ...who }
+  };
+}
+function HomeScreen({
+  opts,
+  server,
+  openClient,
+  onError,
+  onSummary
+}) {
+  const { exit } = useApp7();
+  const width = useFrameWidth();
+  const groups = useMemo3(() => paletteGroups(), []);
+  const [query, setQuery] = useState8("");
+  const [cursor, setCursor] = useState8(0);
+  const [route, setRoute] = useState8(null);
+  const [client, setClient] = useState8(null);
+  const [refused, setRefused] = useState8(null);
+  const rows2 = useMemo3(() => flattenCommands(filterCommands(groups, query)), [groups, query]);
+  useEffect8(() => {
+    setCursor((c) => Math.max(0, Math.min(c, rows2.length - 1)));
+  }, [rows2.length]);
+  const held = useRef(null);
+  const connect = useCallback3(async () => {
+    held.current ??= await openClient();
+    return held.current;
+  }, [openClient]);
+  const answering = useCallback3((title, load) => ({
+    kind: "report",
+    title,
+    load: async () => {
+      try {
+        return await load();
+      } catch (error) {
+        return failure(title, error);
+      }
+    }
+  }), []);
+  const routeFor = useCallback3((value) => {
+    switch (value) {
+      case "catalog.bundles":
+      case "catalog.skills":
+      case "catalog.search":
+        return { kind: "browse" };
+      case "installed.list":
+        return answering("installed", async () => installedReport(await nearestManifest(opts.scope)));
+      case "installed.update":
+        return {
+          kind: "install",
+          title: "update",
+          stream: async function* stream() {
+            const nearest = await nearestManifest(opts.scope);
+            yield* updateTracked(await connect(), nearest.manifest, opts, true);
+          }
+        };
+      case "installed.outdated":
+        return answering("outdated", async () => outdatedReport(await connect(), await nearestManifest(opts.scope)));
+      case "installed.remove":
+        return answering("remove", async () => {
+          const report = installedReport(await nearestManifest(opts.scope));
+          return {
+            ...report,
+            title: "remove",
+            lines: [
+              {
+                mark: "none",
+                text: "Run `yourskills remove <skill>` to delete one."
+              },
+              ...report.lines
+            ]
+          };
+        });
+      case "account.login":
+        return { kind: "login" };
+      case "account.logout":
+        return answering("logout", async () => {
+          await logout();
+          held.current = null;
+          setClient(null);
+          return {
+            title: "logout",
+            lines: [{ mark: "ok", text: "Logged out." }],
+            json: { ok: true }
+          };
+        });
+      case "account.whoami":
+        return answering("whoami", async () => identityReport(await whoami(server)));
+      case "account.org":
+        return answering("org", () => orgListReport(server));
+      case "setup.scope":
+        return answering("scope", () => configGet("scope"));
+      case "setup.agents":
+        return answering("agents", () => configGet("agents"));
+      case "setup.doctor":
+        return answering("doctor", async () => doctorReport(await nearestManifest(opts.scope), server));
+    }
+  }, [answering, connect, opts, server]);
+  const activate = useCallback3(() => {
+    const item = rows2[cursor];
+    if (!item)
+      return;
+    item.onSelect?.();
+    setRoute(routeFor(item.value));
+  }, [rows2, cursor, routeFor]);
+  const back = useCallback3(() => {
+    setRoute(null);
+    setRefused(null);
+  }, []);
+  useEffect8(() => {
+    if (route?.kind !== "browse" || client || refused)
+      return;
+    let live = true;
+    connect().then((opened) => {
+      if (live)
+        setClient(opened);
+    }).catch((error) => {
+      if (live)
+        setRefused(error instanceof Error ? error.message : String(error));
+    });
+    return () => {
+      live = false;
+    };
+  }, [route, client, refused, connect]);
+  const browsing = route?.kind === "browse" && client !== null;
+  useInput3((input, key) => {
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+    } else if (key.downArrow) {
+      setCursor((c) => Math.min(rows2.length - 1, c + 1));
+    } else if (key.return) {
+      activate();
+    } else if (key.escape) {
+      if (query.length > 0)
+        setQuery("");
+      else
+        exit();
+    } else if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setCursor(0);
+    } else if (input && !key.ctrl && !key.meta) {
+      setQuery((q) => q + input);
+      setCursor(0);
+    }
+  }, { isActive: route === null });
+  useInput3((_input, key) => {
+    if (key.escape)
+      back();
+  }, { isActive: route !== null && !browsing });
+  if (route?.kind === "login") {
+    return /* @__PURE__ */ jsx12(LoginScreen, {
+      onError,
+      onDone: back
+    });
+  }
+  if (route?.kind === "report") {
+    return /* @__PURE__ */ jsx12(ReportScreen, {
+      title: route.title,
+      load: route.load,
+      onError,
+      exitWhenDone: false
+    });
+  }
+  if (route?.kind === "install") {
+    return /* @__PURE__ */ jsx12(Installer, {
+      title: route.title,
+      stream: route.stream,
+      exitWhenDone: false,
+      onDone: onSummary
+    });
+  }
+  if (route?.kind === "browse") {
+    if (refused) {
+      return /* @__PURE__ */ jsx12(Frame, {
+        title: "browse",
+        width,
+        children: /* @__PURE__ */ jsxs11(Box10, {
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsxs11(Text12, {
+              children: [
+                /* @__PURE__ */ jsx12(Text12, {
+                  color: tone.danger,
+                  children: mark.fail
+                }),
+                /* @__PURE__ */ jsx12(Text12, {
+                  children: ` ${refused}`
+                })
+              ]
+            }),
+            /* @__PURE__ */ jsx12(Text12, {
+              dimColor: true,
+              children: "Pick `login` from the palette, then try again."
+            })
+          ]
+        })
+      });
+    }
+    if (!client) {
+      return /* @__PURE__ */ jsx12(Frame, {
+        title: "browse",
+        width,
+        children: /* @__PURE__ */ jsxs11(Text12, {
+          children: [
+            /* @__PURE__ */ jsx12(Spinner, {}),
+            /* @__PURE__ */ jsx12(Text12, {
+              dimColor: true,
+              children: " Connecting..."
+            })
+          ]
+        })
+      });
+    }
+    return /* @__PURE__ */ jsx12(BrowserScreen, {
+      client,
+      opts,
+      onError,
+      onSummary,
+      onExit: back
+    });
+  }
+  return /* @__PURE__ */ jsxs11(Frame, {
+    title: "yourskills",
+    width,
+    children: [
+      /* @__PURE__ */ jsx12(CommandPalette, {
+        groups,
+        query,
+        cursor,
+        width
+      }),
+      /* @__PURE__ */ jsx12(Divider, {
+        width
+      }),
+      /* @__PURE__ */ jsx12(Hints, {
+        hints: [
+          ["^v", "move"],
+          ["enter", "open"],
+          ["esc", query ? "clear" : "quit"]
+        ]
+      })
+    ]
+  });
+}
+// src/args.ts
+var HELP = `yourskills — install skills from your organization's registry
+
+Usage: yourskills <command> [options]
+
+Commands:
+  (none)                  Open the command palette (every command, one keystroke away)
+  browse                  Browse and install interactively
+  login                   Device-flow login (RFC 8628)
+  logout                  Forget the stored session token
+  whoami                  Show the current user and active organization
+  org                     List your organizations, marking the active one
+  org <name>              Switch the active organization
+  list                    List every skill in your organization
+  search <query>          Search skills by name and description
+  bundle <name>           Install a role bundle (the default install path)
+  add <skill...>          Install individual skills
+  install <skill...>      The same thing, spelled the other way
+  install                 Re-install everything the nearest manifest records
+  remove <skill...>       Delete skills from disk and from the manifest
+  update <bundle>         Re-install a bundle at its currently pinned refs
+  update                  The same, for every bundle the manifest tracks
+  installed               List what the nearest manifest records
+  outdated                Report skills whose registry pin has moved
+  doctor                  Check the server, the session, the agents, the manifest
+  config get [key]        Show the stored settings, or one of them
+  config set <key> <val>  Set one: scope, agents, server, track
+  hooks status            Show which agents carry our hooks, and where
+  hooks install           Register them: an update check, and usage if opted in
+  hooks uninstall         Remove ours, leaving every other hook alone
+
+Options:
+  -g, --global            Install for the user (the default)
+  -p, --project           Install into this project, recorded in yourskills.json
+  -a, --agent <name>      Target agent (repeatable); omit to auto-detect
+      --all               update: refresh loose skills too, not only bundles
+  -q, --quiet             outdated: print nothing when everything is current
+      --track             hooks install: opt in to counting skill invocations
+      --no-track          hooks install: opt out again
+      --server <url>      Registry base URL for this invocation
+      --plain             Plain, greppable output; no frames, no colour
+      --json              Machine-readable output
+  -v, --version           Show the version
+  -h, --help              Show this help
+
+Environment:
+  YOURSKILLS_URL          Registry base URL (default localhost:3000)
+  YOURSKILLS_NO_TRACK     Set to 1 to disable usage counting outright`;
+function configCommand(rest) {
+  const [action, key, ...value] = rest;
+  if (action === undefined || action === "get") {
+    return { kind: "config", action: "get", ...key ? { key } : {} };
+  }
+  if (action !== "set") {
+    return {
+      kind: "error",
+      message: `config takes get or set, not ${action}: yourskills config get [key]`
+    };
+  }
+  if (!key) {
+    return {
+      kind: "error",
+      message: "config set needs a key: yourskills config set <key> <value>"
+    };
+  }
+  if (value.length === 0) {
+    return {
+      kind: "error",
+      message: `config set needs a value: yourskills config set ${key} <value>`
+    };
+  }
+  return { kind: "config", action: "set", key, value: value.join(" ") };
+}
+function hooksCommand(rest, agent, track) {
+  const action = rest[0] ?? "status";
+  if (action !== "install" && action !== "uninstall" && action !== "status") {
+    return {
+      kind: "error",
+      message: `hooks takes install, uninstall or status, not ${action}`
+    };
+  }
+  return {
+    kind: "hooks",
+    action,
+    ...agent ? { agent } : {},
+    ...track === undefined ? {} : { track }
+  };
+}
+function parseArgv(args, interactive = true) {
+  const opts = {};
+  const positional = [];
+  let plain = !interactive;
+  let json = false;
+  let all = false;
+  let quiet = false;
+  let server;
+  let track;
+  const done = (command2) => ({
+    command: command2,
+    output: { plain, json },
+    ...server ? { server } : {}
+  });
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help")
+      return done({ kind: "help" });
+    if (arg === "-v" || arg === "--version")
+      return done({ kind: "version" });
+    if (arg === "--plain") {
+      plain = true;
+    } else if (arg === "--json") {
+      json = true;
+      plain = true;
+    } else if (arg === "-g" || arg === "--global") {
+      opts.scope = "global";
+    } else if (arg === "-p" || arg === "--project") {
+      opts.scope = "project";
+    } else if (arg === "--all") {
+      all = true;
+    } else if (arg === "-q" || arg === "--quiet") {
+      quiet = true;
+    } else if (arg === "--track") {
+      track = true;
+    } else if (arg === "--no-track") {
+      track = false;
+    } else if (arg === "--server") {
+      const value = args[++i];
+      if (!value)
+        return done({ kind: "error", message: "--server requires a URL" });
+      server = value;
+    } else if (arg === "-a" || arg === "--agent") {
+      const value = args[++i];
+      if (!value)
+        return done({
+          kind: "error",
+          message: "--agent requires an agent name"
+        });
+      opts.agents = [...opts.agents ?? [], value];
+    } else if (arg.startsWith("-")) {
+      return done({ kind: "error", message: `Unknown option: ${arg}` });
+    } else {
+      positional.push(arg);
+    }
+  }
+  const [command, ...rest] = positional;
+  switch (command) {
+    case undefined:
+      return done(plain ? { kind: "help" } : { kind: "home" });
+    case "help":
+      return done({ kind: "help" });
+    case "version":
+      return done({ kind: "version" });
+    case "browse":
+      return done(plain ? {
+        kind: "error",
+        message: "browse needs a terminal; use `list` or `search` instead"
+      } : { kind: "browse" });
+    case "login":
+      return done({ kind: "login" });
+    case "logout":
+      return done({ kind: "logout" });
+    case "whoami":
+      return done({ kind: "whoami" });
+    case "list":
+      return done({ kind: "list" });
+    case "search":
+      return done(rest.length > 0 ? { kind: "search", query: rest.join(" ") } : {
+        kind: "error",
+        message: "search needs a query: yourskills search <query>"
+      });
+    case "add":
+      return done(rest.length > 0 ? { kind: "add", names: rest, opts } : {
+        kind: "error",
+        message: "add needs at least one skill: yourskills add <skill...>"
+      });
+    case "install":
+      return done(rest.length > 0 ? { kind: "add", names: rest, opts } : { kind: "install", opts });
+    case "remove":
+      return done(rest.length > 0 ? { kind: "remove", names: rest, opts } : {
+        kind: "error",
+        message: "remove needs at least one skill: yourskills remove <skill...>"
+      });
+    case "installed":
+      return done({ kind: "installed" });
+    case "outdated":
+      return done({ kind: "outdated", ...quiet ? { quiet: true } : {} });
+    case "doctor":
+      return done({ kind: "doctor" });
+    case "org":
+      return done(rest[0] ? { kind: "org", name: rest[0] } : { kind: "org" });
+    case "config":
+      return done(configCommand(rest));
+    case "hooks":
+      return done(hooksCommand(rest, opts.agents?.[0], track));
+    case "hook": {
+      const event = rest[0];
+      return done(event && isHookEventName(event) ? { kind: "hook", event } : {
+        kind: "error",
+        message: "hook takes session-start or post-tool-use"
+      });
+    }
+    case "bundle":
+      return done(rest[0] ? { kind: "bundle", name: rest[0], opts } : {
+        kind: "error",
+        message: "bundle needs a name: yourskills bundle <name>"
+      });
+    case "update":
+      return done({
+        kind: "update",
+        ...rest[0] ? { bundle: rest[0] } : {},
+        ...all ? { all: true } : {},
+        opts
+      });
+    default:
+      return done({ kind: "error", message: `Unknown command: ${command}` });
+  }
+}
+
+// src/client.ts
+import { createTRPCClient as createTRPCClient2, httpBatchLink as httpBatchLink2 } from "@trpc/client";
+async function createClient2(server) {
+  const { token, base } = await requireToken(server);
+  return createTRPCClient2({
+    links: [
+      httpBatchLink2({
+        url: `${base.replace(/\/$/, "")}/trpc`,
+        headers: () => ({ authorization: `Bearer ${token}` })
+      })
+    ]
+  });
+}
+
+// src/screens.tsx
+import { Box as Box11, Text as Text13, useApp as useApp8 } from "ink";
+import { useEffect as useEffect9, useState as useState9 } from "react";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+var HELP_COLUMN = 26;
+function WhoamiScreen({
+  load,
+  onError
+}) {
+  const { exit } = useApp8();
+  const width = useFrameWidth();
+  const [who, setWho] = useState9(null);
+  useEffect9(() => {
+    let live = true;
+    load().then((result) => {
+      if (!live)
+        return;
+      setWho(result);
+      exit();
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [load, exit, onError]);
+  if (!who) {
+    return /* @__PURE__ */ jsx13(Frame, {
+      title: "whoami",
+      width,
+      children: /* @__PURE__ */ jsxs12(Text13, {
+        children: [
+          /* @__PURE__ */ jsx13(Spinner, {}),
+          /* @__PURE__ */ jsx13(Text13, {
+            dimColor: true,
+            children: " Checking session..."
+          })
+        ]
+      })
+    });
+  }
+  return /* @__PURE__ */ jsx13(Frame, {
+    title: "whoami",
+    width,
+    children: /* @__PURE__ */ jsxs12(Box11, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs12(Text13, {
+          children: [
+            /* @__PURE__ */ jsx13(Text13, {
+              dimColor: true,
+              children: "user    "
+            }),
+            /* @__PURE__ */ jsx13(Text13, {
+              children: who.user
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsxs12(Text13, {
+          children: [
+            /* @__PURE__ */ jsx13(Text13, {
+              dimColor: true,
+              children: "org     "
+            }),
+            who.org ? /* @__PURE__ */ jsx13(Text13, {
+              children: who.org
+            }) : /* @__PURE__ */ jsx13(Text13, {
+              color: tone.notice,
+              children: "none — set an active organization in the web UI"
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsxs12(Text13, {
+          children: [
+            /* @__PURE__ */ jsx13(Text13, {
+              dimColor: true,
+              children: "server  "
+            }),
+            /* @__PURE__ */ jsx13(Text13, {
+              color: tone.primary,
+              children: who.server
+            })
+          ]
+        })
+      ]
+    })
+  });
+}
+function NoticeScreen({
+  title,
+  message
+}) {
+  const { exit } = useApp8();
+  const width = useFrameWidth();
+  useEffect9(exit, [exit]);
+  return /* @__PURE__ */ jsx13(Frame, {
+    title,
+    width,
+    children: /* @__PURE__ */ jsxs12(Text13, {
+      children: [
+        /* @__PURE__ */ jsx13(Text13, {
+          color: "green",
+          children: mark.ok
+        }),
+        /* @__PURE__ */ jsx13(Text13, {
+          children: ` ${message}`
+        })
+      ]
+    })
+  });
+}
+var MARKS2 = {
+  ok: { glyph: mark.ok, color: "green" },
+  fail: { glyph: mark.fail, color: tone.danger },
+  pending: { glyph: mark.pending, color: tone.notice },
+  none: { glyph: "" }
+};
+function ReportRow2({ line: line2, width }) {
+  const { glyph, color } = MARKS2[line2.mark];
+  const head = line2.mark === "none" ? "" : `${glyph} `;
+  const room = width - FRAME_CHROME - head.length;
+  return /* @__PURE__ */ jsxs12(Text13, {
+    children: [
+      head ? /* @__PURE__ */ jsx13(Text13, {
+        color,
+        children: head
+      }) : null,
+      /* @__PURE__ */ jsx13(Text13, {
+        children: clip(line2.text, room)
+      }),
+      line2.note ? /* @__PURE__ */ jsx13(Text13, {
+        dimColor: true,
+        children: clip(`  ${line2.note}`, Math.max(room - line2.text.length, 0))
+      }) : null
+    ]
+  });
+}
+function ReportScreen2({
+  title,
+  load,
+  onError,
+  onReport,
+  exitWhenDone = true
+}) {
+  const { exit } = useApp8();
+  const width = useFrameWidth();
+  const [report, setReport] = useState9(null);
+  useEffect9(() => {
+    let live = true;
+    load().then((result) => {
+      if (!live)
+        return;
+      setReport(result);
+      onReport?.(result);
+    }).catch((error) => {
+      if (live)
+        onError(error);
+    });
+    return () => {
+      live = false;
+    };
+  }, [load, onError, onReport]);
+  useEffect9(() => {
+    if (report && exitWhenDone)
+      exit();
+  }, [report, exit, exitWhenDone]);
+  return /* @__PURE__ */ jsx13(Frame, {
+    title,
+    width,
+    children: report ? /* @__PURE__ */ jsx13(Box11, {
+      flexDirection: "column",
+      children: report.lines.map((line2) => /* @__PURE__ */ jsx13(ReportRow2, {
+        line: line2,
+        width
+      }, `${line2.mark}:${line2.text}`))
+    }) : /* @__PURE__ */ jsxs12(Text13, {
+      children: [
+        /* @__PURE__ */ jsx13(Spinner, {}),
+        /* @__PURE__ */ jsx13(Text13, {
+          dimColor: true,
+          children: " Working..."
+        })
+      ]
+    })
+  });
+}
+function numberedLines(text) {
+  return text.split(`
+`).map((line2, i) => ({ id: `${i}:${line2}`, line: line2 }));
+}
+function HelpScreen({ text }) {
+  const { exit } = useApp8();
+  const width = useFrameWidth();
+  useEffect9(exit, [exit]);
+  return /* @__PURE__ */ jsx13(Frame, {
+    title: "yourskills",
+    width,
+    children: /* @__PURE__ */ jsx13(Box11, {
+      flexDirection: "column",
+      children: numberedLines(text).map(({ id, line: line2 }) => {
+        if (line2.length === 0)
+          return /* @__PURE__ */ jsx13(Blank, {}, id);
+        if (!line2.startsWith("  "))
+          return /* @__PURE__ */ jsx13(Text13, {
+            children: clip(line2, width - FRAME_CHROME)
+          }, id);
+        return /* @__PURE__ */ jsxs12(Text13, {
+          children: [
+            /* @__PURE__ */ jsx13(Text13, {
+              color: tone.primary,
+              children: line2.slice(0, HELP_COLUMN)
+            }),
+            /* @__PURE__ */ jsx13(Text13, {
+              dimColor: true,
+              children: clip(line2.slice(HELP_COLUMN), width - FRAME_CHROME - HELP_COLUMN)
+            })
+          ]
+        }, line2);
+      })
+    })
+  });
+}
+// package.json
+var package_default = {
+  name: "yourskills",
+  version: "0.1.0",
+  description: "Browse, install and keep up to date the agent skills and bundles your team publishes on yourskills.",
+  license: "MIT",
+  homepage: "https://github.com/xiduzo/yourskills/tree/main/apps/cli#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xiduzo/yourskills.git",
+    directory: "apps/cli"
+  },
+  keywords: [
+    "agent-skills",
+    "skills",
+    "cli",
+    "claude-code",
+    "codex",
+    "cursor",
+    "opencode",
+    "ai"
+  ],
+  type: "module",
+  bin: {
+    yourskills: "dist/main.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=22.20.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    "check-types": "tsc --noEmit",
+    build: "bun run build.ts",
+    "build:binary": "bun run build.ts --binary",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@trpc/client": "^11.18.0",
+    "@trpc/server": "^11.18.0",
+    ink: "^7.1.1",
+    react: "^19.2.8",
+    skills: "^1.5.25"
+  },
+  devDependencies: {
+    "@types/bun": "catalog:",
+    "@types/react": "catalog:",
+    "@yourskills/api": "workspace:*",
+    "@yourskills/bundles": "workspace:*",
+    "@yourskills/config": "workspace:*",
+    "@yourskills/ui": "workspace:*",
+    "ink-testing-library": "^4.0.0",
+    typescript: "catalog:"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version ?? "0.0.0-dev";
+
+// src/main.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function applySummary(summary) {
+  if (summary.pending.length > 0 || summary.failed > 0)
+    process.exitCode = 1;
+}
+var PLAIN_MARKS = {
+  ok: mark.ok,
+  fail: mark.fail,
+  pending: mark.pending,
+  none: ""
+};
+function emit(report, output) {
+  if (report.failed)
+    process.exitCode = 1;
+  if (output.json) {
+    console.log(JSON.stringify(report.json));
+    return;
+  }
+  if (report.silent)
+    return;
+  for (const line2 of report.lines)
+    console.log(plainLine(line2, PLAIN_MARKS));
+}
+function toRows(skills) {
+  return skills.map((s) => ({
+    name: s.name,
+    description: s.description,
+    status: s.status
+  }));
+}
+function catalogReport(title, skills) {
+  if (skills.length === 0) {
+    return {
+      title,
+      lines: [{ mark: "none", text: "No skills found." }],
+      json: { skills: [] }
+    };
+  }
+  const width = Math.max(...skills.map((s) => s.name.length));
+  return {
+    title,
+    lines: skills.map((skill) => {
+      const tag = lifecycleTag(skill.status);
+      return {
+        mark: "none",
+        text: `${skill.name.padEnd(width)}${tag ? ` ${tag}` : ""}  ${skill.description ?? ""}`
+      };
+    }),
+    json: { skills }
+  };
+}
+async function resolveInstallOptions(opts) {
+  const { scope, manifestPath } = await resolveScope({ flag: opts.scope });
+  const path = scope === "project" && manifestPath ? manifestPath : manifestPathFor(scope);
+  return {
+    scope,
+    agents: await resolveAgents(opts.agents),
+    manifest: { path, scope }
+  };
+}
+var INVITES_HOOKS = new Set([
+  "login",
+  "add",
+  "bundle",
+  "install",
+  "update",
+  "remove",
+  "browse",
+  "home"
+]);
+async function prepare(command) {
+  switch (command.kind) {
+    case "add":
+    case "bundle":
+    case "update":
+    case "install":
+    case "remove":
+      return { ...command, opts: await resolveInstallOptions(command.opts) };
+    default:
+      return command;
+  }
+}
+function nearestFor(opts) {
+  return nearestManifest(opts.scope);
+}
+function nothingTracked(nearest, kind, all = false) {
+  const has = kind === "install" ? Object.keys(nearest.manifest.skills).length > 0 : Object.keys(nearest.manifest.bundles).length > 0 || all && looseSkills(nearest.manifest).length > 0;
+  if (has)
+    return null;
+  return {
+    title: kind,
+    lines: [
+      {
+        mark: "none",
+        text: kind === "install" ? "Nothing recorded to install. Run `yourskills bundle <name>` first." : "No bundles tracked here. Run `yourskills bundle <name>` first.",
+        note: nearest.path
+      }
+    ],
+    json: { manifest: nearest.path, skills: [], bundles: [] }
+  };
+}
+async function runPlain(command, output, server) {
+  switch (command.kind) {
+    case "help":
+      console.log(HELP);
+      return;
+    case "version":
+      console.log(VERSION);
+      return;
+    case "home":
+    case "browse":
+    case "error":
+      throw new Error(command.kind === "error" ? command.message : `${command.kind === "home" ? "the palette" : "browse"} needs a terminal`);
+    case "login":
+      throw new Error("login needs a terminal. Sign in on a machine that has one; the token is then copied from ~/.config/yourskills/config.json.");
+    case "logout":
+      await logout();
+      console.log("Logged out.");
+      return;
+    case "whoami": {
+      const who = await whoami(server);
+      console.log(`${who.user}  (${who.server})`);
+      console.log(`org: ${who.org ?? "none \u2014 set an active organization in the web UI"}`);
+      return;
+    }
+    case "list":
+    case "search": {
+      const client = await createClient2(server);
+      const skills = command.kind === "list" ? await client.skills.list.query({}) : await client.skills.search.query({ q: command.query });
+      emit(catalogReport(command.kind === "list" ? "skills" : `search: ${command.query}`, skills), output);
+      return;
+    }
+    case "add":
+      applySummary(await installPlain(install(await createClient2(server), command.names, command.opts)));
+      return;
+    case "bundle":
+      applySummary(await installPlain(installBundle(await createClient2(server), command.name, command.opts)));
+      return;
+    case "install": {
+      const nearest = await nearestFor(command.opts);
+      const empty = nothingTracked(nearest, "install");
+      if (empty) {
+        emit(empty, output);
+        return;
+      }
+      applySummary(await installPlain(reinstall(nearest.manifest, command.opts)));
+      return;
+    }
+    case "update": {
+      if (command.bundle) {
+        applySummary(await installPlain(update(await createClient2(server), command.bundle, command.opts)));
+        return;
+      }
+      const nearest = await nearestFor(command.opts);
+      const empty = nothingTracked(nearest, "update", command.all ?? false);
+      if (empty) {
+        emit(empty, output);
+        return;
+      }
+      applySummary(await installPlain(updateTracked(await createClient2(server), nearest.manifest, command.opts, command.all ?? false)));
+      return;
+    }
+    case "remove": {
+      const nearest = await nearestFor(command.opts);
+      emit(await removeSkills(command.names, nearest.manifest, nearest.path, command.opts), output);
+      return;
+    }
+    case "installed":
+      emit(installedReport(await nearestManifest()), output);
+      return;
+    case "outdated":
+      emit(await outdatedReport(await createClient2(server), await nearestManifest(), command.quiet ?? false), output);
+      return;
+    case "doctor":
+      emit(await doctorReport(await nearestManifest(), server), output);
+      return;
+    case "org":
+      emit(command.name ? await orgSwitchReport(command.name, server) : await orgListReport(server), output);
+      return;
+    case "config":
+      emit(command.action === "get" ? await configGet(command.key) : await configSet(command.key, command.value), output);
+      return;
+    case "hooks":
+      emit(await hooksReport(command), output);
+      return;
+    case "hook":
+      await runHook(command.event);
+      return;
+  }
+}
+function hooksReport(command) {
+  if (command.action === "install")
+    return hooksInstall({
+      ...command.agent ? { agent: command.agent } : {},
+      ...command.track === undefined ? {} : { track: command.track }
+    });
+  if (command.action === "uninstall")
+    return hooksUninstall(command.agent ? { agent: command.agent } : {});
+  return hooksStatus();
+}
+async function screenFor(command, fail, summarise, report, server) {
+  const gate = (title, build) => /* @__PURE__ */ jsx14(AuthGate, {
+    title,
+    build,
+    connect: () => createClient2(server),
+    onError: fail
+  });
+  const local = (title, load) => /* @__PURE__ */ jsx14(ReportScreen2, {
+    title,
+    load,
+    onError: fail,
+    onReport: report
+  });
+  switch (command.kind) {
+    case "help":
+      return /* @__PURE__ */ jsx14(HelpScreen, {
+        text: HELP
+      });
+    case "version":
+      return /* @__PURE__ */ jsx14(NoticeScreen, {
+        title: "version",
+        message: VERSION
+      });
+    case "error":
+      throw new Error(command.message);
+    case "login":
+      return /* @__PURE__ */ jsx14(LoginScreen, {
+        onError: fail
+      });
+    case "logout":
+      await logout();
+      return /* @__PURE__ */ jsx14(NoticeScreen, {
+        title: "logout",
+        message: "Logged out."
+      });
+    case "whoami":
+      return gate("whoami", () => /* @__PURE__ */ jsx14(WhoamiScreen, {
+        load: () => whoami(server),
+        onError: fail
+      }));
+    case "list":
+      return gate("skills", (client) => /* @__PURE__ */ jsx14(CatalogScreen, {
+        title: "skills",
+        load: async () => toRows(await client.skills.list.query({})),
+        onError: fail
+      }));
+    case "search": {
+      const q = command.query;
+      return gate(`search: ${q}`, (client) => /* @__PURE__ */ jsx14(CatalogScreen, {
+        title: `search: ${q}`,
+        load: async () => toRows(await client.skills.search.query({ q })),
+        onError: fail
+      }));
+    }
+    case "home": {
+      const opts = await resolveInstallOptions({});
+      return /* @__PURE__ */ jsx14(HomeScreen, {
+        opts,
+        server,
+        openClient: () => createClient2(server),
+        onError: fail,
+        onSummary: summarise
+      });
+    }
+    case "browse": {
+      const opts = await resolveInstallOptions({});
+      return gate("browse", (client) => /* @__PURE__ */ jsx14(BrowserScreen, {
+        client,
+        opts,
+        onError: fail,
+        onSummary: summarise
+      }));
+    }
+    case "add":
+      return gate("add", (client) => /* @__PURE__ */ jsx14(Installer, {
+        title: "add",
+        stream: () => install(client, command.names, command.opts),
+        onDone: summarise
+      }));
+    case "bundle":
+      return gate(`bundle: ${command.name}`, (client) => /* @__PURE__ */ jsx14(Installer, {
+        title: `bundle: ${command.name}`,
+        stream: () => installBundle(client, command.name, command.opts),
+        onDone: summarise
+      }));
+    case "install": {
+      const nearest = await nearestFor(command.opts);
+      const empty = nothingTracked(nearest, "install");
+      if (empty)
+        return local("install", async () => empty);
+      return /* @__PURE__ */ jsx14(Installer, {
+        title: "install",
+        stream: () => reinstall(nearest.manifest, command.opts),
+        onDone: summarise
+      });
+    }
+    case "update": {
+      if (command.bundle) {
+        const name = command.bundle;
+        return gate(`update: ${name}`, (client) => /* @__PURE__ */ jsx14(Installer, {
+          title: `update: ${name}`,
+          stream: () => update(client, name, command.opts),
+          onDone: summarise
+        }));
+      }
+      const nearest = await nearestFor(command.opts);
+      const empty = nothingTracked(nearest, "update", command.all ?? false);
+      if (empty)
+        return local("update", async () => empty);
+      return gate("update", (client) => /* @__PURE__ */ jsx14(Installer, {
+        title: "update",
+        stream: () => updateTracked(client, nearest.manifest, command.opts, command.all ?? false),
+        onDone: summarise
+      }));
+    }
+    case "remove": {
+      const nearest = await nearestFor(command.opts);
+      return local("remove", () => removeSkills(command.names, nearest.manifest, nearest.path, command.opts));
+    }
+    case "installed":
+      return local("installed", async () => installedReport(await nearestManifest()));
+    case "doctor":
+      return local("doctor", async () => doctorReport(await nearestManifest(), server));
+    case "config":
+      return local("config", () => command.action === "get" ? configGet(command.key) : configSet(command.key, command.value));
+    case "hooks":
+      return local("hooks", () => hooksReport(command));
+    case "hook":
+      throw new Error("hooks are not interactive");
+    case "outdated":
+      return gate("outdated", (client) => /* @__PURE__ */ jsx14(ReportScreen2, {
+        title: "outdated",
+        load: async () => outdatedReport(client, await nearestManifest(), command.quiet),
+        onError: fail,
+        onReport: report
+      }));
+    case "org":
+      return gate("org", () => /* @__PURE__ */ jsx14(ReportScreen2, {
+        title: "org",
+        load: () => command.name ? orgSwitchReport(command.name, server) : orgListReport(server),
+        onError: fail,
+        onReport: report
+      }));
+  }
+}
+async function runInk(command, server) {
+  let failure2 = null;
+  const node = await screenFor(command, (error) => {
+    failure2 = error;
+    instance?.unmount();
+  }, applySummary, (report) => {
+    if (report.failed)
+      process.exitCode = 1;
+  }, server);
+  const instance = render(node);
+  await instance.waitUntilExit();
+  if (failure2)
+    throw failure2;
+}
+function isEntrypoint() {
+  const entry = process.argv[1];
+  if (!entry)
+    return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isEntrypoint()) {
+  const interactive = Boolean(process.stdout.isTTY);
+  const parsed = parseArgv(process.argv.slice(2), interactive);
+  const { output, server } = parsed;
+  try {
+    const command = await prepare(parsed.command);
+    if (command.kind === "hook") {
+      await runHook(command.event);
+    } else {
+      await (output.plain ? runPlain(command, output, server) : runInk(command, server));
+      await flushQuietly(server);
+      if (INVITES_HOOKS.has(command.kind))
+        for (const line2 of await ensureHooksRegistered())
+          console.log(line2);
+    }
+  } catch (error) {
+    console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}