@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/blueprints.js

@@ -0,0 +1,312 @@
+import { addCompactListReadFlags, appendCompactListReadQuery } from "../compact-list-flags.js";
+import { collectMultiple, isUuid, parseJsonValue, readCsvOption, splitCommaList } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+async function buildBlueprintRequestBody(// skipcq: JS-R1005
+slug, options) {
+    const body = {};
+    if (slug?.trim())
+        body.slug = slug.trim();
+    const filePath = readOption(options.file);
+    if (filePath) {
+        const fs = await import("node:fs/promises");
+        const raw = await fs.readFile(filePath, "utf8");
+        body.envelope = parseJsonValue(raw, "--file");
+    }
+    const fromUrl = readOption(options.fromUrl);
+    if (fromUrl) {
+        const response = await fetch(fromUrl, { headers: { Accept: "application/json" } });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch blueprint from URL (${response.status} ${response.statusText}).`);
+        }
+        const payload = await response.json();
+        body.envelope = payload.blueprint
+            ?? payload.envelope
+            ?? payload;
+    }
+    const inputJson = readOption(options.inputJson);
+    if (inputJson) {
+        body.inputs = parseJsonValue(inputJson, "--input-json");
+    }
+    const tableRefEntries = Array.isArray(options.tableRef) ? options.tableRef : [];
+    if (tableRefEntries.length > 0) {
+        const refs = {};
+        for (const entry of tableRefEntries) {
+            const [key, value] = entry.split("=");
+            if (key && value)
+                refs[key.trim()] = value.trim();
+        }
+        if (Object.keys(refs).length > 0)
+            body.table_refs = refs;
+    }
+    const workflowId = readOption(options.workflowId);
+    if (workflowId)
+        body.workflow_id = workflowId;
+    const workflowName = readOption(options.workflowName);
+    if (workflowName)
+        body.workflow_name = workflowName;
+    if (!body.slug && !body.envelope) {
+        throw new Error("Pass a blueprint slug, --file, or --from-url.");
+    }
+    return body;
+}
+export function registerBlueprintsFamily(program, handleAsyncAction) {
+    program
+        .command("blueprints")
+        .description("Scaffolding bundles: a workflow + tables + columns + prompts as shareable JSON. For workflow-specific operating steps, start with `oxygen recipes list <goal> --json`.")
+        .addCommand(addCompactListReadFlags(new Command("list")
+        .description("List Oxygen blueprints visible in this workspace (seeds + saved).")
+        .argument("[query]", "Search text.")
+        .option("--tag <tag>", "Filter by tag.")
+        .option("--include-seeds", "Include the shipped seed blueprints (default true).")
+        .option("--no-include-seeds", "Exclude shipped seed blueprints.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (query, options, command) => {
+        await handleAsyncAction("blueprints list", options, () => {
+            const params = new URLSearchParams();
+            if (query)
+                params.set("query", query);
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            if (options.includeSeeds === false)
+                params.set("include_seeds", "false");
+            appendCompactListReadQuery(params, command, "blueprints");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/blueprints${qs}`);
+        });
+    }), "blueprints"))
+        .addCommand(new Command("tag")
+        .description("Replace a saved blueprint's workspace tags (whole set; `--tags \"\"` clears). Works on already-saved blueprints — no re-export needed. See `oxygen tags list` for the vocabulary.")
+        .argument("<blueprint>", "Blueprint slug or id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (blueprint, options) => {
+        await handleAsyncAction("blueprints tag", options, () => requestOxygen("/api/cli/blueprints/tags", {
+            method: "POST",
+            body: { blueprint, tags: splitCommaList(options.tags) },
+        }));
+    }))
+        .addCommand(new Command("describe")
+        .description("Describe one blueprint (seed or saved) by slug. The workflow's compiled bundle is left out (its size and sha256 are listed) unless --include-bundle is passed.")
+        .argument("<slug>", "Blueprint slug.")
+        .option("--include-bundle", "Include each workflow's compiled bundle (often 300k+ characters).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints describe", options, () => requestOxygen("/api/cli/blueprints/get", {
+            method: "POST",
+            body: { slug, ...(options.includeBundle ? { include_bundle: true } : {}) },
+        }));
+    }))
+        .addCommand(new Command("export")
+        .description("Build a portable blueprint JSON from an existing workflow.")
+        .requiredOption("--workflow <id>", "Workflow id or slug to export.")
+        .option("--tables <ids>", "Comma-separated list of table ids/slugs to bundle.")
+        .option("--prompts <slugs>", "Comma-separated list of prompt template slugs to bundle.")
+        .option("--blueprint-id <slug>", "Override the output blueprint slug.")
+        .option("--blueprint-name <name>", "Override the output blueprint name.")
+        .option("--blueprint-summary <text>", "Override the output blueprint summary.")
+        .option("--blueprint-tags <tags>", "Comma-separated tags for the exported blueprint.")
+        .option("--out <path>", "Write the exported envelope to this file path.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("blueprints export", options, async () => {
+            const body = { workflow_id: options.workflow };
+            const tables = readOption(options.tables);
+            if (tables)
+                body.table_ids = readCsvOption(tables);
+            const prompts = readOption(options.prompts);
+            if (prompts)
+                body.prompt_slugs = readCsvOption(prompts);
+            const blueprintId = readOption(options.blueprintId);
+            if (blueprintId)
+                body.blueprint_id = blueprintId;
+            const blueprintName = readOption(options.blueprintName);
+            if (blueprintName)
+                body.blueprint_name = blueprintName;
+            const blueprintSummary = readOption(options.blueprintSummary);
+            if (blueprintSummary)
+                body.blueprint_summary = blueprintSummary;
+            const blueprintTags = readOption(options.blueprintTags);
+            if (blueprintTags)
+                body.blueprint_tags = readCsvOption(blueprintTags);
+            const result = await requestOxygen("/api/cli/blueprints/export", {
+                method: "POST",
+                body,
+            });
+            const outPath = readOption(options.out);
+            if (outPath) {
+                const fs = await import("node:fs/promises");
+                const blueprint = result.blueprint;
+                await fs.writeFile(outPath, JSON.stringify(blueprint, null, 2), "utf8");
+            }
+            return result;
+        });
+    }))
+        .addCommand(new Command("preflight")
+        .description("Preflight a blueprint (slug, local file, or shared URL) against this workspace. Price-aware seeds return a current runtime descriptor upper bound, live/scheduled cap scope and remediation, a zero-spend contract, and an exact apply command.")
+        .argument("[slug]", "Blueprint slug (for stored or seed blueprints).")
+        .option("--file <path>", "Read a blueprint envelope from a local JSON file.")
+        .option("--from-url <url>", "Fetch a shared blueprint envelope from a public Oxygen share URL.")
+        .option("--input-json <json>", "Seed blueprint input (parameters) as JSON.")
+        .option("--table-ref <ref=id...>", "Reuse an existing table for a blueprint ref (repeatable).", collectMultiple, [])
+        .option("--workflow-id <id>", "Reapply to an existing non-default workflow by database UUID or manifest id/slug; preflight.next preserves the exact selector you supplied, including a database UUID. The shipped LinkedIn monitor reuses its active tables and apply publishes a new disabled revision. An unmatched value previews a separate workflow.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints preflight", options, async () => {
+            const body = await buildBlueprintRequestBody(slug, options);
+            return requestOxygen("/api/cli/blueprints/preflight", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("apply")
+        .description("Apply a blueprint: 0 credits and no provider calls or external writes, but creates workspace tables, columns, prompts, and a disabled workflow. Reapplying the shipped LinkedIn monitor reuses its active installed tables. It does not enable or run the workflow.")
+        .argument("[slug]", "Blueprint slug (for stored or seed blueprints).")
+        .option("--file <path>", "Read a blueprint envelope from a local JSON file.")
+        .option("--from-url <url>", "Fetch a shared blueprint envelope from a public Oxygen share URL.")
+        .option("--input-json <json>", "Seed blueprint input (parameters) as JSON.")
+        .option("--table-ref <ref=id...>", "Reuse an existing table for a blueprint ref (repeatable).", collectMultiple, [])
+        .option("--workflow-id <id>", "Target an existing workflow by database UUID or manifest id/slug. The shipped LinkedIn monitor reuses its active tables and publishes a new disabled revision; an unmatched value creates a separate workflow.")
+        .option("--workflow-name <name>", "Override the resulting workflow name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints apply", options, async () => {
+            const body = await buildBlueprintRequestBody(slug, options);
+            return requestOxygen("/api/cli/blueprints/apply", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("save")
+        .description("Persist a blueprint envelope into this workspace's gallery.")
+        .option("--file <path>", "Read a blueprint envelope from a local JSON file.")
+        .option("--slug <slug>", "Override the stored blueprint slug.")
+        .option("--name <name>", "Override the stored blueprint name.")
+        .option("--summary <text>", "Override the stored blueprint summary.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("blueprints save", options, async () => {
+            const filePath = readOption(options.file);
+            if (!filePath)
+                throw new Error("--file is required for blueprints save");
+            const fs = await import("node:fs/promises");
+            const raw = await fs.readFile(filePath, "utf8");
+            const envelope = parseJsonValue(raw, "--file");
+            const body = { envelope };
+            const slug = readOption(options.slug);
+            if (slug)
+                body.slug = slug;
+            const name = readOption(options.name);
+            if (name)
+                body.name = name;
+            const summary = readOption(options.summary);
+            if (summary)
+                body.summary = summary;
+            return requestOxygen("/api/cli/blueprints/save", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a saved blueprint (seed blueprints cannot be archived).")
+        .argument("<id_or_slug>", "Blueprint UUID or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction("blueprints archive", options, () => requestOxygen("/api/cli/blueprints/archive", {
+            method: "POST",
+            body: isUuid(idOrSlug)
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
+    }))
+        .addCommand(new Command("share")
+        .description("Create a public share URL for a saved blueprint (oxygen-agent.com/b/<code>).")
+        .argument("<slug>", "Blueprint slug or id to share.")
+        .option("--expires-in-days <days>", "Optional expiry (default: no expiry).")
+        .option("--disabled", "Create the share in disabled state.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints share", options, () => {
+            const body = { slug };
+            const expiresInDays = readOption(options.expiresInDays);
+            if (expiresInDays)
+                body.expires_in_days = Number(expiresInDays);
+            if (options.disabled)
+                body.enabled = false;
+            return requestOxygen("/api/cli/blueprints/share", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("shares")
+        .description("List existing share URLs for this workspace.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("blueprints shares", options, () => requestOxygen("/api/cli/blueprints/share"));
+    }))
+        .addCommand(new Command("unshare")
+        .description("Revoke a public share URL by short code.")
+        .argument("<code>", "Share short code (the slug after /b/ in the URL).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (code, options) => {
+        await handleAsyncAction("blueprints unshare", options, () => requestOxygen("/api/cli/blueprints/share/revoke", {
+            method: "POST",
+            body: { short_code: code },
+        }));
+    }))
+        .addCommand(new Command("publish")
+        .description("List a blueprint on the public Oxygen marketplace. Auto-creates a share URL if none exists.")
+        .argument("<slug>", "Blueprint slug to publish.")
+        .option("--category <name>", "Optional free-text category (e.g. outbound, enrichment).")
+        .option("--kind <kind>", "Listing kind: community (default) or official (Oxygen-curated; gated).")
+        .option("--approved", "Acknowledge the publish-safety warnings (required if the preview is not clean).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints publish", options, () => {
+            const body = { slug };
+            const category = readOption(options.category);
+            if (category)
+                body.category = category;
+            const kind = readOption(options.kind);
+            if (kind)
+                body.kind = kind;
+            if (options.approved)
+                body.approved = true;
+            return requestOxygen("/api/cli/blueprints/publish", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("unpublish")
+        .description("Remove a blueprint from the public marketplace. The share URL stays valid for direct visitors.")
+        .argument("<slug>", "Blueprint slug to unlist.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("blueprints unpublish", options, () => requestOxygen("/api/cli/blueprints/unpublish", {
+            method: "POST",
+            body: { slug },
+        }));
+    }))
+        .addCommand(new Command("marketplace")
+        .description("Browse the public Oxygen blueprint marketplace.")
+        .option("--category <name>", "Filter by listing category.")
+        .option("--kind <kind>", "Filter by listing kind: community or official.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("blueprints marketplace", options, () => {
+            const params = new URLSearchParams();
+            const category = readOption(options.category);
+            if (category)
+                params.set("category", category);
+            const kind = readOption(options.kind);
+            if (kind)
+                params.set("kind", kind);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/blueprints/marketplace${qs}`, { requireAuth: false });
+        });
+    }))
+        .addHelpText("after", [
+        "",
+        "Safety:",
+        "  list, describe, and preflight use 0 credits, make no provider calls, and do not change workspace state.",
+        "  Price-aware preflights fetch runtime descriptor pricing, label upper bounds versus exact-shape dry runs,",
+        "  and return the exact apply command that preserves the validated inputs.",
+        "  export has the same workspace safety; --out only writes the named local file.",
+        "  apply also uses 0 credits and makes no provider calls or external writes, but it creates workspace",
+        "  tables, prompts, and a disabled workflow. Its response reports future per-run credit ceilings.",
+        "  save, archive, tag, share, publish, and their inverse commands change workspace or publication state.",
+        "",
+    ].join("\n"));
+}

package/dist/commands/budget.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerBudgetFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/budget.js

@@ -0,0 +1,55 @@
+import { readPositiveNumber } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { formatPublicBudgetScopes } from "@oxygen/shared/budget-scopes";
+import { Command } from "commander";
+export function registerBudgetFamily(program, handleAsyncAction) {
+    program
+        .command("budget")
+        .description("Standing credit caps (org/table daily/monthly hard-blocks) beyond per-run max_credits.")
+        .addCommand(new Command("list")
+        .description("Read-only, 0 credits. List standing caps with each policy's current spend and remaining credits, plus plan defaults: the daily spend guard and per-run ceilings of one Agent run, trigger delivery or auto-run batch. Daily/monthly windows start at 00:00 UTC; spend counts reservations minus releases, including open holds. Scoped caps currently measure workspace-wide spend. Every spend default: `oxygen limits show`.")
+        .option("--scope <scope>", `Filter by scope: ${formatPublicBudgetScopes()}.`)
+        .option("--status <status>", "Filter by status. Defaults to all.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget list", options, () => {
+            const params = new URLSearchParams();
+            if (readOption(options.scope))
+                params.set("scope", readOption(options.scope));
+            if (readOption(options.status))
+                params.set("status", readOption(options.status));
+            const suffix = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/budget${suffix}`);
+        });
+    }))
+        .addCommand(new Command("set")
+        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window). Daily/monthly windows start at 00:00 UTC and count reservations minus releases; inspect current use with `oxygen budget list`.")
+        .requiredOption("--scope <scope>", formatPublicBudgetScopes())
+        .requiredOption("--window <window>", "per_run, daily, or monthly.")
+        .requiredOption("--max-credits <credits>", "Cap in Oxygen credits.")
+        .option("--scope-id <id>", "Table id/slug for --scope table (or other scope id). Omit for a scope-wide cap.")
+        .option("--action <action>", "warn or hard_block. Defaults to hard_block.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget set", options, () => requestOxygen("/api/cli/budget", {
+            method: "POST",
+            body: {
+                scope: readOption(options.scope),
+                window: readOption(options.window),
+                max_credits: readPositiveNumber(options.maxCredits),
+                ...(readOption(options.scopeId) ? { scope_id: readOption(options.scopeId) } : {}),
+                ...(readOption(options.action) ? { action: readOption(options.action) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a standing budget policy by id.")
+        .requiredOption("--id <id>", "Budget policy id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget delete", options, () => requestOxygen(`/api/cli/budget?id=${encodeURIComponent(readOption(options.id))}`, {
+            method: "DELETE",
+        }));
+    }));
+}

package/dist/commands/callables.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerCallablesFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/callables.js

@@ -0,0 +1,111 @@
+import { parseJsonObject, readPositiveInt } from "../cli-values.js";
+import { parseJsonArray, readPositiveNumber } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+export function registerCallablesFamily(program, handleAsyncAction) {
+    program
+        .command("callables")
+        .description("Publish and bind typed callable tables (reusable row-in/row-out table runs).")
+        .addCommand(new Command("publish")
+        .description("Publish an existing table as a versioned callable function.")
+        .argument("<table>", "Backing table id or slug.")
+        .requiredOption("--inputs-json <json>", "JSON array of inputs: [{column,key?,required?,description?}].")
+        .requiredOption("--actions-json <json>", "JSON array of executable backing-table column keys or ids.")
+        .requiredOption("--outputs-json <json>", "JSON array of outputs: [{column,key?,required?,description?}].")
+        .requiredOption("--max-credits-per-item <n>", "Default hard credit ceiling for one enrolled caller row.")
+        .option("--max-items <n>", "Default maximum source rows per invocation. Defaults to 100.")
+        .option("--slug <slug>", "Stable callable slug.")
+        .option("--name <name>", "Callable display name.")
+        .option("--description <text>", "What the callable does and when to use it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("callables publish", options, () => requestOxygen("/api/cli/callables", {
+            method: "POST",
+            body: {
+                table,
+                inputs: parseJsonArray(options.inputsJson),
+                action_columns: parseJsonArray(options.actionsJson),
+                outputs: parseJsonArray(options.outputsJson),
+                default_max_credits_per_item: readPositiveNumber(options.maxCreditsPerItem),
+                ...(readPositiveInt(options.maxItems) !== undefined
+                    ? { default_max_items: readPositiveInt(options.maxItems) }
+                    : {}),
+                ...(readOption(options.slug) ? { slug: readOption(options.slug) } : {}),
+                ...(readOption(options.name) ? { display_name: readOption(options.name) } : {}),
+                ...(readOption(options.description) ? { description: readOption(options.description) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("list")
+        .description("List published callable tables and their current credit posture.")
+        .option("--include-disabled", "Include disabled definitions.")
+        .option("--limit <n>", "Maximum definitions to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("callables list", options, () => {
+            const params = new URLSearchParams();
+            if (options.includeDisabled)
+                params.set("include_disabled", "true");
+            if (readPositiveInt(options.limit) !== undefined)
+                params.set("limit", String(readPositiveInt(options.limit)));
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/callables${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("describe")
+        .description("Describe a callable's typed input/output contract and pinned backing columns.")
+        .argument("<callable>", "Callable id, slug, backing table id, or backing table slug.")
+        .option("--include-disabled", "Allow a disabled callable.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (callable, options) => {
+        await handleAsyncAction("callables describe", options, () => {
+            const params = new URLSearchParams({ callable });
+            if (options.includeDisabled)
+                params.set("include_disabled", "true");
+            return requestOxygen(`/api/cli/callables?${params.toString()}`);
+        });
+    }))
+        .addCommand(new Command("bind")
+        .description("Add a callable-function column to a source table with explicit input and callback mappings.")
+        .argument("<table>", "Caller/source table id or slug.")
+        .argument("<callable>", "Callable id or slug.")
+        .requiredOption("--inputs-json <json>", "JSON object mapping callable input keys to source column keys.")
+        .requiredOption("--outputs-json <json>", "JSON object mapping callable output keys to callback target column keys.")
+        .option("--max-credits-per-item <n>", "Override the callable's default per-enrolled-row cap.")
+        .option("--overwrite-policy <policy>", "empty_only (default) or overwrite.")
+        .option("--key <key>", "Binding column key.")
+        .option("--label <label>", "Binding column label.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, callable, options) => {
+        await handleAsyncAction("callables bind", options, () => requestOxygen("/api/cli/callables/bind", {
+            method: "POST",
+            body: {
+                table,
+                callable,
+                input_mapping: parseJsonObject(options.inputsJson),
+                output_mapping: parseJsonObject(options.outputsJson),
+                ...(readPositiveNumber(options.maxCreditsPerItem) !== undefined
+                    ? { max_credits_per_item: readPositiveNumber(options.maxCreditsPerItem) }
+                    : {}),
+                ...(readOption(options.overwritePolicy) ? { overwrite_policy: readOption(options.overwritePolicy) } : {}),
+                ...(readOption(options.key) ? { key: readOption(options.key) } : {}),
+                ...(readOption(options.label) ? { label: readOption(options.label) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("enable")
+        .description("Enable a callable table.")
+        .argument("<callable>", "Callable id, slug, or backing table.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (callable, options) => {
+        await handleAsyncAction("callables enable", options, () => requestOxygen("/api/cli/callables/status", { method: "POST", body: { callable, status: "active" } }));
+    }))
+        .addCommand(new Command("disable")
+        .description("Disable new invocations without changing existing tables or in-flight runs.")
+        .argument("<callable>", "Callable id, slug, or backing table.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (callable, options) => {
+        await handleAsyncAction("callables disable", options, () => requestOxygen("/api/cli/callables/status", { method: "POST", body: { callable, status: "disabled" } }));
+    }));
+}

package/dist/commands/capabilities.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerCapabilitiesFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/capabilities.js

@@ -0,0 +1,44 @@
+import { OXYGEN_CAPABILITY_ROUTES, getCapabilityRouteMatch, serializeCapabilityRoute } from "@oxygen/shared/capability-discovery";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { inferUserCapabilityRoute } from "@oxygen/shared/user-capability-routing";
+import { capabilityDiscoveryRecovery } from "@oxygen/shared/user-capability-routing";
+import { Command } from "commander";
+export function registerCapabilitiesFamily(program, handleAsyncAction) {
+    program
+        .command("capabilities")
+        .description("Route an outcome to its owning OXYGEN layer and hosted primitive.")
+        .addCommand(new Command("search")
+        .description("Find the owning capability, boundary, gateways, and next hydration step.")
+        .argument("<query...>", "Natural-language GTM outcome.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (queryParts, options) => {
+        await handleAsyncAction("capabilities search", options, async () => {
+            const query = queryParts.join(" ");
+            const route = inferUserCapabilityRoute(query);
+            return {
+                query,
+                route: serializeCapabilityRoute(route),
+                hint: route
+                    ? "Hydrate one exact CLI command with `oxygen commands get <exact-command> --json`, or one MCP tool with `oxygen_capabilities_schema`."
+                    : capabilityDiscoveryRecovery(query, "cli"),
+                alternate_search_hint: `If this route does not fit the outcome, run \`oxygen skills search ${JSON.stringify(query)} --json\` for a narrower operational play.`,
+            };
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Hydrate one exact capability card by id.")
+        .argument("<capability-id>", "Capability id returned by capabilities search.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (capabilityId, options) => {
+        await handleAsyncAction("capabilities get", options, async () => {
+            const route = getCapabilityRouteMatch(capabilityId);
+            if (!route) {
+                throw new OxygenError("capability_not_found", `Unknown OXYGEN capability: ${capabilityId}`, {
+                    details: { available_ids: OXYGEN_CAPABILITY_ROUTES.map((card) => card.id) },
+                    exitCode: 2,
+                });
+            }
+            return serializeCapabilityRoute(route);
+        });
+    }));
+}

package/dist/commands/cells.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerCellsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/cells.js

@@ -0,0 +1,94 @@
+import { readPositiveInt } from "../cli-values.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+export function registerCellsFamily(program, handleAsyncAction) {
+    program
+        .command("cells")
+        .description("Workspace cell provenance commands.")
+        .addCommand(new Command("inspect")
+        .description("Inspect one cell's value, row context, and recent history.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .argument("<column>", "Column id or key.")
+        .option("--history-limit <n>", "Maximum recent cell changes to include. Defaults to 10; cap 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, column, options) => {
+        await handleAsyncAction("cells inspect", options, () => {
+            const historyLimit = readPositiveInt(options.historyLimit);
+            return requestOxygen("/api/cli/tables/cells/inspect", {
+                method: "POST",
+                body: {
+                    table,
+                    row_id: rowId,
+                    column,
+                    ...(historyLimit ? { history_limit: historyLimit } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("resolve")
+        .description("Record what a human verified about a cell whose external write was dispatched but never confirmed. It records the outcome only; it never calls the provider again. Use not_applied when the write provably did not land (the cell becomes rerunnable) or applied when it did.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .argument("<column>", "Column id or key.")
+        .requiredOption("--outcome <outcome>", "applied (the external write landed) or not_applied (it never did).")
+        .option("--note <text>", "Short note about how the destination was verified.")
+        .option("--value <json>", "JSON value read off the destination, recorded into the cell. Only valid with --outcome applied.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, column, options) => {
+        const outcome = readOption(options.outcome);
+        if (outcome !== "applied" && outcome !== "not_applied") {
+            throw new OxygenError("invalid_effect_resolution_outcome", "--outcome must be applied or not_applied.", { exitCode: 1 });
+        }
+        const rawValue = readOption(options.value);
+        if (rawValue !== null && outcome !== "applied") {
+            throw new OxygenError("invalid_effect_resolution_value", "--value is only valid with --outcome applied; a not-applied effect wrote nothing.", { exitCode: 1 });
+        }
+        // Parsed locally so a malformed --value fails with a clear message
+        // instead of being posted as a JSON string the server would then
+        // faithfully write into the cell.
+        let value;
+        if (rawValue !== null) {
+            try {
+                value = JSON.parse(rawValue);
+            }
+            catch {
+                throw new OxygenError("invalid_json", `--value must be valid JSON. Quote a string as '"text"'.`, { exitCode: 1 });
+            }
+        }
+        await handleAsyncAction("cells resolve", options, () => requestOxygen("/api/cli/tables/cells/resolve", {
+            method: "POST",
+            body: {
+                table,
+                row_id: rowId,
+                column,
+                outcome,
+                ...(readOption(options.note) ? { note: readOption(options.note) } : {}),
+                ...(rawValue !== null ? { value } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("history")
+        .description("Show cell change history.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .argument("<column>", "Column id or key.")
+        .option("--limit <n>", "Maximum changes to return. Defaults to 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, column, options) => {
+        await handleAsyncAction("cells history", options, () => {
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen("/api/cli/tables/cells/history", {
+                method: "POST",
+                body: {
+                    table,
+                    row_id: rowId,
+                    column,
+                    ...(limit ? { limit } : {}),
+                },
+            });
+        });
+    }));
+}

package/dist/commands/columns.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerColumnsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;