@oxygen-agent/cli 1.1003.12 → 1.1010.644

package/dist/index.js

@@ -15,8 +15,10 @@ import { registerFunctionsCommands } from "./functions-commands.js";
 import { applyOxygenHelp, enableCommandSuggestions, unknownCommandHint, unknownOptionHint } from "./help.js";
 import { buildCommandManifest, getCommandManifestEntry, searchCommandManifest, suggestCommandNames, } from "./command-manifest.js";
 import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatCopilotPlanDuration, formatCopilotPlanSeconds, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, chunk, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_CLI_JSON_BODY_BYTES, MAX_MCP_TOOL_NAME_LENGTH, normalizeCopilotPlanStepStatus, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
-import { PURCHASABLE_PLAN_KEYS } from "@oxygen/shared/billing";
+import { PURCHASABLE_PLAN_KEYS, resolveBasePricingPlan } from "@oxygen/shared/billing";
 import { TAG_COLORS } from "@oxygen/shared/select-options";
+import { readColumnDecisionFlags } from "./column-decision-options.js";
+import { MANAGED_DATA_SUPPLIERS } from "@oxygen/shared/data-suppliers";
 import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { MAILBOX_IMPORT_FILE_MAX_BYTES as SHARED_MAILBOX_IMPORT_FILE_MAX_BYTES, MAILBOX_IMPORT_ROW_LIMIT as SHARED_MAILBOX_IMPORT_ROW_LIMIT, normalizeMailboxImportFile as normalizeSharedMailboxImportFile, normalizeMailboxImportVendor as normalizeSharedMailboxImportVendor, normalizeMailboxWorkbookRows, parseMailboxImportText, summarizeMailboxImportValidation as summarizeSharedMailboxImportValidation, } from "@oxygen/shared/mailbox-import";
 import { assertRecipeBundleSafe, assertPortableWorkflowDefinition, assertWorkflowGraphManifest, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowGraphManifest, isWorkflowManifest, hashPortableWorkflowGraphManifest, WORKFLOW_GRAPH_COMPILER_VERSION, WORKFLOW_GRAPH_MANIFEST_VERSION, } from "@oxygen/workflows";
@@ -29,12 +31,13 @@ import { waitForCliRun } from "./run-wait.js";
 import { assertModeFlagsExclusive, parseKeyValuePairs, parseJsonObject, readJsonObjectOption, readNonNegativeInt, readPositiveInt, readRecordString, resolveLiveDryRunMode, } from "./cli-values.js";
 import { formatAiPromptPreviewNotice, formatColumnReferenceNotices, } from "./column-run-notices.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
+import { formatSearchAiFilterTotalsNotice } from "./search-ai-filter-notice.js";
 import { captureCurrentTranscript, collectFeedbackEnvironment, TranscriptCaptureError, } from "./transcript.js";
 import { addSessionOutput, addSessionStatus, getSessionUsage, startSession, updateSessionStep, } from "./session.js";
 import { doctorAgentSkills, getAgentSkill, installAgentSkills, listAgentSkills, runAutomaticSkillsInstall, searchAgentSkills, } from "./skills.js";
 import { resolveCliBinaryName } from "./runtime.js";
 import { updateCli } from "./update.js";
-import { isRecord, readErrorMessage, readOption } from "./util.js";
+import { isRecord, readClearableOption, readErrorMessage, readOption } from "./util.js";
 const AGENT_MODEL_POLICY_HELP = "Model policy JSON: level low (Fast), medium (Balanced, default), or high (Max); credential_mode managed or organization_byok.";
 const AGENT_TOOL_POLICY_HELP = "Tool policy JSON. Effects: read, internal_write, paid, external_write. Ask-before-changes preset: {\"mode\":\"scoped\",\"rules\":[{\"decision\":\"allow\",\"effect\":\"read\"},{\"decision\":\"ask\",\"effect\":\"internal_write\"},{\"decision\":\"ask\",\"effect\":\"paid\"},{\"decision\":\"ask\",\"effect\":\"external_write\"}]}. Full mode requires --confirm-full-access.";
 /**
@@ -813,6 +816,7 @@ async function handleAsyncAction(command, options, action) {
         writeManagedProviderAvailabilityNotice(data);
         writeAvatarWarning(data);
         writeCreditsReceipt(data);
+        writeSearchAiFilterTotalsNotice(data);
     }
     catch (error) {
         emitCliFailure(command, error);
@@ -1052,6 +1056,15 @@ function writeCreditsReceipt(data) {
         process.stderr.write(byok
             ? `estimated 0 Oxygen credits for a live run on your own key (${byok})${remaining !== null ? `, ${remaining} available` : ""}\n`
             : `estimated ${block.estimated_credits.toLocaleString("en-US")} credits for a live run${remaining !== null ? `, ${remaining} available` : ""}\n`);
+        // Last, where an agent reading the tail of the output sees it: the
+        // estimate above is a ceiling, and only kept posts are charged
+        // (blind acceptance, 2026-09-25: agents read `| tail` and missed it).
+        // The same for what an existing table's saved auto-run adds to this run.
+        for (const key of ["ai_filter_reasons", "standing_auto_run"]) {
+            const summary = asPayloadRecord(data[key])?.summary;
+            if (typeof summary === "string")
+                process.stderr.write(`${summary}\n`);
+        }
     }
 }
 // A disabled workflow is a customer's automation at zero, and `status:
@@ -1084,6 +1097,11 @@ export function formatDisabledWorkflowNotices(data) {
     }
     return notices;
 }
+function writeSearchAiFilterTotalsNotice(data) {
+    const notice = formatSearchAiFilterTotalsNotice(data);
+    if (notice)
+        process.stderr.write(`${notice}\n`);
+}
 function writeAiPromptPreviewNotice(data) {
     const notice = formatAiPromptPreviewNotice(data);
     if (notice)
@@ -1514,6 +1532,11 @@ function writeMaxCreditsHint(error) {
             // --yes and spend nothing — the spend-flag hint would name flags the
             // command does not take. The server message is the signal: it spells out
             // "(CLI: --yes)" on those gates.
+            // Amplification grants name their own three flags and have no dry run.
+            if (error.message.includes("--acknowledge-risk")) {
+                process.stderr.write("hint: re-run with --approved --max-credits <n> --acknowledge-risk\n");
+                return;
+            }
             if (error.message.includes("--yes")) {
                 process.stderr.write("hint: inspect the preview, then re-run with --yes to approve the permanent deletion\n");
                 return;
@@ -1817,6 +1840,14 @@ function parseEnvFile(content) {
     return entries;
 }
 function readFileIfPresent(value) {
+    // Help text across these options promises "JSON or @file/path"; a leading
+    // `@` names a file too (2026-09-25 blind eval: `--filters-json @f.json` was
+    // parsed as JSON). An `@…` value that names no file stays literal text.
+    if (value.startsWith("@") && value.length > 1) {
+        const fromAt = readFileIfPresent(value.slice(1));
+        if (fromAt !== value.slice(1))
+            return fromAt;
+    }
     const candidate = resolve(value);
     try {
         return readFileSync(candidate, "utf8");
@@ -1949,6 +1980,27 @@ function buildCrmObjectAddAttrBody(options) {
         ...(options.asIdentityJson ? { identity: parseJsonObject(options.asIdentityJson) } : {}),
     };
 }
+function buildCrmObjectUpdateAttrBody(options) {
+    const name = readOption(options.name);
+    const optionsJson = readOption(options.optionsJson);
+    if (!name && options.required === undefined && !optionsJson) {
+        throw new OxygenError("missing_attribute_change", "Nothing to change. Pass --name <label>, --required / --no-required, and/or --options-json <json>.", { exitCode: 1 });
+    }
+    let choices;
+    if (optionsJson) {
+        const parsed = parseJsonValue(optionsJson, "--options-json");
+        if (!Array.isArray(parsed)) {
+            throw new OxygenError("invalid_options_json", "--options-json must be a JSON array of {value,label,color?}.", { exitCode: 1 });
+        }
+        choices = parsed;
+    }
+    return {
+        ...(name ? { display_name: name } : {}),
+        ...(options.required !== undefined ? { is_required: options.required } : {}),
+        ...(choices !== undefined ? { options: choices } : {}),
+        mode: resolveLiveDryRunMode(options),
+    };
+}
 function buildCrmAssertBody(object, options) {
     return {
         object,
@@ -2136,6 +2188,7 @@ function buildPublishingPostsListPath(options) {
         sender_account_id: options.sender,
         cursor: options.cursor,
         limit: options.limit,
+        order: options.order,
     };
     for (const [key, value] of Object.entries(filters)) {
         const read = readOption(value);
@@ -2213,10 +2266,84 @@ function buildPublishingPostCreateBody(options) {
         }
         body.ugc_participation_id = ugcParticipationId;
     }
-    if (content)
-        body.content = content;
+    const xContent = buildPublishingXContent(options, { forMerge: false });
+    if (content || xContent)
+        body.content = { ...(content ?? {}), ...(xContent ?? {}) };
     return body;
 }
+/**
+ * The X flags as content keys (see the API's X content contract). On update they
+ * become a `content_merge` so the rest of the stored content is kept; there
+ * `--reply-settings everyone` removes the key.
+ */
+function buildPublishingXContent(options, mode) {
+    const content = {};
+    const threadPosts = options.threadPost ?? [];
+    const threadMedia = parseKeyedPairs(options.threadMedia ?? [], "--thread-media", "position=media_id");
+    if (threadMedia.length > 0 && threadPosts.length === 0) {
+        throw new OxygenError("invalid_request", "--thread-media needs the thread's posts: add --thread-post for each post after the first.", { exitCode: 2 });
+    }
+    if (threadPosts.length > 0) {
+        const thread = threadPosts.map((text) => ({ text }));
+        for (const [position, mediaId] of threadMedia) {
+            const index = Number(position) - 2;
+            if (!Number.isInteger(index) || index < 0 || index >= thread.length) {
+                throw new OxygenError("invalid_request", `--thread-media ${position}=... names no thread post; positions run 2 to ${thread.length + 1}.`, { exitCode: 2 });
+            }
+            const entry = thread[index];
+            entry.media_asset_ids = [...(entry.media_asset_ids ?? []), mediaId];
+        }
+        content.thread = thread;
+    }
+    const pollOptions = options.pollOption ?? [];
+    const pollDuration = readOption(options.pollDuration);
+    if (pollDuration && pollOptions.length === 0) {
+        throw new OxygenError("invalid_request", "--poll-duration needs the poll's options: add --poll-option 2-4 times.", { exitCode: 2 });
+    }
+    if (pollOptions.length > 0) {
+        content.poll = { options: pollOptions, duration_minutes: pollDuration ? parsePollDurationMinutes(pollDuration) : 1440 };
+    }
+    const replySettings = readOption(options.replySettings);
+    if (replySettings) {
+        const map = { everyone: null, following: "following", mentioned: "mentionedUsers", subscribers: "subscribers" };
+        if (!(replySettings in map)) {
+            throw new OxygenError("invalid_request", "--reply-settings must be everyone, following, mentioned, or subscribers.", { exitCode: 2 });
+        }
+        const value = map[replySettings];
+        if (value)
+            content.reply_settings = value;
+        else if (mode.forMerge)
+            content.reply_settings = null;
+    }
+    const altText = parseKeyedPairs(options.altText ?? [], "--alt-text", "media_id=text");
+    if (altText.length > 0)
+        content.media_alt_text = Object.fromEntries(altText);
+    const photoTags = (options.photoTag ?? []).map((name) => name.trim().replace(/^@/, "")).filter(Boolean);
+    if (photoTags.length > 0)
+        content.media_tagged_usernames = photoTags;
+    return Object.keys(content).length > 0 ? content : null;
+}
+/** `key=value` pairs from a repeatable flag; the value may itself contain `=`. */
+function parseKeyedPairs(entries, flag, shape) {
+    return entries.map((entry) => {
+        const at = entry.indexOf("=");
+        const key = at > 0 ? entry.slice(0, at).trim() : "";
+        const value = at > 0 ? entry.slice(at + 1) : "";
+        if (!key || !value.trim()) {
+            throw new OxygenError("invalid_request", `${flag} takes ${shape}.`, { exitCode: 2 });
+        }
+        return [key, value];
+    });
+}
+/** `30m`, `6h`, `2d`, or a bare number of minutes. */
+function parsePollDurationMinutes(value) {
+    const match = /^(\d+)\s*([mhd]?)$/i.exec(value.trim());
+    if (!match) {
+        throw new OxygenError("invalid_request", "--poll-duration takes a number of minutes or 30m, 6h, 2d.", { exitCode: 2 });
+    }
+    const unit = match[2].toLowerCase();
+    return Number(match[1]) * (unit === "d" ? 1440 : unit === "h" ? 60 : 1);
+}
 function buildPublishingPostUpdateBody(options) {
     const body = {};
     const sender = readOption(options.sender);
@@ -2249,8 +2376,89 @@ function buildPublishingPostUpdateBody(options) {
         body.status = status;
     if (content)
         body.content = content;
+    const merge = readOption(options.contentMergeJson);
+    const xContent = buildPublishingXContent(options, { forMerge: true });
+    if (merge || xContent)
+        body.content_merge = { ...(merge ? parseJsonObject(merge) : {}), ...(xContent ?? {}) };
+    if (options.confirmNotPublished)
+        body.confirm_not_published = true;
     return body;
 }
+/**
+ * The LinkedIn video cover flags: a media id, a local file uploaded first, or
+ * (update only) a clear. Sent as the top-level `video_thumbnail_media_asset_id`,
+ * which the server merges into content, so the post's attachments are untouched.
+ */
+async function withPublishingVideoThumbnailOption(body, options) {
+    const mediaId = readOption(options.videoThumbnail);
+    const filePath = readOption(options.videoThumbnailFile);
+    const chosen = [mediaId, filePath, options.clearVideoThumbnail ? "clear" : undefined].filter(Boolean);
+    if (chosen.length > 1) {
+        throw new OxygenError("invalid_request", "Choose one of --video-thumbnail, --video-thumbnail-file, or --clear-video-thumbnail.", { exitCode: 2 });
+    }
+    if (options.clearVideoThumbnail)
+        return { ...body, video_thumbnail_media_asset_id: null };
+    if (mediaId)
+        return { ...body, video_thumbnail_media_asset_id: mediaId };
+    if (!filePath)
+        return body;
+    const contentType = publishingMediaContentTypeForPath(filePath);
+    if (contentType !== "image/jpeg" && contentType !== "image/png") {
+        throw new OxygenError("invalid_request", "--video-thumbnail-file must be a .jpg, .jpeg, or .png image.", { exitCode: 2 });
+    }
+    const uploaded = await uploadPublishingMediaFile(filePath, { contentType, scheduledPostId: null });
+    const media = uploaded.media && typeof uploaded.media === "object" ? uploaded.media : {};
+    const id = readRecordString(media, "id");
+    if (!id)
+        throw new OxygenError("publishing_media_upload_failed", "The cover image uploaded but no media id came back.", { exitCode: 1 });
+    return { ...body, video_thumbnail_media_asset_id: id };
+}
+/** Extension → MIME for the types Publishing accepts; anything else needs --content-type. */
+function publishingMediaContentTypeForPath(path) {
+    const extension = path.toLowerCase().split(".").pop() ?? "";
+    const types = {
+        jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif", webp: "image/webp",
+        mp4: "video/mp4", m4v: "video/x-m4v", mov: "video/quicktime", webm: "video/webm",
+        pdf: "application/pdf",
+    };
+    return types[extension] ?? null;
+}
+/**
+ * Presign, PUT the file straight to object storage, then have the server verify
+ * it — the three hops the web composer makes. The body is a file-backed Blob, so
+ * a large video streams from disk instead of being read into memory.
+ */
+async function uploadPublishingMediaFile(filePath, options) {
+    const { openAsBlob } = await import("node:fs");
+    const { basename } = await import("node:path");
+    const contentType = options.contentType ?? publishingMediaContentTypeForPath(filePath);
+    if (!contentType) {
+        throw new OxygenError("invalid_request", "Could not tell the file type from its extension. Pass --content-type, such as video/mp4 or image/png.", { details: { path: filePath }, exitCode: 2 });
+    }
+    const file = await openAsBlob(filePath, { type: contentType });
+    const ticket = await requestOxygen("/api/cli/publishing/media/upload-url", {
+        method: "POST",
+        body: {
+            file_name: basename(filePath),
+            content_type: contentType,
+            byte_length: file.size,
+            ...(options.scheduledPostId ? { scheduled_post_id: options.scheduledPostId } : {}),
+        },
+    });
+    const uploadUrl = readRecordString(ticket, "upload_url");
+    const completeUrl = readRecordString(ticket, "complete_url");
+    if (!uploadUrl || !completeUrl) {
+        throw new OxygenError("publishing_media_upload_failed", "The server did not return an upload URL for that file.", { exitCode: 1 });
+    }
+    const headers = ticket.upload_headers && typeof ticket.upload_headers === "object"
+        ? Object.fromEntries(Object.entries(ticket.upload_headers).map(([key, value]) => [key, String(value)]))
+        : { "content-type": contentType };
+    const put = await fetch(uploadUrl, { method: "PUT", headers, body: file, signal: AbortSignal.timeout(15 * 60_000) });
+    if (!put.ok) {
+        throw new OxygenError("publishing_media_upload_failed", `Object storage rejected the upload (${put.status}).`, { exitCode: 1 });
+    }
+    return await requestOxygen(completeUrl, { method: "POST", body: {} });
+}
 function buildPublishingMediaUploadUrlBody(options) {
     const fileName = readOption(options.fileName);
     const contentType = readOption(options.contentType);
@@ -2565,15 +2773,42 @@ function splitCommaList(value) {
         return [];
     return raw.split(",").map((entry) => entry.trim()).filter(Boolean);
 }
+// A list value goes out comma-separated (`accounts=a,b`), which every list param
+// in the publishing routes reads.
 function buildPublishingAnalyticsPath(base, params) {
     const query = new URLSearchParams();
+    const lists = [];
     for (const [key, value] of Object.entries(params)) {
-        if (value)
-            query.set(key, value);
+        if (typeof value === "string") {
+            if (value)
+                query.set(key, value);
+        }
+        else if (value && value.length > 0) {
+            lists.push(`${encodeURIComponent(key)}=${value.map(encodeURIComponent).join(",")}`);
+        }
     }
-    const suffix = query.toString();
+    const suffix = [query.toString(), ...lists].filter(Boolean).join("&");
     return suffix ? `${base}?${suffix}` : base;
 }
+const PUBLISHING_ANALYTICS_ACCOUNT_HELP = "An account key from the summary's accounts list, or a LinkedIn sender id from `oxygen senders list`. Repeatable.";
+/** Repeated and/or comma-separated `--account` values, trimmed and de-duplicated. */
+function readPublishingAnalyticsAccounts(values) {
+    return [...new Set((values ?? []).flatMap((value) => splitCommaList(value)))];
+}
+// Content analytics sums every posting profile unless --account names some. When
+// more than one posted, the last line a human reads says how to see one of them;
+// stderr, so stdout stays the payload (the writeDryRunNotice split).
+function writePublishingAnalyticsAccountHint(data) {
+    const payload = asPayloadRecord(data);
+    const accounts = Array.isArray(payload?.accounts) ? payload.accounts : [];
+    const first = asPayloadRecord(accounts[0]);
+    if (accounts.length < 2 || typeof first?.key !== "string")
+        return;
+    const channel = asPayloadRecord(payload?.scope)?.channel;
+    const channelFlag = typeof channel === "string" && channel !== "linkedin" ? ` --channel ${channel}` : "";
+    const example = typeof first.name === "string" ? `, e.g. ${first.name}` : "";
+    process.stderr.write(`Totals combine ${accounts.length} accounts. Scope to one${example}: oxygen publishing analytics summary${channelFlag} --account ${first.key}\n`);
+}
 function buildPublishingCommentsListPath(options) {
     const view = readOption(options.view);
     const status = readOption(options.status);
@@ -2655,8 +2890,15 @@ function requirePublishingApprovalAndCap(approved, maxCredits, action, details)
     }
     return cap;
 }
+/** The LinkedIn-restriction acknowledgement every arming amplification call needs. */
+function requireAmplificationRiskAcknowledged(acknowledged, action, details) {
+    if (acknowledged === true)
+        return;
+    throw new OxygenError("amplification_risk_acknowledgement_required", `${action} runs automated engagement from connected LinkedIn accounts, which LinkedIn may warn, restrict or close. Pacing reduces that risk but does not remove it. Re-run with --acknowledge-risk.`, { details: { ...details, risk_acknowledged: false }, exitCode: 7 });
+}
 function buildPublishingAmplificationCreateBody(options) {
     const maxCredits = requirePublishingApprovalAndCap(options.approved, options.maxCredits, "Creating an amplification policy", { name: options.name, scope: options.scope });
+    requireAmplificationRiskAcknowledged(options.acknowledgeRisk, "Creating an amplification policy", { name: options.name, scope: options.scope });
     const senders = splitCommaList(options.senders);
     const actions = splitCommaList(options.actions);
     if (senders.length === 0)
@@ -2670,6 +2912,7 @@ function buildPublishingAmplificationCreateBody(options) {
         actions,
         max_credits_per_cycle: maxCredits,
         approved: true,
+        risk_acknowledged: true,
         ...publishingAmplificationScope(options),
         ...publishingAmplificationTunables(options),
     };
@@ -2732,11 +2975,15 @@ function buildPublishingAmplificationUpdateBody(options) {
         ...(senders.length > 0 ? { participant_sender_ids: senders } : {}),
         ...(actions.length > 0 ? { actions } : {}),
         ...(maxCredits !== undefined ? { max_credits_per_cycle: maxCredits } : {}),
+        ...(options.acknowledgeRisk === true ? { risk_acknowledged: true } : {}),
         ...publishingAmplificationTunables(options),
     };
 }
 function buildPublishingBoostBody(postId, options) {
     const maxCredits = requirePublishingApprovalAndCap(options.approved, options.maxCredits, "Boosting a post", { post_id: postId });
+    requireAmplificationRiskAcknowledged(options.acknowledgeRisk, "Boosting a post", {
+        post_id: postId,
+    });
     const senders = splitCommaList(options.senders);
     const actions = splitCommaList(options.actions);
     if (senders.length === 0)
@@ -2750,6 +2997,7 @@ function buildPublishingBoostBody(postId, options) {
         actions,
         max_credits: maxCredits,
         approved: true,
+        risk_acknowledged: true,
         ...(maxActions !== undefined ? { max_actions_per_post: maxActions } : {}),
         ...(commentPool ? { comment_pool: commentPool } : {}),
     };
@@ -2837,16 +3085,35 @@ function buildCrmNotesPath(object, rowId, options) {
     const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/notes`;
     return query ? `${base}?${query}` : base;
 }
+/**
+ * One record's tasks, or — with neither argument — every task in the workspace
+ * (Philipp, 2026-09-22). The record scope is BOTH arguments or neither: one
+ * alone is an unfinished command, and guessing the other half would silently
+ * read a different set than the operator asked for.
+ */
 function buildCrmTasksPath(object, rowId, options) {
+    if (Boolean(object) !== Boolean(rowId)) {
+        throw new OxygenError("invalid_request", "Name both the object and the record, or neither: `oxygen crm tasks list companies acme.com` reads one record, `oxygen crm tasks list` reads the whole workspace.", { exitCode: 1 });
+    }
     const params = new URLSearchParams();
-    if (options.status)
-        params.set("status", options.status);
+    // The workspace read is "what do I owe anyone": without --status it lists
+    // OPEN work, as its description promises — the blind acceptance run got
+    // cancelled rows back and had to confirm with a second call. A record's own
+    // list keeps every status, the way its tab shows Done and Cancelled groups.
+    // `--status all` asks the workspace read for everything.
+    const status = options.status ?? (object && rowId ? undefined : "open");
+    if (status && status !== "all")
+        params.set("status", status);
+    if (options.assignee)
+        params.set("assignee", options.assignee);
     if (options.limit)
         params.set("limit", options.limit);
     if (options.cursor)
         params.set("cursor", options.cursor);
     const query = params.toString();
-    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tasks`;
+    const base = object && rowId
+        ? `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tasks`
+        : "/api/cli/crm/tasks";
     return query ? `${base}?${query}` : base;
 }
 function buildCrmPipelinePath(options) {
@@ -4059,13 +4326,18 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 throw new OxygenError("confirmation_required", "Refusing to create upsert-key indexes without --confirm.", { exitCode: 1 });
             }
             const limit = readPositiveInt(options.limit);
+            // `--org` is also a root option; Commander hands it to the root when
+            // both define it, so this subcommand's value arrives empty. Read both
+            // scopes (as backfill-table-order-indexes does) or the filter is lost
+            // and the backfill silently covers every tenant.
+            const organizationId = readOption(options.org) ?? readOption(program.opts().org);
             return requestOxygen("/api/cli/db/backfill-upsert-indexes", {
                 method: "POST",
                 body: {
                     apply: Boolean(options.apply),
                     dry_run: !options.apply,
                     confirm: Boolean(options.confirm),
-                    ...(options.org ? { organization_id: options.org } : {}),
+                    ...(organizationId ? { organization_id: organizationId } : {}),
                     ...(limit !== undefined ? { limit } : {}),
                 },
             });
@@ -4278,7 +4550,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("publishing")
-        .description("Social publishing, performance, and public-comment operations. Start Community triage with `oxygen publishing comments list --view unanswered --json`. Docs: https://oxygen-agent.com/docs/execution/publishing")
+        .description("Social publishing, performance, and public-comment operations. Start Community triage with `oxygen publishing comments list --view unanswered --json`. Teammates engaging on the workspace's own posts is `oxygen publishing amplification --help` (created disabled; enabling needs --approved and --acknowledge-risk). Docs: https://oxygen-agent.com/docs/execution/publishing")
         .addCommand(new Command("mentions")
         .description("Resolve LinkedIn identities for a publish-faithful post preview.")
         .addCommand(new Command("resolve")
@@ -4302,13 +4574,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("posts")
         .description("Manage scheduled Publishing posts.")
         .addCommand(new Command("list")
-        .description("List scheduled posts.")
+        .description("List scheduled posts by publish time, oldest first; pass --order newest for the latest first. Follow next_cursor for more than one page.")
         .option("--status <status>", "Filter by draft, scheduled, queued, publishing, published, failed, or canceled.")
         .option("--approval-status <status>", "Filter by draft, needs_approval, approved, or rejected.")
         .option("--tag <tag>", "Only posts carrying this workspace tag.")
         .option("--provider <provider>", "Filter by provider: linkedin, x, instagram, tiktok, facebook, or youtube.")
         .option("--sender <sender_account_id>", "Only posts belonging to this connected sender in the active workspace.")
-        .option("--cursor <cursor>", "Continue from next_cursor with the same filters.")
+        .option("--order <order>", "oldest (default) or newest publish time first.")
+        .option("--cursor <cursor>", "Continue from next_cursor with the same filters and order.")
         .option("--limit <n>", "Maximum posts to return.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -4322,24 +4595,33 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--sender <sender_account_id>", "LinkedIn sender account id. Required for LinkedIn before the worker can publish.")
         .option("--provider-connection <connection_id>", "Oxygen integration connection id for Composio-backed providers. Find it with `integrations list` (each integration's connection); create one with `integrations connect <provider>` (an OAuth redirect URL, or Settings > Connections on the web).")
         .option("--title <title>", "Internal title for the queue.")
-        .option("--text <text>", "Post text. For LinkedIn mentions, use @<public-identifier> directly.")
+        .option("--text <text>", "Post text. For LinkedIn mentions, use a person's @<public-identifier> directly; company pages cannot be tagged, so write the company name without the @.")
         .option("--text-file <path>", "Read post text from a local file.")
-        .option("--content-json <json>", "Structured content. Use media_asset_ids for Oxygen uploads. LinkedIn attachments require [{content:<base64>,content_type:<MIME>,filename:<name>}]; content.mentions is rejected, so put verified @<public-identifier> values in --text. Composio accepts provider_arguments or composio.arguments.")
+        .option("--content-json <json>", "Structured content. Use media_asset_ids for Oxygen uploads. LinkedIn attachments require [{content:<base64>,content_type:<MIME>,filename:<name>}]; content.mentions is rejected, so put verified @<public-identifier> values in --text. X options have their own flags (--thread-post, --poll-option, --reply-settings, --alt-text, --photo-tag); raw X API keys can still ride in composio.arguments.")
         .option("--composio-action <slug>", "Override the Composio action slug for this scheduled post.")
         .option("--timezone <tz>", "Display timezone for the scheduled date. Defaults to the LinkedIn sender's own timezone when --sender is set, else UTC.")
         .option("--status <status>", "draft or scheduled. Defaults to scheduled. A draft sits outside the queue until `publishing posts approve` schedules and arms it in one step; scheduled is queued for its publish time and still waits for approval.")
         .option("--draft", "Create as a draft instead of scheduled.")
         .option("--ugc-participation-id <id>", "Also enroll this personal post in one active creator participation. It is always saved as an unapproved draft; omit --approved.")
         .option("--approved", "Mark an ordinary post approved for the scheduler. Invalid with --ugc-participation-id.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("publishing posts create", options, () => requestOxygen("/api/cli/publishing/posts", {
+        .option("--thread-post <text>", "X: text of the next post in a thread (posts 2, 3, ... in order). Repeatable.", collectRepeatable, [])
+        .option("--thread-media <position=media_id>", "X: attach an uploaded media id to thread post N (2 or later), e.g. 2=<media_id>. Repeatable.", collectRepeatable, [])
+        .option("--poll-option <text>", "X: a poll option on the first post (2-4 options, 25 characters each). Repeatable.", collectRepeatable, [])
+        .option("--poll-duration <duration>", "X: how long the poll runs, e.g. 30m, 6h, 2d (5 minutes to 7 days; default 1d).")
+        .option("--reply-settings <who>", "X: who can reply: everyone, following, mentioned, or subscribers.")
+        .option("--alt-text <media_id=text>", "X: image or GIF description for screen readers (up to 1,000 characters). Repeatable.", collectRepeatable, [])
+        .option("--photo-tag <username>", "X: tag an account in the first post's images (up to 10). Repeatable.", collectRepeatable, [])
+        .option("--video-thumbnail <media_id>", "LinkedIn video cover: an uploaded JPEG or PNG media id (`publishing media upload`). Needs a video in media_asset_ids.")
+        .option("--video-thumbnail-file <path>", "Upload a local JPEG or PNG and use it as the LinkedIn video cover.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("publishing posts create", options, async () => requestOxygen("/api/cli/publishing/posts", {
             method: "POST",
-            body: buildPublishingPostCreateBody(options),
+            body: await withPublishingVideoThumbnailOption(buildPublishingPostCreateBody(options), options),
         }));
     }))
         .addCommand(new Command("get")
-        .description("Get one scheduled post with resolved media previews and attempt history.")
+        .description("Get one scheduled post with resolved media previews, its LinkedIn video cover, and attempt history. For an X post, publish_plan lists every post that will be sent, in order, with media, alt text, poll and reply settings (free). Open web_url to preview the post as it will look on LinkedIn or X.")
         .argument("<post_id>", "Scheduled post id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
@@ -4353,18 +4635,30 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--sender <sender_account_id>", "LinkedIn sender account id.")
         .option("--provider-connection <connection_id>", "Oxygen integration connection id for Composio-backed providers.")
         .option("--title <title>", "Internal title for the queue.")
-        .option("--text <text>", "Post text. For LinkedIn mentions, use @<public-identifier> directly.")
+        .option("--text <text>", "Post text. For LinkedIn mentions, use a person's @<public-identifier> directly; company pages cannot be tagged, so write the company name without the @.")
         .option("--text-file <path>", "Read post text from a local file.")
-        .option("--content-json <json>", "Structured content. Use media_asset_ids for Oxygen uploads. LinkedIn attachments require [{content:<base64>,content_type:<MIME>,filename:<name>}]; content.mentions is rejected, so put verified @<public-identifier> values in --text. This replaces the existing content object.")
+        .option("--content-json <json>", "Structured content. Use media_asset_ids for Oxygen uploads. LinkedIn attachments require [{content:<base64>,content_type:<MIME>,filename:<name>}]; content.mentions is rejected, so put verified @<public-identifier> values in --text. This replaces the existing content object; use --content-merge-json or the X flags to change single keys.")
         .option("--composio-action <slug>", "Override the Composio action slug for this scheduled post.")
         .option("--publish-at <iso>", "ISO date-time when the post should publish.")
         .option("--timezone <tz>", "Display timezone for the scheduled date.")
         .option("--status <status>", "draft or scheduled.")
+        .option("--thread-post <text>", "X: text of the next post in a thread (posts 2, 3, ... in order). Repeatable.", collectRepeatable, [])
+        .option("--thread-media <position=media_id>", "X: attach an uploaded media id to thread post N (2 or later), e.g. 2=<media_id>. Repeatable.", collectRepeatable, [])
+        .option("--poll-option <text>", "X: a poll option on the first post (2-4 options, 25 characters each). Repeatable.", collectRepeatable, [])
+        .option("--poll-duration <duration>", "X: how long the poll runs, e.g. 30m, 6h, 2d (5 minutes to 7 days; default 1d).")
+        .option("--reply-settings <who>", "X: who can reply: everyone, following, mentioned, or subscribers.")
+        .option("--alt-text <media_id=text>", "X: image or GIF description for screen readers (up to 1,000 characters). Repeatable.", collectRepeatable, [])
+        .option("--photo-tag <username>", "X: tag an account in the first post's images (up to 10). Repeatable.", collectRepeatable, [])
+        .option("--content-merge-json <json>", "Merge these keys into the stored content instead of replacing it; a null value removes a key, e.g. '{\"poll\":null}'.")
+        .option("--video-thumbnail <media_id>", "Set the LinkedIn video cover to an uploaded JPEG or PNG media id (`publishing media upload`). The post needs a video attached.")
+        .option("--video-thumbnail-file <path>", "Upload a local JPEG or PNG and set it as the LinkedIn video cover. To pick a frame from the video instead, open the post's web_url and use Cover.")
+        .option("--clear-video-thumbnail", "Remove the LinkedIn video cover.")
+        .option("--confirm-not-published", "Only after you checked the account: the post OXYGEN could not confirm is NOT there. Unlocks a post that failed with publishing_effect_outcome_uncertain; if the post is live, do not use it or it publishes twice.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
-        await handleAsyncAction("publishing posts update", options, () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}`, {
+        await handleAsyncAction("publishing posts update", options, async () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}`, {
             method: "PATCH",
-            body: buildPublishingPostUpdateBody(options),
+            body: await withPublishingVideoThumbnailOption(buildPublishingPostUpdateBody(options), options),
         }));
     }))
         .addCommand(new Command("approve")
@@ -4386,12 +4680,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("retry")
-        .description("Move a failed post back to scheduled for another worker attempt.")
+        .description("Move a failed post back to scheduled for another worker attempt. A post that failed with publishing_effect_outcome_uncertain stays locked until you check the account and pass --confirm-not-published.")
         .argument("<post_id>", "Scheduled post id.")
+        .option("--confirm-not-published", "Only after you checked the account: the post OXYGEN could not confirm is NOT there. Unlocks a post that failed with publishing_effect_outcome_uncertain; if the post is live, do not use it or it publishes twice.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
         await handleAsyncAction("publishing posts retry", options, () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}/retry`, {
             method: "POST",
+            ...(options.confirmNotPublished ? { body: { confirm_not_published: true } } : {}),
         }));
     }))
         .addCommand(new Command("uncancel")
@@ -4442,15 +4738,16 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("boost")
-        .description("Boost ONE post: your teammates' connected accounts react to and comment on it, once. These are REAL public LinkedIn writes from their accounts and they SPEND CREDITS — refused (exit 7) without --approved and --max-credits. Creates a post-scoped policy that is already enabled and plans its actions immediately. For a standing rule across many posts, use `publishing amplification create`.")
+        .description("Boost ONE post: your teammates' connected accounts react to and comment on it, once. These are REAL public LinkedIn writes from their accounts and they SPEND CREDITS — refused (exit 7) without --approved, --max-credits and --acknowledge-risk. Creates a post-scoped policy that is already enabled and plans its actions immediately. For a standing rule across many posts, use `publishing amplification create`.")
         .argument("<post_id>", "Scheduled post id.")
         .requiredOption("--senders <ids>", "Comma-separated connected sender account ids that will engage.")
         .requiredOption("--actions <list>", "Comma-separated actions: reaction, comment.")
-        .option("--max-actions-per-post <n>", "Hard cap on how many actions are planned.")
+        .option("--max-actions-per-post <n>", "Hard cap on how many actions are planned (at most 12).")
         .option("--max-credits <n>", "Credit ceiling for the boost (required — this is a paid action).")
         .option("--comment-pool <text>", "A comment to draw from. Repeatable. Required when --actions includes comment.", collectRepeatable, [])
         .option("--comment-pool-file <path>", "Read the comment pool from a file, one comment per line.")
         .option("--approved", "Confirm the real public engagement. Without it the command refuses and nothing is planned.")
+        .option("--acknowledge-risk", "Acknowledge that LinkedIn may warn, restrict or close accounts used for automated engagement. Required.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
         await handleAsyncAction("publishing posts boost", options, () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}/boost`, {
@@ -4569,6 +4866,18 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     })))
         .addCommand(new Command("media")
         .description("Manage Publishing media uploads.")
+        .addCommand(new Command("upload")
+        .description("Upload a local image, video, or PDF in one step and print its media id. Attach it with --content-json '{\"media_asset_ids\":[...]}', or use a JPEG/PNG as a LinkedIn video cover with `publishing posts update --video-thumbnail`.")
+        .argument("<path>", "Local file path.")
+        .option("--content-type <type>", "MIME type when the file extension does not say it, such as video/mp4.")
+        .option("--scheduled-post <post_id>", "Optional provenance association; it does not attach the file to the post.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (filePath, options) => {
+        await handleAsyncAction("publishing media upload", options, () => uploadPublishingMediaFile(filePath, {
+            contentType: readOption(options.contentType) ?? null,
+            scheduledPostId: readOption(options.scheduledPost) ?? null,
+        }));
+    }))
         .addCommand(new Command("upload-url")
         .description("Create a Publishing media asset and presigned upload URL with required upload headers.")
         .requiredOption("--file-name <name>", "Original media filename.")
@@ -4715,18 +5024,48 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--from <date>", "Custom inclusive UTC start date.")
         .option("--to <date>", "Custom inclusive UTC end date.")
         .option("--limit <n>", "Top posts to return. Defaults to 10, maximum 50.")
+        .option("--sort <metric>", "Rank top posts by engagements (default; reactions + comments + reposts), impressions, reactions, comments, or reposts. `leader` reports the top post's lead over the runner-up and the median.")
+        .option("--account <key>", PUBLISHING_ANALYTICS_ACCOUNT_HELP, collectRepeatable, [])
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        const accounts = readPublishingAnalyticsAccounts(options.account);
+        let data;
+        await handleAsyncAction("publishing analytics summary", options, async () => {
+            data = await requestOxygen(buildPublishingAnalyticsPath("/api/cli/publishing/analytics/summary", {
+                channel: readOption(options.channel),
+                range: readOption(options.range),
+                from: readOption(options.from),
+                to: readOption(options.to),
+                limit: readOption(options.limit),
+                sort: readOption(options.sort),
+                accounts,
+            }));
+            return data;
+        });
+        if (!options.json && accounts.length === 0)
+            writePublishingAnalyticsAccountHint(data);
+    }))
+        .addCommand(new Command("timeseries")
+        .description("Impressions and engagements EARNED per day across all tracked posts (not only posts published in the range), with reactions, comments and reposts also reported on their own, whether each is growing or shrinking (against the previous period, or when tracking began inside the range, the second half of its tracked days against the first; `trend.basis` says which and `trend.compared` shows both values), and follower change per LinkedIn account. Days without a tracked post are null, never zero; `estimated` days spread a gain across an unread gap of up to three days. Read-only: no provider call, 0 credits.")
+        .option("--channel <channel>", "Channel: linkedin (default) or x.")
+        .option("--range <range>", "Window: 7d, 30d (default), 90d, or 365d.")
+        .option("--from <date>", "Custom inclusive start date.")
+        .option("--to <date>", "Custom inclusive end date.")
+        .option("--tz <zone>", "IANA time zone for day boundaries, e.g. Europe/Berlin. Defaults to UTC.")
+        .option("--account <key>", PUBLISHING_ANALYTICS_ACCOUNT_HELP, collectRepeatable, [])
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("publishing analytics summary", options, () => requestOxygen(buildPublishingAnalyticsPath("/api/cli/publishing/analytics/summary", {
+        await handleAsyncAction("publishing analytics timeseries", options, () => requestOxygen(buildPublishingAnalyticsPath("/api/cli/publishing/analytics/timeseries", {
             channel: readOption(options.channel),
             range: readOption(options.range),
             from: readOption(options.from),
             to: readOption(options.to),
-            limit: readOption(options.limit),
+            tz: readOption(options.tz),
+            accounts: readPublishingAnalyticsAccounts(options.account),
         })));
     }))
         .addCommand(new Command("post")
-        .description("One post's stored daily metric series, totals, and earned-media value. EMV is impressions-derived; absent impressions return a reason instead of a made-up number. Read-only: no provider call, 0 credits.")
+        .description("One post's stored daily metric series, totals, growth curve, 24h/7d benchmarks against the workspace median, and earned-media value. EMV is impressions-derived; absent impressions return a reason instead of a made-up number. Read-only: no provider call, 0 credits.")
         .argument("<post_id>", "Scheduled post id.")
         .option("--since <date>", "ISO date to start the series from.")
         .option("--json", "Print a JSON envelope.")
@@ -4734,14 +5073,16 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("publishing analytics post", options, () => requestOxygen(buildPublishingAnalyticsPath(`/api/cli/publishing/analytics/posts/${encodeURIComponent(postId)}`, { since: readOption(options.since) })));
     }))
         .addCommand(new Command("account")
-        .description("Stored per-account metric series for connected publishing accounts. Read-only: no provider call, 0 credits.")
-        .option("--provider <provider>", "Provider to read. Defaults to linkedin.")
+        .description("Stored per-account metric series (followers) for connected LinkedIn and X publishing accounts, read once a day in the background. Read-only: no provider call, 0 credits.")
+        .option("--provider <provider>", "Channel to read: linkedin or x. Omit for every connected channel.")
         .option("--since <date>", "ISO date to start the series from.")
+        .option("--account <key>", PUBLISHING_ANALYTICS_ACCOUNT_HELP, collectRepeatable, [])
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("publishing analytics account", options, () => requestOxygen(buildPublishingAnalyticsPath("/api/cli/publishing/analytics/account", {
             provider: readOption(options.provider),
             since: readOption(options.since),
+            accounts: readPublishingAnalyticsAccounts(options.account),
         })));
     }))
         .addCommand(new Command("emv")
@@ -4754,7 +5095,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             body: { cpm: parseJsonObject(options.cpmJson ?? "") },
         }));
     }))
