@oxygen-agent/cli 1.1014.1600 → 1.1014.1763

package/node_modules/@oxygen/shared/dist/sequence-lifecycle.js

@@ -1,5 +1,51 @@
-/** Every lifecycle a person reads: the stored statuses plus the derived `completed`. */
-export const SEQUENCE_LIFECYCLES = ["draft", "active", "completed", "paused", "archived"];
+/**
+ * Every lifecycle a person reads: the stored statuses plus the derived
+ * `scheduled` and `completed`.
+ */
+export const SEQUENCE_LIFECYCLES = ["draft", "scheduled", "active", "completed", "paused", "archived"];
+/** How far ahead a scheduled start may be set. */
+export const SEQUENCE_START_AT_MAX_DAYS = 30;
+const DAY_MS = 86_400_000;
+/**
+ * The stored scheduled start (`settings.start_at`) when it is still ahead of
+ * `now`, else null. A past, absent or unreadable value means the Sequence runs
+ * as soon as it is active.
+ */
+export function sequenceScheduledStartAt(settings, now = new Date()) {
+    const raw = settings?.start_at;
+    if (typeof raw !== "string")
+        return null;
+    const ms = Date.parse(raw);
+    return Number.isFinite(ms) && ms > now.getTime() ? new Date(ms) : null;
+}
+const ISO_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-](\d{2}):(\d{2}))$/;
+/**
+ * Read a requested scheduled start: an ISO 8601 timestamp with a timezone
+ * (`Z` or `±hh:mm`), in the future and at most {@link SEQUENCE_START_AT_MAX_DAYS}
+ * days ahead. Returns the canonical UTC form (`toISOString`) that is stored, so
+ * every stored value is one Postgres can cast.
+ */
+export function parseSequenceStartAt(value, now = new Date()) {
+    const shape = typeof value === "string" ? ISO_TIMESTAMP.exec(value.trim()) : null;
+    if (!shape) {
+        return { ok: false, message: "start_at must be an ISO 8601 timestamp with a timezone, e.g. 2026-11-02T09:00:00Z." };
+    }
+    const [, year, month, day, hour, minute, second, , offsetHour, offsetMinute] = shape;
+    const daysInMonth = new Date(Date.UTC(Number(year), Number(month), 0)).getUTCDate();
+    const ms = Date.parse(value);
+    if (Number(month) < 1 || Number(month) > 12 || Number(day) < 1 || Number(day) > daysInMonth
+        || Number(hour) > 23 || Number(minute) > 59 || Number(second ?? 0) > 59
+        || Number(offsetHour ?? 0) > 23 || Number(offsetMinute ?? 0) > 59
+        || !Number.isFinite(ms)) {
+        return { ok: false, message: "start_at is not a valid date and time." };
+    }
+    if (ms <= now.getTime())
+        return { ok: false, message: "start_at must be in the future." };
+    if (ms > now.getTime() + SEQUENCE_START_AT_MAX_DAYS * DAY_MS) {
+        return { ok: false, message: `start_at must be at most ${SEQUENCE_START_AT_MAX_DAYS} days ahead.` };
+    }
+    return { ok: true, startAt: new Date(ms).toISOString() };
+}
 /**
  * The lifecycle word a person reads for a Sequence.
  *
@@ -9,12 +55,19 @@ export const SEQUENCE_LIFECYCLES = ["draft", "active", "completed", "paused", "a
  * is the derived operational state; `drained` means every enrolled lead has
  * reached an end. An active Sequence in that state reads as completed.
  *
+ * An active Sequence whose `settings.start_at` is still ahead reads as
+ * scheduled: it was started, but the planner contacts nobody before then.
+ *
  * Derived on read and never stored: operational health is one derived
  * contract, not another lifecycle (docs/primitives/sequences.md, 2026-08-26).
  * Enrolling new leads makes the same Sequence read as active again with no
  * transition to undo. A paused Sequence stays paused, because someone decided
  * that and the decision still holds.
  */
