@oxygen-agent/cli 1.1003.12 → 1.1010.1

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1003.12
+Version: 1.1010.1

package/dist/column-decision-options.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `columns add` classification flags: `--classify <labels>`, `--yes-no <question>`
+ * and `--score <levels>` author an AI column answered by System One
+ * (`definition.decision`). The server validates the shape; this only turns the
+ * flags into it and refuses combinations that would author something else.
+ */
+export type ColumnDecisionFlagOptions = {
+    classify?: string;
+    yesNo?: string;
+    score?: string;
+    minConfidence?: string;
+    grounding?: string;
+};
+export type ColumnDecisionFlags = {
+    /** The question, when `--yes-no` carried it; `--classify` and `--score` take `--prompt`. */
+    question: string | null;
+    decision: Record<string, unknown>;
+};
+/** Null when no classification flag was passed. */
+export declare function readColumnDecisionFlags(options: ColumnDecisionFlagOptions): ColumnDecisionFlags | null;

package/dist/column-decision-options.js

@@ -0,0 +1,54 @@
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { COLUMN_DECISION_GROUNDINGS, } from "@oxygen/shared/column-decision";
+function readFlag(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function splitList(value) {
+    return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function invalid(message) {
+    return new OxygenError("invalid_request", message, { exitCode: 1 });
+}
+/** Null when no classification flag was passed. */
+export function readColumnDecisionFlags(options) {
+    const classify = readFlag(options.classify);
+    const yesNo = readFlag(options.yesNo);
+    const scoreLevels = readFlag(options.score);
+    const chosen = [classify ? "--classify" : null, yesNo ? "--yes-no" : null, scoreLevels ? "--score" : null]
+        .filter((flag) => flag !== null);
+    const minConfidenceRaw = readFlag(options.minConfidence);
+    const groundingRaw = readFlag(options.grounding);
+    if (chosen.length === 0) {
+        if (minConfidenceRaw || groundingRaw) {
+            throw invalid("--min-confidence and --grounding apply to a classification column: add --classify, --yes-no or --score.");
+        }
+        return null;
+    }
+    if (chosen.length > 1) {
+        throw invalid(`A classification column has one mode: pass one of ${chosen.join(", ")}, not several.`);
+    }
+    const mode = classify ? "labels" : yesNo ? "yes_no" : "score";
+    const decision = { engine: "system_one", mode };
+    if (classify)
+        decision.labels = splitList(classify);
+    if (scoreLevels)
+        decision.levels = splitList(scoreLevels);
+    if (minConfidenceRaw) {
+        const value = Number(minConfidenceRaw);
+        if (!Number.isFinite(value)) {
+            throw invalid(`--min-confidence must be a number from 0 to 1, e.g. 0.8 (got ${minConfidenceRaw}).`);
+        }
+        decision.minConfidence = value;
+    }
+    if (groundingRaw) {
+        const grounding = groundingRaw.toLowerCase();
+        if (!COLUMN_DECISION_GROUNDINGS.includes(grounding)) {
+            throw invalid(`--grounding must be ${COLUMN_DECISION_GROUNDINGS.join(" or ")} (got ${groundingRaw}).`);
+        }
+        decision.grounding = grounding;
+    }
+    return { question: yesNo, decision };
+}

package/dist/command-manifest.js

@@ -26,6 +26,10 @@ const COMMAND_SEARCH_STOP_WORDS = new Set([
 // advertised the most consequential collaboration write as a read.
 const MUTATING_VERBS = new Set([
     "brand-approve", "revoke-invite", "confirm",
+    // Exact leaf: `ugc creators set-target` writes one creator's posting deal.
+    "set-target",
+    // `ugc creators decline` settles an application for good.
+    "decline",
     "accept", "ack", "add", "adopt", "apply", "approve", "archive",
     "assign", "attach",
     // `linkedin intent autoenroll` arms (or revokes) a STANDING grant to contact
@@ -64,7 +68,7 @@ const MUTATING_VERBS = new Set([
     // `support chat` starts or continues a customer-authored Plain Thread. The
     // conversational noun is still a real external write.
     "buy", "call", "cancel", "chat", "chat-action", "claim", "clear",
-    "comment", "configure", "connect", "create", "decide", "delete", "delist", "disable",
+    "comment", "configure", "connect", "create", "decide", "delete", "delete-message", "delist", "disable",
     "disconnect", "dispatch", "done", "draft", "duplicate", "edit", "emit", "enable", "enroll",
     // Exact leaf, not a `field` prefix: `support admin field-set` writes a Plain
     // Thread field, while a future `field-get` would be a read.
@@ -73,7 +77,7 @@ const MUTATING_VERBS = new Set([
     "label-add", "label-remove", "launch", "log", "login", "logout", "mark-all-read", "mark-read", "materialize", "merge",
     "migrate",
     "move", "note", "off", "onboard", "order", "pause", "pin", "priority", "provision",
-    "publish", "purchase", "purge", "push", "react", "reconcile", "record", "recover-pending",
+    "publish", "purchase", "purge", "push", "react", "reactivate", "reconcile", "record", "recover-pending",
     "recover-capacity", "register", "reject", "relink", "remove", "rename", "reorder", "reply", "request",
     "replay", "rerun", "rescan", "resend", "reset", "resolve", "restore", "resume",
     "retry", "retype", "revoke", "rotate", "run", "save", "schedule",
@@ -92,11 +96,19 @@ const MUTATING_VERBS = new Set([
 const MUTATING_COMMANDS = new Set([
     "mailboxes warmup status",
     "mailboxes warmup reconnect",
+    // A noun leaf with its own action (not a group), so the default would
+    // advertise a STANDING per-viewer paid-enrichment toggle as a read. `enrichment`
+    // itself is not a MUTATING_VERBS entry because the other two `enrichment`
+    // leaves in this file (`crm enrichment`, `enrichment` catalogue) are groups
+    // whose own subcommands (list/set/enable/disable/backfill, catalog/entries)
+    // already carry their own correctly-classified verbs.
+    "viewers enrichment",
 ]);
 // `--approved` usually identifies a paid or externally mutating execution
 // mode, but a small number of approved operations are explicitly
 // zero-credit. Keep those exceptions exact so discovery never invents spend.
 const ZERO_CREDIT_APPROVAL_COMMANDS = new Set([
+    "inbox delete-message",
     "tables watcher preview",
     "knowledge repositories connect",
     "knowledge repositories resolve",
@@ -142,6 +154,7 @@ const READ_ONLY_COMMANDS = new Set([
 // invocation still previews, so machine-readable discovery must not imply that
 // calling the command without its confirmation flag writes anything.
 const PREVIEW_BY_DEFAULT_COMMANDS = new Set([
+    "inbox delete-message",
     "tables watcher preview",
     "ugc creators invite",
     "ugc creators send-invite",

package/dist/functions-commands.js

@@ -3,10 +3,10 @@ import { parseJsonObject } from "./cli-values.js";
 import { requestOxygen } from "./http-client.js";
 export function registerFunctionsCommands(program, handle) {
     const functions = program.command("functions")
-        .description("Browse OXYGEN's ready-made Functions (work email, mobile phone, company funding stage, ...), favourite them, bind them to a table, or create, edit and publish your own Functions backed by ordinary Tables.")
-        .addHelpText("after", "\nOXYGEN-managed Functions are pre-built and priced: `functions list --managed` shows each one with its per-row credit estimate before you attach it. Attaching (`functions bind`) is free; only `columns run` spends, after a dry run. A managed Function is read-only; `functions duplicate <function>` gives you an editable copy.\nDraft edits are isolated. Publishing updates future invocations of every caller; queued, in-flight and past runs retain their captured version. Existing caller caps never increase automatically.\nFlow: draft → describe → publish → bind → columns run --dry-run → approved run → runs.\nA bound Function executes on its own published execution table and writes named outputs back to the calling table. The call stays visible from the caller: `table-runs list --table <caller> --status all` lists the run, and the binding column's cell holds the outcome (status, outputs, credits, invocation and run ids). Address a Function by id, slug, or the display name shown by `functions list`.\nWorked example with commands: `oxygen skills install --skill oxygen-gtm --project`, then read its recipes/callable-tables.md.\n");
-    functions.command("list").description("List the Function library: OXYGEN-managed Functions with their per-row credit estimate, plus your workspace's own drafts and published Functions (up to 500).")
-        .option("--managed", "Only OXYGEN-managed Functions (pre-built, priced, read-only; duplicate to customize).")
+        .description("Create, publish and reuse your workspace's Functions backed by ordinary Tables.")
+        .addHelpText("after", "\n`functions list` shows your workspace's drafts and published Functions with per-row credit estimates. Attaching (`functions bind`) is free; only `columns run` spends, after a dry run. Use `functions duplicate <function>` to start an editable copy.\nDraft edits are isolated. Publishing updates future invocations of every caller; queued, in-flight and past runs retain their captured version. Existing caller caps never increase automatically.\nFlow: draft → describe → publish → bind → columns run --dry-run → approved run → runs.\nA bound Function executes on its own published execution table and writes named outputs back to the calling table. The call stays visible from the caller: `table-runs list --table <caller> --status all` lists the run, and the binding column's cell holds the outcome (status, outputs, credits, invocation and run ids). Address a Function by id, slug, or the display name shown by `functions list`.\nWorked example with commands: `oxygen skills install --skill oxygen-gtm --project`, then read its recipes/callable-tables.md.\n");
+    functions.command("list").description("List your workspace's drafts and published Functions with per-row credit estimates (up to 500).")
+        .option("--managed", "Retired compatibility filter; returns an empty list. Use the workspace library without this flag.")
         .option("--favorites", "Only the Functions you favourited (`functions favorite <function>`).")
         .option("--json", "Print a JSON envelope.")
         .action((options) => handle("functions list", options, () => {
@@ -20,11 +20,11 @@ export function registerFunctionsCommands(program, handle) {
             .option("--json", "Print a JSON envelope.")
             .action((ref, options) => handle(`functions ${command}`, options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: command, function: ref } })));
     }
-    functions.command("duplicate <function>").description("Copy a Function's steps into a new editable draft of your own (same inputs and outputs, no rows). The way to customize an OXYGEN-managed Function.")
+    functions.command("duplicate <function>").description("Copy a Function's steps into a new editable draft (same inputs and outputs, no rows).")
         .option("--name <name>", "Display name for the copy. Defaults to '<source> (copy)'.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, options) => handle("functions duplicate", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "duplicate", function: ref, ...(options.name ? { display_name: options.name } : {}) } })));
-    functions.command("describe <function>").description("Inspect a Function's inputs, outputs, steps, per-row credit estimate, caps, and whether it is OXYGEN-managed or your own draft/published version.")
+    functions.command("describe <function>").description("Inspect a Function's inputs, outputs, steps, per-row credit estimate, caps, and draft or published version.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, options) => handle("functions describe", options, () => requestOxygen(`/api/cli/functions?${new URLSearchParams({ function: ref })}`)));
     functions.command("draft [function]").description("Create a Function draft, or save an existing Function's draft; executes nothing.")
@@ -47,17 +47,17 @@ export function registerFunctionsCommands(program, handle) {
     functions.command("rename <function> <name>").description("Rename a Function while preserving its identity, callers and published execution.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, name, options) => handle("functions rename", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "rename", function: ref, display_name: name } })));
-    functions.command("delete <function>").description("Preview removal from the Function library, then remove it with --yes; preserves backing tables, rows and run history. Connected callers or active runs block deletion. Works on an OXYGEN-managed Function too: it leaves this workspace's library and is not seeded back.")
-        .addHelpText("after", "\nDeleting your own Function is final: there is no restore, unlike `tables delete`. To reuse the logic, `tables duplicate` the backing Table and draft a new Function from the copy.\nDeleting an OXYGEN-managed Function only removes it from THIS workspace; `functions restore` brings OXYGEN's ready-made Functions back.\n")
+    functions.command("delete <function>").description("Preview removal from the Function library, then remove it with --yes; preserves backing tables, rows and run history. Connected callers or active runs block deletion.")
+        .addHelpText("after", "\nDeleting your own Function is final: there is no restore, unlike `tables delete`. To reuse the logic, `tables duplicate` the backing Table and draft a new Function from the copy.\n")
         .option("--yes", "Confirm removal of this Function after reviewing its callers.")
         .option("--json", "Print a JSON envelope.")
         .action((ref, options) => handle("functions delete", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "delete", function: ref, approved: options.yes === true } })));
-    functions.command("restore").description("Put back the OXYGEN-managed Functions this workspace deleted. They are rebuilt at the current catalog version in the background; `functions list --managed` shows them as they land.")
-        .option("--catalog-id <id...>", "Restore only these catalog entries (the managed.catalogId from `functions describe`). Defaults to every removed one.")
+    functions.command("restore").description("Retired: OXYGEN-provided Functions can no longer be restored. Create a workspace Function instead.")
+        .option("--catalog-id <id...>", "Legacy catalog identifiers; restoration is no longer available.")
         .option("--json", "Print a JSON envelope.")
         .action((options) => handle("functions restore", options, () => requestOxygen("/api/cli/functions", { method: "POST", body: { operation: "restore_managed", ...(options.catalogId?.length ? { catalog_ids: options.catalogId } : {}) } })));
     functions.command("bind <table> <function>").description("Add a Function column with explicit input/output mappings and a caller credit cap. Create each mapped output column on the caller table first with `columns add`; bind rejects an output mapped to a column the caller table does not have.")
-        .requiredOption("--inputs-json <json>", "Object mapping Function input keys to caller column keys.")
+        .requiredOption("--inputs-json <json>", "Map Function input keys to caller columns or nested JSON paths, e.g. profile.company.domain.")
         .requiredOption("--outputs-json <json>", "Object mapping Function output keys to existing caller column keys.")
         .requiredOption("--max-credits-per-item <n>", "Hard credit ceiling for each caller row; future publishes cannot raise it.")
         .option("--overwrite-policy <policy>", "Callback writes: empty_only or overwrite.", "empty_only")