@lizard-build/cli 4.0.43 → 4.0.45

package/src/commands/skill.ts

@@ -11,24 +11,16 @@ import { EMBEDDED_SKILLS } from "../lib/skills-data.generated.js";
 //
 // LIZARD_SKILLS_DIR overrides the embedded source with a real directory — useful
 // for authoring new skills locally without a rebuild.
+//
+// A skill is SKILL.md plus optional references/<ref>.md files that go deeper on
+// one part of the platform; `lizard skills get <name> --ref <ref>` prints one.
 
 interface Source {
   list(): string[];
   read(name: string): string | null;
-  pathOf(name?: string): string;
-}
-
-/** Inline `<!-- include: _shared/x.md -->` lines, as scripts/gen-skills.mjs does for the embedded copy. */
-export function expandIncludes(md: string, root: string): string {
-  return md.replace(/^<!-- include: ([\w./-]+) -->$/gm, (line, rel: string) => {
-    const file = path.resolve(root, rel);
-    if (!file.startsWith(path.resolve(root) + path.sep)) return line;
-    try {
-      return readFileSync(file, "utf8").trimEnd();
-    } catch {
-      return line;
-    }
-  });
+  refs(name: string): string[];
+  readRef(name: string, ref: string): string | null;
+  pathOf(name?: string, ref?: string): string;
 }
 
 function fsSource(dir: string): Source {
@@ -37,7 +29,6 @@ function fsSource(dir: string): Source {
       try {
         return readdirSync(dir)
           .filter((name) => {
-            if (name.startsWith("_")) return false;
             try {
               return statSync(path.join(dir, name)).isDirectory();
             } catch {
@@ -51,12 +42,34 @@ function fsSource(dir: string): Source {
     },
     read: (name) => {
       try {
-        return expandIncludes(readFileSync(path.join(dir, name, "SKILL.md"), "utf8"), dir);
+        return readFileSync(path.join(dir, name, "SKILL.md"), "utf8");
+      } catch {
+        return null;
+      }
+    },
+    refs: (name) => {
+      try {
+        return readdirSync(path.join(dir, name, "references"))
+          .filter((f) => f.endsWith(".md"))
+          .map((f) => f.slice(0, -3))
+          .sort();
+      } catch {
+        return [];
+      }
+    },
+    readRef: (name, ref) => {
+      try {
+        return readFileSync(path.join(dir, name, "references", `${ref}.md`), "utf8");
       } catch {
         return null;
       }
     },
-    pathOf: (name) => (name ? path.join(dir, name, "SKILL.md") : dir),
+    pathOf: (name, ref) => {
+      if (!name) return dir;
+      return ref
+        ? path.join(dir, name, "references", `${ref}.md`)
+        : path.join(dir, name, "SKILL.md");
+    },
   };
 }
 
@@ -64,8 +77,14 @@ function embeddedSource(): Source {
   return {
     list: () => Object.keys(EMBEDDED_SKILLS).sort(),
     read: (name) => EMBEDDED_SKILLS[name]?.content ?? null,
-    pathOf: (name) =>
-      name ? `embedded://skills/${name}/SKILL.md` : "embedded://skills",
+    refs: (name) => Object.keys(EMBEDDED_SKILLS[name]?.references ?? {}).sort(),
+    readRef: (name, ref) => EMBEDDED_SKILLS[name]?.references[ref] ?? null,
+    pathOf: (name, ref) => {
+      if (!name) return "embedded://skills";
+      return ref
+        ? `embedded://skills/${name}/references/${ref}.md`
+        : `embedded://skills/${name}/SKILL.md`;
+    },
   };
 }
 
@@ -111,6 +130,29 @@ function readSkill(
   return { md, meta: parseFrontmatter(md) };
 }
 
+function readRef(src: Source, name: string, ref: string): string {
+  readSkill(src, name);
+  const md = src.readRef(name, ref);
+  if (md == null) {
+    const refs = src.refs(name);
+    throw new Error(
+      `Reference '${ref}' not found in skill '${name}'. ` +
+        (refs.length
+          ? `Available: ${refs.join(", ")}.`
+          : `This skill has no references.`),
+    );
+  }
+  return md;
+}
+
+function refEntries(src: Source, name: string) {
+  return src.refs(name).map((ref) => ({
+    name: ref,
+    path: src.pathOf(name, ref),
+    command: `lizard skills get ${name} --ref ${ref}`,
+  }));
+}
+
 function shortDesc(desc: string, max = 100): string {
   const oneLine = desc.replace(/\s+/g, " ").trim();
   return oneLine.length > max ? oneLine.slice(0, max - 1) + "…" : oneLine;
@@ -132,12 +174,13 @@ export function registerSkill(program: Command) {
         printJSON({
           dir: src.pathOf(),
           skills: names.map((n) => {
+            let description = "";
             try {
-              const { meta } = readSkill(src, n);
-              return { name: n, description: meta.description || "" };
+              description = readSkill(src, n).meta.description || "";
             } catch {
-              return { name: n, description: "" };
+              // unreadable SKILL.md: list it without a description
             }
+            return { name: n, description, references: src.refs(n) };
           }),
         });
         return;
@@ -147,38 +190,54 @@ export function registerSkill(program: Command) {
         return;
       }
       const rows = names.map((n) => {
+        let description = "";
         try {
-          const { meta } = readSkill(src, n);
-          return [n, shortDesc(meta.description || "")];
+          description = shortDesc(readSkill(src, n).meta.description || "");
         } catch {
-          return [n, ""];
+          // unreadable SKILL.md: list it without a description
         }
+        return [n, description, src.refs(n).join(", ")];
       });
-      table(["name", "description"], rows);
+      table(["name", "description", "references"], rows);
     });
 
   skill
     .command("get")
-    .description("Print a skill's full content (markdown)")
+    .description("Print a skill's content (markdown), or one of its references")
     .argument("<name>", "skill name (e.g. core)")
-    .option(
-      "--full",
-      "Include reference files (reserved; currently equivalent to default)",
-    )
-    .action((name: string, _opts: { full?: boolean }) => {
+    .option("--ref <ref>", "print one reference instead (e.g. sandboxes, deploys, sdk)")
+    .option("--full", "append every reference after the skill")
+    .action((name: string, opts: { ref?: string; full?: boolean }) => {
       const src = getSource();
       try {
+        if (opts.ref) {
+          const md = readRef(src, name, opts.ref);
+          if (isJSONMode()) {
+            printJSON({ name, ref: opts.ref, path: src.pathOf(name, opts.ref), content: md });
+            return;
+          }
+          process.stdout.write(md.endsWith("\n") ? md : md + "\n");
+          return;
+        }
         const { md, meta } = readSkill(src, name);
+        let content = md;
+        if (opts.full) {
+          for (const ref of src.refs(name)) {
+            const body = src.readRef(name, ref) ?? "";
+            content = `${content.trimEnd()}\n\n---\n<!-- references/${ref}.md -->\n\n${body}`;
+          }
+        }
         if (isJSONMode()) {
           printJSON({
             name,
             path: src.pathOf(name),
             frontmatter: meta,
-            content: md,
+            content,
+            references: refEntries(src, name),
           });
           return;
         }
-        process.stdout.write(md.endsWith("\n") ? md : md + "\n");
+        process.stdout.write(content.endsWith("\n") ? content : content + "\n");
       } catch (e: any) {
         fail(e.message, 3);
       }
@@ -188,9 +247,10 @@ export function registerSkill(program: Command) {
     .command("path")
     .description("Print the filesystem path of a skill (or the skills root)")
     .argument("[name]", "skill name; omit to print the skills directory")
-    .action((name?: string) => {
+    .option("--ref <ref>", "print the path of one reference instead")
+    .action((name: string | undefined, opts: { ref?: string }) => {
       const src = getSource();
-      const target = src.pathOf(name);
+      const target = src.pathOf(name, name ? opts.ref : undefined);
       if (isJSONMode()) {
         printJSON({ path: target });
         return;

package/src/index.ts

@@ -6,7 +6,6 @@ import { setJSONMode, isJSONMode, error } from "./lib/format.js";
 import { requireAuth, isLoggedIn } from "./lib/auth.js";
 import { setBaseURL, setAccessToken, APIError, isProjectDeletedError, isAccountScopeError } from "./lib/api.js";
 import { checkForUpdateInBackground, runBackgroundUpdate, CURRENT_VERSION } from "./lib/updater.js";
-import { skillFor } from "./lib/skill-route.js";
 
 const BANNER = chalk.rgb(16, 185, 129)(
   [
@@ -28,34 +27,37 @@ const BANNER = chalk.rgb(16, 185, 129)(
 // of guessing commands from flag docs alone.
 const AGENTS_HELP = [
   chalk.bold("Start here (for AI agents):"),
-  "  " + chalk.cyan("lizard skills get sandbox") + chalk.dim("   sandboxes: run code, files, ports, snapshots, desktop, agents"),
-  "  " + chalk.cyan("lizard skills get core") + chalk.dim("      deploys: services, databases, builds, secrets, domains"),
+  "  " + chalk.cyan("lizard skills get core"),
   "",
   chalk.dim(
-    "  Skills ship with the CLI (always version-matched) and come with copy-paste",
+    "  Skills ship with the CLI (always version-matched) and cover sandboxes and the full app",
   ),
   chalk.dim(
-    "  examples. Prefer them over guessing commands from flag docs alone.",
+    "  lifecycle — deploy, link, addons, logs, scaling, secrets, domains — with",
+  ),
+  chalk.dim(
+    "  copy-paste examples. Prefer this over guessing commands from flag docs alone.",
+  ),
+  chalk.dim(
+    "  For more depth: lizard skills get core --ref sandboxes | deploys | sdk",
   ),
 ].join("\n");
 
-
 // Compact form of the same pointer, shown on every subcommand's `--help` so the
 // per-command flag docs never read as the whole story. Mirrors the `agents`
 // block that `--help --json` already emits for every command; one tight line so
 // it sits above a subcommand's Usage without crowding it.
-const agentsHelpCompact = (skill: string) =>
+const AGENTS_HELP_COMPACT =
   chalk.bold("For AI agents:") +
   " run " +
-  chalk.cyan(`lizard skills get ${skill}`) +
+  chalk.cyan("lizard skills get core") +
   chalk.dim(" for version-matched usage and examples.");
 
-/** Attach the compact agents pointer to every (nested) subcommand's help, naming the skill for its subtree. */
-function addAgentsPointerToSubcommands(cmd: Command, skill?: string) {
+/** Attach the compact agents pointer to every (nested) subcommand's help. */
+function addAgentsPointerToSubcommands(cmd: Command) {
   for (const sub of cmd.commands) {
-    const own = skill ?? skillFor(sub.name());
-    sub.addHelpText("before", agentsHelpCompact(own) + "\n");
-    addAgentsPointerToSubcommands(sub, own);
+    sub.addHelpText("before", AGENTS_HELP_COMPACT + "\n");
+    addAgentsPointerToSubcommands(sub);
   }
 }
 
@@ -275,13 +277,6 @@ function findTargetCommand(
   return { target: cur, unknown: null };
 }
 
-/** The command directly under the root that `cmd` belongs to. */
-function topLevelOf(cmd: Command): Command {
-  let top = cmd;
-  while (top.parent && top.parent !== program) top = top.parent;
-  return top;
-}
-
 function dumpOption(o: any) {
   return {
     flags: o.flags,
@@ -394,9 +389,8 @@ async function main() {
       cli: "lizard",
       version: CURRENT_VERSION,
       agents: {
-        start: `lizard skills get ${isRoot ? "core" : skillFor(topLevelOf(target).name())}`,
-        skills: { sandbox: "lizard skills get sandbox", core: "lizard skills get core" },
-        note: "Skills ship with this CLI version, with copy-paste examples: `sandbox` for sandboxes (run code, files, ports, snapshots, desktop, coding agents), `core` for deploys (services, databases, builds, secrets, domains). Prefer them over guessing commands from flag docs alone.",
+        start: "lizard skills get core",
+        note: "Skills ship with this CLI version and cover sandboxes and the full app lifecycle (deploy, link, addons, logs, scaling, secrets, domains) with copy-paste examples. Prefer this over guessing commands from flag docs alone. For more depth: `lizard skills get core --ref sandboxes|deploys|sdk`.",
       },
       command: dumpCommand(target),
       globalOptions: isRoot

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "4.0.43";
+export const CURRENT_VERSION = "4.0.45";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
 

package/test/unit/skills.test.ts

@@ -1,78 +1,55 @@
-import { describe, expect, test, afterEach } from "vitest";
-import * as path from "node:path";
+import { describe, expect, test } from "vitest";
 import { EMBEDDED_SKILLS } from "../../src/lib/skills-data.generated.js";
-import { expandIncludes } from "../../src/commands/skill.js";
-import { skillFor } from "../../src/lib/skill-route.js";
-import * as fs from "node:fs";
 
-const SKILL_DATA = path.resolve(import.meta.dirname, "../../skill-data");
+const core = EMBEDDED_SKILLS.core;
+const files: Record<string, string> = {
+  "SKILL.md": core.content,
+  ...Object.fromEntries(Object.entries(core.references).map(([ref, md]) => [`references/${ref}.md`, md])),
+};
 
-function frontmatter(md: string): Record<string, string> {
-  const block = md.slice(4, md.indexOf("\n---", 3));
-  return Object.fromEntries(
-    block.split("\n").map((l) => l.match(/^([\w-]+):\s*"?(.*?)"?$/)).filter(Boolean).map((m) => [m![1], m![2]]),
-  );
-}
-
-/** GitHub-style heading slug, which the skills' own links use. */
+/** GitHub-style heading slug, which the skill's own links use. */
 const slug = (h: string) => h.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
 
-describe("embedded skills", () => {
-  test("ship core and sandbox, and not the shared parts as a skill", () => {
-    expect(Object.keys(EMBEDDED_SKILLS).sort()).toEqual(["core", "sandbox"]);
+describe("the core skill", () => {
+  test("is the only embedded skill", () => {
+    expect(Object.keys(EMBEDDED_SKILLS)).toEqual(["core"]);
   });
 
-  test.each(["core", "sandbox"])("%s has the shared basics inlined", (name) => {
-    const md = EMBEDDED_SKILLS[name].content;
-    expect(md).not.toContain("<!-- include");
-    for (const h of ["## Execution rules", "## Discovery", "## Sign-in", "## Exit codes", "## Default project", "## Billing"]) {
-      expect(md).toContain(`\n${h}\n`);
+  test("ships the sandboxes, deploys and sdk references, and names each one", () => {
+    expect(Object.keys(core.references).sort()).toEqual(["deploys", "sandboxes", "sdk"]);
+    for (const ref of Object.keys(core.references)) {
+      expect(core.content).toContain(`--ref ${ref}`);
     }
   });
 
-  test.each(["core", "sandbox"])("%s: every #link points at a heading in the same skill", (name) => {
-    const md = EMBEDDED_SKILLS[name].content;
-    const headings = new Set([...md.matchAll(/^#{2,3} (.+)$/gm)].map((m) => slug(m[1])));
-    const links = [...md.matchAll(/\]\(#([\w-]+)\)/g)].map((m) => m[1]);
-    expect(links.filter((l) => !headings.has(l))).toEqual([]);
-  });
-
-  test("descriptions fit the 1024-character limit and say who they are for", () => {
-    const core = frontmatter(EMBEDDED_SKILLS.core.content);
-    const sandbox = frontmatter(EMBEDDED_SKILLS.sandbox.content);
-    expect(sandbox.name).toBe("lizard-sandbox");
-    expect(core.description.length).toBeLessThanOrEqual(1024);
-    expect(sandbox.description.length).toBeLessThanOrEqual(1024);
-    expect(sandbox.description).toMatch(/^Creates and manages Lizard sandboxes/);
+  test("covers the whole platform in SKILL.md", () => {
+    for (const h of ["Sign-in", "Exit codes", "Default project", "Sandboxes", "Deploys", "Databases and storage", "Secrets and config", "Domains", "Billing"]) {
+      expect(core.content).toContain(`\n## ${h}\n`);
+    }
+    expect(core.content).not.toContain("lizard skills get sandbox ");
   });
 
-  test("sandbox work lives only in the sandbox skill, and core points there", () => {
-    const core = EMBEDDED_SKILLS.core.content;
-    const sandbox = EMBEDDED_SKILLS.sandbox.content;
-    expect(core).not.toMatch(/^## Sandboxes/m);
-    expect(core).toContain("lizard skills get sandbox --json");
-    for (const h of ["## Quickstart", "## Templates", "## Lifetime", "## Snapshots and pause/resume", "## From code: Lizard SDK"]) {
-      expect(sandbox).toContain(`\n${h}\n`);
-    }
-    expect(sandbox).toContain("lizard skills get core --json");
+  test("keeps SKILL.md under 500 lines", () => {
+    const body = core.content.replace(/^---\n[\s\S]*?\n---\n/, "");
+    expect(body.split("\n").length).toBeLessThan(500);
   });
-});
 
-describe("skill routing in --help", () => {
-  test("sandbox, volume and agents point at the sandbox skill, the rest at core", () => {
-    expect(["sandbox", "volume", "agents"].map(skillFor)).toEqual(["sandbox", "sandbox", "sandbox"]);
-    expect(["up", "logs", "secrets", "add"].map(skillFor)).toEqual(["core", "core", "core", "core"]);
+  test.each(Object.keys(files))("every #link in %s points at a heading in the same file", (file) => {
+    const md = files[file];
+    const headings = new Set([...md.matchAll(/^#{1,4} (.+)$/gm)].map((m) => slug(m[1])));
+    const links = [...md.matchAll(/\]\(#([\w-]+)\)/g)].map((m) => m[1]);
+    expect(links.filter((l) => !headings.has(l))).toEqual([]);
   });
-});
 
-describe("LIZARD_SKILLS_DIR (authoring from files)", () => {
-  test("includes expand the same way as the embedded copy", () => {
-    const raw = fs.readFileSync(path.join(SKILL_DATA, "sandbox", "SKILL.md"), "utf8");
-    expect(expandIncludes(raw, SKILL_DATA)).toBe(EMBEDDED_SKILLS.sandbox.content);
+  test("references never link to other files", () => {
+    for (const md of Object.values(core.references)) {
+      expect(md).not.toMatch(/\]\((?!https?:|#)[^)]+\)/);
+    }
   });
 
-  test("an include outside the skills folder is left as it is", () => {
-    const line = "<!-- include: ../package.json -->";
-    expect(expandIncludes(line, SKILL_DATA)).toBe(line);
+  test("its description fits the 1024-character limit", () => {
+    const description = core.content.match(/^description: "(.*)"$/m)![1];
+    expect(description.length).toBeLessThanOrEqual(1024);
+    expect(description).toMatch(/^Creates cloud sandboxes and deploys apps/);
   });
 });

package/dist/lib/skill-route.d.ts

@@ -1,2 +0,0 @@
-/** Which embedded skill an agent should read for a top-level command. */
-export declare function skillFor(topLevel: string): "sandbox" | "core";

package/dist/lib/skill-route.js

@@ -1,7 +0,0 @@
-/** Top-level commands whose work the `sandbox` skill covers; everything else is in `core` (deploys). */
-const SANDBOX_COMMANDS = new Set(["sandbox", "volume", "agents"]);
-/** Which embedded skill an agent should read for a top-level command. */
-export function skillFor(topLevel) {
-    return SANDBOX_COMMANDS.has(topLevel) ? "sandbox" : "core";
-}
-//# sourceMappingURL=skill-route.js.map

package/dist/lib/skill-route.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-route.js","sourceRoot":"","sources":["../../src/lib/skill-route.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;AAElE,yEAAyE;AACzE,MAAM,UAAU,QAAQ,CAAC,QAAgB;IACvC,OAAO,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;AAC7D,CAAC"}

package/skill-data/_shared/basics.md

@@ -1,92 +0,0 @@
-## Execution rules
-
-1. Prefer the `lizard` CLI. For anything it does not expose, ask the user: don't call the API directly.
-2. Always pass `--json` on non-interactive calls. The CLI also switches to JSON by itself when stdout isn't a TTY.
-3. For an unfamiliar command, run `lizard <cmd> --help --json` first: never guess flag shapes. See [Discovery](#discovery).
-4. Resolve context before any change: `lizard status` shows the folder's link and its project. Confirm you are targeting the right project, service or sandbox.
-5. For destructive actions (delete a service or sandbox, drop an addon, overwrite a project-wide secret, restart production), confirm with the user first. The CLI's own prompts only appear on a TTY.
-
-## Discovery
-
-The CLI has ~30 subcommands. Discover at runtime:
-
-```
-lizard --help --json                       # root + all commands + global flags + exit codes
-lizard <cmd> --help --json                  # specific command schema
-lizard <cmd> <sub> --help --json            # nested (e.g. `lizard service set --help --json`)
-```
-
-Returns `{ cli, version, command: { arguments, options, subcommands }, globalOptions, exitCodes }`.
-
-## Sign-in
-
-Every command that needs an account checks the sign-in first. Without one, in JSON mode it fails with exit code `2` and `error.code: "NOT_AUTHENTICATED"`, and `error.body.login` holds what you need to get the user signed in. `lizard login --json` prints the same object at the top level. It never waits and never opens a browser:
-
-- `status: "pending"`: `authUrls` holds one link per sign-in method (`github`, `google`), and `authUrl` the one to use when only one applies. Ask the user how they sign in to Lizard and give them that link as a clickable URL. Someone with an account must use the same method as before: another method opens a second, empty account unless both share a verified email. Once they say the browser shows "CLI authorized", run the same command again (`nextCommand` when present); it picks the sign-in up. A link lasts 5 minutes; the next run prints a new one. Follow `instruction`.
-- `status: "complete"` (from `lizard login` only): `username`, `email`, `source` (`browser`, `saved`, or `env` for `LIZARD_TOKEN` / `LIZARD_API_KEY`), `account` with the plan's `state` (`trial_available`, `subscription_required`, `trialing`, `active`, `past_due`, `credits`, `enterprise`, `not_owner`, `checkout_unavailable`, `unknown`), `billingUrl`, `payUrl` when a payment failed, and an `instruction` that says what to offer and what not to touch, plus `next` commands.
-
-Never start a plan (`lizard billing start`) unless the user agrees. `lizard login` is safe to re-run: a signed-in machine skips straight to the plan. In CI nothing can be opened, so set `LIZARD_TOKEN` or `LIZARD_API_KEY`, or save a token on the machine with `printf '%s' "$TOKEN" | lizard login --token-stdin`. `lizard login --token <token>` works too, but the token lands in the process list and the shell history.
-
-## Exit codes
-
-- `0` success — continue
-- `1` generic error — inspect message, surface to user
-- `2` auth (401/403) — not signed in: give the user the link from `error.body.login` and run the command again once they have signed in (see [Sign-in](#sign-in)). No links in the body (CI, or the platform could not be reached)? Run `lizard login --json`, or ask for `LIZARD_TOKEN`.
-- `3` not found (404) — wrong name / resource gone; verify with `lizard project list` / `lizard ps`
-- `4` timeout — retry or report
-- `5` cancelled by user — stop
-
-## Default project
-
-A command that works on a project takes it from `--project`, then from the folder's link, then falls back to the account's **default project**: the oldest live project in the personal workspace, which every account gets at sign-up (`<username>'s Project`). So `lizard sandbox create`, `lizard up`, `lizard logs` and the rest work in a folder that was never linked. They say so on stderr: `Project: <name> (your default)`.
-
-- `lizard sandbox create` with no project lets the platform pick the default; its JSON carries `projectId`, `projectName` and `projectDefaulted: true`.
-- `lizard up` links the unlinked folder to the default project first, then creates a service named after the folder, so the next `up` from that folder updates the same service. `lizard init --force` relinks it elsewhere.
-- No default project (every project deleted): the old `No project linked. Run lizard init or pass --project <id>.` error.
-
-## Billing
-
-Billing belongs to the account; these commands take no project or service selector.
-
-```sh
-lizard billing --json              # plan, trial, this month's usage, next charge, billingUrl
-lizard billing start --json        # Stripe Checkout link: the Pro trial, or Pro at once
-lizard billing promo <code> --json # a longer trial with more trial usage
-lizard billing open                # the Billing page
-lizard metrics --cost --json       # spend per project; proCredits for Pro accounts
-```
-
-Pro costs $19/month, taxes included, and includes $19 of usage each month for
-everything on the account; unused usage does not carry over. Usage above that is
-pay as you go at the published rates, charged to the card as it builds up. A new
-account starts with no plan. The 7-day trial includes $5 of usage; Checkout asks
-for a card and charges nothing until the trial ends, then Pro is $19/month. When
-the trial usage runs out, running resources pause and nothing new can be created
-until Pro starts. Data is kept. Promo codes work only before the first payment.
-Trial accounts run 1 replica per app and 5 sandboxes at once; after the first
-paid invoice, 5 replicas per app and 100 sandboxes (paused sandboxes don't
-count). Pro cards are changed or removed on the Billing page;
-`lizard billing payment-methods remove` works only for Enterprise accounts.
-Enterprise accounts pay as you go, invoiced monthly. There are no top-ups, no
-auto top-up and no crypto or x402 payments.
-
-When the account needs a plan or a payment, every create command (`up`, `add`,
-`sandbox create`, `volume create`, `domain`, redeploys) fails with HTTP 402.
-The JSON error has `code: "PAYMENT_REQUIRED"` (`"INSUFFICIENT_CREDITS"` from
-older servers), a `message` to show the user as is (its last line is the link),
-and `body.status` with the links:
-
-| `body.status` | What to offer |
-|---|---|
-| `trial_available` | Start the trial: `body.subscribeUrl`, or `lizard billing start` |
-| `subscription_required` | The trial is used: Start Pro ($19 today) the same way |
-| `trial_credits_used` | Trial usage is used up: Start Pro now with `lizard billing start-now` or in Billing |
-| `past_due` | A payment failed: pay the open invoice in Billing (`body.billingUrl`) |
-| `paused` | Running resources are paused, data kept. `message` says why: trial usage used up (Start Pro now, as above) or a failed payment (pay the open invoice in Billing) |
-| anything else | Show `message` and `body.billingUrl` |
-
-Checkout and invoice pages open in the user's browser; you cannot finish them.
-Give the user the link, never ask for card details in chat, and retry the
-failed command after they say they are done. `start-now` (charges $19 now),
-`cancel` and `resume` change what the user pays: run them only when the user
-asks. Without a terminal, `start-now` and `cancel` need `-y`.

package/src/lib/skill-route.ts

@@ -1,7 +0,0 @@
-/** Top-level commands whose work the `sandbox` skill covers; everything else is in `core` (deploys). */
-const SANDBOX_COMMANDS = new Set(["sandbox", "volume", "agents"]);
-
-/** Which embedded skill an agent should read for a top-level command. */
-export function skillFor(topLevel: string): "sandbox" | "core" {
-  return SANDBOX_COMMANDS.has(topLevel) ? "sandbox" : "core";
-}