-export function sequenceDisplayStatus(status, operationalState) {
-    return status === "active" && operationalState === "drained" ? "completed" : status;
+export function sequenceDisplayStatus(status, operationalState, settings, now = new Date()) {
+    if (status !== "active")
+        return status;
+    if (sequenceScheduledStartAt(settings, now))
+        return "scheduled";
+    return operationalState === "drained" ? "completed" : status;
 }

package/node_modules/@oxygen/shared/dist/sequence-template.d.ts

@@ -47,7 +47,24 @@ export type RenderTemplateOptions = {
      * derived from the template + values (still deterministic, not enrollment-scoped).
      */
     seed?: string;
+    /**
+     * `"html"` escapes each SUBSTITUTED value (`&`, `<`, `>`, `"`, `'`) for an HTML
+     * body; the template itself, its fallbacks and spintax options are authored
+     * markup and render untouched. Omitted: values substitute verbatim (text parts,
+     * subjects and the legacy body_html_template path).
+     */
+    escape?: "html";
 };
+/**
+ * Placeholders the email builder fills, never the renderer: the recipient's
+ * signed one-click unsubscribe link and their preference page. The renderer
+ * leaves `{{unsubscribe_url}}` / `{{preferences_url}}` exactly as written, and
+ * they are not row columns (templateColumnKeys skips them).
+ */
+export declare const RESERVED_EMAIL_PLACEHOLDERS: readonly ["unsubscribe_url", "preferences_url"];
+export type ReservedEmailPlaceholder = typeof RESERVED_EMAIL_PLACEHOLDERS[number];
+/** Escape text for an HTML body or a quoted attribute. */
+export declare function escapeHtmlText(value: string): string;
 /**
  * Deterministic, replayable FNV-1a hash → uint32. Stable across processes — the
  * single hash used by both spintax selection here and A/B variant assignment in

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

@@ -385,6 +385,14 @@ export type SequenceEmailSendStep = {
     body_template: string;
     /** Optional HTML body (B-W2): renders the send as multipart/alternative. Supports {{column}}. */
     body_html_template?: string;
+    /**
+     * A designed body stored as an email document (sending-domain Sequences):
+     * its revision supplies the HTML and text parts, rendered per recipient at
+     * delivery with HTML-escaped merge values. Without `revision` the step follows
+     * the document's current revision until the Sequence goes live, which pins it.
+     * Not combined with body_html_template; body_template may then stay empty.
+     */
+    body_document?: SequenceEmailBodyDocument;
     /** Static Cc / Bcc recipients (fixed addresses, not templated). */
     cc?: string[];
     bcc?: string[];
@@ -748,6 +756,39 @@ export type SequenceStep = SequenceLinkedInVisitProfileStep | SequenceLinkedInIn
 export type SequenceDefinition = {
     steps: SequenceStep[];
 };
+/** `body_document` on an email_send step: an email document id and, once pinned, its revision. */
+export type SequenceEmailBodyDocument = {
+    id: string;
+    revision?: number;
+};
+/** The email_send steps whose body is an email document, in flat step order. */
+export declare function sequenceBodyDocumentSteps(definition: {
+    steps?: readonly unknown[];
+} | null | undefined): Array<{
+    index: number;
+    stepId: string;
+    ref: SequenceEmailBodyDocument;
+}>;
+/**
+ * Where a step's content lives, for `sequences content get|set` on every surface:
+ * the email_send step by id, its document reference, and its plain bodies.
+ * Throws a fixed-copy OxygenError naming the step when it is not an email_send.
+ */
+export declare function sequenceContentStep(definition: {
+    steps?: readonly unknown[];
+} | null | undefined, stepId: string): {
+    index: number;
+    step: Record<string, unknown>;
+    bodyDocument: SequenceEmailBodyDocument | null;
+};
+/**
+ * The definition with one email_send step bodied by `documentId` (following its
+ * current revision), or null when the step already references exactly that.
+ * A document replaces the step's body_html_template.
+ */
+export declare function withSequenceStepBodyDocument<T extends {
+    steps: readonly unknown[];
+}>(definition: T, stepId: string, documentId: string): T | null;
 /** Which channel a step executes on, or null for channel-agnostic control steps. */
 export declare function sequenceStepChannel(step: SequenceStep): SequenceChannel | null;
 /** Distinct channels a sequence touches (drives the sequence's channels[] tag). */

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

@@ -472,6 +472,77 @@ export function sequenceLeadContacts(input) {
         phone: callPhoneFromRow(input.rowValues, phoneKey) !== null || whatsAppAttendeeIdFromRow(input.rowValues, phoneKey) !== null,
     };
 }
