@oxygen-agent/cli 1.1014.1696 → 1.1014.1763

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

@@ -1204,6 +1204,61 @@ const SPECS = [
     }),
 ];
 export const FORMULA_FUNCTION_REGISTRY = new Map(SPECS.map((entry) => [entry.name, entry]));
+/**
+ * Names authors bring from spreadsheets, SQL and JavaScript, mapped to the
+ * function here that does that job. Keys are normalized (lowercase, no `_`).
+ */
+const FORMULA_FUNCTION_ALIASES = {
+    tonumber: "number", parseint: "number", parsefloat: "number", int: "number", float: "number", value: "number", cast: "number", numeric: "number",
+    tostring: "text", str: "text", string: "text",
+    regexpreplace: "regex_replace", regexreplace: "regex_replace", regexpextract: "regex_extract", regexpsubstr: "regex_extract",
+    regexextract: "regex_extract", regexpmatch: "regex_match", regexplike: "regex_match", regexmatch: "regex_match", match: "regex_match",
+    splitpart: "split", indexof: "contains", includes: "contains", instr: "contains", strpos: "contains", position: "contains", find: "contains", search: "contains",
+    substr: "substring", mid: "substring", len: "length", charlength: "length", lengthb: "length",
+    tolowercase: "lower", lcase: "lower", touppercase: "upper", ucase: "upper", proper: "title_case", initcap: "title_case",
+    iif: "if", ifs: "switch", case: "switch", ifnull: "coalesce", nvl: "coalesce", isnull: "is_blank", isblank: "is_blank", isempty: "is_blank",
+    datediff: "date_diff", dateadd: "date_add", datevalue: "date_parse", todate: "date_parse", formatdate: "date_format", textjoin: "join",
+    startswith: "starts_with", endswith: "ends_with", average: "avg", mean: "avg", size: "count", domain: "email_domain",
+};
+/**
+ * The refusal for a call to a function the formula language does not have:
+ * the likely intended function (`did_you_mean`) and every supported name, so the
+ * author corrects the call without another lookup.
+ */
+export function unsupportedFormulaFunctionError(name) {
+    const suggestions = suggestFormulaFunctions(name);
+    const supported = [...FORMULA_FUNCTION_REGISTRY.keys()].sort();
+    return formulaExpressionError(suggestions.length > 0
+        ? `Unsupported formula function ${name}; did you mean ${suggestions.join(" or ")}?`
+        : `Unsupported formula function ${name}; use one of details.supported_functions.`, {
+        function: name,
+        ...(suggestions.length > 0 ? { did_you_mean: suggestions } : {}),
+        supported_functions: supported,
+        next_step: "Read signatures and examples with `oxygen formulas functions` (MCP oxygen_formulas_list).",
+    });
+}
+function suggestFormulaFunctions(name) {
+    const key = name.toLowerCase().replace(/_/g, "");
+    const alias = FORMULA_FUNCTION_ALIASES[key];
+    if (alias)
+        return [alias];
+    const ranked = [...FORMULA_FUNCTION_REGISTRY.keys()]
+        .map((candidate) => ({ candidate, distance: editDistance(key, candidate.replace(/_/g, "")) }))
+        .filter((entry) => entry.distance <= Math.max(1, Math.floor(key.length / 4)))
+        .sort((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate));
+    return ranked.slice(0, 2).map((entry) => entry.candidate);
+}
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
 export const FORMULA_FUNCTION_CATEGORIES = [
     "logic",
     "string",

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

@@ -64,14 +64,14 @@ export declare const CREDITS_PER_USD = 100;
  */
 export declare function creditTopupUsdCentsPer100(options?: RepricingOptions): number;
 export declare const CREDIT_TOPUP_MIN_CREDITS = 800;
-export declare const CREDIT_TOPUP_MAX_CREDITS = 100000;
+export declare const CREDIT_TOPUP_MAX_CREDITS = 769200;
 export declare const CREDIT_TOPUP_STEP_CREDITS = 100;
 export declare const CREDIT_TOPUP_DEFAULT_CREDITS = 2000;
 export declare function isValidCreditTopupCredits(credits: number): boolean;
 /**
  * A shortfall expressed as an amount `oxygen billing topup` will actually SELL:
  * rounded up onto CREDIT_TOPUP_STEP_CREDITS (100) and clamped into the purchasable
- * [CREDIT_TOPUP_MIN_CREDITS .. CREDIT_TOPUP_MAX_CREDITS] band (800 .. 100,000). A next_action (or an alert email) naming a number the
+ * [CREDIT_TOPUP_MIN_CREDITS .. CREDIT_TOPUP_MAX_CREDITS] band. A next_action (or an alert email) naming a number the
  * top-up route refuses with `invalid_topup_amount` is not a next action, it is a
  * second dead end during the incident it exists to end.
  *

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

@@ -63,13 +63,11 @@ export const CREDITS_PER_USD = SNAPSHOT_CREDITS_PER_USD;
 export function creditTopupUsdCentsPer100(options = {}) {
     return repricedValue(TOPUP_RATE_REPRICING, options);
 }
-// On-demand purchases run from 800 to 100,000 credits in any 100-credit
-// increment ($10.00 to $1,250 at $1.25 per 100; $10.40 to $1,300 at $1.30). The
-// ceiling is a single-checkout guard rail, not a spend cap: a workspace that
-// needs more tops up again (purchased credits never expire). The range and step
-// are unchanged by the 2026-09 repricing (proposal P-7).
+// On-demand purchases run in 100-credit increments up to $10,000 before tax.
+// At $1.30 per 100, the largest whole increment is 769,200 credits ($9,999.60).
+// The ceiling is per checkout; purchased credits never expire.
 export const CREDIT_TOPUP_MIN_CREDITS = 800;
-export const CREDIT_TOPUP_MAX_CREDITS = 100_000;
+export const CREDIT_TOPUP_MAX_CREDITS = 769_200;
 export const CREDIT_TOPUP_STEP_CREDITS = 100;
 export const CREDIT_TOPUP_DEFAULT_CREDITS = 2_000;
 export function isValidCreditTopupCredits(credits) {
@@ -81,7 +79,7 @@ export function isValidCreditTopupCredits(credits) {
 /**
  * A shortfall expressed as an amount `oxygen billing topup` will actually SELL:
  * rounded up onto CREDIT_TOPUP_STEP_CREDITS (100) and clamped into the purchasable
- * [CREDIT_TOPUP_MIN_CREDITS .. CREDIT_TOPUP_MAX_CREDITS] band (800 .. 100,000). A next_action (or an alert email) naming a number the
+ * [CREDIT_TOPUP_MIN_CREDITS .. CREDIT_TOPUP_MAX_CREDITS] band. A next_action (or an alert email) naming a number the
  * top-up route refuses with `invalid_topup_amount` is not a next action, it is a
  * second dead end during the incident it exists to end.
  *

package/node_modules/@oxygen/shared/dist/bulk-email-pacing.d.ts

@@ -0,0 +1,105 @@
+export declare const BULK_EMAIL_PACING: {
+    /** A send this small always goes at once, even for a brand-new workspace. */
+    readonly quickEmails: 200;
+    /** Days of warm-up after the workspace's first newsletter send. */
+    readonly warmupDays: 30;
+    /** Look-back window for the proven volume. */
+    readonly provenDays: 60;
+    /** A send counts towards the proven volume this long after it went out, once its bounces have come in. */
+    readonly provenSettleHours: 24;
+    /** Sends still queued, and sends of this many past hours, count against a new send. */
+    readonly recentHours: 24;
+    /** Multiplier on the proven volume: `first` on warm-up day 1, rising linearly to `last` on the last day and after. */
+    readonly growth: {
+        readonly first: 2;
+        readonly last: 5;
+    };
+    /** A send over the allowance is spread over at least this many hours … */
+    readonly minSpreadHours: 4;
+    /** … plus this many for each doubling past the allowance … */
+    readonly hoursPerDoubling: 4;
+    /** … and never more than this. */
+    readonly maxSpreadHours: 72;
+};
+/**
+ * Workspace-level bounce and complaint limits, each with a minimum count so one
+ * complaint or a few bounces never stop a workspace. `pause` stops the workspace
+ * until someone resumes it; `block` is abuse and only staff unblock it. The rates
+ * match the release slice (`email-delivery.ts`): 0.3% is Gmail's spam line, 5%
+ * where SES opens a review.
+ */
+export declare const BULK_EMAIL_WORKSPACE_LIMITS: {
+    readonly pause: {
+        readonly bounceRate: 0.02;
+        readonly minBounces: 5;
+        readonly complaintRate: 0.0008;
+        readonly minComplaints: 2;
+    };
+    readonly block: {
+        readonly bounceRate: 0.05;
+        readonly minBounces: 10;
+        readonly complaintRate: 0.003;
+        readonly minComplaints: 3;
+    };
+};
+export type BulkEmailWorkspaceVerdict = "ok" | "pause" | "block";
+/** The workspace's verdict for a window of sends, hard bounces and complaints. */
+export declare function bulkEmailWorkspaceVerdict(input: {
+    sends: number;
+    hardBounces: number;
+    complaints: number;
+}): BulkEmailWorkspaceVerdict;
+/** Warm-up day (1-based) on `now` for a workspace whose first send was at `firstSendAt`; day 1 before any send. */
+export declare function bulkEmailWarmupDay(firstSendAt: Date | null, now: Date): number;
+/** The proven-volume multiplier on a warm-up day. */
+export declare function bulkEmailGrowth(warmupDay: number): number;
+/** Emails that may go out at once: the larger of the quick allowance and the proven volume times the day's growth. */
+export declare function bulkEmailImmediateAllowance(input: {
+    provenVolume: number;
+    warmupDay: number;
+}): number;
+/**
+ * Hours a send is spread over: 0 when the send, together with what the workspace
+ * still has queued and sent in the recent window, fits the allowance; otherwise
+ * the minimum spread plus one step per doubling past the allowance, capped.
+ */
+export declare function bulkEmailSpreadHours(input: {
+    emails: number;
+    queued: number;
+    recentlySent: number;
+    allowance: number;
+}): number;
+/** When the `index`-th of `count` emails of a spread send may leave: the first at once, the last at the end, the rest evenly between. */
+export declare function bulkEmailSpreadOffsetMs(index: number, count: number, spreadHours: number): number;
+/**
+ * Share of the account's bulk 24-hour quota (what is left after the
+ * transactional reserve) that one workspace may reserve in a day, so no single
+ * workspace can drain the account for everyone else.
+ */
+export declare const BULK_EMAIL_WORKSPACE_QUOTA_SHARE = 0.25;
+/**
+ * Share of the account's bulk send rate one workspace may use in a second. A
+ * half leaves the other half to everyone else, so a second workspace always
+ * progresses while one large send runs, and a lone workspace still sends at
+ * half the account's speed (its spread schedule, not the rate, sets its pace).
+ */
+export declare const BULK_EMAIL_WORKSPACE_RATE_SHARE = 0.5;
+/**
+ * Newsletter emails a workspace may reserve today: the smallest of its plan's
+ * daily cap, the staff override (which only lowers) and its share of the
+ * account's bulk 24-hour quota. No account snapshot is zero (fails closed).
+ */
+export declare function bulkEmailWorkspaceDailyAllowance(input: {
+    planDailyCap: number;
+    allowanceOverride: number | null;
+    accountMax24HourSend: number | null;
+}): number;
+/**
+ * Bulk sends a second, account-wide and per workspace: the account limit is
+ * 80% of MaxSendRate (the rest is for transactional mail), the workspace limit
+ * its share of that, both at least 1.
+ */
+export declare function bulkEmailSendRateLimits(maxSendRate: number): {
+    account: number;
+    workspace: number;
+};

