@oxygen-agent/cli 1.1011.322 → 1.1011.405

package/node_modules/@oxygen/shared/dist/decision-ledger.js

@@ -0,0 +1,20 @@
+import { DECISION_LEDGER_ENTRIES } from "./decision-ledger.generated.js";
+export { parseDecisionLedger } from "./decision-ledger-parser.js";
+const DECISIONS_BY_ID = new Map(DECISION_LEDGER_ENTRIES.map((entry) => [entry.id, entry]));
+/**
+ * The ledger entry for a decision id. An exact id wins ("D34a" is its own
+ * decision); otherwise an answer-option suffix resolves to its base decision
+ * ("D19a" and "D19(a)" are D19's option (a)).
+ */
+export function getDecision(id) {
+    const key = id.trim();
+    const exact = DECISIONS_BY_ID.get(key);
+    if (exact)
+        return exact;
+    const base = /^(D\d+)(?:[a-z]|\([a-z]\))$/.exec(key)?.[1];
+    return base ? DECISIONS_BY_ID.get(base) ?? null : null;
+}
+/** Every ledger entry, sorted by decision id. */
+export function listDecisions() {
+    return DECISION_LEDGER_ENTRIES;
+}

package/node_modules/@oxygen/shared/dist/mcp-event-contract.d.ts

@@ -16,12 +16,18 @@ export type McpReplyClassification = (typeof MCP_REPLY_CLASSIFICATIONS)[number];
 export declare const MCP_REPLY_CHANNELS: readonly ["email", "linkedin", "whatsapp"];
 /** How an enrollment ended: the Sequencer's own terminal statuses. */
 export declare const MCP_ENROLLMENT_OUTCOMES: readonly ["completed", "replied", "stopped", "failed", "excluded"];
-/** The run ledgers `run_outcome_analytics` reads (`SettledRunKind` in @oxygen/tenant-db). */
-export declare const MCP_RUN_KINDS: readonly ["workflow", "table_action", "table_ingestion", "agent", "copilot_turn"];
+/**
+ * The durable-run ledgers `run_outcome_analytics` reads (`SettledRunKind` in
+ * @oxygen/tenant-db), without Workspace Copilot turns: a turn is attended and
+ * private to its member, the own-action guard already drops a subscriber's own
+ * turns, and delivering other members' turns would expose private activity
+ * with deep links the subscriber may not be able to open.
+ */
+export declare const MCP_RUN_KINDS: readonly ["workflow", "table_action", "table_ingestion", "agent"];
 export type McpRunKind = (typeof MCP_RUN_KINDS)[number];
 /**
  * Every terminal status those ledgers write, with one spelling of cancel:
- * Workflow and Table runs write `canceled`, Agent runs and Copilot turns `cancelled`.
+ * Workflow and Table runs write `canceled`, Agent runs `cancelled`.
  */
 export declare const MCP_RUN_STATUSES: readonly ["completed", "completed_with_errors", "failed", "canceled", "budget_exhausted", "effect_unknown"];
 export type McpRunStatus = (typeof MCP_RUN_STATUSES)[number];
