@ornncompute/cli 1.0.48 → 1.0.62

package/vendor/capabilities/capabilities/markets.js

@@ -1,11 +1,30 @@
 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.
+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",
@@ -20,317 +39,326 @@ function help(command, outcome, human, automation, related, order, acceptedRefer
         order,
     };
 }
-const microUsd = z.coerce.number().int().positive();
-export const spotBooksInput = z.object({ $positionals: positionals });
-export const spotBooksCapability = defineCapability({
-    id: "spot.books",
+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 spot order books, one per GPU type, with the best bid and ask in micro-USD per GPU-hour.",
+    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}/spot/books` },
-    input: spotBooksInput,
+    http: { method: "GET", path: `${BASE}/books` },
+    input: marketBooksInput,
     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),
+        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) => ctx.fetch(`${BASE}/spot/books`, { method: "GET" }),
+    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 spotBookInput = z.object({
+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 spotBookCapability = defineCapability({
-    id: "spot.book",
+export const marketBookCapability = defineCapability({
+    id: "market.book",
     domain: "markets",
     roles: ["user"],
-    description: "Show one spot order book's depth: GPUs and order counts at each bid and ask price level.",
+    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}/spot/books/{gpuSlug}` },
-    input: spotBookInput,
+    http: { method: "GET", path: `${BASE}/books/{gpuSlug}` },
+    input: marketBookInput,
     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"]),
+        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 = spotBookInput.parse(input);
-        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}`, { method: "GET" });
+        const parsed = marketBookInput.parse(input);
+        return ctx.fetch(`${BASE}/books/${seg(parsed.gpuSlug)}${bookQuery(parsed)}`, {
+            method: "GET",
+        });
     },
 });
-export const spotTradesCapability = defineCapability({
-    id: "spot.trades",
+export const marketTradesCapability = defineCapability({
+    id: "market.trades",
     domain: "markets",
     roles: ["user"],
-    description: "List recent spot trades for one GPU type: price, GPUs and time, with no identities.",
+    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}/spot/books/{gpuSlug}/trades` },
-    input: spotBookInput,
+    http: { method: "GET", path: `${BASE}/books/{gpuSlug}/trades` },
+    input: marketBookInput,
     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"]),
+        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 = spotBookInput.parse(input);
-        return ctx.fetch(`${BASE}/spot/books/${seg(parsed.gpuSlug)}/trades`, { method: "GET" });
+        const parsed = marketBookInput.parse(input);
+        return ctx.fetch(`${BASE}/books/${seg(parsed.gpuSlug)}/trades${bookQuery(parsed)}`, {
+            method: "GET",
+        });
     },
 });