package/node_modules/@oxygen/shared/dist/bulk-email-pacing.js

@@ -0,0 +1,125 @@
+// How fast one workspace's newsletter mail leaves the shared SES account, and when
+// its bounces and complaints pause or block it. Volume is earned: a workspace sends
+// at once only up to a multiple of the largest send it has already made cleanly,
+// and a bigger send is spread over hours, so a bad list shows in the first hours
+// instead of in every inbox. Clean-room after mailcheap.ai's documented behaviour
+// (AGPL; design reference only, no code taken).
+import { SES_BULK_RATE_FRACTION, SES_TRANSACTIONAL_RESERVE_FRACTION } from "./email-delivery.js";
+export const BULK_EMAIL_PACING = {
+    /** A send this small always goes at once, even for a brand-new workspace. */
+    quickEmails: 200,
+    /** Days of warm-up after the workspace's first newsletter send. */
+    warmupDays: 30,
+    /** Look-back window for the proven volume. */
+    provenDays: 60,
+    /** A send counts towards the proven volume this long after it went out, once its bounces have come in. */
+    provenSettleHours: 24,
+    /** Sends still queued, and sends of this many past hours, count against a new send. */
+    recentHours: 24,
+    /** Multiplier on the proven volume: `first` on warm-up day 1, rising linearly to `last` on the last day and after. */
+    growth: { first: 2, last: 5 },
+    /** A send over the allowance is spread over at least this many hours … */
+    minSpreadHours: 4,
+    /** … plus this many for each doubling past the allowance … */
+    hoursPerDoubling: 4,
+    /** … and never more than this. */
+    maxSpreadHours: 72,
+};
+/**
+ * Workspace-level bounce and complaint limits, each with a minimum count so one
+ * complaint or a few bounces never stop a workspace. `pause` stops the workspace
+ * until someone resumes it; `block` is abuse and only staff unblock it. The rates
+ * match the release slice (`email-delivery.ts`): 0.3% is Gmail's spam line, 5%
+ * where SES opens a review.
+ */
+export const BULK_EMAIL_WORKSPACE_LIMITS = {
+    pause: { bounceRate: 0.02, minBounces: 5, complaintRate: 0.0008, minComplaints: 2 },
+    block: { bounceRate: 0.05, minBounces: 10, complaintRate: 0.003, minComplaints: 3 },
+};
+/** The workspace's verdict for a window of sends, hard bounces and complaints. */
+export function bulkEmailWorkspaceVerdict(input) {
+    const sends = Math.max(0, input.sends);
+    if (sends === 0)
+        return "ok";
+    const over = (level) => (input.hardBounces >= level.minBounces && input.hardBounces / sends >= level.bounceRate)
+        || (input.complaints >= level.minComplaints && input.complaints / sends >= level.complaintRate);
+    if (over(BULK_EMAIL_WORKSPACE_LIMITS.block))
+        return "block";
+    if (over(BULK_EMAIL_WORKSPACE_LIMITS.pause))
+        return "pause";
+    return "ok";
+}
+/** Warm-up day (1-based) on `now` for a workspace whose first send was at `firstSendAt`; day 1 before any send. */
+export function bulkEmailWarmupDay(firstSendAt, now) {
+    if (!firstSendAt)
+        return 1;
+    return Math.max(1, Math.floor((now.getTime() - firstSendAt.getTime()) / 86_400_000) + 1);
+}
+/** The proven-volume multiplier on a warm-up day. */
+export function bulkEmailGrowth(warmupDay) {
+    const { warmupDays, growth } = BULK_EMAIL_PACING;
+    const day = Math.min(Math.max(1, Math.floor(warmupDay)), warmupDays);
+    return growth.first + ((growth.last - growth.first) * (day - 1)) / (warmupDays - 1);
+}
+/** Emails that may go out at once: the larger of the quick allowance and the proven volume times the day's growth. */
+export function bulkEmailImmediateAllowance(input) {
+    const proven = Math.max(0, Math.floor(input.provenVolume));
+    return Math.max(BULK_EMAIL_PACING.quickEmails, Math.floor(proven * bulkEmailGrowth(input.warmupDay)));
+}
+/**
+ * Hours a send is spread over: 0 when the send, together with what the workspace
+ * still has queued and sent in the recent window, fits the allowance; otherwise
+ * the minimum spread plus one step per doubling past the allowance, capped.
+ */
+export function bulkEmailSpreadHours(input) {
+    const total = Math.max(0, input.emails) + Math.max(0, input.queued) + Math.max(0, input.recentlySent);
+    const allowance = Math.max(1, input.allowance);
+    if (total <= allowance)
+        return 0;
+    const { minSpreadHours, hoursPerDoubling, maxSpreadHours } = BULK_EMAIL_PACING;
+    const doublings = Math.floor(Math.log2(total / allowance));
+    return Math.min(maxSpreadHours, minSpreadHours + hoursPerDoubling * doublings);
+}
+/** When the `index`-th of `count` emails of a spread send may leave: the first at once, the last at the end, the rest evenly between. */
+export function bulkEmailSpreadOffsetMs(index, count, spreadHours) {
+    if (spreadHours <= 0 || count <= 1)
+        return 0;
+    const clamped = Math.min(Math.max(0, index), count - 1);
+    return Math.round((clamped / (count - 1)) * spreadHours * 3_600_000);
+}
+/**
+ * Share of the account's bulk 24-hour quota (what is left after the
+ * transactional reserve) that one workspace may reserve in a day, so no single
+ * workspace can drain the account for everyone else.
+ */
+export const BULK_EMAIL_WORKSPACE_QUOTA_SHARE = 0.25;
+/**
+ * Share of the account's bulk send rate one workspace may use in a second. A
+ * half leaves the other half to everyone else, so a second workspace always
+ * progresses while one large send runs, and a lone workspace still sends at
+ * half the account's speed (its spread schedule, not the rate, sets its pace).
+ */
+export const BULK_EMAIL_WORKSPACE_RATE_SHARE = 0.5;
+/**
+ * Newsletter emails a workspace may reserve today: the smallest of its plan's
+ * daily cap, the staff override (which only lowers) and its share of the
+ * account's bulk 24-hour quota. No account snapshot is zero (fails closed).
+ */
+export function bulkEmailWorkspaceDailyAllowance(input) {
+    if (input.accountMax24HourSend === null || !Number.isFinite(input.accountMax24HourSend))
+        return 0;
+    const accountShare = Math.floor(Math.max(0, input.accountMax24HourSend) * (1 - SES_TRANSACTIONAL_RESERVE_FRACTION) * BULK_EMAIL_WORKSPACE_QUOTA_SHARE);
+    const caps = [Math.max(0, Math.floor(input.planDailyCap)), accountShare];
+    if (input.allowanceOverride !== null && Number.isFinite(input.allowanceOverride))
+        caps.push(Math.max(0, Math.floor(input.allowanceOverride)));
+    return Math.min(...caps);
+}
+/**
+ * Bulk sends a second, account-wide and per workspace: the account limit is
+ * 80% of MaxSendRate (the rest is for transactional mail), the workspace limit
+ * its share of that, both at least 1.
+ */
+export function bulkEmailSendRateLimits(maxSendRate) {
+    const account = Math.max(1, Math.floor((Number.isFinite(maxSendRate) ? Math.max(0, maxSendRate) : 0) * SES_BULK_RATE_FRACTION));
+    return { account, workspace: Math.max(1, Math.ceil(account * BULK_EMAIL_WORKSPACE_RATE_SHARE)) };
+}