-        .addHelpText("after", "\nExample (stored X snapshots, 0 credits, no provider call):\n  oxygen publishing analytics summary --channel x --range 30d --json\n"))
+        .addHelpText("after", "\nExamples (stored snapshots, 0 credits, no provider call):\n  oxygen publishing analytics summary --channel linkedin --range 30d --sort impressions --json\n  oxygen publishing analytics timeseries --channel linkedin --range 30d --tz Europe/Berlin --json\n\nTotals, leader and trends combine every posting account; `accounts` lists them and `--account <key>` counts only the ones you name. `top_posts[].account` names each post's author.\nWhy a metric is null: every null carries a reason in `null_reasons`:\n  not_exposed_by_provider   the rail OXYGEN currently reads through never returns it (`capabilities.metrics.<metric>.reason` names the limit)\n  not_synced_yet            no background snapshot has landed yet\n  not_returned_by_provider  snapshots exist but the provider left it out (LinkedIn shows impressions only to the post's author)\nSee also: the oxygen-linkedin-marketing product skill (`oxygen skills install`) for reading LinkedIn performance.\n"))
         .addCommand(new Command("import")
         .description("Bulk-load scheduled posts from a .csv or .json file. Dry-run by DEFAULT: it parses, lints, and reports invalid rows while writing nothing. Pass --approved to actually write. Imported posts land as drafts that still need approval — import never approves and never publishes. A row whose idempotency_key was already used is skipped, so re-importing the same file cannot duplicate the queue.")
         .requiredOption("--file <path>", "Path to a .csv (header row) or .json file ([rows] or { rows: [...] }).")
@@ -4777,14 +5118,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("publishing amplification list", options, () => requestOxygen("/api/cli/publishing/amplification"));
     }))
         .addCommand(new Command("create")
-        .description("Create an amplification policy. It arms REAL public engagement from other people's connected accounts and SPENDS CREDITS, so it is refused (exit 7) without --approved and --max-credits — that pair is the standing grant, recorded with who/when/what scope. The policy is created DISABLED: run `amplification enable` when you actually want it to run.")
+        .description("Create an amplification policy. It arms REAL public engagement from other people's connected accounts and, once enabled, draws credits each cycle (creating it spends nothing), so it is refused (exit 7) without --approved, --max-credits and --acknowledge-risk — that grant is recorded with who/when/what scope. The policy is created DISABLED: run `amplification enable` when you actually want it to run.")
         .requiredOption("--name <name>", "Policy name.")
         .requiredOption("--scope <kind>", "What it amplifies: all, tag, or post.")
         .option("--tag <tag>", "Workspace tag to scope to (with --scope tag).")
         .option("--post <post_id>", "Post to scope to (with --scope post).")
         .requiredOption("--senders <ids>", "Comma-separated connected sender account ids that will engage.")
         .requiredOption("--actions <list>", "Comma-separated actions: reaction, comment.")
-        .option("--max-actions-per-post <n>", "Hard cap on actions per post.")
+        .option("--max-actions-per-post <n>", "Hard cap on actions per post (at most 12).")
         .option("--max-credits <n>", "Hard credit cap per cycle (required — this policy spends credits).")
         .option("--comment-pool <text>", "A comment to draw from. Repeatable. Required when --actions includes comment.", collectRepeatable, [])
         .option("--comment-pool-file <path>", "Read the comment pool from a file, one comment per line.")
@@ -4793,6 +5134,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--comment-delay-min <seconds>", "Lower bound of the randomized comment delay.")
         .option("--comment-delay-max <seconds>", "Upper bound of the randomized comment delay.")
         .option("--approved", "Grant the standing permission. Without it the command refuses and creates nothing.")
+        .option("--acknowledge-risk", "Acknowledge that LinkedIn may warn, restrict or close accounts used for automated engagement. Required.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("publishing amplification create", options, () => requestOxygen("/api/cli/publishing/amplification", {
@@ -4813,7 +5155,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--name <name>", "Policy name.")
         .option("--senders <ids>", "Comma-separated connected sender account ids.")
         .option("--actions <list>", "Comma-separated actions: reaction, comment.")
-        .option("--max-actions-per-post <n>", "Hard cap on actions per post.")
+        .option("--max-actions-per-post <n>", "Hard cap on actions per post (at most 12).")
         .option("--max-credits <n>", "Hard credit cap per cycle.")
         .option("--comment-pool <text>", "A comment to draw from. Repeatable.", collectRepeatable, [])
         .option("--comment-pool-file <path>", "Read the comment pool from a file, one comment per line.")
@@ -4821,6 +5163,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--reaction-delay-max <seconds>", "Upper bound of the randomized reaction delay.")
         .option("--comment-delay-min <seconds>", "Lower bound of the randomized comment delay.")
         .option("--comment-delay-max <seconds>", "Upper bound of the randomized comment delay.")
+        .option("--acknowledge-risk", "Record a fresh LinkedIn-restriction risk acknowledgement on the policy.")
         .option("--json", "Print a JSON envelope.")
         .action(async (policyId, options) => {
         await handleAsyncAction("publishing amplification update", options, () => requestOxygen(`/api/cli/publishing/amplification/${encodeURIComponent(policyId)}`, {
@@ -4829,16 +5172,20 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("enable")
-        .description("Arm a policy. From here the worker engages on every post in scope from the participants' real accounts, within the caps — so this refuses (exit 7) without --approved. Nothing else in the policy changes.")
+        .description("Arm a policy. From here the worker engages on every post in scope from the participants' real accounts, within the caps — so this refuses (exit 7) without --approved and --acknowledge-risk. Nothing else in the policy changes.")
         .argument("<policy_id>", "Amplification policy id.")
         .option("--approved", "Confirm arming the standing public engagement. Without it nothing is armed.")
+        .option("--acknowledge-risk", "Acknowledge that LinkedIn may warn, restrict or close accounts used for automated engagement. Required.")
         .option("--json", "Print a JSON envelope.")
         .action(async (policyId, options) => {
         await handleAsyncAction("publishing amplification enable", options, () => {
             if (options.approved !== true) {
                 throw new OxygenError("approval_required", "Enabling a policy starts real public engagement from the participants' connected accounts. Re-run with --approved.", { details: { policy_id: policyId }, exitCode: 7 });
             }
-            return requestOxygen(`/api/cli/publishing/amplification/${encodeURIComponent(policyId)}/enable`, { method: "POST" });
+            requireAmplificationRiskAcknowledged(options.acknowledgeRisk, "Enabling a policy", {
+                policy_id: policyId,
+            });
+            return requestOxygen(`/api/cli/publishing/amplification/${encodeURIComponent(policyId)}/enable`, { method: "POST", body: { risk_acknowledged: true } });
         });
     }))
         .addCommand(new Command("disable")
@@ -5100,7 +5447,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     })));
     program
         .command("crm")
-        .description("Agent-native CRM object setup, records, automatic enrichment, and metadata commands.")
+        .description("Agent-native CRM object setup, records, automatic enrichment, and metadata commands. Who to contact first today: crm signals leads-today lists people ranked by their strongest intent signal in the last 7 days (website visit > profile view > post reaction > new follower), most recent first within a type.")
         .addCommand(new Command("setup")
         .description("Create or repair standard CRM object-backed tables. Defaults to dry-run.")
         .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people,deals.")
@@ -5220,6 +5567,30 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             method: "POST",
             body: buildCrmObjectAddAttrBody(options),
         }));
+    }))
+        .addCommand(new Command("update-attr")
+        .description("Change one field on a CRM object: rename it, make it required or optional, or replace the choices of a select/status field. The field's key never changes, so prompts and formulas that read it keep working. An Oxygen-shipped field on companies/people/deals can be renamed and its choices changed (its key, type and required flag stay); a field you added is fully yours. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies, people, deals, or a custom object like projects.")
+        .argument("<attribute>", "The field's key as `crm describe` lists it, e.g. renewal_date or pipeline_stage.")
+        .option("--name <label>", "New display name for the field.")
+        .option("--required", "Make the field required.")
+        .option("--no-required", "Make the field optional.")
+        .option("--options-json <json>", "Replacement choice list for a select/status field: a JSON array of {value,label,color?}. Keep an existing value to keep the records that hold it.")
+        .option("--dry-run", "Validate the change without applying it.")
+        .option("--live", "Apply the change. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, attribute, options, command) => {
+        await handleAsyncAction("crm object update-attr", { json: Boolean(command.optsWithGlobals().json) }, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/attributes/${encodeURIComponent(attribute)}`, { method: "PATCH", body: buildCrmObjectUpdateAttrBody(options) }));
+    }))
+        .addCommand(new Command("remove-attr")
+        .description("Remove a field you added to a CRM object. The column is archived (restorable with `columns restore <table> <key>`, which brings the field back; no cell destroyed), the object stops listing it, and the key is free for a new field at once. Oxygen-shipped fields, the title field, identity fields and relations cannot be removed. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies, people, deals, or a custom object like projects.")
+        .argument("<attribute>", "The field's key as `crm describe` lists it.")
+        .option("--dry-run", "Show what would be removed without applying it.")
+        .option("--live", "Remove the field. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, attribute, options, command) => {
+        await handleAsyncAction("crm object remove-attr", { json: Boolean(command.optsWithGlobals().json) }, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/attributes/${encodeURIComponent(attribute)}`, { method: "DELETE", body: { mode: resolveLiveDryRunMode(options) } }));
     })))
         .addCommand(new Command("search")
         .description("Search CRM records by identity or record label. Takes ONE query; narrow the objects with --object, not a second argument.")
@@ -5297,15 +5668,48 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("crm files attach", options, async () => {
             const { readFile } = await import("node:fs/promises");
             const { basename } = await import("node:path");
+            const { createHash } = await import("node:crypto");
             const bytes = await readFile(filePath);
-            return requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/files`, {
+            // Presign, PUT straight to object storage, then have the server
+            // verify and attach — the same three hops the web drop zone and
+            // `copilot attach` make. Bytes never ride in the JSON body, whose
+            // 2,000,000-byte ceiling held attachments to ~1.5 MB against a
+            // store that allows 100 MiB.
+            const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/files`;
+            const ticket = await requestOxygen(`${base}/upload-url`, {
                 method: "POST",
                 body: {
                     name: basename(filePath),
-                    content_base64: bytes.toString("base64"),
-                    ...(readOption(options.label) ? { label: readOption(options.label) } : {}),
+                    byte_length: bytes.byteLength,
+                    sha256: createHash("sha256").update(bytes).digest("hex"),
                 },
             });
+            const uploadUrl = readRecordString(ticket, "upload_url");
+            const completeUrl = readRecordString(ticket, "complete_url");
+            if (!uploadUrl || !completeUrl) {
+                throw new OxygenError("attachment_upload_failed", "The server did not return an upload URL for that file.", { exitCode: 1 });
+            }
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 300_000);
+            let put;
+            try {
+                put = await fetch(uploadUrl, {
+                    method: "PUT",
+                    headers: { "content-type": readRecordString(ticket, "upload_content_type") ?? "application/octet-stream" },
+                    body: new Uint8Array(bytes),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!put.ok) {
+                throw new OxygenError("attachment_upload_failed", `Object storage rejected the upload (${put.status}).`, { exitCode: 1 });
+            }
+            return requestOxygen(completeUrl, {
+                method: "POST",
+                body: readOption(options.label) ? { label: readOption(options.label) } : {},
+            });
         });
     }))
         .addCommand(new Command("detach")
@@ -5318,27 +5722,28 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     })))
         .addCommand(new Command("tasks")
-        .description("Read and write a CRM record's tasks \u2014 the human to-do attached to a record. Distinct from `oxygen voice tasks`, which is the phone queue a rep dials from.")
+        .description("Reminders and to-dos on CRM records: file a task on a record, list the open work across the whole workspace or one record's, complete it. Distinct from `oxygen voice tasks`, which is the phone queue a rep dials from.")
         .addCommand(new Command("list")
-        .description("List one record's tasks. Open work first, then by deadline; an undated task sorts last inside its group rather than first.")
-        .argument("<object>", "CRM object slug, such as companies or people.")
-        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
-        .option("--status <status>", "Filter to open, completed or cancelled.")
+        .description("List open reminders across the whole workspace, or one record's with <object> <record>. Open work first, then by deadline; --assignee me for yours, --status completed for the done ones. An undated task sorts last inside its group rather than first.")
+        .argument("[object]", "CRM object slug, such as companies or people. Leave both arguments off to read every record's tasks.")
+        .argument("[record]", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--status <status>", "open, completed, cancelled or all. The workspace read defaults to open; a record's own list shows every status.")
+        .option("--assignee <email|me>", "Only this member's tasks. `me` is whoever this key authenticates as.")
         .option("--limit <n>", "Maximum tasks to return. Defaults to 50.")
         .option("--cursor <cursor>", "Pagination cursor from a previous page.")
         .option("--json", "Print a JSON envelope.")
         .action(async (object, rowId, options) => {
-        await handleAsyncAction("crm tasks list", options, () => requestOxygen(buildCrmTasksPath(object, rowId, options)));
+        await handleReadActionWithLens("crm tasks list", options, () => requestOxygen(buildCrmTasksPath(object, rowId, options)), formatCrmTasks);
     }))
         .addCommand(new Command("add")
-        .description("Create a task on a CRM record. Free and internal, so it writes immediately rather than previewing first.")
+        .description("Create a task on a CRM record. Free and internal, so it writes immediately rather than previewing first. The returned web_url opens THIS task on the record (?tab=tasks&task=<id>) — hand that one to the user, not the bare record link.")
         .argument("<object>", "CRM object slug, such as companies or people.")
         .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
         .argument("<title>", "What needs doing.")
         .option("--body <body>", "Longer description.")
         .option("--priority <priority>", "urgent, high, medium or low.")
         .option("--due <iso>", "ISO-8601 due timestamp. An unparseable value is rejected, never silently dropped.")
-        .option("--assignee <user_id>", "Workspace member to assign it to. Unassigned means the team, not nobody.")
+        .option("--assignee <email>", "Workspace member to assign it to, by email (a user id also works). Unassigned means the team, not nobody.")
         .option("--json", "Print a JSON envelope.")
         .action(async (object, rowId, title, options) => {
         await handleAsyncAction("crm tasks add", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tasks`, {
@@ -5360,25 +5765,25 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--status <status>", "open, completed or cancelled.")
         .option("--priority <priority>", "urgent, high, medium, low, or an empty string to clear it.")
         .option("--due <iso>", "ISO-8601 due timestamp, or an empty string to clear the deadline.")
-        .option("--assignee <user_id>", "Workspace member, or an empty string to unassign.")
+        .option("--assignee <email>", "Workspace member by email (a user id also works), or an empty string to unassign.")
         .option("--json", "Print a JSON envelope.")
         .action(async (taskId, options) => {
         await handleAsyncAction("crm tasks update", options, () => {
-            const body = readOption(options.body);
-            const priority = readOption(options.priority);
-            const due = readOption(options.due);
-            const assignee = readOption(options.assignee);
+            // Absent flag: leave the field alone. Empty string: clear it.
+            // The two must stay distinguishable all the way to the route.
+            const body = readClearableOption(options.body);
+            const priority = readClearableOption(options.priority);
+            const due = readClearableOption(options.due);
+            const assignee = readClearableOption(options.assignee);
             return requestOxygen(`/api/cli/crm/tasks/${encodeURIComponent(taskId)}`, {
                 method: "PATCH",
                 body: {
                     ...(readOption(options.title) ? { title: readOption(options.title) } : {}),
                     ...(readOption(options.status) ? { status: readOption(options.status) } : {}),
-                    ...(body !== undefined ? { body: body === "" ? null : body } : {}),
-                    ...(priority !== undefined ? { priority: priority === "" ? null : priority } : {}),
-                    ...(due !== undefined ? { due_at: due === "" ? null : due } : {}),
-                    ...(assignee !== undefined
-                        ? { assignee_actor_id: assignee === "" ? null : assignee }
-                        : {}),
+                    ...(body !== undefined ? { body } : {}),
+                    ...(priority !== undefined ? { priority } : {}),
+                    ...(due !== undefined ? { due_at: due } : {}),
+                    ...(assignee !== undefined ? { assignee_actor_id: assignee } : {}),
                 },
             });
         });
@@ -5416,7 +5821,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("crm notes list", options, () => requestOxygen(buildCrmNotesPath(object, rowId, options)));
     }))
         .addCommand(new Command("add")
-        .description("Write a note on a CRM record. Free, internal, and editable afterwards, so it writes immediately rather than previewing first.")
+        .description("Write a note on a CRM record. Free, internal, and editable afterwards, so it writes immediately rather than previewing first. The returned web_url opens THIS note on the record (?tab=notes&note=<id>) — hand that one to the user, not the bare record link.")
         .argument("<object>", "CRM object slug, such as companies or people.")
         .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
         .argument("<body>", "Note text. Markdown.")
@@ -5443,7 +5848,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (noteId, options) => {
         await handleAsyncAction("crm notes update", options, () => {
-            const title = readOption(options.title);
+            // Absent --title leaves it; --title "" clears it.
+            const title = readClearableOption(options.title);
             return requestOxygen(`/api/cli/crm/notes/${encodeURIComponent(noteId)}`, {
                 method: "PATCH",
                 body: {
@@ -5591,11 +5997,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("crm activity timeline", options, () => requestOxygen(buildCrmTimelinePath(object, rowId, options)));
     })))
         .addCommand(new Command("describe")
-        .description("Describe one configured CRM object.")
+        .description("Describe one configured CRM object: its fields, identities and relationships. Pass --field <key> to read just one field (its name, type, choices, flags) instead of the whole object.")
         .argument("<object>", "CRM object slug, such as companies or people.")
+        .option("--field <key>", "Narrow the answer to one field by its key, e.g. --field pipeline_stage. Also accepted as --attribute.")
+        .option("--attribute <key>", "Alias for --field.")
         .option("--json", "Print a JSON envelope.")
         .action(async (object, options) => {
-        await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}`));
+        const field = readOption(options.field) ?? readOption(options.attribute);
+        await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}${field ? `?attribute=${encodeURIComponent(field)}` : ""}`));
     }))
         .addCommand(new Command("duplicates")
         .description("List ranked duplicate-candidate record pairs for one CRM object (identity-overlap + fuzzy-label). Read-only.")
@@ -5652,7 +6061,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("leads-today")
-        .description("List people to contact today, ranked by their most recent GTM intent signal. Do-not-contact filtering is best-effort (email-only leads surface unchecked).")
+        .description("List people to contact today, ranked by their most recent GTM intent signal. When the output has rankedBy, equal signals are ordered by the company's ICP fit (see each lead's fit). Do-not-contact filtering is best-effort (email-only leads surface unchecked).")
         .option("--limit <limit>", "Maximum leads to return. Defaults to 25, max 100.")
         .option("--within-days <days>", "Signal look-back window in days. Defaults to 7, max 30.")
         .option("--json", "Print a JSON envelope.")
@@ -5693,11 +6102,11 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("crm automation audit", options, () => requestOxygen(buildCrmAutomationAuditPath(options)));
     })))
         .addCommand(new Command("sync")
-        .description("Bidirectionally sync a connected CRM (HubSpot/Attio) with Oxygen CRM objects: import records, configure a standing two-way sync, run a reconciliation cycle, and inspect runs and provider links.")
+        .description("Sync or import a connected CRM with Oxygen CRM objects: import records (HubSpot/Attio/Pipedrive), configure a standing two-way sync (HubSpot/Attio), run a reconciliation cycle, and inspect runs and provider links.")
         .addCommand(new Command("import")
-        .description("Import provider records into an Oxygen CRM object as a durable workflow run. Defaults to dry-run.")
-        .argument("<provider>", "Connected CRM to import from: hubspot or attio.")
-        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .description("Import provider records into an Oxygen CRM object (canonical CRM truth) as a durable workflow run. Defaults to dry-run. This pulls the WHOLE object and has no list/segment filter; to import one HubSpot saved list or one Pipedrive saved filter into a new table you can filter and enrich, use `oxygen tables hubspot import` or `oxygen tables pipedrive import` instead.")
+        .argument("<provider>", "Connected CRM to import from: hubspot, attio, or pipedrive.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, attio people|companies, or pipedrive persons|organizations. Pipedrive deals have no natural identity key and are not importable yet.")
         .option("--into <object>", "Oxygen CRM object slug to import into. Defaults to the natural mapping.")
         .option("--limit <n>", "Max records to pull this run.")
         .option("--max-credits <n>", "Volume + external-quota cap (BYOK reads cost 0 Oxygen credits but use your CRM API quota).")
@@ -5868,7 +6277,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     })));
     program
         .command("signals")
-        .description("The Signals primitive: the typed GTM intent-event stream — record signals, list the raw event feed, inspect the type registry, and read the ranked leads-to-contact-today queue.")
+        .description("The Signals primitive: the typed GTM intent-event stream — record signals, list the raw event feed, inspect the type registry, and read the ranked leads-to-contact-today queue. Who to contact first today: signals leads-today.")
         .addCommand(new Command("list")
         .description("List the raw GTM signal-event feed newest-first (website_visit / profile_view / post_reaction / new_follower), each resolved onto the person it attached to. Read-only.")
         .option("--types <types>", "Comma-separated signal types to include. Defaults to all four.")
@@ -5905,7 +6314,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("leads-today")
-        .description("List people to contact today, ranked by their most recent GTM intent signal. Do-not-contact filtering is best-effort (email-only leads surface unchecked).")
+        .description("List people to contact today, ranked by their most recent GTM intent signal. When the output has rankedBy, equal signals are ordered by the company's ICP fit (see each lead's fit). Do-not-contact filtering is best-effort (email-only leads surface unchecked).")
         .option("--limit <limit>", "Maximum leads to return. Defaults to 25, max 100.")
         .option("--within-days <days>", "Signal look-back window in days. Defaults to 7, max 30.")
         .option("--json", "Print a JSON envelope.")
@@ -5913,15 +6322,21 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("signals leads-today", options, () => requestOxygen(buildCrmLeadsTodayPath(options)));
     }))
         .addCommand(new Command("search")
-        .description("Source EXTERNAL market signals into a table: hiring, technology adoption, funding, acquisitions, and news. This is the sourcing half of Signals — `signals list` reads the events already captured for your workspace.")
+        .description("Source EXTERNAL market signals into a table: hiring, technology adoption, funding, acquisitions, news, and public LinkedIn posts by keyword (linkedin_posts). This is the sourcing half of Signals — `signals list` reads the events already captured for your workspace.")
         .addCommand(new Command("plan")
         .description("Compile a signal-sourcing request into ordered provider routes without provider calls: the chain, per-route applied/dropped filters, credit estimate, table blueprint, and whether the route can be kept LIVE on a cadence. Free.")
         .argument("[prompt]", "Prompt text or @file (same as --prompt). The --prompt flag wins if both are given.")
         .option("--prompt <text-or-file>", "Signal-sourcing prompt, or a path to a prompt file.")
-        .requiredOption("--family <family>", "Signal family: hiring, tech, funding, acquisition, news, or job_change.")
+        .requiredOption("--family <family>", "Signal family: hiring, tech, funding, acquisition, news, job_change, or linkedin_posts (public LinkedIn posts matching keywords).")
         .option("--scope <scope>", "market (discover new companies) or watch_list (track companies you name via --domains). Defaults per family.")
-        .option("--target-count <n>", "Desired row count for routing and estimates.")
-        .option("--keywords <csv>", "Comma-separated keywords, e.g. job titles for hiring or technology names for tech.")
+        .option("--target-count <n>", "Desired row count for routing and estimates. linkedin_posts: posts fetched per keyword before the AI filter (default 100), which also sets the Why it matches credit ceiling (1.5 per fetched post).")
+        .option("--keywords <csv>", "Comma-separated keywords, e.g. job titles for hiring or technology names for tech. For linkedin_posts: a post must mention AT LEAST ONE of these (each is its own search, at most 5).")
+        .option("--all-keywords <csv>", "linkedin_posts: a post must mention ALL of these.")
+        .option("--exclude-keywords <csv>", "linkedin_posts: drop posts that mention any of these, e.g. hiring.")
+        .option("--sort <order>", "linkedin_posts: recent (latest first), relevance (top match) or top (most reactions first).")
+        .option("--min-reactions <n>", "linkedin_posts: keep only posts with at least this many reactions.")
+        .option("--posted-by <url>", "linkedin_posts: only posts by this LinkedIn profile or company page URL.")
+        .option("--ai-filter <text>", "linkedin_posts: keep only posts an AI classifier judges to match this description (at most 500 characters). Free, unless the plan returns an ai_filter block: that block names the family it covers and its credits_per_item.")
         .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 country codes.")
         .option("--location <text>", "Country or state NAME for providers that filter on a location string.")
         .option("--last-days <n>", "Only signals from the last N days (1-3650).")
@@ -5936,13 +6351,37 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             method: "POST",
             body: readSignalsSearchPlanBody(options, promptArg),
         }));
+    }))
+        .addCommand(new Command("preview")
+        .description("Preview public LinkedIn posts for free (family linkedin_posts): up to 25 per keyword, with author, engagement and the --ai-filter applied. Nothing is created or charged. Each --keywords entry is one search against a small hourly search budget shared across OXYGEN, and keywords match their exact words: use a few short terms and let --ai-filter judge meaning. Then signals search run --family linkedin_posts with the same flags creates the table: free, except that with --ai-filter its Why it matches column fills itself for every kept post, quoted by the dry run.")
+        .option("--family <family>", "linkedin_posts, the only family with a free preview.", "linkedin_posts")
+        .option("--keywords <csv>", "A post must mention AT LEAST ONE of these (each is its own search, at most 5).")
+        .option("--all-keywords <csv>", "A post must mention ALL of these.")
+        .option("--exclude-keywords <csv>", "Drop posts that mention any of these, e.g. hiring.")
+        .option("--last-days <n>", "Only posts from the last N days: 1 = 24 hours, up to 7 = week, up to 30 = month.")
+        .option("--sort <order>", "recent (latest first), relevance (top match) or top (most reactions first).")
+        .option("--min-reactions <n>", "Keep only posts with at least this many reactions.")
+        .option("--posted-by <url>", "Only posts by this LinkedIn profile or company page URL.")
+        .option("--ai-filter <text>", "Keep only posts an AI classifier judges to match this description (at most 500 characters). Free, and each kept post shows why it matches (ai_filter_reason).")
+        .option("--filters-json <json-or-file>", "Filters JSON inline or a path to a JSON file; wins over individual flags per top-level filter path.")
+        .option("--credential-mode <mode>", "managed (default): Oxygen's key. user_api_key: your own Up2Data key saved in Connections, which spends your Up2Data searches instead of the shared hourly budget.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("signals search preview", options, () => requestOxygen("/api/cli/signals/search/preview", {
+            method: "POST",
+            body: {
+                family: options.family,
+                filters: readSignalSearchFilters(options) ?? {},
+                ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
+            },
+        }));
     }))
         .addCommand(new Command("run")
-        .description("Return a dry-run request or queue a live signal-search ingestion run. Live requires --approved and --max-credits. Add --bind-feed --every to also bind a pull feed to the same table in the same call, so the table keeps refilling on a cadence.")
+        .description("Return a dry-run request or queue a live signal-search ingestion run. Live requires --approved and --max-credits (linkedin_posts is free, --approved only, unless --ai-filter is set: its Why it matches reasons cost credits per kept post, quoted by the dry run, or none on the workspace's own OpenRouter key, and a dry-run ai_filter quote prices the filter itself). Add --bind-feed --every to also bind a pull feed to the same table in the same call, so the table keeps refilling on a cadence.")
         .argument("[prompt]", "Prompt text or @file (same as --prompt); requires --family. The --prompt flag wins if both are given.")
         .option("--prompt <text-or-file>", "Signal-sourcing prompt, or a path to a prompt file. Requires --family.")
         .option("--plan-json <json-or-file>", "Plan JSON returned by signals search plan, or a path to a JSON file.")
-        .option("--family <family>", "Signal family when planning from --prompt: hiring, tech, funding, acquisition, news, or job_change.")
+        .option("--family <family>", "Signal family when planning from --prompt: hiring, tech, funding, acquisition, news, job_change, or linkedin_posts.")
         .option("--scope <scope>", "market or watch_list when planning from --prompt.")
         .option("--route-id <id>", "Route id from the plan to execute.")
         .option("--tool-id <tool>", "Tool id from the plan to execute.")
@@ -5951,9 +6390,15 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--upsert-key <key>", "Column key used for live upsert. Defaults to the plan upsert key.")
         .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
         .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to 1.")
-        .option("--max-credits <n>", "Required credit ceiling for live runs.")
-        .option("--target-count <n>", "Desired row count when planning from --prompt.")
-        .option("--keywords <csv>", "Comma-separated keywords when planning from --prompt.")
+        .option("--max-credits <n>", "Credit ceiling for live runs. linkedin_posts needs it only when the dry run quotes credits for the --ai-filter reasons or the filter itself.")
+        .option("--target-count <n>", "Desired row count when planning. linkedin_posts: posts fetched per keyword before the AI filter (default 100); with --ai-filter the Why it matches ceiling is 1.5 credits per fetched post, but only kept posts are charged.")
+        .option("--keywords <csv>", "Comma-separated keywords when planning from --prompt. For linkedin_posts: a post must mention at least one.")
+        .option("--all-keywords <csv>", "linkedin_posts: a post must mention ALL of these, when planning from --prompt.")
+        .option("--exclude-keywords <csv>", "linkedin_posts: drop posts that mention any of these, when planning from --prompt.")
+        .option("--sort <order>", "linkedin_posts: recent, relevance or top, when planning from --prompt.")
+        .option("--min-reactions <n>", "linkedin_posts: at least this many reactions, when planning from --prompt.")
+        .option("--posted-by <url>", "linkedin_posts: only posts by this profile or company page, when planning from --prompt.")
+        .option("--ai-filter <text>", "linkedin_posts: keep only posts an AI classifier judges to match this description (at most 500 characters), when planning from --prompt. Other families only where the plan returns an ai_filter block.")
         .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 country codes when planning from --prompt.")
         .option("--location <text>", "Country or state NAME when planning from --prompt.")
         .option("--last-days <n>", "Only signals from the last N days when planning from --prompt.")
@@ -5966,6 +6411,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--every <sugar>", CADENCE_FLAG_DESCRIPTION)
         .option("--max-credits-per-cycle <n>", "Credit ceiling PER sync cycle for the bound feed.")
         .option("--max-rows-per-cycle <n>", "Advisory row ceiling per sync cycle for the bound feed.")
+        .option("--credential-mode <mode>", "linkedin_posts: managed (default) or user_api_key to search on your own Up2Data key saved in Connections, billed by Up2Data. The table's bound feed keeps using it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (promptArg, options) => {
         await handleAsyncAction("signals search run", options, () => requestOxygen("/api/cli/signals/search/run", {
@@ -5975,10 +6421,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     })));
     const tablesCommand = program
         .command("tables")
-        .description("Tenant workspace table commands.")
+        .description("Tenant workspace tables: create, import rows (CSV, a link, a HubSpot saved list, a Pipedrive saved filter, Supabase), enrich with columns, and run them. `tables sources` lists every way a table can start.")
         .addCommand(new Command("sources")
         .description("List every way a table can start — imports, company/people/signal sources, webhooks, functions — with the provider count and per-row credit estimate behind each. Free; nothing is called or written. The same catalog the web New table picker shows.")
-        .option("--group <group>", "Only one group: Imports, Companies, People, Signals, or Tables.")
+        .option("--group <group>", "Only one group: Companies, People, \"Professional Network\" (or linkedin), Imports, CRM, Signals, or Tables.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("tables sources", options, () => {
@@ -5990,6 +6436,220 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             return requestOxygen(`/api/cli/tables/sources${qs}`);
         });
     }))
+        .addCommand(new Command("hubspot")
+        .description("Import HubSpot contacts or companies into a new table or Records, optionally from a saved list and with do-not-contact suppression.")
+        .addCommand(new Command("lists")
+        .description("List the connected portal's saved contact/company segments and readable identity properties. Reads definitions only; no memberships, rows, or writes. Free — 0 Oxygen credits, uses your HubSpot API quota.")
+        .option("--query <text>", "Optional list-name search.")
+        .option("--connection <id>", "HubSpot connection id; defaults to the first connected account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables hubspot lists", options, () => {
+            const params = new URLSearchParams();
+            const query = readOption(options.query);
+            if (query)
+                params.set("query", query);
+            const connection = readOption(options.connection);
+            if (connection)
+                params.set("connection_id", connection);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/tables/hubspot-import${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("import")
+        .description("Preview or import HubSpot contacts/companies into a new table or Records. Named do-not-contact lists must synchronize before any import. Nothing is enrolled or sent. Live requires the exact dry-run fingerprint and approval.")
+        .option("--list <id>", "HubSpot saved-list id. Omit with --object to import all records; discover ids with `oxygen tables hubspot lists`.")
+        .option("--object <object>", "HubSpot object: contacts or companies. Required without --list; defaults to contacts for a saved list.")
+        .option("--destination <destination>", "Import into table (default) or records.")
+        .option("--connection <id>", "HubSpot connection id; defaults to the first connected account.")
+        .option("--sample", "Read up to 50 real records during the dry-run preview; uses HubSpot API quota and makes no writes.")
+        .option("--dnc-list <id>", "HubSpot contact-list id to suppress into do-not-contact before importing.")
+        .option("--company-dnc-list <id>", "Optional HubSpot company-list id to suppress organization-wide.")
+        .option("--no-dnc", "Import without suppressing anything. Required if you pass no --dnc-list, so an unsuppressed import is never accidental.")
+        .option("--name <table>", "Display name for the new table.")
+        .option("--project <project>", "Project id or slug. Defaults to General.")
+        .option("--contact-linkedin-property <name>", "Optional contact property holding a public LinkedIn /in/ URL.")
+        .option("--contact-company-domain-property <name>", "Optional contact property copied to company_domain.")
+        .option("--contact-company-linkedin-property <name>", "Optional contact property copied to company_linkedin_url.")
+        .option("--company-domain-property <name>", "Company domain property (default domain).", "domain")
+        .option("--company-linkedin-property <name>", "Optional company LinkedIn URL property.")
+        .option("--contact-properties <list>", "Comma-separated extra HubSpot contact properties to hydrate (max 50).")
+        .option("--max-records-per-list <n>", "Optional record limit; omit to import all selected records.")
+        .option("--max-credits <n>", "Hard credits cap per delivery.", "10")
+        .option("--once", "Import once instead of refreshing on a schedule.")
+        .option("--cron <expression>", "Refresh schedule; default every 15 minutes.")
+        .option("--timezone <iana>", "Schedule timezone; default UTC.")
+        .option("--reviewed-fingerprint <hash>", "Exact dry-run fingerprint, required for live.")
+        .option("--idempotency-key <key>", "Optional first-run idempotency key.")
+        .option("--live", "Create the import and queue the first durable run.")
+        .option("--approved", "Approve the reviewed reads, DNC writes, and destination upserts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables hubspot import", options, () => {
+            const list = readOption(options.list);
+            const object = readOption(options.object);
+            const destination = readOption(options.destination);
+            if (!list && !object)
+                throw new OxygenError("invalid_request", "Pass --list or --object contacts|companies to select what to import.", { exitCode: 1 });
+            if (object && object !== "contacts" && object !== "companies")
+                throw new OxygenError("invalid_request", "--object must be contacts or companies.", { exitCode: 1 });
+            if (destination && destination !== "table" && destination !== "records")
+                throw new OxygenError("invalid_request", "--destination must be table or records.", { exitCode: 1 });
+            const dncList = readOption(options.dncList);
+            const companyDncList = readOption(options.companyDncList);
+            // Commander maps `--no-dnc` to `dnc: false`; the default is
+            // `true`, so an unset flag is indistinguishable from an opt-in.
+            // Requiring one of the two means an import that suppresses
+            // nothing is always something the operator typed, which is the
+            // same guarantee the web lane gets from its preview fingerprint.
+            const optedOut = options.dnc === false;
+            if (!dncList && !companyDncList && !optedOut) {
+                // invalid_request, not a bare Error: handleAsyncAction reports
+                // an uncoded throw as `unexpected_error`, which tells a calling
+                // agent that OXYGEN broke when the caller simply omitted a flag.
+                throw new OxygenError("invalid_request", "Pass --dnc-list (and/or --company-dnc-list) to suppress a HubSpot list, or --no-dnc to import without suppressing anything. Run `oxygen tables hubspot lists` to see the ids your portal exposes.", { exitCode: 1 });
+            }
+            if (optedOut && (dncList || companyDncList)) {
+                throw new OxygenError("invalid_request", "--no-dnc cannot be combined with --dnc-list or --company-dnc-list.", { exitCode: 1 });
+            }
+            const maxRecords = readPositiveInt(options.maxRecordsPerList);
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (options.maxRecordsPerList !== undefined && (maxRecords === undefined || !Number.isSafeInteger(maxRecords)))
+                throw new OxygenError("invalid_request", "--max-records-per-list must be a positive integer.", { exitCode: 1 });
+            if (maxCredits === undefined)
+                throw new OxygenError("spend_cap_required", "--max-credits must be positive.", { exitCode: 1 });
+            const fingerprint = readOption(options.reviewedFingerprint);
+            if (options.live && !fingerprint)
+                throw new OxygenError("approval_required", "Live import requires --reviewed-fingerprint from the exact dry-run. Run the same command without --live first.", { exitCode: 1 });
+            const contactProperties = readOption(options.contactProperties)
+                ?.split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean) ?? [];
+            return requestOxygen("/api/cli/tables/hubspot-import", {
+                method: "POST",
+                body: {
+                    lead_list_id: list ?? null,
+                    ...(object ? { object } : {}),
+                    ...(destination ? { destination } : {}),
+                    ...(readOption(options.connection) ? { connection_id: readOption(options.connection) } : {}),
+                    ...(options.sample ? { sample: true } : {}),
+                    dnc_list_id: dncList ?? null,
+                    company_dnc_list_id: companyDncList ?? null,
+                    table_name: readOption(options.name) ?? null,
+                    project: readOption(options.project) ?? null,
+                    contact_linkedin_property: readOption(options.contactLinkedinProperty) ?? null,
+                    contact_company_domain_property: readOption(options.contactCompanyDomainProperty) ?? null,
+                    contact_company_linkedin_property: readOption(options.contactCompanyLinkedinProperty) ?? null,
+                    company_domain_property: readOption(options.companyDomainProperty) ?? "domain",
+                    company_linkedin_property: readOption(options.companyLinkedinProperty) ?? null,
+                    contact_properties: contactProperties,
+                    max_records_per_list: maxRecords ?? null,
+                    refresh: options.once ? "once" : "scheduled",
+                    cron: readOption(options.cron) ?? undefined,
+                    timezone: readOption(options.timezone) ?? undefined,
+                    max_credits: maxCredits,
+                    mode: options.live ? "live" : "dry_run",
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(fingerprint ? { reviewed_fingerprint: fingerprint } : {}),
+                    ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
+                },
+            });
+        });
+    })))
+        .addCommand(new Command("pipedrive")
+        .description("Import a Pipedrive saved people filter into a new Oxygen table, optionally suppressing a Pipedrive do-not-contact filter first. Connect Pipedrive with an API token first: `oxygen integrations connect pipedrive --api-key <token>`.")
+        .addCommand(new Command("filters")
+        .description("List the connected Pipedrive account's saved people/organization filters and its person/organization fields (custom-field keys included). Reads definitions only; no persons, rows, or writes. Free — 0 Oxygen credits, uses your Pipedrive API quota.")
+        .option("--query <text>", "Optional filter-name search.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables pipedrive filters", options, () => {
+            const params = new URLSearchParams();
+            const query = readOption(options.query);
+            if (query)
+                params.set("query", query);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/tables/pipedrive-import${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("import")
+        .description("Preview or run a Pipedrive saved people filter into a NEW table. Any do-not-contact filter you name is synchronized first and no row lands unless it fully succeeds. Nothing is ever enrolled or sent. Live requires the exact dry-run fingerprint and approval.")
+        .requiredOption("--filter <id>", "Pipedrive people-filter id whose persons become rows. Run `oxygen tables pipedrive filters` to see the ids your account exposes.")
+        .option("--dnc-filter <id>", "Pipedrive people-filter id to suppress into do-not-contact before importing (a filter on Marketing status = Unsubscribed is the usual choice).")
+        .option("--org-dnc-filter <id>", "Optional Pipedrive organization-filter id to suppress organization-wide.")
+        .option("--no-dnc", "Import without suppressing anything. Required if you pass no --dnc-filter, so an unsuppressed import is never accidental.")
+        .option("--name <table>", "Display name for the new table.")
+        .option("--project <project>", "Project id or slug. Defaults to General.")
+        .option("--person-linkedin-field <key>", "Optional person field key holding a public LinkedIn /in/ URL (custom keys are 40-character hex; see `tables pipedrive filters`).")
+        .option("--person-title-field <key>", "Optional person field key copied to title. Pipedrive has no native job-title field.")
+        .option("--org-domain-field <key>", "Optional organization field key holding the website or domain. Pipedrive has no native domain field; never inferred from email.")
+        .option("--org-linkedin-field <key>", "Optional organization field key holding its LinkedIn company page.")
+        .option("--person-fields <list>", "Comma-separated extra Pipedrive person field keys to hydrate into pipedrive_fields (max 15).")
+        .option("--no-hydrate-organizations", "Skip reading each person's organization; company columns stay empty.")
+        .option("--max-records-per-filter <n>", "Complete-snapshot cap (1-5000), enforced while the filter is read.", "5000")
+        .option("--max-credits <n>", "Hard credits cap per delivery.", "10")
+        .option("--once", "Import once instead of refreshing on a schedule.")
+        .option("--cron <expression>", "Refresh schedule; default every 15 minutes.")
+        .option("--timezone <iana>", "Schedule timezone; default UTC.")
+        .option("--reviewed-fingerprint <hash>", "Exact dry-run fingerprint, required for live.")
+        .option("--idempotency-key <key>", "Optional first-run idempotency key.")
+        .option("--live", "Create the table and queue the first durable run.")
+        .option("--approved", "Approve the reviewed bounded reads, DNC writes, and table upserts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables pipedrive import", options, () => {
+            const dncFilter = readOption(options.dncFilter);
+            const orgDncFilter = readOption(options.orgDncFilter);
+            // Same affirmative contract as `tables hubspot import`: an import
+            // that suppresses nothing is always something the operator typed.
+            const optedOut = options.dnc === false;
+            if (!dncFilter && !orgDncFilter && !optedOut) {
+                throw new OxygenError("invalid_request", "Pass --dnc-filter (and/or --org-dnc-filter) to suppress a Pipedrive filter, or --no-dnc to import without suppressing anything. Run `oxygen tables pipedrive filters` to see the ids your account exposes.", { exitCode: 1 });
+            }
+            if (optedOut && (dncFilter || orgDncFilter)) {
+                throw new OxygenError("invalid_request", "--no-dnc cannot be combined with --dnc-filter or --org-dnc-filter.", { exitCode: 1 });
+            }
+            const maxRecords = readPositiveInt(options.maxRecordsPerFilter);
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxRecords === undefined || maxRecords > 5000)
+                throw new OxygenError("invalid_request", "--max-records-per-filter must be between 1 and 5000.", { exitCode: 1 });
+            if (maxCredits === undefined)
+                throw new OxygenError("spend_cap_required", "--max-credits must be positive.", { exitCode: 1 });
+            const fingerprint = readOption(options.reviewedFingerprint);
+            if (options.live && !fingerprint)
+                throw new OxygenError("approval_required", "Live import requires --reviewed-fingerprint from the exact dry-run. Run the same command without --live first.", { exitCode: 1 });
+            const personFields = readOption(options.personFields)
+                ?.split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean) ?? [];
+            const hydrateOrganizations = options.hydrateOrganizations !== false;
+            return requestOxygen("/api/cli/tables/pipedrive-import", {
+                method: "POST",
+                body: {
+                    filter_id: readOption(options.filter),
+                    dnc_filter_id: dncFilter ?? null,
+                    org_dnc_filter_id: orgDncFilter ?? null,
+                    table_name: readOption(options.name) ?? null,
+                    project: readOption(options.project) ?? null,
+                    person_linkedin_field: readOption(options.personLinkedinField) ?? null,
+                    person_title_field: readOption(options.personTitleField) ?? null,
+                    org_domain_field: readOption(options.orgDomainField) ?? null,
+                    org_linkedin_field: readOption(options.orgLinkedinField) ?? null,
+                    person_fields: personFields,
+                    hydrate_organizations: hydrateOrganizations,
+                    max_records_per_filter: maxRecords,
+                    refresh: options.once ? "once" : "scheduled",
+                    cron: readOption(options.cron) ?? undefined,
+                    timezone: readOption(options.timezone) ?? undefined,
+                    max_credits: maxCredits,
+                    mode: options.live ? "live" : "dry_run",
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(fingerprint ? { reviewed_fingerprint: fingerprint } : {}),
+                    ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
+                },
+            });
+        });
+    })))
         .addCommand(new Command("create")
         .description("Create a real Postgres-backed workspace table. Free — 0 Oxygen credits. To create a table and import a file in one step, use `tables import --create <name>`.")
         .argument("<name>", "Display name for the table.")
@@ -6410,9 +7070,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }));
     const watcherCommand = tablesCommand.command("watcher")
-        .description("LinkedIn Profile Watcher: one editable table of daily engagers, source attribution, and current employers from posts in the past 7 days. Start with preview (free); create/resume activate paid daily monitoring after exact approval.");
+        .description("Professional Network Post Engagers: one editable table of daily engagers, source attribution, and current employers from posts in the past 7 days. Start with preview (free); create/resume activate paid daily monitoring after exact approval.");
     watcherCommand.command("get")
-        .description("Read a table's LinkedIn Profile Watcher configuration and status. Free.")
+        .description("Read a table's Professional Network Post Engagers configuration and status. Free.")
         .argument("<table>", "Watcher table id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
@@ -6422,7 +7082,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         const command = watcherCommand.command(action)
             .description({
             preview: "Free configuration and credit preview: no provider calls, writes, or scheduling. Omit --max-credits for a recommendation and preview hash. Ask for real profile URLs; never invent them.",
-            create: "Create and activate a LinkedIn Profile Watcher after approval of its exact preview. Starts collection now and daily at 07:00 UTC under the approved per-cycle cap.",
+            create: "Create and activate a Professional Network Post Engagers table after approval of its exact preview. Starts collection now and daily at 07:00 UTC under the approved per-cycle cap.",
             update: "Edit watched profiles or the per-cycle cap from the table. Preview the changes first; approval binds the exact new configuration.",
             pause: "Pause daily monitoring while retaining the table and collected rows.",
             resume: "Resume paid daily monitoring after reviewing a fresh preview and approving its per-cycle credit cap.",
@@ -6434,7 +7094,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 .option("--name <name>", "Watcher table display name.")
                 .option("--project <project>", "Project id or slug; defaults to General.")
                 .option("--profiles-json <json>", "JSON array of 1–10 real public LinkedIn profile URLs; replaces the watched list.")
-                .option("--max-credits <credits>", "Hard credit ceiling for each daily cycle; never a monthly ceiling.");
+                .option("--max-credits <credits>", "Hard credit ceiling for each daily cycle; never a monthly ceiling.")
+                .option("--credential-mode <mode>", "managed (default): Oxygen credits per cycle. user_api_key: every LinkedIn call runs on your own Up2Data key saved in Connections, billed by Up2Data, no Oxygen credits.");
             if (action !== "preview")
                 command
                     .option("--preview-hash <hash>", "Exact configuration hash returned by preview; re-preview after any change.")
@@ -6461,11 +7122,60 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                         ...(readOption(options.requestId) ? { request_id: readOption(options.requestId) } : {}),
                         ...(readOption(options.previewHash) ? { preview_hash: readOption(options.previewHash) } : {}),
                         ...(options.approved ? { approved: true } : {}),
+                        ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
                     },
                 });
             });
         });
     }
+    const followersCommand = tablesCommand.command("followers")
+        .description("Order a LinkedIn company page's followers as a table of leads — a competitor's audience. `check` is free and quotes the exact cost; `order` places it. The order is fulfilled by ScrapeLi, so the table is created immediately and its rows land later; there is no published delivery time.");
+    followersCommand.command("check")
+        .description("Free: read the page's follower count and quote the exact credits an order would reserve. No spend, no table; `orderable: false` means no order can be placed yet.")
+        .requiredOption("--company <url>", "LinkedIn company page URL, e.g. https://www.linkedin.com/company/hubspot.")
+        .option("--records <n>", "How many followers to price. Minimum 100; defaults to 1000.")
+        .option("--package <package>", "Basic (default) or Advanced.")
+        .option("--credential-mode <mode>", "managed (default): Oxygen credits. user_api_key: your own ScrapeLi key saved in Connections, billed by ScrapeLi.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables followers check", options, () => requestOxygen("/api/cli/tables/linkedin-company-followers", {
+            method: "POST",
+            body: {
+                action: "preview",
+                company_url: readOption(options.company),
+                ...(options.records !== undefined ? { records: readPositiveNumber(options.records) } : {}),
+                ...(readOption(options.package) ? { package: readOption(options.package) } : {}),
+                ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
+            },
+        }));
+    });
+    followersCommand.command("order")
+        .description("Place the follower order after checking it. With managed credits it requires --max-credits at or above the quoted cost: this buys a real audience and is never approved implicitly. Creates the table now; rows land when ScrapeLi delivers.")
+        .requiredOption("--company <url>", "LinkedIn company page URL whose followers to order.")
+        .option("--max-credits <credits>", "Hard credit ceiling for this order. Must be at least the amount `tables followers check` quoted. Not needed with --credential-mode user_api_key.")
+        .requiredOption("--request-id <uuid>", "One stable UUID for this order. Reuse it after a timeout; a new key would buy the same audience twice.")
+        .option("--records <n>", "How many followers to buy. Minimum 100; defaults to 1000.")
+        .option("--package <package>", "Basic (default) or Advanced.")
+        .option("--name <name>", "Table name. Defaults to \"<Company> Followers\".")
+        .option("--project <project>", "Project id or slug; defaults to General.")
+        .option("--credential-mode <mode>", "managed (default): Oxygen credits. user_api_key: your own ScrapeLi key saved in Connections, billed by ScrapeLi.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables followers order", options, () => requestOxygen("/api/cli/tables/linkedin-company-followers", {
+            method: "POST",
+            body: {
+                action: "create",
+                company_url: readOption(options.company),
+                ...(options.records !== undefined ? { records: readPositiveNumber(options.records) } : {}),
+                ...(readOption(options.package) ? { package: readOption(options.package) } : {}),
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+                ...(options.maxCredits !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+                ...(readOption(options.requestId) ? { request_id: readOption(options.requestId) } : {}),
+                ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
+            },
+        }));
+    });
     tablesCommand.addCommand(new Command("relate")
         .description("Relate two tables: define empty Tables-owned relation columns on the source and target. Then use `oxygen tables link` to populate row-to-row edges. Works on any workspace table; plain tables stay plain and are never registered as CRM objects. Defaults to dry-run.")
         .argument("<table>", "Source table id or slug.")
@@ -6938,7 +7648,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         return requestOxygen(`/api/cli/tables/auto-run?${params.toString()}`);
     })))
         .addCommand(new Command("set")
-        .description("Enable a standing auto-run: automatically queue the given columns for rows written to this table (imports, inserts, upserts). Default off.")
+        .description("Enable a standing auto-run: automatically queue the given columns for rows written to this table (imports, inserts, upserts). A queued cell that already has a value is skipped unless --force, so an upsert that touches an existing, filled row is not charged again. Rows a LinkedIn capture writes are subscribed separately and only when newly inserted — for profile viewers, `viewers enrichment --on`. Default off.")
         .argument("<table>", "Table id or slug.")
         .requiredOption("--columns <csv>", "Comma-separated column keys to auto-run on newly written rows (tool, AI, formula, enrichment, bind, or lookup columns).")
         .option("--sources <csv>", "Which write sources trigger the auto-run: any of import, insert, upsert, send. Defaults to all when omitted.")
@@ -8556,10 +9266,14 @@ Examples:
         .addCommand(new Command("add")
         .description("Add a nullable column to a workspace table. Writes the definition only — this never runs the column and never spends credits; use `columns run` for that, with --dry-run first to see the cost. For a page, posting or filing the row already links to, or a company fact Oxygen already knows how to research (founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ, a LinkedIn or Crunchbase page), pick a template from `columns catalog` (--prompt-key) instead of writing a prompt; or read a URL column with --kind research --research-url. The guide is the oxygen-gtm skill's enriching-and-researching.md. A formula column needs no run at all: it evaluates on read from its current inputs, so `tables query` shows its values immediately.")
         .argument("<table>", "Table id or slug.")
-        .option("--preset <preset>", "Add a pre-built column bundle instead of one column, which is what --prompt-key adds: a preset writes SEVERAL columns at once and needs no --input on a table whose identity column it can find, while --prompt-key adds one template column and binds each input you name. Presets: `person_enrich` (one LinkedIn profile lookup, then first/last/full name, current company and its LinkedIn URL, job title, start date, education, school, headline, bio, location and followers as free formula columns; the person templates in `columns catalog --category people` all read its payload column), `company_enrich` (domain, LinkedIn page, headcount, industry and full profile, cascading across providers until one answers; binds to the person preset's current_company_linkedin_url automatically), `company_tech_stack` (the technologies a company runs, from its website and hiring, over the same cascade), `email_hashes` (SHA-256 and MD5 of each email for ad audiences, 0 credits), or `domain_check` (1 credit/row for a live/redirect/parked/not_found/dead verdict on every domain, cached 30 days, plus a free label column to filter on). For a single cleaned or classified column, use a template from `columns catalog` instead — that is one column, not a bundle. Oxygen finds the identity column itself — override with --input. Creating the columns is free; run them afterwards, --dry-run first.")
-        .option("--input <slot=column...>", "Bind a preset or template input to an exact column, e.g. --input url=pricing_url with --prompt-key, or --input company_name=account --input domain=website with --preset. Repeatable. For a preset it is only needed when the automatic match is wrong or missing; for a template it names the column each declared input reads.", collectRepeatable, [])
-        .option("--preset-fields <fields>", "For --preset company_enrich: comma-separated field keys to create instead of the default bundle (see `oxygen find company --list-fields` for the catalog and per-row cost), e.g. --preset-fields headcount,industry,funding_stage,latest_funding_round,competitors,technologies,job_openings. Free derived fields read the profile the bundle already fetches; each lane-priced field adds its own cost to the run. On a table that already has the bundle, the new fields are added to the existing company enrichment column rather than a second one.")
-        .option("--check-technologies <names>", "For --preset company_enrich with the technology_check field: comma-separated technology names answered yes/no per row (e.g. hubspot,salesforce).")
+        .option("--preset <preset>", "Add a pre-built column bundle instead of one column, which is what --prompt-key adds: a preset writes SEVERAL columns at once and needs no --input on a table whose identity column it can find, while --prompt-key adds one template column and binds each input you name. Presets: `person_enrich` (one LinkedIn profile lookup — Blitz first, the LinkedIn Scraper only when Blitz has no match — then first/last/full name, current company and its LinkedIn URL, job title, start date, education, school, headline, bio, location and followers as free stored fields that fill when the lookup runs; the person templates in `columns catalog --category people` all read its payload column), `company_enrich` (one company lookup from a domain or LinkedIn URL — Blitz first, the LinkedIn Scraper only when Blitz has no match, about 1 credit a company — keeping the whole profile in its JSON column plus name, domain, LinkedIn URL, headcount, industry, description, founded year and HQ country as free stored fields; no field choices; binds to the person preset's current_company_linkedin_url automatically), `company_tech_stack` (the technologies a company runs, from its website and hiring), or `domain_check` (1 credit/row for a live/redirect/parked/not_found/dead verdict on every domain, cached 30 days, plus a free label column to filter on). For a single cleaned or classified column, use a template from `columns catalog` instead — that is one column, not a bundle. Name the input column with --input: `url` for person_enrich, `domain` and/or `linkedin_url` for the company presets. Any column works whatever it is called; without --input Oxygen guesses from column names. Creating the columns is free; run them afterwards, --dry-run first.")
+        .option("--input <slot=column...>", "Bind a preset or template input to an exact column, e.g. --input url=pricing_url with --prompt-key, or --input domain=website --input linkedin_url=company_li with --preset. Repeatable. For a preset it is only needed when the automatic match is wrong or missing; for a template it names the column each declared input reads.", collectRepeatable, [])
+        // No preset takes a field list any more (founder, 2026-09-24). Hidden,
+        // not removed: an old script passing them gets the server's refusal,
+        // which names `find company --fields` and `--preset company_tech_stack`,
+        // instead of an unknown-option error that explains nothing.
+        .addOption(new Option("--preset-fields <fields>", "Retired: presets take no field list.").hideHelp())
+        .addOption(new Option("--check-technologies <names>", "Retired: presets take no field list.").hideHelp())
         .option("--capability <capability>", "Seed a ready-to-run enrichment column WITHOUT running it (0 credits): verify_email grades the address a row already holds \u2014 MillionVerifier first, catch-all domains escalate to BounceBan; work_email, personal_email, mobile_phone and linkedin_url find a value the row is missing through the managed waterfall (personal_email is the non-work mailbox, graded by MillionVerifier before it is written). Sets kind=enrichment and jsonb; label and key default from the capability. Preview cost with `enrich-column preview --capability <same>` and run later with `enrich-column run --approved --max-credits <n>`.")
         .option("--label <label>", "Display label for the new column. Required unless --prompt-key or --capability supplies a default title.")
         .option("--key <key>", "Optional stable column key. Defaults to a normalized label.")
@@ -8573,7 +9287,7 @@ Examples:
         .option("--research-exclude-domains <csv>", "Research columns: comma-separated domains to exclude from results.")
         .option("--research-mode <mode>", "Research columns: how tightly the answer is bound to the sources. Default: summarize and combine what they say. strict: answer only from what a source states verbatim (for figures and identifiers). estimate: reason to a figure from the evidence (for revenue or headcount).")
         .option("--research-results <n>", "Research columns: how many search results to ground each row on (1-25, default 5). More evidence costs no extra search, but a larger prompt.")
-        .option("--research-engine <engine>", "Research columns: pin the search provider (exa, parallel, or firecrawl), or with --research-url the page-fetch provider (firecrawl, linkup, or exa). Defaults to exa for search and firecrawl for fetch, falling back automatically. Most users should not set this.")
+        .option("--research-engine <engine>", "Research columns: pin the search provider (serper or exa), or with --research-url the page-fetch provider (firecrawl or exa). Defaults to serper for search and firecrawl for fetch, falling back automatically. Most users should not set this.")
         .option("--research-url <column_key>", "Research columns: read the ONE page whose URL is in this column for each row instead of searching the web — a pricing page, a job posting, an event page, a 10-K. The page's content is the only evidence, the answer cites it as its source, and the row costs the fetch plus the model (see --dry-run). A URL ending in .pdf is read by the PDF-capable fetch lane first.")
         .option("--prompt-key <key>", "Add a column template from `oxygen columns catalog` (e.g. pricing_plan_summary_v1 reads a pricing-page URL column and returns plan count, price range and enterprise plan; company_founders_v1 reads a domain column and returns the founders with sources; person_skill_set_v1 reads the person_enrich payload column with --input profile=person_enrich). Materializes the template's prompt, output schema and grounding and sets its kind (ai, research, formula, or search — a managed web search whose cell is a page URL). Bind each declared input with --input <name>=<column_key>.")
         .option("--input-mapping <json>", "JSON alternative to --input for --prompt-key: an object mapping template input names to columns, e.g. '{\"url\":{\"column\":\"pricing_url\"}}' (a bare column-key string or {\"literal\": ...} also works). Copy templates (email_draft_v1, subject_line_variants_v1, ...) reject mappings built only from manual name/title/company columns — ground them on a research or enrichment column, or write a freeform prompt with --prompt instead.")
@@ -8585,6 +9299,16 @@ Examples:
         .option("--structured-output", "Undo --no-structured-output: let the prompt's named sections shape the answer again.")
         .option("--output-schema-json <json>", "AI column output JSON schema as inline JSON.")
         .option("--output-schema-file <path>", "AI column output JSON schema read from a file path.")
+        // Classification columns stay out of --help until OXYGEN_SYSTEM_ONE_COLUMN_MODE
+        // is on in production: a help screen the npm CLI prints everywhere must not
+        // offer what production answers with classification_not_enabled. They still
+        // parse where the surface is on (dev), and the flag-aware `tools search`
+        // catalog advertises them there. Unhide at the production flip (ADR 0027).
+        .addOption(new Option("--classify <labels>", "Classification column: label every row with one of these comma-separated labels (2-20), answering --prompt. Each cell holds the label, a 0-1 confidence and uncertain:true below --min-confidence (the best guess is kept). Flat ~0.075 credits/row; see `columns run --dry-run`.").hideHelp())
+        .addOption(new Option("--yes-no <question>", "Classification column: answer this yes/no question per row (reference columns as {{column_key}}). Filter on the answer with `tables query --filter-tree-json` and a path leaf, e.g. '{\"type\":\"group\",\"conjunction\":\"and\",\"children\":[{\"type\":\"leaf\",\"columnKey\":\"<column>\",\"path\":\"answer\",\"operator\":\"is\",\"value\":true}]}'.").hideHelp())
+        .addOption(new Option("--score <levels>", "Classification column: rate each row on these comma-separated levels, lowest first (2-10), answering --prompt.").hideHelp())
+        .addOption(new Option("--min-confidence <0-1>", "Classification columns: below this the answer is marked uncertain. Default 0.85 (0.7 for --yes-no).").hideHelp())
+        .addOption(new Option("--grounding <mode>", "Classification columns: none (default) judges only the row and your question; workspace also sends your workspace knowledge (ICP, positioning), which can pull answers toward your ICP.").hideHelp())
         .option("--bind-object <slug>", "Bind column CRM object slug (companies, people, deals, ...). Sets kind=bind and resolves rows to CRM records by identity.")
         .option("--bind-map <pairs>", "Bind identity mapping as identity=column pairs, e.g. domain=website,linkedin_url=li.")
         .option("--bind-create", "Bind columns: assert a new CRM record for unmatched rows (onNoMatch=create; a truth write, needs --approved on run).")
@@ -8635,6 +9359,11 @@ Examples:
                 if (options.label || options.promptKey || options.definitionJson) {
                     throw new OxygenError("invalid_request", "--preset builds its own column set. Drop --label/--prompt-key/--definition-json, or add the column by hand without --preset.", { exitCode: 1 });
                 }
+                // Named only when passed: the classification flags are hidden from help.
+                const classificationFlag = options.classify ? "--classify" : options.yesNo ? "--yes-no" : options.score ? "--score" : null;
+                if (classificationFlag) {
+                    throw new OxygenError("invalid_request", `--preset builds its own column set. Drop ${classificationFlag}, or add the classification column without --preset.`, { exitCode: 1 });
+                }
                 const presetBody = { table, preset };
                 const inputs = parseKeyValuePairs(options.input ?? []);
                 if (Object.keys(inputs).length > 0)
@@ -8661,7 +9390,30 @@ Examples:
             if (options.promptKey && !options.inputMapping && Object.keys(templateInputs).length === 0) {
                 throw new OxygenError("missing_input_mapping", `--prompt-key ${options.promptKey} reads named inputs; bind each one to a column with --input <name>=<column_key> (e.g. --input url=pricing_url), or pass --input-mapping <json>. See \`oxygen columns catalog\` for the inputs a template reads.`, { exitCode: 1 });
             }
-            const prompt = readAiPromptOption(options.prompt);
+            const promptOption = readAiPromptOption(options.prompt);
+            const decisionFlags = readColumnDecisionFlags(options);
+            if (decisionFlags) {
+                const conflicting = [
+                    capability ? "--capability" : null,
+                    readOption(options.promptKey) ? "--prompt-key" : null,
+                    readOption(options.bindObject) || readOption(options.bindMap) || options.bindCreate ? "--bind-object" : null,
+                    readOption(options.lookupTable) ? "--lookup-table" : null,
+                    readOption(options.model) ? "--model" : null,
+                    readOption(options.outputSchemaJson) || readOption(options.outputSchemaFile) ? "--output-schema-json" : null,
+                    readOption(options.researchQuery) || readOption(options.researchUrl) ? "--research-query/--research-url" : null,
+                    readOption(options.kind) && readOption(options.kind).toLowerCase() !== "ai" ? `--kind ${readOption(options.kind)}` : null,
+                ].filter((flag) => flag !== null);
+                if (conflicting.length > 0) {
+                    throw new OxygenError("invalid_request", `A classification column (--classify, --yes-no or --score) is an AI column answered by the classifier, so it cannot be combined with ${conflicting.join(", ")}.`, { exitCode: 1 });
+                }
+                if (decisionFlags.question !== null && promptOption !== null) {
+                    throw new OxygenError("invalid_request", "--yes-no carries the question itself. Drop --prompt, or use --classify \"yes,no\" with --prompt.", { exitCode: 1 });
+                }
+                if (decisionFlags.question === null && promptOption === null) {
+                    throw new OxygenError("invalid_request", "--classify and --score need the question each row answers. Add --prompt \"<question>\", referencing columns as {{column_key}} — e.g. --prompt \"What kind of company is {{company_name}}?\".", { exitCode: 1 });
+                }
+            }
+            const prompt = decisionFlags?.question ?? promptOption;
             if (prompt !== null && options.promptKey) {
                 throw new OxygenError("invalid_request", "Pass either --prompt (a freeform prompt) or --prompt-key (a prompt-library entry), not both.", { exitCode: 1 });
             }
@@ -8731,6 +9483,12 @@ Examples:
                 column.definition = isResearch
                     ? applyResearchColumnConfig(applyAiColumnConfig(definition, options), options)
                     : applyAiColumnConfig(definition, options);
+                if (decisionFlags) {
+                    column.definition.decision = decisionFlags.decision;
+                    // The cell is {answer, confidence, uncertain, reason}: JSON, so it filters.
+                    if (!options.dataType)
+                        column.data_type = "jsonb";
+                }
             }
             if (readOption(options.bindObject) || readOption(options.bindMap) || options.bindCreate) {
                 // A column is one kind. --prompt already set kind=ai above, and the
@@ -8803,7 +9561,7 @@ Examples:
         .option("--all", "Run all rows. Requires --background, except with --dry-run, which previews the background run without queueing it.")
         .option("--filter-json <json>", "Row selector filter object or array for background runs. Do not combine with --all, --limit, or --row-id.")
         .option("--formula-values <mode>", "With --filter-json on a formula column, first refresh that selector with `columns run <table> <column> --force` (0 credits), then pass 'materialized'. The run filters the stored snapshot and persists this freshness acknowledgement.")
-        .option("--force", "Run even when the target cell already has a value. Formula columns compute when read, so `tables query` shows their values without a run; a run skips rows that already store a value (existing_value), and --force refreshes them.")
+        .option("--force", "Run even when the target cell already has a value. Formula columns compute when read, so `tables query` shows their values without a run. Stored fields (definition `fill: \"empty\"`, such as the person_enrich profile fields) keep their own cell instead: it fills when the column they read from runs. A run skips rows that already store a value (existing_value), and --force refreshes them.")
         .option("--connection-id <connection_id>", "Optional provider integration connection id.")
         .option("--background", "Create a durable background run for a free deterministic column. Paid AI/tool/enrichment server runs are always backgrounded.")
         .option("--approved", "Confirm a paid durable run, or a bind create-mode run (onNoMatch=create), after inspecting a dry run or preview.")
@@ -8990,7 +9748,7 @@ Examples:
         .option("--research-exclude-domains <csv>", "Research columns: replace the comma-separated list of domains to exclude.")
         .option("--research-mode <mode>", "Research columns: strict (answer only from the sources) or estimate (reason to a figure from them).")
         .option("--research-results <n>", "Research columns: how many search results to ground each row on (1-25).")
-        .option("--research-engine <engine>", "Research columns: pin the search provider (exa, parallel, or firecrawl).")
+        .option("--research-engine <engine>", "Research columns: pin the search provider (serper or exa).")
         // Declaring BOTH forms leaves the default undefined (Commander only
         // defaults to true when --no- is declared alone), so an update that
         // doesn't mention visibility leaves it untouched.
@@ -9443,6 +10201,7 @@ Examples:
         .option("--upsert-key <key>", "Column key used to upsert instead of inserting.")
         .option("--connection-id <connection_id>", "Optional provider integration connection id.")
         .option("--max-concurrency <n>", "Maximum concurrent ingestion items for this run. Defaults to 5.")
+        .option("--max-credits <n>", "Maximum credits to reserve for this run; required for paid tools.")
         .option("--metadata-json <json>", "Optional metadata object to attach to the run.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
@@ -9455,6 +10214,7 @@ Examples:
             }
             const maxPages = readPositiveInt(options.maxPages);
             const maxConcurrency = readPositiveInt(options.maxConcurrency);
+            const maxCredits = readPositiveNumber(options.maxCredits);
             const rowMappingJson = readOption(options.rowMappingJson);
             const payload = {
                 tool_id: toolId,
@@ -9474,6 +10234,7 @@ Examples:
                     ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
                     ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
                     ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+                    ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
                     metadata: {
                         command: "table-ingestions create-tool-page",
                         ...(options.metadataJson ? parseJsonObject(options.metadataJson) : {}),
@@ -9724,15 +10485,15 @@ Examples:
         .description("Plan, dry-run, or queue provider-backed company search.")
         .addCommand(new Command("filters")
         .description("List Company Search filter fields and options without a provider call, including every enum field's full accepted-value list. --source hiring lists the Job postings filters instead (job.* and company.*).")
-        .option("--source <source>", "company_search (default) or hiring: live job postings for the roles you name, one row per posting with a link to it.")
+        .option("--source <source>", "company_search (default), google_maps, or hiring: live job postings for the roles you name, one row per posting with a link to it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("companies search filters", options, () => requestOxygen(`/api/cli/companies/search/preview${readCompanySourceQuery(options.source)}`));
     }))
         .addCommand(new Command("preview")
-        .description("Preview up to 50 rows free, using native filters from companies search filters. With --source hiring the sample is the open roles matching job.title, one row per posting, and total_results is the exact number of matching postings.")
-        .requiredOption("--filters-json <json-or-file>", 'Nested native filters as JSON or @file/path, e.g. {"employee_count":{"min":10}}; {} searches all.')
-        .option("--source <source>", "company_search (default) or hiring. Filters for hiring nest under job and company, e.g. {\"job\":{\"title\":{\"include\":[\"Account Executive\"]}}}.")
+        .description("Preview up to 50 rows free, using native filters from companies search filters. --source google_maps previews 20 businesses with a q business-and-area filter; total_results is unavailable when the API publishes no total. --source hiring previews matching job postings with an exact total.")
+        .requiredOption("--filters-json <json-or-file>", 'Native filters as JSON or @file/path. Google Maps requires q, placeId or cid; other sources accept {} for all results.')
+        .option("--source <source>", "company_search (default), hiring or google_maps. Filters for hiring nest under job and company, e.g. {\"job\":{\"title\":{\"include\":[\"Account Executive\"]}}}.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("companies search preview", options, () => requestOxygen("/api/cli/companies/search/preview", {
@@ -9772,7 +10533,7 @@ Examples:
     }))
         .addCommand(new Command("run")
         .description("Return a dry-run request or queue a live company-search ingestion run.")
-        .option("--source <source>", "Use company_search or hiring with --source-filters-json instead of a prompt or plan. hiring sources the live job postings for the roles you name, one row per posting (up to 5,000 per search), each with its posting URL, date and hiring company.")
+        .option("--source <source>", "Use company_search, hiring or google_maps with --source-filters-json instead of a prompt or plan. hiring sources the live job postings for the roles you name, one row per posting (up to 5,000 per search), each with its posting URL, date and hiring company.")
         .option("--source-filters-json <json-or-file>", 'Same nested filters as the free preview, e.g. {"employee_count":{"min":10}} or, with --source hiring, {"job":{"title":{"include":["Account Executive"]}}}.')
         .option("--table-name <name>", "Name the table this run creates. Ignored when --table names an existing table, which must already exist.")
         .argument("[prompt]", "Prompt text or @file (same as --prompt). The --prompt flag wins if both are given.")
@@ -9786,7 +10547,7 @@ Examples:
         .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
         .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to the route estimate, and is itself capped by --target-count: asking for more pages than that many rows needs cannot add rows.")
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
-        .option("--target-count <n>", "How many rows to source. Defaults to 50 — one page — so raise it to import more than the free sample, using the preview's total_results as the real ceiling. It bounds pagination: --max-pages can never exceed the pages this count needs, and a run that stops because of it reports stopped_by row_target.")
+        .option("--target-count <n>", "How many rows to source (default 50), independently of the free preview size. Maps previews up to 20; page size varies by source. Total matches may be unavailable. This count bounds pagination: --max-pages cannot exceed the pages it needs, and a run that stops because of it reports stopped_by row_target.")
         .option("--source-intent <intent>", "Override detected intent when planning from --prompt.")
         .option("--filters-json <json-or-file>", "CompanySearchFilters JSON inline or a @file/path when planning from --prompt; wins over individual flags per top-level filter path.")
         .option("--industries <csv>", "Comma-separated industries to include when planning from --prompt.")
@@ -9833,7 +10594,7 @@ Examples:
         .argument("<table>", "Table id or slug.")
         .option("--missing-fields <fields>", "Comma-separated fields to fill.")
         .option("--providers <providers>", "Comma-separated provider pool.")
-        .option("--mode <mode>", "dry_run or live. Defaults to live. dry_run returns the same plan as `companies enrich preview` and creates no column; only a live run creates the target columns it fills. To attach a company field for free and run it later, bind the OXYGEN-managed Function instead (`functions list --managed`, then `functions bind`).")
+        .option("--mode <mode>", "dry_run or live. Defaults to live. dry_run returns the same plan as `companies enrich preview` and creates no column; only a live run creates the target columns it fills. To reuse a published workspace Function, inspect `functions list` and attach it with `functions bind` before running the column.")
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
         .option("--approved", "Approve this live paid run after inspecting the preview.")
         .option("--all", "Run on all rows.")
@@ -10072,8 +10833,13 @@ Examples:
         .requiredOption("--to <plan>", 
     // Derived from the catalog, never retyped: this help text is the only
     // place a customer's agent learns which plans exist, and it named
-    // three retired ones for as long as it was a literal.
-    `Target plan: ${PURCHASABLE_PLAN_KEYS.join(", ")}.`)
+    // three retired ones for as long as it was a literal. The price sits
+    // beside each key because nothing else on the CLI prints a
+    // plan-to-price table (blind baseline, 2026-09-22).
+    `Target plan: ${PURCHASABLE_PLAN_KEYS.map((key) => {
+        const cents = resolveBasePricingPlan(key)?.monthlyPriceCents;
+        return typeof cents === "number" ? `${key} ($${cents / 100}/mo)` : key;
+    }).join(", ")}.`)
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing change", options, () => requestOxygen("/api/cli/billing/change", {
@@ -10138,7 +10904,7 @@ Examples:
         .option("--provider <provider>", "Filter by provider id. With --meter provider_seats, selects the seat provider: linkedin (default) or whatsapp.")
         .option("--source <source_id>", "Filter by source_id/provider operation.")
         .option("--source-id <source_id>", "Alias for --source.")
-        .option("--run-id <run_id>", "Filter by run id recorded in ledger metadata.")
+        .option("--run-id <run_id>", "Filter by run id recorded in ledger metadata. A table run's reserve and release events carry it, but its settled charges may not yet: read what a table run billed from `table-runs get <run>` (creditsUsed), or per row from `table-runs items`.")
         .option("--nonzero", "Only include events that changed available or reserved credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -10160,7 +10926,7 @@ Examples:
         .option("--provider <provider>", "Filter by provider id.")
         .option("--source <source_id>", "Filter by source_id/provider operation.")
         .option("--source-id <source_id>", "Alias for --source.")
-        .option("--run-id <run_id>", "Filter by run id recorded in ledger metadata.")
+        .option("--run-id <run_id>", "Filter by run id recorded in ledger metadata. A table run's reserve and release events carry it, but its settled charges may not yet: read what a table run billed from `table-runs get <run>` (creditsUsed), or per row from `table-runs items`.")
         .option("--nonzero", "Only include events that changed available or reserved credits. Default for audit except BYOK filters.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -10329,7 +11095,7 @@ Examples:
     program.addCommand(new Command("egress")
         .description("Native email egress: status, shared/dedicated IP inventory, the dedicated-IP add-on, policy assignments, and a fail-closed retired rotation shim.")
         .addCommand(new Command("status")
-        .description("Show this workspace's actual native egress mode, active IP, health counts, dedicated add-on, and one bounded page of the inspectable mailbox policy ledger. Read-only, 0 credits.")
+        .description("Show this workspace's actual native egress mode, active IP, health counts, dedicated add-on, and one bounded page of the inspectable mailbox policy ledger. Native Gmail/Microsoft sends, reply reads and token refreshes use the active IP; Zapmail-connected (Zapbox) mailboxes send through Zapmail and never use it. Read-only, 0 credits.")
         .option("--assignment-offset <number>", "Continue the policy ledger from open_assignments_next_offset.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -10340,15 +11106,15 @@ Examples:
         await handleAsyncAction("egress status", options, () => requestOxygen(`/api/cli/egress${query}`));
     }))
         .addCommand(new Command("ips")
-        .description("List the shared native worker IP and this workspace's dedicated IP history. Read-only, 0 credits.")
+        .description("List the shared native worker IP (it carries the sends, reply reads and token refreshes of every workspace without a dedicated IP) and this workspace's dedicated IP history. Read-only, 0 credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("egress ips", options, () => requestOxygen("/api/cli/egress?view=ips"));
     }))
         .addCommand(new Command("dedicated")
-        .description("Dedicated native egress add-on (25,000 credits per 30-day period): workspace tenant isolation and account safety, not a deliverability or inbox-placement lever. Preview the quote, order with `request --approved`, cancel with `cancel --approve`, or check status.")
+        .description("Dedicated native egress add-on (2,500 credits per 30-day period): one static IP only this workspace uses, which IT can allowlist; workspace tenant isolation and account safety, not a deliverability or inbox-placement lever. Preview the quote, order with `request --approved`, cancel with `cancel --approve`, or check status.")
         .addCommand(new Command("request")
-        .description("Preview the dedicated native egress add-on (25,000 credits per 30-day period, $25 face value). With --approved, ORDER it: OXYGEN provisions one isolated send drain plus one static egress IP for the workspace, debits the first period immediately, and debits the next 30 days later — not on the 1st. Every current inbox is assigned to that IP, every future inbox joins it automatically, and after the guarded handoff every workspace send routes through the dedicated drain; the Google/Microsoft relay IP recipients see does not change. This is workspace tenant isolation and account safety, not a deliverability or inbox-placement lever. Without --approved nothing is ordered or charged. While native provisioning is unavailable, ordering fails closed and the preview says so.")
+        .description("Preview the dedicated native egress add-on (2,500 credits per 30-day period, $25 face value). With --approved, ORDER it: OXYGEN provisions one isolated send drain plus one static egress IP for the workspace, debits the first period immediately, and debits the next 30 days later — not on the 1st. Every current inbox is assigned to that IP, every future inbox joins it automatically, and after the guarded handoff every send, reply read and token refresh for the workspace's mailboxes uses that one IP, so IT can allowlist it in Microsoft Conditional Access or Google context-aware access. Recipients of Gmail API and Microsoft Graph sends still see Google/Microsoft relay IPs; a Microsoft mailbox on the SMTP transport may show the sending IP, shared or dedicated, in its headers. This is workspace tenant isolation and account safety, not a deliverability or inbox-placement lever. Without --approved nothing is ordered or charged. While native provisioning is unavailable, ordering fails closed and the preview says so.")
         // --approved (not --approve): the credit-spending approval flag,
         // which is also what derives spends_credits in the self-index.
         .option("--approved", "Execute the order (a real recurring credit charge). Omit for a no-side-effect preview.")
@@ -11173,12 +11939,12 @@ Examples:
     }));
     program
         .command("copilot")
-        .description("Workspace Copilot: an attended workspace agent you drive turn by turn from the terminal. Start a session, send it messages and watch the reply stream, approve the actions it proposes, then cancel when done. Inference bills credits at 5x the actual model cost and is bounded by a 30,000-credit internal platform safety backstop; paid or external actions keep their own approval gates. Web: /copilot.")
+        .description("Workspace Copilot: an attended workspace agent you drive turn by turn from the terminal. Start a session, send it messages and watch the reply stream, approve the actions it proposes, then cancel when done. Inference bills credits at 5x the actual model cost and is bounded by a 3,000-credit internal platform safety backstop; paid or external actions keep their own approval gates. Web: /copilot.")
         .addCommand(new Command("start")
-        .description("Start an attended Workspace Copilot session. Starting is free; the next send starts inference. No inference budget is required; inference bills at 5x actual model cost under a 30,000-credit internal platform safety backstop. Legacy budget flags remain accepted for older clients but do not authorize or cap spend. Paid or external actions require separate approval.")
+        .description("Start an attended Workspace Copilot session on Oxygen Auto — Oxygen picks the model, keeps one conversation on one model, and runs its own errands on a cheaper one. Starting is free; the next send starts inference. No inference budget is required; inference bills at 5x actual model cost under a 3,000-credit internal platform safety backstop. Legacy budget and tier flags remain accepted for older clients but do not authorize or cap spend. Paid or external actions require separate approval.")
         .option("--budget-credits <number>", "Legacy compatibility only: accepted and clamped, but does not authorize or cap attended Copilot inference.")
-        .option("--tier <low|medium|high>", "Reasoning effort tier for the session's model.")
-        .option("--model <id>", "Pin a specific model id instead of the journey/tier default.")
+        .option("--tier <auto|low|medium|high>", "Legacy. Sessions run on Oxygen Auto; Oxygen picks the model. The three older tiers are still accepted so existing scripts keep working.")
+        .option("--model <id>", "Pin a specific priced model id instead of letting Oxygen choose.")
         .option("--per-turn-ceiling <number>", "Legacy compatibility only: accepted and clamped, but does not cap an attended turn.")
         .option("--journey <slug>", "Optional journey slug to seed the session's goal and context.")
         .option("--title <text>", "Optional human title for the session.")
@@ -11617,7 +12383,7 @@ Examples:
         .description("The priced catalog: every provider operation and every OXYGEN column (enrichment bundles, waterfalls, templates, Functions) with its credit cost per row. Start with `tools search --for-table <table>` to see what a table's own columns can be enriched with and what each costs, before adding anything.")
         .addCommand(new Command("search")
         .description("Search the priced catalog (0 credits): provider operations in `tools`, and OXYGEN's own columns in `native_columns` (enrichment bundles, waterfalls, templates, Functions), each with `price_label`, `estimated_credits_per_row`, `pricing_kind` and the exact `cli_add` command. With --for-table <table> it reads that table's columns and returns `suggestions`: the enrichments those columns already support, priced per row. Hydrate one provider operation with tools get. A response listing partial_sources means an optional catalog source timed out and totals may be understated — rerun for the complete catalog.")
-        .argument("[query]", "Search text.")
+        .argument("[query]", "Search text, e.g. `web` for the Web search column and its modes (each priced in `modes`), or `email`.")
         .option("--verbosity <verbosity>", "minimal, summary, or full. Defaults to minimal; hydrate one result with tools get.")
         .option("--terse", "Alias for --verbosity minimal.")
         .option("--all", "Return the complete matching catalog — with no query that is every provider operation (7,000+ rows). Explicit because the default is bounded to 10; with --for-table the table-scoped answer is `suggestions`, which --all does not change.")
@@ -11629,7 +12395,7 @@ Examples:
         .option("--provider <provider>", "Filter to one exact provider id, such as blitzapi.")
         .option("--limit <n>", "Maximum number of tools to return. Capped at 100.")
         .option("--providers", "Also return a per-vendor summary (provider id, display name, tool count) alongside the tools.")
-        .option("--for-table <table>", "Table id or slug. Prices Oxygen's own column kinds, presets and waterfalls (native_columns) for that table's columns and lists deterministic suggestions first — what you can enrich here and what each costs per row, before adding anything. `suggestions` (cross-referenced into native_columns) is the table-scoped answer; `tools` stays the general provider catalog, so leave --all off unless you want every provider operation.")
+        .option("--for-table <table>", "Table id or slug. Prices Oxygen's own column kinds, presets and waterfalls (native_columns) for that table's columns and lists deterministic suggestions first — what you can enrich here and what each costs per row, before adding anything. The envelope opens with `suggested` (each entry's price and exact add command), then `native_columns`; `tools` comes last and lists only provider operations a column can run, so leave --all off unless you want every one of them.")
         .option("--favorites", "Only the catalog entries you favourited for this workspace (see tools favorite).")
         .option("--table-runnable", "Only tools a table column can run.")
         .option("--json", "Print a JSON envelope.")
@@ -12236,6 +13002,7 @@ Examples:
         .option("--account-id <id>", "Provider account id for integrations that span multiple accounts (e.g. Cloudflare when the token can access more than one account).")
         .option("--country <code>", "ISO 3166-1 alpha-2 country where the LinkedIn account owner normally signs in (required for `connect linkedin`; picks the egress proxy).")
         .option("--pairing-phone-number <e164>", "WhatsApp only: pair by code sent to this E.164 number instead of showing a QR.")
+        .option("--acknowledge-risk", "LinkedIn only, required for a new account: LinkedIn restricts automated activity; pacing reduces but does not remove the risk.")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, options) => {
         await handleAsyncAction("integrations connect", options, () => {
@@ -12253,6 +13020,7 @@ Examples:
                     ...(accountId ? { account_id: accountId } : {}),
                     ...(country ? { country } : {}),
                     ...(pairingPhoneNumber ? { pairing_phone_number: pairingPhoneNumber } : {}),
+                    ...(options.acknowledgeRisk ? { acknowledge_linkedin_risk: true } : {}),
                 },
             });
         });
