@oxygen-agent/cli 1.1014.1225 → 1.1014.1341

package/node_modules/@oxygen/shared/dist/hubspot-engagements.js

@@ -0,0 +1,107 @@
+// HubSpot engagements onto the Records timeline (Network Mining S8c, DEV-only).
+//
+// Calls, meetings, notes, emails and tasks map onto existing activity kinds.
+// Every imported row is `metadata.historical: true`: it is history the workspace
+// lived before OXYGEN, so funnel and meeting analytics leave it out, and it
+// replays no reply effect (no stop, suppression or DNC change).
+export const HUBSPOT_ENGAGEMENT_TYPES = ["calls", "meetings", "notes", "emails", "tasks"];
+/** Properties each list page asks for. Email bodies are read only as an excerpt. */
+export const HUBSPOT_ENGAGEMENT_PROPERTIES = {
+    calls: ["hs_timestamp", "hs_call_title", "hs_call_body", "hs_call_direction", "hs_call_disposition", "hs_call_duration", "hs_call_status"],
+    meetings: ["hs_timestamp", "hs_meeting_title", "hs_meeting_body", "hs_meeting_start_time", "hs_meeting_end_time", "hs_meeting_outcome"],
+    notes: ["hs_timestamp", "hs_note_body"],
+    emails: ["hs_timestamp", "hs_email_subject", "hs_email_text", "hs_email_direction", "hs_email_status"],
+    tasks: ["hs_timestamp", "hs_task_subject", "hs_task_body", "hs_task_status", "hs_task_priority", "hs_task_type"],
+};
+/** The records an engagement may link to: HubSpot association type → registered external object. */
+export const HUBSPOT_ENGAGEMENT_ASSOCIATIONS = ["contacts", "companies"];
+const MAX_SUMMARY_CHARS = 300;
+const MAX_BODY_CHARS = 1_000;
+function text(value) {
+    if (typeof value !== "string")
+        return "";
+    // HubSpot rich-text bodies are HTML; the timeline stores plain text.
+    return value.replace(/<[^>]*>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+}
+function clip(value, max) {
+    return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
+function iso(value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return null;
+    const raw = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+    const date = new Date(raw);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function associationIds(raw, kind) {
+    const associations = raw.associations && typeof raw.associations === "object" ? raw.associations : {};
+    const block = associations[kind] && typeof associations[kind] === "object" ? associations[kind] : {};
+    const results = Array.isArray(block.results) ? block.results : [];
+    const ids = results.map((entry) => entry && typeof entry === "object" ? String(entry.id ?? "") : "").filter(Boolean);
+    return [...new Set(ids)];
+}
+/**
+ * One HubSpot engagement object (`crm/v3/objects/<type>` with associations)
+ * as a timeline activity, or null when it has no id or no timestamp.
+ */
+export function normalizeHubspotEngagement(type, raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const entry = raw;
+    const id = typeof entry.id === "string" || typeof entry.id === "number" ? String(entry.id) : "";
+    const props = entry.properties && typeof entry.properties === "object" ? entry.properties : {};
+    const occurredAt = iso(props.hs_timestamp) ?? iso(props.hs_meeting_start_time) ?? iso(entry.createdAt);
+    if (!id || !occurredAt)
+        return null;
+    const kept = {};
+    for (const key of HUBSPOT_ENGAGEMENT_PROPERTIES[type]) {
+        if (key === "hs_email_text" || key.endsWith("_body"))
+            continue;
+        const value = props[key];
+        if (typeof value === "string" && value.trim())
+            kept[key] = clip(value.trim(), 200);
+    }
+    const base = { hubspotType: type, hubspotId: id, occurredAt, contactIds: associationIds(entry, "contacts"), companyIds: associationIds(entry, "companies"), properties: kept };
+    if (type === "calls") {
+        const direction = String(props.hs_call_direction ?? "").toUpperCase();
+        return {
+            ...base, activityType: "call", channel: "phone",
+            direction: direction === "INBOUND" ? "inbound" : direction === "OUTBOUND" ? "outbound" : null,
+            summary: clip(text(props.hs_call_title) || "Call", MAX_SUMMARY_CHARS),
+            body: clip(text(props.hs_call_body), MAX_BODY_CHARS) || null,
+        };
+    }
+    if (type === "meetings") {
+        // Only HubSpot's own outcome says a meeting happened; anything else stays booked.
+        const outcome = String(props.hs_meeting_outcome ?? "").toUpperCase();
+        return {
+            ...base,
+            activityType: outcome === "NO_SHOW" ? "no_show" : outcome === "COMPLETED" ? "meeting_completed" : "meeting_booked",
+            channel: "meeting", direction: null,
+            summary: clip(text(props.hs_meeting_title) || "Meeting", MAX_SUMMARY_CHARS),
+            body: clip(text(props.hs_meeting_body), MAX_BODY_CHARS) || null,
+        };
+    }
+    if (type === "notes") {
+        const body = text(props.hs_note_body);
+        return {
+            ...base, activityType: "note", channel: null, direction: "internal",
+            summary: clip(body || "Note", MAX_SUMMARY_CHARS), body: clip(body, MAX_BODY_CHARS) || null,
+        };
+    }
+    if (type === "emails") {
+        const direction = String(props.hs_email_direction ?? "").toUpperCase();
+        const inbound = direction === "INCOMING_EMAIL";
+        return {
+            ...base, activityType: inbound ? "email_received" : "email_sent", channel: "email", direction: inbound ? "inbound" : "outbound",
+            summary: clip(text(props.hs_email_subject) || "Email", MAX_SUMMARY_CHARS),
+            body: clip(text(props.hs_email_text), MAX_BODY_CHARS) || null,
+        };
+    }
+    const status = String(props.hs_task_status ?? "").toUpperCase();
+    return {
+        ...base, activityType: status === "COMPLETED" ? "task_completed" : "task_created", channel: null, direction: "internal",
+        summary: clip(text(props.hs_task_subject) || "Task", MAX_SUMMARY_CHARS),
+        body: clip(text(props.hs_task_body), MAX_BODY_CHARS) || null,
+    };
+}

package/node_modules/@oxygen/shared/dist/integration-secrets.d.ts

@@ -0,0 +1,19 @@
+export declare function encryptSecret(plaintext: string, secretKey?: string): string;
+export declare function decryptSecret(ciphertext: string, secretKey?: string): string;
+export declare function isIntegrationSecretDecryptError(error: unknown): boolean;
+/**
+ * Stable, server-secret-keyed identity for coordinating one upstream credential.
+ *
+ * The digest may be stored as an internal lock/rate-limit scope. It deliberately
+ * is not a plain hash: a control-DB reader must not be able to compare guessed
+ * provider credentials or learn that two tenants supplied the same key. Never
+ * log or return this value to a client.
+ */
+export declare function integrationSecretScopeFingerprint(plaintext: string, secretKey?: string): string;
+/**
+ * A purpose-bound 32-byte subkey of the integration secret key (HKDF-SHA256,
+ * `info` names the purpose). Use it wherever a new MAC or cipher needs a key, so
+ * no two purposes ever share key material with `encryptSecret` or
+ * `integrationSecretScopeFingerprint`.
+ */
+export declare function deriveIntegrationSubkey(info: string, secretKey?: string): Buffer;

package/node_modules/@oxygen/shared/dist/integration-secrets.js

@@ -0,0 +1,77 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, hkdfSync, randomBytes } from "node:crypto";
+import { OxygenError } from "./cli-result.js";
+const VERSION = "v1";
+export function encryptSecret(plaintext, secretKey = resolveIntegrationSecretKey()) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", deriveKey(secretKey), iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return [
+        VERSION,
+        iv.toString("base64url"),
+        tag.toString("base64url"),
+        encrypted.toString("base64url"),
+    ].join(".");
+}
+export function decryptSecret(ciphertext, secretKey = resolveIntegrationSecretKey()) {
+    const [version, iv, tag, encrypted] = ciphertext.split(".");
+    if (version !== VERSION || !iv || !tag || !encrypted) {
+        throw new Error("Unsupported integration secret ciphertext.");
+    }
+    const decipher = createDecipheriv("aes-256-gcm", deriveKey(secretKey), Buffer.from(iv, "base64url"));
+    decipher.setAuthTag(Buffer.from(tag, "base64url"));
+    return Buffer.concat([
+        decipher.update(Buffer.from(encrypted, "base64url")),
+        decipher.final(),
+    ]).toString("utf8");
+}
+export function isIntegrationSecretDecryptError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.message.includes("Unsupported state or unable to authenticate data")
+        || error.message.includes("Unsupported integration secret ciphertext");
+}
+/**
+ * Stable, server-secret-keyed identity for coordinating one upstream credential.
+ *
+ * The digest may be stored as an internal lock/rate-limit scope. It deliberately
+ * is not a plain hash: a control-DB reader must not be able to compare guessed
+ * provider credentials or learn that two tenants supplied the same key. Never
+ * log or return this value to a client.
+ */
+export function integrationSecretScopeFingerprint(plaintext, secretKey = resolveIntegrationSecretKey()) {
+    return createHmac("sha256", deriveKey(secretKey))
+        .update(plaintext, "utf8")
+        .digest("base64url");
+}
+/**
+ * A purpose-bound 32-byte subkey of the integration secret key (HKDF-SHA256,
+ * `info` names the purpose). Use it wherever a new MAC or cipher needs a key, so
+ * no two purposes ever share key material with `encryptSecret` or
+ * `integrationSecretScopeFingerprint`.
+ */
+export function deriveIntegrationSubkey(info, secretKey = resolveIntegrationSecretKey()) {
+    return Buffer.from(hkdfSync("sha256", deriveKey(secretKey), Buffer.alloc(0), `oxygen:${info}`, 32));
+}
+function resolveIntegrationSecretKey() {
+    const key = readNonEmpty(process.env.INTEGRATION_SECRET_KEY)
+        ?? readNonEmpty(process.env.ENCRYPTION_KEY);
+    if (!key) {
+        throw new OxygenError("integration_secret_key_missing", "INTEGRATION_SECRET_KEY is not set.", {
+            details: { env: "INTEGRATION_SECRET_KEY" },
+            exitCode: 1,
+        });
+    }
+    return key;
+}
+function readNonEmpty(value) {
+    return value?.trim() ? value.trim() : null;
+}
+function deriveKey(secretKey) {
+    if (secretKey.startsWith("base64:")) {
+        const decoded = Buffer.from(secretKey.slice("base64:".length), "base64");
+        if (decoded.length === 32)
+            return decoded;
+    }
+    return createHash("sha256").update(secretKey).digest();
+}

