@oxygen-agent/cli 1.1014.1035 → 1.1014.1087

package/node_modules/@oxygen/shared/dist/contracts/operations.d.ts

@@ -33,6 +33,12 @@ export type OperationSpec<C extends ContractObject = ContractObject> = {
         nameField: string;
         typeField: string;
         fileField: string;
+        /** Opt-in metadata derived from the original --file bytes. Explicit caller
+         * assertions must match; required native fields remain required on the wire. */
+        fileMetadata?: {
+            sha256Field: string;
+            sizeBytesField: string;
+        };
     };
     /** Download bytes through the same authenticated route; never follow redirects. */
     binary?: {

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -12,6 +12,9 @@ import { BROWSER_OPERATIONS } from "./browser-operations.js";
 import { TABLE_FEED_UPDATE_OPERATION } from "./table-feed-update.js";
 import { GEO_OPERATIONS } from "./geo.js";
 import { CUSTOMER_OPERATIONS } from "./customer-operations.js";
+import { GUIDED_ONBOARDING_JOURNEY_OPERATIONS } from "./guided-onboarding-journey.js";
+import { GUIDED_FIRST_SOURCING_OPERATIONS } from "./guided-first-sourcing.js";
+import { GUIDED_COMPANY_FILE_UPLOAD_OPERATION } from "./guided-company-files.js";
 import { GUIDED_ACTIVATION_OPERATIONS } from "./guided-activation.js";
 import { AGENT_SESSION_OPERATIONS } from "./agent-sessions.js";
 import { TEAMMATE_OPERATIONS } from "./teammates.js";
@@ -79,7 +82,9 @@ export function operationFormData(spec, body) {
     if (!fields)
         throw new Error("This operation does not accept a file.");
     const encoded = body[fields.contentField];
-    if (typeof encoded !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded) || !encoded) {
+    // A repeated capture over multi-megabyte uploads can overflow V8's regexp
+    // stack. Validate the same alphabet, length and terminal padding separately.
+    if (typeof encoded !== "string" || !encoded || encoded.length % 4 !== 0 || /[^A-Za-z0-9+/]/u.test(encoded.replace(/={1,2}$/u, ""))) {
         throw new Error(`${fields.contentField} must contain valid non-empty base64 file bytes.`);
     }
     const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
@@ -92,6 +97,6 @@ export function operationFormData(spec, body) {
     }
     return form;
 }
-export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS];
-export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
-export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...GUIDED_ONBOARDING_JOURNEY_OPERATIONS, ...GUIDED_FIRST_SOURCING_OPERATIONS, GUIDED_COMPANY_FILE_UPLOAD_OPERATION, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS];
+export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...GUIDED_ONBOARDING_JOURNEY_OPERATIONS, ...GUIDED_FIRST_SOURCING_OPERATIONS, GUIDED_COMPANY_FILE_UPLOAD_OPERATION, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
+export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS, ...GUIDED_ACTIVATION_OPERATIONS, ...GUIDED_ONBOARDING_JOURNEY_OPERATIONS, ...GUIDED_FIRST_SOURCING_OPERATIONS, GUIDED_COMPANY_FILE_UPLOAD_OPERATION, ...TEAMMATE_OPERATIONS, ...WORKSPACE_SKILL_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);

package/node_modules/@oxygen/shared/dist/contracts/table-query-raw.d.ts

@@ -11,4 +11,6 @@ export declare const TABLE_QUERY_RAW_CONTRACT: import("./schema.js").ContractObj
 export declare const TABLE_QUERY_CLI_DEFAULT_LIMIT = 20;
 export declare const TABLE_QUERY_CLI_DEFAULT_MAX_CHARS = 12000;
 export declare function tableQueryRawResultFits(data: Record<string, unknown>, maxChars: number | undefined): boolean;
+/** What a page shortened to fit its result window says to do next (CLI, MCP and API alike). */
+export declare const TABLE_QUERY_RESULT_WINDOW_NEXT_STEP: string;
 export declare function tableQueryRawRecovery(table: string, row?: string): Record<string, unknown>;

package/node_modules/@oxygen/shared/dist/contracts/table-query-raw.js

@@ -9,6 +9,9 @@ export const TABLE_QUERY_CLI_DEFAULT_MAX_CHARS = 12_000;
 export function tableQueryRawResultFits(data, maxChars) {
     return maxChars === undefined || JSON.stringify(success("tables query", data)).length <= maxChars;
 }