@@ -12353,7 +13121,7 @@ Examples:
     program.addCommand(new Command("senders")
         .description("Manage the org's connected LinkedIn sender accounts for Sequencer: list, connect, sync, get details, disconnect, and tune rate limits. This group is LinkedIn/WhatsApp accounts only; the cross-channel identity (one person's name and photo) that owns inboxes as well is `oxygen senders profiles`.")
         .addCommand(new Command("list")
-        .description("List connected LinkedIn sender accounts with health status, rate limits, and today's usage.")
+        .description("List connected LinkedIn sender accounts with health status, rate limits, and today's usage. Disconnected accounts are hidden unless you pass --status disconnected.")
         .option("--status <status>", "Filter by sender status: active, paused, disconnected, restricted, or credentials_required.")
         .option("--no-usage", "Skip today's per-account usage counts for a faster, lighter response.")
         .option("--tag <tags>", "Comma-separated workspace tags — matches sender accounts carrying ANY of these tags (see `oxygen tags list`).")
@@ -12380,7 +13148,7 @@ Examples:
         await handleAsyncAction("senders checkpoints", options, () => requestOxygen("/api/cli/senders/checkpoints"));
     }))
         .addCommand(new Command("connect")
-        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Each connected LinkedIn account occupies one LinkedIn sending seat — $30/month, billed in dollars on the billing owner's seat subscription — unless the billing owner still has grandfathered LinkedIn capacity; check `oxygen billing seats --json` before connecting, and a workspace linked to another organization's plan draws on that organization's seats. New accounts require --country (the owner's normal LinkedIn login country) and default to syncing only conversations OXYGEN starts; use --inbox-scope all to opt into the full LinkedIn inbox. Use --cookie-auth and --custom-proxy to expose those inputs inside Unipile's hosted wizard; their secrets never pass through OXYGEN. Use --count for bulk onboarding. Links are shareable and valid for 10 minutes.")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Each connected LinkedIn account occupies one LinkedIn sending seat — $30/month, billed in dollars on the billing owner's seat subscription — unless the billing owner still has grandfathered LinkedIn capacity; check `oxygen billing seats --json` before connecting, and a workspace linked to another organization's plan draws on that organization's seats. New accounts require --country (the owner's normal LinkedIn login country) and default to syncing only conversations OXYGEN starts; use --inbox-scope all to opt into the full LinkedIn inbox. Use --cookie-auth and --custom-proxy to expose those inputs inside Unipile's hosted wizard; their secrets never pass through OXYGEN. Use --count for bulk onboarding. LinkedIn restricts automated activity: every connection needs --acknowledge-risk (only a reconnect that already recorded one is exempt), and --count above 1 also needs --owner-consent (each owner connects their own account). Links are shareable and valid for 10 minutes.")
         .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
         .option("--country <code>", "Required for new accounts: ISO 3166-1 alpha-2 code for the account owner's normal LinkedIn login country (for example DE or US).")
         .option("--sales-nav", "Request Classic + Sales Navigator access during Unipile hosted authentication.")
@@ -12388,6 +13156,9 @@ Examples:
         .option("--custom-proxy", "Let the account owner enter a custom proxy in Unipile's hosted wizard. OXYGEN never receives the proxy credentials.")
         .option("--count <n>", "Mint N hosted-auth links in one call for bulk onboarding (1-25, default 1). Every link uses the same --country; use separate calls for different login countries. Ignored when reconnecting.")
         .option("--inbox-scope <scope>", "LinkedIn inbox privacy for new accounts: oxygen_initiated (default) or all. Reconnect preserves the existing account setting.")
+        .option("--acknowledge-risk", "Required for a new account: LinkedIn restricts automated activity; pacing reduces but does not remove the risk of a restriction.")
+        .option("--owner-consent", "Required with --count above 1: each account owner connects their own account.")
+        .option("--established", "The account is an established profile: skip the ~2-week warm-up a new account gets by default.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("senders connect", options, () => {
@@ -12405,6 +13176,9 @@ Examples:
                     ...(options.customProxy ? { custom_proxy: true } : {}),
                     ...(count ? { count } : {}),
                     ...(inboxScope ? { inbox_sync_scope: inboxScope } : {}),
+                    ...(options.acknowledgeRisk ? { acknowledge_linkedin_risk: true } : {}),
+                    ...(options.ownerConsent ? { owner_consent: true } : {}),
+                    ...(options.established ? { established: true } : {}),
                 },
             });
         });
