@oxygen-agent/cli 1.1014.985 → 1.1014.1087

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -236,6 +236,144 @@ export function dropBlankImportCells(row, keepKey) {
 export function normalizeImportColumnKey(value) {
     return toSnakeIdentifier(value, "column");
 }
+/**
+ * Read `ignore_source_keys`: the headers a mapping step set to "Don't import".
+ * A JSON array (staged body) or its JSON text (multipart form field); headers
+ * are matched verbatim, so they are not trimmed. Anything malformed reads as
+ * no choice at all, never as a reason to fail the import.
+ */
+export function readImportHeaderList(value) {
+    let parsed = value;
+    if (typeof value === "string") {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((entry) => typeof entry === "string" && entry.length > 0).slice(0, 1_000);
+}
+/**
+ * Decide, once per file header, which column of an EXISTING table it lands in.
+ *
+ * File imports used to hand every header to the row writer verbatim, and the
+ * writer refuses an unknown key for the whole chunk. A standard export carries
+ * columns the table does not have — Baserow puts an `id` first — so on
+ * 2026-10-12 and 2026-10-15 three workspaces' CRM imports wrote nothing at all
+ * and showed only `invalid_row_values`. Headers now resolve in a fixed order:
+ * an explicit choice (`explicitMap`, `ignore`) first, then the column key, then
+ * the column's label or the normalized key. A header that resolves to no
+ * column, or to a column another header already fills, is left out and
+ * reported, never guessed: two headers writing one column would overwrite each
+ * other. Rows keep their cells; only the keys are renamed or dropped.
+ */
+export function createImportHeaderProjector(input) {
+    const exact = new Map();
+    const aliases = new Map();
+    for (const column of input.columns) {
+        if (!column.key || column.key.startsWith("_"))
+            continue;
+        exact.set(column.key, column.key);
+        for (const alias of [
+            column.label?.trim(),
+            normalizeImportColumnKey(column.key),
+            column.label ? normalizeImportColumnKey(column.label) : undefined,
+        ]) {
+            if (!alias)
+                continue;
+            const existing = aliases.get(alias);
+            if (existing === undefined)
+                aliases.set(alias, column.key);
+            else if (existing !== column.key)
+                aliases.set(alias, null);
+        }
+    }
+    const explicitMap = input.explicitMap ?? {};
+    const ignore = new Set(input.ignore ?? []);
+    const keyByHeader = new Map();
+    const ignored = new Map();
+    const claimed = new Set();
+    const decide = (headers) => {
+        const pending = headers.filter((header) => !keyByHeader.has(header) && !ignored.has(header));
+        const aliasCandidates = new Map();
+        const skip = (header, reason, column) => ignored.set(header, { header, reason, ...(column ? { column } : {}) });
+        const claim = (header, key) => {
+            keyByHeader.set(header, key);
+            claimed.add(key);
+        };
+        // Explicit choices and exact keys claim their columns before any alias can.
+        for (const header of pending) {
+            if (ignore.has(header)) {
+                skip(header, "not_selected");
+                continue;
+            }
+            const explicit = explicitMap[header];
+            if (explicit) {
+                claim(header, explicit);
+                continue;
+            }
+            const key = exact.get(header) ?? exact.get(header.trim());
+            if (key && !claimed.has(key))
+                claim(header, key);
+        }
+        for (const header of pending) {
+            if (keyByHeader.has(header) || ignored.has(header))
+                continue;
+            const exactKey = exact.get(header) ?? exact.get(header.trim());
+            if (exactKey) {
+                skip(header, "duplicate_target", exactKey);
+                continue;
+            }
+            // `_created_at` must not alias `created_at`: system keys are never written.
+            if (header.startsWith("_")) {
+                skip(header, "system_column");
+                continue;
+            }
+            const alias = aliases.get(header.trim()) ?? aliases.get(normalizeImportColumnKey(header)) ?? null;
+            if (!alias) {
+                skip(header, "no_matching_column");
+                continue;
+            }
+            aliasCandidates.set(alias, [...(aliasCandidates.get(alias) ?? []), header]);
+        }
+        for (const [key, candidates] of aliasCandidates) {
+            if (candidates.length === 1 && !claimed.has(key)) {
+                claim(candidates[0], key);
+                continue;
+            }
+            for (const header of candidates)
+                skip(header, "duplicate_target", key);
+        }
+    };
+    return {
+        /** Resolve any headers first seen in these rows; earlier decisions stand. */
+        observe(rows) {
+            decide(inferImportColumnLabels(rows));
+        },
+        /** The row with every key renamed to its column, unwritten headers dropped. */
+        project(row) {
+            const projected = {};
+            for (const [header, value] of Object.entries(row)) {
+                if (!keyByHeader.has(header) && !ignored.has(header))
+                    decide([header]);
+                const key = keyByHeader.get(header);
+                if (key !== undefined)
+                    projected[key] = value;
+            }
+            return projected;
+        },
+        /** header → column for every header that writes; for a preview or a receipt. */
+        mapping() {
+            return Object.fromEntries(keyByHeader);
+        },
+        ignored() {
+            return [...ignored.values()];
+        },
+    };
+}
 async function parseXlsxRows(buffer, options) {
     const rows = await parseXlsxWorkbookBuffer(buffer, options);
     const [header, ...body] = rows;

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

@@ -8,6 +8,14 @@ export type GuidedActivationRoutine = {
 export declare const GUIDED_ACTIVATION_POINTERS: readonly ["knowledge", "first_leads_table", "sequence", "sender", "oxygent", "direct_chat", "scan_routine", "briefing_routine"];
 export type GuidedActivationPointer = typeof GUIDED_ACTIVATION_POINTERS[number];
 export type GuidedActivationResources = Partial<Record<GuidedActivationPointer, string>>;
+/** Read projection only. Historical resource/Start identities stay unchanged. */
+export type GuidedActivationConversation = {
+    source_chat_id: string;
+    canonical_chat_id: string;
+    oxygent_id: string;
+    visibility: "workspace" | "personal";
+    history_migration_pending: boolean;
+};
 export declare const GUIDED_ACTIVATION_REVISIONS: readonly ["configuration", "sequence", "audience", "recipients", "sender", "copy", "knowledge", "schedule", "authority"];
 export type GuidedActivationRevisions = Record<typeof GUIDED_ACTIVATION_REVISIONS[number], string>;
 export type GuidedActivationBounds = {

package/node_modules/@oxygen/shared/dist/guided-company-files.d.ts

@@ -0,0 +1,13 @@
+/** Browser-safe budgets for the native guided company-file owner and all transports. */
+export declare const GUIDED_COMPANY_FILE_LIMITS: {
+    readonly textBytes: 1500000;
+    readonly pdfBytes: 5242880;
+    readonly retainedWorkspaceBytes: 1073741824;
+    readonly bodyTimeoutMs: 15000;
+    readonly storageTimeoutMs: 15000;
+    readonly bodyLimitBytes: 5308416;
+    readonly nameBytes: 255;
+};
+export declare const GUIDED_COMPANY_FILE_CONTENT_TYPES: readonly ["text/plain", "text/markdown", "application/pdf"];
+export type GuidedCompanyFileContentType = typeof GUIDED_COMPANY_FILE_CONTENT_TYPES[number];
+export declare function guidedCompanyFileByteLimit(contentType: GuidedCompanyFileContentType): number;

package/node_modules/@oxygen/shared/dist/guided-company-files.js

@@ -0,0 +1,14 @@
+/** Browser-safe budgets for the native guided company-file owner and all transports. */
+export const GUIDED_COMPANY_FILE_LIMITS = {
+    textBytes: 1_500_000,
+    pdfBytes: 5_242_880,
+    retainedWorkspaceBytes: 1_073_741_824,
+    bodyTimeoutMs: 15_000,
+    storageTimeoutMs: 15_000,
+    bodyLimitBytes: 5_308_416,
+    nameBytes: 255,
+};
+export const GUIDED_COMPANY_FILE_CONTENT_TYPES = ["text/plain", "text/markdown", "application/pdf"];
+export function guidedCompanyFileByteLimit(contentType) {
+    return contentType === "application/pdf" ? GUIDED_COMPANY_FILE_LIMITS.pdfBytes : GUIDED_COMPANY_FILE_LIMITS.textBytes;
+}

package/node_modules/@oxygen/shared/dist/guided-first-sourcing.d.ts

@@ -0,0 +1,116 @@
+import type { GuidedOnboardingAnswers, GuidedOnboardingProspectLimitation } from "./guided-onboarding-journey.js";
+export type GuidedFirstSourcingOwner = {
+    organizationId: string;
+    actorId: string;
+    activationId: string;
+};
+export type GuidedFirstSourcingBounds = {
+    targetCount: number;
+    maxPages: number;
+    maxCredits: number;
+};
+export type GuidedFirstSourcingCriteria = {
+    sourceKey: string;
+    digest: string;
+    company: NonNullable<GuidedOnboardingAnswers["company_review"]>;
+    targeting: {
+        filters: Record<string, unknown>;
+        signals: GuidedOnboardingAnswers["signals"];
+        limitations: GuidedOnboardingProspectLimitation[];
+    };
+};
+export type GuidedFirstSourcingQuote = {
+    toolId: "blitzapi.people_search";
+    perPageCredits: number;
+    revision: string;
+    canRun: boolean;
+};
+export type GuidedFirstSourcingPreview = {
+    id: string;
+    activationId: string;
+    actorId: string;
+    activationRevision: number;
+    tableId: string;
+    criteria: GuidedFirstSourcingCriteria;
+    bounds: GuidedFirstSourcingBounds;
+    quote: GuidedFirstSourcingQuote & {
+        pages: number;
+        estimatedCredits: number;
+    };
+    expiresAt: string;
+    digest: string;
+};
+/** Current authority witness, distinct from the provider query's stable identity.
+ * Confirmation revisions, journey generation, navigation and preview/cap expiry
+ * cannot turn the same approved native source into another first pull. */
+export declare function guidedFirstSourcingAudienceWitness(answers: GuidedOnboardingAnswers): {
+    company: string | null;
+    company_size: import("./guided-onboarding-journey.js").GuidedOnboardingChoice | null;
+    markets: import("./guided-onboarding-journey.js").GuidedOnboardingChoice | null;
+    industries: import("./guided-onboarding-journey.js").GuidedOnboardingChoice | null;
+    personas: import("./guided-onboarding-journey.js").GuidedOnboardingChoice | null;
+    signals: {
+        hiring: import("./guided-onboarding-journey.js").GuidedOnboardingSignal;
+        technology: import("./guided-onboarding-journey.js").GuidedOnboardingTechnologySignal;
+    } | null;
+};
+/** Optional GET scope for a current native NIGHTLY quote. The timezone is a
+ * customer/browser IANA suggestion; it never confirms or saves a schedule. */
+export type GuidedFirstSourcingDefaultsRequest = {
+    revision: number;
+    generation: number;
+    timezoneHint: string;
+};
+/** Structural projection of E's actual readonly producer; no native import in shared. */
+export type GuidedFirstSourcingRoutineDefaults = {
+    initial: {
+        sourceIds: string[];
+        limits: {
+            max_examined: number;
+            max_new_leads: number;
+            max_provider_pages: number;
+            max_provider_credits: number;
+        };
+        scanBudget: {
+            per_run_credits: number;
+            daily_credits: number;
+        };
+        briefingBudget: {
+            per_run_credits: number;
+            daily_credits: number;
+        };
+    };
+    sourceNames: Record<string, string>;
+    quote: {
+        provider_credits_per_run: number;
+        inference_credits_per_run: 0;
+        source_quotes: Array<{
+            source_id: string;
+            provider_credits_per_page: number;
+            incremental_mode: "cursor" | "watermark";
+        }>;
+    };
+};
+export type GuidedFirstSourcingRoutineDefaultsScope = GuidedFirstSourcingOwner & GuidedFirstSourcingDefaultsRequest & {
+    sourceKey: string;
+};
+/** Observation metadata stays outside form defaults. Quoted time alone must
+ * never reset edits; consumers reject responses outside their current scope. */
+export type GuidedFirstSourcingRoutineDefaultsReadback = {
+    routineDefaults: null;
+    routineDefaultsScope: null;
+} | {
+    routineDefaults: null;
+    routineDefaultsScope: GuidedFirstSourcingRoutineDefaultsScope & {
+        state: "not_ready";
+    };
+} | {
+    routineDefaults: GuidedFirstSourcingRoutineDefaults;
+    routineDefaultsScope: GuidedFirstSourcingRoutineDefaultsScope & {
+        state: "ready";
+        quoteDigest: string;
+        quotedAt: string;
+        defaultMaxCredits: number;
+        defaultsDigest: string;
+    };
+};

package/node_modules/@oxygen/shared/dist/guided-first-sourcing.js

@@ -0,0 +1,11 @@
+/** Current authority witness, distinct from the provider query's stable identity.
+ * Confirmation revisions, journey generation, navigation and preview/cap expiry
+ * cannot turn the same approved native source into another first pull. */
+export function guidedFirstSourcingAudienceWitness(answers) {
+    return {
+        company: answers.company_review?.statement ?? null,
+        company_size: answers.audience_company_size ?? null, markets: answers.audience_markets ?? null,
+        industries: answers.audience_industries ?? null, personas: answers.audience_personas ?? null,
+        signals: answers.signals ?? null,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { GuidedOnboardingAnswers, GuidedOnboardingStep } from "./guided-onboarding-journey.js";
+/** Only the current step can be edited, never native billing/resources/research.
+ * Validation does not claim a file is owned, a connection exists or results ran. */
+export declare function normalizeGuidedOnboardingAnswers(step: GuidedOnboardingStep, input: unknown): GuidedOnboardingAnswers;

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

@@ -0,0 +1,42 @@
+import { OxygenError } from "./cli-result.js";
+import { validateContract } from "./contracts/schema.js";
+import { GUIDED_ONBOARDING_ANSWERS_CONTRACT } from "./contracts/guided-onboarding-journey.js";
+import { normalizeGuidedOnboardingCompanyContext } from "./guided-onboarding-company-context.js";
+import { normalizeGuidedOnboardingSignals } from "./guided-onboarding-signals.js";
+const fail = (message) => { throw new OxygenError("invalid_onboarding_answer", message, { exitCode: 2 }); };
+const clean = (value) => value.normalize("NFKC").trim().replace(/\s+/gu, " ");
+const choices = (values) => {
+    const names = values.map(clean);
+    if (names.some(value => !value))
+        return fail("Choose a nonempty audience value.");
+    return [...new Map(names.map(value => [value.toLowerCase(), value])).values()];
+};
+/** Only the current step can be edited, never native billing/resources/research.
+ * Validation does not claim a file is owned, a connection exists or results ran. */
+export function normalizeGuidedOnboardingAnswers(step, input) {
+    const checked = validateContract(GUIDED_ONBOARDING_ANSWERS_CONTRACT, input, { unknown: "reject", overMax: "reject" });
+    if (!checked.ok)
+        return fail("Use the reviewed answer fields for this onboarding step.");
+    const answers = checked.value;
+    if (Object.keys(answers).some(key => key !== step))
+        return fail("Save only the current step's answers.");
+    if (answers.company_context)
+        answers.company_context = normalizeGuidedOnboardingCompanyContext(answers.company_context);
+    if (answers.company_review) {
+        const statement = answers.company_review.statement.trim();
+        if (!statement || !/^(?:0|[1-9]\d*)$/.test(answers.company_review.profile_revision))
+            return fail("Review a company statement at the current native profile revision.");
+        answers.company_review = { ...answers.company_review, statement };
+    }
+    for (const key of ["audience_company_size", "audience_markets", "audience_industries", "audience_personas"]) {
+        if (answers[key])
+            answers[key] = { values: choices(answers[key].values) };
+    }
+    if (answers.signals)
+        answers.signals = normalizeGuidedOnboardingSignals(answers.signals);
+    if (answers.prospects)
+        answers.prospects = { ...answers.prospects, feedback: answers.prospects.feedback.trim() };
+    if (answers.tour)
+        answers.tour = { visited: [...new Set(answers.tour.visited)] };
+    return answers;
+}

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

@@ -0,0 +1,22 @@
+import type { GuidedOnboardingAnswers } from "./guided-onboarding-journey.js";
+/** One native-supported input budget for web/CLI/MCP and D research preparation. */
+export declare const GUIDED_ONBOARDING_COMPANY_CONTEXT_LIMITS: {
+    readonly descriptionChars: 6000;
+    readonly contextLinks: 5;
+    readonly fileIds: 5;
+    readonly nameChars: 160;
+    readonly urlChars: 2000;
+};
+export declare const GUIDED_ONBOARDING_COMPANY_CONTEXT_CONTRACT: import("./contracts/schema.js").ContractObject<{
+    readonly website: {
+        oneOf: [import("./contracts/schema.js").StringProperty, import("./contracts/schema.js").NullProperty];
+        description?: string;
+    };
+    readonly name: import("./contracts/schema.js").StringProperty;
+    readonly description: import("./contracts/schema.js").StringProperty;
+    readonly context_links: import("./contracts/schema.js").ArrayProperty<import("./contracts/schema.js").StringProperty>;
+    readonly file_ids: import("./contracts/schema.js").ArrayProperty<import("./contracts/schema.js").StringProperty>;
+}, "context_links" | "description" | "file_ids" | "name" | "website">;
+/** Input-only rule; existing evidence links retain their independent navigation policy. */
+export declare function normalizeGuidedOnboardingContextLink(value: string): string;
+export declare function normalizeGuidedOnboardingCompanyContext(input: unknown): NonNullable<GuidedOnboardingAnswers["company_context"]>;

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

@@ -0,0 +1,38 @@
+import { OxygenError } from "./cli-result.js";
+import { arr, nullable, obj, str, validateContract } from "./contracts/schema.js";
+/** One native-supported input budget for web/CLI/MCP and D research preparation. */
+export const GUIDED_ONBOARDING_COMPANY_CONTEXT_LIMITS = {
+    descriptionChars: 6000, contextLinks: 5, fileIds: 5, nameChars: 160, urlChars: 2000,
+};
+const limits = GUIDED_ONBOARDING_COMPANY_CONTEXT_LIMITS;
+export const GUIDED_ONBOARDING_COMPANY_CONTEXT_CONTRACT = obj({
+    website: nullable(str({ maxLength: limits.urlChars })), name: str({ maxLength: limits.nameChars }),
+    description: str({ maxLength: limits.descriptionChars }),
+    context_links: arr(str({ minLength: 1, maxLength: limits.urlChars }), { maxItems: limits.contextLinks }),
+    file_ids: arr(str({ minLength: 1, maxLength: 160 }), { maxItems: limits.fileIds }),
+}, { required: ["website", "name", "description", "context_links", "file_ids"] });
+const fail = (message) => { throw new OxygenError("invalid_onboarding_answer", message, { exitCode: 2 }); };
+/** Input-only rule; existing evidence links retain their independent navigation policy. */
+export function normalizeGuidedOnboardingContextLink(value) {
+    try {
+        const url = new URL(value.includes("://") ? value : `https://${value}`);
+        if (url.protocol !== "https:" || url.username || url.password || !url.hostname.includes("."))
+            return fail("Use an HTTPS website or context link without credentials.");
+        return url.href;
+    }
+    catch {
+        return fail("Use a valid HTTPS website or context link.");
+    }
+}
+export function normalizeGuidedOnboardingCompanyContext(input) {
+    const checked = validateContract(GUIDED_ONBOARDING_COMPANY_CONTEXT_CONTRACT, input, { unknown: "reject", overMax: "reject" });
+    if (!checked.ok)
+        return fail("Use up to 6000 description characters, five context links and five Knowledge files.");
+    const value = checked.value;
+    const website = value.website?.trim() ? normalizeGuidedOnboardingContextLink(value.website.trim()) : null;
+    const description = value.description.trim();
+    if (!website && !description)
+        return fail("Provide a website or describe your company.");
+    return { website, name: value.name.normalize("NFKC").trim().replace(/\s+/gu, " "), description,
+        context_links: [...new Set(value.context_links.map(link => normalizeGuidedOnboardingContextLink(link.trim())))], file_ids: [...new Set(value.file_ids)] };
+}

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

@@ -0,0 +1,147 @@
+/** Full DEV onboarding, approved by Philipp on 2026-10-16.
+ * Browser-safe vocabulary. Native owners, never navigation or caller assertions,
+ * establish research results, billing eligibility and resource authority. */
+export declare const GUIDED_ONBOARDING_JOURNEY_VERSION: 1;
+export declare const GUIDED_ONBOARDING_PART1_STEPS: readonly ["company_context", "company_research", "company_review", "audience_company_size", "audience_markets", "audience_industries", "audience_personas", "signals", "prospects", "trial"];
+export declare const GUIDED_ONBOARDING_PART2_STEPS: readonly ["welcome", "daily_rhythm", "linkedin", "campaign", "sequence", "routines", "tour"];
+export declare const GUIDED_ONBOARDING_STEPS: readonly ["company_context", "company_research", "company_review", "audience_company_size", "audience_markets", "audience_industries", "audience_personas", "signals", "prospects", "trial", "welcome", "daily_rhythm", "linkedin", "campaign", "sequence", "routines", "tour", "complete"];
+export type GuidedOnboardingStep = typeof GUIDED_ONBOARDING_STEPS[number];
+export type GuidedOnboardingPart = "part1" | "part2" | "complete";
+export declare function guidedOnboardingPart(step: GuidedOnboardingStep): GuidedOnboardingPart;
+export type GuidedOnboardingChoice = {
+    values: string[];
+};
+export type GuidedOnboardingSignal = {
+    mode: "none" | "selected";
+    values: string[];
+};
+export declare const GUIDED_ONBOARDING_TECHNOLOGY_RELATIONSHIPS: readonly ["uses", "replaces", "integrates_with"];
+export type GuidedOnboardingTechnologyRelationship = typeof GUIDED_ONBOARDING_TECHNOLOGY_RELATIONSHIPS[number];
+export type GuidedOnboardingTechnology = {
+    name: string;
+    relationship: GuidedOnboardingTechnologyRelationship;
+};
+export type GuidedOnboardingTechnologySignal = {
+    mode: "none" | "selected";
+    values: GuidedOnboardingTechnology[];
+};
+export type GuidedOnboardingAnswers = {
+    company_context?: {
+        website: string | null;
+        name: string;
+        description: string;
+        context_links: string[];
+        file_ids: string[];
+    };
+    /** Saving a statement alone is not its native confirmation receipt. */
+    company_review?: {
+        statement: string;
+        profile_revision: string;
+    };
+    audience_company_size?: GuidedOnboardingChoice;
+    audience_markets?: GuidedOnboardingChoice;
+    audience_industries?: GuidedOnboardingChoice;
+    audience_personas?: GuidedOnboardingChoice;
+    signals?: {
+        hiring: GuidedOnboardingSignal;
+        technology: GuidedOnboardingTechnologySignal;
+    };
+    prospects?: {
+        decision: "continue" | "refine";
+        feedback: string;
+    };
+    /** Connect is an intent. Only the native sender owner can prove a connection. */
+    linkedin?: {
+        choice: "connect" | "skip";
+    };
+    /** A draft remains a valid outcome on the optional LinkedIn branch. */
+    sequence?: {
+        decision: "review" | "keep_draft";
+    };
+    tour?: {
+        visited: Array<"overview" | "leads" | "sourcing" | "sequence">;
+    };
+};
+export type GuidedOnboardingResearchStatus = "not_started" | "running" | "completed" | "partial" | "unavailable" | "failed" | "credits_exhausted";
+export type GuidedOnboardingResearch = {
+    status: GuidedOnboardingResearchStatus;
+    run_id: string | null;
+    knowledge_page_ids: string[];
+    /** Fixed customer-safe code only. Provider diagnostics remain in their owner. */
+    fault: {
+        code: string;
+        retryable: boolean;
+    } | null;
+};
+export type GuidedOnboardingProspect = {
+    row_id: string;
+    person_key: string;
+    name: string;
+    title: string;
+    company: string;
+    linkedin_url: string | null;
+    sources: Array<{
+        url: string;
+        title: string;
+    }>;
+    fit: {
+        rationale: string;
+        criteria: string[];
+    };
+};
+export type GuidedOnboardingProspectLimitation = {
+    field: string;
+    code: "unsupported_filter";
+    blocking: boolean;
+    message: string;
+    values: string[];
+    suggestions: string[];
+};
+export type GuidedOnboardingProspects = {
+    status: "not_started" | "running" | "ready" | "partial" | "empty" | "unavailable" | "failed" | "credits_exhausted";
+    table_id: string | null;
+    ingestion_run_ids: string[];
+    /** Up to five native source-backed people; an empty array is never success. */
+    people: GuidedOnboardingProspect[];
+    /** Absent in legacy receipts means unknown, never proof of supported filters.
+     * Current D projections supply actual structured diagnostics, including []. */
+    limitations?: GuidedOnboardingProspectLimitation[];
+    fault: {
+        code: string;
+        retryable: boolean;
+    } | null;
+};
+/** Read projection from native billing, not an accepted browser mutation field.
+ * I owns the actual test Checkout/subscription/grant producer and its signatures. */
+export type GuidedOnboardingEligibility = {
+    state: "unverified" | "checkout_required" | "checkout_pending" | "eligible" | "unavailable";
+    basis: "paid" | "trial" | null;
+    subscription_id: string | null;
+    observed_at: string | null;
+    trial_ends_at: string | null;
+};
+export type GuidedOnboardingJourney = {
+    version: typeof GUIDED_ONBOARDING_JOURNEY_VERSION;
+    /** Increments on non-destructive restart; activation revision guards writes. */
+    generation: number;
+    step: GuidedOnboardingStep;
+    completed_steps: GuidedOnboardingStep[];
+    /** Presentation state is authoritative and independent of deduplicated history. */
+    navigation: {
+        paused: boolean;
+        tour_active_stop: "overview" | "leads" | "sourcing" | "sequence" | null;
+    };
+    answers: GuidedOnboardingAnswers;
+    /** Native confirmation binds the actual typed company profile revision. */
+    company_confirmation: {
+        profile_revision: string;
+        statement_digest: string;
+        confirmed_at: string;
+    } | null;
+    research: GuidedOnboardingResearch;
+    prospects: GuidedOnboardingProspects;
+};
+/** Free initialization; creates no research, chat turn, subscription or resource. */
+export declare function createGuidedOnboardingJourney(): GuidedOnboardingJourney;
+/** Old saved v1 records have no current-stop evidence. Never guess from visited[]. */
+export declare function normalizeSavedGuidedOnboardingJourney(journey: GuidedOnboardingJourney): GuidedOnboardingJourney;

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

@@ -0,0 +1,12 @@
+import { type GuidedOnboardingJourney, type GuidedOnboardingEligibility } from "./guided-onboarding-journey.js";
+/** Synthetic component/test data only. Never substitute this for hosted receipts. */
+export declare const GUIDED_ONBOARDING_FIXTURE_NAMES: readonly ["part1_initial", "research_running", "company_review", "audience_question", "technology_relationships", "prospects_ready", "prospects_partial", "prospects_empty", "prospects_unavailable", "prospects_failed", "research_failed", "credits_exhausted", "checkout_pending", "billing_unavailable", "part2_trial", "part2_paid", "linkedin_skipped", "tour_paused_back", "complete"];
+export type GuidedOnboardingFixtureName = typeof GUIDED_ONBOARDING_FIXTURE_NAMES[number];
+export type GuidedOnboardingFixture = {
+    fixture_only: true;
+    label: string;
+    activation_revision: number;
+    journey: GuidedOnboardingJourney;
+    eligibility: GuidedOnboardingEligibility;
+};
+export declare function createGuidedOnboardingFixture(name: GuidedOnboardingFixtureName): GuidedOnboardingFixture;