@oxygen-agent/cli 1.336.5 → 1.346.5

package/node_modules/@oxygen/shared/dist/custom-http-safety.d.ts

@@ -15,4 +15,36 @@ export declare function assertCustomHttpResolvedHostAllowed(input: {
     resolveHostname?: CustomHttpResolveHostname;
 }): Promise<CustomHttpResolvedAddress[]>;
 export declare function normalizeCustomHttpUrlHost(hostname: string): string;
+export type PinnedHostLookupEntry = {
+    address: string;
+    family: number;
+};
+export type PinnedHostLookup = (hostname: string, options: {
+    all?: boolean;
+    family?: number;
+} | undefined, callback: (error: NodeJS.ErrnoException | null, address?: string | PinnedHostLookupEntry[], family?: number) => void) => void;
+/**
+ * Build the `connect.lookup` for a dispatcher pinned to guard-validated
+ * addresses (DNS-rebinding TOCTOU closure).
+ *
+ * Node's dns.lookup callback contract has TWO conventions and the pinned lookup
+ * must honor BOTH: a plain lookup gets `(err, address, family)`, while an
+ * `{all: true}` lookup — which undici's connect path always issues when
+ * autoSelectFamily is available (Node >= 20) — gets `(err, [{address, family}])`.
+ * `@types/node` types `net.LookupFunction` scalar-only, so a scalar-only
+ * implementation typechecks and then fails EVERY pinned fetch at runtime with
+ * `ERR_INVALID_IP_ADDRESS: Invalid IP address: undefined` (the 2026-07-15
+ * custom_http outage). The regression tests exercise a real socket through a
+ * real undici Agent precisely because the compiler cannot catch this.
+ *
+ * All validated addresses are returned (not just the first) so the runtime can
+ * fall back across records, sorted IPv4-first: some runtimes (Vercel serverless
+ * functions) have no IPv6 egress, and autoSelectFamily attempts addresses in
+ * the order given.
+ */
+export declare function createPinnedHostLookup(input: {
+    pinnedHost: string;
+    addresses: readonly CustomHttpResolvedAddress[];
+    mismatchMessage: string;
+}): PinnedHostLookup;
 export declare function isBlockedCustomHttpHost(host: string): boolean;

package/node_modules/@oxygen/shared/dist/custom-http-safety.js