@@ -12487,7 +13261,7 @@ Examples:
         });
     }))
         .addCommand(new Command("disconnect")
-        .description("Disconnect a LinkedIn sender account so it stops sending. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .description("Disconnect a LinkedIn sender account so it stops sending and frees its sending seat for another account. Works on an account that is already disconnected. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
@@ -12529,7 +13303,7 @@ Examples:
         await handleAsyncAction("senders limits get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
     }))
         .addCommand(new Command("set")
-        .description("Adjust per-account daily action limits and the daily-reset timezone. Values are clamped to safe maximums (30 invites/day and 40 messages/day). Send windows (time of day) are set per sequence in the campaign schedule, not per account. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .description("Adjust per-account daily action limits and the daily-reset timezone. Defaults: 20 invites/day, 100 invites/week, 40 messages/day, 5 comments/day. Values are clamped to hard maximums (30 invites/day, 150 invites/week, 40 messages/day, 20 comments/day, 300 human Unibox sends/hour); higher caps raise the risk of a LinkedIn restriction. Daily send caps run at half on Saturday and Sunday in the account's timezone unless --weekend-full-volume is set. Send windows (time of day) are set per sequence in the campaign schedule, not per account. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--invites-per-day <n>", "Daily LinkedIn connection invites cap.")
         .option("--invites-per-week <n>", "Weekly LinkedIn connection invites cap.")
@@ -12551,13 +13325,17 @@ Examples:
         .option("--interactive-min-spacing-seconds <n>", "Minimum seconds between human-sent Unibox actions.")
         .option("--interactive-spacing-jitter-seconds <n>", "Random jitter seconds added to human-sent Unibox action spacing.")
         .option("--interactive-sends-per-hour <n>", "Hourly cap on human-sent Unibox actions.")
-        .option("--timezone <tz>", "IANA timezone the daily action counters reset in, e.g. America/New_York.")
+        .option("--timezone <tz>", "IANA timezone the daily action counters reset in, e.g. Europe/Berlin. Defaults to the zone of the country chosen at connect.")
         .option("--warmup-restart", "Start (or restart) the warm-up ramp now — gradually raises this account's invite + message caps to full over ~2 weeks.")
         .option("--warmup-disable", "Turn off warm-up for this account (treat it as already warm and use its full configured caps).")
+        .option("--read-warmup-disable", "Turn off the READ warm-up ramp for this account. Network capture (`oxygen linkedin network setup`) eases a newly armed account in at 5 \u2192 10 \u2192 20 reads a day over two weeks; this runs it at the full read budget immediately. Separate from --warmup-disable, which governs invites and messages.")
+        .option("--read-warmup-restart", "Restart the READ warm-up ramp from today, so network capture eases back in from 5 reads a day. Also clears --read-warmup-disable.")
         .option("--warmup-start-date <date>", "Set the warm-up start date (ISO, e.g. 2026-01-31). A past date credits prior warming and advances the ramp.")
         .option("--warmup-preset <preset>", "Warm-up ramp curve: conservative (~3 weeks), standard (~2 weeks, default), or fast (~1 week for an aged account).")
-        .option("--randomize-caps", "Randomise this account's daily send caps to 80-100% of configured so volume looks human day to day.")
+        .option("--randomize-caps", "Randomise this account's daily send caps to 80-100% of configured so daily volume varies instead of hitting the same cap every day.")
         .option("--no-randomize-caps", "Turn off randomised daily caps (use the exact configured caps every day).")
+        .option("--weekend-full-volume", "Keep full daily send caps on Saturday and Sunday (by default they run at half).")
+        .option("--no-weekend-full-volume", "Run daily send caps at half on Saturday and Sunday again (the default).")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders limits set", options, () => {
@@ -12770,7 +13548,7 @@ Examples:
         });
     })));
     program.addCommand(new Command("followers")
-        .description("Read a LinkedIn account's followers into a Clay-like workspace table you can enrich, qualify, and enroll from. Imports run as a slow, durable background drip under a dedicated conservative read budget — they never burst and never starve the sequencer's own reads.")
+        .description("Read the followers of YOUR OWN connected LinkedIn account into a Clay-like workspace table you can enrich, qualify, and enroll from. Imports run as a slow, durable background drip under a dedicated conservative read budget — they never burst and never starve the sequencer's own reads. For the followers of a company page — a competitor's audience — use `oxygen tables followers check` instead.")
         .addCommand(new Command("import")
         .description("Start (or re-arm) a followers import. Followers drip into a workspace table + the deduped mirror over many ticks; poll `followers status` to watch them accrue. The import keeps itself fresh by periodically re-walking followers in the background (new followers dedupe in). No messages are sent and no Oxygen credits are charged.")
         .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id). Omit to import every active LinkedIn account.")
@@ -12804,11 +13582,13 @@ Examples:
         });
     })));
     program.addCommand(new Command("viewers")
-        .description("Read the named LinkedIn 'who viewed my profile' (WVMP) viewers into a Clay-like workspace table. Imports run as a slow, durable background drip under a dedicated conservative read budget. LinkedIn hides anonymous/private viewers, so the table is always a partial sample.")
+        .description("Read the named LinkedIn 'who viewed my profile' (WVMP) viewers into a Clay-like workspace table that leads with each person's photo, name and `viewed_account` (\"Viewed profile of\": every one of your connected accounts that person viewed). `import` arms (or resumes) a slow, durable background drip per account under a dedicated conservative read budget; `pause` switches an account off without touching rows or the table; `enrichment` switches standing paid full-profile enrichment of new viewers on/off. LinkedIn hides anonymous/private viewers, so the table is always a partial sample. `status` reports two counts with two denominators: `viewers_count` is named viewers captured from LinkedIn into the per-account mirror (a person who viewed two of your accounts counts twice) and `table_row_count` is rows in the table, one per viewer — they are not the same number and neither is a page or read counter.")
         .addCommand(new Command("import")
-        .description("Start (or re-arm) a durable profile-viewers (WVMP) import. Named viewers drip into a workspace table + the deduped mirror (view_count / last_viewed_at accumulate) over many ticks; poll `viewers status` to watch them accrue. No messages are sent and no Oxygen credits are charged.")
-        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id). Omit to import every active LinkedIn account.")
+        .description("Start (or re-arm, or resume a paused account) a durable profile-viewers (WVMP) import. Named viewers drip into a workspace table (one row per viewer, upserted on provider_id) from the deduped per-account mirror over many ticks; poll `viewers status` to watch them accrue. Two columns are coarser than they look: `view_count` counts the capture walks a viewer re-appeared in (about one every 6 hours), not profile views, and `last_viewed_at` is approximate — LinkedIn only reports 'Viewed 3w ago'-style recency, stored as the earliest day it can mean. Do not run this for an account whose viewers already land through a LinkedIn capture feed (`viewers status` says `landing_via: feed`): it would arm a second writer into a different table. The import itself sends no messages and charges no Oxygen credits; `--enrich`/`--no-enrich` switch standing per-viewer paid enrichment on or off in the same call (omit to leave it as-is) — see `viewers enrichment`.")
+        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id); also switches a paused account back on. Omit to import every active LinkedIn account.")
         .option("--table <ref>", "Existing workspace table (id or slug) to import into. Omit to create or reuse a 'LinkedIn Profile Viewers' table.")
