@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/recipes.d.ts

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

package/dist/commands/recipes.js

@@ -0,0 +1,120 @@
+import { collectMultiple, parseJsonValue } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+export function registerRecipesFamily(program, handleAsyncAction) {
+    program
+        .command("recipes")
+        // Customers meet these as "plays" (the web app's Plays page and every
+        // copied play prompt), so that is the noun their agent types first. A
+        // production audit on 2026-10-04 saw all 33 blind runs open with
+        // `oxygen plays` and lose a call to "unknown command".
+        .alias("plays")
+        .description("GTM plays: proven motions with prerequisites, credit posture, and approval gates spelled out, to borrow from and adapt. Alias: `plays`. To design a motion for your company, use the oxygen-gtm-consultant skill: oxygen skills get oxygen-gtm-consultant --json.")
+        .addCommand(new Command("list")
+        .description("Find a GTM play for a goal: recipes ranked by relevance to your words; --view summary for a compact index. Filter by business-case category, journey stage, or audience.")
+        .argument("[query]", "Your goal in plain words, e.g. \"more pipeline from linkedin\" (ranked against title, trigger phrases, tags, and business case).")
+        .option("--category <category>", "Business-case category (e.g. start-here, pipeline-from-zero).")
+        .option("--stage <stage>", "Journey stage: day-1, day-7, day-30, or ongoing.")
+        .option("--audience <audience>", "founder, gtm-operator, or agency-operator.")
+        .option("--view <view>", "summary (compact index to choose a play from) or full (default: every field).")
+        .option("--limit <n>", "Return at most n recipes (1-50), after ranking.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (query, options) => {
+        await handleAsyncAction("recipes list", options, () => {
+            const params = new URLSearchParams();
+            if (query)
+                params.set("query", query);
+            const category = readOption(options.category);
+            if (category)
+                params.set("category", category);
+            const stage = readOption(options.stage);
+            if (stage)
+                params.set("stage", stage);
+            const audience = readOption(options.audience);
+            if (audience)
+                params.set("audience", audience);
+            const view = readOption(options.view);
+            if (view)
+                params.set("view", view);
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/recipes${qs}`);
+        });
+    }))
+        .addCommand(new Command("show")
+        // `get` is what a naive agent reaches for first, because `workflows`,
+        // `knowledge page` and `table-ingestions` all use it and only `recipes`
+        // uses `show` (while `sequences` is the mirror image and rejects
+        // `show`). A blind user eval on 2026-09-13 burned two steps on
+        // `recipes get inbound-led-outbound` -> "unknown command 'get'".
+        // The catalog is the front door of the whole kit; it should not punish
+        // the guess the rest of the CLI teaches.
+        .alias("get")
+        .description("Show one recipe: its kit, the install status of each stage here, prerequisites, credits, approval gates, and the playbook body. Alias: `get`.")
+        .argument("<slug>", "Recipe slug, e.g. outbound-pilot-50.")
+        .option("--section <heading>", "Read one recipe heading instead of the whole playbook.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("recipes show", options, () => requestOxygen("/api/cli/recipes/get", {
+            method: "POST",
+            body: { slug, ...(readOption(options.section) ? { section: readOption(options.section) } : {}) },
+        }));
+    }))
+        .addCommand(new Command("install")
+        .description("Install a recipe into the workspace wiki as a playbook page (revisioned, retrieval-grounded, with per-version provenance).")
+        .argument("<slug>", "Recipe slug, e.g. outbound-pilot-50.")
+        .option("--slug <wiki_slug>", "Override the target wiki slug (default playbook-<recipe-slug>).")
+        .option("--draft", "Install as a draft page (drafts never ground AI actions until activated).")
+        .option("--force", "Overwrite a customized installed copy (edits survive as a page revision).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("recipes install", options, () => {
+            const body = { slug };
+            const wikiSlug = readOption(options.slug);
+            if (wikiSlug)
+                body.wiki_slug = wikiSlug;
+            if (options.draft)
+                body.draft = true;
+            if (options.force)
+                body.force = true;
+            return requestOxygen("/api/cli/recipes/install", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("apply")
+        .description("Install a recipe's kit: every Blueprint stage in order under ONE approval — 0 credits, no provider calls, no external writes, every installed Workflow disabled until you arm it with its own credit cap. A stage whose Workflow is already active is left untouched. `--dry-run` preflights every stage into one combined forecast and writes nothing.")
+        .argument("<slug>", "Recipe slug, e.g. inbound-led-outbound.")
+        .option("--input-json <json>", "Stage inputs as a JSON object keyed by blueprint id, e.g. '{\"linkedin-profile-engager-monitor\":{\"profiles\":[\"https://www.linkedin.com/in/example\"],\"max_credits\":2200}}'.")
+        .option("--table-ref <blueprint.ref=table...>", "Bind a stage's table ref to an existing table id or slug, e.g. --table-ref linkedin-engager-tier-router.engaged_people=linkedin-engaged-people (repeatable).", collectMultiple, [])
+        .option("--dry-run", "Preflight every stage and print the combined forecast; installs nothing.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        const command = options.dryRun ? "recipes preflight" : "recipes apply";
+        await handleAsyncAction(command, options, () => {
+            const body = { slug };
+            const inputJson = readOption(options.inputJson);
+            if (inputJson)
+                body.inputs = parseJsonValue(inputJson, "--input-json");
+            const tableRefs = {};
+            for (const entry of options.tableRef ?? []) {
+                const eq = entry.indexOf("=");
+                const dot = entry.indexOf(".");
+                if (eq <= 0 || dot <= 0 || dot > eq) {
+                    throw new Error(`--table-ref expects <blueprint>.<ref>=<table id or slug>, got "${entry}"`);
+                }
+                const blueprint = entry.slice(0, dot);
+                const ref = entry.slice(dot + 1, eq);
+                const table = entry.slice(eq + 1);
+                tableRefs[blueprint] = { ...(tableRefs[blueprint] ?? {}), [ref]: table };
+            }
+            if (Object.keys(tableRefs).length > 0)
+                body.table_refs = tableRefs;
+            return requestOxygen(options.dryRun ? "/api/cli/recipes/preflight" : "/api/cli/recipes/apply", {
+                method: "POST",
+                body,
+            });
+        });
+    }));
+}

package/dist/commands/reviews.d.ts

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

package/dist/commands/reviews.js

@@ -0,0 +1,75 @@
+import { parseJsonValue } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+export function registerReviewsFamily(program, handleAsyncAction) {
+    // The deprecated `templates` alias tree was removed at its registry sunset
+    // (v1.290.0) — `oxygen prompts` has been canonical since v1.80.0.
+    program
+        .command("reviews")
+        .description("Human-in-the-loop reviews for AI-generated outreach messages.")
+        .addCommand(new Command("list")
+        .description("List message reviews.")
+        .option("--status <status>", "Filter by pending, accepted, rejected, or superseded.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--limit <n>", "Max rows to return (default 50, max 200).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews list", options, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            const table = readOption(options.table);
+            const limit = readOption(options.limit);
+            if (status)
+                params.set("status", status);
+            if (table)
+                params.set("table_id", table);
+            if (limit)
+                params.set("limit", limit);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews${qs}`);
+        });
+    }))
+        .addCommand(new Command("next")
+        .description("Read the oldest pending review.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews next", options, () => {
+            const params = new URLSearchParams();
+            const table = readOption(options.table);
+            if (table)
+                params.set("table_id", table);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews/next${qs}`);
+        });
+    }))
+        .addCommand(new Command("accept")
+        .description("Accept a pending message review.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews accept", options, () => requestOxygen("/api/cli/message-reviews/decide", {
+            method: "POST",
+            body: { id: reviewId, decision: "accept" },
+        }));
+    }))
+        .addCommand(new Command("reject")
+        .description("Reject a pending message review with optional highlights and auto-rerun.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--highlights-json <json>", "JSON array of {start,end,comment} highlight objects.")
+        .option("--auto-rerun", "Trigger a single-row rerun of the column after rejecting.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews reject", options, () => {
+            const body = { id: reviewId, decision: "reject" };
+            const highlightsJson = readOption(options.highlightsJson);
+            if (highlightsJson) {
+                body.highlights = parseJsonValue(highlightsJson, "--highlights-json");
+            }
+            if (options.autoRerun)
+                body.auto_rerun = true;
+            return requestOxygen("/api/cli/message-reviews/decide", { method: "POST", body });
+        });
+    }));
+}

package/dist/commands/rows.d.ts

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

package/dist/commands/rows.js

@@ -0,0 +1,27 @@
+import { readPositiveInt } from "../cli-values.js";
+import { requestOxygen } from "../http-client.js";
+import { Command } from "commander";
+export function registerRowsFamily(program, handleAsyncAction) {
+    program
+        .command("rows")
+        .description("Workspace row provenance commands.")
+        .addCommand(new Command("history")
+        .description("Show row change history.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .option("--limit <n>", "Maximum changes to return. Defaults to 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, options) => {
+        await handleAsyncAction("rows history", options, () => {
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen("/api/cli/tables/rows/history", {
+                method: "POST",
+                body: {
+                    table,
+                    row_id: rowId,
+                    ...(limit ? { limit } : {}),
+                },
+            });
+        });
+    }));
+}

package/dist/commands/runs.d.ts

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

package/dist/commands/runs.js

@@ -0,0 +1,37 @@
+import { readPositiveInt } from "../cli-values.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+export function registerRunsFamily(program, handleAsyncAction) {
+    program
+        .command("runs")
+        .description("Workspace run ledger and provenance. `runs list --table <table>` is one table's full run history: imports, row writes and column runs.")
+        .addCommand(new Command("list")
+        .description("List workspace runs, newest first; --table gives one table's full run history.")
+        .option("--table <table>", "One table's full run history (id, slug or table URL): imports, row writes, column runs and Function calls.")
+        .option("--limit <n>", "Maximum runs to return. Defaults to 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("runs list", options, () => {
+            const limit = readPositiveInt(options.limit);
+            const params = new URLSearchParams();
+            const table = readOption(options.table);
+            if (table)
+                params.set("table", table);
+            if (limit)
+                params.set("limit", String(limit));
+            const query = params.toString();
+            return requestOxygen(`/api/cli/runs${query ? `?${query}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one run with events.")
+        .argument("<run_id>", "Run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("runs get", options, () => requestOxygen("/api/cli/runs/get", {
+            method: "POST",
+            body: { run_id: runId },
+        }));
+    }));
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,182 @@
+import { parseJsonObject, readPositiveInt } from "../cli-values.js";
+import { TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS, TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS, buildGetSurfaceRunWaitConfig, isTerminalTableIngestionStatus, readCsvOption, readFileIfPresent, readPositiveNumber, readSearchPlanJson } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { waitForCliRun } from "../run-wait.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+// Company search has moved to the dedicated companies-search surface. The CLI rejects
+// `oxygen search plan --kind company_search` client-side so a stale agent gets a typed,
+// self-correcting error instead of an opaque server 400. Message mirrors
+// COMPANY_SEARCH_MOVED_MESSAGE in @oxygen/tools (CLI does not import that package).
+const COMPANY_SEARCH_MOVED_MESSAGE = "Company search is handled by the dedicated companies-search surface. Use: oxygen companies search plan --prompt \"<goal>\" (CLI) or oxygen_companies_search_plan (MCP).";
+function assertNotCompanySearchKind(kind) {
+    if (readOption(kind) === "company_search") {
+        throw new OxygenError("use_companies_search", COMPANY_SEARCH_MOVED_MESSAGE, {
+            details: {
+                equivalent_cli: "oxygen companies search plan --prompt <goal>",
+                equivalent_mcp: "oxygen_companies_search_plan",
+            },
+            exitCode: 1,
+        });
+    }
+}
+// People search has moved to the dedicated people-search surface. The CLI rejects
+// `oxygen search plan --kind people_search` client-side so a stale agent gets a typed,
+// self-correcting error instead of an opaque server 400. Message mirrors
+// PEOPLE_SEARCH_MOVED_MESSAGE in @oxygen/tools (CLI does not import that package).
+const PEOPLE_SEARCH_MOVED_MESSAGE = "People search is handled by the dedicated people-search surface. Use: oxygen people search plan --prompt \"<goal>\" (CLI) or oxygen_people_search_plan (MCP).";
+function assertNotPeopleSearchKind(kind) {
+    if (readOption(kind) === "people_search") {
+        throw new OxygenError("use_people_search", PEOPLE_SEARCH_MOVED_MESSAGE, {
+            details: {
+                equivalent_cli: "oxygen people search plan --prompt <goal>",
+                equivalent_mcp: "oxygen_people_search_plan",
+            },
+            exitCode: 1,
+        });
+    }
+}
+function waitForSearchRun(runId, options) {
+    return waitForCliRun(buildGetSurfaceRunWaitConfig({
+        runId,
+        endpoint: "/api/cli/search/runs",
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        // Search intentionally reuses the table-ingestion defaults and terminal
+        // predicate; the status set is identical (a naming-drift smell, not a bug).
+        defaultTimeoutSeconds: TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS,
+        isTerminal: isTerminalTableIngestionStatus,
+        runKey: "searchRun",
+        runIdKey: "searchRunId",
+        timeoutCode: "search_run_wait_timeout",
+        timeoutMessage: "Timed out waiting for search run to finish.",
+        timeoutDetailIdKey: "search_run_id",
+    }));
+}
+export function registerSearchFamily(program, handleAsyncAction) {
+    program
+        .command("search")
+        .description("Agent-operable people, signal, web, scrape, and local-business search jobs. For company search use 'oxygen companies search'; for hiring-based account discovery use 'oxygen companies search plan --prompt <goal> --source-intent hiring'.")
+        .addCommand(new Command("plan")
+        .description("Plan an Oxygen search or scrape route before running provider jobs.")
+        .requiredOption("--goal <file|text>", "Search/scrape goal text, or a local file path containing the goal.")
+        .option("--kind <kind>", "Route kind: signal_search, web_search, web_scrape, local_business_search, or source_specific_scrape. For people search use 'oxygen people search plan'; for company search use 'oxygen companies search plan'.")
+        .option("--target-count <n>", "Optional target row count.")
+        .option("--geography <text>", "Optional geography hint.")
+        .option("--known-urls <urls>", "Comma-separated known URLs for scrape routes.")
+        .option("--provider-hints <providers>", "Comma-separated provider hints.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("search plan", options, () => {
+            assertNotCompanySearchKind(options.kind);
+            assertNotPeopleSearchKind(options.kind);
+            return requestOxygen("/api/cli/search/plan", {
+                method: "POST",
+                body: {
+                    goal: readFileIfPresent(options.goal),
+                    ...(readOption(options.kind) ? { kind: readOption(options.kind) } : {}),
+                    ...(readPositiveInt(options.targetCount) ? { target_count: readPositiveInt(options.targetCount) } : {}),
+                    ...(readOption(options.geography) ? { geography: readOption(options.geography) } : {}),
+                    ...(readOption(options.knownUrls) ? { known_urls: readCsvOption(options.knownUrls) } : {}),
+                    ...(readOption(options.providerHints) ? { provider_hints: readCsvOption(options.providerHints) } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("run")
+        .description("Preview or enqueue a durable table-backed search/scrape job from a search plan.")
+        .argument("<table>", "Target table id or slug for live runs.")
+        .requiredOption("--plan <file|json>", "Search plan JSON returned by oxygen search plan.")
+        .option("--route <route_id>", "Route id from the plan. Defaults to recommended_route_id.")
+        .requiredOption("--request-json <json>", "Provider request JSON for the selected route.")
+        .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
+        .option("--max-credits <n>", "Required credit ceiling for live runs.")
+        .option("--max-pages <n>", "Maximum provider pages to fetch. Defaults to the route's page cap.")
+        .option("--rows-path <path>", "Override route rows path.")
+        .option("--row-mapping-json <json>", "Override route row mapping.")
+        .option("--cursor-path <path>", "Override route cursor path.")
+        .option("--cursor-request-key <path>", "Override request key that receives the next cursor.")
+        .option("--upsert-key <key>", "Column key used to upsert instead of inserting.")
+        .option("--connection-id <connection_id>", "Optional provider integration connection id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("search run", options, () => requestOxygen("/api/cli/search/run", {
+            method: "POST",
+            body: {
+                table,
+                // Accepts the `search plan --json` envelope as-is, like the
+                // companies/people/signals runs do: the inner `data` is the plan.
+                plan: readSearchPlanJson(options.plan),
+                request: parseJsonObject(options.requestJson),
+                ...(readOption(options.route) ? { route_id: readOption(options.route) } : {}),
+                ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
+                ...(readPositiveNumber(options.maxCredits) ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+                ...(readPositiveInt(options.maxPages) ? { max_pages: readPositiveInt(options.maxPages) } : {}),
+                ...(readOption(options.rowsPath) ? { rows_path: readOption(options.rowsPath) } : {}),
+                ...(options.rowMappingJson ? { row_mapping: parseJsonObject(options.rowMappingJson) } : {}),
+                ...(readOption(options.cursorPath) ? { cursor_path: readOption(options.cursorPath) } : {}),
+                ...(readOption(options.cursorRequestKey) ? { cursor_request_key: readOption(options.cursorRequestKey) } : {}),
+                ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+                ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("runs")
+        .description("Inspect and control durable search/scrape runs.")
+        .addCommand(new Command("get")
+        .description("Get one durable search/scrape run.")
+        .argument("<run_id>", "Search run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("search runs get", options, () => requestOxygen(`/api/cli/search/runs/${encodeURIComponent(runId)}`));
+    }))
+        .addCommand(new Command("items")
+        .description("List search/scrape run items.")
+        .argument("<run_id>", "Search run UUID.")
+        .option("--status <status>", "Filter by pending, leased, completed, failed, skipped, or canceled.")
+        .option("--limit <n>", "Maximum items to return. Defaults to 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("search runs items", options, () => {
+            const query = new URLSearchParams();
+            if (readOption(options.status))
+                query.set("status", readOption(options.status) ?? "");
+            const limit = readPositiveInt(options.limit);
+            if (limit)
+                query.set("limit", String(limit));
+            const suffix = query.toString() ? `?${query.toString()}` : "";
+            return requestOxygen(`/api/cli/search/runs/${encodeURIComponent(runId)}/items${suffix}`);
+        });
+    }))
+        .addCommand(new Command("wait")
+        .description("Poll a durable search/scrape run until it finishes.")
+        .argument("<run_id>", "Search run UUID.")
+        .option("--timeout-seconds <n>", "Maximum time to wait. Defaults to 600.")
+        .option("--interval-seconds <n>", "Polling interval. Defaults to 5.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("search runs wait", options, () => waitForSearchRun(runId, options));
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation for a queued or running search/scrape run.")
+        .argument("<run_id>", "Search run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("search runs cancel", options, () => requestOxygen(`/api/cli/search/runs/${encodeURIComponent(runId)}/cancel`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("retry-failed")
+        .description("Requeue failed search/scrape run items.")
+        .argument("<run_id>", "Search run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("search runs retry-failed", options, () => requestOxygen(`/api/cli/search/runs/${encodeURIComponent(runId)}/retry-failed`, {
+            method: "POST",
+            body: {},
+        }));
+    })));
+}

package/dist/commands/senders.d.ts

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