@ornncompute/cli 0.2.24 → 1.0.25

package/vendor/capabilities/capabilities/admin.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+import { listFacilitiesCapability, listNodesCapability, listOperatorsCapability } from "./fleet.js";
+import { logsLatestCapability, telemetryLatestCapability } from "./observability.js";
+import { tokensListCapability } from "./tokens.js";
+import { usersQueryCapability } from "./users.js";
+import { adminCapacityOffersCreateCapability } from "./admin-capacity-reservations.js";
+export const ADMIN_CLI_ROOTS = [
+    { name: "users" },
+    { name: "operators" },
+    { name: "facilities" },
+    { name: "nodes" },
+    { name: "enrollment-tokens" },
+    { name: "capacity-offers" },
+    { name: "reservations" },
+];
+function adminHelp(command, outcome, human, automation, acceptedReferences = []) {
+    return {
+        audience: "admin",
+        category: "resource",
+        command,
+        outcome,
+        human,
+        automation,
+        acceptedReferences,
+    };
+}
+function withAdminBinding(capability, help) {
+    if (!help.command)
+        throw new Error(`${capability.id} requires a canonical CLI command`);
+    return {
+        ...capability,
+        cli: {
+            command: [...help.command],
+            vnext: help,
+        },
+    };
+}
+export const adminUsersSearchCapability = withAdminBinding(usersQueryCapability, adminHelp(["admin", "users", "search"], "Search the staff-authorized user directory.", "ornn admin users search [--name NAME] [--email EMAIL] [--organization NAME] [--limit 50] [--cursor CURSOR]", "ornn admin users search --email EMAIL --limit 50 [--cursor CURSOR] --format json"));
+export const adminOperatorsListCapability = withAdminBinding(listOperatorsCapability, adminHelp(["admin", "operators", "list"], "List operators visible to staff.", "ornn admin operators list [--limit 50] [--cursor CURSOR]", "ornn admin operators list --limit 50 --format json"));
+export const adminFacilitiesListCapability = withAdminBinding(listFacilitiesCapability, adminHelp(["admin", "facilities", "list"], "List facilities visible to staff.", "ornn admin facilities list [--operator OPERATOR] [--limit 50] [--cursor CURSOR]", "ornn admin facilities list --limit 50 --format json"));
+export const adminNodesListCapability = withAdminBinding(listNodesCapability, adminHelp(["admin", "nodes", "list"], "List enrolled, ghost, and off-grid nodes.", "ornn admin nodes list [--operator OPERATOR] [--facility FACILITY] [--status STATUS] [--email EMAIL] [--limit 50] [--cursor CURSOR]", "ornn admin nodes list --limit 50 [--cursor CURSOR] --format json"));
+const nodeInput = z.object({ node_id: z.string().min(1) });
+export const adminNodeHealthCapability = defineCapability({
+    id: "nodes.health",
+    domain: "fleet",
+    roles: ["admin"],
+    description: "Read lifecycle and readiness facts for one enrolled node.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/nodes/{id}" },
+    cli: {
+        command: ["admin", "nodes", "health"],
+        vnext: adminHelp(["admin", "nodes", "health"], "Inspect lifecycle and readiness facts for one node.", "ornn admin nodes health <node-id>", "ornn admin nodes health <node-id> --format json", ["canonical node ID"]),
+    },
+    mcp: false,
+    slack: false,
+    input: nodeInput,
+    execute: async (ctx, input) => {
+        const parsed = nodeInput.parse(input);
+        return ctx.fetch(`/internal/nodes/${encodeURIComponent(parsed.node_id)}`, { method: "GET" });
+    },
+});
+export const adminNodeMetricsCapability = withAdminBinding(telemetryLatestCapability, adminHelp(["admin", "nodes", "metrics"], "Read a bounded telemetry window for one node.", "ornn admin nodes metrics <node-id> [--span 15m] [--start TIME --end TIME] [--max-points 240]", "ornn admin nodes metrics <node-id> --span 15m [--start TIME --end TIME] --max-points 240 --format json", ["canonical node ID"]));
+export const adminNodeLogsCapability = withAdminBinding(logsLatestCapability, adminHelp(["admin", "nodes", "logs"], "Read one bounded node log page.", "ornn admin nodes logs <node-id> [--stream kernel|serial] [--count 200] [--before TIME] [--cursor CURSOR]", "ornn admin nodes logs <node-id> --stream kernel --count 200 [--before TIME] [--cursor CURSOR] --format json", ["canonical node ID"]));
+export const adminEnrollmentTokensListCapability = withAdminBinding(tokensListCapability, adminHelp(["admin", "enrollment-tokens", "list"], "List enrollment-token metadata without token bytes.", "ornn admin enrollment-tokens list [--limit 50] [--cursor CURSOR]", "ornn admin enrollment-tokens list --limit 50 --format json"));
+export const adminCapabilities = [
+    adminUsersSearchCapability,
+    adminOperatorsListCapability,
+    adminFacilitiesListCapability,
+    adminNodesListCapability,
+    adminNodeHealthCapability,
+    adminNodeMetricsCapability,
+    adminNodeLogsCapability,
+    adminEnrollmentTokensListCapability,
+];
+const replacements = {
+    "listings.create": adminCapacityOffersCreateCapability,
+    "facilities.list": adminFacilitiesListCapability,
+    "logs.latest": adminNodeLogsCapability,
+    "nodes.list": adminNodesListCapability,
+    "operator.list": adminOperatorsListCapability,
+    "telemetry.latest": adminNodeMetricsCapability,
+    "tokens.list": adminEnrollmentTokensListCapability,
+    "users.query": adminUsersSearchCapability,
+};
+/** Applies canonical admin CLI bindings without changing MCP or Slack identities. */
+export function bindAdminCapabilities(capabilities) {
+    return capabilities.map((capability) => replacements[capability.id] ?? capability);
+}