+        .option("--enrich", "Also switch on standing full-profile enrichment for new viewers (see `viewers enrichment`). Omit to leave enrichment as-is.")
+        .option("--no-enrich", "Also switch off standing full-profile enrichment. Omit to leave enrichment as-is.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("viewers import", options, () => {
@@ -12819,12 +13599,13 @@ Examples:
                 body: {
                     ...(account ? { account } : {}),
                     ...(table ? { table } : {}),
+                    ...(options.enrich === undefined ? {} : { enrich: options.enrich }),
                 },
             });
         });
     }))
         .addCommand(new Command("status")
-        .description("Show durable profile-viewers (WVMP) import progress (per-sender drip status, viewers ingested, last error, the preserved privacy ceiling note) plus a preview of the viewers table and a deep-link to open it.")
+        .description("Show durable profile-viewers (WVMP) import progress: `accounts[]` lists every connected LinkedIn account with its display_name, headline, picture_url, per-account `on` (true when switched on, whatever its health) and state (off|collecting|waiting|paused|attention) with state_note, last_read_at/next_read_at, and whether it is toggleable — plus a preview of the viewers table, `enrichment` (on, credits_per_person, columns — see `viewers enrichment`) and a deep-link to open it. Read job/org `health` before `last_error`, worst state wins: `landing` — every import lands somewhere (its own table, or the LinkedIn capture feed named in `landing_via`/`jobs[].landing`) and is due; `waiting` — it lands, but the last tick parked on the account's daily read quota until `next_tick_at` (a wait, not a fault); `paused` — an account was switched off with `viewers pause`; `viewers import --account <ref>` switches it back on; `stalled` — the landing feed is stopped or paused, or the import spent its retries; `health_note` carries the exact repair (`oxygen feeds resume <id>` or `viewers import`); `unbound` — armed with no table and no feed, reading LinkedIn every tick and writing nothing, without ever recording an error (repair: `viewers import`); `none` — nothing armed. Two counts, two denominators: `viewers_count` is named viewers captured from LinkedIn into the per-account mirror (`viewers_count_scope` says workspace or one account; a person who viewed two of your accounts counts twice), `table_row_count` is rows in the table (one per viewer). They diverge while landing lags capture.")
         .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -12836,9 +13617,38 @@ Examples:
             const suffix = params.toString();
             return requestOxygen(`/api/cli/linkedin/viewers/status${suffix ? `?${suffix}` : ""}`);
         });