package/node_modules/@oxygen/shared/dist/knowledge-bootstrap.d.ts

@@ -55,14 +55,25 @@
  * The provider sub-cap covers every external research leg, including fallbacks.
  */
 import type { HostedAiLevel } from "./hosted-ai.js";
-/** Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases. */
-export declare const KNOWLEDGE_BOOTSTRAP_MAX_CREDITS = 30;
+/**
+ * Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases.
+ * 150 since 2026-10-18 (founder, current chat: "increase to at least 100 ... don't
+ * save, really make it magical"): the parallel research agents read the whole site,
+ * the market, the team and their hiring, so onboarding starts with the full context.
+ */
+export declare const KNOWLEDGE_BOOTSTRAP_MAX_CREDITS = 150;
 /**
  * Tighter sub-ceiling on the provider/enrichment half (search + page fetch), i.e.
  * the external-money phase. Reaching it degrades the pass to `partial` — synthesize
  * from what was read — rather than failing it.
  */
-export declare const KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS = 6;
+export declare const KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS = 30;
+/**
+ * The research agents' share of the cap (knowledge-research-swarm.ts): market, traction,
+ * customer-voice and team evidence plus one model call per page they write. The company
+ * pass and the draft pages' deepening share the rest of the cap.
+ */
+export declare const KNOWLEDGE_BOOTSTRAP_SWARM_MAX_CREDITS = 60;
 /**
  * Reasoning tier the synthesis pass runs at. `medium` ("Oxygen Balanced") is the
  * deliberate middle: `low` cannot hold a company profile's structure together, and
@@ -74,7 +85,7 @@ export declare const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_TIER: HostedAiLevel;
  * is billed, so raising this raises the read ceiling as well as latency and prompt
  * size. The credit ceilings above remain the money guard.
  */
