@oxygen-agent/cli 1.906.0 → 1.917.5

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.906.0
+Version: 1.917.5

package/dist/command-manifest.js

@@ -36,6 +36,9 @@ const MUTATING_VERBS = new Set([
     // recurring write, and --run can connect newly eligible mailboxes immediately.
     "auto-enroll",
     "backfill",
+    // A noun leaf, so the default would advertise `projects color` — a tenant
+    // write — to every agent as a read. `decide` is the same case.
+    "color",
     // Exact leaves, not the `billing` prefix — `orgs billing-owners` is a read.
     // Both move a workspace's billing owner, so an agent must treat them as writes.
     "billing-link", "billing-unlink",

package/dist/index.js

@@ -9,7 +9,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command, CommanderError, Option } from "commander";
 import { applyOxygenHelp } from "./help.js";
 import { buildCommandManifest, getCommandManifestEntry, searchCommandManifest, suggestCommandNames, } from "./command-manifest.js";
-import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_MCP_TOOL_NAME_LENGTH, normalizeCopilotPlanStepStatus, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
+import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatCopilotPlanDuration, formatCopilotPlanSeconds, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_MCP_TOOL_NAME_LENGTH, normalizeCopilotPlanStepStatus, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
 import { TAG_COLORS } from "@oxygen/shared/select-options";
 import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { MAILBOX_IMPORT_FILE_MAX_BYTES as SHARED_MAILBOX_IMPORT_FILE_MAX_BYTES, MAILBOX_IMPORT_ROW_LIMIT as SHARED_MAILBOX_IMPORT_ROW_LIMIT, normalizeMailboxImportFile as normalizeSharedMailboxImportFile, normalizeMailboxImportVendor as normalizeSharedMailboxImportVendor, normalizeMailboxWorkbookRows, parseMailboxImportText, summarizeMailboxImportValidation as summarizeSharedMailboxImportValidation, } from "@oxygen/shared/mailbox-import";
@@ -567,6 +567,72 @@ function writeObservabilityCapsNotice(data) {
         : Array.isArray(record.items) ? record.items.length : 0;
     process.stderr.write(`note: showing ${returned} item(s); some sources hit the per-source cap (${cappedSources.join(", ")}) — raise --limit (max 100) or filter --source to see more.\n`);
 }
+// Discovery lists are windowed by default (200 rows, max 1000) so the cost of
+// asking "what is in this workspace?" does not scale with how much the customer
+// has built. A window nobody can see is indistinguishable from a complete
+// answer, so say it on stderr — same treatment the observability console's
+// per-source cap already gets. Machine-read stdout carries `capped`, `returned`
+// and `limit` either way.
+function writeListCapNotice(data, noun) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return;
+    const record = data;
+    if (record.capped !== true)
+        return;
+    const returned = typeof record.returned === "number" ? record.returned : null;
+    process.stderr.write(`note: showing ${returned === null ? "a window of" : returned} ${noun}; more exist — raise --limit (max 1000) or pass --all.\n`);
+}
+// The map is bounded twice over — a scan window per kind, then a character
+// budget across all of them — and both bounds are invisible in the rendered
+// output. Say them on stderr for the same reason every other cap here is said:
+// a window presented as a complete answer is a confident lie, and this one is
+// the first thing an agent or a person reads about a workspace. `degraded` gets
+// the same treatment: an empty kind that failed to read is not an empty kind.
+function writeWorkspaceMapNotices(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return;
+    const record = data;
+    const degraded = Array.isArray(record.degraded) ? record.degraded : [];
+    if (degraded.length > 0) {
+        process.stderr.write(`note: could not read ${degraded.join(", ")} — those kinds are unknown, not empty.\n`);
+    }
+    const kinds = Array.isArray(record.kinds) ? record.kinds : [];
+    const capped = kinds
+        .filter((kind) => Boolean(kind) && typeof kind === "object" && !Array.isArray(kind) && kind.capped === true)
+        .map((kind) => String(kind.kind));
+    if (capped.length > 0) {
+        process.stderr.write(`note: ${capped.join(", ")} hold more than this scan saw; their counts are a floor. Narrow with --query or --tag.\n`);
+    }
+    const budget = record.budget;
+    if (budget && typeof budget === "object" && !Array.isArray(budget)) {
+        const trimmed = budget.trimmed;
+        if (Array.isArray(trimmed) && trimmed.length > 0) {
+            process.stderr.write(`note: the character budget trimmed ${trimmed.length} item(s) from ${[...new Set(trimmed.map(String))].join(", ")}.\n`);
+        }
+    }
+    const tagNote = record.tag_note;
+    if (typeof tagNote === "string" && tagNote)
+        process.stderr.write(`note: ${tagNote}\n`);
+}
+// The wiki index counts the whole wiki even when the page list is a window, so
+// name both numbers: "200 of 512 pages" is honest, "200 pages" is not.
+function writeKnowledgeIndexCapNotice(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return;
+    const index = data.index;
+    if (!index || typeof index !== "object" || Array.isArray(index))
+        return;
+    const block = index;
+    if (block.capped !== true)
+        return;
+    const counts = block.counts;
+    const returned = typeof counts?.returned === "number" ? counts.returned : null;
+    const total = typeof counts?.total === "number" ? counts.total : null;
+    const shown = returned === null
+        ? "a window of this wiki's pages"
+        : `${returned}${total === null ? "" : ` of ${total}`} page(s)`;
+    process.stderr.write(`note: listing ${shown}, most recently updated first; counts cover the whole wiki — raise --limit (max 1000) or pass --all.\n`);
+}
 // Arming a cron commits recurring spend, so `workflows enable` mirrors its
 // `automation` block as stderr lines: what the schedule burns per day, what
 // share of the monthly allowance that is, and when it runs out. Observed burn