+    }))
+        .addCommand(new Command("pause")
+        .description("Switch the profile-viewers import off for one account or all: rows and the table stay exactly as they are, and `viewers import --account <ref>` switches it back on. Imports landed by a LinkedIn capture feed are not touched here — pause the feed instead with `oxygen feeds pause <id>`. Free.")
+        .option("--account <ref>", "Sender account to pause (sender id, connection id, or Unipile account id). Omit to pause every account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/viewers/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("enrichment")
+        .description("Turn automatic full-profile enrichment of NEW profile viewers on or off for the viewers table (" + MANAGED_DATA_SUPPLIERS.scraper + " profile: about, current role and company, experience, education, location). This is STANDING credit spend, charged credits_per_person credits per enriched viewer, applied only to viewers first seen after `enrichment.enabled_at`, each delivery bounded by `enrichment.max_credits_per_delivery` (the plan default). Switching on adds the table's Person profile columns (a paid lookup plus its extractors); they stay, with their data, when switched off. Existing rows are never charged by it — enrich them on demand by running the Person profile column. `viewers status` shows `enrichment` (on, credits_per_person, enabled_at, max_credits_per_delivery, next_capture_at: when new viewers can next arrive); the runs appear on the table's Runs page. Requires exactly one of --on or --off.")
+        .option("--on", "Switch standing enrichment on for new viewers.")
+        .option("--off", "Switch standing enrichment off.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers enrichment", options, () => {
+            if (options.on === options.off) {
+                throw new Error("Pass exactly one of --on or --off.");
+            }
+            return requestOxygen("/api/cli/linkedin/viewers/enrichment", {
+                method: "POST",
+                body: { enabled: options.on === true },
+            });
+        });
     })));
     program.addCommand(new Command("posts")
-        .description("Read and publish LinkedIn posts through a connected account. `get`, `comments`, and `reactions` are LIVE provider reads: they use 0 Oxygen credits but consume the sender's daily account-read allowance. Do not use them when a task forbids provider calls; use `publishing comments list` for the local Community queue, which discovers recent posts owned by connected accounts in the background. `create` publishes a real post (approval-gated). The direct commands here address ONE post you already have an id for; aggregate analytics still cover posts Oxygen itself published (`oxygen publishing ...`).")
+        .description("Read and publish LinkedIn posts through a connected account. `get`, `comments`, and `reactions` are LIVE provider reads: they use 0 Oxygen credits but consume the sender's daily account-read allowance. Do not use them when a task forbids provider calls; use `publishing comments list` for the local Community queue, which discovers recent posts owned by connected accounts in the background. `create` publishes a real post (approval-gated). The direct commands here address ONE post you already have an id for; aggregate analytics are `oxygen publishing analytics` (LinkedIn includes owned posts discovered from the provider).")
         .addCommand(new Command("get")
         .description("LIVE provider read of one LinkedIn post. Uses 0 Oxygen credits but consumes the sender's metered account-read allowance; do not run it when the task forbids provider calls. Returns the post and its composite social_id (reuse that social_id for `posts comments`, `posts reactions`, and `engagement harvest --source unipile` — NOT the raw activity URN). This does not populate or refresh the durable `publishing comments` queue.")
         .requiredOption("--post <id>", "Numeric activity id, activity URL, or composite social_id. For a direct live read, take the id from the post's LinkedIn URL or a scheduled post (`oxygen publishing posts get <post_id>` → provider_post_id); Community discovers recent owned posts separately in the background.")
@@ -12939,7 +13749,7 @@ Examples:
         });
     })));
     program.addCommand(new Command("engagement")
-        .description("Capture LinkedIn intent from one known post (harvest needs its public URL or the composite social_id from `oxygen posts get`), and react or comment on it. Recurring capture — a post's engagers on a cadence, 'who viewed my profile', new followers, new connections — is a live table: arm it with `oxygen linkedin intent setup` and operate it with `oxygen feeds list|pause|resume|run`. For daily monitoring across profiles and their recent post engagers, start with `oxygen tables watcher preview --help` (free credit review; one editable table). Harvests run as a slow, durable drip under a conservative read budget.")
+        .description("Capture LinkedIn intent from one known post (harvest needs its public URL or the composite social_id from `oxygen posts get`), and react or comment on it. Recurring capture — a post's engagers on a cadence, 'who viewed my profile', new followers, new connections — is a live table: arm it with `oxygen linkedin intent setup` and operate it with `oxygen feeds list|pause|resume|run`. For daily monitoring across profiles and their recent post engagers, start with `oxygen tables watcher preview --help` (free credit review; one editable table). Harvests run as a slow, durable drip under a conservative read budget. To have teammates react to or comment on the workspace's own posts, use `oxygen publishing amplification --help`.")
         .addCommand(new Command("engagers")
         .description("Read one post's reactors and commenters right now as a de-duplicated people list ready to enroll. Pages both sources up to --max-pages (default 5, max 20) x 100 per page; `truncated: true` in the envelope means a cap stopped a source that still had more — raise --max-pages, or use `oxygen engagement harvest` for a post too big to read in one request. Nothing is sent and no credits are spent, but every page is one LinkedIn read against the sender account. --post is the composite social_id from `oxygen posts get` (NOT the activity URN).")
         .requiredOption("--post <social_id>", "Composite post social_id from `oxygen posts get` (NOT the activity URN).")
@@ -13093,7 +13903,46 @@ Examples:
         });
     })));
     program.addCommand(new Command("linkedin")
-        .description("LinkedIn read-into-workspace ingestion controls (Goal-3): the unified status of the connections / engagement / message-history drips and each account's remaining ingest read budget.")
+        .description("Put your own LinkedIn network in a table and keep it current. `linkedin network setup` captures everyone you are connected to and everyone who follows you into one self-refreshing 'LinkedIn Network' table (free, read-only on your account, paced so the account is never at risk); `linkedin network status` reports the pace and `linkedin network pause` switches it off. `linkedin invitations setup` does the same for open connection requests — received and sent — in one self-updating table. Also home to `linkedin intent` (engagement capture) and `linkedin ingestion status` (every LinkedIn read drip and each account's remaining read budget).")
+        .addCommand(new Command("network")
+        .description("Capture everyone already in your LinkedIn network \u2014 the people you are connected to and the people who follow you \u2014 into one self-refreshing workspace table you can filter, enrich and enroll from. READ-ONLY on your LinkedIn account: it lists your own connections and followers and nothing else. It sends no messages, no connection requests, and does not visit anyone's profile. Runs as a slow background drip on its OWN per-account read budget, so it cannot slow down or starve anything else the account does: about 2,000 people a day while it first walks your network (40 reads of up to 50 people), then a light check a few times a day for new arrivals. Only inside each account's own 07:00-22:00 working hours, spaced minutes apart, never in a burst; a newly armed account eases in over its first two weeks. LinkedIn does not say how big a network is until the walk has been through it, so a large network takes days \u2014 `status` reports the rate, not a completion date it cannot know. Free \u2014 no Oxygen credits; it uses the LinkedIn seat you already pay for.")
+        .addCommand(new Command("setup")
+        .description("Arm (or re-arm) network capture. Creates or reuses one merged 'LinkedIn Network' table and starts a connections drip and a followers drip per account, both writing into that one table deduped on LinkedIn member id \u2014 somebody who is both shows as 'both' in the Relationship column. This is a STANDING permission: capture keeps running until you switch it off with `linkedin network pause`, and a LinkedIn account you connect later is armed automatically. A newly connected account eases into full read speed over its first two weeks. Nothing is sent and no credits are charged. The response names each account it armed (`senders[].display_name`) \u2014 check it is yours before leaving it running.")
+        .option("--account <ref>", "Account to capture (sender id, connection id, or Unipile account id). Omit to capture every connected LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to capture into. Omit to create or reuse 'LinkedIn Network'.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network setup", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/tables/linkedin-network", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show network capture progress: `accounts[]` lists every connected LinkedIn account with its headline, `on` (switched on or not), and state (off|collecting|waiting|paused|attention); which accounts are armed, what each one may actually read TODAY after its warm-up ramp (`reads_per_day_now` / `people_per_day_now`), and per-drip state \u2014 including whether each half is still doing its first full walk ('backfill') or has switched to the light check ('delta'). `pace` states the rate in people per day and says plainly that no completion date exists until the first walk finishes, rather than inventing one. Also previews the table and deep-links to it. A capture sitting in 'backfill' for days is working as designed, not stuck.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network status", options, () => requestOxygen("/api/cli/tables/linkedin-network"));
+    }))
+        .addCommand(new Command("pause")
+        .description("Switch network capture off: the worker stops reading that account's connections and followers until you run `linkedin network setup` again. Pass --account to pause one account (the one you armed by mistake, say); omit it to pause every armed account. The table and its rows stay exactly as they are, and re-arming continues the walk where it stopped rather than starting over. A standalone `connections import` or `followers import` is not touched. Free.")
+        .option("--account <ref>", "Account to pause (sender id, connection id, or Unipile account id). Omit to pause every armed LinkedIn account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/tables/linkedin-network/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    })))
         .addCommand(new Command("intent")
         .description("Capture organic LinkedIn intent in durable OXYGEN Workflows + linked Tables. People are deduped; every reaction, comment, weekly profile view, new follower, and new connection is retained as a touchpoint. Engagement does not create CRM leads.")
         .addCommand(new Command("setup")
@@ -13189,7 +14038,44 @@ Examples:
         });
     })))
         .addCommand(new Command("invitations")
-        .description("List and withdraw the pending LinkedIn connection invitations a sender account has sent.")
+        .description("Open LinkedIn connection requests on your own accounts. `setup` keeps one self-updating 'LinkedIn Open Connection Requests' table of every pending request — people who asked to connect with you (received) and requests you sent (sent) — and marks each one accepted or no_longer_pending when it disappears; `status` and `pause` manage it. `list` and `withdraw` act on the sent requests directly.")
+        .addCommand(new Command("setup")
+        .description("Switch on the open connection requests table. Creates or reuses one 'LinkedIn Open Connection Requests' table and checks each chosen account about twice a day, inside that account's working hours: every pending request, received and sent, is a row with the person, the account it is on (`account`), its `direction` and its `status`. A request that disappears is marked `accepted` when the person is now a connection, otherwise `no_longer_pending` (LinkedIn does not say whether it was declined, withdrawn or expired); acceptances seen live are marked within minutes. READ-ONLY on LinkedIn: nothing is accepted, declined, withdrawn or sent. Free — no Oxygen credits; the reads count against each account's daily LinkedIn read budget. Accounts connected later stay off until you switch them on.")
+        .option("--account <ref>", "Account to switch on (sender id, connection id, or Unipile account id). Omit to switch on every connected LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to write into. Omit to create or reuse 'LinkedIn Open Connection Requests'.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations setup", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/tables/linkedin-open-invites", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show the open connection requests table: `accounts[]` lists every connected LinkedIn account with `on`, its state (off|collecting|waiting|paused|attention), and when it was last and will next be checked. Also previews the table and deep-links to it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations status", options, () => requestOxygen("/api/cli/tables/linkedin-open-invites"));
+    }))
+        .addCommand(new Command("pause")
+        .description("Stop checking open connection requests for one account (--account) or every account. The table and its rows stay; `linkedin invitations setup` switches it back on. Free.")
+        .option("--account <ref>", "Account to pause (sender id, connection id, or Unipile account id). Omit to pause every account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/tables/linkedin-open-invites/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    }))
         .addCommand(new Command("withdraw")
         .description("Withdraw pending sent LinkedIn invitations. A real external social action gated behind approval: prints the resolved target list by default and only withdraws when you pass --approved. Select targets with --ids (a comma-separated id list from `linkedin invitations list`) OR --older-than <days> (pending invites older than N days, among the 100 most recent sent) — not both. Idempotent: an invite that is already gone counts as withdrawn.")
         .option("--ids <a,b>", "Comma-separated invitation ids to withdraw (from `linkedin invitations list`).")
@@ -13214,7 +14100,7 @@ Examples:
         });
     }))
         .addCommand(new Command("list")
-        .description("List the account's pending sent LinkedIn invitations with their invitation ids — the ids `linkedin invitations withdraw --ids` cancels. Read-only: no provider write, no credits.")
+        .description("List the account's pending sent LinkedIn invitations with their invitation ids — the ids `linkedin invitations withdraw --ids` cancels. Read-only: no provider write, no credits. For received requests too, kept in a table that updates itself, use `linkedin invitations setup`.")
         .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
         .option("--limit <n>", "Maximum invitations to return.")
         .option("--json", "Print a JSON envelope.")
@@ -13234,7 +14120,7 @@ Examples:
     program.addCommand(new Command("whatsapp")
         .description("Manage the org's connected WhatsApp accounts for Sequencer: list, connect, sync, inspect, disconnect, tune daily limits, and warm-send into an existing conversation. Cold outbound runs through a WhatsApp sequence (sequences create --channels whatsapp).")
         .addCommand(new Command("accounts")
-        .description("List connected WhatsApp accounts with health status, warm-up ramp state, limits, and today's usage.")
+        .description("List connected WhatsApp accounts with health status, warm-up ramp state, limits, and today's usage. Disconnected accounts are hidden unless you pass --status disconnected.")
         .option("--status <status>", "Filter by account status: active, paused, disconnected, restricted, or credentials_required.")
         .option("--no-usage", "Skip today's per-account usage counts.")
         .option("--tag <tags>", "Comma-separated workspace tags — matches WhatsApp accounts carrying ANY of these tags (see `oxygen tags list`).")
@@ -13288,7 +14174,7 @@ Examples:
         });
     }))
         .addCommand(new Command("disconnect")
-        .description("Disconnect a WhatsApp account so it stops sending. <id> accepts an account id, connection id, or Unipile account id.")
+        .description("Disconnect a WhatsApp account so it stops sending and frees its sending seat for another account. Works on an account that is already disconnected. <id> accepts an account id, connection id, or Unipile account id.")
         .argument("<id>", "WhatsApp account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
@@ -13460,25 +14346,29 @@ Examples:
     program.addCommand(new Command("inbox")
         .description("Unified inbox (unibox): private email + LinkedIn DM + WhatsApp conversations in one stream (the default), or a single channel with --channel; `get` and `send` resolve a conversation's channel from its id. Public comments on owned LinkedIn posts are not inbox messages; use `publishing comments`. Scan, read threads, and reply.")
         .addCommand(new Command("list")
-        .description("List conversations newest first across email, LinkedIn, and WhatsApp — the merged stream is the default, --channels narrows it, and --channel email/linkedin/whatsapp lists a single channel. Primary excludes the negative tier (not_now, not_interested, lost, bounced); All includes every ordinary conversation.")
+        .description("List conversations newest first across email, LinkedIn, and WhatsApp — the merged stream is the default, --channels narrows it, and --channel email/linkedin/whatsapp lists a single channel. Primary excludes the negative tier (not_now, not_interested, lost, bounced); All includes every ordinary conversation. Background AI reply triage sets each conversation's status, so triage is a filter, not a script: `--status interested` is positive sales intent, `--status not_interested` is who said no, and `--unanswered` only means the last message is theirs. None of them means a thread needs a reply: interested includes thank-yous and booking confirmations, and neutral can hold real questions. A reply that just arrived can read neutral until it is analyzed (`inbox analyze <id>` classifies one now). In --json, `count` is the rows on this page (follow next_cursor for more); on email, `total_conversations` and the `sidebar_counts` facets are mailbox-wide and do not apply your filters, so never read them as the size of a filtered list.")
         .option("--channel <channel>", "Inbox channel: all (default, the merged stream), email, linkedin, or whatsapp.")
         .option("--channels <list>", "Narrow the merged stream: comma-separated channel groups to include (email,linkedin,whatsapp). Implies --channel all.")
         .option("--account <id>", "LinkedIn only: filter to one sender account (sender id, connection id, or Unipile account id).")
         .option("--unread", "Only show conversations with unread messages.")
-        .option("--unanswered", "Only conversations awaiting YOUR reply — the last message in the thread is inbound. Cross-channel. Off by default: an unfiltered list still shows answered threads. (The web Unibox turns this on by default for its Primary tab.) It includes inbound mail no campaign sent — unsolicited or spam — so for replies to your outreach add --sequence-id; the ids and per-campaign counts are in sidebar_counts.byCampaign of the same --json response.")
+        .option("--unanswered", "Only conversations you have not replied to — the last message in the thread is inbound. Not the same as needing a reply: it keeps thank-yous and automated mail. Cross-channel. Off by default: an unfiltered list still shows answered threads. (The web Unibox turns this on by default for its Primary tab.) It includes inbound mail no campaign sent — unsolicited or spam — so for replies to your outreach add --sequence-id; the ids and per-campaign counts are in sidebar_counts.byCampaign of the same --json response.")
+        // Hidden while the AI inbox triage is dev-only (ADR 0027): production
+        // help must not offer a flag its API refuses. Unhide with the flag's
+        // production rollout.
+        .addOption(new Option("--needs-reply", "Narrower than --unanswered: unanswered threads minus those AI inbox triage judged bulk (newsletters, notifications, mass pitches) or needing no answer. Threads not yet triaged stay in. Rows then carry `triage` in --json. Ignored while --search is set. Only where AI inbox triage is enabled; elsewhere the API answers needs_reply_unavailable.").hideHelp())
         .option("--responses-only", "Email only: only conversations with an inbound reply (never sent-only threads).")
         .option("--bucket <bucket>", "Email only: primary or others (superseded by --segment).")
         .option("--segment <segment>", "Top tab: primary (everything but the negative status tier), all, or an email-only folder (others, sent, warmup, dmarc).")
-        .option("--status <keys>", "Comma-separated status keys (e.g. interested,meeting_booked). Cross-channel — filters email + LinkedIn + WhatsApp by the shared taxonomy.")
+        .option("--status <keys>", "Comma-separated reply-status keys, set by AI reply triage. System keys: interested, neutral, out_of_office, wrong_person, not_now, not_interested, lost, bounced; your workspace's full list, custom labels included, is `inbox labels list`. Cross-channel — filters email + LinkedIn + WhatsApp by the shared taxonomy.")
         .option("--tag <tags>", "Comma-separated campaign tags — matches email conversations whose campaign (sequence) carries any of these tags. DMs have no campaign link, so a tag filter shows email only.")
         .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Cross-channel.")
         .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Cross-channel.")
-        .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — get the id from `sequences get <slug>`).")
+        .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — `sequences list` shows each campaign's id). Returns only conversations linked to that campaign; `sidebar_counts.byCampaign` is its size.")
         .option("--provider <providers>", "Email only: comma-separated providers (google,microsoft).")
         .option("--domain <domains>", "Email only: comma-separated counterpart domains to include.")
         .option("--exclude-domain <domains>", "Email only: comma-separated counterpart domains to exclude.")
         .option("--mailbox-id <ids>", "Email only: comma-separated mailbox ids.")
-        .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow.")
+        .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow. For structured filters use --status or --tag, not a text search.")
         .option("--include-archived", "Include archived conversations.")
         .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
         .option("--cursor <cursor>", "Merged stream only: the previous page's next_cursor — resumes after that row.")
@@ -13497,6 +14387,8 @@ Examples:
                 params.set("unread", "true");
             if (options.unanswered)
                 params.set("unanswered", "true");
+            if (options.needsReply)
+                params.set("needs_reply", "true");
             if (options.responsesOnly)
                 params.set("responses_only", "true");
             for (const [flag, key] of [
@@ -13578,6 +14470,18 @@ Examples:
                 },
             });
         });
