@ornncompute/cli 1.0.35 → 1.0.48

package/vendor/capabilities/capabilities/admin-capacity-reservations.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { defineCapability } from "../capability.js";
-import { createListingCapability } from "./listings.js";
+import { defineCapability, preview } from "../capability.js";
+import { nativeListingCreateInput } from "./native-listing.js";
+import { idempotencyHeaders } from "./market-shared.js";
 function adminHelp(command, outcome, human, automation, review) {
     return {
         audience: "admin",
@@ -13,78 +14,58 @@ function adminHelp(command, outcome, human, automation, review) {
         ...(review ? { review } : {}),
     };
 }
-const capacityOfferCreateInput = z.object({
-    gpu_type: z.string().min(1),
-    node_count: z.number().int().positive(),
-    gpus_per_node: z.number().int().min(1).max(8),
-    site_nickname: z.string().min(1),
-    available_start_at: z.string().min(1),
-    available_end_at: z.string().min(1),
-    buy_now_price_per_gpu_hour: z.number().positive(),
-    cost_per_gpu_hour: z.number().positive().optional(),
-    down_payment_cents: z.number().int().nonnegative().optional(),
-    access_mode: z.enum(["bare-metal", "virtual-machine"]).optional(),
-});
-export const adminCapacityOffersCreateCapability = {
-    ...createListingCapability,
+export const adminCapacityOffersCreateCapability = defineCapability({
+    id: "listing.create",
+    domain: "listings",
+    roles: ["admin"],
+    description: "Create native capacity with explicit organization/facility IDs, hardware, availability and advertised terms. Returns {listing, terms}. Requires an idempotencyKey reused on retries and confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/commerce/v2/listings" },
+    input: nativeListingCreateInput,
+    slack: false,
     cli: {
-        ...createListingCapability.cli,
-        vnext: adminHelp(["admin", "capacity-offers", "create"], "Create one primary listing from explicit commercial terms.", "ornn admin capacity-offers create --gpu GPU --nodes COUNT --gpus-per-node COUNT --site SITE --starts-at TIME --ends-at TIME --price-per-gpu-hour USD [--supplier-price-per-gpu-hour USD] [--down-payment-cents CENTS] [--access-mode bare-metal|virtual-machine]", "Not supported in machine or redirected execution because offer creation has no durable replay identity.", "GPU, site, availability window, supplier price, spread, and down payment are normalized before default-no consent."),
+        command: ["admin", "capacity-offers", "create"],
+        vnext: adminHelp(["admin", "capacity-offers", "create"], "Create native capacity and its advertised financial terms.", "ornn admin capacity-offers create --gpu-slug GPU --capacity-node-count COUNT --gpus-per-node COUNT --facility-id UUID --provisioning-type bare-metal|virtual-machine --state draft|available --terms JSON --idempotency-key KEY [--organization-id UUID] [--available-at TIME --available-until TIME] [--days-to-rfs DAYS]", "Requires an eligible human terminal; reuse --idempotency-key on retries.", "Review the native parent fields and each financial term before default-no consent."),
     },
-    input: createListingCapability.input,
     execute: async (ctx, input) => {
-        if (!ctx.cli)
-            return createListingCapability.execute(ctx, createListingCapability.input.parse(input));
-        const result = await createListingCapability.execute(ctx, capacityOfferCreateInput.parse(input));
-        if (!ctx.confirmed || object(result).ok === false)
-            return result;
-        return { listing: result };
+        const { confirm: _confirm, idempotencyKey, ...body } = nativeListingCreateInput.parse(input);
+        if (!ctx.confirmed)
+            return preview("listing.create", body);
+        return ctx.fetch("/commerce/v2/listings", {
+            method: "POST",
+            body,
+            headers: idempotencyHeaders(ctx, idempotencyKey),
+        });
     },
-};
-const MICRO_USD = 1_000_000;
+});
 export const reservationCreateInput = z.object({
-    organization_id: z.string().uuid(),
-    listing_id: z.string().uuid(),
-    start_at: z.string().min(1),
-    end_at: z.string().min(1),
-    price_per_gpu_hour: z
+    customerId: z.string().uuid(),
+    listingTermId: z.string().uuid(),
+    reservedNodeCount: z.number().int().positive().max(2_147_483_647),
+    reservedGpuCount: z.number().int().positive().max(2_147_483_647),
+    startsAt: z.iso.datetime({ offset: true }),
+    endsAt: z.iso.datetime({ offset: true }).nullable().optional(),
+    transactionId: z
         .string()
-        .regex(/^\d+(?:\.\d{1,6})?$/)
-        .describe("USD per GPU-hour, for example 2.50."),
-    down_payment_cents: z.number().int().nonnegative().optional(),
-    notes: z.string().max(2000).optional(),
+        .uuid()
+        .describe("Reuse this transaction ID when retrying the same reservation."),
+    vmDiskId: z.string().uuid().nullable().optional(),
 });