@@ -2648,6 +2714,38 @@ export function createProgram() {
         .action(async (options) => {
         await handleAsyncAction("home standup", options, readHomeStandup);
     });
+    // `oxygen workspace map` sits beside `oxygen home` on purpose: home answers
+    // "what needs me", the map answers "what is in here". Both are Control-surface
+    // compositions over reads the primitives already own — neither is a primitive.
+    program
+        .command("workspace")
+        .description("Read what this workspace contains, across every primitive.")
+        .addCommand(new Command("map")
+        .description("What this workspace actually contains: the newest tables, CRM objects, sequences, workflows, agents, wiki pages, posts and projects, each with its id, last activity, tags and link. Read-only, 0 credits. Capability search tells you what OXYGEN can do; this tells you what is here.")
+        .option("--kind <kinds>", "Comma-separated kinds to include: table, crm_object, sequence, workflow, agent, knowledge_page, post, project.")
+        .option("--tag <tag>", "Only objects carrying this workspace tag. Answered by the Tags footprint read, so it also covers kinds this map does not model.")
+        .option("--query <text>", "Match on name, slug, or tag.")
+        .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", "\nEach kind returns its newest few objects under a character budget the payload echoes back; `capped` says when a kind holds more than the scan saw. Hydrate one object with its own primitive's read (`oxygen tables describe`, `oxygen workflows get`, `oxygen knowledge page get`).\n\nRead-only means read-only: the map creates nothing in your workspace in order to answer, so an empty wiki reports zero pages rather than a starter set this command seeded. Use `oxygen knowledge index` when you do want the starter wiki created.\n")
+        .action(async (options) => {
+        await handleAsyncAction("workspace map", options, async () => {
+            const params = new URLSearchParams();
+            const kind = readOption(options.kind);
+            if (kind)
+                params.set("kind", kind);
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            const query = readOption(options.query);
+            if (query)
+                params.set("query", query);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            const data = await requestOxygen(`/api/cli/workspace/map${qs}`);
+            if (!options.json)
+                writeWorkspaceMapNotices(data);
+            return data;
+        });
+    }));
     const ACTIVATION_DESCRIPTION = "Where this workspace stands in the prescribed activation play (inbound-led outbound) and the ONE thing to do next: each step's state, what blocks a blocked one, the exact CLI / MCP tool / API call for the next step, and an honest pacing note — LinkedIn is read on a metered drip and a sender's warm-up ramp, not the size of your list, sets how fast anyone is contacted. Read-only, 0 credits. Read the play itself with `oxygen recipes list --stage day-1 --json`.";
     // Bare `oxygen activation` is the spelling a founder guesses; `activation state`
     // is the exact name discovery routes to (it is a gatewayCommand of the
@@ -3520,6 +3618,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             method: "POST",
             body: { tags: splitCommaList(options.tags) },
         }));
+    }))
+        .addCommand(new Command("color")
+        .description("Set a project's colour in the Tables rail. `--color auto` restores the automatic colour.")
+        .argument("<project>", "Project slug or id.")
+        .requiredOption("--color <color>", "Colour name (gray, red, orange, amber, yellow, green, teal, blue, indigo, purple, pink) or `auto` to clear.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (project, options) => {
+        await handleAsyncAction("projects color", options, () => requestOxygen(`/api/cli/projects/${encodeURIComponent(project)}/color`, {
+            method: "POST",
+            body: { color: options.color?.trim().toLowerCase() ?? null },
+        }));
     }));
     program
         .command("notetaker")
@@ -5038,9 +5147,12 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--project <project>", "Project id or slug to filter by.")
         .option("--tag <tag>", "Only tables carrying this workspace tag (see `oxygen tags list`).")
         .option("--include-archived", "Also list archived and delete-scheduled tables (the restorable trash; each carries a lifecycle with purge_scheduled_at).")
+        .option("--limit <n>", "Maximum tables to list. Defaults to 200; hard cap is 1000.")
+        .option("--all", "List every table instead of the newest window.")
         .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", "\nLists the 200 newest tables by default; `capped` in the JSON envelope says when there are more.\n")
         .action(async (options) => {
-        await handleAsyncAction("tables list", options, () => {
+        await handleAsyncAction("tables list", options, async () => {
             const params = new URLSearchParams();
             const project = readOption(options.project);
             if (project)
@@ -5050,8 +5162,16 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 params.set("tag", tag);
             if (options.includeArchived)
                 params.set("include_archived", "true");
+            const limit = readPositiveInt(options.limit);
+            if (limit !== undefined)
+                params.set("limit", String(limit));
+            if (options.all)
+                params.set("all", "true");
             const qs = params.toString() ? `?${params.toString()}` : "";
-            return requestOxygen(`/api/cli/tables${qs}`);
+            const data = await requestOxygen(`/api/cli/tables${qs}`);
+            if (!options.json)
+                writeListCapNotice(data, "table(s)");
+            return data;
         });
     }))
         .addCommand(new Command("query")
@@ -6242,10 +6362,24 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("index")
-        .description("Compact wiki index: every page's slug, one-liner, tags, link degree, plus type/status counts.")
+        .description("Compact wiki index: each page's slug, one-liner, tags, link degree, plus type/status counts over the whole wiki. Lists the 200 most recently updated pages by default.")
+        .option("--limit <n>", "Maximum pages to list. Defaults to 200; hard cap is 1000. Counts always cover the whole wiki.")
+        .option("--all", "List every page instead of the most recently updated window.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("knowledge index", options, () => requestOxygen("/api/cli/knowledge/index"));
+        await handleAsyncAction("knowledge index", options, async () => {
+            const params = new URLSearchParams();
+            const limit = readPositiveInt(options.limit);
+            if (limit !== undefined)
+                params.set("limit", String(limit));
+            if (options.all)
+                params.set("all", "true");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            const data = await requestOxygen(`/api/cli/knowledge/index${qs}`);
+            if (!options.json)
+                writeKnowledgeIndexCapNotice(data);
+            return data;
+        });
     }))
         .addCommand(new Command("graph")
         .description("Knowledge graph of pages and their [[wikilink]] edges. Pass --center to render one page's local neighborhood instead of the whole graph.")
@@ -15292,8 +15426,10 @@ Run completion:
         .option("--tag <tag>", "Only workflows carrying this workspace tag (see `oxygen tags list`).")
         .option("--node-testable", "Only canonical graph workflows, the ones `workflows call --node` can scope a test to. Legacy recipes and v1 step lists own their own execution order and are excluded.")
         .option("--search <text>", "Match on name, slug, trigger event, or an integration the workflow uses — so \"meeting\" or \"hubspot\" finds it without knowing what someone named it.")
+        .option("--limit <n>", "Maximum workflows to list. Defaults to 200; hard cap is 1000.")
+        .option("--all", "List every workflow instead of the most-recently-updated window.")
         .option("--json", "Print a JSON envelope.")
-        .addHelpText("after", "\nEach row carries `format` (graph, recipe or steps) and `nodeTestable`, so you can tell which workflows support single-step testing without opening them.\n")
+        .addHelpText("after", "\nEach row carries `format` (graph, recipe or steps) and `nodeTestable`, so you can tell which workflows support single-step testing without opening them.\nLists the 200 most recently updated workflows by default; `capped` in the JSON envelope says when there are more.\n")
         .action(async (options) => {
         await handleAsyncAction("workflows list", options, async () => {
             const params = new URLSearchParams();
@@ -15305,10 +15441,17 @@ Run completion:
             const search = readOption(options.search);
             if (search)
                 params.set("search", search);
+            const limit = readPositiveInt(options.limit);
+            if (limit !== undefined)
+                params.set("limit", String(limit));
+            if (options.all)
+                params.set("all", "true");
             const qs = params.toString() ? `?${params.toString()}` : "";
             const data = await requestOxygen(`/api/cli/workflows${qs}`);
-            if (!options.json)
+            if (!options.json) {
                 writeDisabledWorkflowNotices(data);
+                writeListCapNotice(data, "workflow(s)");
+            }
             return data;
         });
     }))