+/** The email_send steps whose body is an email document, in flat step order. */
+export function sequenceBodyDocumentSteps(definition) {
+    const out = [];
+    (definition?.steps ?? []).forEach((step, index) => {
+        if (!isRecord(step) || step.kind !== "email_send" || !isRecord(step.body_document))
+            return;
+        const id = step.body_document.id;
+        const revision = step.body_document.revision;
+        if (typeof id !== "string")
+            return;
+        out.push({ index, stepId: typeof step.id === "string" ? step.id : "", ref: { id, ...(typeof revision === "number" ? { revision } : {}) } });
+    });
+    return out;
+}
+/**
+ * Where a step's content lives, for `sequences content get|set` on every surface:
+ * the email_send step by id, its document reference, and its plain bodies.
+ * Throws a fixed-copy OxygenError naming the step when it is not an email_send.
+ */
+export function sequenceContentStep(definition, stepId) {
+    const steps = definition?.steps ?? [];
+    const index = steps.findIndex((step) => isRecord(step) && step.id === stepId);
+    const step = index === -1 ? null : steps[index];
+    if (!isRecord(step)) {
+        throw new OxygenError("sequence_step_not_found", "No step with that id in this sequence.", {
+            details: { step_id: stepId, step_ids: steps.filter(isRecord).map((entry) => entry.id) }, exitCode: 2,
+        });
+    }
+    if (step.kind !== "email_send") {
+        throw new OxygenError("sequence_step_not_email", "Content applies to an email_send step.", { details: { step_id: stepId, kind: step.kind }, exitCode: 2 });
+    }
+    const ref = sequenceBodyDocumentSteps({ steps: [step] })[0]?.ref ?? null;
+    return { index, step, bodyDocument: ref };
+}
+/**
+ * The definition with one email_send step bodied by `documentId` (following its
+ * current revision), or null when the step already references exactly that.
+ * A document replaces the step's body_html_template.
+ */
+export function withSequenceStepBodyDocument(definition, stepId, documentId) {
+    const { index, step, bodyDocument } = sequenceContentStep(definition, stepId);
+    if (bodyDocument && bodyDocument.id === documentId && bodyDocument.revision === undefined && step.body_html_template === undefined)
+        return null;
+    const { body_html_template: _html, ...rest } = step;
+    const steps = [...definition.steps];
+    steps[index] = { ...rest, body_document: { id: documentId } };
+    return { ...definition, steps };
+}
+const BODY_DOCUMENT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function normalizeBodyDocument(raw, path, issues) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (!isRecord(raw)) {
+        issues.push({ path, message: "must be an object { id, revision? }." });
+        return undefined;
+    }
+    const unknownKeys = Object.keys(raw).filter((key) => key !== "id" && key !== "revision");
+    if (unknownKeys.length > 0)
+        issues.push({ path, message: `unknown field(s): ${unknownKeys.join(", ")}; only id and revision.` });
+    if (typeof raw.id !== "string" || !BODY_DOCUMENT_UUID_RE.test(raw.id)) {
+        issues.push({ path: `${path}.id`, message: "must be an email document id." });
+        return undefined;
+    }
+    if (raw.revision === undefined || raw.revision === null)
+        return { id: raw.id.toLowerCase() };
+    if (typeof raw.revision !== "number" || !Number.isInteger(raw.revision) || raw.revision < 1) {
+        issues.push({ path: `${path}.revision`, message: "must be a positive integer." });
+        return undefined;
+    }
+    return { id: raw.id.toLowerCase(), revision: raw.revision };
+}
 const MAX_SEQUENCE_STEPS = 50;
 const MAX_TEMPLATE_LENGTH = 8_000;
 // The Premium ceiling, and only an authoring hint: the limit that actually