-function object(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
 export const adminReservationsCreateCapability = defineCapability({
     id: "reservations.create",
     domain: "reservations",
     roles: ["admin"],
-    description: "Create one schedule reservation on a listing from explicit, reviewed commercial terms (admin). The reservation covers the listing's nodes for the window.",
+    description: "Create one reservation from a listing term, customer, quantities, dates, and a stable transaction ID (admin).",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/commerce/reservations" },
     cli: {
         command: ["admin", "reservations", "create"],
-        vnext: adminHelp(["admin", "reservations", "create"], "Create one schedule reservation from explicit commercial terms.", "ornn admin reservations create --organization ID --capacity-offer ID --starts-at TIME --ends-at TIME --price-per-gpu-hour USD [--down-payment-cents CENTS]", "Not supported in machine or redirected execution because reservation creation has no durable replay identity.", "Organization, listing, dates, price, and down payment are normalized before default-no consent."),
+        vnext: adminHelp(["admin", "reservations", "create"], "Create one reservation using the selected listing term and quantities.", "ornn admin reservations create --customer ID --listing-term ID --nodes COUNT --gpus COUNT --starts-at TIME --transaction ID [--ends-at TIME] [--vm-disk ID]", "Requires an eligible human terminal. Reuse --transaction when retrying the same reservation.", "Customer, listing term, reserved quantities, dates, VM disk, and transaction ID are reviewed before default-no consent."),
     },
     slack: false,
     input: reservationCreateInput,
     execute: async (ctx, input) => {
-        const parsed = reservationCreateInput.parse(input);
-        const body = {
-            listingId: parsed.listing_id,
-            organizationId: parsed.organization_id,
-            startsAt: parsed.start_at,
-            endsAt: parsed.end_at,
-            pricePerGpuHourMicroUsd: Math.round(Number(parsed.price_per_gpu_hour) * MICRO_USD),
-            ...(parsed.down_payment_cents !== undefined
-                ? { downPaymentCents: parsed.down_payment_cents }
-                : {}),
-            ...(parsed.notes ? { notes: parsed.notes } : {}),
-        };
+        const body = reservationCreateInput.parse(input);
         if (!ctx.confirmed)
             return { preview: body };
         return { reservation: await ctx.fetch("/commerce/reservations", { method: "POST", body }) };

package/vendor/capabilities/capabilities/admin.js

@@ -3,10 +3,10 @@ import { defineCapability } from "../capability.js";
 import { listFacilitiesCapability, listNodesCapability, listSuppliersCapability } 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";
+import { organizationListCapability, usersListCapability } from "./users.js";
 export const ADMIN_CLI_ROOTS = [
     { name: "users" },
+    { name: "organizations" },
     { name: "suppliers" },
     { name: "facilities" },
     { name: "nodes" },
@@ -36,7 +36,8 @@ function withAdminBinding(capability, 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 adminUsersListCapability = withAdminBinding(usersListCapability, adminHelp(["admin", "users", "list"], "List users belonging to organizations in the Authorization directory.", "ornn admin users list [--query QUERY] [--organization UUID] [--limit 25] [--offset OFFSET] [--cursor CURSOR]", "ornn admin users list --query QUERY --limit 25 [--cursor CURSOR] --format json"));
+export const adminOrganizationsListCapability = withAdminBinding(organizationListCapability, adminHelp(["admin", "organizations", "list"], "List organizations in the Authorization directory.", "ornn admin organizations list [--query QUERY] [--role consumer|supplier] [--approved true|false] [--ids UUID,...] [--limit 25] [--offset OFFSET] [--cursor CURSOR]", "ornn admin organizations list --query QUERY --limit 25 [--cursor CURSOR] --format json"));
 export const adminSuppliersListCapability = withAdminBinding(listSuppliersCapability, adminHelp(["admin", "suppliers", "list"], "List supplier organizations visible to staff.", "ornn admin suppliers list [--limit 50] [--cursor CURSOR]", "ornn admin suppliers list --limit 50 --format json"));
 export const adminFacilitiesListCapability = withAdminBinding(listFacilitiesCapability, adminHelp(["admin", "facilities", "list"], "List facilities visible to staff.", "ornn admin facilities list [--supplier UUID] [--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 [--supplier UUID] [--facility FACILITY] [--status STATUS] [--email EMAIL] [--limit 50] [--cursor CURSOR]", "ornn admin nodes list --limit 50 [--cursor CURSOR] --format json"));
@@ -64,7 +65,8 @@ export const adminNodeMetricsCapability = withAdminBinding(telemetryLatestCapabi
 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,
+    adminUsersListCapability,
+    adminOrganizationsListCapability,
     adminSuppliersListCapability,
     adminFacilitiesListCapability,
     adminNodesListCapability,
@@ -74,14 +76,14 @@ export const adminCapabilities = [
     adminEnrollmentTokensListCapability,
 ];
 const replacements = {
-    "listings.create": adminCapacityOffersCreateCapability,
     "facilities.list": adminFacilitiesListCapability,
     "logs.latest": adminNodeLogsCapability,
     "nodes.list": adminNodesListCapability,
     "supplier.list": adminSuppliersListCapability,
     "telemetry.latest": adminNodeMetricsCapability,
     "tokens.list": adminEnrollmentTokensListCapability,
-    "users.query": adminUsersSearchCapability,
+    "users.list": adminUsersListCapability,
+    "organization.list": adminOrganizationsListCapability,
 };
 /** Applies canonical admin CLI bindings without changing MCP or Slack identities. */
 export function bindAdminCapabilities(capabilities) {

package/vendor/capabilities/capabilities/commerce-market.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { defineCapability } from "../capability.js";
-import { consent, flag, idempotencyHeaders, microUsdLabel, positionals, query, seg, } from "./market-shared.js";
+import { nativeTermsInput, nativeTermFields, listingWriteControls } from "./native-listing.js";
+import { defineCapability, preview } from "../capability.js";
+import { consent, idempotencyHeaders, positionals, query, seg } from "./market-shared.js";
 // Commerce market verbs: one capability per role-aware `/commerce` route.
 // Commerce decides from the caller's session what each listing or
 // reservation reveals; these verbs return its JSON unchanged.
@@ -18,7 +19,6 @@ function help(command, outcome, human, automation, related, order, acceptedRefer
         order,
     };
 }
-const microUsd = z.coerce.number().int().positive();
 const pageLimit = z.coerce.number().int().min(1).max(200).optional();
 const nodeIdList = z.preprocess((value) => typeof value === "string"
     ? value
@@ -28,29 +28,29 @@ const nodeIdList = z.preprocess((value) => typeof value === "string"
     : value, z.array(z.string().uuid()).min(1));
 export const listingsListInput = z.object({
     $positionals: positionals,
-    kind: z.enum(["primary", "secondary"]).optional(),
-    state: z.enum(["available", "internal", "delisted"]).optional(),
+    kind: z.enum(["primary", "secondary", "on_demand"]).optional(),
+    state: z.enum(["draft", "available", "held", "sold", "delisted"]).optional(),
     sourceReservationId: z.string().uuid().optional(),
     sourceListingId: z.string().uuid().optional(),
-    limit: pageLimit,
+    limit: z.coerce.number().int().min(1).max(100).optional(),
     cursor: z.string().min(1).optional(),
 });
 export const listingsListCapability = defineCapability({
     id: "listings.list",
     domain: "listings",
     roles: ["user"],
-    description: "List Commerce listings. Primary listings are shown to approved organizations; secondary listings (relists) to every signed-in organization. Prices are micro-USD per GPU-hour.",
+    description: "List native capacity listings. Primary listings require organization approval. Returns capacityListingId, hardware, capacity and availability; read listings.terms separately for prices and durations.",
     mutation: "read",
-    http: { method: "GET", path: "/commerce/listings" },
+    http: { method: "GET", path: "/commerce/v2/listings" },
     input: listingsListInput,
     cli: {
         command: ["capacity-offers", "list"],
-        vnext: help(["capacity-offers", "list"], "List primary and secondary listings with bounded pagination and no supplier provenance.", "ornn capacity-offers list [--kind primary|secondary] [--source-reservation-id <id>] [--limit <1-200>] [--cursor <opaque>]", "ornn capacity-offers list --limit 50 --format json", ["capacity-offers show", "schedules list"], 20, ["opaque page cursor"]),
+        vnext: help(["capacity-offers", "list"], "List capacity parents with bounded pagination; read their financial terms separately.", "ornn capacity-offers list [--kind primary|secondary|on_demand] [--source-reservation-id <id>] [--limit <1-100>] [--cursor <opaque>]", "ornn capacity-offers list --limit 50 --format json", ["capacity-offers show", "capacity-offers terms", "schedules list"], 20, ["opaque page cursor"]),
     },
     slack: false,
     execute: async (ctx, input) => {
         const parsed = listingsListInput.parse(input ?? {});
-        return ctx.fetch(`/commerce/listings${query({
+        return ctx.fetch(`/commerce/v2/listings${query({
             kind: parsed.kind,
             state: parsed.state,
             sourceReservationId: parsed.sourceReservationId,
@@ -68,122 +68,113 @@ export const listingShowCapability = defineCapability({
     id: "listings.show",
     domain: "listings",
     roles: ["user"],
-    description: "Show one Commerce listing: specs, window, node count and its buyer price.",
+    description: "Show one native capacity listing. Returns capacityListingId, hardware, capacity and availability; use listings.terms for financial choices.",
     mutation: "read",
-    http: { method: "GET", path: "/commerce/listings/{listingId}" },
+    http: { method: "GET", path: "/commerce/v2/listings/{listingId}" },
     input: listingShowInput,
     cli: {
         command: ["capacity-offers", "show"],
-        vnext: help(["capacity-offers", "show"], "Inspect one listing's hardware, facility, window and price.", "ornn capacity-offers show --listing-id <id>", "ornn capacity-offers show --listing-id <id> --format json", ["capacity-offers list", "schedules show"], 21, ["listing ID"]),
+        vnext: help(["capacity-offers", "show"], "Inspect one listing's hardware, capacity and availability.", "ornn capacity-offers show --listing-id <id>", "ornn capacity-offers show --listing-id <id> --format json", ["capacity-offers list", "capacity-offers terms", "schedules show"], 21, ["listing ID"]),
     },
     slack: false,
     execute: async (ctx, input) => {
         const parsed = listingShowInput.parse(input);
-        return ctx.fetch(`/commerce/listings/${seg(parsed.listingId)}`, { method: "GET" });
+        return ctx.fetch(`/commerce/v2/listings/${seg(parsed.listingId)}`, { method: "GET" });
     },
 });
-export const listingRelistInput = z
-    .object({
+export const listingTermsCapability = defineCapability({
+    id: "listings.terms",
+    domain: "listings",
+    roles: ["user"],
+    description: "Read a capacity listing's advertised financial terms. Each term returns listingTermsId, capacityListingId, pricePerGpuHourMicroUsd, duration bounds, downPaymentCents and renewable. Use the parent's capacityListingId as listingId. Prices are integer micro-USD per GPU-hour.",
+    mutation: "read",
+    http: { method: "GET", path: "/commerce/v2/listings/{listingId}/terms" },
+    input: listingShowInput,
+    cli: {
+        command: ["capacity-offers", "terms"],
+        vnext: help(["capacity-offers", "terms"], "Read the advertised financial terms for a capacity listing.", "ornn capacity-offers terms --listing-id <id>", "ornn capacity-offers terms --listing-id <id> --format json", ["capacity-offers show", "offers post"], 22, ["capacityListingId from capacity-offers list or show"]),
+    },
+    slack: false,
+    execute: async (ctx, input) => {
+        const parsed = listingShowInput.parse(input);
+        return ctx.fetch(`/commerce/v2/listings/${seg(parsed.listingId)}/terms`, { method: "GET" });
+    },
+});
+export const listingRelistInput = z.object({
     $positionals: positionals,
-    sourceReservationId: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("A confirmed or active schedule reservation you hold."),
-    sourceListingId: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("A primary listing you own (suppliers relist their own listings)."),
-    nodeIds: nodeIdList.describe("The nodes to relist: a subset of the source's nodes (comma-separated on the CLI)."),
-    startsAt: z.string().min(1).describe("RFC 3339 start, inside the source's window."),
-    endsAt: z.string().min(1).describe("RFC 3339 end, inside the source's window."),
-    askPricePerGpuHourMicroUsd: microUsd.describe("Asking price in micro-USD per GPU-hour, the listing's only price: buyers buy any open window at it, and idle time sells as spot at it."),
-    sellAtMarketFirst: flag
-        .default(false)
-        .describe("Sell each node's GPUs into resting spot bids before asking at the asking price."),
+    reservationId: z.string().uuid(),
+    startsAt: z.iso.datetime({ offset: true }),
+    endsAt: z.iso.datetime({ offset: true }),
+    nodeCount: z.coerce.number().int().positive(),
+    nodeIds: nodeIdList.optional(),
+    reservedNodeIds: nodeIdList.optional(),
+    terms: nativeTermsInput,
     idempotencyKey: z.string().min(1).max(200).optional(),
     confirm: z.boolean().optional(),
-})
-    .refine((relist) => (relist.sourceReservationId === undefined) !== (relist.sourceListingId === undefined), {
-    message: "Give exactly one of sourceReservationId or sourceListingId.",
-    path: ["sourceReservationId"],
 });
 export const listingRelistCapability = defineCapability({
     id: "listings.relist",
     domain: "listings",
     roles: ["user"],
-    description: "Relist a time slice and/or node subset of a schedule reservation you hold (or a primary listing you own) as a secondary listing with an asking price. " +
-        "Buyers buy any open window of it at the asking price, and its unsold time goes on the spot book. Fails with node_window_sold if those nodes are already sold for part of the window, or relist_overlaps if another live relist of those nodes overlaps it. Requires confirm: true.",
+    description: "Relist delivered capacity from a reservation using a native availability window, nodeCount and financial terms. Supply nodeIds or reservedNodeIds only when selecting specific nodes. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: "/commerce/listings" },
+    http: { method: "POST", path: "/commerce/reservations/{reservationId}/relist" },
     input: listingRelistInput,
     cli: {
         command: ["capacity-offers", "relist"],
-        vnext: help(["capacity-offers", "relist"], "Relist part of a reservation or primary listing you hold.", "ornn capacity-offers relist --source-reservation-id <id> --node-ids <id,...> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd <n> [--sell-at-market-first true]", "ornn capacity-offers relist --source-reservation-id <id> --node-ids <id> --starts-at <time> --ends-at <time> --ask-price-per-gpu-hour-micro-usd 2500000 --yes --format json", ["capacity-offers update", "capacity-offers delist", "reservations show"], 23, ["reservation ID", "listing ID", "node ID"]),
+        vnext: help(["capacity-offers", "relist"], "Relist reserved capacity with explicit financial terms.", "ornn capacity-offers relist --reservation-id UUID --node-count COUNT --starts-at TIME --ends-at TIME --terms JSON [--node-ids UUID,...] [--reserved-node-ids UUID,...]", "ornn capacity-offers relist --reservation-id UUID --node-count 1 --starts-at TIME --ends-at TIME --terms JSON --idempotency-key KEY --yes --format json", ["capacity-offers terms", "capacity-offers delist"], 23, ["reservation ID"]),
     },
     slack: false,
     execute: async (ctx, input) => {
-        const parsed = listingRelistInput.parse(input);
-        const body = {
-            ...(parsed.sourceReservationId ? { sourceReservationId: parsed.sourceReservationId } : {}),
-            ...(parsed.sourceListingId ? { sourceListingId: parsed.sourceListingId } : {}),
-            nodeIds: parsed.nodeIds,
-            startsAt: parsed.startsAt,
-            endsAt: parsed.endsAt,
-            askPricePerGpuHourMicroUsd: parsed.askPricePerGpuHourMicroUsd,
-            sellAtMarketFirst: parsed.sellAtMarketFirst,
-        };
+        const { $positionals: _, reservationId, confirm: _confirm, idempotencyKey, ...body } = listingRelistInput.parse(input);
         const gate = await consent(ctx, "listings.relist", "Relist capacity", [
-            {
-                label: "Source",
-                value: parsed.sourceReservationId
-                    ? `reservation ${parsed.sourceReservationId}`
-                    : `listing ${parsed.sourceListingId}`,
-            },
-            { label: "Nodes", value: parsed.nodeIds.join(", ") },
-            { label: "Window", value: `${parsed.startsAt} to ${parsed.endsAt}` },
-            { label: "Asking price", value: microUsdLabel(parsed.askPricePerGpuHourMicroUsd) },
-            { label: "Sell at market first", value: parsed.sellAtMarketFirst ? "yes" : "no" },
-        ], body);
+            { label: "Reservation", value: reservationId },
+            { label: "Capacity and financial terms", value: JSON.stringify(body) },
+        ], { reservationId, ...body });
         if (gate)
             return gate;
-        return ctx.fetch("/commerce/listings", {
+        return ctx.fetch(`/commerce/reservations/${seg(reservationId)}/relist`, {
             method: "POST",
             body,
-            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
+            headers: idempotencyHeaders(ctx, idempotencyKey),
         });
     },
 });
-export const listingUpdateInput = z.object({
+export const listingUpdateInput = z
+    .object({
     $positionals: positionals,
     listingId: z.string().uuid(),
-    askPricePerGpuHourMicroUsd: microUsd,
-    confirm: z.boolean().optional(),
-});
+    listingTermsId: z.string().uuid(),
+    ...nativeTermFields,
+    ...listingWriteControls,
+})
+    .strict();
 export const listingUpdateCapability = defineCapability({
     id: "listings.update",
     domain: "listings",
-    roles: ["user"],
-    description: "Change the asking price of a secondary listing you own, its only price. Windows bought later use the new price, and the listing's spot asks are re-sent at it. Requires confirm: true.",
+    roles: ["admin"],
+    description: "Staff only: edit one advertised native financial term with its complete financial fields. Reuse idempotencyKey on retries. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/commerce/listings/{listingId}" },
+    http: { method: "PATCH", path: "/commerce/v2/listings/{listingId}/terms/{listingTermsId}" },
     input: listingUpdateInput,
     cli: {
-        command: ["capacity-offers", "update"],
-        vnext: help(["capacity-offers", "update"], "Change the asking price of a listing you relisted.", "ornn capacity-offers update --listing-id <id> --ask-price-per-gpu-hour-micro-usd <n>", "ornn capacity-offers update --listing-id <id> --ask-price-per-gpu-hour-micro-usd 2400000 --yes --format json", ["capacity-offers relist", "capacity-offers delist"], 24, ["listing ID"]),
+        command: ["admin", "capacity-offers", "update"],
+        vnext: {
+            ...help(["admin", "capacity-offers", "update"], "Edit one advertised financial term as staff.", "ornn admin capacity-offers update --listing-id UUID --listing-terms-id UUID --min-duration-hours HOURS --max-duration-hours HOURS --price-per-gpu-hour-micro-usd RATE --renewable true|false --idempotency-key KEY [--type reserved|spot|on-demand] [--down-payment-cents CENTS]", "Requires an eligible human terminal; reuse --idempotency-key on retries.", ["capacity-offers terms"], 24),
+            audience: "admin",
+        },
     },
     slack: false,
+    mcp: false,
     execute: async (ctx, input) => {
-        const parsed = listingUpdateInput.parse(input);
-        const body = { askPricePerGpuHourMicroUsd: parsed.askPricePerGpuHourMicroUsd };
-        const gate = await consent(ctx, "listings.update", "Update listing asking price", [
-            { label: "Listing", value: parsed.listingId },
-            { label: "Asking price", value: microUsdLabel(body.askPricePerGpuHourMicroUsd) },
-        ], { listingId: parsed.listingId, ...body });
-        if (gate)
-            return gate;
-        return ctx.fetch(`/commerce/listings/${seg(parsed.listingId)}`, { method: "PATCH", body });
+        const { $positionals: _, listingId, listingTermsId, confirm: _confirm, idempotencyKey, ...body } = listingUpdateInput.parse(input);
+        if (!ctx.confirmed)
+            return preview("listings.update", { listingId, listingTermsId, ...body });
+        return ctx.fetch(`/commerce/v2/listings/${seg(listingId)}/terms/${seg(listingTermsId)}`, {
+            method: "PATCH",
+            body,
+            headers: idempotencyHeaders(ctx, idempotencyKey),
+        });
     },
 });
 export const listingDelistInput = z.object({
@@ -197,7 +188,7 @@ export const listingDelistCapability = defineCapability({
     roles: ["user"],
     description: "Delist a listing you own. Its unsold time leaves the market, its spot asks are cancelled and running spot reservations on it end. Windows already bought stay sold. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "DELETE", path: "/commerce/listings/{listingId}" },
+    http: { method: "POST", path: "/commerce/v2/listings/{listingId}/delist" },
     input: listingDelistInput,
     cli: {
         command: ["capacity-offers", "delist"],
@@ -215,7 +206,7 @@ export const listingDelistCapability = defineCapability({
         ], { listingId: parsed.listingId });
         if (gate)
             return gate;
-        return ctx.fetch(`/commerce/listings/${seg(parsed.listingId)}`, { method: "DELETE" });
+        return ctx.fetch(`/commerce/v2/listings/${seg(parsed.listingId)}/delist`, { method: "POST" });
     },
 });
 export const reservationsListInput = z.object({
@@ -301,30 +292,14 @@ export const reservationInvoicesCapability = defineCapability({
         });
     },
 });
-export const feesShowInput = z.object({ $positionals: positionals });
-export const feesShowCapability = defineCapability({
-    id: "fees.show",
-    domain: "billing",
-    roles: ["user"],
-    description: "Show the transaction fee on spot and secondary trades, in parts per million (1000000 = 100%). The side that takes a resting order pays it; primary schedules carry no transaction fee.",
-    mutation: "read",
-    http: { method: "GET", path: "/commerce/fees" },
-    input: feesShowInput,
-    cli: {
-        command: ["fees", "show"],
-        vnext: help(["fees", "show"], "Show the transaction fee on spot and secondary trades.", "ornn fees show", "ornn fees show --format json", ["spot bid", "offers post"], 29),
-    },
-    slack: false,
-    execute: async (ctx) => ctx.fetch("/commerce/fees", { method: "GET" }),
-});
 export const commerceMarketCapabilities = [
     listingsListCapability,
     listingShowCapability,
+    listingTermsCapability,
     listingRelistCapability,
     listingUpdateCapability,
     listingDelistCapability,
     reservationsListCapability,
     reservationsShowCapability,
     reservationInvoicesCapability,
-    feesShowCapability,
 ];

package/vendor/capabilities/capabilities/compute.js

@@ -23,6 +23,7 @@ export const launchInput = z
     resume: z.union([z.string().min(1), z.literal(true)]).optional(),
     timeout: z.string().optional(),
     username: z.string().optional(),
+    vms: z.string().optional(),
     wait: z.boolean().optional(),
     yes: z.boolean().optional(),
     volume: z.string().optional(),
@@ -139,11 +140,12 @@ export const launchCapability = cliOnly({
             category: "journey",
             order: 2,
             outcome: "Launch one reviewed VM, Bare Metal machine, Kubernetes cluster, or Slurm cluster from active reserved capacity, including a declared durable Bare Metal workspace.",
-            human: "ornn launch [<capacity-reservation>] --mode vm|bare-metal|kubernetes|slurm [--key <ssh-key>]; Bare Metal may add --network shared --volume <managed-volume> --mount-access read-only|read-write; Kubernetes/Slurm prompt for missing --network public|private and --nodes <membership-count>",
-            automation: "ornn launch <canonical-reservation-id> --mode vm|bare-metal|kubernetes|slurm --organization <id> --yes --idempotency-key <key> --format json; VM/Bare Metal/Slurm require --key <canonical-key-id>; Bare Metal may add --network shared --volume <canonical-volume-id> --mount-access read-only|read-write; Kubernetes/Slurm require --network public|private --nodes <membership-count> --machines <canonical-machine-ids>",
+            human: "ornn launch [<capacity-reservation>] --mode vm|bare-metal|kubernetes|slurm [--key <ssh-key>]; Bare Metal may add --network shared --volume <managed-volume> --mount-access read-only|read-write; Kubernetes/Slurm prompt for missing --network public|private and --nodes <membership-count>, and may add running VMs with --vms <vm-ids>",
+            automation: "ornn launch <canonical-reservation-id> --mode vm|bare-metal|kubernetes|slurm --organization <id> --yes --idempotency-key <key> --format json; VM/Bare Metal/Slurm require --key <canonical-key-id>; Bare Metal may add --network shared --volume <canonical-volume-id> --mount-access read-only|read-write; Kubernetes/Slurm require --network public|private --nodes <membership-count> --machines <canonical-machine-ids>, and may add --vms <canonical-vm-ids> (with --nodes 0 for a cluster of VMs only)",
             acceptedReferences: [
                 "canonical capacity-reservation ID",
                 "canonical eligible machine IDs",
+                "canonical running VM IDs for cluster membership",
                 "invocation-local eligible reservation and machine choices",
                 "exact SSH-key and managed-volume references; organization network shared",
             ],