-export declare const KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ = 5;
+export declare const KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ = 15;
 /**
  * Per-call provider abort budget for every paid leg of the pass (LinkedIn company,
  * person search/profile, page search, page read), in milliseconds.

package/node_modules/@oxygen/shared/dist/knowledge-bootstrap.js

@@ -56,14 +56,25 @@
  */
 import { normalizeLinkedinCompanyUrl } from "./dnc-identities.js";
 import { normalizeLinkedinProfileUrl } from "./linkedin-url.js";
-/** Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases. */
-export const KNOWLEDGE_BOOTSTRAP_MAX_CREDITS = 30;
+/**
+ * Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases.
+ * 150 since 2026-10-18 (founder, current chat: "increase to at least 100 ... don't
+ * save, really make it magical"): the parallel research agents read the whole site,
+ * the market, the team and their hiring, so onboarding starts with the full context.
+ */
+export const KNOWLEDGE_BOOTSTRAP_MAX_CREDITS = 150;
 /**
  * Tighter sub-ceiling on the provider/enrichment half (search + page fetch), i.e.
  * the external-money phase. Reaching it degrades the pass to `partial` — synthesize
  * from what was read — rather than failing it.
  */
-export const KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS = 6;
+export const KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS = 30;
+/**
+ * The research agents' share of the cap (knowledge-research-swarm.ts): market, traction,
+ * customer-voice and team evidence plus one model call per page they write. The company
+ * pass and the draft pages' deepening share the rest of the cap.
+ */
+export const KNOWLEDGE_BOOTSTRAP_SWARM_MAX_CREDITS = 60;
 /**
  * Reasoning tier the synthesis pass runs at. `medium` ("Oxygen Balanced") is the
  * deliberate middle: `low` cannot hold a company profile's structure together, and
@@ -75,7 +86,7 @@ export const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_TIER = "medium";
  * is billed, so raising this raises the read ceiling as well as latency and prompt
  * size. The credit ceilings above remain the money guard.
  */
