@oxygen-agent/cli 1.1014.1225 → 1.1014.1343

package/node_modules/@oxygen/shared/dist/conversation-lineage.js

@@ -0,0 +1,72 @@
+// Conversation lineage (Network Mining LN1, DEV-only): where a reply came from,
+// as one bounded, free read on the conversation (`inbox get`'s `lineage`). The
+// tenant-db assembler (conversation-lineage.ts) owns no fact; this module is the
+// shape every surface and agent shares, and the one digest agents read.
+//
+// Nothing is guessed: an attribution names the rule that made it, an unknown
+// origin says `unknown`, and a name-only match never fills a record id.
+export const CONVERSATION_LINEAGE_SCHEMA_VERSION = 1;
+export const CONVERSATION_LINEAGE_MAX_CHARS = 2_500;
+export const LINEAGE_DIGEST_MAX_CHARS = 600;
+function duration(seconds) {
+    if (seconds === null || !Number.isFinite(seconds) || seconds < 0)
+        return null;
+    if (seconds < 3_600)
+        return `${Math.max(1, Math.round(seconds / 60))} min`;
+    if (seconds < 172_800)
+        return `${Math.round(seconds / 3_600)} h`;
+    return `${Math.round(seconds / 86_400)} d`;
+}
+const ORIGIN_KINDS = {
+    table_row: "a table row", lead_list: "a lead list", workflow: "a Workflow", agent: "an Agent",
+    engagement_watch: "an engagement watch", one_off_send: "a one-off send", import: "an import",
+};
+/** "a one-off send via cli, focus decile 2"; `unknown` when the enrollment recorded none. */
+export function originText(origin) {
+    if (!("gateway" in origin))
+        return "unknown";
+    const decile = origin.focus?.decile ? `, focus decile ${origin.focus.decile}` : "";
+    return `${ORIGIN_KINDS[origin.kind] ?? origin.kind.replace(/_/g, " ")} via ${origin.gateway}${decile}`;
+}
+/**
+ * One short, plain-text line set an agent reads beside the thread (≤600 chars):
+ * which sequence, step and variant the reply answered, how fast, from which
+ * sender, where the lead came from, and what is unknown.
+ */
+export function renderLineageDigest(lineage) {
+    if (!lineage)
+        return null;
+    const lines = [];
+    const sender = lineage.conversation.sender.label;
+    lines.push(`Thread started by ${lineage.conversation.started_by ?? "unknown"}${sender ? `, our side ${sender}` : ""}.`);
+    const enrollment = lineage.enrollments[0];
+    if (!enrollment) {
+        lines.push("Not from a Sequence this workspace can link.");
+    }
+    else {
+        const reply = enrollment.reply;
+        const answered = reply?.answered;
+        const step = answered?.step_index !== null && answered?.step_index !== undefined ? `step ${answered.step_index + 1}` : null;
+        const variant = answered?.variant_id ? `variant ${answered.variant_id}` : null;
+        const linked = enrollment.link === "stored" ? "" : `, linked by ${enrollment.link === "chat_id" ? "chat id" : "lead id"}`;
+        lines.push(`Sequence "${enrollment.sequence.name ?? enrollment.sequence.id}" (${enrollment.status ?? "unknown status"}${linked}).`);
+        if (reply) {
+            const answeredText = [step, variant].filter(Boolean).join(", ");
+            const latency = duration(reply.latency_seconds);
+            lines.push(`Replied ${reply.occurred_at.slice(0, 16).replace("T", " ")}Z${answeredText ? ` to ${answeredText}` : ""}${latency ? `, ${latency} after that send` : ""} (${reply.attribution.replace(/_/g, " ")}).`);
+        }
+        if (enrollment.touches_before_reply)
+            lines.push(`${enrollment.touches_before_reply.total} touches before the reply.`);
+        // An enrollment without an origin predates origin recording; saying so spares a reader the search for one.
+        lines.push(`Lead source: ${"gateway" in enrollment.origin ? originText(enrollment.origin) : "unknown (enrolled before origins were recorded)"}.`);
+    }
+    if ("row_id" in lineage.record)
+        lines.push(`Record: ${lineage.record.object} ${lineage.record.row_id} (by ${lineage.record.matched_on}).`);
+    else
+        lines.push("No CRM record is linked.");
+    const [status, previous] = lineage.classification_history;
+    if (status)
+        lines.push(`Status ${status.status} (${status.source})${previous ? `, before that ${previous.status} (${previous.source})` : ""}.`);
+    const text = lines.join(" ");
+    return text.length <= LINEAGE_DIGEST_MAX_CHARS ? text : `${text.slice(0, LINEAGE_DIGEST_MAX_CHARS - 1)}…`;
+}

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

