@ornncompute/cli 0.2.24 → 1.0.34

package/vendor/capabilities/capabilities/markets.js

@@ -0,0 +1,449 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+import { gpuDisplay, loadHardwareCatalog } from "../spec-catalog.js";
+import { consent, idempotencyHeaders, microUsdLabel, positionals, query, seg, } from "./market-shared.js";
+// Markets verbs: one capability per `/v1/markets` route. Spot order books are
+// per GPU slug; schedules are per listing. Prices are integer micro-USD per
+// GPU-hour, exactly as Markets reads and writes them.
+const BASE = "/v1/markets";
+function help(command, outcome, human, automation, related, order, acceptedReferences = []) {
+    return {
+        arguments: "semantic",
+        audience: "customer",
+        category: "resource",
+        command,
+        outcome,
+        human,
+        automation,
+        acceptedReferences,
+        related,
+        order,
+    };
+}
+const microUsd = z.coerce.number().int().positive();
+export const spotBooksInput = z.object({ $positionals: positionals });
+export const spotBooksCapability = defineCapability({
+    id: "spot.books",
+    domain: "markets",
+    roles: ["user"],
+    description: "List the spot order books, one per GPU type, with the best bid and ask in micro-USD per GPU-hour.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books` },
+    input: spotBooksInput,
+    cli: {
+        command: ["spot", "books"],
+        vnext: help(["spot", "books"], "List spot order books by GPU type with their best bid and ask.", "ornn spot books", "ornn spot books --format json", ["spot book", "spot bid"], 30),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/spot/books`, { method: "GET" }),
+});
+export const spotBookInput = z.object({
+    $positionals: positionals,
+    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
+});
+export const spotBookCapability = defineCapability({
+    id: "spot.book",
+    domain: "markets",
+    roles: ["user"],
+    description: "Show one spot order book's depth: GPUs and order counts at each bid and ask price level.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books/{gpuSlug}` },
+    input: spotBookInput,
+    cli: {
+        command: ["spot", "book"],
+        vnext: help(["spot", "book"], "Show bid and ask depth for one GPU type.", "ornn spot book --gpu-slug <slug>", "ornn spot book --gpu-slug <slug> --format json", ["spot books", "spot trades", "spot bid"], 31, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBookInput.parse(input);
+        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}`, { method: "GET" });
+    },
+});
+export const spotTradesCapability = defineCapability({
+    id: "spot.trades",
+    domain: "markets",
+    roles: ["user"],
+    description: "List recent spot trades for one GPU type: price, GPUs and time, with no identities.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/books/{gpuSlug}/trades` },
+    input: spotBookInput,
+    cli: {
+        command: ["spot", "trades"],
+        vnext: help(["spot", "trades"], "List recent spot fills for one GPU type.", "ornn spot trades --gpu-slug <slug>", "ornn spot trades --gpu-slug <slug> --format json", ["spot book"], 32, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBookInput.parse(input);
+        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}/trades`, { method: "GET" });
+    },
+});
+export const spotBidInput = z
+    .object({
+    $positionals: positionals,
+    gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
+    gpus: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(8)
+        .describe("GPUs on one node, 1-8. To buy N whole nodes, place N bids of 8 GPUs."),
+    orderType: z
+        .enum(["limit", "market"])
+        .default("limit")
+        .describe("A limit bid rests until filled; a market bid fills now or is cancelled."),
+    pricePerGpuHourMicroUsd: microUsd
+        .optional()
+        .describe("Limit price in micro-USD per GPU-hour (1000000 = $1.00). Required for limit bids."),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    confirm: z.boolean().optional(),
+})
+    .refine((bid) => (bid.orderType === "limit") === (bid.pricePerGpuHourMicroUsd !== undefined), {
+    message: "A limit bid needs pricePerGpuHourMicroUsd; a market bid takes no price.",
+    path: ["pricePerGpuHourMicroUsd"],
+});
+export const spotBidCapability = defineCapability({
+    id: "spot.bid",
+    domain: "markets",
+    roles: ["user"],
+    description: "Place a spot bid for 1-8 GPUs on one node. A filled bid becomes a running spot reservation, " +
+        "prepaid hourly from Ornn credits first and then the saved card; the side that takes a resting order pays the transaction fee. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/spot/orders` },
+    input: spotBidInput,
+    cli: {
+        command: ["spot", "bid"],
+        vnext: help(["spot", "bid"], "Place one spot bid for 1-8 GPUs on a single node.", "ornn spot bid --gpu-slug <slug> --gpus <1-8> [--order-type limit|market] [--price-per-gpu-hour-micro-usd <n>]", "ornn spot bid --gpu-slug <slug> --gpus 8 --price-per-gpu-hour-micro-usd 2500000 --yes --format json", ["spot orders", "spot cancel"], 33, ["catalog GPU slug"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotBidInput.parse(input);
+        const body = {
+            gpuSlug: parsed.gpuSlug,
+            gpus: parsed.gpus,
+            orderType: parsed.orderType,
+            ...(parsed.pricePerGpuHourMicroUsd !== undefined
+                ? { pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd }
+                : {}),
+        };
+        // 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, "spot.bid", "Place spot bid", [
+            { label: "GPU type", value: gpuDisplay(hardware?.terms ?? [], parsed.gpuSlug) },
+            { label: "GPUs", value: String(parsed.gpus) },
+            { label: "Order", value: parsed.orderType },
+            { label: "Limit price", value: microUsdLabel(parsed.pricePerGpuHourMicroUsd) },
+        ], body);
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/spot/orders`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const spotOrdersInput = z.object({ $positionals: positionals });
+export const spotOrdersCapability = defineCapability({
+    id: "spot.orders",
+    domain: "markets",
+    roles: ["user"],
+    description: "List this organization's spot bids (resting, running and ended) and the asks its listings have on the books.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/spot/orders` },
+    input: spotOrdersInput,
+    cli: {
+        command: ["spot", "orders"],
+        vnext: help(["spot", "orders"], "List your organization's spot bids and listing asks.", "ornn spot orders", "ornn spot orders --format json", ["spot bid", "spot cancel"], 34),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/spot/orders`, { method: "GET" }),
+});
+export const spotCancelInput = z.object({
+    $positionals: positionals,
+    orderId: z
+        .string()
+        .uuid()
+        .describe("A spot bid ID; for a running bid this is also its reservation ID."),
+    confirm: z.boolean().optional(),
+});
+export const spotCancelCapability = defineCapability({
+    id: "spot.cancel",
+    domain: "markets",
+    roles: ["user"],
+    description: "Cancel a resting spot bid, or end a running spot reservation (the buyer or the seller may end it; the GPUs go back on the book). Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: `${BASE}/spot/orders/{orderId}` },
+    input: spotCancelInput,
+    cli: {
+        command: ["spot", "cancel"],
+        vnext: help(["spot", "cancel"], "Cancel a resting bid or end a running spot reservation.", "ornn spot cancel --order-id <id>", "ornn spot cancel --order-id <id> --yes --format json", ["spot orders"], 35, ["spot order ID", "spot reservation ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = spotCancelInput.parse(input);
+        const gate = await consent(ctx, "spot.cancel", "Cancel spot order", [
+            { label: "Order", value: parsed.orderId },
+            {
+                label: "Consequence",
+                value: "A resting bid is cancelled; a running spot reservation ends and its machine stops.",
+            },
+        ], { orderId: parsed.orderId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/spot/orders/${seg(parsed.orderId)}`, { method: "DELETE" });
+    },
+});
+export const schedulesListInput = z.object({
+    $positionals: positionals,
+    listingKind: z.enum(["primary", "secondary"]).optional(),
+    gpuSlug: z.string().min(1).optional(),
+    from: z.string().min(1).optional().describe("RFC 3339 lower bound for the schedule window."),
+    to: z.string().min(1).optional().describe("RFC 3339 upper bound for the schedule window."),
+});
+export const schedulesListCapability = defineCapability({
+    id: "schedules.list",
+    domain: "markets",
+    roles: ["user"],
+    description: "List reservable schedules with their available windows (sold windows removed). Primary schedules are shown only to approved organizations; secondary (relisted) schedules are open to every signed-in organization.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/schedules` },
+    input: schedulesListInput,
+    cli: {
+        command: ["schedules", "list"],
+        vnext: help(["schedules", "list"], "List primary and secondary schedules with their open windows.", "ornn schedules list [--listing-kind primary|secondary] [--gpu-slug <slug>] [--from <time>] [--to <time>]", "ornn schedules list --listing-kind secondary --format json", ["schedules show", "schedules buy", "offers post"], 40),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = schedulesListInput.parse(input ?? {});
+        return ctx.fetch(`${BASE}/schedules${query({
+            listingKind: parsed.listingKind,
+            gpuSlug: parsed.gpuSlug,
+            from: parsed.from,
+            to: parsed.to,
+        })}`, { method: "GET" });
+    },
+});
+export const scheduleShowInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+});
+export const scheduleShowCapability = defineCapability({
+    id: "schedules.show",
+    domain: "markets",
+    roles: ["user"],
+    description: "Show one listing's schedule: a primary's price, down payment and open offer book, or a secondary's asking price, and its sold windows.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/schedules/{listingId}` },
+    input: scheduleShowInput,
+    cli: {
+        command: ["schedules", "show"],
+        vnext: help(["schedules", "show"], "Show one schedule with its sold windows and offers.", "ornn schedules show --listing-id <id>", "ornn schedules show --listing-id <id> --format json", ["schedules list", "schedules buy", "offers post", "offers accept"], 41, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = scheduleShowInput.parse(input);
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}`, { method: "GET" });
+    },
+});
+export const schedulePurchaseInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid().describe("A secondary (relisted) listing."),
+    startsAt: z
+        .string()
+        .min(1)
+        .describe("RFC 3339 start of the window: inside the listing, now or later, on the hour."),
+    endsAt: z
+        .string()
+        .min(1)
+        .describe("RFC 3339 end of the window, at least an hour after the start."),
+    askPricePerGpuHourMicroUsd: microUsd.describe("The listing's current asking price in micro-USD per GPU-hour, from schedules show. A changed price refuses the purchase."),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    confirm: z.boolean().optional(),
+});
+export const schedulePurchaseCapability = defineCapability({
+    id: "schedules.purchase",
+    domain: "markets",
+    roles: ["user"],
+    description: "Buy a window of a secondary (relisted) listing at its asking price, for every node on it. There is no offer: the window is yours once it is paid. You pay the asking price plus the Ornn trading fee up front, from Ornn credits and then your saved card; $10,000 or more is invoiced by wire. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/purchases` },
+    input: schedulePurchaseInput,
+    cli: {
+        command: ["schedules", "buy"],
+        vnext: help(["schedules", "buy"], "Buy a window of relisted capacity at its asking price.", "ornn schedules buy --listing-id <id> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd <n>", "ornn schedules buy --listing-id <id> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd 4000000 --yes --format json", ["schedules show", "reservations show"], 42, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = schedulePurchaseInput.parse(input);
+        const body = {
+            legs: [
+                {
+                    listingId: parsed.listingId,
+                    startsAt: parsed.startsAt,
+                    endsAt: parsed.endsAt,
+                    askPricePerGpuHourMicroUsd: parsed.askPricePerGpuHourMicroUsd,
+                },
+            ],
+        };
+        const gate = await consent(ctx, "schedules.purchase", "Buy relisted window", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Window", value: `${parsed.startsAt} to ${parsed.endsAt}` },
+            { label: "Asking price", value: microUsdLabel(parsed.askPricePerGpuHourMicroUsd) },
+            {
+                label: "Payment",
+                value: "Up front, with the Ornn trading fee on top: Ornn credits, then your saved card.",
+            },
+        ], body);
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/purchases`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const offersListInput = z.object({ $positionals: positionals });
+export const offersListCapability = defineCapability({
+    id: "offers.list",
+    domain: "markets",
+    roles: ["user"],
+    description: "List the offers this organization has posted on schedules, with their status.",
+    mutation: "read",
+    http: { method: "GET", path: `${BASE}/offers` },
+    input: offersListInput,
+    cli: {
+        command: ["offers", "list"],
+        vnext: help(["offers", "list"], "List the offers your organization has posted.", "ornn offers list", "ornn offers list --format json", ["offers post", "offers cancel"], 42),
+    },
+    slack: false,
+    execute: async (ctx) => ctx.fetch(`${BASE}/offers`, { method: "GET" }),
+});
+export const offerPostInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+    pricePerGpuHourMicroUsd: microUsd.describe("Offer price in micro-USD per GPU-hour (1000000 = $1.00). Covers every node for the rest of the listing."),
+    downPaymentCents: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Primary listings only: 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: every node, from the later of the listing's start and now to its end. The listing owner accepts it to create your reservation. Relisted (secondary) capacity takes no offers: buy it with schedules purchase. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers` },
+    input: offerPostInput,
+    cli: {
+        command: ["offers", "post"],
+        vnext: help(["offers", "post"], "Offer a price for a whole primary listing.", "ornn offers post --listing-id <id> --price-per-gpu-hour-micro-usd <n> [--down-payment-cents <n>]", "ornn offers post --listing-id <id> --price-per-gpu-hour-micro-usd 2500000 --yes --format json", ["schedules show", "offers list", "offers cancel"], 43, ["listing ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerPostInput.parse(input);
+        const body = {
+            pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd,
+            ...(parsed.downPaymentCents !== undefined
+                ? { downPaymentCents: parsed.downPaymentCents }
+                : {}),
+        };
+        const gate = await consent(ctx, "offers.post", "Post schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Window", value: "The rest of the listing" },
+            { label: "Price", value: microUsdLabel(parsed.pricePerGpuHourMicroUsd) },
+            ...(parsed.downPaymentCents !== undefined
+                ? [{ label: "Down payment", value: `$${(parsed.downPaymentCents / 100).toFixed(2)}` }]
+                : []),
+        ], { listingId: parsed.listingId, ...body });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers`, {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+        });
+    },
+});
+export const offerDecisionInput = z.object({
+    $positionals: positionals,
+    listingId: z.string().uuid(),
+    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 accepted window becomes the buyer's reservation and overlapping offers and relists from the same holding are cancelled. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers/{offerId}/accept` },
+    input: offerDecisionInput,
+    cli: {
+        command: ["offers", "accept"],
+        vnext: help(["offers", "accept"], "Accept one offer on a listing you own.", "ornn offers accept --listing-id <id> --offer-id <id>", "ornn offers accept --listing-id <id> --offer-id <id> --yes --format json", ["schedules show"], 44, ["listing ID", "offer ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerDecisionInput.parse(input);
+        const gate = await consent(ctx, "offers.accept", "Accept schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Offer", value: parsed.offerId },
+            {
+                label: "Consequence",
+                value: "The window is sold; overlapping open offers and conflicting relists from this holding are cancelled.",
+            },
+        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/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 posted, or one on a listing you own. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "DELETE", path: `${BASE}/schedules/{listingId}/offers/{offerId}` },
+    input: offerDecisionInput,
+    cli: {
+        command: ["offers", "cancel"],
+        vnext: help(["offers", "cancel"], "Cancel one open offer.", "ornn offers cancel --listing-id <id> --offer-id <id>", "ornn offers cancel --listing-id <id> --offer-id <id> --yes --format json", ["offers list"], 45, ["listing ID", "offer ID"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = offerDecisionInput.parse(input);
+        const gate = await consent(ctx, "offers.cancel", "Cancel schedule offer", [
+            { label: "Listing", value: parsed.listingId },
+            { label: "Offer", value: parsed.offerId },
+        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        if (gate)
+            return gate;
+        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers/${seg(parsed.offerId)}`, {
+            method: "DELETE",
+        });
+    },
+});
+export const marketCapabilities = [
+    spotBooksCapability,
+    spotBookCapability,
+    spotTradesCapability,
+    spotBidCapability,
+    spotOrdersCapability,
+    spotCancelCapability,
+    schedulesListCapability,
+    scheduleShowCapability,
+    schedulePurchaseCapability,
+    offersListCapability,
+    offerPostCapability,
+    offerAcceptCapability,
+    offerCancelCapability,
+];

package/vendor/capabilities/capabilities/mounts.js

@@ -0,0 +1,176 @@
+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 --yes --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> --yes --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> --yes --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> --yes --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"],
+    }),
+];