@@ -1,5 +1,6 @@
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
+import { describeErrorWithCauses } from "./error-redaction.js";
 export class CustomHttpUrlSafetyError extends Error {
     reason;
     details;
@@ -41,7 +42,9 @@ export async function assertCustomHttpResolvedHostAllowed(input) {
     catch (error) {
         throw new CustomHttpUrlSafetyError("dns_lookup_failed", "Custom HTTP URL host could not be resolved.", {
             host,
-            reason: error instanceof Error ? error.message : String(error),
+            // Keep the DNS error code (ENOTFOUND/EAI_AGAIN/...) — `message` alone is
+            // often the unactionable "fetch failed"-style wrapper.
+            reason: describeErrorWithCauses(error),
         });
     }
     if (addresses.length === 0) {
@@ -63,6 +66,54 @@ export function normalizeCustomHttpUrlHost(hostname) {
     const host = hostname.toLowerCase().replace(/\.+$/, "");
     return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
 }
+/**
+ * Build the `connect.lookup` for a dispatcher pinned to guard-validated
+ * addresses (DNS-rebinding TOCTOU closure).
+ *
+ * Node's dns.lookup callback contract has TWO conventions and the pinned lookup
+ * must honor BOTH: a plain lookup gets `(err, address, family)`, while an
+ * `{all: true}` lookup — which undici's connect path always issues when
+ * autoSelectFamily is available (Node >= 20) — gets `(err, [{address, family}])`.
+ * `@types/node` types `net.LookupFunction` scalar-only, so a scalar-only
+ * implementation typechecks and then fails EVERY pinned fetch at runtime with
+ * `ERR_INVALID_IP_ADDRESS: Invalid IP address: undefined` (the 2026-07-15
+ * custom_http outage). The regression tests exercise a real socket through a
+ * real undici Agent precisely because the compiler cannot catch this.
+ *
+ * All validated addresses are returned (not just the first) so the runtime can
+ * fall back across records, sorted IPv4-first: some runtimes (Vercel serverless
+ * functions) have no IPv6 egress, and autoSelectFamily attempts addresses in
+ * the order given.
+ */
+export function createPinnedHostLookup(input) {
+    const pinnedHost = normalizeCustomHttpUrlHost(input.pinnedHost);
+    const entries = input.addresses
+        .map((entry) => ({ address: entry.address, family: entry.family ?? isIP(entry.address) }))
+        .filter((entry) => entry.family === 4 || entry.family === 6)
+        .sort((a, b) => a.family - b.family);
+    return (hostname, options, callback) => {
+        if (normalizeCustomHttpUrlHost(hostname) !== pinnedHost) {
+            const error = new Error(input.mismatchMessage);
+            error.code = "ERR_OXYGEN_PINNED_LOOKUP_HOST_MISMATCH";
+            callback(error);
+            return;
+        }
+        const family = options?.family === 4 || options?.family === 6 ? options.family : null;
+        const matching = family === null ? entries : entries.filter((entry) => entry.family === family);
+        const first = matching[0];
+        if (!first) {
+            const error = new Error(`No pinned address available for host "${hostname}".`);
+            error.code = "ERR_OXYGEN_PINNED_LOOKUP_NO_ADDRESS";
+            callback(error);
+            return;
+        }
+        if (options?.all) {
+            callback(null, matching);
+            return;
+        }
+        callback(null, first.address, first.family);
+    };
+}
 export function isBlockedCustomHttpHost(host) {
     return host === "localhost"
         || host.endsWith(".localhost")

package/node_modules/@oxygen/shared/dist/error-redaction.d.ts

@@ -78,3 +78,18 @@ export declare function readWorkflowStepFailure(error: unknown): WorkflowStepFai
  */
 export declare const AUTOMATION_ACTIONS_EXCEEDED_ERROR_CODE = "automation_actions_exceeded";
 export declare function isAutomationUsageQuotaError(error: unknown): boolean;
+/**
+ * Node network primitives bury the actionable failure in `error.cause`: undici's
+ * fetch rejects with a bare TypeError "fetch failed" and puts the real
+ * ENOTFOUND/ECONNREFUSED/ERR_INVALID_IP_ADDRESS underneath. Recording only
+ * `error.message` made the Appsaavy custom_http outage (2026-07-15) undiagnosable
+ * from operation events — these helpers exist so catch sites can persist the
+ * whole chain. Callers owning secrets must still redact each message.
+ */
+export type ErrorCauseEntry = {
+    name: string;
+    code: string | null;
+    message: string;
+};
+export declare function errorCauseChain(error: unknown, maxDepth?: number): ErrorCauseEntry[];
+export declare function describeErrorWithCauses(error: unknown, maxDepth?: number): string;

package/node_modules/@oxygen/shared/dist/error-redaction.js

@@ -215,6 +215,42 @@ export function isAutomationUsageQuotaError(error) {
         && typeof error === "object"
         && error.code === AUTOMATION_ACTIONS_EXCEEDED_ERROR_CODE;
 }
+const MAX_CAUSE_DEPTH = 4;
+const MAX_CAUSE_MESSAGE_LENGTH = 200;
+export function errorCauseChain(error, maxDepth = MAX_CAUSE_DEPTH) {
+    const chain = [];
+    const seen = new Set();
+    let current = error;
+    while (current !== null && current !== undefined && chain.length < maxDepth && !seen.has(current)) {
+        seen.add(current);
+        chain.push(describeCauseEntry(current));
+        current = current instanceof Error || isRecord(current) ? current.cause : undefined;
+    }
+    return chain;
+}
+export function describeErrorWithCauses(error, maxDepth = MAX_CAUSE_DEPTH) {
+    return errorCauseChain(error, maxDepth)
+        .map((entry) => (entry.code ? `${entry.code}: ${entry.message}` : entry.message))
+        .join(" <- ");
+}
+function describeCauseEntry(value) {
+    if (value instanceof Error) {
+        const code = value.code;
+        return {
+            name: value.name,
+            code: typeof code === "string" ? code : null,
+            message: truncate(value.message, MAX_CAUSE_MESSAGE_LENGTH),
+        };
+    }
+    if (isRecord(value)) {
+        return {
+            name: typeof value.name === "string" ? value.name : "object",
+            code: typeof value.code === "string" ? value.code : null,
+            message: truncate(typeof value.message === "string" ? value.message : JSON.stringify(value) ?? "", MAX_CAUSE_MESSAGE_LENGTH),
+        };
+    }
+    return { name: typeof value, code: null, message: truncate(String(value), MAX_CAUSE_MESSAGE_LENGTH) };
+}
 function truncate(value, maxLength) {
     return value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
 }

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

@@ -25,10 +25,13 @@ export * from "./networks.js";
 export * from "./recipes.js";
 export * from "./sequence-template.js";
 export * from "./sequences.js";
+export * from "./suppression-entries.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
+export * from "./schedule-label.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
+export * from "./tags.js";
 export * from "./telemetry.js";
 export * from "./tenant-database-secret.js";
 export * from "./timing.js";

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

@@ -25,10 +25,13 @@ export * from "./networks.js";
 export * from "./recipes.js";
 export * from "./sequence-template.js";
 export * from "./sequences.js";
+export * from "./suppression-entries.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
+export * from "./schedule-label.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
+export * from "./tags.js";
 export * from "./telemetry.js";
 export * from "./tenant-database-secret.js";
 export * from "./timing.js";

package/node_modules/@oxygen/shared/dist/schedule-label.d.ts

@@ -0,0 +1 @@
+export declare function humanizeCronSchedule(cron: string): string | null;

package/node_modules/@oxygen/shared/dist/schedule-label.js

@@ -0,0 +1,157 @@
+// Human-readable labels for the common cron shapes OXYGEN schedules actually
+// use ("Every 5 minutes", "Daily at 10:00", "Mon at 09:30"). Returns null for
+// anything exotic — callers MUST fall back to the raw cron string
+// (`humanizeCronSchedule(cron) ?? cron`) and keep the raw expression available
+// as secondary text/tooltip. Timezone is rendered by callers as a separate
+// suffix; it is never folded into the label because cron fields are already
+// expressed in the trigger's own timezone.
+//
+// Dependency-free on purpose: consumed by web, CLI, and the MCP widgets
+// (packages/mcp-server depends only on @oxygen/shared).
+const DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const MINUTE_RANGE = { min: 0, max: 59 };
+const HOUR_RANGE = { min: 0, max: 23 };
+const DAY_OF_MONTH_RANGE = { min: 1, max: 31 };
+const MONTH_RANGE = { min: 1, max: 12 };
+const DAY_OF_WEEK_RANGE = { min: 0, max: 7 };
+// Expand one cron field to its sorted concrete values, or null when invalid.
+// Same grammar as estimateCronRunsPer30Days: *, N, N-M, with optional /step,
+// comma-joined; dow 7 normalizes to 0 (Sunday).
+function expandCronField(field, range) {
+    const values = new Set();
+    for (const part of field.split(",")) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            return null;
+        const match = trimmed.match(/^(\*|\d+(?:-\d+)?)(?:\/(\d+))?$/);
+        if (!match)
+            return null;
+        const rangePart = match[1];
+        const stepPart = match[2];
+        if (!rangePart)
+            return null;
+        const step = stepPart ? Number(stepPart) : 1;
+        if (!Number.isInteger(step) || step <= 0)
+            return null;
+        let start = range.min;
+        let end = range.max;
+        if (rangePart !== "*") {
+            const [startRaw, endRaw] = rangePart.split("-");
+            start = Number(startRaw);
+            end = endRaw === undefined ? start : Number(endRaw);
+        }
+        if (!Number.isInteger(start)
+            || !Number.isInteger(end)
+            || start < range.min
+            || end > range.max
+            || end < start) {
+            return null;
+        }
+        for (let value = start; value <= end; value += step) {
+            const normalized = range.max === 7 && value === 7 ? 0 : value;
+            values.add(normalized);
+        }
+    }
+    return [...values].sort((a, b) => a - b);
+}
+function coversFullRange(values, range) {
+    return values.length === range.max - range.min + 1
+        // dow spans 0-7 but 7 aliases to 0, so 7 distinct values are "every day".
+        || (range.max === 7 && values.length === 7);
+}
+// A set like {0, g, 2g, …} covering the field via a uniform gap g (g > 1).
+function uniformStep(values, rangeSize) {
+    if (values.length < 2 || values[0] !== 0)
+        return null;
+    if (rangeSize % values.length !== 0)
+        return null;
+    const gap = rangeSize / values.length;
+    for (let i = 0; i < values.length; i += 1) {
+        if (values[i] !== i * gap)
+            return null;
+    }
+    return gap;
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+function timeOfDay(hour, minute) {
+    return `${pad2(hour)}:${pad2(minute)}`;
+}
+// Mon-first display order (cron's 0 is Sunday).
+function dayNames(days) {
+    return days
+        .slice()
+        .sort((a, b) => ((a + 6) % 7) - ((b + 6) % 7))
+        .map((day) => DAY_NAMES[day])
+        .join(", ");
+}
+export function humanizeCronSchedule(cron) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return null;
+    const [minuteField, hourField, dayOfMonthField, monthField, dayOfWeekField] = fields;
+    const minutes = expandCronField(minuteField, MINUTE_RANGE);
+    const hours = expandCronField(hourField, HOUR_RANGE);
+    const daysOfMonth = expandCronField(dayOfMonthField, DAY_OF_MONTH_RANGE);
+    const months = expandCronField(monthField, MONTH_RANGE);
+    const daysOfWeek = expandCronField(dayOfWeekField, DAY_OF_WEEK_RANGE);
+    if (!minutes || !hours || !daysOfMonth || !months || !daysOfWeek)
+        return null;
+    // Month-restricted schedules read poorly as one-liners — raw cron is clearer.
+    if (!coversFullRange(months, MONTH_RANGE))
+        return null;
+    const everyDayOfMonth = coversFullRange(daysOfMonth, DAY_OF_MONTH_RANGE);
+    const everyDayOfWeek = coversFullRange(daysOfWeek, DAY_OF_WEEK_RANGE);
+    const everyHour = coversFullRange(hours, HOUR_RANGE);
+    const everyMinute = coversFullRange(minutes, MINUTE_RANGE);
+    // Sub-hourly cadences: "Every minute" / "Every N minutes".
+    if (everyHour && everyDayOfMonth && everyDayOfWeek) {
+        if (everyMinute)
+            return "Every minute";
+        const minuteGap = uniformStep(minutes, 60);
+        if (minuteGap !== null)
+            return `Every ${minuteGap} minutes`;
+        if (minutes.length === 1) {
+            const minute = minutes[0];
+            return minute === 0 ? "Hourly" : `Hourly at :${pad2(minute)}`;
+        }
+        return null;
+    }
+    if (minutes.length !== 1)
+        return null;
+    const minute = minutes[0];
+    // Multi-hour cadences: "Every 6 hours" (at :MM when the minute is offset).
+    if (everyDayOfMonth && everyDayOfWeek) {
+        const hourGap = uniformStep(hours, 24);
+        if (hourGap !== null && hours.length > 1) {
+            return minute === 0
+                ? `Every ${hourGap} hours`
+                : `Every ${hourGap} hours at :${pad2(minute)}`;
+        }
+        // A short list of fixed times: "Daily at 09:00, 17:00".
+        if (hours.length >= 2 && hours.length <= 3) {
+            return `Daily at ${hours.map((hour) => timeOfDay(hour, minute)).join(", ")}`;
+        }
+    }
+    if (hours.length !== 1)
+        return null;
+    const time = timeOfDay(hours[0], minute);
+    if (everyDayOfMonth) {
+        if (everyDayOfWeek)
+            return `Daily at ${time}`;
+        const dowKey = daysOfWeek.join(",");
+        if (dowKey === "1,2,3,4,5")
+            return `Weekdays at ${time}`;
+        if (dowKey === "0,6")
+            return `Weekends at ${time}`;
+        if (daysOfWeek.length <= 3)
+            return `${dayNames(daysOfWeek)} at ${time}`;
+        return null;
+    }
+    // Restricted day-of-month: only the single-day monthly shape stays readable.
+    if (everyDayOfWeek && daysOfMonth.length === 1) {
+        return `Monthly on day ${daysOfMonth[0]} at ${time}`;
+    }
+    return null;
+}

package/node_modules/@oxygen/shared/dist/select-options.d.ts

@@ -3,6 +3,7 @@ export type TagColor = (typeof TAG_COLORS)[number];
 export declare const DEFAULT_TAG_COLOR: TagColor;
 export declare function isTagColor(value: unknown): value is TagColor;
 export declare function tagColorForIndex(index: number): TagColor;
+export declare function tagColorForLabel(label: string): TagColor;
 export declare const SELECT_COLUMN_SEMANTICS: readonly ["select", "single_select", "multi_select", "tags", "status"];
 export type SelectColumnSemantic = (typeof SELECT_COLUMN_SEMANTICS)[number];
 export declare function isSelectColumnSemantic(semanticType: string | null | undefined): boolean;

package/node_modules/@oxygen/shared/dist/select-options.js

@@ -27,6 +27,15 @@ export function tagColorForIndex(index) {
     const palette = TAG_COLORS.filter((color) => color !== "gray");
     return palette[Math.abs(index) % palette.length] ?? DEFAULT_TAG_COLOR;
 }
+// Deterministic color for a free-form label (workspace tags): same tag, same
+// color on every surface, with no stored color to sync.
+export function tagColorForLabel(label) {
+    let hash = 0;
+    for (let index = 0; index < label.length; index += 1) {
+        hash = (hash * 31 + label.charCodeAt(index)) | 0;
+    }
+    return tagColorForIndex(Math.abs(hash));
+}
 // Semantic types (the column's `semanticType`) that present a fixed option set.
 // `select`/`status` are single-value; `multi_select`/`tags` are array-valued.
 // `single_select` is accepted as an alias of `select`.

package/node_modules/@oxygen/shared/dist/suppression-entries.d.ts

@@ -0,0 +1,29 @@
+export type SuppressionEntryKind = "email" | "domain" | "linkedin" | "invalid";
+export type ClassifiedSuppressionEntry = {
+    kind: SuppressionEntryKind;
+    /** The ledger key to store: canonical profile URL / verbatim URN / lowercased email or domain. */
+    key: string;
+    /** The original entry as pasted (trimmed), echoed back for rejection reporting. */
+    entry: string;
+};
+/**
+ * A LinkedIn member id as Unipile surfaces it (e.g. "ACoAADXaTD4B…"): the "AC"
+ * prefix plus base64url payload. Anchored and length-bounded so a short word that
+ * happens to start with "AC" never lands on the contact ledger; the charset has no
+ * dot or slash, so a URN can never collide with the domain or URL branches.
+ */
+export declare const LINKEDIN_MEMBER_URN_PATTERN: RegExp;
+/**
+ * Classify one pasted entry by shape. Order matters:
+ *   1. LinkedIn profile URL (any scheme/www/pub form) -> linkedin, keyed by the
+ *      canonical https://www.linkedin.com/in/<handle> form the sequencer enrolls on.
+ *   2. Contains "@" -> email (lowercased).
+ *   3. LinkedIn member URN -> linkedin, keyed verbatim (opaque + case-sensitive,
+ *      matching normalizeLeadProviderId's trim-only contract).
+ *   4. Any other URL-shaped string -> invalid. A non-profile linkedin.com link
+ *      (Sales Navigator, company page) or a random website URL is NOT a domain
+ *      block — classifying it as one used to store garbage whole-domain blocks.
+ *   5. Dotted, whitespace-free -> domain (lowercased).
+ *   6. Everything else -> invalid.
+ */
+export declare function classifySuppressionEntry(entry: string): ClassifiedSuppressionEntry;

package/node_modules/@oxygen/shared/dist/suppression-entries.js

@@ -0,0 +1,40 @@
+import { looksLikeUrlIdentifier, normalizeLinkedinProfileUrl } from "./linkedin-url.js";
+/**
+ * A LinkedIn member id as Unipile surfaces it (e.g. "ACoAADXaTD4B…"): the "AC"
+ * prefix plus base64url payload. Anchored and length-bounded so a short word that
+ * happens to start with "AC" never lands on the contact ledger; the charset has no
+ * dot or slash, so a URN can never collide with the domain or URL branches.
+ */
+export const LINKEDIN_MEMBER_URN_PATTERN = /^AC[A-Za-z0-9_-]{8,}$/;
+/**
+ * Classify one pasted entry by shape. Order matters:
+ *   1. LinkedIn profile URL (any scheme/www/pub form) -> linkedin, keyed by the
+ *      canonical https://www.linkedin.com/in/<handle> form the sequencer enrolls on.
+ *   2. Contains "@" -> email (lowercased).
+ *   3. LinkedIn member URN -> linkedin, keyed verbatim (opaque + case-sensitive,
+ *      matching normalizeLeadProviderId's trim-only contract).
+ *   4. Any other URL-shaped string -> invalid. A non-profile linkedin.com link
+ *      (Sales Navigator, company page) or a random website URL is NOT a domain
+ *      block — classifying it as one used to store garbage whole-domain blocks.
+ *   5. Dotted, whitespace-free -> domain (lowercased).
+ *   6. Everything else -> invalid.
+ */
+export function classifySuppressionEntry(entry) {
+    const trimmed = typeof entry === "string" ? entry.trim() : "";
+    if (!trimmed)
+        return { kind: "invalid", key: "", entry: trimmed };
+    const profile = normalizeLinkedinProfileUrl(trimmed);
+    if (profile)
+        return { kind: "linkedin", key: profile.normalized, entry: trimmed };
+    if (trimmed.includes("@"))
+        return { kind: "email", key: trimmed.toLowerCase(), entry: trimmed };
+    if (LINKEDIN_MEMBER_URN_PATTERN.test(trimmed))
+        return { kind: "linkedin", key: trimmed, entry: trimmed };
+    if (looksLikeUrlIdentifier(trimmed) || trimmed.includes("/")) {
+        return { kind: "invalid", key: "", entry: trimmed };
+    }
+    if (trimmed.includes(".") && !/\s/.test(trimmed)) {
+        return { kind: "domain", key: trimmed.toLowerCase(), entry: trimmed };
+    }
+    return { kind: "invalid", key: "", entry: trimmed };
+}

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

@@ -0,0 +1,14 @@
+/** Primitive kinds that participate in the workspace tag union today. */
+export declare const TAG_KINDS: readonly ["knowledge_page", "sequence", "table", "workflow", "recipe"];
+export type TagKind = (typeof TAG_KINDS)[number];
+export declare function isTagKind(value: unknown): value is TagKind;
+/** Hard cap per tagged item — matches the wiki's long-standing limit. */
+export declare const MAX_TAGS_PER_ITEM = 50;
+/**
+ * Normalize a raw tag array: lowercase, trim, drop non-strings/empties, dedupe,
+ * cap at {@link MAX_TAGS_PER_ITEM}. Callers that must reject non-arrays with a
+ * typed error (the wiki does) validate the shape first and delegate here.
+ */
+export declare function normalizeTagList(values: readonly unknown[]): string[];
+/** Lenient variant: `undefined`/`null`/non-arrays normalize to `[]`. */
+export declare function normalizeTags(value: unknown): string[];

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

@@ -0,0 +1,33 @@
+// Workspace tags (Tags primitive, ADR 0010): free-form lowercase labels shared
+// across primitives so campaign knowledge links across stores — a sequence, its
+// campaign-learnings wiki page, the source table, and the workflow that feeds it
+// can all carry `q3-outbound`. Storage stays per-store (`tags text[]` + GIN,
+// the 0009/0025 pattern); this module is the one vocabulary: which kinds
+// participate, and how a tag list is normalized before it is written anywhere.
+/** Primitive kinds that participate in the workspace tag union today. */
+export const TAG_KINDS = [
+    "knowledge_page",
+    "sequence",
+    "table",
+    "workflow",
+    "recipe",
+];
+export function isTagKind(value) {
+    return typeof value === "string" && TAG_KINDS.includes(value);
+}
+/** Hard cap per tagged item — matches the wiki's long-standing limit. */
+export const MAX_TAGS_PER_ITEM = 50;
+/**
+ * Normalize a raw tag array: lowercase, trim, drop non-strings/empties, dedupe,
+ * cap at {@link MAX_TAGS_PER_ITEM}. Callers that must reject non-arrays with a
+ * typed error (the wiki does) validate the shape first and delegate here.
+ */
+export function normalizeTagList(values) {
+    return Array.from(new Set(values.map((tag) => (typeof tag === "string" ? tag.trim().toLowerCase() : "")).filter(Boolean))).slice(0, MAX_TAGS_PER_ITEM);
+}
+/** Lenient variant: `undefined`/`null`/non-arrays normalize to `[]`. */
+export function normalizeTags(value) {
+    if (!Array.isArray(value))
+        return [];
+    return normalizeTagList(value);
+}

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

@@ -1,3 +1,3 @@
-export declare const OXYGEN_VERSION = "1.336.5";
+export declare const OXYGEN_VERSION = "1.346.5";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";

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

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.336.5";
+export const OXYGEN_VERSION = "1.346.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/dist/workflow-status-change.d.ts

@@ -31,7 +31,7 @@ export type WorkflowStatusChangeActor = {
     label: string;
 };
 export type WorkflowStatusChange = {
-    status: "active" | "disabled";
+    status: "active" | "disabled" | "archived";
     /** ISO-8601 UTC. */
     at: string;
     source: WorkflowStatusChangeSource;

package/node_modules/@oxygen/shared/dist/workflow-status-change.js

@@ -62,7 +62,7 @@ export function parseWorkflowStatusChange(raw) {
         return null;
     const record = raw;
     const status = record.status;
-    if (status !== "active" && status !== "disabled")
+    if (status !== "active" && status !== "disabled" && status !== "archived")
         return null;
     const at = record.at;
     if (typeof at !== "string" || Number.isNaN(Date.parse(at)))
@@ -110,7 +110,11 @@ export function formatWorkflowStatusChangeTimestamp(at) {
  * "who turned this off?" is identical wherever the customer looks.
  */
 export function describeWorkflowStatusChange(change) {
-    const verb = change.status === "disabled" ? "Disabled" : "Enabled";
+    const verb = change.status === "disabled"
+        ? "Disabled"
+        : change.status === "archived"
+            ? "Archived"
+            : "Enabled";
     const when = formatWorkflowStatusChangeTimestamp(change.at);
     // Auto-pause is not a "who" — Oxygen paused it, and the reason carries the why.
     const by = change.source === "auto_pause"

package/node_modules/@oxygen/workflows/dist/usage-estimate.d.ts

@@ -23,6 +23,13 @@ export declare function assessCronCadenceViability(input: {
     includedActions: number | null;
     overageEnabled: boolean;
 }): CronCadenceAssessment | null;
+export type CronAggressiveness = {
+    level: "aggressive" | "very_aggressive";
+    approxIntervalMinutes: number;
+    runsPer30Days: number;
+    message: string;
+};
+export declare function assessCronAggressiveness(cron: string | null | undefined): CronAggressiveness | null;
 export type ObservedAutomationUsageProjection = {
     runSample: number;
     actionsPerRunAvg: number;

package/node_modules/@oxygen/workflows/dist/usage-estimate.js

@@ -164,6 +164,41 @@ export function assessCronCadenceViability(input) {
         verdict: floorActionsPer30Days > input.includedActions ? "impossible" : "fits",
     };
 }
+// Warn (never block) below this cadence; the billing gate above stays the
+// only hard stop. 15-minute syncs are common and intentional — they pass.
+const AGGRESSIVE_INTERVAL_MINUTES = 15;
+// Near-continuous schedules are almost always a mistake.
+const VERY_AGGRESSIVE_INTERVAL_MINUTES = 2;
+// Pure frequency check, independent of plan/allowance: flags schedules that
+// fire more often than every 15 minutes so users confirm the cadence is
+// intentional before it burns automation actions. Null = nothing to warn
+// about (interval >= 15 min, on-demand, or unparseable cron).
+export function assessCronAggressiveness(cron) {
+    if (!cron)
+        return null;
+    const runsPer30Days = estimateCronRunsPer30Days(cron);
+    if (runsPer30Days === null || runsPer30Days <= 0)
+        return null;
+    const approxIntervalMinutes = Math.max(1, Math.round(MINUTES_PER_30_DAYS / runsPer30Days));
+    if (approxIntervalMinutes >= AGGRESSIVE_INTERVAL_MINUTES)
+        return null;
+    const runs = runsPer30Days.toLocaleString("en-US");
+    const interval = approxIntervalMinutes === 1 ? "minute" : `${approxIntervalMinutes} minutes`;
+    if (approxIntervalMinutes <= VERY_AGGRESSIVE_INTERVAL_MINUTES) {
+        return {
+            level: "very_aggressive",
+            approxIntervalMinutes,
+            runsPer30Days,
+            message: `Runs about every ${interval} (~${runs} runs/30d). This is almost always unintentionally fast and can exhaust the monthly automation allowance within days — strongly consider slowing it down.`,
+        };
+    }
+    return {
+        level: "aggressive",
+        approxIntervalMinutes,
+        runsPer30Days,
+        message: `Runs about every ${interval} (~${runs} runs/30d). Schedules faster than every 15 minutes burn automation actions quickly — make sure this cadence is intentional.`,
+    };
+}
 export function projectObservedAutomationUsage(input) {
     const billedRuns = input.perRunActions.filter((actions) => Number.isFinite(actions) && actions > 0);
     if (billedRuns.length === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.336.5",
+  "version": "1.346.5",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",