@@ -285,7 +291,7 @@ declare const RECORD_STAGE_CHANGED_PAYLOAD: ContractObject<{
 declare const RUN_SETTLED_PAYLOAD: ContractObject<{
     readonly kind: {
         type: "string";
-        enum: readonly ("agent" | "copilot_turn" | "table_action" | "table_ingestion" | "workflow")[];
+        enum: readonly ("agent" | "table_action" | "table_ingestion" | "workflow")[];
         description?: string;
     };
     readonly status: {
@@ -574,9 +580,6 @@ export type McpRunSettledSource = McpRunSettledCommon & ({
 } | {
     kind: "agent";
     agentSlug: string;
-} | {
-    kind: "copilot_turn";
-    copilotSessionId: string;
 });
 /** A settled run as `run.settled`. Its producer is OXP-11.5.21. */
 export declare function projectRunSettledEvent(source: McpRunSettledSource, context?: McpEventLinkOptions): McpRunSettledPayload;

package/node_modules/@oxygen/shared/dist/mcp-event-contract.js

@@ -59,11 +59,17 @@ const REPLY_LABELS_DELIVERED_AS_IS = new Set([
 export const MCP_REPLY_CHANNELS = ["email", "linkedin", "whatsapp"];
 /** How an enrollment ended: the Sequencer's own terminal statuses. */
 export const MCP_ENROLLMENT_OUTCOMES = SEQUENCE_TERMINAL_STATUSES;
-/** The run ledgers `run_outcome_analytics` reads (`SettledRunKind` in @oxygen/tenant-db). */
-export const MCP_RUN_KINDS = ["workflow", "table_action", "table_ingestion", "agent", "copilot_turn"];
+/**
+ * The durable-run ledgers `run_outcome_analytics` reads (`SettledRunKind` in
+ * @oxygen/tenant-db), without Workspace Copilot turns: a turn is attended and
+ * private to its member, the own-action guard already drops a subscriber's own
+ * turns, and delivering other members' turns would expose private activity
+ * with deep links the subscriber may not be able to open.
+ */
+export const MCP_RUN_KINDS = ["workflow", "table_action", "table_ingestion", "agent"];
 /**
  * Every terminal status those ledgers write, with one spelling of cancel:
- * Workflow and Table runs write `canceled`, Agent runs and Copilot turns `cancelled`.
+ * Workflow and Table runs write `canceled`, Agent runs `cancelled`.
  */
 export const MCP_RUN_STATUSES = [
     "completed",
@@ -160,7 +166,7 @@ const RUN_SETTLED_INPUT = obj({
 });
 const RUN_SETTLED_PAYLOAD = payloadObject({
     kind: enumOf(MCP_RUN_KINDS, {
-        description: "What ran: a Workflow run, a Table action run, a Table import (`table_ingestion`), an Agent run or a Workspace Copilot turn.",
+        description: "What ran: a Workflow run, a Table action run, a Table import (`table_ingestion`) or an Agent run.",
     }),
     status: enumOf(MCP_RUN_STATUSES, {
         description: "How it ended. An Agent run can also end `budget_exhausted` or `effect_unknown`.",
@@ -189,7 +195,7 @@ export const MCP_EVENT_DEFINITIONS = [
     eventDefinition("enrollment.ended", "A lead's enrollment in an OXYGEN Sequence ended: the lead replied, every step was sent, the enrollment was stopped or excluded, or sending failed.", ENROLLMENT_ENDED_INPUT, ENROLLMENT_ENDED_PAYLOAD),
     eventDefinition("meeting.completed", "OXYGEN's Meeting Notetaker finished processing a recorded meeting; its transcript and meeting note are ready in OXYGEN.", MEETING_COMPLETED_INPUT, MEETING_COMPLETED_PAYLOAD),
     eventDefinition("record.stage_changed", "A CRM record's stage changed in OXYGEN, such as a person's lead stage, a company's account stage or a deal's pipeline stage.", RECORD_STAGE_CHANGED_INPUT, RECORD_STAGE_CHANGED_PAYLOAD),
-    eventDefinition("run.settled", "A run in OXYGEN reached its final status: a Workflow run, a Table action run or import, an Agent run, or a Workspace Copilot turn.", RUN_SETTLED_INPUT, RUN_SETTLED_PAYLOAD),
+    eventDefinition("run.settled", "A run in OXYGEN reached its final status: a Workflow run, a Table action run or import, or an Agent run.", RUN_SETTLED_INPUT, RUN_SETTLED_PAYLOAD),
     eventDefinition("approval.requested", "A Workflow run or an Agent run in OXYGEN paused and is waiting for a person to approve its next step.", APPROVAL_REQUESTED_INPUT, APPROVAL_REQUESTED_PAYLOAD),
 ];
 const DEFINITIONS_BY_NAME = new Map(MCP_EVENT_DEFINITIONS.map((entry) => [entry.name, entry]));
@@ -574,8 +580,6 @@ function runPath(source) {
             return `/tables/${encodeURIComponent(source.tableId)}/ingestions/${encodeURIComponent(source.runId)}`;
         case "agent":
             return agentRunPath(source.agentSlug, source.runId);
-        case "copilot_turn":
-            return `/copilot/${encodeURIComponent(source.copilotSessionId)}`;
     }
 }
 // Every catalogue projection first proves the row is that event, so a reader

package/node_modules/@oxygen/shared/dist/mcp-table-widget.d.ts

@@ -0,0 +1,50 @@
+export declare const TABLE_WIDGET_NAME = "oxygen.table";
+/** A run filling the Table, shown as progress until it reaches a terminal state. */
+export type TableWidgetRun = {
+    kind: "ingestion" | "column_run";
+    id: string;
+    status: string;
+    terminal: boolean;
+    /** Settled / total work items in this run (chunks for an ingestion), not Table rows. */
+    rowsDone?: number | null;
+    rowsTarget?: number | null;
+    creditsUsed?: number | null;
+    creditsCap?: number | null;
+};
+export type TableWidgetGridPage = {
+    /** SerializedWorkspaceColumn[] from the web grid serializer. */
+    columns: unknown[];
+    /** SerializedWorkspaceTableRow[] from the web grid serializer. */
+    rows: unknown[];
+    cellStates?: Record<string, Record<string, unknown>> | null;
+    rowCount?: number | null;
+    hasMore?: boolean;
+    nextCursor?: string | null;
+    /**
+     * SerializedWorkspaceColumnStats[], the grid's column stats: what it
+     * collapses as empty, its header fill lines and run bars. Only a first page
+     * carries them, and only when they answered in time.
+     */
+    columnStats?: unknown[] | null;
+    /**
+     * An empty first page's fill state, the body of GET
+     * /api/tables/<id>/fill-progress: rows still being written, a failed fill,
+     * or neither.
+     */
+    fillProgress?: Record<string, unknown> | null;
+};
+export type TableWidgetPayload = {
+    version: 1;
+    /** "table": rows of a saved Table. "preview": sample rows of a search that saved nothing yet. */
+    source: "table" | "preview";
+    title: string;
+    /** The counts line under the title, e.g. "1,840 matches · 0 credits". */
+    summary?: string | null;
+    /** The Table these rows belong to; absent for a preview. Paging and live progress read it. */
+    tableId?: string | null;
+    webUrl?: string | null;
+    grid: TableWidgetGridPage;
+    run?: TableWidgetRun | null;
+};
+/** The payload inside a tool result, or null when the result carries none (a refusal, a filter list). */
+export declare function readTableWidgetPayload(result: unknown): TableWidgetPayload | null;

package/node_modules/@oxygen/shared/dist/mcp-table-widget.js

@@ -0,0 +1,24 @@
+// What an MCP tool hands the OXYGEN Table widget. The tool puts it in its
+// result's `_meta["oxygen/widget"].data`; MCP Apps hosts pass result `_meta` to
+// the widget and not to the model, so the grid page the widget draws costs the
+// model no context. The widget renders the page with the web grid's own
+// components, so `grid` carries the web grid's serialization unchanged
+// (columns, rows, cell states as GET /api/tables/<id>/rows returns them).
+export const TABLE_WIDGET_NAME = "oxygen.table";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The payload inside a tool result, or null when the result carries none (a refusal, a filter list). */
+export function readTableWidgetPayload(result) {
+    if (!isRecord(result) || !isRecord(result._meta))
+        return null;
+    const widget = result._meta["oxygen/widget"];
+    if (!isRecord(widget) || widget.name !== TABLE_WIDGET_NAME || !isRecord(widget.data))
+        return null;
+    const data = widget.data;
+    if (data.version !== 1 || typeof data.title !== "string" || !isRecord(data.grid))
+        return null;
+    if (!Array.isArray(data.grid.columns) || !Array.isArray(data.grid.rows))
+        return null;
+    return data;
+}

package/node_modules/@oxygen/shared/dist/plan-band.d.ts

@@ -84,6 +84,14 @@ export type PlanSpendResolution = {
  * is never clamped by this.
  */
 export declare function resolveDefaultTriggerRunCreditCeilingForPlan(resolution: PlanSpendResolution, options?: RepricingOptions): number | null;
+/**
+ * The default rolling 24-hour credit ceiling of one connected app (an MCP OAuth
+ * connection such as ChatGPT) while it holds MCP event subscriptions (ADR 0030
+ * §11, decision D3): the trigger default above, so the two cannot drift.
+ * Enterprise has no trigger default and uses the largest rung's, the way Agent
+ * run defaults do; a connection is never uncapped by default.
+ */
+export declare function resolveDefaultConnectionCreditCeilingForPlan(resolution: PlanSpendResolution, options?: RepricingOptions): number;
 /** The same default for one standing or webhook table auto-run batch. */
 export declare function resolveDefaultAutoRunBatchCreditCeilingForPlan(resolution: PlanSpendResolution, options?: RepricingOptions): number | null;
 /**

package/node_modules/@oxygen/shared/dist/plan-band.js

@@ -183,6 +183,18 @@ function resolveDeliveryCreditCeiling(resolution, preRepricingTable, options) {
 export function resolveDefaultTriggerRunCreditCeilingForPlan(resolution, options = {}) {
     return resolveDeliveryCreditCeiling(resolution, DEFAULT_TRIGGER_RUN_CREDIT_CEILING, options);
 }
+/**
+ * The default rolling 24-hour credit ceiling of one connected app (an MCP OAuth
+ * connection such as ChatGPT) while it holds MCP event subscriptions (ADR 0030
+ * §11, decision D3): the trigger default above, so the two cannot drift.
+ * Enterprise has no trigger default and uses the largest rung's, the way Agent
+ * run defaults do; a connection is never uncapped by default.
+ */
+export function resolveDefaultConnectionCreditCeilingForPlan(resolution, options = {}) {
+    return resolveDefaultTriggerRunCreditCeilingForPlan(resolution, options)
+        ?? resolveDefaultTriggerRunCreditCeilingForPlan(bandSpendResolution("1999"), options)
+        ?? 0;
+}
 /** The same default for one standing or webhook table auto-run batch. */
 export function resolveDefaultAutoRunBatchCreditCeilingForPlan(resolution, options = {}) {
     return resolveDeliveryCreditCeiling(resolution, DEFAULT_AUTO_RUN_BATCH_CREDIT_CEILING, options);

package/node_modules/@oxygen/shared/dist/plan-limits.d.ts

@@ -844,6 +844,27 @@ export declare function assertAgentRunCeilingApproval(input: {
 }): {
     aboveDefault: boolean;
 };
+/** `details.approval_kind` when a connected app's ceiling above its default needs approval. */
+export declare const CONNECTION_CEILING_ABOVE_DEFAULT_APPROVAL_KIND = "connection_ceiling_above_default";
+/**
+ * The same approval posture for a connected app's rolling 24-hour credit
+ * ceiling (ADR 0030 §11): at or under the default (the plan-sized trigger
+ * default) nothing more to approve; above it only with the explicit
+ * above-default approval, whose flag and refusal shape match the Agent run and
+ * trigger ceilings; above the platform maximum never. `defaultCredits` is the
+ * lowest default among the workspaces the app can spend in, so the approval
+ * covers every one of them.
+ */
+export declare function assertConnectionCreditCeilingApproval(input: {
+    creditCeiling: number;
+    defaultCredits: number;
+    approveAboveDefault: boolean;
+    appName: string;
+    /** The workspace whose default is the one compared, named in the refusal. */
+    workspaceName?: string;
+}): {
+    aboveDefault: boolean;
+};
 /**
  * The ceilings one run is held to, for the worker and every budget check that
  * reads a run's authority. A run with a recorded above-default approval is

package/node_modules/@oxygen/shared/dist/plan-limits.js

@@ -419,6 +419,47 @@ export function assertAgentRunCeilingApproval(input) {
         },
     });
 }
+/** `details.approval_kind` when a connected app's ceiling above its default needs approval. */
+export const CONNECTION_CEILING_ABOVE_DEFAULT_APPROVAL_KIND = "connection_ceiling_above_default";
+/**
+ * The same approval posture for a connected app's rolling 24-hour credit
+ * ceiling (ADR 0030 §11): at or under the default (the plan-sized trigger
+ * default) nothing more to approve; above it only with the explicit
+ * above-default approval, whose flag and refusal shape match the Agent run and
+ * trigger ceilings; above the platform maximum never. `defaultCredits` is the
+ * lowest default among the workspaces the app can spend in, so the approval
+ * covers every one of them.
+ */
+export function assertConnectionCreditCeilingApproval(input) {
+    const subject = `${input.appName}'s rolling 24-hour credit ceiling`;
+    const where = input.workspaceName ? ` in ${input.workspaceName}` : "";
+    if (input.creditCeiling > AGENT_RUN_APPROVED_CEILING_MAX_CREDITS) {
+        throw new OxygenError("invalid_request", `credit_ceiling ${input.creditCeiling} is above the platform maximum of ${AGENT_RUN_APPROVED_CEILING_MAX_CREDITS} credits for ${subject}.`, {
+            exitCode: 2,
+            details: {
+                requested_credit_ceiling: input.creditCeiling,
+                default_credit_ceiling: input.defaultCredits,
+                platform_max_credits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+            },
+        });
+    }
+    if (input.creditCeiling <= input.defaultCredits)
+        return { aboveDefault: false };
+    if (input.approveAboveDefault)
+        return { aboveDefault: true };
+    throw new OxygenError("approval_required", `credit_ceiling ${input.creditCeiling} is above the plan default of ${input.defaultCredits} credits${where} for ${subject}. Approve the higher ceiling with approve_above_default=true, or set ${input.defaultCredits} or less.`, {
+        exitCode: 7,
+        details: {
+            approval_kind: CONNECTION_CEILING_ABOVE_DEFAULT_APPROVAL_KIND,
+            scope: "connection",
+            requested_credit_ceiling: input.creditCeiling,
+            default_credit_ceiling: input.defaultCredits,
+            ...(input.workspaceName ? { default_workspace_name: input.workspaceName } : {}),
+            platform_max_credits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+            next_step: `Re-send with approve_above_default=true (CLI: --approve-above-default) to approve up to ${input.creditCeiling} credits a day for ${input.appName}.`,
+        },
+    });
+}
 /**
  * The ceilings one run is held to, for the worker and every budget check that
  * reads a run's authority. A run with a recorded above-default approval is

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

@@ -570,6 +570,13 @@ export type SequenceEmailSendStep = {
     kind: "email_send";
     /** Advanced: send this step from this exact inbox instead of the lead's normal assignment. */
     sender_mailbox_id?: string;
+    /**
+     * Advanced: send this step from any inbox of this sender profile (person)
+     * instead of the lead's normal assignment. Each lead gets one of that
+     * person's inboxes and keeps it for every step naming the same person. Set
+     * this or sender_mailbox_id, never both.
+     */
+    sender_profile_id?: string;
     /**
      * Subject line. Supports {{column}} interpolation.
      *
@@ -945,10 +952,13 @@ export type SequenceLintIssue = {
  *    code as its launch blocker and the preview's `blocked` marker). A blind MCP run
  *    pinned the founder on the connection request alone and learned why the
  *    draft could not launch only from the start preview (2026-09-29).
+ *  - `sequence_step_sender_ignored`: a sender field on a step kind that does not
+ *    take it is not stored. A blind CLI run put `sender_profile_id` on an email
+ *    step before email took one; it was dropped without a word (2026-09-30).
  */
 export type SequenceDefinitionNotice = {
     path: string;
-    code: "email_reply_rewritten" | "sequence_linkedin_owner_conflict";
+    code: "email_reply_rewritten" | "sequence_linkedin_owner_conflict" | "sequence_step_sender_ignored";
     message: string;
 };
 export type ValidateSequenceOptions = {
@@ -1009,12 +1019,31 @@ export type SequenceMissingCopy = {
  * stored under `draft`. Empty means nothing to send, so starting would
  * either dispatch a blank message or fail per lead at send time.
  */
+/**
+ * Who an email step names as its From: one exact inbox, any inbox of one
+ * person, or null for the lead's own assignment.
+ */
+export type SequenceEmailStepSender = {
+    kind: "mailbox";
+    mailboxId: string;
+} | {
+    kind: "person";
+    senderProfileId: string;
+} | null;
+export declare function sequenceEmailStepSender(step: SequenceStep): SequenceEmailStepSender;
+/** One comparable value per From rule, so a change of rule is a change of thread. */
+export declare function sequenceEmailStepSenderKey(step: SequenceStep): string | undefined;
+/** Whether any email step follows the lead's own assigned person and inbox. */
+export declare function sequenceHasDefaultEmailStep(steps: readonly {
+    kind: string;
+}[]): boolean;
 /**
  * Threaded email steps that would continue another inbox's thread. A provider
  * thread belongs to the mailbox that opened it, so a step that changes From —
- * an exact-inbox step, or the return to the lead's assigned inbox after one —
- * must open a new thread under its own subject. Checked on save and again at
- * launch, because a draft may be saved half-written.
+ * an exact-inbox or person step, or the return to the lead's assigned inbox
+ * after one — must open a new thread under its own subject. Consecutive steps
+ * naming the same person keep one inbox per lead, so they may thread. Checked
+ * on save and again at launch, because a draft may be saved half-written.
  */
 export declare function sequenceSenderThreadConflicts(steps: readonly SequenceStep[]): {
     index: number;

package/node_modules/@oxygen/shared/dist/sequences.js

@@ -1027,17 +1027,33 @@ export function sequenceChannels(definition) {
     }
     return [...channels];
 }
-/**
- * Steps that still have empty copy — the launch gate for definitions stored
- * stored under `draft`. Empty means nothing to send, so starting would
- * either dispatch a blank message or fail per lead at send time.
- */
+export function sequenceEmailStepSender(step) {
+    if (step.kind !== "email_send")
+        return null;
+    if (step.sender_mailbox_id)
+        return { kind: "mailbox", mailboxId: step.sender_mailbox_id };
+    if (step.sender_profile_id)
+        return { kind: "person", senderProfileId: step.sender_profile_id };
+    return null;
+}
+/** One comparable value per From rule, so a change of rule is a change of thread. */
+export function sequenceEmailStepSenderKey(step) {
+    const sender = sequenceEmailStepSender(step);
+    if (!sender)
+        return undefined;
+    return sender.kind === "mailbox" ? `mailbox:${sender.mailboxId}` : `person:${sender.senderProfileId}`;
+}
+/** Whether any email step follows the lead's own assigned person and inbox. */
+export function sequenceHasDefaultEmailStep(steps) {
+    return steps.some((step) => (step.kind === "email_send" || step.kind === "email_reply") && sequenceEmailStepSender(step) === null);
+}
 /**
  * Threaded email steps that would continue another inbox's thread. A provider
  * thread belongs to the mailbox that opened it, so a step that changes From —
- * an exact-inbox step, or the return to the lead's assigned inbox after one —
- * must open a new thread under its own subject. Checked on save and again at
- * launch, because a draft may be saved half-written.
+ * an exact-inbox or person step, or the return to the lead's assigned inbox
+ * after one — must open a new thread under its own subject. Consecutive steps
+ * naming the same person keep one inbox per lead, so they may thread. Checked
+ * on save and again at launch, because a draft may be saved half-written.
  */
 export function sequenceSenderThreadConflicts(steps) {
     const conflicts = [];
@@ -1046,12 +1062,12 @@ export function sequenceSenderThreadConflicts(steps) {
     steps.forEach((step, index) => {
         if (step.kind !== "email_send" && step.kind !== "email_reply")
             return;
-        const sender = step.kind === "email_send" ? step.sender_mailbox_id : undefined;
+        const sender = sequenceEmailStepSenderKey(step);
         if (seenEmail && sequenceEmailStepThreads(step) && sender !== precedingSender) {
             conflicts.push({
                 index,
                 stepId: step.id,
-                message: `step '${step.id}' changes the sending inbox. Give it a new subject to start a new thread.`,
+                message: `step '${step.id}' changes who sends it. Give it a new subject to start a new thread.`,
             });
         }
         seenEmail = true;
@@ -1064,7 +1080,7 @@ export const LINKEDIN_RELATIONSHIP_STEP_KINDS = new Set(["invite", "message", "i
 /** LinkedIn light touches: they bind nothing, so each may come from any selected person. */
 export const LINKEDIN_LIGHT_TOUCH_STEP_KINDS = new Set(["visit_profile", "follow", "like_post", "comment_post"]);
 const LINKEDIN_SENDER_STEP_KINDS = new Set([...LINKEDIN_RELATIONSHIP_STEP_KINDS, ...LINKEDIN_LIGHT_TOUCH_STEP_KINDS]);
-function normalizeLinkedInStepSender(value, path, issues) {
+function normalizeStepSenderProfile(value, path, issues) {
     if (value === undefined || value === null || value === "")
         return {};
     if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value.trim())) {
@@ -1409,8 +1425,20 @@ raw, index, options, issues) {
         issues.push({ path: `${path}.channel`, message: `channel '${channel}' is not enabled for this sequence.` });
     }
     const linkedInSender = LINKEDIN_SENDER_STEP_KINDS.has(stepKind)
-        ? normalizeLinkedInStepSender(raw.sender_profile_id, `${path}.sender_profile_id`, issues)
+        ? normalizeStepSenderProfile(raw.sender_profile_id, `${path}.sender_profile_id`, issues)
         : {};
+    // A sender field this kind does not take is not stored: say so rather than
+    // let the definition read back without it.
+    for (const field of ["sender_profile_id", "sender_mailbox_id"]) {
+        const takes = stepKind === "email_send" || (field === "sender_profile_id" && LINKEDIN_SENDER_STEP_KINDS.has(stepKind));
+        if (!takes && raw[field] !== undefined && raw[field] !== null && raw[field] !== "") {
+            options.notices?.push({
+                path: `${path}.${field}`,
+                code: "sequence_step_sender_ignored",
+                message: `step '${id}': ${stepKind} steps do not take ${field}, so it was not saved. Email steps take sender_profile_id (any inbox of that person) or sender_mailbox_id (one exact inbox); LinkedIn steps take sender_profile_id.`,
+            });
+        }
+    }
     switch (stepKind) {
         case "visit_profile":
             return { id, channel: "linkedin", kind: "visit_profile", ...linkedInSender };
@@ -1489,9 +1517,16 @@ raw, index, options, issues) {
             if (senderMailboxId && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(senderMailboxId)) {
                 issues.push({ path: `${path}.sender_mailbox_id`, message: "must be an inbox id." });
             }
+            const senderPerson = normalizeStepSenderProfile(raw.sender_profile_id, `${path}.sender_profile_id`, issues);
+            if (senderMailboxId && senderPerson.sender_profile_id) {
+                issues.push({
+                    path: `${path}.sender_profile_id`,
+                    message: "set sender_profile_id (any inbox of that person) or sender_mailbox_id (one exact inbox), not both.",
+                });
+            }
             return {
                 id, channel: "email", kind: "email_send",
-                ...(senderMailboxId ? { sender_mailbox_id: senderMailboxId } : {}),
+                ...(senderMailboxId ? { sender_mailbox_id: senderMailboxId } : senderPerson),
                 ...(threaded ? {} : { subject_template: subject }),
                 body_template: body ?? "",
                 ...(bodyHtml !== undefined ? { body_html_template: bodyHtml } : {}),

package/node_modules/@oxygen/shared/dist/user-capability-routing.js

@@ -5,6 +5,15 @@ import { getCapabilityRoute, getCapabilityRouteMatch, inferCapabilityRoute, } fr
 // the user-facing boundary while preserving table joins and channel-specific
 // connection routes.
 export function inferUserCapabilityRoute(query) {
+    if (isProviderCredentialSetupIntent(query.toLowerCase())) {
+        const setup = getCapabilityRouteMatch("connected-integrations");
+        if (setup)
+            return {
+                ...setup,
+                recommendedTools: ["oxygen_integrations_connect", ...setup.recommendedTools.filter((tool) => tool !== "oxygen_integrations_connect")],
+                recommendedCommands: ["integrations connect", ...setup.recommendedCommands.filter((command) => command !== "integrations connect")],
+            };
+    }
     const route = inferCapabilityRoute(query);
     const providerConnectionIntent = isSimpleProviderConnectionIntent(query);
     if (!providerConnectionIntent
@@ -55,3 +64,11 @@ function isSimpleProviderConnectionIntent(query) {
     return !new Set(["this", "that", "them", "us", "me", "account", "workspace"])
         .has(match[1] ?? "");
 }
+/** Provider credential setup, rather than workspace keys or provider data actions. */
+function isProviderCredentialSetupIntent(query) {
+    const provider = /\b(providers?|integrations?|cloudflare|bounceban)\b/.test(query);
+    const credential = /\b(keys?|tokens?|credentials?|byok|bring your own key)\b/.test(query);
+    const setup = /\b(connect\w*|reconnect\w*|set up|setup|configure|replace|rotate|check|validate|test)\b/.test(query);
+    const cloudflareAccountChoice = /\bcloudflare\b/.test(query) && /\baccount\b/.test(query) && /\b(select|choose|pick)\b/.test(query);
+    return (provider && credential && setup) || cloudflareAccountChoice;
+}

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1011.322";
+export declare const OXYGEN_BUILD_VERSION = "1.1011.405";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1011.322";
+export const OXYGEN_BUILD_VERSION = "1.1011.405";

package/node_modules/@oxygen/shared/package.json

@@ -276,6 +276,11 @@
       "import": "./dist/enrichment-intents.js",
       "default": "./dist/enrichment-intents.js"
     },
+    "./decision-ledger": {
+      "types": "./dist/decision-ledger.d.ts",
+      "import": "./dist/decision-ledger.js",
+      "default": "./dist/decision-ledger.js"
+    },
     "./log": {
       "types": "./dist/log.d.ts",
       "import": "./dist/log.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1011.322",
+  "version": "1.1011.405",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",