+    }))
+        .addCommand(new Command("delete-message")
+        .description("Delete your sent LinkedIn message for everyone within 60 minutes. This cannot be undone. Omit --approved for a preview; show it before approving. Other channels and inbound messages are unsupported.")
+        .argument("<conversationId>", "Oxygen conversation id from inbox get.")
+        .argument("<messageId>", "Oxygen message id from inbox get.")
+        .option("--approved", "Approve permanent deletion of this exact message after reviewing the preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversationId, messageId, options) => {
+        await handleAsyncAction("inbox delete-message", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/delete`, {
+            method: "POST",
+            body: { approved: options.approved === true },
+        }));
     }))
         .addCommand(new Command("mark-read")
         .description("Mark a conversation and all its messages as read.")
@@ -13609,7 +14513,9 @@ Examples:
         .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Cross-channel.")
         .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow.")
         .option("--include-archived", "Also mark archived conversations read.")
-        .option("--unanswered", "Only sweep conversations awaiting your reply (the last message is inbound) — the same filter as `inbox list --unanswered`, so the scope is exactly that list.")
+        .option("--unanswered", "Only sweep conversations you have not replied to (the last message is inbound) — the same filter as `inbox list --unanswered`, so the scope is exactly that list.")
+        // Hidden with `inbox list --needs-reply`; see there.
+        .addOption(new Option("--needs-reply", "Only sweep the `inbox list --needs-reply` set (where AI inbox triage is enabled). Ignored while --search is set.").hideHelp())
         .option("--yes", "Apply the sweep. Without this flag, returns a preview of the unread count only.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -13646,6 +14552,8 @@ Examples:
             // the string-valued options.
             if (options.unanswered)
                 params.set("unanswered", "true");
+            if (options.needsReply)
+                params.set("needs_reply", "true");
             return requestOxygen(`/api/cli/inbox/read-all?${params.toString()}`, {
                 method: "POST",
                 // Approval rides in the body: a bodyless POST reads as
@@ -14359,6 +15267,7 @@ Examples:
         .option("--from <date>", "Custom start date (YYYY-MM-DD). Windows up to five years are accepted.")
         .option("--to <date>", "Custom end date (YYYY-MM-DD).")
         .option("--sequence <id-or-slug>", "Limit analytics to one sequence.")
+        .option("--sender <key>", "A sender from `oxygen senders list` or `oxygen senders profiles list`, or a key from this output's senders list. Repeatable.", collectRepeatable, [])
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleReadActionWithLens("sequences analytics", options, () => {
@@ -14367,6 +15276,7 @@ Examples:
             const from = readOption(options.from);
             const to = readOption(options.to);
             const sequence = readOption(options.sequence);
+            const senders = (options.sender ?? []).flatMap((value) => readCsvOption(value));
             if (range)
                 params.set("range", range);
             if (from)
@@ -14375,6 +15285,8 @@ Examples:
                 params.set("to", to);
             if (sequence)
                 params.set("sequence", sequence);
+            if (senders.length > 0)
+                params.set("senders", senders.join(","));
             const qs = params.toString();
             return requestOxygen(`/api/cli/sequences/analytics${qs ? `?${qs}` : ""}`);
         }, formatSequenceAnalyticsHealth);
@@ -15565,7 +16477,7 @@ Examples:
         });
     }))
         .addCommand(new Command("hubspot")
-        .description("Discover and synchronize HubSpot contact/company saved lists into the shared Oxygen DNC endpoint.")
+        .description("Discover and synchronize HubSpot contact/company saved lists into the shared Oxygen DNC endpoint. The same saved lists can be imported as table rows instead — see `oxygen tables hubspot import`, which syncs a do-not-contact list first and then lands the members in a new table.")
         .addCommand(new Command("lists")
         .description("List contact/company saved lists and readable identity properties. Reads definitions only; no memberships or writes.")
         .option("--query <text>", "Optional list-name search.")
@@ -16034,11 +16946,12 @@ Examples:
         await handleAsyncAction("mailboxes get", options, () => requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}`));
     }))
         .addCommand(new Command("delete")
-        .description("Preview or approve removal of exact mailboxes from Oxygen at 0 credits. Deletion immediately removes them from sending but never deletes the underlying Google Workspace or Microsoft 365 accounts. It preserves conversation/message/delivery history and stops any separately listed 100-credit connected-mailbox commitment for future renewals; that line is currently built but not charged, and it is not the 100-credit OXYGEN Warm-up subscription. The current period is not refunded. Listed active/paused sequences keep their status but lose these senders and are not automatically paused. Managed mailboxes and live warmup/monitoring add-ons fail closed with their exact address-scoped teardown steps.")
+        .description("Preview or approve removal of exact mailboxes from Oxygen at 0 credits. Deletion immediately removes them from sending but never deletes the underlying Google Workspace or Microsoft 365 accounts. It preserves conversation/message/delivery history and stops any separately listed 100-credit connected-mailbox commitment for future renewals; that line is currently built but not charged, and it is not the 100-credit OXYGEN Warm-up subscription. The current period is not refunded. Listed active/paused sequences keep their status but lose these senders and are not automatically paused. Without --cascade, a mailbox whose own warm-up or deliverability monitoring is still connected fails closed with its exact teardown steps; with --cascade, those add-ons are disconnected as part of the delete (their recurring credits stop too) and nothing is deleted unless every teardown is confirmed. A live managed DOMAIN subscription always fails closed, because it covers other mailboxes — manage it from its domain row.")
         .requiredOption("--mailboxes <list>", "Comma-separated mailbox ids or addresses (maximum 500).")
         .option("--approved", "Execute the fresh preview. Requires --plan-hash and --confirmation.")
         .option("--plan-hash <hash>", "Fresh preview plan_hash.")
         .option("--confirmation <phrase>", "Exact confirmation_phrase returned by the fresh preview.")
+        .option("--cascade", "Disconnect each mailbox's OWN warm-up and deliverability-monitoring add-ons as part of the delete, instead of failing closed until you tear them down by hand. Stops their recurring credits too. Pass it on the preview as well as the approval: the plan hash is bound to it, so an approval cannot turn it on. A live managed domain subscription still fails closed.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("mailboxes delete", options, () => {
@@ -16056,6 +16969,7 @@ Examples:
                 body: {
                     mailboxes,
                     ...(options.approved === true ? { approved: true } : {}),
+                    ...(options.cascade === true ? { cascade: true } : {}),
                     ...(planHash ? { plan_hash: planHash } : {}),
                     ...(confirmation ? { confirmation } : {}),
                 },
@@ -16721,6 +17635,21 @@ Examples:
                 },
             });
         });