package/vendor/capabilities/capabilities/capacity-offers.js

@@ -0,0 +1,368 @@
+import { z } from "zod";
+import { defineCapability, } from "../capability.js";
+const CANONICAL_REFERENCE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const BASE64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const EXACT_DECIMAL = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+const DEFAULT_LIMIT = 50;
+export const capacityOffersListInput = z.object({
+    $positionals: z.array(z.string()).max(0).default([]),
+    cursor: z.string().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(500).optional(),
+});
+export const capacityOfferShowInput = z.object({
+    $positionals: z.array(z.string()).max(0).default([]),
+    offer: z.string().min(1).optional(),
+});
+function requireInteraction(context) {
+    const interaction = context.cli?.interaction;
+    if (!interaction)
+        throw new Error("Capacity offers require the Ornn CLI interaction runtime.");
+    return interaction;
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function integer(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
+}
+function exactDecimal(value) {
+    const candidate = text(value);
+    return candidate && EXACT_DECIMAL.test(candidate) ? candidate : null;
+}
+function requireReference(value, field, interaction) {
+    if (!value)
+        interaction.usage(`--${field} is required.`, { code: "missing_input", field });
+    if (!CANONICAL_REFERENCE.test(value)) {
+        interaction.usage(`--${field} must be one canonical identifier.`, {
+            code: "invalid_reference",
+            field,
+        });
+    }
+    return value;
+}
+function offerFromWire(value, interaction) {
+    const item = record(value);
+    const ref = text(item.id ?? item.ref);
+    const gpuType = text(item.gpu_type ?? item.hardware);
+    const gpusPerMachine = integer(item.gpus_per_node ?? item.gpus_per_machine);
+    const machines = integer(item.available_node_count ?? item.node_count ?? item.machine_count);
+    const gpus = integer(item.available_gpu_count ?? item.gpu_count);
+    const facility = text(item.site_nickname ?? item.facility_name ?? item.facility);
+    const start = text(item.available_start_at ?? item.start_at ?? item.available_from);
+    const end = text(item.available_end_at ?? item.end_at ?? item.available_to);
+    const currency = text(item.currency)?.toUpperCase() ?? null;
+    const rawFixedValue = item.buy_now_price_per_gpu_hour_exact ?? item.ask_price_per_gpu_hour_exact;
+    const fixedValue = exactDecimal(rawFixedValue);
+    if (!ref ||
+        !CANONICAL_REFERENCE.test(ref) ||
+        !gpuType ||
+        gpusPerMachine === null ||
+        gpusPerMachine < 1 ||
+        machines === null ||
+        machines < 0 ||
+        gpus === null ||
+        gpus < 0 ||
+        !facility ||
+        !start ||
+        !end ||
+        !currency ||
+        !/^[A-Z]{3}$/.test(currency) ||
+        (rawFixedValue != null && !fixedValue)) {
+        interaction.error("The gateway returned an incomplete capacity offer.", {
+            code: "invalid_gateway_response",
+        });
+    }
+    return {
+        ref,
+        hardware: {
+            gpu_type: gpuType,
+            gpus_per_machine: gpusPerMachine,
+            cpu: text(item.cpu),
+            ram: text(item.ram),
+            storage: text(item.storage),
+            fabric: text(item.fabric_type ?? item.fabric),
+            internet: text(item.internet),
+        },
+        location: { facility },
+        availability: { machine_count: machines, gpu_count: gpus, start, end },
+        fixedPrice: fixedValue ? { value: fixedValue, currency, unit: "gpu_hour" } : null,
+    };
+}
+function offerData(offer) {
+    return {
+        ref: offer.ref,
+        kind: "capacity_offer",
+        hardware: offer.hardware,
+        location: offer.location,
+        availability: offer.availability,
+        fixed_price: offer.fixedPrice,
+    };
+}
+function query(parameters) {
+    const encoded = Object.entries(parameters)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(String(value))}`)
+        .join("&");
+    return encoded ? `?${encoded}` : "";
+}
+function encodeOpaque(value) {
+    const input = encodeURIComponent(value);
+    let output = "";
+    for (let index = 0; index < input.length; index += 3) {
+        const first = input.charCodeAt(index);
+        const second = index + 1 < input.length ? input.charCodeAt(index + 1) : 0;
+        const third = index + 2 < input.length ? input.charCodeAt(index + 2) : 0;
+        output += BASE64URL[first >> 2];
+        output += BASE64URL[((first & 3) << 4) | (second >> 4)];
+        if (index + 1 < input.length)
+            output += BASE64URL[((second & 15) << 2) | (third >> 6)];
+        if (index + 2 < input.length)
+            output += BASE64URL[third & 63];
+    }
+    return output;
+}
+function decodeOpaque(value) {
+    if (!value || !/^[A-Za-z0-9_-]+$/.test(value))
+        throw new Error("invalid cursor encoding");
+    let output = "";
+    for (let index = 0; index < value.length; index += 4) {
+        const first = BASE64URL.indexOf(value[index]);
+        const second = BASE64URL.indexOf(value[index + 1]);
+        const third = index + 2 < value.length ? BASE64URL.indexOf(value[index + 2]) : 0;
+        const fourth = index + 3 < value.length ? BASE64URL.indexOf(value[index + 3]) : 0;
+        if (first < 0 || second < 0 || third < 0 || fourth < 0) {
+            throw new Error("invalid cursor encoding");
+        }
+        output += String.fromCharCode((first << 2) | (second >> 4));
+        if (index + 2 < value.length)
+            output += String.fromCharCode(((second & 15) << 4) | (third >> 2));
+        if (index + 3 < value.length)
+            output += String.fromCharCode(((third & 3) << 6) | fourth);
+    }
+    return decodeURIComponent(output);
+}
+function encodeCursor(cursor) {
+    return `ornn-capacity-v1.${encodeOpaque(JSON.stringify(cursor))}`;
+}
+function decodeCursor(raw, interaction) {
+    if (!raw)
+        return { source: "primary", cursor: null };
+    const prefix = "ornn-capacity-v1.";
+    try {
+        if (!raw.startsWith(prefix))
+            throw new Error("wrong cursor kind");
+        const decoded = JSON.parse(decodeOpaque(raw.slice(prefix.length)));
+        if (!decoded ||
+            (decoded.source !== "primary" && decoded.source !== "resale") ||
+            (decoded.cursor !== null && typeof decoded.cursor !== "string")) {
+            throw new Error("invalid cursor payload");
+        }
+        return decoded;
+    }
+    catch {
+        interaction.usage("--cursor is not a capacity-offer cursor returned by Ornn.", {
+            code: "invalid_cursor",
+            field: "cursor",
+        });
+    }
+}
+async function readPage(context, source, limit, cursor) {
+    const path = source === "primary"
+        ? "/v1/workflows/commerce/listings"
+        : "/v1/workflows/commerce/resale-listings";
+    const payload = record(await context.fetch(`${path}${query({ limit, cursor: cursor ?? undefined })}`));
+    const rows = Array.isArray(payload.listings)
+        ? payload.listings
+        : source === "primary" && Array.isArray(payload.items)
+            ? payload.items
+            : [];
+    return { rows, next: text(payload.next_cursor) };
+}
+async function executeCapacityOffersList(context, input) {
+    const interaction = requireInteraction(context);
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    const position = decodeCursor(input.cursor, interaction);
+    let page = await readPage(context, position.source, limit, position.cursor);
+    let source = position.source;
+    if (source === "primary" && page.rows.length === 0 && page.next === null) {
+        source = "resale";
+        page = await readPage(context, source, limit, null);
+    }
+    const offers = page.rows.map((item) => offerFromWire(item, interaction));
+    let nextCursor = page.next ? encodeCursor({ source, cursor: page.next }) : null;
+    if (source === "primary" && page.next === null && offers.length > 0) {
+        const resaleProbe = await readPage(context, "resale", 1, null);
+        if (resaleProbe.rows.length > 0)
+            nextCursor = encodeCursor({ source: "resale", cursor: null });
+    }
+    const next = nextCursor
+        ? `ornn capacity-offers list --limit ${limit} --cursor ${nextCursor}`
+        : offers[0]
+            ? `ornn capacity-offers show --offer ${offers[0].ref}`
+            : "ornn capacity-offers forecast";
+    return interaction.result({
+        data: {
+            capacity_offers: offers.map(offerData),
+            defaults: { limit },
+        },
+        outcome: { class: "ready", phase: offers.length ? "listed" : "empty" },
+        page: { limit, returned: offers.length, next_cursor: nextCursor },
+        presentation: {
+            lines: offers.length
+                ? offers.map((offer) => {
+                    const price = offer.fixedPrice
+                        ? `${offer.fixedPrice.value} ${offer.fixedPrice.currency}/GPU-hour`
+                        : "price unavailable";
+                    return `${offer.ref}  ${offer.hardware.gpu_type}  ${offer.location.facility}  ${offer.availability.machine_count} machines  ${price}`;
+                })
+                : ["No capacity offers are available."],
+            next,
+        },
+    });
+}
+async function executeCapacityOfferShow(context, input) {
+    const interaction = requireInteraction(context);
+    const ref = requireReference(input.offer, "offer", interaction);
+    const offer = offerFromWire(await context.fetch(`/v1/workflows/commerce/listings/${encodeURIComponent(ref)}`), interaction);
+    if (offer.ref !== ref) {
+        interaction.error("The gateway returned a different capacity offer.", {
+            code: "capacity_offer_correlation_changed",
+        });
+    }
+    const price = offer.fixedPrice
+        ? `${offer.fixedPrice.value} ${offer.fixedPrice.currency} per GPU-hour`
+        : "Unavailable";
+    return interaction.result({
+        data: { capacity_offer: offerData(offer), defaults: {} },
+        outcome: { class: "ready", phase: "available" },
+        presentation: {
+            lines: [
+                `Capacity offer ${offer.ref}`,
+                `Hardware: ${offer.hardware.gpu_type}, ${offer.hardware.gpus_per_machine} GPUs per machine`,
+                `Location: ${offer.location.facility}`,
+                `Availability: ${offer.availability.machine_count} machines, ${offer.availability.start} to ${offer.availability.end}`,
+                `Price: ${price}`,
+            ],
+            next: "ornn capacity-offers list",
+        },
+    });
+}
+export async function executeCapacityOfferForecast(context, input) {
+    const interaction = requireInteraction(context);
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    const payload = record(await context.fetch(`/v1/workflows/commerce/listings/forecast${query({ limit, cursor: input.cursor })}`));
+    const rawListings = Array.isArray(payload.listings) ? payload.listings : [];
+    const offers = rawListings.map((item) => {
+        const row = record(item);
+        const offer = offerFromWire(row, interaction);
+        const availability = Array.isArray(row.availability)
+            ? row.availability.map((bucket) => {
+                const interval = record(bucket);
+                const start = text(interval.start_at);
+                const end = text(interval.end_at);
+                const machines = integer(interval.available_nodes);
+                const gpus = integer(interval.available_gpus);
+                if (!start || !end || machines === null || gpus === null) {
+                    interaction.error("The gateway returned an incomplete capacity forecast bucket.", {
+                        code: "invalid_gateway_response",
+                    });
+                }
+                return { start, end, machine_count: machines, gpu_count: gpus };
+            })
+            : [];
+        return { ...offerData(offer), availability };
+    });
+    const nextCursor = text(payload.next_cursor);
+    const next = nextCursor
+        ? `ornn capacity-offers forecast --limit ${limit} --cursor ${nextCursor}`
+        : offers[0]
+            ? `ornn capacity-offers show --offer ${offers[0].ref}`
+            : "ornn capacity-offers list";
+    return interaction.result({
+        data: {
+            generated_at: text(payload.generated_at),
+            bucket_hours: integer(payload.bucket_hours),
+            horizon_hours: integer(payload.horizon_hours),
+            capacity_offers: offers,
+            defaults: { limit },
+        },
+        outcome: { class: "ready", phase: offers.length ? "forecast" : "empty" },
+        page: { limit, returned: offers.length, next_cursor: nextCursor },
+        presentation: {
+            lines: offers.length
+                ? offers.map((offer) => `${offer.ref}  ${offer.hardware.gpu_type}  ${offer.location.facility}  ${offer.availability.length} forecast buckets`)
+                : ["No forecast capacity offers are available."],
+            next,
+        },
+    });
+}
+export const capacityOfferForecastVnext = {
+    arguments: "semantic",
+    audience: "customer",
+    category: "resource",
+    outcome: "Forecast owner-provided capacity availability in bounded pages.",
+    human: "ornn capacity-offers forecast [--limit <1-500>] [--cursor <opaque>]",
+    automation: "ornn capacity-offers forecast --limit 50 --format json",
+    acceptedReferences: ["opaque page cursor"],
+    related: ["capacity-offers list"],
+    order: 21,
+};
+export const capacityOffersListCapability = defineCapability({
+    id: "listings.capacity_list",
+    domain: "listings",
+    roles: ["user"],
+    description: "List primary and resale capacity offers through one customer-safe shape.",
+    mutation: "read",
+    input: capacityOffersListInput,
+    cli: {
+        command: ["capacity-offers", "list"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            outcome: "List ordinary capacity offers with bounded opaque pagination and no supplier provenance.",
+            human: "ornn capacity-offers list [--limit <1-500>] [--cursor <opaque>]",
+            automation: "ornn capacity-offers list --limit 50 --format json",
+            acceptedReferences: ["opaque page cursor"],
+            related: ["capacity-offers show", "capacity-offers forecast"],
+            order: 20,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: executeCapacityOffersList,
+});
+export const capacityOfferShowCapability = defineCapability({
+    id: "listings.capacity_show",
+    domain: "listings",
+    roles: ["user"],
+    description: "Show one exact primary or resale capacity offer without supplier provenance.",
+    mutation: "read",
+    input: capacityOfferShowInput,
+    cli: {
+        command: ["capacity-offers", "show"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            outcome: "Inspect owner-provided hardware, location, quantity, term, and exact prices.",
+            human: "ornn capacity-offers show --offer <id>",
+            automation: "ornn capacity-offers show --offer <id> --format json",
+            acceptedReferences: ["canonical capacity-offer ID"],
+            related: ["capacity-offers list", "capacity-offers forecast"],
+            order: 22,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: executeCapacityOfferShow,
+});
+export const capacityOfferCapabilities = [
+    capacityOffersListCapability,
+    capacityOfferShowCapability,
+];

package/vendor/capabilities/capabilities/cli.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+export const CLI_MACHINE_SCHEMA = "ornn.cli/v1";
+const emptyInput = z.object({});
+function requireCliRuntime(context) {
+    if (!context.cli) {
+        throw new Error("This capability must execute through the Ornn CLI runtime.");
+    }
+    return context.cli;
+}
+const updateInput = z.object({
+    $positionals: z.array(z.string()).max(0).default([]),
+    major: z.boolean().optional(),
+});
+const completionInput = z
+    .object({
+    $positionals: z.tuple([z.enum(["bash", "fish", "zsh"])]),
+})
+    .transform(({ $positionals }) => ({ shell: $positionals[0] }));
+export const versionCapability = defineCapability({
+    id: "cli.version",
+    domain: "cli",
+    roles: ["user"],
+    description: "Show the CLI version and machine-output contract.",
+    mutation: "local",
+    input: emptyInput,
+    cli: {
+        command: ["version"],
+        vnext: {
+            audience: "customer",
+            category: "platform",
+            outcome: "Identify the installed CLI and its machine-output contract.",
+            human: "ornn version",
+            automation: "ornn version --format json",
+            related: ["status", "resources"],
+            order: 20,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: async (context) => {
+        const runtime = requireCliRuntime(context);
+        return {
+            version: runtime.version,
+            machine_schema: runtime.machineSchema,
+            update_channel: runtime.updateChannel,
+        };
+    },
+});
+export const updateCapability = defineCapability({
+    id: "cli.update",
+    domain: "cli",
+    roles: ["user"],
+    description: "Update the installed CLI through its detected package manager.",
+    mutation: "local",
+    input: updateInput,
+    cli: {
+        command: ["update"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "platform",
+            outcome: "Update the installed CLI with explicit acknowledgement for a major crossing.",
+            human: "ornn update [--major]",
+            automation: "ornn update --format human [--major]",
+            related: ["version"],
+            order: 25,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: async (context, input) => {
+        const runtime = requireCliRuntime(context);
+        if (!runtime.update) {
+            throw new Error("This capability must execute through the Ornn CLI update runtime.");
+        }
+        return runtime.update(input);
+    },
+});
+export const completionCapability = defineCapability({
+    id: "cli.completion",
+    domain: "cli",
+    roles: ["user"],
+    description: "Generate shell completion from canonical catalog commands.",
+    mutation: "local",
+    input: completionInput,
+    cli: {
+        command: ["completion"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "platform",
+            outcome: "Generate bash, fish, or zsh completion from the canonical command catalog.",
+            human: "ornn completion <bash|fish|zsh> --format human",
+            automation: "ornn completion <bash|fish|zsh> --format json",
+            related: ["resources"],
+            order: 27,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: async (context, input) => {
+        const runtime = requireCliRuntime(context);
+        if (!runtime.completion) {
+            throw new Error("This capability must execute through the Ornn CLI completion runtime.");
+        }
+        return runtime.completion(input);
+    },
+});
+export const resourcesCapability = defineCapability({
+    id: "cli.resources",
+    domain: "cli",
+    roles: ["user"],
+    description: "List registered advanced customer resource commands.",
+    mutation: "local",
+    input: emptyInput,
+    cli: {
+        command: ["resources"],
+        vnext: {
+            audience: "customer",
+            category: "platform",
+            outcome: "Discover advanced customer resource commands without dispatching a generic request.",
+            human: "ornn resources",
+            automation: "ornn resources --format json",
+            related: ["status", "version"],
+            order: 30,
+        },
+    },
+    mcp: false,
+    slack: false,
+    execute: async (context) => {
+        const runtime = requireCliRuntime(context);
+        const resources = [];
+        for (const capability of runtime.catalog) {
+            const binding = capability.cli;
+            const help = binding?.vnext;
+            if (!binding || help?.audience !== "customer" || help.category !== "resource") {
+                continue;
+            }
+            resources.push({
+                command: binding.command.join(" "),
+                outcome: help.outcome,
+                human: help.human,
+                automation: help.automation,
+            });
+        }
+        resources.sort((left, right) => left.command.localeCompare(right.command));
+        return { resources };
+    },
+});
+export const cliShellCapabilities = [
+    versionCapability,
+    updateCapability,
+    completionCapability,
+    resourcesCapability,
+];