@@ -6,9 +6,9 @@ export type CustomerFacingCopilotError = {
     message: string | null;
 };
 /**
- * Replace an internal worker deadline with the stable Copilot timeout contract.
- * The message-pattern fallback heals rows written before the worker error code
- * was persisted consistently. Other errors pass through byte-for-byte.
+ * Project known internal failures to stable customer-facing copy.
+ * The timeout message-pattern fallback heals rows written before the worker
+ * error code was persisted consistently. Unrecognized errors pass through.
  */
 export declare function customerFacingCopilotError(input: {
     code?: string | null;

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

@@ -14,13 +14,16 @@ export const COPILOT_TURN_TIMEOUT_MESSAGE = "This Copilot request timed out and
 export const COPILOT_TURN_DEADLINE_EXCEEDED_CODE = "copilot_turn_deadline_exceeded";
 const WORKER_STEP_TIMEOUT_MESSAGE = /\bWorker step '[^']+' exceeded \d+ms deadline\.?/i;
 /**
- * Replace an internal worker deadline with the stable Copilot timeout contract.
- * The message-pattern fallback heals rows written before the worker error code
- * was persisted consistently. Other errors pass through byte-for-byte.
+ * Project known internal failures to stable customer-facing copy.
+ * The timeout message-pattern fallback heals rows written before the worker
+ * error code was persisted consistently. Unrecognized errors pass through.
  */
 export function customerFacingCopilotError(input) {
     const code = input.code ?? null;
     const message = input.message ?? null;
+    if (code === "dev_eval_policy_refused") {
+        return { code, message: "The run's safety policy refused this request, so this turn stopped. Review the run's authorization and limits before continuing." };
+    }
     if (code === "agent_response_incomplete") {
         return { code, message: "I stopped before completing the requested work. Completed actions are saved; ask me to continue." };
     }

package/node_modules/@oxygen/shared/dist/crm-record-brief.d.ts

@@ -5,6 +5,6 @@
  */
 export declare const CRM_RECORD_BRIEF_SECTIONS: readonly ["record", "company", "intent", "warm_paths", "meetings", "timeline", "conversations", "sequences", "notes", "tasks", "related", "knowledge"];
 export type CrmRecordBriefSection = typeof CRM_RECORD_BRIEF_SECTIONS[number];
-export declare const CRM_RECORD_BRIEF_DEFAULT_MAX_CHARS = 8000;
+export declare const CRM_RECORD_BRIEF_DEFAULT_MAX_CHARS = 16000;
 export declare const CRM_RECORD_BRIEF_MIN_MAX_CHARS = 3000;
 export declare const CRM_RECORD_BRIEF_MAX_MAX_CHARS = 20000;

package/node_modules/@oxygen/shared/dist/crm-record-brief.js

@@ -17,6 +17,8 @@ export const CRM_RECORD_BRIEF_SECTIONS = [
     "related",
     "knowledge",
 ];
-export const CRM_RECORD_BRIEF_DEFAULT_MAX_CHARS = 8_000;
+// A typical person brief (record, company, warm paths, threads, timeline) fits uncut at the default
+// (S1 acceptance round 6 used ~12.2k); agents offload any result above their inline size either way.
+export const CRM_RECORD_BRIEF_DEFAULT_MAX_CHARS = 16_000;
 export const CRM_RECORD_BRIEF_MIN_MAX_CHARS = 3_000;
 export const CRM_RECORD_BRIEF_MAX_MAX_CHARS = 20_000;

package/node_modules/@oxygen/shared/dist/deliverability-surface.d.ts

@@ -11,8 +11,10 @@ export declare const DELIVERABILITY_SURFACE_MAX_LIMIT = 100;
 /** A check's stored raw evidence is capped at 64 KB; reads return it whole up to this size. */
 export declare const DELIVERABILITY_SURFACE_RAW_MAX_CHARS = 16000;
 export declare const DELIVERABILITY_SURFACE_EVIDENCE_DEFAULT_DAYS = 28;
-export declare const DELIVERABILITY_SURFACE_CHECK_KINDS: readonly ["dns_auth", "bimi", "tracking_cname", "blacklist", "content_score", "header_proof", "placement"];
-export declare const DELIVERABILITY_SURFACE_SUBJECT_TYPES: readonly ["domain", "mailbox", "copy", "placement_run"];
+/** Placement results are observations, never check runs, so `placement` is not a readable kind. */
+export declare const DELIVERABILITY_SURFACE_CHECK_KINDS: ("bimi" | "blacklist" | "content_score" | "dns_auth" | "header_proof" | "tracking_cname")[];
+/** Placement runs are read through observations and compare, so no check run has that subject type. */
+export declare const DELIVERABILITY_SURFACE_SUBJECT_TYPES: ("copy" | "domain" | "mailbox")[];
 export declare const DELIVERABILITY_SURFACE_RUN_STATUSES: readonly ["succeeded", "partial", "failed", "unknown"];
 export declare const DELIVERABILITY_SURFACE_FINDING_STATUSES: readonly ["pass", "warn", "fail", "unknown"];
 export declare const DELIVERABILITY_SURFACE_FOLDERS: readonly ["inbox", "spam", "other", "not_observed", "unknown"];

package/node_modules/@oxygen/shared/dist/deliverability-surface.js

@@ -12,8 +12,10 @@ export const DELIVERABILITY_SURFACE_MAX_LIMIT = 100;
 /** A check's stored raw evidence is capped at 64 KB; reads return it whole up to this size. */
 export const DELIVERABILITY_SURFACE_RAW_MAX_CHARS = 16_000;
 export const DELIVERABILITY_SURFACE_EVIDENCE_DEFAULT_DAYS = 28;
-export const DELIVERABILITY_SURFACE_CHECK_KINDS = DELIVERABILITY_CHECK_KINDS;
-export const DELIVERABILITY_SURFACE_SUBJECT_TYPES = DELIVERABILITY_SUBJECT_TYPES;
+/** Placement results are observations, never check runs, so `placement` is not a readable kind. */
+export const DELIVERABILITY_SURFACE_CHECK_KINDS = DELIVERABILITY_CHECK_KINDS.filter((kind) => kind !== "placement");
+/** Placement runs are read through observations and compare, so no check run has that subject type. */
+export const DELIVERABILITY_SURFACE_SUBJECT_TYPES = DELIVERABILITY_SUBJECT_TYPES.filter((type) => type !== "placement_run");
 export const DELIVERABILITY_SURFACE_RUN_STATUSES = DELIVERABILITY_RUN_STATUSES;
 export const DELIVERABILITY_SURFACE_FINDING_STATUSES = DELIVERABILITY_FINDING_STATUSES;
 export const DELIVERABILITY_SURFACE_FOLDERS = PLACEMENT_FOLDERS;

package/node_modules/@oxygen/shared/dist/dev-eval-context.d.ts

@@ -1,8 +1,25 @@
+export type DevEvalNoDispatchEffectReceipt = Readonly<{
+    kind: "dev_eval_verified_no_dispatch/1";
+    campaignId: string;
+    organizationId: string;
+    sessionId: string;
+    actionRunId: string;
+    requests: readonly Readonly<{
+        provider: string;
+        operation: string;
+        nativeAttemptId: string;
+        physicalRequestSha256: string;
+        attestationSha256: string;
+    }>[];
+}>;
 export type DevEvalContext = Readonly<{
     campaignId: string;
     organizationId: string;
     sessionId: string;
     actionRunId?: string;
+    /** Installed only by the authenticated native host; never deserialized.
+     * The callback proves the complete failed operation, not just its last error. */
+    observeNoDispatch?: <T>(operation: () => Promise<T>, onVerified: (receipt: DevEvalNoDispatchEffectReceipt) => Promise<void>) => Promise<T>;
     /** Installed by the authenticated host after control-DB lookup, never deserialized. */
     fetch: (provider: string, operation: string, input: string | Request | URL, init: RequestInit | undefined, transport: typeof fetch) => Promise<Response>;
 }>;
@@ -11,6 +28,9 @@ export declare const currentDevEvalContext: () => Readonly<{
     organizationId: string;
     sessionId: string;
     actionRunId?: string;
+    /** Installed only by the authenticated native host; never deserialized.
+     * The callback proves the complete failed operation, not just its last error. */
+    observeNoDispatch?: <T>(operation: () => Promise<T>, onVerified: (receipt: DevEvalNoDispatchEffectReceipt) => Promise<void>) => Promise<T>;
     /** Installed by the authenticated host after control-DB lookup, never deserialized. */
     fetch: (provider: string, operation: string, input: string | Request | URL, init: RequestInit | undefined, transport: typeof fetch) => Promise<Response>;
 }> | null;

package/node_modules/@oxygen/shared/dist/enrollment-origin.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Where a Sequence enrollment came from, stamped once at its single insert
+ * (`ox_sequencer.enrollments.origin`, migration 0541) because the actor, run and
+ * gateway exist only at enroll time and `sequences.source_table_id` can be
+ * rebound later. Read by the conversation lineage and the day-1 funnel.
+ *
+ * One contract for every writer: `parseEnrollmentOrigin` refuses an unknown
+ * kind, actor, gateway or ref type, and the pg CHECK on `origin->>'kind'` keeps
+ * the column from rotting like `metadata`. `{}` is a pre-0541 row and reads as
+ * `unknown`; nothing is ever inferred into it.
+ */
+export declare const ENROLLMENT_ORIGIN_SCHEMA_VERSION = 1;
+/** What chose these leads. Mirrored by the CHECK constraint in 0541; add to both. */
+export declare const ENROLLMENT_ORIGIN_KINDS: readonly ["table_row", "lead_list", "workflow", "agent", "engagement_watch", "one_off_send", "import", "unknown"];
+export type EnrollmentOriginKind = typeof ENROLLMENT_ORIGIN_KINDS[number];
+export declare const ENROLLMENT_ACTOR_TYPES: readonly ["user", "agent", "workflow", "api_key", "system"];
+export type EnrollmentActorType = typeof ENROLLMENT_ACTOR_TYPES[number];
+/** The surface the enroll call came through. */
+export declare const ENROLLMENT_GATEWAYS: readonly ["cli", "mcp", "web", "copilot", "agent", "workflow", "engagement_watch"];
+export type EnrollmentGateway = typeof ENROLLMENT_GATEWAYS[number];
+export declare const ENROLLMENT_REF_TYPES: readonly ["workflow_run", "agent_run", "copilot_session", "engagement_watch", "guided_activation"];
+export type EnrollmentRefType = typeof ENROLLMENT_REF_TYPES[number];
+/** Network Mining (gated): the lead's place in the focus rank when it was enrolled. Focus is read-time and drifts. */
+export type EnrollmentFocusSnapshot = {
+    /** The People record the enrolled row resolved to, or null when it resolved to none. */
+    record_row_id: string | null;
+    in_focus: boolean;
+    /** 1-based position in the whole candidate set; null when not in focus. */
+    rank: number | null;
+    /** 1 (warmest tenth) to 10; null when not in focus. */
+    decile: number | null;
+    /** How many people the rank held; null when none of the batch was in it. */
+    candidates: number | null;
+    reasons: Array<{
+        code: string;
+        evidence_ids: string[];
+    }>;
+    rule_version: string;
+    computed_at: string;
+};
+export type EnrollmentOrigin = {
+    schema_version: typeof ENROLLMENT_ORIGIN_SCHEMA_VERSION;
+    kind: EnrollmentOriginKind;
+    gateway: EnrollmentGateway;
+    enrolled_by: {
+        type: EnrollmentActorType;
+        id: string | null;
+    };
+    /** The table the enrolled rows belong to (also stamped as the typed `source_table_id`). */
+    table_id: string | null;
+    ref: {
+        type: EnrollmentRefType;
+        id: string;
+    } | null;
+    /** Network Mining only; absent while the gate is off, null when the read failed. */
+    focus_at_enroll?: EnrollmentFocusSnapshot | null;
+};
+/** Everything a writer states; the enroller adds the per-lead focus snapshot. */
+export type EnrollmentOriginInput = Omit<EnrollmentOrigin, "schema_version" | "focus_at_enroll">;
+/** Validates a writer's origin; throws on anything outside the contract. */
+export declare function parseEnrollmentOrigin(value: unknown): EnrollmentOrigin;
+/** A stored origin as readers see it: `{}` and anything malformed read as `unknown`, never guessed. */
+export declare function readEnrollmentOrigin(value: unknown): EnrollmentOrigin | {
+    kind: "unknown";
+};

package/node_modules/@oxygen/shared/dist/enrollment-origin.js

@@ -0,0 +1,92 @@
+/**
+ * Where a Sequence enrollment came from, stamped once at its single insert
+ * (`ox_sequencer.enrollments.origin`, migration 0541) because the actor, run and
+ * gateway exist only at enroll time and `sequences.source_table_id` can be
+ * rebound later. Read by the conversation lineage and the day-1 funnel.
+ *
+ * One contract for every writer: `parseEnrollmentOrigin` refuses an unknown
+ * kind, actor, gateway or ref type, and the pg CHECK on `origin->>'kind'` keeps
+ * the column from rotting like `metadata`. `{}` is a pre-0541 row and reads as
+ * `unknown`; nothing is ever inferred into it.
+ */
+export const ENROLLMENT_ORIGIN_SCHEMA_VERSION = 1;
+/** What chose these leads. Mirrored by the CHECK constraint in 0541; add to both. */
+export const ENROLLMENT_ORIGIN_KINDS = [
+    "table_row",
+    "lead_list",
+    "workflow",
+    "agent",
+    "engagement_watch",
+    "one_off_send",
+    "import",
+    "unknown",
+];
+export const ENROLLMENT_ACTOR_TYPES = ["user", "agent", "workflow", "api_key", "system"];
+/** The surface the enroll call came through. */
+export const ENROLLMENT_GATEWAYS = [
+    "cli",
+    "mcp",
+    "web",
+    "copilot",
+    "agent",
+    "workflow",
+    "engagement_watch",
+];
+export const ENROLLMENT_REF_TYPES = [
+    "workflow_run",
+    "agent_run",
+    "copilot_session",
+    "engagement_watch",
+    "guided_activation",
+];
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function oneOf(values, value, field) {
+    if (typeof value === "string" && values.includes(value))
+        return value;
+    throw new Error(`Enrollment origin ${field} must be one of ${values.join(", ")}.`);
+}
+function optionalId(value, field) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string" && value.trim() && value.length <= 200)
+        return value.trim();
+    throw new Error(`Enrollment origin ${field} must be a non-empty id or null.`);
+}
+/** Validates a writer's origin; throws on anything outside the contract. */
+export function parseEnrollmentOrigin(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Enrollment origin must be an object.");
+    const input = value;
+    const enrolledBy = input.enrolled_by;
+    if (!enrolledBy || typeof enrolledBy !== "object")
+        throw new Error("Enrollment origin enrolled_by is required.");
+    const tableId = optionalId(input.table_id, "table_id");
+    if (tableId !== null && !UUID_RE.test(tableId))
+        throw new Error("Enrollment origin table_id must be a uuid.");
+    const ref = input.ref;
+    const refId = ref ? optionalId(ref.id, "ref.id") : null;
+    if (ref && refId === null)
+        throw new Error("Enrollment origin ref.id is required with a ref.");
+    return {
+        schema_version: ENROLLMENT_ORIGIN_SCHEMA_VERSION,
+        kind: oneOf(ENROLLMENT_ORIGIN_KINDS, input.kind, "kind"),
+        gateway: oneOf(ENROLLMENT_GATEWAYS, input.gateway, "gateway"),
+        enrolled_by: {
+            type: oneOf(ENROLLMENT_ACTOR_TYPES, enrolledBy.type, "enrolled_by.type"),
+            id: optionalId(enrolledBy.id, "enrolled_by.id"),
+        },
+        table_id: tableId,
+        ref: ref && refId ? { type: oneOf(ENROLLMENT_REF_TYPES, ref.type, "ref.type"), id: refId } : null,
+    };
+}
+/** A stored origin as readers see it: `{}` and anything malformed read as `unknown`, never guessed. */
+export function readEnrollmentOrigin(value) {
+    try {
+        const origin = parseEnrollmentOrigin(value);
+        const focus = value.focus_at_enroll;
+        return focus === undefined ? origin : { ...origin, focus_at_enroll: focus };
+    }
+    catch {
+        return { kind: "unknown" };
+    }
+}

package/node_modules/@oxygen/shared/dist/first-month-offer.d.ts

@@ -22,6 +22,12 @@ export declare const FIRST_MONTH_OFFER: Readonly<{
     key: "first_month_half";
     /** The cheapest size it applies to; every dearer size qualifies too. */
     minimumPlanKey: "oxygen_99";
+    /**
+     * The size every surface proposes while the offer runs ("By default it's the
+     * $99/month plan, which is 50% off for the first month"): `/pricing` and the
+     * upgrade page preselect it, and the CLI and MCP name it to an agent.
+     */
+    defaultPlanKey: "oxygen_99";
     /** How long a person has to claim it after first seeing it. */
     windowMs: number;
 }>;
@@ -29,6 +35,18 @@ export declare const FIRST_MONTH_OFFER: Readonly<{
 export declare const FIRST_MONTH_OFFER_PLAN_KEYS: readonly OxygenPlanKey[];
 /** Whether the offer applies to this size (billed monthly; checkout checks the rest). */
 export declare function firstMonthOfferAppliesTo(planKey: string): planKey is OxygenPlanKey;
+/**
+ * Whether the offer covers one first subscription: a size it applies to, billed
+ * monthly (never a yearly commitment). Who may claim it, and when, is the
+ * server's `readFirstMonthOfferState`.
+ */
+export type FirstMonthOfferCoverage = {
+    applies: true;
+} | {
+    applies: false;
+    reason: "plan_not_covered" | "yearly_not_covered";
+};
+export declare function firstMonthOfferCoverage(planKey: string, interval: "month" | "year"): FirstMonthOfferCoverage;
 export type FirstMonthOfferPrice = {
     planKey: OxygenPlanKey;
     regularCents: number;

package/node_modules/@oxygen/shared/dist/first-month-offer.js

@@ -22,6 +22,12 @@ export const FIRST_MONTH_OFFER = Object.freeze({
     key: "first_month_half",
     /** The cheapest size it applies to; every dearer size qualifies too. */
     minimumPlanKey: "oxygen_99",
+    /**
+     * The size every surface proposes while the offer runs ("By default it's the
+     * $99/month plan, which is 50% off for the first month"): `/pricing` and the
+     * upgrade page preselect it, and the CLI and MCP name it to an agent.
+     */
+    defaultPlanKey: "oxygen_99",
     /** How long a person has to claim it after first seeing it. */
     windowMs: FIRST_MONTH_OFFER_WINDOW_MS,
 });
@@ -36,6 +42,13 @@ export const FIRST_MONTH_OFFER_PLAN_KEYS = (() => {
 export function firstMonthOfferAppliesTo(planKey) {
     return FIRST_MONTH_OFFER_PLAN_KEYS.includes(planKey);
 }
+export function firstMonthOfferCoverage(planKey, interval) {
+    if (!firstMonthOfferAppliesTo(planKey))
+        return { applies: false, reason: "plan_not_covered" };
+    if (interval !== "month")
+        return { applies: false, reason: "yearly_not_covered" };
+    return { applies: true };
+}
 /** A size's first month under the offer: half its price, rounded down to the dollar ($99 → $49, 50% off). */
 export function firstMonthOfferPrice(planKey = FIRST_MONTH_OFFER.minimumPlanKey) {
     if (!firstMonthOfferAppliesTo(planKey))

package/node_modules/@oxygen/shared/dist/guided-onboarding-recommendations.d.ts

@@ -0,0 +1,54 @@
+import type { GuidedOnboardingAnswers } from "./guided-onboarding-journey.js";
+export declare const ONBOARDING_AUDIENCE_QUESTIONS: {
+    readonly audience_company_size: "What size companies do you sell to?";
+    readonly audience_markets: "Which markets do you serve?";
+    readonly audience_industries: "Which industries fit your customers?";
+    readonly audience_personas: "Who buys from you?";
+};
+export type OnboardingAudienceStep = keyof typeof ONBOARDING_AUDIENCE_QUESTIONS;
+export type OnboardingRecommendation = {
+    values: string[];
+    rationale: string;
+    source_revision: number;
+    source_page?: {
+        id: string;
+        slug: string;
+    };
+    sources: Array<{
+        id: string;
+        url: string;
+        title: string | null;
+    }>;
+};
+export declare const ONBOARDING_DRAFT_FILTER_PAGES: {
+    readonly audience_company_size: "filter-company-size";
+    readonly audience_markets: "filter-regions";
+    readonly audience_industries: "filter-industries";
+    readonly audience_personas: "filter-job-titles";
+};
+export type OnboardingDraftFilterPage = {
+    id: string;
+    slug: string;
+    revision: number;
+    body: string;
+    data: unknown;
+};
+export type OnboardingRecommendations = Partial<Record<OnboardingAudienceStep, OnboardingRecommendation>> & {
+    signals?: {
+        answer: NonNullable<GuidedOnboardingAnswers["signals"]>;
+        source_revision: number;
+    };
+};
+/** The background research's target-customer projection, never the company's
+ * own headcount/industry or a generic catalog. Recommendations are unsaved drafts. */
+export declare function guidedOnboardingRecommendations(profile: {
+    revision: number;
+    data: {
+        icp?: Record<string, unknown>;
+    };
+} | null | undefined, evidence?: OnboardingRecommendation["sources"], draft?: {
+    domain: string | null;
+    pages: OnboardingDraftFilterPage[];
+}): OnboardingRecommendations;
+/** Only deliberate, saved answers enter shared chat history; no sealed research. */
+export declare function onboardingAnswerPost(answers: GuidedOnboardingAnswers): string | null;

package/node_modules/@oxygen/shared/dist/guided-onboarding-recommendations.js

@@ -0,0 +1,100 @@
+import { asRecordOrEmpty } from "./type-guards.js";
+export const ONBOARDING_AUDIENCE_QUESTIONS = {
+    audience_company_size: "What size companies do you sell to?",
+    audience_markets: "Which markets do you serve?",
+    audience_industries: "Which industries fit your customers?",
+    audience_personas: "Who buys from you?",
+};
+export const ONBOARDING_DRAFT_FILTER_PAGES = {
+    audience_company_size: "filter-company-size", audience_markets: "filter-regions",
+    audience_industries: "filter-industries", audience_personas: "filter-job-titles",
+};
+function values(value) {
+    const list = typeof value === "string" ? [value] : Array.isArray(value) ? value : [];
+    const unique = new Map();
+    for (const item of list) {
+        if (typeof item !== "string")
+            continue;
+        const text = item.normalize("NFKC").trim().replace(/\s+/gu, " ");
+        if (text && text.length <= 160)
+            unique.set(text.toLowerCase(), text);
+    }
+    return [...unique.values()];
+}
+/** The background research's target-customer projection, never the company's
+ * own headcount/industry or a generic catalog. Recommendations are unsaved drafts. */
+export function guidedOnboardingRecommendations(profile, evidence = [], draft) {
+    const icp = profile?.data.icp ?? {};
+    const candidates = {
+        audience_company_size: icp.company_sizes ?? icp.company_size,
+        audience_markets: icp.markets ?? icp.geographies,
+        audience_industries: icp.industries,
+        audience_personas: icp.buyer_personas ?? icp.buyer_titles,
+    };
+    const sources = evidence.filter(source => {
+        try {
+            const url = new URL(source.url);
+            return url.protocol === "https:" && !url.username && !url.password;
+        }
+        catch {
+            return false;
+        }
+    }).slice(0, 8);
+    const result = {};
+    for (const [step, candidate] of Object.entries(candidates)) {
+        const key = step;
+        const page = candidate === undefined && draft?.domain ? draft.pages.find(page => page.slug === ONBOARDING_DRAFT_FILTER_PAGES[key]
+            && asRecordOrEmpty(asRecordOrEmpty(page.data).brain_draft).domain === draft.domain) : undefined;
+        const provenance = asRecordOrEmpty(asRecordOrEmpty(page?.data).brain_draft);
+        const selected = values(page ? [...page.body.matchAll(/^- ([^\r\n]+)$/gm)].map(match => match[1]) : candidate).slice(0, 3);
+        if (!selected.length)
+            continue;
+        const references = page ? values(provenance.source_urls).flatMap((url, index) => {
+            try {
+                const parsed = new URL(url);
+                return parsed.protocol === "https:" && !parsed.username && !parsed.password ? [{ id: `${page.id}:${index}`, url, title: null }] : [];
+            }
+            catch {
+                return [];
+            }
+        }) : sources;
+        result[key] = { values: selected,
+            rationale: `I'd start with ${selected.join(", ")} from your ${page ? "draft" : "saved"} target-customer research. Confirm this starting audience or adjust it.`,
+            source_revision: page?.revision ?? profile.revision, sources: references,
+            ...(page ? { source_page: { id: page.id, slug: page.slug } } : {}) };
+    }
+    const hiring = values(icp.hiring_roles).slice(0, 3);
+    const relationships = new Set(["uses", "integrates_with", "replaces"]);
+    const technology = (Array.isArray(icp.technology_relationships) ? icp.technology_relationships : []).flatMap(item => {
+        if (!item || typeof item !== "object" || !relationships.has(item.relationship))
+            return [];
+        const name = values(item.name)[0];
+        return name ? [{ name, relationship: item.relationship }] : [];
+    }).slice(0, 3);
+    if (hiring.length || technology.length)
+        result.signals = { source_revision: profile.revision,
+            answer: { hiring: { mode: hiring.length ? "selected" : "none", values: hiring },
+                technology: { mode: technology.length ? "selected" : "none", values: technology } } };
+    return result;
+}
+/** Only deliberate, saved answers enter shared chat history; no sealed research. */
+export function onboardingAnswerPost(answers) {
+    for (const [step, question] of Object.entries(ONBOARDING_AUDIENCE_QUESTIONS)) {
+        const answer = answers[step];
+        if (answer)
+            return `${question}\n\nConfirmed: ${answer.values.join(", ")}`;
+    }
+    if (answers.company_context) {
+        const answer = answers.company_context;
+        return `Your company\n\n${[answer.name, answer.website, answer.description].filter(Boolean).join("\n")}`;
+    }
+    if (answers.company_review)
+        return `Your company\n\nConfirmed: ${answers.company_review.statement}`;
+    if (answers.signals) {
+        const signals = answers.signals;
+        const selected = [...signals.hiring.values.map(role => `Hiring: ${role}`),
+            ...signals.technology.values.map(item => `${item.name} (${item.relationship})`)];
+        return `Which signals matter to you?\n\nConfirmed: ${selected.length ? selected.join(", ") : "No signals for now"}`;
+    }
+    return null;
+}

package/node_modules/@oxygen/shared/dist/hosted-ai.d.ts

@@ -90,6 +90,12 @@ export type ManagedModelPin = {
     fallbackModels: readonly string[];
     /** Send `reasoning: {enabled: false}`, as the pass was measured. */
     disableReasoning: boolean;
+    /** The pass's own completion ceiling, replacing the column tier's. Credits stay
+     *  the tier's flat price, so it only decides whether a long answer is cut off. */
+    maxOutputTokens?: number;
+    /** OpenRouter provider routing for the pinned model: `throughput` sends each call
+     *  to the provider serving it fastest right now, at the same model and price tier. */
+    providerSort?: "throughput" | "latency" | "price";
 };
 /**
  * Signup research synthesis (knowledge bootstrap): the company profile, cited

package/node_modules/@oxygen/shared/dist/hosted-ai.js

@@ -278,6 +278,15 @@ export const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_MODEL = {
     model: "deepseek/deepseek-v4.1-flash",
     fallbackModels: ["openai/gpt-6-luna"],
     disableReasoning: true,
+    // The profile plus the cited note of a well-documented company runs past the
+    // Balanced tier's 4,096: on dev (2026-10-18) attio.com and lemlist.com stopped at
+    // exactly 4,096 tokens (`finish_reason: length`), mid-note, as invalid JSON, so the
+    // run ended `partial` with no research page. A shorter answer is unaffected.
+    maxOutputTokens: 8192,
+    // The same model ran 3x apart by provider on dev (2026-10-18): DigitalOcean and
+    // Together wrote 300 to 370 tokens a second, Relace and Parasail 105 to 120, so one
+    // 7,600-token research note took 66 s instead of about 20 s.
+    providerSort: "throughput",
 };
 /**
  * Managed model ids OXYGEN ran that never sat in the registry above, mapped to

package/node_modules/@oxygen/shared/dist/hubspot-engagements.d.ts

@@ -0,0 +1,26 @@
+export declare const HUBSPOT_ENGAGEMENT_TYPES: readonly ["calls", "meetings", "notes", "emails", "tasks"];
+export type HubspotEngagementType = (typeof HUBSPOT_ENGAGEMENT_TYPES)[number];
+/** Properties each list page asks for. Email bodies are read only as an excerpt. */
+export declare const HUBSPOT_ENGAGEMENT_PROPERTIES: Readonly<Record<HubspotEngagementType, readonly string[]>>;
+/** The records an engagement may link to: HubSpot association type → registered external object. */
+export declare const HUBSPOT_ENGAGEMENT_ASSOCIATIONS: readonly ["contacts", "companies"];
+export type HubspotEngagementActivity = {
+    hubspotType: HubspotEngagementType;
+    hubspotId: string;
+    activityType: "call" | "meeting_booked" | "meeting_completed" | "no_show" | "note" | "email_sent" | "email_received" | "task_created" | "task_completed";
+    direction: "inbound" | "outbound" | "internal" | null;
+    channel: "phone" | "meeting" | "email" | null;
+    occurredAt: string;
+    summary: string;
+    body: string | null;
+    /** HubSpot ids of the associated contacts and companies, in that order of preference. */
+    contactIds: string[];
+    companyIds: string[];
+    /** The source properties kept for provenance (never the full email body). */
+    properties: Record<string, string>;
+};
+/**
+ * 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 declare function normalizeHubspotEngagement(type: HubspotEngagementType, raw: unknown): HubspotEngagementActivity | null;