-export const KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ = 5;
+export const KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ = 15;
 /**
  * Per-call provider abort budget for every paid leg of the pass (LinkedIn company,
  * person search/profile, page search, page read), in milliseconds.

package/node_modules/@oxygen/shared/dist/knowledge-brain-draft.d.ts

@@ -1,5 +1,7 @@
 /** The draft's centre page: the company itself. Stable, so a rerun never mints a second one. */
 export declare const KNOWLEDGE_BRAIN_DRAFT_COMPANY_SLUG = "company";
+/** The control-DB organization metadata key holding the draft's claim and outcome. */
+export declare const KNOWLEDGE_BRAIN_DRAFT_METADATA_KEY = "knowledge_brain_draft";
 /** What marks a page as written by the draft; the onboarding graph watches for it. */
 export declare const KNOWLEDGE_BRAIN_DRAFT_TAG = "onboarding-draft";
 /** Tags every drafted page carries. */

package/node_modules/@oxygen/shared/dist/knowledge-brain-draft.js

@@ -5,6 +5,8 @@
 // (apps/web onboarding-brain) can never disagree.
 /** The draft's centre page: the company itself. Stable, so a rerun never mints a second one. */
 export const KNOWLEDGE_BRAIN_DRAFT_COMPANY_SLUG = "company";
+/** The control-DB organization metadata key holding the draft's claim and outcome. */
+export const KNOWLEDGE_BRAIN_DRAFT_METADATA_KEY = "knowledge_brain_draft";
 /** What marks a page as written by the draft; the onboarding graph watches for it. */
 export const KNOWLEDGE_BRAIN_DRAFT_TAG = "onboarding-draft";
 /** Tags every drafted page carries. */

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

