@oxygen-agent/cli 1.1014.1035 → 1.1014.1132

package/node_modules/@oxygen/shared/dist/email-tracking-token.js

@@ -45,6 +45,7 @@ function parseTokenPayload(body) {
         ...(uh ? { uh } : {}),
         ...(typeof candidate.seq === "string" && candidate.seq ? { seq: candidate.seq } : {}),
         ...(typeof candidate.enr === "string" && candidate.enr ? { enr: candidate.enr } : {}),
+        ...(candidate.diagnostic === true ? { diagnostic: true } : {}),
         iat: typeof candidate.iat === "number" && Number.isFinite(candidate.iat) ? candidate.iat : 0,
     };
 }

package/node_modules/@oxygen/shared/dist/feature-gates.d.ts

@@ -71,10 +71,9 @@ export type FeatureGateResolution = {
  * - OXYGEN_AGENTS_ENABLED — (b). Authorizes autonomous Agent run execution —
  *   tool authority AND credit spend (`apps/web/src/lib/agent-runtime.ts`,
  *   `apps/worker/src/agent-cycle.ts`). Same class as publishing.
- * - OXYGEN_AGENTS_WORKSPACE_IDS — (b). Which workspaces that execution may run
- *   in (`packages/shared/src/agents-enabled.ts`); production also requires its
- *   reviewed PRODUCTION_AGENT_WORKSPACE_IDS, so a wrong "on" for a customer's
- *   workspace there needs a code change as well.
+ * - OXYGEN_AGENTS_WORKSPACE_IDS — (b). Which workspaces the "staff" stage of
+ *   that execution may run in (`packages/shared/src/agents-enabled.ts`);
+ *   production also requires its reviewed PRODUCTION_AGENT_WORKSPACE_IDS.
  * - OXYGEN_REPRICING_2026_09_EFFECTIVE_AT — (b). The instant every held price
  *   rise and limit cut of the 2026-09 repricing takes effect
  *   (`packages/shared/src/repricing.ts`). A remotely flippable value would let

package/node_modules/@oxygen/shared/dist/feature-gates.js

@@ -62,10 +62,9 @@
  * - OXYGEN_AGENTS_ENABLED — (b). Authorizes autonomous Agent run execution —
  *   tool authority AND credit spend (`apps/web/src/lib/agent-runtime.ts`,
  *   `apps/worker/src/agent-cycle.ts`). Same class as publishing.
- * - OXYGEN_AGENTS_WORKSPACE_IDS — (b). Which workspaces that execution may run
- *   in (`packages/shared/src/agents-enabled.ts`); production also requires its
- *   reviewed PRODUCTION_AGENT_WORKSPACE_IDS, so a wrong "on" for a customer's
- *   workspace there needs a code change as well.
+ * - OXYGEN_AGENTS_WORKSPACE_IDS — (b). Which workspaces the "staff" stage of
+ *   that execution may run in (`packages/shared/src/agents-enabled.ts`);
+ *   production also requires its reviewed PRODUCTION_AGENT_WORKSPACE_IDS.
  * - OXYGEN_REPRICING_2026_09_EFFECTIVE_AT — (b). The instant every held price
  *   rise and limit cut of the 2026-09 repricing takes effect
  *   (`packages/shared/src/repricing.ts`). A remotely flippable value would let

package/node_modules/@oxygen/shared/dist/file-import.d.ts

@@ -76,6 +76,52 @@ export declare function normalizeRowsForNewTable(rows: Record<string, unknown>[]
  */
 export declare function dropBlankImportCells(row: Record<string, unknown>, keepKey?: string | null): Record<string, unknown>;
 export declare function normalizeImportColumnKey(value: string): string;
+/**
+ * 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 declare function readImportHeaderList(value: unknown): string[];
+/** A column of the table an import writes into. */
+export type ImportTargetColumn = {
+    key: string;
+    label?: string | null;
+};
+/** Why a file column was not written. */
+export type IgnoredImportHeaderReason = "not_selected" | "no_matching_column" | "duplicate_target" | "system_column";
+export type IgnoredImportHeader = {
+    header: string;
+    reason: IgnoredImportHeaderReason;
+    column?: string;
+};
+/**
+ * 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 declare function createImportHeaderProjector(input: {
+    columns: readonly ImportTargetColumn[];
+    explicitMap?: Readonly<Record<string, string>> | null;
+    ignore?: readonly string[] | null;
+}): {
+    /** Resolve any headers first seen in these rows; earlier decisions stand. */
+    observe(rows: readonly Record<string, unknown>[]): void;
+    /** The row with every key renamed to its column, unwritten headers dropped. */
+    project(row: Record<string, unknown>): Record<string, unknown>;
+    /** header → column for every header that writes; for a preview or a receipt. */
+    mapping(): Record<string, string>;
+    ignored(): IgnoredImportHeader[];
+};
 /**
  * Refuse a JSON or XLSX file over the buffered-parse ceiling before anything is
  * uploaded or queued. CSV and JSONL stream, so they pass at any size and only

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)] };
+}