@@ -670,7 +741,9 @@ export function sequenceStepsMissingCopy(steps) {
                 if (sequenceInheritedEmailSubject(steps, index) === null) {
                     check(step, "subject_template", step.subject_template);
                 }
-                check(step, "body_template", step.body_template);
+                // A document-bodied step's copy is the document.
+                if (!step.body_document)
+                    check(step, "body_template", step.body_template);
                 break;
             case "email_reply":
                 check(step, "body_template", step.body_template);
@@ -1020,12 +1093,20 @@ raw, index, options, issues) {
             // instead of relying on an empty string being read the right way downstream.
             const subject = optionalTemplate(raw.subject_template, `${path}.subject_template`, MAX_TEMPLATE_LENGTH, issues);
             const threaded = !(subject ?? "").trim();
-            const body = requiredTemplate(raw.body_template, `${path}.body_template`, issues, options.draft === true);
+            const bodyDocument = normalizeBodyDocument(raw.body_document, `${path}.body_document`, issues);
+            // A document carries its own plain-text part, so body_template may stay
+            // empty (it remains the text fallback when set).
+            const body = requiredTemplate(raw.body_template ?? (bodyDocument ? "" : undefined), `${path}.body_template`, issues, options.draft === true || bodyDocument !== undefined);
             const bodyHtml = optionalTemplate(raw.body_html_template, `${path}.body_html_template`, MAX_TEMPLATE_LENGTH, issues);
+            if (bodyDocument && bodyHtml !== undefined && bodyHtml.trim()) {
+                issues.push({ path: `${path}.body_html_template`, message: "set body_document or body_html_template, not both." });
+            }
             // A threaded step has no subject to override, so its variants may only vary
             // the body — a subject-only variant then fails normalizeVariants' own
             // "must override at least one of" check rather than silently doing nothing.
-            const variants = normalizeVariants(raw.variants, `${path}.variants`, threaded ? ["body_template", "body_html_template"] : ["subject_template", "body_template", "body_html_template"], issues, options.draft === true);
+            // A document-bodied step's HTML is the document, so variants vary subject/text only.
+            const variantBodyFields = bodyDocument ? ["body_template"] : ["body_template", "body_html_template"];
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, threaded ? variantBodyFields : ["subject_template", ...variantBodyFields], issues, options.draft === true);
             const autoOptimize = normalizeAutoOptimize(raw.auto_optimize, `${path}.auto_optimize`, variants, options, issues);
             const cc = optionalEmailList(raw.cc, `${path}.cc`, issues);
             const bcc = optionalEmailList(raw.bcc, `${path}.bcc`, issues);