@@ -16722,7 +16865,7 @@ function writeCopilotPlan(plan, webUrl) {
     const lines = [];
     if (typeof plan.summary === "string" && plan.summary)
         lines.push(plan.summary, "");
-    lines.push(`${progress.done ?? 0}/${progress.total ?? 0} steps done${formatPlanEta(eta)}`, "");
+    lines.push(`${progress.done ?? 0}/${progress.total ?? 0} steps done${formatPlanEta(eta, plan.turnActive !== false)}`, "");
     for (const step of steps) {
         if (!isRecord(step))
             continue;
@@ -16730,7 +16873,7 @@ function writeCopilotPlan(plan, webUrl) {
         const mark = status === "done" ? "[x]" : status === "in_progress" ? "[>]" : status === "blocked" ? "[!]" : "[ ]";
         const timing = status === "done"
             ? formatPlanDuration(step.elapsedMs)
-            : typeof step.etaSeconds === "number" ? `~${formatPlanSeconds(step.etaSeconds)} left` : "";
+            : typeof step.etaSeconds === "number" ? `~${formatCopilotPlanSeconds(step.etaSeconds)} left` : "";
         lines.push(`${mark} ${String(step.title ?? "")}${timing ? `  (${timing})` : ""}`);
         for (const sub of Array.isArray(step.substeps) ? step.substeps : []) {
             if (!isRecord(sub))
@@ -16746,7 +16889,12 @@ function writeCopilotPlan(plan, webUrl) {
     process.stdout.write(`${lines.join("\n")}\n`);
 }
 /** Every estimate names its basis, so nobody reads a guess as a measurement. */
-function formatPlanEta(eta) {
+function formatPlanEta(eta, turnActive) {
+    // Nothing is running, so nothing REMAINS. "estimating" on a session that stopped
+    // weeks ago describes work in flight that does not exist; the step marks still
+    // say where the copilot got to, which is the honest half of the answer.
+    if (!turnActive)
+        return "";
     const remaining = typeof eta.remainingSeconds === "number" ? eta.remainingSeconds : null;
     if (remaining === null)
         return " · time remaining: estimating";
@@ -16755,19 +16903,11 @@ function formatPlanEta(eta) {
         ? `measured from ${measured} completed step${measured === 1 ? "" : "s"}`
         : eta.basis === "model" ? "estimated, nothing measured yet" : "no basis";
     const bound = eta.deadlineBound === true ? ", capped by the turn deadline" : "";
-    return ` · ~${formatPlanSeconds(remaining)} left (${basis}${bound})`;
-}
-function formatPlanSeconds(seconds) {
-    if (seconds < 60)
-        return `${Math.round(seconds)}s`;
-    const minutes = Math.floor(seconds / 60);
-    const rest = Math.round(seconds % 60);
-    return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+    return ` · ~${formatCopilotPlanSeconds(remaining)} left (${basis}${bound})`;
 }
+/** Narrows the untyped ledger value, then defers to the one shared formatter. */
 function formatPlanDuration(ms) {
-    if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0)
-        return "";
-    return ms < 1000 ? `${Math.round(ms)}ms` : formatPlanSeconds(ms / 1000);
+    return (typeof ms === "number" ? formatCopilotPlanDuration(ms) : null) ?? "";
 }
 function printCopilotEvent(event, sessionId) {
     if (!isRecord(event))
@@ -23458,7 +23598,9 @@ options, orgOverride) {
         }
         // Generated summaries come from the server's own projections, not a client-side
         // recomputation. A real wiki page may own the `index`/`log` slug — page bytes win.
-        const index = await requestOxygen("/api/cli/knowledge/index", requestOrg);
+        // `all=true` on purpose: the generated index.md must list every page this
+        // mirror just cloned, and the route's default is a 200-page window.
+        const index = await requestOxygen("/api/cli/knowledge/index?all=true", requestOrg);
         const logPage = await requestOxygen("/api/cli/knowledge/log", {
             method: "POST",
             body: {},

package/node_modules/@oxygen/formula/dist/expression.d.ts

@@ -41,6 +41,27 @@ export type ParseOptions = {
 export declare function parseFormulaExpression(expression: string, options?: ParseOptions): FormulaAst;
 /** Validate supported functions and arity on an already-parsed tree. */
 export declare function validateFormulaAst(ast: FormulaAst): void;
+/**
+ * SAVE-TIME ONLY: reject a literal regex pattern that is too long to ever compile.
+ *
+ * Deliberately NOT part of validateFormulaAst. That runs on the READ path too
+ * (formula-column-runner prepares every batch through it) and
+ * prepareFormulaForRead swallows the throw and nulls the WHOLE column, so
+ * tightening it would silently blank already-stored columns rather than reject
+ * the edit. Keeping this save-only means a column that stores today keeps
+ * reading today, and only a NEW write is refused.
+ *
+ * Length is checked, not compilation. A pattern over the cap can never succeed in
+ * any branch, so flagging it costs the author nothing -- whereas rejecting an
+ * unparseable literal would break `if(cond, regex_match(x, "["), "n/a")`, which
+ * works today precisely because if/switch/and/or/coalesce are lazy and never
+ * evaluate the untaken side. That stricter semantic is a separate decision.
+ *
+ * Without this, an over-long pattern stored fine and then failed per row on every
+ * run forever -- the production shape was one column failing across dozens of rows
+ * for days with received_length 290 against the old 256 cap.
+ */
+export declare function validateFormulaRegexLiterals(ast: FormulaAst): void;
 /** Validate syntax, supported functions, and arity without evaluating any data. */
 export declare function validateFormulaExpression(expression: string, options?: ParseOptions): void;
 export declare function walkExpression(node: FormulaAst, visit: (node: FormulaAst) => void): void;

package/node_modules/@oxygen/formula/dist/expression.js

@@ -1,4 +1,4 @@
-import { FORMULA_FUNCTION_REGISTRY, checkFormulaFunctionArity, formulaExpressionError, } from "./formula-functions.js";
+import { FORMULA_FUNCTION_REGISTRY, MAX_FORMULA_REGEX_PATTERN_LENGTH, checkFormulaFunctionArity, formulaExpressionError, } from "./formula-functions.js";
 /**
  * Functions evaluated against the whole column rather than the current scope.
  * They are intercepted before registry dispatch (the registry entry carries
@@ -37,6 +37,47 @@ export function validateFormulaAst(ast) {
         checkFormulaFunctionArity(spec, node.args.length);
     });
 }
+/**
+ * SAVE-TIME ONLY: reject a literal regex pattern that is too long to ever compile.
+ *
+ * Deliberately NOT part of validateFormulaAst. That runs on the READ path too
+ * (formula-column-runner prepares every batch through it) and
+ * prepareFormulaForRead swallows the throw and nulls the WHOLE column, so
+ * tightening it would silently blank already-stored columns rather than reject
+ * the edit. Keeping this save-only means a column that stores today keeps
+ * reading today, and only a NEW write is refused.
+ *
+ * Length is checked, not compilation. A pattern over the cap can never succeed in
+ * any branch, so flagging it costs the author nothing -- whereas rejecting an
+ * unparseable literal would break `if(cond, regex_match(x, "["), "n/a")`, which
+ * works today precisely because if/switch/and/or/coalesce are lazy and never
+ * evaluate the untaken side. That stricter semantic is a separate decision.
+ *
+ * Without this, an over-long pattern stored fine and then failed per row on every
+ * run forever -- the production shape was one column failing across dozens of rows
+ * for days with received_length 290 against the old 256 cap.
+ */
+export function validateFormulaRegexLiterals(ast) {
+    walkExpression(ast, (node) => {
+        if (node.type !== "call")
+            return;
+        const normalized = node.name.toLowerCase();
+        if (normalized !== "regex_match" && normalized !== "regex_extract" && normalized !== "regex_replace") {
+            return;
+        }
+        // Every regex function takes its pattern as the second argument.
+        const pattern = node.args[1];
+        if (!pattern || pattern.type !== "literal" || typeof pattern.value !== "string")
+            return;
+        if (pattern.value.length <= MAX_FORMULA_REGEX_PATTERN_LENGTH)
+            return;
+        throw formulaExpressionError("Regular-expression pattern is too long.", {
+            function: node.name,
+            max_length: MAX_FORMULA_REGEX_PATTERN_LENGTH,
+            received_length: pattern.value.length,
+        });
+    });
+}
 /** Validate syntax, supported functions, and arity without evaluating any data. */
 export function validateFormulaExpression(expression, options = {}) {
     validateFormulaAst(parseFormulaExpression(expression, options));

package/node_modules/@oxygen/formula/dist/formula-functions.d.ts

@@ -37,7 +37,7 @@ export type FormulaFunctionSpec = FormulaFunctionMeta & {
     evaluate?: (args: unknown[]) => unknown;
     evaluateLazy?: (thunks: Array<() => unknown>) => unknown;
 };
-export declare const MAX_FORMULA_REGEX_PATTERN_LENGTH = 256;
+export declare const MAX_FORMULA_REGEX_PATTERN_LENGTH = 1000;
 export declare const MAX_FORMULA_REGEX_INPUT_LENGTH = 20000;
 export declare function formulaExpressionError(message: string, details: Record<string, unknown>): OxygenError;
 export declare function isBlankFormulaValue(value: unknown): boolean;

package/node_modules/@oxygen/formula/dist/formula-functions.js

@@ -1,7 +1,16 @@
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { walkJsonPath } from "@oxygen/shared/json-path";
 import { normalizeDomain, normalizeEmail, normalizeLinkedinUrl, } from "./value-normalizers.js";
-export const MAX_FORMULA_REGEX_PATTERN_LENGTH = 256;
+// Pattern LENGTH is not a safety bound and never was -- catastrophic backtracking
+// is a function of pattern SHAPE, and `(a+)+$` hangs at 6 characters, so 256 already
+// permitted an unbounded hang while rejecting harmless long literals. The real bound
+// on scan cost is MAX_FORMULA_REGEX_INPUT_LENGTH below, which caps what a pattern is
+// run against. 256 rejected a customer's 290-character alternation on every row of
+// their table, continuously, for days (production 2026-08-28/31). Raised to a value
+// that still stops a pathological paste while leaving ordinary generated alternations
+// room. If real ReDoS protection is ever needed it belongs in the engine (a
+// backtracking budget or re2), not in a character count.
+export const MAX_FORMULA_REGEX_PATTERN_LENGTH = 1_000;
 export const MAX_FORMULA_REGEX_INPUT_LENGTH = 20_000;
 // ---------------------------------------------------------------------------
 // Shared coercion helpers (used by the registry AND the runner's operators)

package/node_modules/@oxygen/shared/dist/capability-discovery.js

@@ -21,15 +21,20 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         id: "discovery-and-skills",
         layer: "Control",
         primitive: null,
-        owns: "Bounded capability, command, provider-operation, Recipe, and product-skill discovery with exact hydration on demand.",
+        owns: "Bounded capability, command, provider-operation, Recipe, and product-skill discovery, plus INSTANCE discovery — what this workspace actually holds — with exact hydration on demand.",
         notFor: "Executing GTM work or loading full manifests and schemas before a capability is selected.",
-        execution: "Search by outcome, choose the owner, then hydrate one exact command, MCP schema, provider descriptor, or skill.",
+        execution: "Search by outcome, choose the owner, then hydrate one exact command, MCP schema, provider descriptor, or skill. For instance discovery, read the map and then the primitive that owns the row.",
         posture: "read_only",
-        gatewayTools: ["oxygen_capabilities_search", "oxygen_tools_search", "oxygen_recipes_list"],
-        gatewayCommands: ["capabilities search", "commands search", "skills search", "tools search", "recipes list"],
+        gatewayTools: ["oxygen_capabilities_search", "oxygen_tools_search", "oxygen_recipes_list", "oxygen_workspace_map"],
+        gatewayCommands: ["capabilities search", "commands search", "skills search", "tools search", "recipes list", "workspace map"],
         skills: ["oxygen-quickstart", "oxygen-gtm"],
-        endpointSections: ["skills"],
-        intentTerms: ["discover", "discovery", "capability", "capabilities", "command", "commands", "skill", "skills", "which tool", "how do i"],
+        // `workspace` (the map) belongs here rather than beside `home`: capability
+        // discovery answers what OXYGEN can do and instance discovery answers what THIS
+        // workspace holds, and they are the same act — bounded, read-only, hydrate one
+        // thing on demand. `home` stayed on the onboarding card because the standup is a
+        // first-run surface; the map is not.
+        endpointSections: ["skills", "workspace"],
+        intentTerms: ["discover", "discovery", "capability", "capabilities", "command", "commands", "skill", "skills", "which tool", "how do i", "what do i have", "what is in my workspace", "workspace map"],
     },
     {
         id: "onboarding-and-copilot",

package/node_modules/@oxygen/shared/dist/copilot-errors.d.ts

@@ -1,5 +1,6 @@
 export declare const COPILOT_TURN_TIMEOUT_CODE = "copilot_turn_timeout";
 export declare const COPILOT_TURN_TIMEOUT_MESSAGE = "This Copilot request timed out and stopped. Any completed actions are still saved\u2014review this session before trying again.";
+export declare const COPILOT_TURN_DEADLINE_EXCEEDED_CODE = "copilot_turn_deadline_exceeded";
 export type CustomerFacingCopilotError = {
     code: string | null;
     message: string | null;

package/node_modules/@oxygen/shared/dist/copilot-errors.js

@@ -4,6 +4,14 @@
 // and already-persisted failures serialize identically across web, CLI, and MCP.
 export const COPILOT_TURN_TIMEOUT_CODE = "copilot_turn_timeout";
 export const COPILOT_TURN_TIMEOUT_MESSAGE = "This Copilot request timed out and stopped. Any completed actions are still saved—review this session before trying again.";
+// A turn the worker refused to start because it was ALREADY past its stamped
+// wall-clock deadline when it was reclaimed. Distinct in the durable row from
+// `copilot_turn_timeout` (a turn that ran and then ran out of clock) so an
+// operator can separate "we never started it" from "we could not finish it" in
+// SQL — but deliberately NOT distinct to the customer: the mapping below folds
+// it into the same timeout contract every Control surface already renders, per
+// this module's policy.
+export const COPILOT_TURN_DEADLINE_EXCEEDED_CODE = "copilot_turn_deadline_exceeded";
 const WORKER_STEP_TIMEOUT_MESSAGE = /\bWorker step '[^']+' exceeded \d+ms deadline\.?/i;
 /**
  * Replace an internal worker deadline with the stable Copilot timeout contract.
@@ -15,6 +23,7 @@ export function customerFacingCopilotError(input) {
     const message = input.message ?? null;
     const isTimeout = code === "worker_step_timeout" ||
         code === COPILOT_TURN_TIMEOUT_CODE ||
+        code === COPILOT_TURN_DEADLINE_EXCEEDED_CODE ||
         (message !== null && WORKER_STEP_TIMEOUT_MESSAGE.test(message));
     return isTimeout
         ? { code: COPILOT_TURN_TIMEOUT_CODE, message: COPILOT_TURN_TIMEOUT_MESSAGE }

package/node_modules/@oxygen/shared/dist/copilot-plan.d.ts

@@ -109,6 +109,8 @@ export type CopilotPlanProjection = {
         /** True when the turn's wall-clock deadline, not the plan, is the binding bound. */
         deadlineBound: boolean;
     };
+    /** False when no turn is executing: the plan is history, not work in flight. */
+    turnActive: boolean;
     /** Ledger position of the newest plan_updated, so a caller can tell staleness. */
     updatedAtSeq: number;
     updatedAt: string;
@@ -124,6 +126,20 @@ export type ProjectCopilotPlanInput = {
     events: CopilotPlanSourceEvent[];
     /** The active turn's wall-clock deadline, used only to clamp the total. */
     turnDeadlineAt?: string | Date | null;
+    /**
+     * Whether a turn is executing right now. Defaults to true.
+     *
+     * A plan OUTLIVES the turn that wrote it. The model routinely stops without
+     * marking its last step done, so the session rests in the ledger forever with a
+     * step still `in_progress`. Read against a running clock that step accrues
+     * elapsed time indefinitely -- production session fd259942 reached 37 DAYS --
+     * and the surface goes on offering "time remaining" for work that stopped weeks
+     * ago. Both are the same error: treating a historical record as work in flight.
+     *
+     * So the clock stops with the turn, and a plan nobody is working reports no
+     * estimate at all rather than a false one.
+     */
+    turnActive?: boolean;
     now?: Date;
 };
 /**
@@ -135,3 +151,19 @@ export type ProjectCopilotPlanInput = {
  * would be worse than one that stays away.
  */
 export declare function projectCopilotPlan(input: ProjectCopilotPlanInput): CopilotPlanProjection | null;
+/**
+ * How long, in words. One owner, because there were three and all three were wrong.
+ *
+ * The rail, `oxygen copilot plan` and the MCP widget each carried their own copy
+ * of this, and every copy did `Math.floor(s / 60)` minutes with `Math.round(s % 60)`
+ * seconds -- which rounds the remainder INDEPENDENTLY of the minutes it was taken
+ * from. A 179.6s sub-agent therefore rendered as "2m 60s" on all three surfaces
+ * (observed live in session 34826105), and 59.6s rendered as "60s" rather than
+ * "1m". Rounding the total FIRST and splitting afterwards cannot produce either.
+ *
+ * The projection promised one implementation behind three surfaces; the numbers
+ * were shared and the words describing them were not, so this is where they meet.
+ */
+export declare function formatCopilotPlanSeconds(seconds: number): string;
+/** A duration in ms, or null when there is nothing worth showing. */
+export declare function formatCopilotPlanDuration(ms: number | null | undefined): string | null;

package/node_modules/@oxygen/shared/dist/copilot-plan.js

@@ -169,6 +169,13 @@ export function projectCopilotPlan(input) {
     const planEvents = events.filter((event) => event.kind === "plan_updated");
     if (planEvents.length === 0)
         return null;
+    // The plan's clock stops when the turn does -- see `turnActive` on the input.
+    // `Math.min` because a clock that runs BACKWARDS is worse than one that stops:
+    // the last event is normally in the past, but a clock skew must not make an
+    // elapsed time negative.
+    const turnActive = input.turnActive !== false;
+    const lastEvent = events[events.length - 1];
+    const clockMs = turnActive || !lastEvent ? nowMs : Math.min(nowMs, toMs(lastEvent.created_at));
     // -- Pass 1: fold the successive plans into one tracked set -----------------
     //
     // Identity is what makes timing possible. Match on `id` first, then on the
@@ -230,7 +237,7 @@ export function projectCopilotPlan(input) {
     if (tracked.length === 0)
         return null;
     // -- Pass 2: attribute observed tool calls to the step that was running -----
-    attributeToolCalls(events, planEvents, tracked, nowMs);
+    attributeToolCalls(events, planEvents, tracked, clockMs);
     // -- Pass 3: the ETA --------------------------------------------------------
     const samples = tracked
         .filter((t) => t.status === "done" && t.startedAtMs !== null && t.endedAtMs !== null)
@@ -250,10 +257,11 @@ export function projectCopilotPlan(input) {
         // Once a step has started it has an elapsed time: its own end if it finished,
         // otherwise the clock. A step that never started has none -- which is exactly
         // why it is also never a measurement sample.
-        const elapsedMs = entry.startedAtMs === null ? null : (entry.endedAtMs ?? nowMs) - entry.startedAtMs;
+        const elapsedMs = entry.startedAtMs === null ? null : (entry.endedAtMs ?? clockMs) - entry.startedAtMs;
         let etaSeconds = null;
         let etaBasis = "none";
-        if (entry.status === "pending" || entry.status === "in_progress") {
+        // A step only has time REMAINING while something is running to consume it.
+        if (turnActive && (entry.status === "pending" || entry.status === "in_progress")) {
             let budget = null;
             if (entry.estimateSeconds !== null && calibration !== null) {
                 budget = entry.estimateSeconds * calibration;
@@ -307,6 +315,7 @@ export function projectCopilotPlan(input) {
     }
     const done = steps.filter((step) => step.status === "done").length;
     return {
+        turnActive,
         summary: summary.length > 0 ? summary : null,
         steps,
         progress: { done, total: steps.length, ratio: steps.length === 0 ? 0 : done / steps.length },
@@ -327,7 +336,7 @@ export function projectCopilotPlan(input) {
  * Attribution uses the plan as of the call's own seq, not the final plan -- a call
  * made during step 2 belongs to step 2 even after step 4 becomes current.
  */
-function attributeToolCalls(events, planEvents, tracked, nowMs) {
+function attributeToolCalls(events, planEvents, tracked, clockMs) {
     const byId = new Map(tracked.map((t) => [t.id, t]));
     const byTitle = new Map(tracked.map((t) => [normalizeTitleKey(t.title), t]));
     /** Which tracked step was in progress at a given ledger position. */
@@ -409,7 +418,7 @@ function attributeToolCalls(events, planEvents, tracked, nowMs) {
             title: entry.capability,
             status: "in_progress",
             source: "tool",
-            durationMs: nowMs - entry.startedMs,
+            durationMs: clockMs - entry.startedMs,
             startedAt: new Date(entry.startedMs).toISOString(),
         });
     }
@@ -433,3 +442,35 @@ function mergeSubsteps(entry) {
     }));
     return [...declared, ...entry.toolSubsteps];
 }
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/**
+ * How long, in words. One owner, because there were three and all three were wrong.
+ *
+ * The rail, `oxygen copilot plan` and the MCP widget each carried their own copy
+ * of this, and every copy did `Math.floor(s / 60)` minutes with `Math.round(s % 60)`
+ * seconds -- which rounds the remainder INDEPENDENTLY of the minutes it was taken
+ * from. A 179.6s sub-agent therefore rendered as "2m 60s" on all three surfaces
+ * (observed live in session 34826105), and 59.6s rendered as "60s" rather than
+ * "1m". Rounding the total FIRST and splitting afterwards cannot produce either.
+ *
+ * The projection promised one implementation behind three surfaces; the numbers
+ * were shared and the words describing them were not, so this is where they meet.
+ */
+export function formatCopilotPlanSeconds(seconds) {
+    if (!Number.isFinite(seconds))
+        return "0s";
+    const total = Math.max(Math.round(seconds), 0);
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    const rest = total % 60;
+    return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+}
+/** A duration in ms, or null when there is nothing worth showing. */
+export function formatCopilotPlanDuration(ms) {
+    if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0)
+        return null;
+    return ms < 1000 ? `${Math.round(ms)}ms` : formatCopilotPlanSeconds(ms / 1000);
+}

package/node_modules/@oxygen/shared/dist/langfuse.d.ts

@@ -54,11 +54,42 @@ export type LlmEventBody = {
     sessionId?: string | null;
     userId?: string | null;
 };
+/**
+ * An eval/annotation attached to a trace (ADR 0014 files these as exactly what
+ * the LLM store exists to enable). Narrower than the API's CreateScoreRequest on
+ * purpose: `traceId` is REQUIRED (a score orphaned from its trace is unreadable
+ * in the UI), `value` is numeric-only, and `dataType` drops "CATEGORICAL"
+ * because that variant requires a *string* value. Widening later stays additive.
+ */
+export type LlmScoreBody = {
+    /** Deterministic id upserts; omit for a new score each call. */
+    id?: string;
+    traceId: string;
+    name: string;
+    value: number;
+    dataType?: "BOOLEAN" | "NUMERIC";
+    comment?: string;
+};
 export type LlmTracingClient = {
     trace(body: LlmTraceBody): void;
     span(body: LlmSpanBody): void;
     generation(body: LlmGenerationBody): void;
     event(body: LlmEventBody): void;
+    /**
+     * Attach a score to an existing trace.
+     *
+     * ASYNC, unlike the four above, because it is not the same transport. Spans go
+     * through the OTel processor, which batches and is drained by `flush()`; a
+     * score has no span, so it is one HTTP call to the scores API. Awaiting it is
+     * what keeps it alive on a serverless function that freezes the moment the
+     * handler returns — there is nothing for `flush()` to drain on its behalf.
+     *
+     * Never rejects: resolves `true` when the score was accepted, `false` when it
+     * was not (transport down, tracing misconfigured, API refusal). Fail-open like
+     * every other path here — telemetry must not break the product write it
+     * describes.
+     */
+    score(body: LlmScoreBody): Promise<boolean>;
     /** Never rejects; bounded at ~5s. */
     flush(): Promise<void>;
     /** Flush + stop background timers. Never rejects; bounded at ~5s. */
@@ -108,6 +139,10 @@ export type LlmEmitter = {
     flush(): Promise<void>;
     shutdown(): Promise<void>;
 };
+export type LlmScorer = {
+    /** Resolves true when the score was accepted. Never rejects. */
+    score(body: LlmScoreBody): Promise<boolean>;
+};
 /**
  * Construct a fail-open Langfuse client, or `null` when tracing is disabled or
  * misconfigured. Prefer the process-wide `getLlmTracingClient` in app code;
@@ -115,6 +150,7 @@ export type LlmEmitter = {
  */
 export declare function createLlmTracingClient(env?: EnvMap, options?: {
     emitterImpl?: LlmEmitter;
+    scorerImpl?: LlmScorer;
 }): LlmTracingClient | null;
 export declare function getLlmTracingClient(env?: EnvMap): LlmTracingClient | null;
 /** Flush the singleton if it exists. Never rejects. Hang off request/cycle ends. */

package/node_modules/@oxygen/shared/dist/langfuse.js

@@ -126,6 +126,17 @@ function boundJsonField(value) {
         preview: serialized.slice(0, MAX_JSON_FIELD_CHARS),
     };
 }
+// A score's `comment` is free text (a thumbs-down reason is user-authored and
+// unbounded) and the API types it as a STRING, so it cannot take
+// boundJsonField's `{truncated, preview}` envelope. It gets the same
+// MAX_JSON_FIELD_CHARS ceiling and the same "explicit marker, never a silent
+// clip" rule, with the marker counted INSIDE the cap so the bound holds.
+const COMMENT_TRUNCATION_MARKER = "…[truncated]";
+function boundComment(comment) {
+    if (comment.length <= MAX_JSON_FIELD_CHARS)
+        return comment;
+    return comment.slice(0, MAX_JSON_FIELD_CHARS - COMMENT_TRUNCATION_MARKER.length) + COMMENT_TRUNCATION_MARKER;
+}
 function compact(body) {
     const out = {};
     for (const [key, value] of Object.entries(body)) {
@@ -223,6 +234,65 @@ function createOtelEmitter(env, warn) {
         shutdown: () => init().then((h) => h?.processor.shutdown() ?? Promise.resolve()),
     };
 }
+/**
+ * The real scorer: one authenticated POST to the Langfuse scores API.
+ *
+ * `@langfuse/core` is imported LAZILY on first score for the same reason the
+ * OTel tree is — a runtime with tracing disabled (the packed CLI, every test)
+ * never pays for it.
+ *
+ * The API client's `environment` option is its BASE URL, not the Langfuse
+ * environment tag; the tag is the `environment` FIELD on the score body, and it
+ * is resolved from the same helper the span processor uses so a score lands in
+ * the same Langfuse environment as the trace it scores. OXYGEN always sets
+ * LANGFUSE_BASE_URL (the project is US-region and the EU host 401s these keys);
+ * the fallback is the SDK's documented default, which `@langfuse/core` itself
+ * does not supply.
+ */
+function createApiScorer(env, warn) {
+    let handle = null;
+    const init = () => {
+        handle ??= (async () => {
+            try {
+                const { LangfuseAPIClient } = await import("@langfuse/core");
+                const client = new LangfuseAPIClient({
+                    environment: env.LANGFUSE_BASE_URL?.trim() || "https://cloud.langfuse.com",
+                    username: env.LANGFUSE_PUBLIC_KEY,
+                    password: env.LANGFUSE_SECRET_KEY,
+                });
+                return client.scores;
+            }
+            catch (error) {
+                warn(error, { stage: "score_init" });
+                return null;
+            }
+        })();
+        return handle;
+    };
+    return {
+        score: async (body) => {
+            try {
+                const api = await init();
+                if (!api)
+                    return false;
+                await api.create(compact({
+                    id: body.id,
+                    traceId: body.traceId,
+                    name: body.name,
+                    value: body.value,
+                    dataType: body.dataType,
+                    comment: typeof body.comment === "string" ? boundComment(body.comment) : undefined,
+                    environment: resolveLlmTracingEnvironment(env),
+                }));
+                return true;
+            }
+            catch (error) {
+                warn(error, { stage: "score" });
+                return false;
+            }
+        },
+    };
+}
 /**
  * Construct a fail-open Langfuse client, or `null` when tracing is disabled or
  * misconfigured. Prefer the process-wide `getLlmTracingClient` in app code;
@@ -244,6 +314,7 @@ export function createLlmTracingClient(env = process.env, options) {
         });
     };
     const emitter = options?.emitterImpl ?? createOtelEmitter(env, warn);
+    const scorer = options?.scorerImpl ?? createApiScorer(env, warn);
     const guarded = (fn, stage) => {
         try {
             fn();
@@ -351,6 +422,18 @@ export function createLlmTracingClient(env = process.env, options) {
                 endTime: startTime,
             });
         }, "event"),
+        // Already fail-open inside the scorer; the extra catch is here so that a
+        // scorer which throws SYNCHRONOUSLY (a substituted one in a test, a future
+        // implementation) still cannot escape into a product write.
+        score: async (body) => {
+            try {
+                return await scorer.score(body);
+            }
+            catch (error) {
+                warn(error, { stage: "score" });
+                return false;
+            }
+        },
         // The "never rejects, bounded at ~5s" contract is the CLIENT's, so it is
         // enforced here rather than inside one emitter — an emitter that throws
         // synchronously or rejects must still not escape into product code.

package/node_modules/@oxygen/shared/dist/linkedin-quota-denial.d.ts

@@ -1,5 +1,5 @@
 /**
- * How a LinkedIn quota denial is read by the background jobs that hit it.
+ * How a LinkedIn/WhatsApp quota denial is read by the background jobs that hit it.
  *
  * The denial itself is raised by the chokepoint in
  * packages/integrations/src/linkedin-quota.ts; this module is the consumer half,

package/node_modules/@oxygen/shared/dist/linkedin-quota-denial.js

@@ -1,5 +1,5 @@
 /**
- * How a LinkedIn quota denial is read by the background jobs that hit it.
+ * How a LinkedIn/WhatsApp quota denial is read by the background jobs that hit it.
  *
  * The denial itself is raised by the chokepoint in
  * packages/integrations/src/linkedin-quota.ts; this module is the consumer half,
@@ -16,10 +16,21 @@
  */
 import { OxygenError } from "./cli-result.js";
 import { isRecord } from "./type-guards.js";
-// The two codes a denial is raised with. Either is a "come back later" signal,
-// not a broken caller: a daily cap / closed active window that reopens on its own
-// clock, or an account the status webhook will reactivate.
-const QUOTA_DENIED_CODES = new Set(["linkedin_rate_limited", "linkedin_account_unavailable"]);
+// The codes a denial is raised with. Each is a "come back later" signal, not a
+// broken caller: a daily cap / closed active window that reopens on its own clock,
+// or an account the status webhook will reactivate.
+//
+// The WhatsApp mirrors are here because the inbox backstop is shared across
+// networks: a WhatsApp daily-limit denial was reaching it, missing this set, and
+// so was logged as a failure AND never parked -- the same hot re-deny loop the
+// LinkedIn codes were added to stop. Both WhatsApp denials carry `resets_at`, so
+// the park lands on the real reset rather than the fallback below.
+const QUOTA_DENIED_CODES = new Set([
+    "linkedin_rate_limited",
+    "linkedin_account_unavailable",
+    "whatsapp_rate_limited",
+    "whatsapp_account_unavailable",
+]);
 /** Park length when a denial carries no usable `resets_at` hint. */
 const QUOTA_FALLBACK_BACKOFF_MS = 60 * 60 * 1000;
 /** Was this thrown error the quota chokepoint refusing the call? */

package/node_modules/@oxygen/shared/dist/user-capability-routing.js

@@ -1,4 +1,4 @@
-import { getCapabilityRouteMatch, inferCapabilityRoute, } from "./capability-discovery.js";
+import { getCapabilityRoute, getCapabilityRouteMatch, inferCapabilityRoute, } from "./capability-discovery.js";
 // Provider brands are intentionally not duplicated into the static capability
 // catalog. A short "connect <provider>" query would otherwise match Tables via
 // its relationship-oriented "connect" term. Correct that narrow ambiguity at
@@ -13,9 +13,30 @@ export function inferUserCapabilityRoute(query) {
     }
     return getCapabilityRouteMatch("connected-integrations") ?? route;
 }
+// The words that mean "this is Tables work, not a provider connection". Hand-typing
+// them drifted: the list covered table/row/column/dataset/join/relate but not csv,
+// import, enrich, waterfall, formula, lookup or score -- all of which the Tables card
+// itself claims. The measured cost was 11 queries ("connect my csv", "connect my
+// enrichment", "connect my formula") losing their Tables tools and being handed
+// oxygen_integrations_connect instead, on ALL THREE surfaces that call this wrapper.
+//
+// So derive from the card rather than restating it. `connect` is excluded because it
+// is the ambiguity itself -- it is a Tables intent term AND the verb this function
+// keys on, and leaving it in would make the guard reject every query the wrapper
+// exists to correct.
+const TABLES_INTENT_AMBIGUITY_TRIGGERS = new Set(["connect"]);
+function tablesIntentGuard() {
+    const terms = (getCapabilityRoute("tables")?.intentTerms ?? [])
+        .filter((term) => !TABLES_INTENT_AMBIGUITY_TRIGGERS.has(term))
+        .flatMap((term) => (term.includes(" ") ? [term] : [term, `${term}s`]))
+        .map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .sort((a, b) => b.length - a.length);
+    return new RegExp(`\\b(?:${terms.join("|")})\\b`);
+}
+const TABLES_INTENT_GUARD = tablesIntentGuard();
 function isSimpleProviderConnectionIntent(query) {
     const normalized = query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
-    if (/\b(table|tables|row|rows|column|columns|dataset|join|relationship|relate)\b/.test(normalized)) {
+    if (TABLES_INTENT_GUARD.test(normalized)) {
         return false;
     }
     if (/\b(integration|provider|oauth|byok|api key|connected account)\b/.test(normalized)) {

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.906.0";
+export declare const OXYGEN_VERSION = "1.917.5";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";
 export declare const SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION = "1.747.0";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.906.0";
+export const OXYGEN_VERSION = "1.917.5";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/node_modules/@oxygen/shared/package.json

@@ -141,6 +141,11 @@
       "import": "./dist/pricing-sheet.js",
       "default": "./dist/pricing-sheet.js"
     },
+    "./copilot-plan": {
+      "types": "./dist/copilot-plan.d.ts",
+      "import": "./dist/copilot-plan.js",
+      "default": "./dist/copilot-plan.js"
+    },
     "./copilot-journeys": {
       "types": "./dist/copilot-journeys.d.ts",
       "import": "./dist/copilot-journeys.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.906.0",
+  "version": "1.917.5",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -34,6 +34,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.1050.0",
     "@aws-sdk/s3-request-presigner": "3.1050.0",
+    "@langfuse/core": "^5.11.0",
     "@langfuse/otel": "^5.11.0",
     "@langfuse/tracing": "^5.11.0",
     "@opentelemetry/api": "1.9.1",