+/** What a page shortened to fit its result window says to do next (CLI, MCP and API alike). */
+export const TABLE_QUERY_RESULT_WINDOW_NEXT_STEP = "This page holds fewer rows than the limit so it fits the result window; every value is complete. "
+    + "Continue with nextCursor (same table, filters, sorts and fields), or select fewer fields for more rows per page.";
 export function tableQueryRawRecovery(table, row) {
     return {
         table,

package/node_modules/@oxygen/shared/dist/contracts/teammates.js

@@ -53,20 +53,20 @@ export const TEAMMATE_OPERATIONS = [
     // Adding a teammate (phase 7): a custom Agent that can chat at once and run
     // on its own, under a policy that asks before any write, send or spend. As in
     // Grok Bot, it can start as just "New Bot" and learn its job in the chat.
-    teammateOperation("teammates.create", "create", "POST", "", `Add an Oxygent to the workspace, named "${NEW_TEAMMATE_NAME}" unless you name it; tell it its job in your chat with it. It can chat at once and run on its own (background tasks, routines), reading freely and asking before anything that writes, sends or spends. You own it. Workspace access and a shared chat are the default; choose personal for creator-only access. Free: adding one starts no inference.`, {
+    teammateOperation("teammates.create", "create", "POST", "", `Add an Oxygent to the workspace, named "${NEW_TEAMMATE_NAME}" unless you name it; tell it its job in your chat with it. It can chat at once and run on its own (background tasks, routines), reading freely and asking before anything that writes, sends or spends. You own it. Workspace access as collaborators and a shared chat are the default; choose personal for creator-only access. Free: adding one starts no inference.`, {
         ...TEAMMATE_PROFILE_FIELDS,
-        visibility: enumOf(["workspace", "personal"], { description: "Workspace (default) shares one chat history with everyone who has access. Personal is accessible only to its creator here, including against workspace admins. An API key acts as the person who issued it." }),
+        visibility: enumOf(["workspace", "personal"], { description: "Workspace (default) shares one chat history with everyone who has access. Personal is accessible only to its creator here, including against workspace admins. Explicitly saving to team memory publishes that entry to the workspace. An API key acts as the person who issued it." }),
         slug: str({ minLength: 2, maxLength: 49, pattern: TEAMMATE_SLUG_PATTERN, description: "Its permanent handle in commands and links; made from the name when omitted." }),
     }),
     teammateOperation("teammates.get", "get", "GET", "/{slug}", "Read one Oxygent's profile and its ongoing chat and visibility."),
-    teammateOperation("teammates.update", "update", "PATCH", "/{slug}", "Edit an Oxygent's profile as its owner, manager or a workspace admin. Only its owner can change visibility, with confirm_visibility. History is kept in both directions: Workspace shares it all; Personal removes others' future access but cannot retract what they saw. Home stays Workspace. Free.", { ...TEAMMATE_PROFILE_FIELDS, visibility: enumOf(["workspace", "personal"], { description: "Only the owner can change visibility. Workspace shares the complete history; Personal retains all messages, removes additional grants and everyone else's future access. Home stays Workspace." }), confirm_visibility: bool({ description: "Required when changing visibility: publishing shares all history; making personal removes everyone else's future access but cannot retract what they saw." }) }),
+    teammateOperation("teammates.update", "update", "PATCH", "/{slug}", "Edit an Oxygent's profile, or change visibility as its owner with confirm_visibility. Owners, managers and workspace admins can edit profiles. History is kept in both directions: Workspace shares it all; Personal removes others' future access but cannot retract what they saw. Home (the first Oxygent) stays Workspace. Free.", { ...TEAMMATE_PROFILE_FIELDS, visibility: enumOf(["workspace", "personal"], { description: "Only the owner can change visibility. Workspace grants everyone collaborator access and shares the complete history; Personal retains all messages, removes additional grants and everyone else's future access. Explicitly saving to team memory publishes that entry to the workspace. Home (the first Oxygent) stays Workspace." }), confirm_visibility: bool({ description: "Required when changing visibility: publishing shares all history; making personal removes everyone else's future access but cannot retract what they saw." }) }),
     // Sharing (Tim, 2026-10-14: "make agents accessible to your team mates"), the
     // way Grok Bot shares a Bot: everyone in the workspace, or people by email,
     // each as a collaborator or a manager, with one ongoing shared chat.
-    teammateOperation("teammates.access", "access", "GET", "/{slug}/access", "Read access (visibility, owner, everyone, named people with roles, fixed and your permissions), without chat history. A collaborator uses its shared chat; a manager also changes its profile and access. Personal is creator-only; Home is fixed. Free."),
+    teammateOperation("teammates.access", "access", "GET", "/{slug}/access", "Read access (visibility, owner, everyone, named people with roles, fixed and your permissions), without chat history. A collaborator uses its shared chat; a manager also changes its profile and access. Personal is creator-only; Home (the first Oxygent) is fixed. Free."),
     teammateOperation("teammates.share", "share", "POST", "/{slug}/access", "Share an Oxygent with teammates, or stop sharing it: with everyone in the workspace (everyone), or with people by their workspace email (add, as role; remove). Everyone with access reads the same chat history. Personal Oxygents cannot be shared; change visibility explicitly first. Its owner, its managers or a workspace admin only; never the first Oxygent, which is everyone's. Free.", {
         everyone: enumOf([...TEAMMATE_SHARE_ROLES, "off"], {
-            description: "Workspace-wide role: collaborator, manager, or off (owner and named people, with workspace admins retaining management access). This restricts a Workspace Oxygent's audience; it does not make it Personal or split its shared chat.",
+            description: "Workspace-wide role: collaborator (the default), manager, or off (owner and named people, with workspace admins retaining management access). This restricts a Workspace Oxygent's audience; it does not make it Personal or split its shared chat.",
         }),
         add: arr(str({ minLength: 3, maxLength: 320 }), { maxItems: 50, description: "People to share it with, by their workspace email." }),
         role: enumOf([...TEAMMATE_SHARE_ROLES], {
@@ -80,7 +80,7 @@ export const TEAMMATE_OPERATIONS = [
     // Copy and delete (Tim, 2026-10-13: "CRUD actions ... through the right
     // click"; "'delete' should be 'full delete'"), as Grok Bot's Bot menu has.
     teammateOperation("teammates.duplicate", "duplicate", "POST", "/{slug}/duplicate", `Copy an Oxygent as a new one you own, named "<name> copy" unless you name it: its job, look, instructions, skills and tool settings, but not its chats, memory, routines or who it is shared with. The copy defaults to Workspace; choose Personal for creator-only access. Free.`, {
-        visibility: enumOf(["workspace", "personal"], { description: "Visibility of the copy; Workspace by default. No history is copied." }),
+        visibility: enumOf(["workspace", "personal"], { description: "Visibility of the copy; Workspace by default. No history is copied. Explicitly saving to team memory publishes that entry to the workspace." }),
         name: str({
             minLength: 1, maxLength: TEAMMATE_NAME_MAX_CHARS,
             description: "What everyone calls the copy. Its slug is made from the name, and a deleted Oxygent's slug stays taken, so a copy can get a numbered one (scout-2).",
@@ -115,7 +115,7 @@ export const TEAMMATE_OPERATIONS = [
     teammateOperation("teammates.memory", "memory", "GET", "/{slug}/memory", "List what the team asked an Oxygent to remember. Every chat with it reads this; it is a Knowledge page."),
     teammateOperation("teammates.remember", "remember", "POST", "/{slug}/memory", "Add one thing to an Oxygent's team memory: every chat with it reads it, and the whole workspace can see it. Free.", { text: str({ minLength: 1, maxLength: 500 }) }, ["text"]),
     teammateOperation("teammates.forget", "forget", "DELETE", "/{slug}/memory/{entry_id}", "Remove one entry from an Oxygent's team memory."),
-    teammateOperation("teammates.notes", "notes", "GET", "/{slug}/notes", "Read what an Oxygent keeps about you: private to you, read only in your own chat with it."),
+    teammateOperation("teammates.notes", "notes", "GET", "/{slug}/notes", "Read what an Oxygent keeps about you. Private to you; never included in shared Workspace or multi-person group chats."),
     teammateOperation("teammates.notes_set", "notes_set", "POST", "/{slug}/notes", "Replace what an Oxygent keeps about you; empty clears it. Private to you.", { notes: str({ maxLength: 4000 }) }, ["notes"]),
     teammateOperation("teammates.activity", "activity", "GET", "/{slug}/activity", "List an Oxygent's recent work: its runs and the actions taken in its chats, as metadata only (no goals or messages)."),
     teammateGroupOperation("teammate_groups.list", "groups", "GET", "", "List the group chats you are in: name, Oxygents, people (each an admin or member) and the chat (working or waiting for you, unread, the latest words and who said them). Candidates are the teammates a new group chat could bring in."),

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

@@ -37,6 +37,8 @@ export type EmailTrackingTokenPayload = {
     enr?: string;
     /** Issued-at (epoch ms), recorded as provenance. */
     iat: number;
+    /** Diagnostic copy test: preserve transport rendering without campaign analytics. */
+    diagnostic?: true;
 };
 /** SHA-256 hex of a destination URL — the value bound into a click token's `uh`. */
 export declare function hashTrackingUrl(url: string): string;

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