-export const spotBidInput = z
-    .object({
+export const marketQuoteInput = z.object({
     $positionals: positionals,
     gpuSlug: z.string().min(1).describe("Catalog GPU slug, for example nvidia_h100_sxm."),
-    gpus: z.coerce
-        .number()
-        .int()
-        .min(8)
-        .max(8)
-        .describe("Exactly 8 GPUs on one full node. To buy N nodes, place N bids."),
-    orderType: z
-        .enum(["limit", "market"])
-        .default("limit")
-        .describe("A limit bid rests until filled; a market bid fills now or is cancelled."),
-    pricePerGpuHourMicroUsd: microUsd
+    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("Limit price in micro-USD per GPU-hour (1000000 = $1.00). Required for limit bids."),
+        .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(),
-})
-    .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",
+export const marketBidCapability = defineCapability({
+    id: "market.bid",
     domain: "markets",
     roles: ["user"],
-    description: "Place a spot bid for a full node with 8 GPUs. A filled bid becomes a running spot reservation, " +
-        "prepaid hourly from Ornn credits first and then the saved card. Book prices are what you pay; a limit is the most you pay per GPU-hour. Requires confirm: true.",
+    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. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/spot/orders` },
-    input: spotBidInput,
+    http: { method: "POST", path: `${BASE}/orders` },
+    input: marketBidInput,
     cli: {
-        command: ["spot", "bid"],
-        vnext: help(["spot", "bid"], "Place one spot bid for a full node with 8 GPUs.", "ornn spot bid --gpu-slug <slug> --gpus 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"]),
+        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 --yes --format json", ["market quote", "market orders", "market fills", "market cancel"], 35, ["catalog GPU slug"]),
     },
     slack: false,
     execute: async (ctx, input) => {
-        const parsed = spotBidInput.parse(input);
+        const parsed = marketBidInput.parse(input);
         const body = {
             gpuSlug: parsed.gpuSlug,
-            gpus: parsed.gpus,
-            orderType: parsed.orderType,
-            ...(parsed.pricePerGpuHourMicroUsd !== undefined
-                ? { pricePerGpuHourMicroUsd: parsed.pricePerGpuHourMicroUsd }
-                : {}),
+            ...(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, "spot.bid", "Place spot bid", [
+        const gate = await consent(ctx, "market.bid", "Place 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) },
+            { 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}/spot/orders`, {
+        return ctx.fetch(`${BASE}/orders`, {
             method: "POST",
             body,
             headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
         });
     },
 });
-export const spotOrdersInput = z.object({ $positionals: positionals });
-export const spotOrdersCapability = defineCapability({
-    id: "spot.orders",
+export const marketOrdersInput = z.object({ $positionals: positionals });
+export const marketOrdersCapability = defineCapability({
+    id: "market.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.",
+    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}/spot/orders` },
-    input: spotOrdersInput,
+    http: { method: "GET", path: `${BASE}/orders` },
+    input: marketOrdersInput,
     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),
+        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}/spot/orders`, { method: "GET" }),
+    execute: async (ctx) => ctx.fetch(`${BASE}/orders`, { method: "GET" }),
 });
-export const spotCancelInput = z.object({
+export const marketCancelInput = z.object({
     $positionals: positionals,
-    orderId: z
-        .string()
-        .uuid()
-        .describe("A spot bid ID; for a running bid this is also its reservation ID."),
+    orderId: z.string().uuid().describe("A resting bid ID."),
     confirm: z.boolean().optional(),
 });
-export const spotCancelCapability = defineCapability({
-    id: "spot.cancel",
+export const marketCancelCapability = defineCapability({
+    id: "market.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.",
+    description: "Cancel what a resting bid has not bought yet. Its fills keep running; end them with market end. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "DELETE", path: `${BASE}/spot/orders/{orderId}` },
-    input: spotCancelInput,
+    http: { method: "DELETE", path: `${BASE}/orders/{orderId}` },
+    input: marketCancelInput,
     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"]),
+        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> --yes --format json", ["market orders", "market end"], 37, ["order ID"]),
     },
     slack: false,
     execute: async (ctx, input) => {
-        const parsed = spotCancelInput.parse(input);
-        const gate = await consent(ctx, "spot.cancel", "Cancel spot order", [
+        const parsed = marketCancelInput.parse(input);
+        const gate = await consent(ctx, "market.cancel", "Cancel bid", [
             { label: "Order", value: parsed.orderId },
             {
                 label: "Consequence",
-                value: "A resting bid is cancelled; a running spot reservation ends and its machine stops.",
+                value: "The bid stops buying. What it already bought keeps running.",
             },
         ], { orderId: parsed.orderId });
         if (gate)
             return gate;
-        return ctx.fetch(`${BASE}/spot/orders/${seg(parsed.orderId)}`, { method: "DELETE" });
+        return ctx.fetch(`${BASE}/orders/${seg(parsed.orderId)}`, { method: "DELETE" });
     },
 });
-export const schedulesListInput = z.object({
+export const marketFillsInput = 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."),
+    orderId: z.string().uuid().optional().describe("Only this bid's fills."),
 });
-export const schedulesListCapability = defineCapability({
-    id: "schedules.list",
+export const marketFillsCapability = defineCapability({
+    id: "market.fills",
     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.",
+    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}/schedules` },
-    input: schedulesListInput,
+    http: { method: "GET", path: `${BASE}/fills` },
+    input: marketFillsInput,
     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),
+        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 = schedulesListInput.parse(input ?? {});
-        return ctx.fetch(`${BASE}/schedules${query({
-            listingKind: parsed.listingKind,
-            gpuSlug: parsed.gpuSlug,
-            from: parsed.from,
-            to: parsed.to,
-        })}`, { method: "GET" });
+        const parsed = marketFillsInput.parse(input ?? {});
+        return ctx.fetch(`${BASE}/fills${query({ orderId: parsed.orderId })}`, { method: "GET" });
     },
 });
-export const scheduleShowInput = z.object({
+export const marketEndInput = 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(),
+    fillId: z.string().uuid().describe("A fill ID; it is also its reservation ID."),
     confirm: z.boolean().optional(),
 });
-export const schedulePurchaseCapability = defineCapability({
-    id: "schedules.purchase",
+export const marketEndCapability = defineCapability({
+    id: "market.end",
     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 up front, from Ornn credits and then your saved card; $10,000 or more is invoiced by wire. Requires confirm: true.",
+    description: "End a running fill: its reservation stops, its VMs stop, and its GPUs go back on the book. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/schedules/purchases` },
-    input: schedulePurchaseInput,
+    http: { method: "POST", path: "/commerce/reservations/{fillId}/stop" },
+    input: marketEndInput,
     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"]),
+        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> --yes --format json", ["market fills"], 39, ["fill ID", "reservation 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: Ornn credits, then your saved card.",
-            },
-        ], body);
+        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(`${BASE}/schedules/purchases`, {
-            method: "POST",
-            body,
-            headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
-        });
+        return ctx.fetch(`/commerce/reservations/${seg(parsed.fillId)}/stop`, { method: "POST" });
     },
 });
-export const offersListInput = z.object({ $positionals: positionals });
+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 the offers this organization has posted on schedules, with their status.",
+    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 the offers your organization has posted.", "ornn offers list", "ornn offers list --format json", ["offers post", "offers cancel"], 42),
+        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) => ctx.fetch(`${BASE}/offers`, { method: "GET" }),
+    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(),
-    pricePerGpuHourMicroUsd: microUsd.describe("Offer price in micro-USD per GPU-hour (1000000 = $1.00). Covers every node for the rest of the listing."),
+    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("Primary listings only: the down payment you offer, in cents."),
+        .describe("The down payment you offer, in cents."),
     idempotencyKey: z.string().min(1).max(200).optional(),
     confirm: z.boolean().optional(),
 });