package/node_modules/@oxygen/shared/dist/capability-discovery.d.ts

@@ -1,5 +1,7 @@
 import { type EnrichmentIntentTaxonomyEntry } from "./enrichment-intents.js";
 import { type RecipePrimitive } from "./recipes.js";
+import { type SkillPlayMatch } from "./skill-play-routing.js";
+export { matchSkillPlay, SKILL_PLAY_TRIGGERS, type SkillPlayMatch } from "./skill-play-routing.js";
 export type CapabilityLayer = "Control" | "Knowledge" | "Data" | "Action" | "External";
 export type CapabilityPosture = "read_only" | "workspace_write" | "paid_read" | "external_write" | "mixed";
 export type CapabilityRouteCard = {
@@ -55,6 +57,11 @@ export type CapabilityRouteMatch = {
         /** The same read as an MCP call, served on MCP in place of `exactCommand`. */
         exactMcpCall: CapabilityMcpCall;
     };
+    /**
+     * The feature-skill play the ask matches (skill-play-routing.ts), present only
+     * when the route's card lists that skill: the exact file to open before planning.
+     */
+    play?: SkillPlayMatch;
 };
 export type PrimitiveRouteMatch = CapabilityRouteMatch & {
     card: PrimitiveRouteCard;
@@ -202,6 +209,26 @@ export declare const CAPABILITY_ROUTE_MCP_CALLS: {
             product_url: string;
         };
     };
