@shipeasy/openapi 1.4.0 → 1.6.0

package/dist/operations/index.js

@@ -0,0 +1,1751 @@
+// src/operations/types.ts
+var opId = (op) => [...op.group, op.name].join(".");
+var opMcpName = (op) => [...op.group, op.name].join("_");
+var opCli = (op) => [...op.group, op.name].join(" ");
+
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/operations/coerce.ts
+function coerceValue(param, raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  switch (param.type) {
+    case "number": {
+      const n = typeof raw === "number" ? raw : Number(raw);
+      if (!Number.isFinite(n)) throw new ApiError(`--${param.name} must be a number`, 400);
+      return n;
+    }
+    case "boolean":
+      return raw === true || raw === "true" || raw === "1";
+    case "json":
+      if (typeof raw !== "string") return raw;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        throw new ApiError(`--${param.name} must be valid JSON`, 400);
+      }
+    case "string":
+    default: {
+      const s = String(raw);
+      if (param.enum && !param.enum.includes(s)) {
+        throw new ApiError(`--${param.name} must be one of: ${param.enum.join(", ")}`, 400);
+      }
+      return s;
+    }
+  }
+}
+function coerceInput(op, raw) {
+  const out = {};
+  for (const param of op.params) {
+    const value = coerceValue(param, raw[param.name]);
+    if (value === void 0) {
+      if (param.required) throw new ApiError(`${param.name} is required`, 400);
+      continue;
+    }
+    out[param.name] = value;
+  }
+  return out;
+}
+
+// src/operations/cli-adapter.ts
+var toKebab = (s) => s.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+function commandSignature(op) {
+  const positionals = op.params.filter((p) => p.positional).map((p) => p.required === false ? `[${p.name}]` : `<${p.name}>`);
+  return [op.name, ...positionals].join(" ");
+}
+function mountOperations(group, ops, ctx) {
+  for (const op of ops) {
+    const positionals = op.params.filter((p) => p.positional);
+    const flags = op.params.filter((p) => !p.positional);
+    const cmd = group.command(commandSignature(op)).description(op.summary);
+    for (const p of flags) {
+      cmd.option(`--${toKebab(p.name)} <value>`, p.description);
+    }
+    cmd.option("--json", "Output as JSON");
+    cmd.option("--project <id>", "Project ID override");
+    cmd.action(async (...argv) => {
+      try {
+        const opts = argv.find((a) => a && typeof a === "object" && !Array.isArray(a)) ?? {};
+        const raw = { ...opts };
+        positionals.forEach((p, i) => {
+          raw[p.name] = argv[i];
+        });
+        const input = coerceInput(op, raw);
+        const client = ctx.getClient({
+          mutates: op.mutates,
+          projectOverride: opts.project
+        });
+        const data = await op.run(client, input);
+        if (opts.json) ctx.printJson(data);
+        else ctx.printResult(op, data, input);
+      } catch (e) {
+        ctx.onError(e);
+      }
+    });
+  }
+}
+
+// src/operations/mcp-adapter.ts
+function jsonType(t) {
+  switch (t) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+    case "string":
+    default:
+      return "string";
+  }
+}
+function operationsToMcpTools(ops) {
+  return ops.map((op) => {
+    const properties = {};
+    const required = [];
+    for (const p of op.params) {
+      properties[p.name] = { type: jsonType(p.type), description: p.description };
+      if (p.enum) properties[p.name].enum = p.enum;
+      if (p.required) required.push(p.name);
+    }
+    return {
+      name: opMcpName(op),
+      description: op.description,
+      inputSchema: { type: "object", ...required.length ? { required } : {}, properties }
+    };
+  });
+}
+function operationsToDispatch(ops) {
+  const map = {};
+  for (const op of ops) {
+    map[opMcpName(op)] = async (client, args) => op.run(client, coerceInput(op, args ?? {}));
+  }
+  return map;
+}
+
+// src/operations/docs.ts
+function renderOperationsMarkdown(ops, opts = {}) {
+  const lines = [];
+  if (opts.title) lines.push(`# ${opts.title}`, "");
+  for (const op of ops) {
+    lines.push(`## \`${opId(op)}\``, "");
+    lines.push(op.summary, "");
+    if (op.description && op.description !== op.summary) lines.push(op.description, "");
+    lines.push(
+      `- **CLI:** \`shipeasy ${opCli(op)}\`  \xB7  **MCP tool:** \`${opMcpName(op)}\`  \xB7  ${op.mutates ? "write (needs project binding)" : "read"}`,
+      ""
+    );
+    if (op.params.length) {
+      lines.push("| Param | Type | Required | Description |", "| --- | --- | --- | --- |");
+      for (const p of op.params) {
+        const kind = p.positional ? `${p.type} (positional)` : p.type;
+        lines.push(`| \`${p.name}\` | ${kind} | ${p.required ? "yes" : "no"} | ${p.description} |`);
+      }
+      lines.push("");
+    }
+    if (op.examples?.length) {
+      lines.push("**Examples**", "");
+      for (const ex of op.examples) {
+        if (ex.note) lines.push(`- ${ex.note}:`);
+        lines.push("```sh", ex.run, "```");
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/operations/util.ts
+var num = (i, k) => i[k] === void 0 ? void 0 : i[k];
+var str = (i, k) => i[k] === void 0 ? void 0 : i[k];
+var bool = (i, k) => i[k] === void 0 ? void 0 : i[k];
+
+// src/operations/gates.ts
+var ROLLOUT_DESC = "Rollout percentage, 0\u2013100 (converted to basis points internally).";
+var RULES_DESC = `Targeting rules as a JSON array, e.g. '[{"attr":"plan","op":"eq","value":"pro"}]'. AND-combined.`;
+var STACK_DESC = "Gatekeeper stack as a JSON array of ordered first-match-wins tiers (condition/rollout steps, rolloutPct in basis points). Takes precedence over flat rules/rollout. Pass to express internal \u222A beta \u222A public in one gate.";
+var gateOperations = [
+  {
+    group: ["release", "flags"],
+    name: "list",
+    mutates: false,
+    summary: "List all feature gates",
+    description: "Return every feature gate in the project (name, enabled, rollout %), ordered by most recently updated.",
+    params: [],
+    examples: [{ run: "shipeasy release flags list" }],
+    run: (client) => client.gates.listAll()
+  },
+  {
+    group: ["release", "flags"],
+    name: "create",
+    mutates: true,
+    summary: "Create a feature gate",
+    description: "Create a feature gate. A flat gate is `rules` + a single `rollout` %. For tiered rollouts (e.g. 'US @ 50% \u2192 bots @ 30% \u2192 everyone else @ 10%') pass `stack` \u2014 an ordered list of steps evaluated first-match-wins; flat `rules`/`rollout` are then ignored.",
+    params: [
+      { name: "name", type: "string", description: "Gate key (lowercase, digits, _/-).", required: true, positional: true },
+      { name: "rollout", type: "number", description: ROLLOUT_DESC },
+      { name: "rules", type: "json", description: RULES_DESC },
+      { name: "salt", type: "string", description: "Override hash salt (immutable after create)." },
+      { name: "stack", type: "json", description: STACK_DESC }
+    ],
+    examples: [
+      { note: "Off by default; flip it on later", run: "shipeasy release flags create checkout-v2" },
+      {
+        note: "Roll out to 25% of pro-plan users",
+        run: `shipeasy release flags create new-ui --rollout 25 --rules '[{"attr":"plan","op":"eq","value":"pro"}]'`
+      }
+    ],
+    run: (client, i) => client.gates.create({
+      name: i.name,
+      rollout_pct: Math.round((num(i, "rollout") ?? 0) * 100),
+      // Validated at runtime by gateCreateSchema.parse inside gates.create().
+      rules: i.rules ?? [],
+      ...i.salt ? { salt: i.salt } : {},
+      ...i.stack ? { stack: i.stack } : {}
+    })
+  },
+  {
+    group: ["release", "flags"],
+    name: "update",
+    mutates: true,
+    summary: "Update a gate's rollout, rules, stack, or enabled flag",
+    description: "Update a feature gate's rollout, rules, gatekeeper stack, or enabled flag. Pass `stack` to replace the tiered rollout wholesale; array fields replace, they do not merge.",
+    params: [
+      { name: "name", type: "string", description: "Gate name to update.", required: true, positional: true },
+      { name: "rollout", type: "number", description: ROLLOUT_DESC },
+      { name: "rules", type: "json", description: RULES_DESC + " Replaces the existing rules wholesale." },
+      { name: "stack", type: "json", description: STACK_DESC + " Pass null to revert to flat evaluation." },
+      { name: "enabled", type: "boolean", description: "Master switch \u2014 false forces the gate off for every caller." }
+    ],
+    examples: [{ note: "Ramp to 50%", run: "shipeasy release flags update checkout-v2 --rollout 50" }],
+    run: async (client, i) => {
+      const gate = await client.gates.resolve(i.name);
+      const patch = {};
+      const rollout = num(i, "rollout");
+      if (rollout !== void 0) patch.rollout_pct = Math.round(rollout * 100);
+      if (i.rules !== void 0) patch.rules = i.rules;
+      if (i.stack !== void 0) patch.stack = i.stack;
+      if (i.enabled !== void 0) patch.enabled = i.enabled;
+      return client.gates.update(gate.id, patch);
+    }
+  },
+  {
+    group: ["release", "flags"],
+    name: "enable",
+    mutates: true,
+    summary: "Enable a feature gate",
+    description: "Set `enabled: true`, preserving the current rollout %.",
+    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release flags enable checkout-v2" }],
+    run: async (client, i) => {
+      const gate = await client.gates.resolve(i.name);
+      return client.gates.enable(gate.id);
+    }
+  },
+  {
+    group: ["release", "flags"],
+    name: "disable",
+    mutates: true,
+    summary: "Disable a feature gate (kill switch)",
+    description: "Set `enabled: false` so the gate evaluates to `false` for every caller regardless of rules/rollout.",
+    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release flags disable checkout-v2" }],
+    run: async (client, i) => {
+      const gate = await client.gates.resolve(i.name);
+      return client.gates.disable(gate.id);
+    }
+  },
+  {
+    group: ["release", "flags"],
+    name: "rollout",
+    mutates: true,
+    summary: "Set rollout percentage (0\u2013100)",
+    description: "Resolve the gate by name and set its rollout percentage (0\u2013100).",
+    params: [
+      { name: "name", type: "string", description: "Gate name.", required: true, positional: true },
+      { name: "pct", type: "number", description: "Rollout percentage, 0\u2013100.", required: true, positional: true }
+    ],
+    examples: [
+      { note: "Ramp to 50%", run: "shipeasy release flags rollout checkout-v2 50" },
+      { note: "Instant kill \u2014 set to 0", run: "shipeasy release flags rollout checkout-v2 0" }
+    ],
+    run: (client, i) => client.gates.setRollout(i.name, num(i, "pct"))
+  },
+  {
+    group: ["release", "flags"],
+    name: "archive",
+    mutates: true,
+    summary: "Archive a feature gate",
+    description: "Archive (soft-delete) a feature gate by name. Refuses if a running experiment references it as a targeting gate.",
+    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release flags archive checkout-v2" }],
+    run: async (client, i) => {
+      const gate = await client.gates.resolve(i.name);
+      await client.gates.delete(gate.id);
+      return { ok: true, archived: i.name };
+    }
+  }
+];
+
+// src/operations/killswitches.ts
+var GROUP = ["release", "killswitch"];
+var ENVS = ["dev", "staging", "prod"];
+var killswitchOperations = [
+  {
+    group: GROUP,
+    name: "list",
+    mutates: false,
+    summary: "List all kill switches",
+    description: "Return every kill switch with its per-env default value and switch count.",
+    params: [],
+    examples: [{ run: "shipeasy release killswitch list" }],
+    run: (client) => client.killswitches.listAll()
+  },
+  {
+    group: GROUP,
+    name: "create",
+    mutates: true,
+    summary: "Create a kill switch",
+    description: "Create a kill switch (a static `{ value, switches }` config shipped in the flags KV blob). Name must be `folder.name`. Switches take precedence over `value` for that switch_key.",
+    params: [
+      { name: "name", type: "string", description: "`folder.name` \u2014 two lowercase segments.", required: true, positional: true },
+      { name: "description", type: "string", description: "Optional description." },
+      { name: "value", type: "boolean", description: "Default value (true|false). Defaults to false." },
+      { name: "switches", type: "json", description: "JSON object of { switch_key: bool }; takes precedence over value." }
+    ],
+    examples: [
+      { note: "Default OFF", run: "shipeasy release killswitch create payments.stripe-gateway" },
+      { note: "Pre-seed per-key switches", run: `shipeasy release killswitch create payments.stripe-gateway --switches '{"refunds":true,"payouts":false}'` }
+    ],
+    run: (client, i) => client.killswitches.create({
+      name: i.name,
+      description: str(i, "description"),
+      value: bool(i, "value") ?? false,
+      switches: i.switches
+    })
+  },
+  {
+    group: GROUP,
+    name: "update",
+    mutates: true,
+    summary: "Update a kill switch's default value, switches map, or description",
+    description: "Patch a kill switch. `switches` replaces the map wholesale; pass an empty description to clear it.",
+    params: [
+      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
+      { name: "value", type: "boolean", description: "Default value (true|false)." },
+      { name: "switches", type: "json", description: "JSON { switch_key: bool } \u2014 replaces wholesale." },
+      { name: "description", type: "string", description: "Description (empty string clears it)." }
+    ],
+    examples: [{ note: "Flip the default ON", run: "shipeasy release killswitch update payments.stripe-gateway --value true" }],
+    run: async (client, i) => {
+      const k = await client.killswitches.resolve(i.name);
+      const patch = {};
+      if (i.value !== void 0) patch.value = i.value;
+      if (i.switches !== void 0) patch.switches = i.switches;
+      if (i.description !== void 0) patch.description = i.description === "" ? null : i.description;
+      return client.killswitches.update(k.id, patch);
+    }
+  },
+  {
+    group: GROUP,
+    name: "set",
+    mutates: true,
+    summary: "Set one switch entry on one env",
+    description: "Set or update a single named switch on one environment (default `prod`), leaving the rest untouched.",
+    params: [
+      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
+      { name: "switchKey", type: "string", description: "Switch key to set.", required: true, positional: true },
+      { name: "value", type: "boolean", description: "true|false.", required: true, positional: true },
+      { name: "env", type: "string", description: `Env: ${ENVS.join(" | ")} (default prod).`, enum: ENVS }
+    ],
+    examples: [
+      { note: "Kill refunds in prod", run: "shipeasy release killswitch set payments.stripe-gateway refunds true" },
+      { note: "Target staging instead", run: "shipeasy release killswitch set payments.stripe-gateway refunds true --env staging" }
+    ],
+    run: async (client, i) => {
+      const k = await client.killswitches.resolve(i.name);
+      return client.killswitches.setSwitch(k.id, {
+        env: str(i, "env") ?? "prod",
+        switchKey: i.switchKey,
+        value: i.value
+      });
+    }
+  },
+  {
+    group: GROUP,
+    name: "unset",
+    mutates: true,
+    summary: "Remove one switch entry from one env",
+    description: "Remove a single named switch from one environment (default `prod`), reverting it to the default.",
+    params: [
+      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
+      { name: "switchKey", type: "string", description: "Switch key to remove.", required: true, positional: true },
+      { name: "env", type: "string", description: `Env: ${ENVS.join(" | ")} (default prod).`, enum: ENVS }
+    ],
+    examples: [{ run: "shipeasy release killswitch unset payments.stripe-gateway refunds" }],
+    run: async (client, i) => {
+      const k = await client.killswitches.resolve(i.name);
+      return client.killswitches.unsetSwitch(k.id, {
+        env: str(i, "env") ?? "prod",
+        switchKey: i.switchKey
+      });
+    }
+  },
+  {
+    group: GROUP,
+    name: "archive",
+    mutates: true,
+    summary: "Archive a kill switch",
+    description: "Archive (soft-delete) a kill switch by name.",
+    params: [{ name: "name", type: "string", description: "Kill switch name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release killswitch archive payments.stripe-gateway" }],
+    run: async (client, i) => {
+      const k = await client.killswitches.resolve(i.name);
+      await client.killswitches.delete(k.id);
+      return { ok: true, archived: i.name };
+    }
+  }
+];
+
+// src/operations/configs.ts
+var GROUP2 = ["release", "configs"];
+var configOperations = [
+  {
+    group: GROUP2,
+    name: "list",
+    mutates: false,
+    summary: "List all configs",
+    description: "Return every dynamic config (name, schema, last updated).",
+    params: [],
+    examples: [{ run: "shipeasy release configs list" }],
+    run: (client) => client.configs.listAll()
+  },
+  {
+    group: GROUP2,
+    name: "get",
+    mutates: false,
+    summary: "Show a config by name",
+    description: "Resolve a config by name and return its full detail (schema + per-env values + drafts).",
+    params: [{ name: "name", type: "string", description: "Config name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release configs get pricing" }],
+    run: async (client, i) => {
+      const c = await client.configs.resolve(i.name);
+      return client.configs.get(c.id);
+    }
+  },
+  {
+    group: GROUP2,
+    name: "create",
+    mutates: true,
+    summary: "Create a config",
+    description: "Create a dynamic config. Configs are JSON objects validated against a JSON Schema (object-only).",
+    params: [
+      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
+      { name: "schema", type: "json", description: "JSON Schema (top-level type=object). Defaults to a permissive object schema." },
+      { name: "value", type: "json", description: "Initial value as a JSON object. Defaults to {}." },
+      { name: "description", type: "string", description: "Human-readable description." }
+    ],
+    examples: [
+      { note: "Permissive schema, empty value", run: "shipeasy release configs create pricing" },
+      { note: "Seed an initial value", run: `shipeasy release configs create pricing --value '{"free_trial_days":14}'` }
+    ],
+    run: (client, i) => client.configs.create({
+      name: i.name,
+      schema: i.schema ?? { type: "object", properties: {}, additionalProperties: true },
+      value: i.value ?? {},
+      ...i.description ? { description: i.description } : {}
+    })
+  },
+  {
+    group: GROUP2,
+    name: "update",
+    mutates: true,
+    summary: "Update a config's value (flat, all envs)",
+    description: "Legacy flat value update across all envs. Use draft + publish for per-env staging.",
+    params: [
+      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
+      { name: "value", type: "json", description: "New value (JSON object).", required: true }
+    ],
+    examples: [{ note: "Overwrite the value (all envs)", run: `shipeasy release configs update pricing --value '{"free_trial_days":30}'` }],
+    run: async (client, i) => {
+      const c = await client.configs.resolve(i.name);
+      return client.configs.update(c.id, { value: i.value });
+    }
+  },
+  {
+    group: GROUP2,
+    name: "draft",
+    mutates: true,
+    summary: "Save a draft value for one env",
+    description: "Stage a draft value for the given env, to publish later.",
+    params: [
+      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
+      { name: "env", type: "string", description: "Target env (e.g. prod, staging, dev).", required: true },
+      { name: "value", type: "json", description: "Draft value (JSON object).", required: true }
+    ],
+    examples: [{ note: "Stage a prod value", run: `shipeasy release configs draft pricing --env prod --value '{"free_trial_days":30}'` }],
+    run: async (client, i) => {
+      const c = await client.configs.resolve(i.name);
+      return client.configs.saveDraft(c.id, { env: i.env, value: i.value });
+    }
+  },
+  {
+    group: GROUP2,
+    name: "publish",
+    mutates: true,
+    summary: "Publish the saved draft for one env",
+    description: "Promote the staged draft for the given env to live.",
+    params: [
+      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
+      { name: "env", type: "string", description: "Target env to publish.", required: true }
+    ],
+    examples: [{ note: "Promote staged draft to prod", run: "shipeasy release configs publish pricing --env prod" }],
+    run: async (client, i) => {
+      const c = await client.configs.resolve(i.name);
+      return client.configs.publish(c.id, { env: str(i, "env") });
+    }
+  },
+  {
+    group: GROUP2,
+    name: "archive",
+    mutates: true,
+    summary: "Archive a config",
+    description: "Archive (soft-delete) a config by name.",
+    params: [{ name: "name", type: "string", description: "Config name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release configs archive pricing" }],
+    run: async (client, i) => {
+      const c = await client.configs.resolve(i.name);
+      await client.configs.delete(c.id);
+      return { ok: true, archived: i.name };
+    }
+  }
+];
+
+// src/operations/experiments.ts
+var GROUP3 = ["release", "experiments"];
+var DEFAULT_GROUPS = [
+  { name: "control", weight: 5e3, params: {} },
+  { name: "test", weight: 5e3, params: {} }
+];
+var AGGREGATIONS = [
+  "count_users",
+  "count_events",
+  "retention_7d",
+  "retention_30d",
+  "sum",
+  "avg"
+];
+function buildGoalMetric(i) {
+  const event = str(i, "successEvent");
+  if (!event) return void 0;
+  const agg = str(i, "successAggregation") ?? "count_users";
+  const value = str(i, "successValue");
+  switch (agg) {
+    case "count_users":
+      return { query: `count_users(${event})` };
+    case "count_events":
+      return { query: `count(${event})` };
+    case "retention_7d":
+      return { query: `retention_7d(${event})` };
+    case "retention_30d":
+      return { query: `retention_30d(${event})` };
+    case "sum":
+    case "avg":
+      if (!value)
+        throw new Error(
+          `successAggregation '${agg}' requires successValue \u2014 the numeric event property to ${agg} (e.g. "amount")`
+        );
+      return { query: `${agg}(${event}, ${value})` };
+    default:
+      throw new Error(`Unknown successAggregation '${agg}'`);
+  }
+}
+function parseGuardrails(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry === "string") {
+      const query = entry.trim();
+      if (query) out.push({ query });
+    } else if (entry && typeof entry === "object") {
+      const o = entry;
+      const query = typeof o.query === "string" ? o.query.trim() : "";
+      if (query)
+        out.push(typeof o.name === "string" && o.name ? { query, name: o.name } : { query });
+    }
+  }
+  return out;
+}
+function computeVerdict(detail, results) {
+  if (results.some((r) => r.srm_detected === 1))
+    return { verdict: "invalid_srm", reason: "sample-ratio mismatch detected" };
+  if (detail.status !== "running") return { verdict: "not_running", reason: `status=${detail.status}` };
+  if (!results.length) return { verdict: "wait", reason: "no data yet" };
+  const withP = results.filter((r) => r.p_value !== null);
+  if (!withP.length) return { verdict: "wait", reason: "no p-values yet" };
+  const best = withP.reduce((a, b) => a.p_value < b.p_value ? a : b);
+  const threshold = detail.significance_threshold ?? 0.05;
+  if (best.p_value < threshold) return { verdict: "ship" };
+  const startedAt = detail.startedAt ?? detail.started_at;
+  const daysRunning = startedAt ? (Date.now() - new Date(startedAt).getTime()) / (1e3 * 60 * 60 * 24) : 0;
+  return daysRunning < (detail.min_runtime_days ?? 0) ? { verdict: "wait", reason: "min runtime not reached" } : { verdict: "hold" };
+}
+var experimentOperations = [
+  {
+    group: GROUP3,
+    name: "list",
+    mutates: false,
+    summary: "List experiments",
+    description: "Return every experiment (status, universe, allocation).",
+    params: [],
+    examples: [{ run: "shipeasy release experiments list" }],
+    run: (client) => client.experiments.listAll()
+  },
+  {
+    group: GROUP3,
+    name: "create",
+    mutates: true,
+    summary: "Create an experiment",
+    description: "Create an experiment draft with groups, params, optional targeting gate, a success (goal) metric, optional guardrail metrics, and full statistical config. Pass `successEvent` (+ `successAggregation`) to attach the goal metric inline \u2014 required before the experiment can be started. Defaults to a 50/50 control-vs-test split at 100% allocation in the `default` universe. Does NOT start \u2014 call `start`.",
+    params: [
+      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
+      { name: "universe", type: "string", description: "Universe name. Defaults to 'default'." },
+      { name: "allocation", type: "number", description: "Allocation percentage, 0\u2013100. Defaults to 100." },
+      { name: "groups", type: "json", description: "Groups as JSON [{name,weight,params}]. weight is basis points." },
+      { name: "params", type: "json", description: "Parameter schema {name: type}." },
+      { name: "targetingGate", type: "string", description: "Targeting gate name." },
+      { name: "bucketBy", type: "string", description: "Attribute to bucket by (defaults to the universe unit)." },
+      { name: "salt", type: "string", description: "Override hash salt." },
+      { name: "successEvent", type: "string", description: "Event name for the inline goal metric. Attaching one makes the draft startable." },
+      { name: "successAggregation", type: "string", description: `Goal-metric reducer. Defaults to count_users.`, enum: [...AGGREGATIONS] },
+      { name: "successValue", type: "string", description: "Numeric event property for sum/avg goal metrics." },
+      { name: "guardrailMetrics", type: "json", description: "Up to 10 guardrail metrics: JSON array of DSL query strings or {query,name}." },
+      { name: "significance", type: "number", description: "Significance threshold (0.0001\u20130.5). Defaults to 0.05." },
+      { name: "minRuntimeDays", type: "number", description: "Minimum runtime in days." },
+      { name: "minSampleSize", type: "number", description: "Minimum sample size." },
+      { name: "sequentialTesting", type: "boolean", description: "Enable sequential testing (always-valid p-values; Premium+)." },
+      { name: "description", type: "string", description: "Human-readable description." }
+    ],
+    examples: [
+      { note: "Default 50/50, full traffic", run: "shipeasy release experiments create pricing-page" },
+      {
+        note: "Attach a goal metric so it's startable",
+        run: "shipeasy release experiments create checkout-cta --universe web --success-event checkout_completed"
+      }
+    ],
+    run: (client, i) => {
+      const goal_metric = buildGoalMetric(i);
+      const guardrail_metrics = parseGuardrails(i.guardrailMetrics);
+      return client.experiments.create({
+        name: i.name,
+        universe: str(i, "universe") ?? "default",
+        allocation_pct: Math.round((num(i, "allocation") ?? 100) * 100),
+        groups: i.groups ?? DEFAULT_GROUPS,
+        params: i.params ?? {},
+        targeting_gate: str(i, "targetingGate") ?? null,
+        ...str(i, "bucketBy") ? { bucket_by: str(i, "bucketBy") } : {},
+        ...str(i, "description") !== void 0 ? { description: str(i, "description") } : {},
+        ...i.salt ? { salt: i.salt } : {},
+        ...num(i, "significance") !== void 0 ? { significance_threshold: num(i, "significance") } : {},
+        ...num(i, "minRuntimeDays") !== void 0 ? { min_runtime_days: num(i, "minRuntimeDays") } : {},
+        ...num(i, "minSampleSize") !== void 0 ? { min_sample_size: num(i, "minSampleSize") } : {},
+        ...bool(i, "sequentialTesting") !== void 0 ? { sequential_testing: bool(i, "sequentialTesting") } : {},
+        ...goal_metric ? { goal_metric } : {},
+        ...guardrail_metrics.length ? { guardrail_metrics } : {}
+      });
+    }
+  },
+  {
+    group: GROUP3,
+    name: "update",
+    mutates: true,
+    summary: "Update an experiment",
+    description: "Patch allocation, groups, params, targeting gate, or stats thresholds. Pass `targetingGate` = 'null' to clear it.",
+    params: [
+      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
+      { name: "allocation", type: "number", description: "Allocation percentage, 0\u2013100." },
+      { name: "groups", type: "json", description: "Groups as JSON [{name,weight,params}]." },
+      { name: "params", type: "json", description: "Parameter schema {name: type}." },
+      { name: "targetingGate", type: "string", description: "Targeting gate name ('null' to clear)." },
+      { name: "bucketBy", type: "string", description: "Attribute to bucket by (empty string clears)." },
+      { name: "successEvent", type: "string", description: "Attach/replace the goal metric from this event." },
+      { name: "successAggregation", type: "string", description: "Goal-metric reducer (with successEvent).", enum: [...AGGREGATIONS] },
+      { name: "successValue", type: "string", description: "Numeric event property for sum/avg goal metrics." },
+      { name: "guardrailMetrics", type: "json", description: "Replace the guardrail set: JSON array of DSL queries or {query,name}." },
+      { name: "significance", type: "number", description: "Significance threshold (0.0001\u20130.5)." },
+      { name: "minRuntimeDays", type: "number", description: "Minimum runtime in days." },
+      { name: "minSampleSize", type: "number", description: "Minimum sample size." },
+      { name: "sequentialTesting", type: "boolean", description: "Enable sequential testing (always-valid p-values)." }
+    ],
+    examples: [
+      { note: "Dial allocation to 50%", run: "shipeasy release experiments update pricing-page --allocation 50" },
+      { note: "Clear targeting + tighten significance", run: "shipeasy release experiments update checkout-cta --targeting-gate null --significance 0.01" }
+    ],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      const patch = {};
+      const allocation = num(i, "allocation");
+      if (allocation !== void 0) patch.allocation_pct = Math.round(allocation * 100);
+      if (i.groups !== void 0) patch.groups = i.groups;
+      if (i.params !== void 0) patch.params = i.params;
+      if (i.targetingGate !== void 0)
+        patch.targeting_gate = i.targetingGate === "null" ? null : i.targetingGate;
+      if (str(i, "bucketBy") !== void 0) patch.bucket_by = str(i, "bucketBy") || null;
+      if (i.significance !== void 0) patch.significance_threshold = i.significance;
+      if (i.minRuntimeDays !== void 0) patch.min_runtime_days = i.minRuntimeDays;
+      if (i.minSampleSize !== void 0) patch.min_sample_size = i.minSampleSize;
+      if (bool(i, "sequentialTesting") !== void 0) patch.sequential_testing = bool(i, "sequentialTesting");
+      if (i.guardrailMetrics !== void 0) patch.guardrail_metrics = parseGuardrails(i.guardrailMetrics);
+      const goal_metric = buildGoalMetric(i);
+      if (goal_metric) patch.goal_metric = goal_metric;
+      return client.experiments.update(e.id, patch);
+    }
+  },
+  {
+    group: GROUP3,
+    name: "start",
+    mutates: true,
+    summary: "Start an experiment",
+    description: "Move an experiment from draft to running.",
+    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments start pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      return client.experiments.start(e.id);
+    }
+  },
+  {
+    group: GROUP3,
+    name: "stop",
+    mutates: true,
+    summary: "Stop a running experiment",
+    description: "Stop a running experiment. Optionally name a `promoteGroup` to record an intent note (actual promotion happens in the dashboard).",
+    params: [
+      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
+      { name: "promoteGroup", type: "string", description: "Group to note as the winner to promote." }
+    ],
+    examples: [{ run: "shipeasy release experiments stop pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      const result = await client.experiments.stop(e.id);
+      const promote = str(i, "promoteGroup");
+      return {
+        ...result,
+        ...promote ? {
+          promote_group_note: `Manual promotion needed: promote group '${promote}' in the dashboard or via PATCH /api/admin/experiments/${e.id}.`
+        } : {}
+      };
+    }
+  },
+  {
+    group: GROUP3,
+    name: "archive",
+    mutates: true,
+    summary: "Archive a stopped experiment",
+    description: "Archive (soft-delete) a stopped experiment, hiding it from the default list while preserving results.",
+    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments archive pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      return client.experiments.archive(e.id);
+    }
+  },
+  {
+    group: GROUP3,
+    name: "restore",
+    mutates: true,
+    summary: "Restore an archived experiment to draft",
+    description: "Restore a soft-deleted (archived) experiment back to `draft`. Allowed only if it never started; one that already ran must be cloned instead. Preserves the goal metric.",
+    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments restore pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      return client.experiments.restore(e.id);
+    }
+  },
+  {
+    group: GROUP3,
+    name: "reanalyze",
+    mutates: true,
+    summary: "Re-run the analysis pass",
+    description: "Trigger a fresh analysis pass for an experiment.",
+    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments reanalyze pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      return client.experiments.reanalyze(e.id);
+    }
+  },
+  {
+    group: GROUP3,
+    name: "status",
+    mutates: false,
+    summary: "Show experiment status, verdict, and latest results",
+    description: "Return the experiment, its latest per-metric results (enrolment, deltas, p-values), and a ship/hold/wait/not_running/invalid_srm verdict computed from the goal metric vs the significance threshold and minimum runtime.",
+    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments status pricing-page" }],
+    run: async (client, i) => {
+      const e = await client.experiments.resolve(i.name);
+      const detail = await client.experiments.get(e.id).catch(() => e);
+      const results = await client.experiments.results(e.id).catch(() => []);
+      const { verdict, reason } = computeVerdict(detail, results);
+      return { verdict, ...reason ? { reason } : {}, experiment: detail, results };
+    }
+  }
+];
+
+// src/operations/universes.ts
+var GROUP4 = ["release", "experiments", "universes"];
+function parseHoldout(raw) {
+  if (raw === void 0 || raw === "" || raw === "null") return null;
+  const [lo, hi] = raw.split(",").map((s) => Number(s.trim()));
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+    throw new ApiError("holdout must be 'lo,hi' integers in [0,9999]", 400);
+  }
+  return [lo, hi];
+}
+var universeOperations = [
+  {
+    group: GROUP4,
+    name: "list",
+    mutates: false,
+    summary: "List universes",
+    description: "Return every experiment universe (allocation %, holdout %).",
+    params: [],
+    examples: [{ run: "shipeasy release experiments universes list" }],
+    run: (client) => client.universes.listAll()
+  },
+  {
+    group: GROUP4,
+    name: "create",
+    mutates: true,
+    summary: "Create a universe",
+    description: "Create an experiment universe (container + optional holdout).",
+    params: [
+      { name: "name", type: "string", description: "Universe name.", required: true, positional: true },
+      { name: "unitType", type: "string", description: "Unit type (e.g. user_id, account_id). Defaults to user_id." },
+      { name: "holdout", type: "string", description: "Holdout range as 'lo,hi' (0\u20139999); omit for no holdout." }
+    ],
+    examples: [
+      { note: "Default user_id unit, no holdout", run: "shipeasy release experiments universes create web" },
+      { note: "Holdout 0\u2013999, keyed on account_id", run: "shipeasy release experiments universes create web --unit-type account_id --holdout 0,999" }
+    ],
+    run: (client, i) => client.universes.create({
+      name: i.name,
+      unit_type: str(i, "unitType") ?? "user_id",
+      holdout_range: parseHoldout(str(i, "holdout"))
+    })
+  },
+  {
+    group: GROUP4,
+    name: "update",
+    mutates: true,
+    summary: "Update a universe's holdout range",
+    description: "Update the holdout range. Pass 'null' to clear the holdout.",
+    params: [
+      { name: "name", type: "string", description: "Universe name.", required: true, positional: true },
+      { name: "holdout", type: "string", description: "Holdout range as 'lo,hi' (0\u20139999), or 'null' to clear." }
+    ],
+    examples: [
+      { note: "Set a 5% holdout", run: "shipeasy release experiments universes update web --holdout 0,499" },
+      { note: "Clear the holdout", run: "shipeasy release experiments universes update web --holdout null" }
+    ],
+    run: async (client, i) => {
+      const x = await client.universes.resolve(i.name);
+      const patch = i.holdout === void 0 ? {} : { holdout_range: parseHoldout(str(i, "holdout")) };
+      return client.universes.update(x.id, patch);
+    }
+  },
+  {
+    group: GROUP4,
+    name: "archive",
+    mutates: true,
+    summary: "Archive a universe",
+    description: "Archive (soft-delete) a universe by name.",
+    params: [{ name: "name", type: "string", description: "Universe name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy release experiments universes archive web" }],
+    run: async (client, i) => {
+      const x = await client.universes.resolve(i.name);
+      await client.universes.delete(x.id);
+      return { ok: true, archived: i.name };
+    }
+  }
+];
+
+// src/operations/metrics.ts
+var GROUP5 = ["metrics"];
+var METRIC_GRAMMAR = `Shipeasy metric query DSL
+=========================
+
+Query        := AggFunc "(" Selector ("," Identifier)? ")" GroupBy?
+AggFunc      := count_users | count | sum | avg | min | max | unique |
+                p50 | p75 | p90 | p95 | p99 | p999 |
+                retention_<N>d            (N in 1..90)
+Selector     := Identifier ("{" Filter ("," Filter)* ","? "}")?
+Filter       := Identifier MatchOp StringLiteral
+MatchOp      := "=" | "!=" | "=~" | "!~"
+StringLiteral := double-quoted, supports \\" and \\\\
+GroupBy      := ("by" | "without") "(" Identifier ("," Identifier)* ","? ")"
+
+Examples
+--------
+  count_users(checkout_completed)
+  sum(purchase{country="US"}, amount)
+  p99(req_dur{route=~"/api/.*"}, ms) by (route, status)
+  retention_7d(session_start)
+  avg(req_dur{tier!="free"}, ms) without (region)
+
+Notes
+-----
+- One event selector per query (no formulas).
+- "count" maps to count_events (per-row count); "count_users" is uniq-by-user.
+- For experiments, "by (label)" is ignored \u2014 per-user reducer is applied.
+- Filter values must be quoted strings, even for numeric labels (they are coerced).
+- Filter labels and value labels must be declared on the source event.
+`;
+var metricOperations = [
+  {
+    group: GROUP5,
+    name: "grammar",
+    mutates: false,
+    summary: "Print the metric query DSL grammar",
+    description: "Return the full metric query DSL grammar \u2014 aggregation functions, event selectors, label filters, and group-by. A pure op: it ignores the client and never hits the API.",
+    params: [],
+    examples: [{ run: "shipeasy metrics grammar" }],
+    run: async () => ({ grammar: METRIC_GRAMMAR })
+  },
+  {
+    group: GROUP5,
+    name: "list",
+    mutates: false,
+    summary: "List all metrics",
+    description: "Return every metric in the project (name, folder, source event, aggregation).",
+    params: [],
+    examples: [{ run: "shipeasy metrics list" }],
+    run: (client) => client.metrics.list()
+  },
+  {
+    group: GROUP5,
+    name: "show",
+    mutates: false,
+    summary: "Show one metric",
+    description: "Resolve a metric by id, id-prefix, or name and return its full detail.",
+    params: [{ name: "metric", type: "string", description: "Metric id or name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy metrics show checkouts" }],
+    run: (client, i) => client.metrics.resolve(i.metric)
+  },
+  {
+    group: GROUP5,
+    name: "create",
+    mutates: true,
+    summary: "Create a metric",
+    description: "Create an event-backed metric. Pass the query as the DSL string (`query`) or the typed IR form (`queryIr`). `event` must match the event the query references. Run `metrics grammar` for the DSL syntax.",
+    params: [
+      { name: "name", type: "string", description: "Metric name.", required: true, positional: true },
+      { name: "event", type: "string", description: "Source event name (must equal the query's event).", required: true },
+      { name: "query", type: "string", description: "Query DSL string, e.g. 'sum(purchase, amount)'." },
+      { name: "queryIr", type: "json", description: "Typed IR JSON (alternative to query)." },
+      { name: "folder", type: "string", description: "Folder to file the metric under." },
+      { name: "winsorize", type: "number", description: "Winsorize percentile (1\u201399). Defaults to 99." },
+      { name: "mde", type: "number", description: "Min detectable effect (0\u20131)." }
+    ],
+    examples: [
+      { note: "Unique users who completed checkout", run: "shipeasy metrics create checkouts --event checkout_completed --query 'count_users(checkout_completed)'" },
+      { note: "p99 latency grouped by route", run: `shipeasy metrics create api-latency --event req_dur --query 'p99(req_dur{route=~"/api/.*"}, ms) by (route)'` }
+    ],
+    run: (client, i) => client.metrics.create({
+      name: i.name,
+      event_name: i.event,
+      folder: str(i, "folder") ?? null,
+      winsorize_pct: num(i, "winsorize") ?? 99,
+      min_detectable_effect: num(i, "mde") ?? null,
+      ...i.query ? { query: i.query } : {},
+      ...i.queryIr ? { query_ir: i.queryIr } : {}
+    })
+  },
+  {
+    group: GROUP5,
+    name: "archive",
+    mutates: true,
+    summary: "Archive a metric",
+    description: "Archive (soft-delete) a metric by id or name.",
+    params: [{ name: "metric", type: "string", description: "Metric id or name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy metrics archive checkouts" }],
+    run: async (client, i) => {
+      const m = await client.metrics.resolve(i.metric);
+      await client.metrics.delete(m.id);
+      return { ok: true, archived: m.name };
+    }
+  }
+];
+
+// src/operations/events.ts
+var GROUP6 = ["events"];
+var PROPS_DESC = `Event properties as a JSON array, e.g. '[{"name":"amount","type":"number","required":true}]'. type is one of string|number|boolean. Replaces the full set on update/approve.`;
+function props(i) {
+  return i.props === void 0 ? void 0 : i.props;
+}
+var eventOperations = [
+  {
+    group: GROUP6,
+    name: "list",
+    mutates: false,
+    summary: "List catalogued events",
+    description: "List every catalogued event (including pending auto-discovered names). Pass `pending` to show only the unapproved queue.",
+    params: [{ name: "pending", type: "boolean", description: "Show only pending (unapproved) events." }],
+    examples: [
+      { run: "shipeasy metrics events list" },
+      { note: "Review the auto-discovered queue", run: "shipeasy metrics events list --pending true" }
+    ],
+    run: async (client, i) => {
+      const rows = await client.events.list();
+      return bool(i, "pending") ? rows.filter((e) => e.pending === 1) : rows;
+    }
+  },
+  {
+    group: GROUP6,
+    name: "get",
+    mutates: false,
+    summary: "Show one catalogued event",
+    description: "Resolve an event by id, id-prefix, or name and return its full detail.",
+    params: [{ name: "event", type: "string", description: "Event id or name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy metrics events get checkout_completed" }],
+    run: (client, i) => client.events.resolve(i.event)
+  },
+  {
+    group: GROUP6,
+    name: "create",
+    mutates: true,
+    summary: "Register a new event",
+    description: "Register a new event name and (optionally) its typed properties.",
+    params: [
+      { name: "name", type: "string", description: "Event name.", required: true, positional: true },
+      { name: "folder", type: "string", description: "Folder to file it under." },
+      { name: "description", type: "string", description: "Human-readable description." },
+      { name: "props", type: "json", description: PROPS_DESC }
+    ],
+    examples: [
+      { run: "shipeasy metrics events create checkout_completed" },
+      { note: "With a typed, required property", run: `shipeasy metrics events create purchase --props '[{"name":"amount","type":"number","required":true}]'` }
+    ],
+    run: (client, i) => client.events.create({
+      name: i.name,
+      folder: str(i, "folder") ?? null,
+      ...i.description ? { description: i.description } : {},
+      properties: props(i) ?? []
+    })
+  },
+  {
+    group: GROUP6,
+    name: "update",
+    mutates: true,
+    summary: "Update an event",
+    description: "Update an event's folder, description, or properties (props replace the full set).",
+    params: [
+      { name: "event", type: "string", description: "Event id.", required: true, positional: true },
+      { name: "folder", type: "string", description: "New folder." },
+      { name: "description", type: "string", description: "New description." },
+      { name: "props", type: "json", description: PROPS_DESC }
+    ],
+    examples: [{ run: "shipeasy metrics events update evt_3f9a --folder checkout" }],
+    run: (client, i) => {
+      const patch = {};
+      if (i.folder !== void 0) patch.folder = i.folder;
+      if (i.description !== void 0) patch.description = i.description;
+      const p = props(i);
+      if (p) patch.properties = p;
+      return client.events.update(i.event, patch);
+    }
+  },
+  {
+    group: GROUP6,
+    name: "approve",
+    mutates: true,
+    summary: "Approve a pending event",
+    description: "Promote a pending (auto-discovered) event so metrics can query it. Optionally declare its folder/props on approval.",
+    params: [
+      { name: "event", type: "string", description: "Event id.", required: true, positional: true },
+      { name: "folder", type: "string", description: "Folder to file it under." },
+      { name: "description", type: "string", description: "Description." },
+      { name: "props", type: "json", description: PROPS_DESC }
+    ],
+    examples: [{ note: "Promote an auto-discovered event", run: "shipeasy metrics events approve evt_3f9a" }],
+    run: (client, i) => {
+      const body = {};
+      if (i.folder !== void 0) body.folder = i.folder;
+      if (i.description !== void 0) body.description = i.description;
+      const p = props(i);
+      if (p) body.properties = p;
+      return client.events.approve(i.event, body);
+    }
+  },
+  {
+    group: GROUP6,
+    name: "archive",
+    mutates: true,
+    summary: "Archive an event",
+    description: "Archive (remove) an event from the catalog by id.",
+    params: [{ name: "event", type: "string", description: "Event id.", required: true, positional: true }],
+    examples: [{ run: "shipeasy metrics events archive evt_3f9a" }],
+    run: async (client, i) => {
+      await client.events.delete(i.event);
+      return { ok: true, archived: i.event };
+    }
+  }
+];
+
+// src/operations/ops.ts
+var QUEUE = ["ops"];
+var ALERTS = ["ops", "alerts"];
+var TYPES = ["bug", "feature_request", "error", "alert"];
+var STATUSES = [
+  "open",
+  "triaged",
+  "in_progress",
+  "ready_for_qa",
+  "resolved",
+  "wont_fix"
+];
+var PRIORITIES = ["nice_to_have", "medium", "high", "critical"];
+var COMPARATORS = ["gt", "gte", "lt", "lte"];
+var SEVERITIES = ["danger", "warn", "info"];
+async function resolveSlackChannel(client, idOrName) {
+  const res = await client.ops.channels();
+  if (!res.connected)
+    throw new ApiError("No Slack connector \u2014 connect Slack in Settings \u2192 Notifications first.", 400);
+  const stripped = idOrName.replace(/^#/, "");
+  const byId = res.channels.find((c) => c.id === idOrName);
+  if (byId) return { id: byId.id, name: byId.name };
+  const byName = res.channels.filter((c) => c.name === stripped);
+  if (byName.length === 1) return { id: byName[0].id, name: byName[0].name };
+  if (byName.length > 1)
+    throw new ApiError(`Slack channel name '${stripped}' is ambiguous \u2014 pass a channel id`, 400);
+  throw new ApiError(`Slack channel '${idOrName}' not found (run 'ops alerts channels')`, 404);
+}
+var opsOperations = [
+  // ── unified queue ──────────────────────────────────────────────────────────
+  {
+    group: QUEUE,
+    name: "list",
+    mutates: false,
+    summary: "List the operational queue",
+    description: "List the unified queue \u2014 bugs, feature requests, and auto-filed error/alert tickets. Filter by `type`, `status`, or `priority`.",
+    params: [
+      { name: "type", type: "string", description: "Filter by type.", enum: [...TYPES, "all"] },
+      { name: "status", type: "string", description: "Filter by status.", enum: [...STATUSES, "all"] },
+      { name: "priority", type: "string", description: "Filter by priority.", enum: PRIORITIES },
+      { name: "limit", type: "number", description: "Max rows (default 200)." }
+    ],
+    examples: [
+      { note: "Open critical items only", run: "shipeasy ops list --priority critical" },
+      { note: "Just error tickets", run: "shipeasy ops list --type error" }
+    ],
+    run: async (client, i) => {
+      let items = await client.ops.list({
+        type: str(i, "type") ?? "all",
+        status: str(i, "status") ?? "open",
+        limit: num(i, "limit") ?? 200
+      });
+      const priority = str(i, "priority");
+      if (priority) items = items.filter((x) => x.priority === priority);
+      return items;
+    }
+  },
+  {
+    group: QUEUE,
+    name: "get",
+    mutates: false,
+    summary: "Show one queue item",
+    description: "Show one queue item by number (#7 \u2192 7) or id \u2014 any type.",
+    params: [{ name: "handle", type: "string", description: "Item number or id.", required: true, positional: true }],
+    examples: [{ note: "By queue number", run: "shipeasy ops get 7" }],
+    run: (client, i) => client.ops.get(i.handle)
+  },
+  {
+    group: QUEUE,
+    name: "create",
+    mutates: true,
+    summary: "File a bug or feature request",
+    description: "File an operational item \u2014 a bug report or feature request \u2014 against the bound project. Fires the project's connectors (GitHub issue, Slack). error/alert tickets are auto-filed and cannot be created here.",
+    params: [
+      { name: "type", type: "string", description: "Item type.", required: true, enum: ["bug", "feature_request"] },
+      { name: "title", type: "string", description: "One-line title.", required: true, positional: true },
+      { name: "body", type: "string", description: "Detailed description." },
+      { name: "priority", type: "string", description: "Priority.", enum: PRIORITIES },
+      { name: "stepsToReproduce", type: "string", description: "Repro steps (bugs)." },
+      { name: "pageUrl", type: "string", description: "Page URL the item relates to." }
+    ],
+    examples: [
+      { note: "File a bug", run: 'shipeasy ops create "Checkout 500s on Safari" --type bug' },
+      { note: "File a feature request", run: 'shipeasy ops create "Dark mode" --type feature_request --priority medium' }
+    ],
+    run: (client, i) => client.ops.create({
+      type: i.type,
+      title: i.title,
+      ...i.body ? { body: i.body } : {},
+      ...i.priority ? { priority: i.priority } : {},
+      ...i.stepsToReproduce ? { stepsToReproduce: i.stepsToReproduce } : {},
+      ...i.pageUrl ? { pageUrl: i.pageUrl } : {}
+    })
+  },
+  {
+    group: QUEUE,
+    name: "update",
+    mutates: true,
+    summary: "Update a queue item's status/priority",
+    description: "Flip a queue item's status (any type) and optionally its priority.",
+    params: [
+      { name: "handle", type: "string", description: "Item number or id.", required: true, positional: true },
+      { name: "status", type: "string", description: "New status.", enum: STATUSES },
+      { name: "priority", type: "string", description: "New priority.", enum: PRIORITIES }
+    ],
+    examples: [
+      { note: "Resolve item #7", run: "shipeasy ops update 7 --status resolved" },
+      { note: "Bump priority", run: "shipeasy ops update 7 --priority high" }
+    ],
+    run: (client, i) => {
+      const patch = {};
+      if (i.status !== void 0) patch.status = i.status;
+      if (i.priority !== void 0) patch.priority = i.priority;
+      if (!Object.keys(patch).length)
+        throw new ApiError("Nothing to update \u2014 pass status and/or priority.", 400);
+      return client.ops.update(i.handle, patch);
+    }
+  },
+  {
+    group: QUEUE,
+    name: "link-pr",
+    mutates: true,
+    summary: "Link the PR that fixed an item",
+    description: "Link the PR that fixed a queue item (any type). Records connector_data.github.pr. Pass `remove` to unlink.",
+    params: [
+      { name: "handle", type: "string", description: "Item number or id.", required: true, positional: true },
+      { name: "prNumber", type: "number", description: "PR number.", positional: true },
+      { name: "url", type: "string", description: "Explicit PR URL (required for error/alert tickets)." },
+      { name: "remove", type: "boolean", description: "Unlink the PR instead of setting one." }
+    ],
+    examples: [
+      { note: "Link the fixing PR", run: "shipeasy ops link-pr 7 42 --url https://github.com/acme/app/pull/42" }
+    ],
+    run: (client, i) => {
+      if (i.remove) return client.ops.linkPr(i.handle, { prNumber: null });
+      const prNumber = num(i, "prNumber");
+      if (prNumber === void 0 || !Number.isInteger(prNumber) || prNumber <= 0)
+        throw new ApiError("Pass a positive PR number (or --remove to unlink).", 400);
+      return client.ops.linkPr(i.handle, {
+        prNumber,
+        ...i.url ? { prUrl: i.url } : {}
+      });
+    }
+  },
+  {
+    group: QUEUE,
+    name: "notify",
+    mutates: true,
+    summary: "Raise a 'needs your attention' bell notification",
+    description: "Raise an attention bell notification (agent escalation, create-only). Idempotent on the dedupe key \u2014 pass `item` to derive `feedback:<n>`, or an explicit `key`.",
+    params: [
+      { name: "title", type: "string", description: "One-line headline of what's blocked.", required: true },
+      { name: "summary", type: "string", description: "One sentence: why it can't be fixed in code.", required: true },
+      { name: "steps", type: "json", description: "Steps the human should take, as a JSON array of strings." },
+      { name: "href", type: "string", description: "Dashboard-relative deep link." },
+      { name: "item", type: "string", description: "Queue item number this is about (sets dedupe key feedback:<n>)." },
+      { name: "key", type: "string", description: "Explicit dedupe key (overrides item)." }
+    ],
+    examples: [
+      { note: "Escalate a blocked item", run: `shipeasy ops notify --item 7 --title "Needs a DB migration" --summary "Fix requires a schema change I can't apply in code"` }
+    ],
+    run: (client, i) => {
+      const item = str(i, "item");
+      const dedupeKey = str(i, "key") ?? (item ? `feedback:${item.replace(/^#/, "")}` : void 0);
+      return client.ops.notify({
+        title: i.title,
+        summary: i.summary,
+        steps: i.steps ?? [],
+        ...i.href ? { href: i.href } : {},
+        ...dedupeKey ? { dedupeKey } : {}
+      });
+    }
+  },
+  // ── alert rules (ops alerts …) ───────────────────────────────────────────────
+  {
+    group: ALERTS,
+    name: "list",
+    mutates: false,
+    summary: "List alert rules",
+    description: "List the project's metric-threshold alert rules the analysis cron evaluates.",
+    params: [],
+    examples: [{ run: "shipeasy ops alerts list" }],
+    run: (client) => client.alertRules.list()
+  },
+  {
+    group: ALERTS,
+    name: "channels",
+    mutates: false,
+    summary: "List the project's Slack channels",
+    description: "List the project's Slack channels (for the `slackChannel` alert target).",
+    params: [],
+    examples: [{ run: "shipeasy ops alerts channels" }],
+    run: (client) => client.ops.channels()
+  },
+  {
+    group: ALERTS,
+    name: "create",
+    mutates: true,
+    summary: "Create an alert rule",
+    description: "Create a metric-threshold alert rule. The metric (and its aggregation) is fixed for the rule's life \u2014 delete + recreate to repoint it. Optionally target a Slack channel/email.",
+    params: [
+      { name: "name", type: "string", description: "Rule name.", required: true, positional: true },
+      { name: "metric", type: "string", description: "Metric to evaluate (id or name).", required: true },
+      { name: "comparator", type: "string", description: "Comparison operator.", required: true, enum: COMPARATORS },
+      { name: "threshold", type: "number", description: "Threshold the metric value is compared against.", required: true },
+      { name: "window", type: "number", description: "Lookback window in whole hours (1\u2013720). Defaults to 24." },
+      { name: "severity", type: "string", description: "Severity. Defaults to warn.", enum: SEVERITIES },
+      { name: "disabled", type: "boolean", description: "Create the rule disabled." },
+      { name: "slackChannel", type: "string", description: "Slack channel to post to (id or name)." },
+      { name: "email", type: "string", description: "Email address to notify." }
+    ],
+    examples: [
+      { note: "Alert when error rate exceeds 50 / 24h", run: "shipeasy ops alerts create high-error-rate --metric api-errors --comparator gt --threshold 50" },
+      { note: "Post to a Slack channel + email on-call", run: "shipeasy ops alerts create high-error-rate --metric api-errors --comparator gt --threshold 50 --slack-channel '#incidents' --email oncall@acme.com" }
+    ],
+    run: async (client, i) => {
+      const metric = await client.metrics.resolve(i.metric);
+      const slackChannel = str(i, "slackChannel");
+      const email = str(i, "email");
+      const notify = slackChannel || email ? {
+        slackChannel: slackChannel ? await resolveSlackChannel(client, slackChannel) : null,
+        email: email ?? null
+      } : void 0;
+      return client.alertRules.create({
+        name: i.name,
+        metricId: metric.id,
+        comparator: i.comparator,
+        threshold: num(i, "threshold"),
+        windowHours: num(i, "window") ?? 24,
+        severity: str(i, "severity") ?? "warn",
+        enabled: !i.disabled,
+        ...notify ? { notify } : {}
+      });
+    }
+  },
+  {
+    group: ALERTS,
+    name: "update",
+    mutates: true,
+    summary: "Update an alert rule",
+    description: "Update an alert rule's tunable knobs (by id, id-prefix, or unique name). The metric is immutable. Pass `clearTarget` to revert the rule's target to the project default.",
+    params: [
+      { name: "rule", type: "string", description: "Rule id, id-prefix, or name.", required: true, positional: true },
+      { name: "name", type: "string", description: "New human label." },
+      { name: "comparator", type: "string", description: "Comparison operator.", enum: COMPARATORS },
+      { name: "threshold", type: "number", description: "New threshold." },
+      { name: "window", type: "number", description: "New lookback window in whole hours (1\u2013720)." },
+      { name: "severity", type: "string", description: "New severity.", enum: SEVERITIES },
+      { name: "enabled", type: "boolean", description: "Enable/disable the rule." },
+      { name: "slackChannel", type: "string", description: "Set the Slack channel target (id or name)." },
+      { name: "email", type: "string", description: "Set the email target." },
+      { name: "clearTarget", type: "boolean", description: "Clear the target back to the project default." }
+    ],
+    examples: [
+      { note: "Raise the threshold", run: "shipeasy ops alerts update high-error-rate --threshold 100" },
+      { note: "Disable a rule", run: "shipeasy ops alerts update high-error-rate --enabled false" }
+    ],
+    run: async (client, i) => {
+      const rule = await client.alertRules.resolve(i.rule);
+      const patch = {};
+      if (i.name !== void 0) patch.name = i.name;
+      if (i.comparator !== void 0) patch.comparator = i.comparator;
+      if (i.threshold !== void 0) patch.threshold = num(i, "threshold");
+      if (i.window !== void 0) patch.windowHours = num(i, "window");
+      if (i.severity !== void 0) patch.severity = i.severity;
+      if (i.enabled !== void 0) patch.enabled = i.enabled;
+      const slackChannel = str(i, "slackChannel");
+      const email = str(i, "email");
+      if (i.clearTarget) {
+        patch.notify = { slackChannel: null, email: null };
+      } else if (slackChannel || email) {
+        patch.notify = {
+          slackChannel: slackChannel ? await resolveSlackChannel(client, slackChannel) : rule.notify?.slackChannel ?? null,
+          email: email ?? rule.notify?.email ?? null
+        };
+      }
+      if (!Object.keys(patch).length)
+        throw new ApiError("Nothing to update \u2014 pass at least one field to change.", 400);
+      return client.alertRules.update(rule.id, patch);
+    }
+  },
+  {
+    group: ALERTS,
+    name: "archive",
+    mutates: true,
+    summary: "Archive an alert rule",
+    description: "Archive (delete) an alert rule by id, id-prefix, or unique name.",
+    params: [{ name: "rule", type: "string", description: "Rule id, id-prefix, or name.", required: true, positional: true }],
+    examples: [{ run: "shipeasy ops alerts archive high-error-rate" }],
+    run: async (client, i) => {
+      const rule = await client.alertRules.resolve(i.rule);
+      await client.alertRules.delete(rule.id);
+      return { ok: true, archived: rule.name };
+    }
+  }
+];
+
+// src/operations/projects.ts
+var GROUP7 = ["projects"];
+var projectOperations = [
+  {
+    group: GROUP7,
+    name: "current",
+    mutates: false,
+    summary: "Show the current project",
+    description: "Return the project the session resolves to (plan, status, enabled modules, billing). The server reads the project from the auth header \u2014 no id needed. Powers `whoami`.",
+    params: [],
+    examples: [{ run: "shipeasy projects current" }],
+    run: (client) => client.projects.current()
+  },
+  {
+    group: GROUP7,
+    name: "upsert",
+    mutates: false,
+    summary: "Find-or-create a project by domain",
+    description: "Find-or-create a project by domain (idempotent), under the session's owner. Returns the project. The `.shipeasy` bind that records the result locally is a consumer side-effect layered on top of this op \u2014 it is not performed here.",
+    params: [
+      { name: "domain", type: "string", description: "Hostname-like project identifier (e.g. acme.com).", required: true },
+      { name: "name", type: "string", description: "Human-readable name (defaults to the domain on first create)." }
+    ],
+    examples: [
+      { note: "Find-or-create by domain", run: "shipeasy projects upsert --domain acme.com" },
+      { note: "Name it explicitly", run: 'shipeasy projects upsert --domain shouks.app --name "Shouks"' }
+    ],
+    run: (client, i) => client.projects.upsert({
+      domain: i.domain,
+      ...i.name ? { name: i.name } : {}
+    })
+  }
+];
+
+// src/operations/i18n.ts
+var I18N = ["i18n"];
+var PROFILES = ["i18n", "profiles"];
+var DRAFTS = ["i18n", "drafts"];
+var i18nOperations = [
+  {
+    group: PROFILES,
+    name: "list",
+    mutates: false,
+    summary: "List i18n locale profiles",
+    description: "List the project's i18n locale profiles (name, default locale, locales).",
+    params: [],
+    examples: [{ run: "shipeasy i18n profiles list" }],
+    run: (client) => client.i18n.listProfiles()
+  },
+  {
+    group: PROFILES,
+    name: "create",
+    mutates: true,
+    summary: "Create an i18n locale profile",
+    description: "Create an i18n profile (e.g. 'en:prod', 'fr:prod') with one or more locales.",
+    params: [
+      { name: "name", type: "string", description: "Profile name.", required: true, positional: true },
+      { name: "locales", type: "json", description: `Locales as a JSON array, e.g. '["fr","fr-CA"]'. Defaults to ["en"].` },
+      { name: "defaultLocale", type: "string", description: "Default locale (defaults to the first locale)." }
+    ],
+    examples: [
+      { run: "shipeasy i18n profiles create en:prod" },
+      { note: "Multiple locales with a default", run: `shipeasy i18n profiles create fr:prod --locales '["fr","fr-CA"]' --default-locale fr` }
+    ],
+    run: (client, i) => {
+      const locales = i.locales ?? ["en"];
+      return client.i18n.createProfile({
+        name: i.name,
+        locales,
+        default_locale: str(i, "defaultLocale") ?? locales[0]
+      });
+    }
+  },
+  {
+    group: I18N,
+    name: "push",
+    mutates: true,
+    summary: "Add new i18n keys (insert-only)",
+    description: "Add NEW keys to a profile. Insert-only \u2014 existing keys are never overwritten (use `i18n update` to change a value). Keys are a JSON array of {key,value}.",
+    params: [
+      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
+      { name: "keys", type: "json", description: `Keys as a JSON array, e.g. '[{"key":"home.cta","value":"Get started"}]'.`, required: true },
+      { name: "chunk", type: "string", description: "Logical grouping for the keys. Defaults to 'default'." }
+    ],
+    examples: [
+      { note: "Add keys to a profile", run: `shipeasy i18n push --profile en:prod --keys '[{"key":"home.cta","value":"Get started"}]'` }
+    ],
+    run: async (client, i) => {
+      const profile = await client.i18n.resolveProfile(i.profile);
+      return client.i18n.pushKeys({
+        profile_id: profile.id,
+        chunk: str(i, "chunk") ?? "default",
+        keys: i.keys
+      });
+    }
+  },
+  {
+    group: I18N,
+    name: "update",
+    mutates: true,
+    summary: "Update one i18n key's value",
+    description: "Change the value of a single existing key (the only overwrite path; `push` only adds). One key per call.",
+    params: [
+      { name: "key", type: "string", description: "Key name.", required: true, positional: true },
+      { name: "value", type: "string", description: "New value.", required: true, positional: true },
+      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
+      { name: "description", type: "string", description: "Optional description to store with the key." }
+    ],
+    examples: [
+      { note: "Change one key's value", run: "shipeasy i18n update home.cta 'Get started' --profile en:prod" }
+    ],
+    run: async (client, i) => {
+      const profile = await client.i18n.resolveProfile(i.profile);
+      return client.i18n.updateKeyByName(profile.id, i.key, {
+        value: i.value,
+        ...i.description !== void 0 ? { description: i.description } : {}
+      });
+    }
+  },
+  {
+    group: I18N,
+    name: "publish",
+    mutates: true,
+    summary: "Publish a profile chunk to the CDN",
+    description: "Publish a profile chunk (rebuilds the KV manifest and purges the CDN).",
+    params: [
+      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
+      { name: "chunk", type: "string", description: "Chunk to publish. Defaults to 'default'." }
+    ],
+    examples: [
+      { note: "Publish the default chunk", run: "shipeasy i18n publish --profile en:prod" },
+      { note: "Publish a specific chunk", run: "shipeasy i18n publish --profile fr:prod --chunk marketing" }
+    ],
+    run: async (client, i) => {
+      const profile = await client.i18n.resolveProfile(i.profile);
+      return client.i18n.publish(profile.id, { chunk: str(i, "chunk") ?? "default" });
+    }
+  },
+  {
+    group: DRAFTS,
+    name: "list",
+    mutates: false,
+    summary: "List staged i18n drafts",
+    description: "List staged translation drafts. Replaces the `drafts` kind of the deleted MCP generic read.",
+    params: [],
+    examples: [{ run: "shipeasy i18n drafts list" }],
+    run: (client) => client.i18n.listDrafts()
+  }
+];
+
+// src/operations/attributes.ts
+var attributeOperations = [
+  {
+    group: ["attributes"],
+    name: "list",
+    mutates: false,
+    summary: "List targeting attributes",
+    description: "List the auto-inferred user-attribute schema available for gate/experiment targeting.",
+    params: [],
+    examples: [{ run: "shipeasy attributes list" }],
+    run: (client) => client.attributes.list()
+  }
+];
+
+// src/operations/sdk-docs.ts
+var SDK_REPOS = {
+  typescript: { owner: "shipeasy-ai", repo: "sdk" },
+  javascript: { owner: "shipeasy-ai", repo: "sdk" },
+  node: { owner: "shipeasy-ai", repo: "sdk" },
+  ts: { owner: "shipeasy-ai", repo: "sdk" },
+  python: { owner: "shipeasy-ai", repo: "sdk-python" },
+  go: { owner: "shipeasy-ai", repo: "sdk-go" },
+  java: { owner: "shipeasy-ai", repo: "sdk-java" },
+  kotlin: { owner: "shipeasy-ai", repo: "sdk-kotlin" },
+  php: { owner: "shipeasy-ai", repo: "sdk-php" },
+  swift: { owner: "shipeasy-ai", repo: "sdk-swift" },
+  ruby: { owner: "shipeasy-ai", repo: "sdk-ruby" }
+};
+var SDK_ENUM = Object.keys(SDK_REPOS);
+var DEFAULT_MANIFEST = {
+  schemaVersion: 2,
+  sdk: "default",
+  placeholders: ["RESOURCE_NAME"],
+  skill: "skill/SKILL.md",
+  pages: { overview: "pages/overview.md", installation: "pages/installation.md" },
+  snippets: { release: { flags: "snippets/release/flags.md" } }
+};
+var DEFAULT_CONTENT = {
+  "pages/overview.md": "# Shipeasy SDK\n\nThis SDK has not published its `/docs/` folder yet. See https://docs.shipeasy.ai for the full reference.",
+  "pages/installation.md": "# Installation\n\nInstall the Shipeasy SDK for your language, then call `shipeasy({ serverKey })` (server) or `shipeasy({ clientKey })` (browser).",
+  "snippets/release/flags.md": "```\nconst on = await client.checkGate(user, '{{RESOURCE_NAME}}');\n```",
+  "skill/SKILL.md": "---\nname: shipeasy-sdk\ndescription: Use the Shipeasy SDK for flags, experiments, configs, and i18n.\n---\n\nThis SDK has not published a skill yet. See https://docs.shipeasy.ai."
+};
+function repoFor(sdk) {
+  const r = SDK_REPOS[sdk.toLowerCase()];
+  if (!r) throw new ApiError(`Unknown SDK '${sdk}'. One of: ${SDK_ENUM.join(", ")}`, 400);
+  return r;
+}
+function pagesBase(sdk) {
+  const { owner, repo } = repoFor(sdk);
+  return `https://${owner}.github.io/${repo}`;
+}
+async function fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  return res.text();
+}
+async function loadManifest(sdk) {
+  const text = await fetchText(`${pagesBase(sdk)}/manifest.json`);
+  if (!text) return { manifest: DEFAULT_MANIFEST, fallback: true };
+  try {
+    return { manifest: JSON.parse(text), fallback: false };
+  } catch {
+    return { manifest: DEFAULT_MANIFEST, fallback: true };
+  }
+}
+function resolvePath(manifest, handle) {
+  if (handle.endsWith(".md")) return handle;
+  if (manifest.pages?.[handle]) return manifest.pages[handle];
+  if (handle.includes("/")) {
+    const [group, resource] = handle.split("/", 2);
+    const p = manifest.snippets?.[group]?.[resource];
+    if (p) return p;
+  }
+  throw new ApiError(
+    `Doc '${handle}' not found. Run 'docs list --sdk <lang>' to see available pages and snippets.`,
+    404
+  );
+}
+function substitute(body, manifest, i) {
+  let out = body;
+  for (const ph of manifest.placeholders ?? []) {
+    const value = str(i, ph) ?? (ph === "RESOURCE_NAME" ? str(i, "name") : void 0) ?? (ph === "FRAMEWORK" ? str(i, "framework") : void 0);
+    if (value !== void 0) out = out.replaceAll(`{{${ph}}}`, value);
+  }
+  return out;
+}
+var docsOperations = [
+  {
+    group: ["docs"],
+    name: "list",
+    mutates: false,
+    summary: "List an SDK's documentation tree",
+    description: "Fetch an SDK's `/docs/manifest.json` and return the doc tree \u2014 the feature-reference pages, the nested snippet groups, and whether an installable skill exists. The runtime 'explore' step before fetching a specific page or snippet.",
+    params: [{ name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM }],
+    examples: [{ run: "shipeasy docs list --sdk python" }],
+    run: async (_client, i) => {
+      const { manifest, fallback } = await loadManifest(i.sdk);
+      return {
+        sdk: i.sdk,
+        fallback,
+        pages: Object.keys(manifest.pages ?? {}),
+        snippets: Object.fromEntries(
+          Object.entries(manifest.snippets ?? {}).map(([g, r]) => [g, Object.keys(r)])
+        ),
+        skill: Boolean(manifest.skill)
+      };
+    }
+  },
+  {
+    group: ["docs"],
+    name: "get",
+    mutates: false,
+    summary: "Fetch one SDK doc page or snippet",
+    description: "Fetch one feature-reference page (`flags`, `experiments`, \u2026) or nested snippet (`release/experiments`, `i18n/setup`, \u2026) from the SDK's published docs, substituting declared {{placeholders}} from caller args. Replaces the old `get_sdk_snippet`.",
+    params: [
+      { name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM },
+      { name: "path", type: "string", description: "Page key or snippet 'group/resource'.", required: true, positional: true },
+      { name: "framework", type: "string", description: "Framework hint (substitutes {{FRAMEWORK}})." },
+      { name: "name", type: "string", description: "Resource name (substitutes {{RESOURCE_NAME}})." }
+    ],
+    examples: [
+      { note: "A feature page", run: "shipeasy docs get --sdk python experiments" },
+      { note: "A nested snippet, with a resource name", run: "shipeasy docs get --sdk typescript release/flags --name checkout_v2" }
+    ],
+    run: async (_client, i) => {
+      const sdk = i.sdk;
+      const { manifest, fallback } = await loadManifest(sdk);
+      const path = resolvePath(manifest, i.path);
+      const body = fallback ? DEFAULT_CONTENT[path] : await fetchText(`${pagesBase(sdk)}/${path}`) ?? void 0;
+      if (body === void 0) throw new ApiError(`Doc '${path}' could not be fetched for '${sdk}'.`, 404);
+      return { sdk, path, fallback, content: substitute(body, manifest, i) };
+    }
+  },
+  {
+    group: ["docs"],
+    name: "skill",
+    mutates: false,
+    summary: "Fetch an SDK's installable LLM skill",
+    description: "Fetch the SDK's `skill/SKILL.md` (YAML frontmatter intact) so an agent can install it verbatim into its skills directory. The CLI's `--install` writes it locally (a consumer fs side-effect layered on the fetch); the op itself just returns the bytes.",
+    params: [
+      { name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM },
+      { name: "install", type: "boolean", description: "CLI only: write the skill to the local agent skills dir." }
+    ],
+    examples: [
+      { run: "shipeasy docs skill --sdk python" },
+      { note: "Install into the local skills dir", run: "shipeasy docs skill --sdk python --install true" }
+    ],
+    run: async (_client, i) => {
+      const sdk = i.sdk;
+      const { manifest, fallback } = await loadManifest(sdk);
+      const skillPath = manifest.skill ?? "skill/SKILL.md";
+      const content = fallback ? DEFAULT_CONTENT[skillPath] : await fetchText(`${pagesBase(sdk)}/${skillPath}`) ?? void 0;
+      if (content === void 0) throw new ApiError(`No skill published for '${sdk}'.`, 404);
+      return { sdk, skillPath, fallback, content };
+    }
+  }
+];
+
+// src/operations/index.ts
+var RELEASE_OPERATIONS = [
+  ...gateOperations,
+  ...killswitchOperations,
+  ...configOperations,
+  ...experimentOperations,
+  ...universeOperations
+];
+var ALL_OPERATIONS = [
+  ...RELEASE_OPERATIONS,
+  ...metricOperations,
+  ...eventOperations,
+  ...opsOperations,
+  ...projectOperations,
+  ...i18nOperations,
+  ...attributeOperations,
+  ...docsOperations
+];
+export {
+  ALL_OPERATIONS,
+  METRIC_GRAMMAR,
+  RELEASE_OPERATIONS,
+  attributeOperations,
+  coerceInput,
+  configOperations,
+  docsOperations,
+  eventOperations,
+  experimentOperations,
+  gateOperations,
+  i18nOperations,
+  killswitchOperations,
+  metricOperations,
+  mountOperations,
+  opCli,
+  opId,
+  opMcpName,
+  operationsToDispatch,
+  operationsToMcpTools,
+  opsOperations,
+  projectOperations,
+  renderOperationsMarkdown,
+  universeOperations
+};