@@ -338,34 +366,43 @@ 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.",
+    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. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers` },
+    http: { method: "POST", path: `${BASE}/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"]),
+        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 --yes --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 schedule offer", [
+        const gate = await consent(ctx, "offers.post", "Post offer", [
             { label: "Listing", value: parsed.listingId },
-            { label: "Window", value: "The rest of the listing" },
+            { 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)}` }]
                 : []),
-        ], { listingId: parsed.listingId, ...body });
+        ], body);
         if (gate)
             return gate;
-        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers`, {
+        return ctx.fetch(`${BASE}/offers`, {
             method: "POST",
             body,
             headers: idempotencyHeaders(ctx, parsed.idempotencyKey),
@@ -374,7 +411,6 @@ export const offerPostCapability = defineCapability({
 });
 export const offerDecisionInput = z.object({
     $positionals: positionals,
-    listingId: z.string().uuid(),
     offerId: z.string().uuid(),
     confirm: z.boolean().optional(),
 });
@@ -382,66 +418,63 @@ 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.",
+    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. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "POST", path: `${BASE}/schedules/{listingId}/offers/{offerId}/accept` },
+    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 --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"]),
+        vnext: help(["offers", "accept"], "Accept one offer on a listing you own.", "ornn offers accept --offer-id <id>", "ornn offers accept --offer-id <id> --yes --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 schedule offer", [
-            { label: "Listing", value: parsed.listingId },
+        const gate = await consent(ctx, "offers.accept", "Accept offer", [
             { label: "Offer", value: parsed.offerId },
             {
                 label: "Consequence",
-                value: "The window is sold; overlapping open offers and conflicting relists from this holding are cancelled.",
+                value: "The buyer's reservation is booked; this listing's overlapping open offers are cancelled.",
             },
-        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        ], { offerId: parsed.offerId });
         if (gate)
             return gate;
-        return ctx.fetch(`${BASE}/schedules/${seg(parsed.listingId)}/offers/${seg(parsed.offerId)}/accept`, { method: "POST", body: {} });
+        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 posted, or one on a listing you own. Requires confirm: true.",
+    description: "Cancel an open offer you made, or one on a listing you own. Requires confirm: true.",
     mutation: "preview-confirm",
-    http: { method: "DELETE", path: `${BASE}/schedules/{listingId}/offers/{offerId}` },
+    http: { method: "DELETE", path: `${BASE}/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"]),
+        vnext: help(["offers", "cancel"], "Cancel one open offer.", "ornn offers cancel --offer-id <id>", "ornn offers cancel --offer-id <id> --yes --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 schedule offer", [
-            { label: "Listing", value: parsed.listingId },
-            { label: "Offer", value: parsed.offerId },
-        ], { listingId: parsed.listingId, offerId: parsed.offerId });
+        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}/schedules/${seg(parsed.listingId)}/offers/${seg(parsed.offerId)}`, {
-            method: "DELETE",
-        });
+        return ctx.fetch(`${BASE}/offers/${seg(parsed.offerId)}`, { method: "DELETE" });
     },
 });
 export const marketCapabilities = [
-    spotBooksCapability,
-    spotBookCapability,
-    spotTradesCapability,
-    spotBidCapability,
-    spotOrdersCapability,
-    spotCancelCapability,
-    schedulesListCapability,
-    scheduleShowCapability,
-    schedulePurchaseCapability,
+    marketBooksCapability,
+    marketBookCapability,
+    marketTradesCapability,
+    marketQuoteCapability,
+    marketBidCapability,
+    marketOrdersCapability,
+    marketCancelCapability,
+    marketFillsCapability,
+    marketEndCapability,
     offersListCapability,
     offerPostCapability,
     offerAcceptCapability,