@ornncompute/cli 1.0.75 → 1.0.97

package/vendor/capabilities/capabilities/markets.js

@@ -1,482 +0,0 @@
-import { z } from "zod";
-import { defineCapability } from "../capability.js";
-import { gpuDisplay, loadHardwareCatalog } from "../spec-catalog.js";
-import { consent, idempotencyHeaders, microUsd, microUsdLabel, positionals, query, seg, } from "./market-shared.js";
-// Markets verbs: one capability per `/v1/markets` route. Order books are
-// per GPU slug, sale type (Spot or On-demand) and region; Spot and On-demand
-// trade GPUs. Clients buy a number of nodes at market for now; Markets also
-// takes GPU counts and limit bids. Offers are per primary listing. Prices are
-// integer micro-USD per GPU-hour, exactly as Markets reads and writes them.
-const BASE = "/v1/markets";
-const saleType = z
-    .enum(["spot", "on-demand"])
-    .optional()
-    .describe("spot (the default) yields to scheduled bookings; on-demand runs until stopped or the listing ends.");
-const region = z
-    .string()
-    .min(1)
-    .optional()
-    .describe("A region slug, for example us-east-11. Omit for every region.");
-const nodes = z.coerce
-    .number()
-    .int()
-    .min(1)
-    .describe("Nodes to buy, each the GPUs of one whole machine.");
-function bookQuery(input) {
-    return query({ saleType: input.saleType, region: input.region });
-}
-function help(command, outcome, human, automation, related, order, acceptedReferences = []) {
-    return {
-        arguments: "semantic",
-        audience: "customer",
-        category: "resource",
-        command,
-        outcome,
-        human,
-        automation,
-        acceptedReferences,
-        related,
-        order,
-    };
-}
-export const marketBooksInput = z.object({
-    $positionals: positionals,
-    gpuSlug: z.string().min(1).optional().describe("Only this catalog GPU slug."),
-    saleType,
-    region: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Only this region slug, or any for the books of bids in any region."),
-});
-export const marketBooksCapability = defineCapability({
-    id: "market.books",
-    domain: "markets",
-    roles: ["user"],
-    description: "List the order books, one per GPU type, sale type (Spot or On-demand) and region, with the best bid and ask in micro-USD per GPU-hour.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/books` },
-    input: marketBooksInput,
-    cli: {
-        command: ["market", "books"],
-        vnext: help(["market", "books"], "List order books by GPU type, sale type and region with their best bid and ask.", "ornn market books [--gpu-slug <slug>] [--sale-type spot|on-demand] [--region <slug>]", "ornn market books --sale-type on-demand --format json", ["market book", "market quote", "market bid"], 31),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketBooksInput.parse(input);
-        return ctx.fetch(`${BASE}/books${query({ gpuSlug: parsed.gpuSlug, saleType: parsed.saleType, region: parsed.region })}`, {
-            method: "GET",
-        });
-    },
-});
-export const marketBookInput = z.object({
-    $positionals: positionals,
-    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
-    saleType,
-    region,
-});
-export const marketBookCapability = defineCapability({
-    id: "market.book",
-    domain: "markets",
-    roles: ["user"],
-    description: "Show one GPU type's depth for a sale type, in one region or across all of them: nodes and order counts at each bid and ask price level (ask levels also count their GPUs).",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/books/{gpuSlug}` },
-    input: marketBookInput,
-    cli: {
-        command: ["market", "book"],
-        vnext: help(["market", "book"], "Show bid and ask depth for one GPU type, sale type and region.", "ornn market book --gpu-slug <slug> [--sale-type spot|on-demand] [--region <slug>]", "ornn market book --gpu-slug <slug> --region us-east-11 --format json", ["market books", "market trades", "market quote"], 32, ["catalog GPU slug", "region slug"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketBookInput.parse(input);
-        return ctx.fetch(`${BASE}/books/${seg(parsed.gpuSlug)}${bookQuery(parsed)}`, {
-            method: "GET",
-        });
-    },
-});
-export const marketTradesCapability = defineCapability({
-    id: "market.trades",
-    domain: "markets",
-    roles: ["user"],
-    description: "List recent trades for one GPU type and sale type, in one region or all: price, nodes, GPUs, region and time, with no identities.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/books/{gpuSlug}/trades` },
-    input: marketBookInput,
-    cli: {
-        command: ["market", "trades"],
-        vnext: help(["market", "trades"], "List recent fills for one GPU type, sale type and region.", "ornn market trades --gpu-slug <slug> [--sale-type spot|on-demand] [--region <slug>]", "ornn market trades --gpu-slug <slug> --format json", ["market book"], 33, ["catalog GPU slug", "region slug"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketBookInput.parse(input);
-        return ctx.fetch(`${BASE}/books/${seg(parsed.gpuSlug)}/trades${bookQuery(parsed)}`, {
-            method: "GET",
-        });
-    },
-});
-export const marketQuoteInput = z.object({
-    $positionals: positionals,
-    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
-    saleType,
-    region: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("A region with an order book (see market books). Omit for any region."),
-    nodes,
-});
-export const marketQuoteCapability = defineCapability({
-    id: "market.quote",
-    domain: "markets",
-    roles: ["user"],
-    description: "Preview a market bid for nodes without placing it: each node it would take now, cheapest first, with its price per GPU-hour, the GPUs taken there, its region and when it is next scheduled to stop. Fewer nodes than asked means the rest would be cancelled.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/books/{gpuSlug}/quote` },
-    input: marketQuoteInput,
-    cli: {
-        command: ["market", "quote"],
-        vnext: help(["market", "quote"], "Preview which nodes a bid would take now and what each costs.", "ornn market quote --gpu-slug <slug> --nodes <n> [--sale-type spot|on-demand] [--region <slug>]", "ornn market quote --gpu-slug <slug> --nodes 2 --format json", ["market book", "market bid"], 34, ["catalog GPU slug", "region slug"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketQuoteInput.parse(input);
-        return ctx.fetch(`${BASE}/books/${seg(parsed.gpuSlug)}/quote${query({
-            nodes: String(parsed.nodes),
-            orderType: "market",
-            saleType: parsed.saleType,
-            region: parsed.region,
-        })}`, { method: "GET" });
-    },
-});
-export const marketBidInput = z.object({
-    $positionals: positionals,
-    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
-    saleType,
-    region: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("A region with an order book (see market books), for example us-east-11. Omit to fill in any region."),
-    nodes,
-    diskId: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("The disk every VM boots. Omit to boot your newest disk, else Ornn's newest."),
-    idempotencyKey: z.string().min(1).max(200).optional(),
-    confirm: z.boolean().optional(),
-});
-export const marketBidCapability = defineCapability({
-    id: "market.bid",
-    domain: "markets",
-    roles: ["user"],
-    description: "Buy nodes at market, each the GPUs of one whole machine, as Spot (the default; a scheduled booking that needs the GPUs can stop it) or On-demand (runs until stopped or the listing ends), " +
-        "in one region or any. The bid takes the cheapest nodes for sale now and cancels the rest. What one listing sells becomes a running reservation (a fill), prepaid hourly from Ornn credits first and then the saved card. " +
-        "Book prices are what you pay per GPU-hour..",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/orders` },
-    input: marketBidInput,
-    cli: {
-        command: ["market", "bid"],
-        vnext: help(["market", "bid"], "Buy nodes at market.", "ornn market bid --gpu-slug <slug> --nodes <n> [--sale-type spot|on-demand] [--region <slug>] [--disk-id <id>]", "ornn market bid --gpu-slug <slug> --nodes 2  --format json", ["market quote", "market orders", "market fills", "market cancel"], 35, ["catalog GPU slug"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketBidInput.parse(input);
-        const body = {
-            gpuSlug: parsed.gpuSlug,
-            ...(parsed.saleType ? { saleType: parsed.saleType } : {}),
-            ...(parsed.region ? { region: parsed.region } : {}),
-            nodes: parsed.nodes,
-            orderType: "market",
-            ...(parsed.diskId ? { diskId: parsed.diskId } : {}),
-        };
-        // Only the CLI review renders terms; MCP and Slack preview the payload.
-        const hardware = ctx.cli?.interaction
-            ? await loadHardwareCatalog(ctx.fetch).catch(() => null)
-            : null;
-        const gate = await consent(ctx, "market.bid", "Place bid", [
-            { label: "GPU type", value: gpuDisplay(hardware?.terms ?? [], parsed.gpuSlug) },
-            { label: "Sale type", value: parsed.saleType === "on-demand" ? "On-demand" : "Spot" },
-            { label: "Location", value: parsed.region ?? "Any location" },
-            { label: "Nodes", value: String(parsed.nodes) },
-            { label: "Order", value: "Market: the cheapest nodes for sale now" },
-        ], body);
-        if (gate)
-            return gate;
-        return ctx.fetch(`${BASE}/orders`, {
-            method: "POST",
-            body,
-            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
-        });
-    },
-});
-export const marketOrdersInput = z.object({ $positionals: positionals });
-export const marketOrdersCapability = defineCapability({
-    id: "market.orders",
-    domain: "markets",
-    roles: ["user"],
-    description: "List this organization's bids (resting, filled and cancelled, each with its fill IDs) and the asks its listings have on the books.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/orders` },
-    input: marketOrdersInput,
-    cli: {
-        command: ["market", "orders"],
-        vnext: help(["market", "orders"], "List your organization's bids and listing asks.", "ornn market orders", "ornn market orders --format json", ["market bid", "market fills", "market cancel"], 36),
-    },
-    slack: false,
-    execute: async (ctx) => ctx.fetch(`${BASE}/orders`, { method: "GET" }),
-});
-export const marketCancelInput = z.object({
-    $positionals: positionals,
-    orderId: z.string().uuid().describe("A resting bid ID."),
-    confirm: z.boolean().optional(),
-});
-export const marketCancelCapability = defineCapability({
-    id: "market.cancel",
-    domain: "markets",
-    roles: ["user"],
-    description: "Cancel what a resting bid has not bought yet. Its fills keep running; end them with market end..",
-    mutation: "preview-confirm",
-    http: { method: "DELETE", path: `${BASE}/orders/{orderId}` },
-    input: marketCancelInput,
-    cli: {
-        command: ["market", "cancel"],
-        vnext: help(["market", "cancel"], "Cancel the rest of a resting bid.", "ornn market cancel --order-id <id>", "ornn market cancel --order-id <id>  --format json", ["market orders", "market end"], 37, ["order ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketCancelInput.parse(input);
-        const gate = await consent(ctx, "market.cancel", "Cancel bid", [
-            { label: "Order", value: parsed.orderId },
-            {
-                label: "Consequence",
-                value: "The bid stops buying. What it already bought keeps running.",
-            },
-        ], { orderId: parsed.orderId });
-        if (gate)
-            return gate;
-        return ctx.fetch(`${BASE}/orders/${seg(parsed.orderId)}`, { method: "DELETE" });
-    },
-});
-export const marketFillsInput = z.object({
-    $positionals: positionals,
-    orderId: z.string().uuid().optional().describe("Only this bid's fills."),
-});
-export const marketFillsCapability = defineCapability({
-    id: "market.fills",
-    domain: "markets",
-    roles: ["user"],
-    description: "List this organization's fills, newest first, or one bid's: each is one trade of GPUs from one listing at one price. Its ID is the reservation it runs as; read its status from the reservation.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/fills` },
-    input: marketFillsInput,
-    cli: {
-        command: ["market", "fills"],
-        vnext: help(["market", "fills"], "List the nodes your bids bought, one reservation per fill.", "ornn market fills [--order-id <id>]", "ornn market fills --format json", ["market orders", "market end"], 38, ["order ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketFillsInput.parse(input ?? {});
-        return ctx.fetch(`${BASE}/fills${query({ orderId: parsed.orderId })}`, { method: "GET" });
-    },
-});
-export const marketEndInput = z.object({
-    $positionals: positionals,
-    fillId: z.string().uuid().describe("A fill ID; it is also its reservation ID."),
-    confirm: z.boolean().optional(),
-});
-export const marketEndCapability = defineCapability({
-    id: "market.end",
-    domain: "markets",
-    roles: ["user"],
-    description: "End a running fill: its reservation stops, its VMs stop, and its GPUs go back on the book..",
-    mutation: "preview-confirm",
-    http: { method: "DELETE", path: "/commerce/reservations/{fillId}" },
-    input: marketEndInput,
-    cli: {
-        command: ["market", "end"],
-        vnext: help(["market", "end"], "End a running fill and stop its VMs.", "ornn market end --fill-id <id>", "ornn market end --fill-id <id>  --format json", ["market fills"], 39, ["fill ID", "reservation ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = marketEndInput.parse(input);
-        const gate = await consent(ctx, "market.end", "End fill", [
-            { label: "Fill", value: parsed.fillId },
-            { label: "Consequence", value: "The reservation ends and its VMs stop." },
-        ], { fillId: parsed.fillId });
-        if (gate)
-            return gate;
-        return ctx.fetch(`/commerce/reservations/${seg(parsed.fillId)}`, { method: "DELETE" });
-    },
-});
-export const offersListInput = z.object({
-    $positionals: positionals,
-    listingId: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("A primary listing whose offer book to read. Omit for your organization's offers."),
-});
-export const offersListCapability = defineCapability({
-    id: "offers.list",
-    domain: "markets",
-    roles: ["user"],
-    description: "List offers with their status. Without listingId: the offers this organization made and the offers on listings it owns (onMyListing: true, with netPricePerGpuHourMicroUsd, what it receives). With listingId: that listing's offer book.",
-    mutation: "read",
-    http: { method: "GET", path: `${BASE}/offers` },
-    input: offersListInput,
-    cli: {
-        command: ["offers", "list"],
-        vnext: help(["offers", "list"], "List offers your organization made or received, or one listing's offer book.", "ornn offers list [--listing-id <id>]", "ornn offers list --format json", ["offers post", "offers accept", "offers cancel"], 42, ["listing ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = offersListInput.parse(input ?? {});
-        return ctx.fetch(`${BASE}/offers${query({ listingId: parsed.listingId })}`, {
-            method: "GET",
-        });
-    },
-});
-export const offerPostInput = z.object({
-    $positionals: positionals,
-    listingId: z.string().uuid().describe("A primary listing."),
-    listingTermId: z
-        .string()
-        .uuid()
-        .describe("The listingTermsId of a non-spot term of that listing, from listings.terms."),
-    durationSeconds: z.coerce
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("How long the reservation runs, within the term's minimum and maximum duration. Omit only when they are equal, or when the term has none (the rest of the listing)."),
-    pricePerGpuHourMicroUsd: microUsd.describe("Offer price in micro-USD per GPU-hour (1000000 = $1.00). Covers every node on the listing."),
-    downPaymentCents: z.coerce
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("The down payment you offer, in cents."),
-    idempotencyKey: z.string().min(1).max(200).optional(),
-    confirm: z.boolean().optional(),
-});
-export const offerPostCapability = defineCapability({
-    id: "offers.post",
-    domain: "markets",
-    roles: ["user"],
-    description: "Offer a price for a whole primary listing on one of its terms: every node, from the later of the listing's start and now, for durationSeconds. The listing owner accepts it to create your reservation. Relisted (secondary) capacity takes no offers: buy its windows with reservations.purchase..",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/offers` },
-    input: offerPostInput,
-    cli: {
-        command: ["offers", "post"],
-        vnext: help(["offers", "post"], "Offer a price for a whole primary listing on one of its terms.", "ornn offers post --listing-id <id> --listing-term-id <id> [--duration-seconds <n>] --price-per-gpu-hour-micro-usd <n> [--down-payment-cents <n>]", "ornn offers post --listing-id <id> --listing-term-id <id> --duration-seconds 2592000 --price-per-gpu-hour-micro-usd 2500000  --format json", ["capacity-offers terms", "offers list", "offers cancel"], 43, ["listing ID", "listingTermsId from capacity-offers terms"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = offerPostInput.parse(input);
-        const body = {
-            listingId: parsed.listingId,
-            listingTermId: parsed.listingTermId,
-            ...(parsed.durationSeconds !== undefined ? { durationSeconds: parsed.durationSeconds } : {}),
-            pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd,
-            ...(parsed.downPaymentCents !== undefined
-                ? { downPaymentCents: parsed.downPaymentCents }
-                : {}),
-        };
-        const gate = await consent(ctx, "offers.post", "Post offer", [
-            { label: "Listing", value: parsed.listingId },
-            { label: "Term", value: parsed.listingTermId },
-            {
-                label: "Duration",
-                value: parsed.durationSeconds !== undefined
-                    ? `${parsed.durationSeconds} seconds from the later of the listing's start and now`
-                    : "The term's only duration, or the rest of the listing",
-            },
-            { label: "Price", value: microUsdLabel(parsed.pricePerGpuHourMicroUsd) },
-            ...(parsed.downPaymentCents !== undefined
-                ? [{ label: "Down payment", value: `$${(parsed.downPaymentCents / 100).toFixed(2)}` }]
-                : []),
-        ], body);
-        if (gate)
-            return gate;
-        return ctx.fetch(`${BASE}/offers`, {
-            method: "POST",
-            body,
-            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
-        });
-    },
-});
-export const offerDecisionInput = z.object({
-    $positionals: positionals,
-    offerId: z.string().uuid(),
-    confirm: z.boolean().optional(),
-});
-export const offerAcceptCapability = defineCapability({
-    id: "offers.accept",
-    domain: "markets",
-    roles: ["user"],
-    description: "Accept an offer on a primary listing you own. The buyer's reservation is booked and the listing's overlapping open offers are cancelled..",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/offers/{offerId}/accept` },
-    input: offerDecisionInput,
-    cli: {
-        command: ["offers", "accept"],
-        vnext: help(["offers", "accept"], "Accept one offer on a listing you own.", "ornn offers accept --offer-id <id>", "ornn offers accept --offer-id <id>  --format json", ["offers list"], 44, ["offer ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = offerDecisionInput.parse(input);
-        const gate = await consent(ctx, "offers.accept", "Accept offer", [
-            { label: "Offer", value: parsed.offerId },
-            {
-                label: "Consequence",
-                value: "The buyer's reservation is booked; this listing's overlapping open offers are cancelled.",
-            },
-        ], { offerId: parsed.offerId });
-        if (gate)
-            return gate;
-        return ctx.fetch(`${BASE}/offers/${seg(parsed.offerId)}/accept`, {
-            method: "POST",
-            body: {},
-        });
-    },
-});
-export const offerCancelCapability = defineCapability({
-    id: "offers.cancel",
-    domain: "markets",
-    roles: ["user"],
-    description: "Cancel an open offer you made, or one on a listing you own..",
-    mutation: "preview-confirm",
-    http: { method: "DELETE", path: `${BASE}/offers/{offerId}` },
-    input: offerDecisionInput,
-    cli: {
-        command: ["offers", "cancel"],
-        vnext: help(["offers", "cancel"], "Cancel one open offer.", "ornn offers cancel --offer-id <id>", "ornn offers cancel --offer-id <id>  --format json", ["offers list"], 45, ["offer ID"]),
-    },
-    slack: false,
-    execute: async (ctx, input) => {
-        const parsed = offerDecisionInput.parse(input);
-        const gate = await consent(ctx, "offers.cancel", "Cancel offer", [{ label: "Offer", value: parsed.offerId }], { offerId: parsed.offerId });
-        if (gate)
-            return gate;
-        return ctx.fetch(`${BASE}/offers/${seg(parsed.offerId)}`, { method: "DELETE" });
-    },
-});
-export const marketCapabilities = [
-    marketBooksCapability,
-    marketBookCapability,
-    marketTradesCapability,
-    marketQuoteCapability,
-    marketBidCapability,
-    marketOrdersCapability,
-    marketCancelCapability,
-    marketFillsCapability,
-    marketEndCapability,
-    offersListCapability,
-    offerPostCapability,
-    offerAcceptCapability,
-    offerCancelCapability,
-];

package/vendor/capabilities/capabilities/mounts.js

@@ -1,176 +0,0 @@
-import { z } from "zod";
-import { defineCapability, } from "../capability.js";
-const mountInput = z
-    .object({
-    $positionals: z.array(z.string()).default([]),
-    access: z.string().optional(),
-    capacityGib: z.union([z.string(), z.number()]).optional(),
-    cursor: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    limit: z.union([z.string(), z.number()]).optional(),
-    noWait: z.boolean().optional(),
-    performanceTier: z.string().optional(),
-    timeout: z.string().optional(),
-    volume: z.string().optional(),
-    wait: z.boolean().optional(),
-    yes: z.boolean().optional(),
-})
-    .strict();
-function mountExecutor(context) {
-    const interaction = context.cli?.interaction;
-    if (!interaction?.mounts) {
-        throw new Error("This capability must execute through the Ornn CLI mount runtime.");
-    }
-    return interaction.mounts.bind(interaction);
-}
-function mountCapability({ acceptedReferences = [], automation, command, description, human, id, mutation, order, outcome, related = [], resumableStates = [], review, }) {
-    return defineCapability({
-        id,
-        domain: "storage",
-        roles: ["user"],
-        description,
-        mutation,
-        input: mountInput,
-        cli: {
-            command,
-            vnext: {
-                arguments: "semantic",
-                audience: "customer",
-                category: "resource",
-                order,
-                outcome,
-                human,
-                automation,
-                acceptedReferences,
-                related,
-                resumableStates,
-                ...(review ? { review } : {}),
-            },
-        },
-        mcp: false,
-        slack: false,
-        execute: async (context, input) => mountExecutor(context)(id, input),
-    });
-}
-export const mountCapabilities = [
-    mountCapability({
-        id: "storage.volume-mounts.candidates",
-        command: ["volume-mounts", "candidates"],
-        description: "List capacity reservations eligible for a managed-volume mount.",
-        mutation: "read",
-        order: 540,
-        outcome: "List one bounded page of safe Bare Metal volume-mount candidates.",
-        human: "ornn volume-mounts candidates [--limit <1-500>] [--cursor <cursor>]",
-        automation: "ornn volume-mounts candidates --limit 50 --format json",
-        related: ["volume-mounts attach", "volumes list"],
-    }),
-    mountCapability({
-        id: "storage.volume-mounts.show",
-        command: ["volume-mounts", "show"],
-        description: "Show one reservation's exact managed-volume relationship and per-machine readiness.",
-        mutation: "read",
-        order: 541,
-        outcome: "Show actual per-machine mount state without rewriting volume lifecycle.",
-        human: "ornn volume-mounts show <canonical-reservation-id>",
-        automation: "ornn volume-mounts show <canonical-reservation-id> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        related: ["volume-mounts wait", "volumes show"],
-    }),
-    mountCapability({
-        id: "storage.volume-mounts.attach",
-        command: ["volume-mounts", "attach"],
-        description: "Attach one exact managed volume to every machine in one exact capacity reservation.",
-        mutation: "preview-confirm",
-        order: 542,
-        outcome: "Reconcile one exact volume-mount goal and preserve per-machine readiness.",
-        human: "ornn volume-mounts attach <canonical-reservation-id> --volume <exact-name-or-id> --access read-only|read-write [--no-wait]",
-        automation: "ornn volume-mounts attach <canonical-reservation-id> --volume <canonical-volume-id> --access read-only|read-write  --idempotency-key <key> --format json",
-        acceptedReferences: [
-            "canonical capacity-reservation ID",
-            "canonical or exact unique managed-volume reference",
-        ],
-        review: "Review the exact capacity reservation, volume, and access mode.",
-        resumableStates: ["accepted", "partial", "ready"],
-        related: ["volume-mounts wait", "volume-mounts detach"],
-    }),
-    mountCapability({
-        id: "storage.volume-mounts.wait",
-        command: ["volume-mounts", "wait"],
-        description: "Wait locally for every requested machine mount to reach a durable terminal state.",
-        mutation: "read",
-        order: 543,
-        outcome: "Wait with a bounded deadline while preserving useful per-machine partial data.",
-        human: "ornn volume-mounts wait <canonical-reservation-id> [--timeout <duration>]",
-        automation: "ornn volume-mounts wait <canonical-reservation-id> --timeout <duration> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        resumableStates: ["partial", "ready"],
-        related: ["volume-mounts show", "volume-mounts detach"],
-    }),
-    mountCapability({
-        id: "storage.volume-mounts.detach",
-        command: ["volume-mounts", "detach"],
-        description: "Detach one exact reservation relationship without deleting its volume.",
-        mutation: "preview-confirm",
-        order: 544,
-        outcome: "Reconcile an exact detached goal and preserve the underlying volume.",
-        human: "ornn volume-mounts detach <canonical-reservation-id>",
-        automation: "ornn volume-mounts detach <canonical-reservation-id>  --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        review: "Review the exact relationship and access loss; the managed volume remains.",
-        resumableStates: ["detaching", "ended"],
-        related: ["volumes show", "private-networks list"],
-    }),
-    mountCapability({
-        id: "storage.filesystems.deploy",
-        command: ["filesystems", "deploy"],
-        description: "Deploy one managed filesystem for an exact capacity reservation.",
-        mutation: "preview-confirm",
-        order: 550,
-        outcome: "Create or rediscover one filesystem deployment and expose every machine mount.",
-        human: "ornn filesystems deploy <canonical-reservation-id> --performance-tier <tier> --capacity-gib <gib> [--no-wait]",
-        automation: "ornn filesystems deploy <canonical-reservation-id> --performance-tier <tier> --capacity-gib <gib>  --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        review: "Review the exact reservation, performance tier, capacity, and managed filesystem consequence.",
-        resumableStates: ["accepted", "partial", "ready"],
-        related: ["filesystems wait", "filesystems delete"],
-    }),
-    mountCapability({
-        id: "storage.filesystems.show",
-        command: ["filesystems", "show"],
-        description: "Summarize one filesystem deployment from its underlying per-machine mounts.",
-        mutation: "read",
-        order: 551,
-        outcome: "Show actual per-machine filesystem readiness without changing volume state.",
-        human: "ornn filesystems show <canonical-reservation-id>",
-        automation: "ornn filesystems show <canonical-reservation-id> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        related: ["filesystems wait", "volume-mounts show"],
-    }),
-    mountCapability({
-        id: "storage.filesystems.wait",
-        command: ["filesystems", "wait"],
-        description: "Wait locally for a filesystem deployment's per-machine mount goal.",
-        mutation: "read",
-        order: 552,
-        outcome: "Wait for every filesystem member while retaining partial member data.",
-        human: "ornn filesystems wait <canonical-reservation-id> [--timeout <duration>]",
-        automation: "ornn filesystems wait <canonical-reservation-id> --timeout <duration> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        resumableStates: ["partial", "ready"],
-        related: ["filesystems show", "filesystems delete"],
-    }),
-    mountCapability({
-        id: "storage.filesystems.delete",
-        command: ["filesystems", "delete"],
-        description: "Remove one filesystem deployment relationship without deleting its managed volume.",
-        mutation: "preview-confirm",
-        order: 553,
-        outcome: "Detach every filesystem member while preserving the underlying managed volume.",
-        human: "ornn filesystems delete <canonical-reservation-id>",
-        automation: "ornn filesystems delete <canonical-reservation-id>  --idempotency-key <key> --format json",
-        acceptedReferences: ["canonical capacity-reservation ID"],
-        review: "Review the exact deployment and access loss; its managed volume remains.",
-        resumableStates: ["detaching", "ended"],
-        related: ["volumes show", "filesystems deploy"],
-    }),
-];