+    }))
+        .addCommand(new Command("reactivate")
+        .description("Make the warm-up provider re-run the connection check it abandoned on an inbox it has DISABLED, without touching your credential, your subscription, or the ramp day. Use this when warmup status reports an inbox stopped by the provider and `warmup reconnect` refuses it — which is what happens to a Microsoft inbox connected by OAuth or tenant consent, because there is no password to re-push. 0 credits: the subscription, its renewal date, and the ramp day all stay exactly as they are, so it is the free alternative to disable + re-enable (which bills another warm-up month AND restarts the ramp at day 1). Only inboxes with a live warm-up subscription are eligible. IMPORTANT: this forces the provider to re-check; a forced pass is NOT proof the connection works. Confirm recovery from a rising send count with `oxygen mailboxes warmup status` after the provider's next batch, which is hours away, not minutes. Targets the whole pool unless --mailboxes is given.")
+        .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes warmup reactivate", options, () => {
+            const mailboxes = readCsvOption(options.mailboxes);
+            return requestOxygen("/api/cli/mailboxes/warmup/reactivate", {
+                method: "POST",
+                body: {
+                    ...(mailboxes.length > 0 ? { mailboxes } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("disable")
         .description("Disable warmup and unenroll each mailbox from the rail that actually enrolled it. On a managed rail — OXYGEN Warm-up today, TrulyInbox for older enrollments — this also cancels that mailbox's warmup subscription, so billing stops with the provider removal. This is how you wind an inbox off the retired TrulyInbox rail. NOT the way to fix a rotated app password — use `mailboxes warmup reconnect` for that, which costs 0 credits instead of a new 100-credit month. Targets the whole pool unless --mailboxes is given.")
@@ -19463,7 +20392,9 @@ function printColumnCatalog(result) {
     const data = isRecord(result) ? (isRecord(result.data) ? result.data : result) : null;
     const entries = data && Array.isArray(data.entries) ? data.entries.filter(isRecord) : [];
     const bundles = data && Array.isArray(data.bundles) ? data.bundles.filter(isRecord) : [];
-    if (entries.length === 0 && bundles.length === 0) {
+    // Native column kinds (Classify) are sent only by a server that runs them.
+    const native = data && Array.isArray(data.native) ? data.native.filter(isRecord) : [];
+    if (entries.length === 0 && bundles.length === 0 && native.length === 0) {
         process.stderr.write("No column templates match. No preset bundle matches either.\n"
             + "A template is one column (`columns add <table> --prompt-key <key>`); a bundle is a preset that creates several at once (`columns add <table> --preset <id>`).\n"
             + "Shorten --search, drop it, or pick a section: `columns catalog --category people`.\n");
@@ -19477,6 +20408,20 @@ function printColumnCatalog(result) {
         byFamily.set(family, bucket);
     }
     const lines = [];
+    for (const kind of native) {
+        const credits = isRecord(kind.credit_estimate) && typeof kind.credit_estimate.label === "string" ? kind.credit_estimate.label : "";
+        lines.push(`${String(kind.label)}  [native${credits ? ` · ${credits}` : ""}]`);
+        if (typeof kind.description === "string" && kind.description)
+            lines.push(`      ${kind.description}`);
+        for (const mode of Array.isArray(kind.modes) ? kind.modes.filter(isRecord) : []) {
+            if (typeof mode.add_command === "string")
+                lines.push(`      ${mode.add_command}`);
+        }
+        if (typeof kind.review_uncertain === "string" && kind.review_uncertain)
+            lines.push(`      ${kind.review_uncertain}`);
+    }
+    if (native.length > 0 && byFamily.size > 0)
+        lines.push("");
     for (const [family, bucket] of byFamily) {
         lines.push(`${family.replaceAll("_", " ")}:`);
         for (const entry of bucket) {
@@ -19559,8 +20504,21 @@ function applyAiColumnConfig(definition, options) {
         definition.structuredOutput = true;
     return definition;
 }
-const RESEARCH_ENGINES = new Set(["exa", "parallel", "firecrawl"]);
-const RESEARCH_FETCH_ENGINES = new Set(["firecrawl", "linkup", "exa"]);
+// Client-side mirror of the server's managed grounding rosters
+// (AI_WEB_SEARCH_ENGINES / AI_WEB_FETCH_ENGINES in @oxygen/tenant-db). Kept in
+// step by hand: if this set is wider than the server's, `--research-engine` takes
+// a value the server then rejects; if it is narrower, the CLI blocks an engine
+// that works. D52 took parallel and linkup to BYOK and moved firecrawl off the
+// search rail onto scraping only.
+//
+// Restored 2026-09-21: b152df38b (a Dashboards CLI change) rebased a 295-line
+// addition over a stale copy of this file and silently reverted both sets to the
+// pre-D52 values, so dev shipped a CLI that accepted `--research-engine parallel`
+// and let the server reject it. `research-engine-roster.test.ts` now asserts
+// these against the tenant-db unions so the next stale rebase fails the gate
+// instead of reaching a customer.
+const RESEARCH_ENGINES = new Set(["serper", "exa"]);
+const RESEARCH_FETCH_ENGINES = new Set(["firecrawl", "exa"]);
 const RESEARCH_MODES = new Set(["strict", "estimate"]);
 /**
  * Fold the `--research-*` flags into `definition.webSearch`.
@@ -19604,8 +20562,8 @@ function applyResearchColumnConfig(definition, options) {
         const allowed = researchUrl ? RESEARCH_FETCH_ENGINES : RESEARCH_ENGINES;
         if (!allowed.has(engine)) {
             throw new OxygenError("invalid_request", researchUrl
-                ? `--research-engine with --research-url must be firecrawl, linkup, or exa (got ${engine}).`
-                : `--research-engine must be exa, parallel, or firecrawl (got ${engine}).`, { exitCode: 1 });
+                ? `--research-engine with --research-url must be firecrawl or exa (got ${engine}).`
+                : `--research-engine must be serper or exa (got ${engine}).`, { exitCode: 1 });
         }
         webSearch.engine = engine;
     }
@@ -20523,8 +21481,14 @@ function readSignalsSearchRunBody(options, promptArg) {
     const promptSource = options.prompt ?? promptArg;
     const prompt = promptSource ? readFileIfPresent(promptSource) : null;
     const plan = options.planJson ? readSearchPlanJson(options.planJson) : null;
-    if (!prompt && !plan) {
-        throw new OxygenError("invalid_request", "Pass --prompt or --plan-json.", { exitCode: 1 });
+    // A post search needs no prompt: its --keywords and filters are the plan,
+    // as they are for the free preview (the server names the table after them).
+    const postSearchFilters = !prompt && !plan && readOption(options.family) === "linkedin_posts"
+        ? readSignalSearchFilters(options)
+        : null;
+    const postSearch = Array.isArray(postSearchFilters?.keywords) && postSearchFilters.keywords.length > 0;
+    if (!prompt && !plan && !postSearch) {
+        throw new OxygenError("invalid_request", "Pass --prompt or --plan-json (linkedin_posts needs only --keywords).", { exitCode: 1 });
     }
     if (prompt && !readOption(options.family)) {
         throw new OxygenError("invalid_request", "Pass --family when planning from --prompt.", { exitCode: 1 });
@@ -20535,8 +21499,15 @@ function readSignalsSearchRunBody(options, promptArg) {
     const maxCreditsPerCycle = readPositiveNumber(options.maxCreditsPerCycle);
     const maxRowsPerCycle = readPositiveInt(options.maxRowsPerCycle);
     // Filters describe a prompt that is being (re)planned. A saved plan already
-    // froze its own, so re-sending them would silently plan something else.
-    const filters = prompt ? readSignalSearchFilters(options) : null;
+    // froze its own, so they are never re-sent with one; typed alongside a saved
+    // plan they are refused, because dropping them would run live unfiltered. A
+    // prompt-less linkedin_posts search (no plan) is planned from its filters.
+    const typedFilters = readSignalSearchFilters(options);
+    if (plan && !prompt && typedFilters) {
+        throw new OxygenError("invalid_request", `A saved plan keeps the filters it was planned with, so ${Object.keys(typedFilters).join(", ")} cannot be added to --plan-json. `
+            + "Re-plan with oxygen signals search plan --prompt <goal> --family <family> and the filter flags, or pass them to signals search run --prompt.", { exitCode: 1 });
+    }
+    const filters = prompt ? typedFilters : postSearchFilters;
     return {
         ...(prompt ? { prompt } : {}),
         ...(plan ? { plan } : {}),
@@ -20557,6 +21528,7 @@ function readSignalsSearchRunBody(options, promptArg) {
         ...(readOption(options.every) ? { every: readOption(options.every) } : {}),
         ...(maxCreditsPerCycle !== undefined ? { max_credits_per_cycle: maxCreditsPerCycle } : {}),
         ...(maxRowsPerCycle !== undefined ? { max_rows_per_cycle: maxRowsPerCycle } : {}),
+        ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
     };
 }
 // SignalSearchFilters mirror (structural — the server validates every field and
@@ -20567,6 +21539,24 @@ function readSignalSearchFilters(options) {
     const keywords = readCsvOption(options.keywords);
     if (keywords.length > 0)
         filters.keywords = keywords;
+    const allKeywords = readCsvOption(options.allKeywords);
+    if (allKeywords.length > 0)
+        filters.all_keywords = allKeywords;
+    const excludeKeywords = readCsvOption(options.excludeKeywords);
+    if (excludeKeywords.length > 0)
+        filters.exclude_keywords = excludeKeywords;
+    const sort = readOption(options.sort);
+    if (sort)
+        filters.sort_by = sort;
+    const minReactions = readOption(options.minReactions);
+    if (minReactions)
+        filters.min_reactions = minReactions;
+    const postedBy = readOption(options.postedBy);
+    if (postedBy)
+        filters.posted_by = postedBy;
+    const aiFilter = readOption(options.aiFilter);
+    if (aiFilter)
+        filters.ai_filter = aiFilter;
     const countries = readCsvOption(options.countries);
     if (countries.length > 0)
         filters.countries = countries;
@@ -20614,8 +21604,8 @@ function readCompaniesSearchRunBody(options, promptArg) {
     const promptSource = options.prompt ?? promptArg;
     const prompt = promptSource ? readFileIfPresent(promptSource) : null;
     const plan = options.planJson ? readSearchPlanJson(options.planJson) : null;
-    if (!prompt && !plan && options.source !== "company_search" && options.source !== "hiring") {
-        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, or --source company_search|hiring with --source-filters-json.", { exitCode: 1 });
+    if (!prompt && !plan && options.source !== "company_search" && options.source !== "hiring" && options.source !== "google_maps") {
+        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, or --source company_search|hiring|google_maps with --source-filters-json.", { exitCode: 1 });
     }
     const maxPages = readPositiveInt(options.maxPages);
     const maxCredits = readPositiveNumber(options.maxCredits);
@@ -20792,8 +21782,8 @@ const PEOPLE_SEARCH_MIN_CONNECTIONS_HELP = "Only return people with at least thi
 /** The company lanes that share Company Search's flow; anything else is a typo, not a provider. */
 function readCompanySearchSource(value) {
     const source = readOption(value) ?? "company_search";
-    if (source !== "company_search" && source !== "hiring") {
-        throw new OxygenError("invalid_request", "--source must be company_search or hiring.", { exitCode: 1 });
+    if (source !== "company_search" && source !== "hiring" && source !== "google_maps") {
+        throw new OxygenError("invalid_request", "--source must be company_search, hiring or google_maps.", { exitCode: 1 });
     }
     return source;
 }
@@ -24371,6 +25361,57 @@ function formatCrmObjects(data) {
         "",
     ].join("\n");
 }
+/**
+ * A to-do list an operator can read without a JSON parser.
+ *
+ * The record column is the point of the workspace read — a task title alone
+ * ("Send the deck") says nothing about who it is for — so it comes first, from
+ * the same primary link the web row shows. A record-scoped read prints the
+ * same table; the column is simply the record you asked about.
+ */
+function formatCrmTasks(data) {
+    const tasks = Array.isArray(data.tasks) ? data.tasks.filter(isRecord) : [];
+    // The workspace read names its scope as `object: null`; the record-scoped
+    // envelope carries no `object` key at all.
+    const scoped = !Object.hasOwn(data, "object");
+    if (tasks.length === 0) {
+        return scoped
+            ? "No tasks on this record. Add one with: oxygen crm tasks add <object> <record> \"<title>\"\n"
+            : "No tasks in this workspace. A task is filed on a record: oxygen crm tasks add companies acme.com \"Send the deck\"\n";
+    }
+    const rows = tasks.map((task) => {
+        const links = Array.isArray(task.links) ? task.links.filter(isRecord) : [];
+        const primary = links[0];
+        const assignee = isRecord(task.assignee) ? task.assignee : null;
+        return [
+            // Clipped, so one essay-length title cannot push every other column off
+            // the terminal. `--json` still carries the whole thing.
+            clipCell(String(primary?.label ?? primary?.objectSlug ?? "—"), 28),
+            clipCell(String(task.title ?? "—"), 48),
+            String(task.status ?? "—"),
+            String(task.priority ?? "—"),
+            formatCrmTaskDue(task.dueAt),
+            String(assignee?.name ?? assignee?.email ?? "unassigned"),
+            String(task.id ?? "—"),
+        ];
+    });
+    const link = typeof data.web_url === "string" ? data.web_url : null;
+    return [
+        `${tasks.length} task${tasks.length === 1 ? "" : "s"}${data.hasMore === true ? " (more available — pass --cursor)" : ""}`,
+        "",
+        ...renderTextTable(["RECORD", "TASK", "STATUS", "PRIORITY", "DUE", "ASSIGNEE", "ID"], rows),
+        "",
+        "  Finish one:  oxygen crm tasks complete <id>",
+        ...(link ? [`  In the app:  ${link}`] : []),
+        "",
+    ].join("\n");
+}
+/** A deadline is a day to whoever reads the list; the time of day is noise. */
+function formatCrmTaskDue(value) {
+    if (typeof value !== "string" || !value)
+        return "—";
+    return value.slice(0, 10);
+}
 /** "Website domain (website domain)" is noise, so the comparison is named only
  *  when it says something the field name does not. An object with no identity
  *  is called out rather than left blank: it duplicates on every re-import. */
@@ -24677,8 +25718,14 @@ function formatSequenceAnalyticsHealth(data) {
     const from = stringValue(range.from);
     const to = stringValue(range.to);
     const rangeLabel = from || to ? `${from ?? "start"} → ${to ?? "now"}` : stringValue(range.preset) ?? "selected window";
+    const senderOptions = Array.isArray(analytics.senders) ? analytics.senders.filter(isRecord) : [];
+    const senderFilter = Array.isArray(analytics.senderFilter)
+        ? analytics.senderFilter.filter((key) => typeof key === "string")
+        : null;
+    const senderName = (key) => stringValue(senderOptions.find((option) => option.key === key)?.name) ?? key;
     const lines = [
         `Sequencer analytics (${rangeLabel})`,
+        ...(senderFilter ? [`Senders: ${senderFilter.map(senderName).join(", ")}`] : []),
         ...formatSequenceFleetSummary(analytics.fleet),
         `Open work: ${formatSequenceOpenWork(summary.openWork)}`,
         `Selected-window outcomes: ${formatSequenceFailureTotals(failureAnalytics)}`,
@@ -24701,6 +25748,10 @@ function formatSequenceAnalyticsHealth(data) {
     const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
     if (link)
         lines.push(link);
+    const firstSender = stringValue(senderOptions[0]?.key);
+    if (!senderFilter && senderOptions.length > 1 && firstSender) {
+        lines.push(`Scope to one sender: add --sender ${firstSender} (${senderName(firstSender)}); all ${senderOptions.length} are under analytics.senders with --json.`);
+    }
     return `${lines.join("\n")}\n`;
 }
 function sequenceHealthRow(sequence) {
@@ -27191,11 +28242,21 @@ options) {
     const warmupPreset = readOption(options.warmupPreset);
     const hasPreset = warmupPreset !== null && warmupPreset !== undefined;
     const hasRandomize = options.randomizeCaps !== undefined;
+    const hasWeekendFullVolume = options.weekendFullVolume !== undefined;
+    // The READ ramp is a separate axis from the send-side warm-up above: it is
+    // default-on, anchored on when network capture was armed, and governs read
+    // budgets only. Disabling one must never disable the other.
+    const readWarmup = options.readWarmupDisable
+        ? false
+        : options.readWarmupRestart
+            ? true
+            : undefined;
     const hasLimits = Object.keys(limits).length > 0;
     const hasWorkingHours = Object.keys(workingHours).length > 0;
     const hasWarmup = warmup !== undefined;
-    if (!hasLimits && !hasWorkingHours && !hasWarmup && !hasPreset && !hasRandomize) {
-        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day), --timezone, a warm-up flag (--warmup-restart / --warmup-disable / --warmup-start-date), --warmup-preset, or --randomize-caps.", { exitCode: 1 });
+    const hasReadWarmup = readWarmup !== undefined;
+    if (!hasLimits && !hasWorkingHours && !hasWarmup && !hasPreset && !hasRandomize && !hasReadWarmup && !hasWeekendFullVolume) {
+        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day), --timezone, a warm-up flag (--warmup-restart / --warmup-disable / --warmup-start-date), --read-warmup-disable / --read-warmup-restart, --warmup-preset, --randomize-caps, or --weekend-full-volume.", { exitCode: 1 });
     }
     return {
         ...(hasLimits ? { limits } : {}),
@@ -27203,6 +28264,8 @@ options) {
         ...(hasWarmup ? { warmup } : {}),
         ...(hasPreset ? { warmup_preset: warmupPreset } : {}),
         ...(hasRandomize ? { randomize_daily_caps: options.randomizeCaps } : {}),
+        ...(hasWeekendFullVolume ? { weekend_full_volume: options.weekendFullVolume } : {}),
+        ...(hasReadWarmup ? { read_warmup: readWarmup } : {}),
     };
 }
 /**