+    publishingPostDraft: () => {
+        tool: string;
+        arguments: {
+            content_text: string;
+            publish_at: string;
+            status: string;
+        };
+    };
+    signalCapture: () => {
+        tool: string;
+        arguments: {
+            object: string;
+            row_id: string;
+            activity_type: string;
+            direction: string;
+            summary: string;
+            occurred_at: string;
+            mode: string;
+        };
+    };
     publishingFirstComment: () => {
         tool: string;
         arguments: {
@@ -286,6 +313,8 @@ export declare const CAPABILITY_ROUTE_MCP_CALLS: {
 /** The catalogue row's `enrichment catalog --intent <id>` as an MCP call. */
 export declare function catalogueIntentMcpCall(intentId: string): CapabilityMcpCall;
 /** A post's first comment is set with the post; `publishing posts update` takes the same flag. */
+export declare const POST_DRAFT_COMMAND = "oxygen publishing posts create --draft --publish-at <iso> --text \"<post>\" --json";
+export declare const SIGNAL_CAPTURE_COMMAND = "oxygen crm activity log people <rowId or email> --type website_visit --direction inbound --summary \"<what they viewed>\" --live --json";
 export declare const PUBLISHING_FIRST_COMMENT_COMMAND = "oxygen publishing posts create --publish-at <iso> --sender <sender_id> --text \"<post>\" --first-comment \"<comment, e.g. the link>\" --json";
 export declare const COMPANY_PAGE_FOLLOWERS_COMMAND = "oxygen tables followers check --company <linkedin company page URL> --records <n> --json";
 /** The exact `companies search plan` invocation for the url_recovery intent. */