@@ -1047,6 +1128,7 @@ raw, index, options, issues) {
                 ...(threaded ? {} : { subject_template: subject }),
                 body_template: body ?? "",
                 ...(bodyHtml !== undefined ? { body_html_template: bodyHtml } : {}),
+                ...(bodyDocument ? { body_document: bodyDocument } : {}),
                 ...(cc ? { cc } : {}),
                 ...(bcc ? { bcc } : {}),
                 ...(variants ? { variants: variants } : {}),
@@ -1289,7 +1371,7 @@ const STEP_KIND_FIELDS = {
     like_post: ["reaction", "post_recency_days", "on_no_post"],
     comment_post: ["text_template", "ai_prompt", "post_recency_days", "on_no_post"],
     withdraw_invite: [],
-    email_send: ["subject_template", "body_template", "body_html_template", "cc", "bcc", "send_window", "variants", "auto_optimize"],
+    email_send: ["subject_template", "body_template", "body_html_template", "body_document", "cc", "bcc", "send_window", "variants", "auto_optimize"],
     email_reply: ["body_template", "body_html_template", "cc", "bcc", "send_window", "variants", "auto_optimize"],
     email_enroll: ["subsequence_id"],
     email_move: ["subsequence_id"],

package/node_modules/@oxygen/shared/dist/ses-identity-policy.d.ts

@@ -0,0 +1,19 @@
+/** OXYGEN's own sending and product domains: never claimable by a workspace. */
+export declare const RESERVED_SES_IDENTITY_SUFFIXES: readonly ["oxygen-agent.com"];
+/** An unverified claim lapses after this long, so a typo cannot hold a domain forever. */
+export declare const SES_IDENTITY_CLAIM_TTL_MS: number;
+/** Lower-cased hostname with at least two labels, or null when it is not one. */
+export declare function normalizeSesIdentity(value: unknown): string | null;
+/** True when `identity` is `parent` or one of its subdomains. */
+export declare function isSesIdentityWithin(identity: string, parent: string): boolean;
+/** True when either identity covers the other: the same name, or one is a subdomain of the other. */
+export declare function sesIdentitiesOverlap(a: string, b: string): boolean;
+export declare function isReservedSesIdentity(identity: string): boolean;
+/**
+ * The identity's parents down to two labels, nearest first: `a.news.example.com`
+ * gives `news.example.com`, `example.com`. With the identity itself these are
+ * the registry rows a claim must not collide with on the way up.
+ */
+export declare function sesIdentityParents(identity: string): string[];
+/** The SES tenant name for a workspace: `oxy_` plus its UUID without dashes (36 of SES's 64 characters). */
+export declare function sesTenantName(organizationId: string): string;

package/node_modules/@oxygen/shared/dist/ses-identity-policy.js

@@ -0,0 +1,54 @@
+// Who may own an SES identity on OXYGEN's one shared SES account. SES knows an
+// identity once per account and lets a verified domain send for its subdomains,
+// so ownership is decided here and in the control-db registry before any SES
+// call: one workspace per identity, never one under or over another workspace's
+// identity, and never OXYGEN's own domains.
+/** OXYGEN's own sending and product domains: never claimable by a workspace. */
+export const RESERVED_SES_IDENTITY_SUFFIXES = ["oxygen-agent.com"];
+/** An unverified claim lapses after this long, so a typo cannot hold a domain forever. */
+export const SES_IDENTITY_CLAIM_TTL_MS = 72 * 60 * 60 * 1000;
+const LABEL_RE = /^(?!-)[a-z0-9-]{1,63}(?<!-)$/;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Lower-cased hostname with at least two labels, or null when it is not one. */
+export function normalizeSesIdentity(value) {
+    if (typeof value !== "string")
+        return null;
+    const identity = value.trim().toLowerCase().replace(/\.$/, "");
+    if (identity.length === 0 || identity.length > 253)
+        return null;
+    const labels = identity.split(".");
+    if (labels.length < 2 || !labels.every((label) => LABEL_RE.test(label)))
+        return null;
+    if (/^[0-9]+$/.test(labels[labels.length - 1]))
+        return null;
+    return identity;
+}
+/** True when `identity` is `parent` or one of its subdomains. */
+export function isSesIdentityWithin(identity, parent) {
+    return identity === parent || identity.endsWith(`.${parent}`);
+}
+/** True when either identity covers the other: the same name, or one is a subdomain of the other. */
+export function sesIdentitiesOverlap(a, b) {
+    return isSesIdentityWithin(a, b) || isSesIdentityWithin(b, a);
+}
+export function isReservedSesIdentity(identity) {
+    return RESERVED_SES_IDENTITY_SUFFIXES.some((suffix) => sesIdentitiesOverlap(identity, suffix));
+}
+/**
+ * The identity's parents down to two labels, nearest first: `a.news.example.com`
+ * gives `news.example.com`, `example.com`. With the identity itself these are
+ * the registry rows a claim must not collide with on the way up.
+ */
+export function sesIdentityParents(identity) {
+    const labels = identity.split(".");
+    const parents = [];
+    for (let index = 1; index <= labels.length - 2; index += 1)
+        parents.push(labels.slice(index).join("."));
+    return parents;
+}
+/** The SES tenant name for a workspace: `oxy_` plus its UUID without dashes (36 of SES's 64 characters). */
+export function sesTenantName(organizationId) {
+    if (!UUID_RE.test(organizationId))
+        throw new Error("sesTenantName needs an organization UUID");
+    return `oxy_${organizationId.toLowerCase().replaceAll("-", "")}`;
+}

package/node_modules/@oxygen/shared/dist/skill-play-routing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Which feature-skill play a GTM ask matches, from each play's own title and
+ * trigger phrases (generated from the play catalog, never a second list).
+ *
+ * A capability route names the skill that owns an ask; without the play file the
+ * agent planned from general knowledge and skipped OXYGEN's defaults (Oxygent
+ * suite, 2026-10-21: oxygen_skills_get called 0 times in 8 runs). The match is
+ * deliberately strict: the ask must hold three quarters (and at least three) of
+ * one trigger phrase's content words, an adjacent pair of them included, and a
+ * tie between plays names none.
+ */
+export type SkillPlayMatch = {
+    skill: string;
+    slug: string;
+    file: string;
+};
+export declare const SKILL_PLAY_TRIGGERS: readonly {
+    skill: string;
+    slug: string;
+    phrases: readonly string[];
+}[];
+export declare function matchSkillPlay(query: string): SkillPlayMatch | null;

package/node_modules/@oxygen/shared/dist/skill-play-routing.js

@@ -0,0 +1,75 @@
+import { SKILL_PLAY_TRIGGERS_GENERATED } from "./skill-plays.generated.js";
+export const SKILL_PLAY_TRIGGERS = SKILL_PLAY_TRIGGERS_GENERATED;
+const STOPWORDS = new Set([
+    "a", "about", "across", "all", "an", "and", "any", "are", "as", "at", "be", "before", "by", "can", "d", "do", "does",
+    "every", "for", "from", "get", "give", "going", "how", "i", "i'm", "in", "into", "is", "it", "it's", "its", "just",
+    "let", "ll", "me", "my", "of", "on", "one", "or", "our", "s", "should", "so", "some", "that", "the", "their", "them",
+    "then", "these", "they", "this", "those", "to", "up", "us", "want", "we", "what", "when", "which", "who", "why",
+    "will", "with", "would", "you", "your",
+]);
+function stem(word) {
+    if (word.length > 4 && word.endsWith("ies"))
+        return `${word.slice(0, -3)}y`;
+    if (word.length > 3 && word.endsWith("s") && !word.endsWith("ss"))
+        return word.slice(0, -1);
+    return word;
+}
+function contentWords(text) {
+    return text
+        .toLowerCase()
+        .replace(/[’]/g, "'")
+        .split(/[^a-z0-9/']+/)
+        .map((word) => word.replace(/^[/']+|[/']+$/g, ""))
+        .filter((word) => word.length > 0 && !STOPWORDS.has(word))
+        .map(stem);
+}
+function wordPairs(words) {
+    const pairs = new Set();
+    for (let i = 1; i < words.length; i += 1)
+        pairs.add(`${words[i - 1]} ${words[i]}`);
+    return pairs;
+}
+const PLAY_PHRASES = SKILL_PLAY_TRIGGERS.map((play) => ({
+    play,
+    phrases: play.phrases.map((phrase) => {
+        const words = contentWords(phrase);
+        return { words: new Set(words), pairs: wordPairs(words) };
+    }),
+}));
+/** An ask must hold at least this many of one phrase's words... */
+const MIN_SHARED_WORDS = 3;
+/** ...and this share of them, one adjacent pair included. */
+const MIN_PHRASE_COVERAGE = 0.75;
+export function matchSkillPlay(query) {
+    const askedWords = contentWords(query);
+    const asked = new Set(askedWords);
+    const askedPairs = wordPairs(askedWords);
+    if (askedPairs.size === 0)
+        return null;
+    let best = null;
+    let tied = false;
+    for (const { play, phrases } of PLAY_PHRASES) {
+        let score = 0;
+        for (const { words, pairs } of phrases) {
+            let shared = 0;
+            for (const word of words)
+                if (asked.has(word))
+                    shared += 1;
+            if (shared < MIN_SHARED_WORDS || shared / words.size < MIN_PHRASE_COVERAGE)
+                continue;
+            if (![...pairs].some((pair) => askedPairs.has(pair)))
+                continue;
+            score = Math.max(score, shared / words.size + shared / 100);
+        }
+        if (score === 0)
+            continue;
+        if (!best || score > best.score) {
+            best = { skill: play.skill, slug: play.slug, score };
+            tied = false;
+        }
+        else if (score === best.score) {
+            tied = true;
+        }
+    }
+    return best && !tied ? { skill: best.skill, slug: best.slug, file: `plays/${best.slug}.md` } : null;
+}

package/node_modules/@oxygen/shared/dist/skill-plays.generated.d.ts

@@ -0,0 +1,5 @@
+export declare const SKILL_PLAY_TRIGGERS_GENERATED: readonly {
+    skill: string;
+    slug: string;
+    phrases: readonly string[];
+}[];