@@ -41,6 +41,8 @@ export type LinkedInInviteStep = LinkedInStepBase & {
     kind: "invite";
     /** Optional connection-request note. Supports {{column}} interpolation. ~300 char max on LinkedIn. */
     note_template?: string;
+    /** Network Mining: the goal of a note drafted at send time; note_template is the fallback. */
+    ai_prompt?: string;
 };
 export type LinkedInWaitForConnectionStep = LinkedInStepBase & {
     kind: "wait_for_connection";
@@ -64,6 +66,8 @@ export type LinkedInMessageStep = LinkedInStepBase & {
         url: string;
         name?: string;
     }[];
+    /** Network Mining: the goal of a DM drafted at send time; template is the fallback. */
+    ai_prompt?: string;
 };
 export type LinkedInInMailStep = LinkedInStepBase & {
     kind: "inmail";

package/node_modules/@oxygen/shared/dist/network-mining-approval.d.ts

@@ -0,0 +1,90 @@
+export declare const STANDING_APPROVAL_VERSION = 1;
+export declare const PILOT_SAMPLE_MIN = 10;
+export declare const BATCH_SAMPLE_MAX = 30;
+/** What a standing approval binds: digests of the stored configuration, compared verbatim, and the limits as ceilings. */
+export declare const STANDING_APPROVAL_SCOPE_KEYS: readonly ["sources", "qualification", "enrichment", "sender", "copy", "brief_schema_version", "schedule", "recipient_limits", "credit_ceiling"];
+export type StandingApprovalScopeKey = (typeof STANDING_APPROVAL_SCOPE_KEYS)[number];
+export type StandingApprovalScope = Record<StandingApprovalScopeKey, string>;
+export type ApprovalActor = {
+    user_id: string;
+    /** `member_credential` or `copilot_card`; never an Agent run, a workspace key or Auto-approve. */
+    kind: string;
+    auth_type: string | null;
+    copilot_approval_id?: string;
+};
+export type SequenceFirstLaunch = ApprovalActor & {
+    at: string;
+};
+export type SequencePilotReview = {
+    preview_hash: string;
+    sample_count: number;
+    enrollment_ids: string[];
+    scope: StandingApprovalScope;
+    reviewed_by: ApprovalActor;
+    at: string;
+};
+export type SequenceStandingApproval = {
+    version: number;
+    scope: StandingApprovalScope;
+    /** The bound ceilings, kept readable beside their digests. */
+    caps: {
+        max_credits: number;
+        max_live_sends: number | null;
+        max_new_enrollments_per_day: number | null;
+    };
+    pilot_preview_hash: string;
+    approved_by: ApprovalActor;
+    approved_at: string;
+};
+/** An AI draft generated for a batch preview, kept so the batch a person approves is the one they read. */
+export type SequenceSampleDraft = {
+    enrollment_id: string;
+    step_id: string;
+    text: string;
+};
+/** The drafts of the latest paid batch preview, keyed by its preview_hash. */
+export type SequenceBatchCandidate = {
+    preview_hash: string;
+    drafts: SequenceSampleDraft[];
+    credits_used: number;
+    at: string;
+};
+export type SequenceApprovalState = {
+    first_launch: SequenceFirstLaunch | null;
+    pilot: SequencePilotReview | null;
+    standing: SequenceStandingApproval | null;
+    candidate: SequenceBatchCandidate | null;
+};
+/** The key in `ox_sequencer.sequences.metadata` that holds the approval state. */
+export declare const SEQUENCE_APPROVAL_METADATA_KEY = "network_mining_approval";
+/** Reads the approval state from a Sequence's metadata. A malformed part reads as absent, so it never grants. */
+export declare function readSequenceApprovalState(metadata: Record<string, unknown> | null | undefined): SequenceApprovalState;
+/** The scope components that left what was approved, in declaration order. */
+export declare function standingApprovalScopeChanges(bound: StandingApprovalScope, current: StandingApprovalScope): StandingApprovalScopeKey[];
+/** A standing approval's caps refuse a start that asks for more than was approved. Returns the exceeded caps. */
+export declare function standingApprovalCapOverruns(caps: SequenceStandingApproval["caps"], requested: {
+    maxCredits?: number | null;
+    maxLiveSends?: number | null;
+}): Array<"max_credits" | "max_live_sends">;
+export type DraftKind = "invite" | "message" | "comment" | "inmail" | "whatsapp";
+/** LinkedIn's own ceilings: a connection note, a comment and a DM. */
+export declare const DRAFT_CHARACTER_LIMITS: Readonly<Record<DraftKind, number>>;
+export type DraftCheckIssue = {
+    code: "draft_empty" | "draft_unresolved_variable" | "draft_third_person_sender" | "draft_too_long";
+    message: string;
+};
+/**
+ * The automatic check every draft passes before it goes out under standing approval (D8). Fails closed on: no text,
+ * a placeholder left in the copy, the sender named in the third person outside a closing sign-off line (the draft must
+ * read as written by the sender), and a draft longer than LinkedIn accepts for its kind.
+ */
+export declare function checkDraft(input: {
+    text: string | null | undefined;
+    kind: DraftKind;
+    senderName?: string | null;
+    leadName?: string | null;
+}): DraftCheckIssue[];
+/** The draft kind a step's copy is checked as; any other copy step is checked as a DM. */
+export declare function draftKindForStep(kind: string): DraftKind;
+/** The strictest kind among the steps that carry a draft: a cell read by an invite note is held to 300 characters. */
+export declare function strictestDraftKind(kinds: readonly DraftKind[]): DraftKind;

package/node_modules/@oxygen/shared/dist/network-mining-approval.js

@@ -0,0 +1,225 @@
+// Approval tiers for Network Mining Sequences (DEV-only, S10).
+//
+// T0: a person accepts each lead's exact copy at first launch (S4a).
+// T1: a person reviews a batch of 10–30 rendered drafts at once and accepts them together.
+// T2: after a reviewed pilot, a person grants standing approval per Sequence. It binds the scope below; anything
+//     outside it, or a changed component, needs a person again.
+// Founder decision 3 (2026-10-17) holds regardless of Auto-approve: the first launch of every Sequence needs a person.
+// D8: under standing approval, "copy" is the prompt and voice revision, a person's review of at least 10 samples, and
+// the automatic check below on every draft.
+import { LINKEDIN_INVITE_NOTE_LIMIT_BASIC } from "./linkedin-sequences.js";
+export const STANDING_APPROVAL_VERSION = 1;
+export const PILOT_SAMPLE_MIN = 10;
+export const BATCH_SAMPLE_MAX = 30;
+/** What a standing approval binds: digests of the stored configuration, compared verbatim, and the limits as ceilings. */
+export const STANDING_APPROVAL_SCOPE_KEYS = [
+    "sources",
+    "qualification",
+    "enrichment",
+    "sender",
+    "copy",
+    "brief_schema_version",
+    "schedule",
+    "recipient_limits",
+    "credit_ceiling",
+];
+/** The key in `ox_sequencer.sequences.metadata` that holds the approval state. */
+export const SEQUENCE_APPROVAL_METADATA_KEY = "network_mining_approval";
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function scopeOf(value) {
+    const raw = record(value);
+    if (!raw)
+        return null;
+    const scope = {};
+    for (const key of STANDING_APPROVAL_SCOPE_KEYS) {
+        if (typeof raw[key] !== "string")
+            return null;
+        scope[key] = raw[key];
+    }
+    return scope;
+}
+function actorOf(value) {
+    const raw = record(value);
+    if (!raw || typeof raw.user_id !== "string" || typeof raw.kind !== "string")
+        return null;
+    return {
+        user_id: raw.user_id,
+        kind: raw.kind,
+        auth_type: typeof raw.auth_type === "string" ? raw.auth_type : null,
+        ...(typeof raw.copilot_approval_id === "string" ? { copilot_approval_id: raw.copilot_approval_id } : {}),
+    };
+}
+function nullableCount(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** Reads the approval state from a Sequence's metadata. A malformed part reads as absent, so it never grants. */
+export function readSequenceApprovalState(metadata) {
+    const raw = record(metadata?.[SEQUENCE_APPROVAL_METADATA_KEY]);
+    const firstRaw = record(raw?.first_launch);
+    const firstActor = actorOf(firstRaw);
+    const pilotRaw = record(raw?.pilot);
+    const pilotScope = scopeOf(pilotRaw?.scope);
+    const pilotActor = actorOf(pilotRaw?.reviewed_by);
+    const standingRaw = record(raw?.standing);
+    const standingScope = scopeOf(standingRaw?.scope);
+    const standingActor = actorOf(standingRaw?.approved_by);
+    const caps = record(standingRaw?.caps);
+    const candidateRaw = record(raw?.candidate);
+    return {
+        first_launch: firstActor && typeof firstRaw?.at === "string" ? { ...firstActor, at: firstRaw.at } : null,
+        pilot: pilotRaw && pilotScope && pilotActor && typeof pilotRaw.preview_hash === "string"
+            && typeof pilotRaw.sample_count === "number" && typeof pilotRaw.at === "string"
+            ? {
+                preview_hash: pilotRaw.preview_hash,
+                sample_count: pilotRaw.sample_count,
+                enrollment_ids: Array.isArray(pilotRaw.enrollment_ids) ? pilotRaw.enrollment_ids.filter((id) => typeof id === "string") : [],
+                scope: pilotScope,
+                reviewed_by: pilotActor,
+                at: pilotRaw.at,
+            }
+            : null,
+        standing: standingRaw && standingScope && standingActor && standingRaw.version === STANDING_APPROVAL_VERSION
+            && typeof caps?.max_credits === "number" && typeof standingRaw.pilot_preview_hash === "string"
+            && typeof standingRaw.approved_at === "string"
+            ? {
+                version: STANDING_APPROVAL_VERSION,
+                scope: standingScope,
+                caps: {
+                    max_credits: caps.max_credits,
+                    max_live_sends: nullableCount(caps.max_live_sends),
+                    max_new_enrollments_per_day: nullableCount(caps.max_new_enrollments_per_day),
+                },
+                pilot_preview_hash: standingRaw.pilot_preview_hash,
+                approved_by: standingActor,
+                approved_at: standingRaw.approved_at,
+            }
+            : null,
+        candidate: candidateRaw && typeof candidateRaw.preview_hash === "string" && Array.isArray(candidateRaw.drafts) && typeof candidateRaw.at === "string"
+            ? {
+                preview_hash: candidateRaw.preview_hash,
+                drafts: candidateRaw.drafts.flatMap((draft) => {
+                    const item = record(draft);
+                    return item && typeof item.enrollment_id === "string" && typeof item.step_id === "string" && typeof item.text === "string"
+                        ? [{ enrollment_id: item.enrollment_id, step_id: item.step_id, text: item.text }]
+                        : [];
+                }),
+                credits_used: typeof candidateRaw.credits_used === "number" ? candidateRaw.credits_used : 0,
+                at: candidateRaw.at,
+            }
+            : null,
+    };
+}
+/** Limits are ceilings, stored as canonical JSON rather than digests: lowering one stays in scope, raising it does not. */
+const CEILING_SCOPE_KEYS = new Set(["recipient_limits", "credit_ceiling"]);
+function parseCeilings(value) {
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        return null;
+    }
+}
+/** Within ceilings: each bounded number is set and no higher, an unbounded one is anything, any other value equal. */
+function withinCeilings(bound, current) {
+    const approved = parseCeilings(bound);
+    const now = parseCeilings(current);
+    if (!approved || !now)
+        return false;
+    const keys = new Set([...Object.keys(approved), ...Object.keys(now)]);
+    for (const key of keys) {
+        const limit = approved[key];
+        const value = now[key] ?? null;
+        if (typeof limit === "number") {
+            if (typeof value !== "number" || value > limit)
+                return false;
+        }
+        else if (limit !== null && limit !== undefined && limit !== value) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The scope components that left what was approved, in declaration order. */
+export function standingApprovalScopeChanges(bound, current) {
+    return STANDING_APPROVAL_SCOPE_KEYS.filter((key) => (CEILING_SCOPE_KEYS.has(key) ? !withinCeilings(bound[key], current[key]) : bound[key] !== current[key]));
+}
+/** A standing approval's caps refuse a start that asks for more than was approved. Returns the exceeded caps. */
+export function standingApprovalCapOverruns(caps, requested) {
+    const overruns = [];
+    if (requested.maxCredits != null && requested.maxCredits > caps.max_credits)
+        overruns.push("max_credits");
+    if (requested.maxLiveSends != null && (caps.max_live_sends === null || requested.maxLiveSends > caps.max_live_sends)) {
+        overruns.push("max_live_sends");
+    }
+    return overruns;
+}
+/** LinkedIn's own ceilings: a connection note, a comment and a DM. */
+export const DRAFT_CHARACTER_LIMITS = {
+    // The Basic-account ceiling the dispatcher enforces, safe on every tier.
+    invite: LINKEDIN_INVITE_NOTE_LIMIT_BASIC,
+    comment: 1250,
+    message: 8000,
+    inmail: 1900,
+    whatsapp: 4096,
+};
+const UNRESOLVED_VARIABLE = /\{\{\s*[^{}]*\}\}|\{\s*(?:first_?name|last_?name|company|name|title)\s*\}|\[(?:first ?name|name|company|your name)\]/i;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function firstName(name) {
+    const first = name?.trim().split(/\s+/)[0];
+    return first && first.length >= 2 ? first : null;
+}
+/**
+ * The automatic check every draft passes before it goes out under standing approval (D8). Fails closed on: no text,
+ * a placeholder left in the copy, the sender named in the third person outside a closing sign-off line (the draft must
+ * read as written by the sender), and a draft longer than LinkedIn accepts for its kind.
+ */
+export function checkDraft(input) {
+    const text = (input.text ?? "").trim();
+    if (!text)
+        return [{ code: "draft_empty", message: "The draft is empty." }];
+    const issues = [];
+    if (UNRESOLVED_VARIABLE.test(text)) {
+        issues.push({ code: "draft_unresolved_variable", message: "The draft still contains a placeholder." });
+    }
+    const senderFull = input.senderName?.trim() ?? "";
+    const senderFirst = firstName(senderFull);
+    if (senderFirst) {
+        const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        // A closing line that is only the name (with an optional greeting) is a sign-off, written by the sender.
+        const body = lines.length > 1 && lines.at(-1).split(/\s+/).length <= 4 ? lines.slice(0, -1).join("\n") : lines.join("\n");
+        const sameFirstName = firstName(input.leadName)?.toLowerCase() === senderFirst.toLowerCase();
+        // A self-introduction ("Philipp here", "I'm Philipp") is the sender speaking, not being spoken about.
+        const spoken = [senderFull, senderFirst].filter(Boolean).reduce((text, value) => text
+            .replace(new RegExp(`\\b(?:i'?m|i am|this is|it'?s)\\s+${escapeRegExp(value)}(?=$|[^\\p{L}])`, "giu"), " ")
+            .replace(new RegExp(`(^|[^\\p{L}])${escapeRegExp(value)}\\s+here\\b`, "giu"), "$1 "), body);
+        const named = (value) => new RegExp(`(^|[^\\p{L}])${escapeRegExp(value)}(?=$|[^\\p{L}])`, "iu").test(spoken);
+        if ((senderFull.includes(" ") && named(senderFull)) || (!sameFirstName && named(senderFirst))) {
+            issues.push({ code: "draft_third_person_sender", message: `The draft names the sender (${senderFirst}) instead of speaking as them.` });
+        }
+    }
+    const length = [...text].length;
+    const limit = DRAFT_CHARACTER_LIMITS[input.kind];
+    if (length > limit) {
+        issues.push({ code: "draft_too_long", message: `The draft has ${length} characters; a LinkedIn ${input.kind} allows ${limit}.` });
+    }
+    return issues;
+}
+const DRAFT_KIND_BY_STEP = {
+    invite: "invite",
+    message: "message",
+    inmail: "inmail",
+    comment_post: "comment",
+    whatsapp_message: "whatsapp",
+};
+/** The draft kind a step's copy is checked as; any other copy step is checked as a DM. */
+export function draftKindForStep(kind) {
+    return DRAFT_KIND_BY_STEP[kind] ?? "message";
+}
+/** The strictest kind among the steps that carry a draft: a cell read by an invite note is held to 300 characters. */
+export function strictestDraftKind(kinds) {
+    return kinds.reduce((strictest, kind) => (DRAFT_CHARACTER_LIMITS[kind] < DRAFT_CHARACTER_LIMITS[strictest] ? kind : strictest), "message");
+}