fullstackgtm 0.46.0 → 0.48.0

package/dist/cli.js

@@ -2,7 +2,7 @@ import { activeProfile, listProfiles, setActiveProfile } from "./credentials.js"
 import { capabilitiesCommand, printCommandHelpJson, robotDocsCommand, unknownCommandEnvelope } from "./cli/capabilities.js";
 import { BESPOKE_HELP, commandHelp, HELP, shortUsage, stylizeShortUsage, usage } from "./cli/help.js";
 import { readPackageInfo } from "./cli/shared.js";
-import { correctedCommand, detectFlagTypo, suggestCommand, unknownFlagEnvelope } from "./cli/suggest.js";
+import { correctedCommand, detectFlagTypo, detectUnknownFlag, suggestCommand, unknownFlagEnvelope } from "./cli/suggest.js";
 import { colorEnabled, paint } from "./cli/ui.js";
 // Verb modules load lazily inside their dispatch branch below. The dispatcher
 // used to import all of them eagerly, so `--version` compiled the full
@@ -56,16 +56,22 @@ export async function runCli(argv) {
     }
     if (command === "help") {
         const [topic] = args;
-        if (topic && topic !== "--full" && !topic.startsWith("-")) {
+        if (topic && !topic.startsWith("-") && args.includes("--json")) {
             // `help <cmd> --json` → machine-readable help derived from the same
-            // HELP entry the plain text renders from. Plain output is unchanged.
-            if (args.includes("--json"))
-                printCommandHelpJson(topic);
-            else
-                console.log(commandHelp(topic));
+            // HELP entry the plain text renders from. JSON takes precedence over
+            // --full so automated callers get a stable shape.
+            printCommandHelpJson(topic);
+        }
+        else if (args.includes("--full")) {
+            // --full is the global escape hatch to the complete reference, even
+            // when a topic is given (help <cmd> --full), unless --json is requested.
+            console.log(usage());
+        }
+        else if (topic && !topic.startsWith("-")) {
+            console.log(commandHelp(topic));
         }
         else {
-            console.log(args.includes("--full") || topic === "--full" ? usage() : styledShortUsage());
+            console.log(styledShortUsage());
         }
         return;
     }
@@ -90,20 +96,27 @@ export async function runCli(argv) {
     }
     // Flag typos used to be silently dropped by the per-verb parsers —
     // `audit --demo --jsn` exited 0 and printed markdown where the agent asked
-    // for JSON. Near-miss unknown flags (≤ 1 edit from a flag documented in
-    // help.ts) now stop with the exact corrected command. Suggest-only: never
-    // auto-execute the correction, so a typo can never change what a
-    // write-shaped invocation stages.
+    // for JSON. Every flag-shaped token is now checked against the per-command
+    // registry in help.ts, so unknown flags fail closed instead of being ignored.
+    // Suggest-only: never auto-execute the correction, so a typo can never
+    // silently change what a write-shaped invocation stages.
     if (command in HELP) {
-        const typo = detectFlagTypo(args);
+        const typo = detectUnknownFlag(command, args);
         if (typo) {
             if (args.includes("--json")) {
                 console.log(JSON.stringify(unknownFlagEnvelope(command, args, typo), null, 2));
             }
             else {
+                console.error(`Unknown flag for ${command}: ${typo.given}`);
+                // Keep the old near-miss shape too; existing agents key off it.
                 console.error(`Unknown flag: ${typo.given}`);
-                console.error(`Did you mean: ${typo.suggestion}`);
-                console.error(`Try: ${correctedCommand(command, args, typo)}`);
+                if (typo.suggestion) {
+                    console.error(`Did you mean ${typo.suggestion}?`);
+                    console.error(`Did you mean: ${typo.suggestion}`);
+                    if (typo.replacement.length > 0) {
+                        console.error(`Try: ${correctedCommand(command, args, typo)}`);
+                    }
+                }
             }
             process.exitCode = 1;
             return;
@@ -161,6 +174,18 @@ export async function runCli(argv) {
         await (await import("./cli/fix.js")).resolveCommand(args);
         return;
     }
+    if (command === "route") {
+        await (await import("./cli/fix.js")).routeCommand(args);
+        return;
+    }
+    if (command === "hierarchy") {
+        await (await import("./cli/fix.js")).hierarchyCommand(args);
+        return;
+    }
+    if (command === "relationships") {
+        await (await import("./cli/fix.js")).relationshipsCommand(args);
+        return;
+    }
     if (command === "bulk-update") {
         await (await import("./cli/fix.js")).bulkUpdateCommand(args);
         return;

package/dist/connector.js

@@ -71,6 +71,13 @@ function normalizeForComparison(value) {
         return null;
     return String(value);
 }
+function isApplyBatchCandidate(operation) {
+    return (((operation.operation === "set_field" || operation.operation === "clear_field") && Boolean(operation.field)) ||
+        operation.operation === "archive_record");
+}
+function sameApplyBatchKind(a, b) {
+    return a.operation === b.operation && a.objectType === b.objectType;
+}
 /**
  * Apply an approved subset of a patch plan through a connector.
  *
@@ -194,6 +201,11 @@ export async function applyPatchPlan(connector, plan, options) {
         for (const operation of plan.operations) {
             if (!approved.has(operation.id) || conflicts.has(operation.id))
                 continue;
+            // Generic batch connectors (Salesforce) do their own batched CAS read for
+            // eligible field writes, so don't pre-read those one-by-one here.
+            if (connector.applyBatch && isApplyBatchCandidate(operation) && !operation.groupId && !operation.preconditions?.length) {
+                continue;
+            }
             let conflict = null;
             if (operation.field && FIELD_WRITE_OPERATIONS.has(operation.operation)) {
                 const current = await connector.readField(operation.objectType, operation.objectId, operation.field);
@@ -266,35 +278,38 @@ export async function applyPatchPlan(connector, plan, options) {
     const notifyProgress = () => {
         if ((!options.onOperation && !options.progress) || results.length === lastNotified)
             return;
-        lastNotified = results.length;
-        const last = results[results.length - 1];
-        if (last.status === "applied")
-            progressCounts.applied += 1;
-        else if (last.status === "failed")
-            progressCounts.failed += 1;
-        else if (last.status === "conflict")
-            progressCounts.conflicts += 1;
-        else
-            progressCounts.skipped += 1;
-        // Shared vocabulary: operation id + status only — a conflict/failure
-        // detail can echo field values, which never leave the machine.
-        options.progress?.opResult(last.operationId, last.status);
-        options.progress?.items(results.length - resultsBefore, plan.operations.length);
-        if (options.onOperation) {
-            try {
-                options.onOperation({
-                    completed: results.length - resultsBefore,
-                    total: plan.operations.length,
-                    ...progressCounts,
-                });
-            }
-            catch {
-                // progress is presentation-only
+        while (lastNotified < results.length) {
+            const last = results[lastNotified];
+            lastNotified += 1;
+            if (last.status === "applied")
+                progressCounts.applied += 1;
+            else if (last.status === "failed")
+                progressCounts.failed += 1;
+            else if (last.status === "conflict")
+                progressCounts.conflicts += 1;
+            else
+                progressCounts.skipped += 1;
+            // Shared vocabulary: operation id + status only — a conflict/failure
+            // detail can echo field values, which never leave the machine.
+            options.progress?.opResult(last.operationId, last.status);
+            options.progress?.items(results.length - resultsBefore, plan.operations.length);
+            if (options.onOperation) {
+                try {
+                    options.onOperation({
+                        completed: lastNotified - resultsBefore,
+                        total: plan.operations.length,
+                        ...progressCounts,
+                    });
+                }
+                catch {
+                    // progress is presentation-only
+                }
             }
         }
     };
     emitStage("operations");
-    for (const operation of plan.operations) {
+    for (let opIndex = 0; opIndex < plan.operations.length; opIndex++) {
+        const operation = plan.operations[opIndex];
         // Report the previous iteration's result (guarded: no-op if it pushed
         // nothing). One-iteration lag keeps this a two-line hook instead of a
         // notify after all ten push sites; the loop-exit call below flushes the last.
@@ -362,6 +377,62 @@ export async function applyPatchPlan(connector, plan, options) {
             });
             continue;
         }
+        if (connector.applyBatch && isApplyBatchCandidate(operation) && (checkConflicts || operation.operation === "archive_record") && !operation.groupId && !operation.preconditions?.length) {
+            const chunk = [];
+            const applyBatchLimit = Math.max(1, connector.applyBatchLimit ?? 200);
+            for (let scan = opIndex; scan < plan.operations.length && chunk.length < applyBatchLimit; scan++) {
+                const candidate = plan.operations[scan];
+                if (!sameApplyBatchKind(operation, candidate) || !isApplyBatchCandidate(candidate))
+                    break;
+                const candidateOverride = options.valueOverrides?.[candidate.id];
+                if (!approved.has(candidate.id) ||
+                    (requiresHumanInput(candidate.afterValue) && candidateOverride === undefined) ||
+                    conflicts.has(candidate.id) ||
+                    Boolean(candidate.groupId) ||
+                    Boolean(candidate.preconditions?.length) ||
+                    (staleByFilter && staleByFilter.has(candidate.objectId)) ||
+                    irreversibleStale.has(candidate.id)) {
+                    break;
+                }
+                chunk.push(candidateOverride === undefined ? candidate : { ...candidate, afterValue: candidateOverride });
+            }
+            if (chunk.length > 1) {
+                try {
+                    const batchResults = await connector.applyBatch(chunk);
+                    const byOperationId = new Map(batchResults.map((result) => [result.operationId, result]));
+                    for (const batchOperation of chunk) {
+                        const result = byOperationId.get(batchOperation.id) ?? {
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: "Batch connector did not return a result for this operation.",
+                        };
+                        results.push(result);
+                        if (result.status === "applied" || result.status === "failed")
+                            attempted += 1;
+                        if (result.status === "applied")
+                            applied += 1;
+                    }
+                    const appliedInBatch = batchResults.filter((result) => result.status === "applied").length;
+                    appliedSinceRecheck += appliedInBatch;
+                    if (appliedInBatch > 0 && (applied === appliedInBatch || appliedSinceRecheck >= recheckEvery)) {
+                        appliedSinceRecheck = 0;
+                        await refreshSnapshotChecks();
+                    }
+                }
+                catch (error) {
+                    for (const batchOperation of chunk) {
+                        results.push({
+                            operationId: batchOperation.id,
+                            status: "failed",
+                            detail: error instanceof Error ? error.message : String(error),
+                        });
+                        attempted += 1;
+                    }
+                }
+                opIndex += chunk.length - 1;
+                continue;
+            }
+        }
         const resolved = override === undefined ? operation : { ...operation, afterValue: override };
         attempted += 1;
         try {

package/dist/connectors/hubspot.d.ts

@@ -1,6 +1,7 @@
 import { type FieldMappings } from "../mappings.ts";
 import type { GtmConnector, SnapshotProgress } from "../types.ts";
 import { type ProgressEmitter } from "../progress.ts";
+export type HubspotWritableConnector = GtmConnector & Required<Pick<GtmConnector, "applyOperation" | "readField">>;
 export type HubspotConnectorOptions = {
     /** Returns a HubSpot access token (private app token or OAuth access token). */
     getAccessToken: () => string | Promise<string>;
@@ -26,4 +27,4 @@ export type HubspotConnectorOptions = {
  * amountless deals — so audit rules can surface the gaps instead of hiding
  * them.
  */
-export declare function createHubspotConnector(options: HubspotConnectorOptions): Required<GtmConnector>;
+export declare function createHubspotConnector(options: HubspotConnectorOptions): HubspotWritableConnector;

package/dist/connectors/hubspot.js

@@ -1057,6 +1057,173 @@ export function createHubspotConnector(options) {
             detail: `Archived ${objectPath}/${operation.objectId}.`,
         };
     }
+    function fieldMapping(operation) {
+        const objectPath = OBJECT_PATHS[operation.objectType];
+        const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+        if (!objectPath || !mappingType || !operation.field)
+            return null;
+        const defaults = HUBSPOT_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+        return { objectPath, property: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field) };
+    }
+    function normalizeHubspotReadValue(field, value) {
+        if (field === "closeDate" && typeof value === "string")
+            return value.split("T")[0];
+        return value ?? null;
+    }
+    function normalizeForComparison(value) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        return String(value);
+    }
+    function batchErrorIds(error) {
+        const context = error?.context ?? {};
+        const ids = context.ids ?? context.id ?? error?.id ?? error?.objectId;
+        if (Array.isArray(ids))
+            return ids.map(String);
+        if (ids !== undefined && ids !== null)
+            return [String(ids)];
+        return [];
+    }
+    function batchErrorDetail(error) {
+        const category = error?.category ? `${String(error.category)}: ` : "";
+        return `${category}${String(error?.message ?? "HubSpot batch row failed.")}`;
+    }
+    async function applySetFieldBatch(operations) {
+        const out = new Map();
+        const mapped = operations.map((operation) => ({ operation, mapping: fieldMapping(operation) }));
+        for (const item of mapped) {
+            if (!item.mapping) {
+                out.set(item.operation.id, {
+                    operationId: item.operation.id,
+                    status: "skipped",
+                    detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+                });
+            }
+        }
+        const clean = mapped.filter((item) => Boolean(item.mapping));
+        if (clean.length === 0)
+            return operations.map((operation) => out.get(operation.id));
+        const objectPath = clean[0].mapping.objectPath;
+        const properties = [...new Set(clean.map((item) => item.mapping.property))];
+        const liveById = new Map();
+        const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+        for (let i = 0; i < ids.length; i += 100) {
+            const chunkIds = ids.slice(i, i + 100);
+            const data = await request(`/crm/v3/objects/${objectPath}/batch/read`, {
+                method: "POST",
+                body: JSON.stringify({ properties, inputs: chunkIds.map((id) => ({ id })) }),
+            });
+            for (const row of data?.results ?? []) {
+                if (row?.id)
+                    liveById.set(String(row.id), row.properties ?? {});
+            }
+        }
+        const toWrite = [];
+        for (const { operation, mapping } of clean) {
+            const props = liveById.get(operation.objectId);
+            const current = normalizeHubspotReadValue(operation.field, props?.[mapping.property] ?? null);
+            const expected = normalizeForComparison(operation.beforeValue);
+            const found = normalizeForComparison(current);
+            if (!props || expected !== found) {
+                out.set(operation.id, {
+                    operationId: operation.id,
+                    status: "conflict",
+                    detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+                    providerData: { currentValue: current ?? null },
+                });
+                continue;
+            }
+            toWrite.push({ operation, property: mapping.property });
+        }
+        for (let i = 0; i < toWrite.length; i += 100) {
+            const chunk = toWrite.slice(i, i + 100);
+            let data;
+            try {
+                data = await request(`/crm/v3/objects/${objectPath}/batch/update`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        inputs: chunk.map(({ operation, property }) => ({
+                            id: operation.objectId,
+                            properties: { [property]: operation.operation === "clear_field" ? "" : String(operation.afterValue ?? "") },
+                        })),
+                    }),
+                });
+            }
+            catch (error) {
+                for (const { operation } of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            const opByObjectId = new Map(chunk.map(({ operation }) => [operation.objectId, operation]));
+            for (const error of data?.errors ?? []) {
+                for (const id of batchErrorIds(error)) {
+                    const operation = opByObjectId.get(id);
+                    if (operation)
+                        out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+                }
+            }
+            for (const result of data?.results ?? []) {
+                const operation = opByObjectId.get(String(result?.id));
+                if (operation && !out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${chunk.find((item) => item.operation.id === operation.id)?.property ?? "field"} on ${objectPath}/${operation.objectId}.`, providerData: { id: result?.id } });
+            }
+            for (const { operation, property } of chunk) {
+                if (!out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Set ${property} on ${objectPath}/${operation.objectId}.` });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+    }
+    async function applyArchiveBatch(operations) {
+        const objectPath = OBJECT_PATHS[operations[0]?.objectType];
+        if (!objectPath)
+            return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+        const out = new Map();
+        for (let i = 0; i < operations.length; i += 100) {
+            const chunk = operations.slice(i, i + 100);
+            let data;
+            try {
+                data = await request(`/crm/v3/objects/${objectPath}/batch/archive`, {
+                    method: "POST",
+                    body: JSON.stringify({ inputs: chunk.map((operation) => ({ id: operation.objectId })) }),
+                });
+            }
+            catch (error) {
+                for (const operation of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            const opByObjectId = new Map(chunk.map((operation) => [operation.objectId, operation]));
+            for (const error of data?.errors ?? []) {
+                for (const id of batchErrorIds(error)) {
+                    const operation = opByObjectId.get(id);
+                    if (operation)
+                        out.set(operation.id, { operationId: operation.id, status: "failed", detail: batchErrorDetail(error) });
+                }
+            }
+            for (const result of data?.results ?? []) {
+                const operation = opByObjectId.get(String(result?.id));
+                if (operation && !out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+            }
+            for (const operation of chunk) {
+                if (!out.has(operation.id))
+                    out.set(operation.id, { operationId: operation.id, status: "applied", detail: `Archived ${objectPath}/${operation.objectId}.` });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch archive did not process this operation." });
+    }
+    async function applyBatch(operations) {
+        if (operations.length === 0)
+            return [];
+        if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+            return applySetFieldBatch(operations);
+        }
+        if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+            return applyArchiveBatch(operations);
+        }
+        return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+    }
     /**
      * Merge a duplicate group into the approved survivor via HubSpot's v3
      * merge API (supported for contacts, companies, deals, and tickets).
@@ -1182,10 +1349,7 @@ export function createHubspotConnector(options) {
         // single-object read here returns HubSpot's raw "2026-03-07T00:00:00Z", which
         // made compare-and-set see a spurious drift and refuse every date-field write.
         // Mirror the snapshot's normalization so the comparison is apples-to-apples.
-        if (field === "closeDate" && typeof value === "string") {
-            return value.split("T")[0];
-        }
-        return value;
+        return normalizeHubspotReadValue(field, value);
     }
     return {
         provider: "hubspot",
@@ -1193,6 +1357,8 @@ export function createHubspotConnector(options) {
         fetchChanges,
         applyOperation,
         applyCreateContactsBatch,
+        applyBatch,
+        applyBatchLimit: 100,
         readField,
     };
 }

package/dist/connectors/salesforce.d.ts

@@ -6,6 +6,7 @@ export type SalesforceConnection = {
     /** e.g. https://yourorg.my.salesforce.com */
     instanceUrl: string;
 };
+export type SalesforceWritableConnector = GtmConnector & Required<Pick<GtmConnector, "applyOperation" | "readField">>;
 export type SalesforceConnectorOptions = {
     /** Returns an access token plus the instance URL it belongs to. */
     getConnection: () => SalesforceConnection | Promise<SalesforceConnection>;
@@ -32,4 +33,4 @@ export type SalesforceConnectorOptions = {
  * surface the gaps). Probabilities are normalized to 0..1 to match the
  * canonical model.
  */
-export declare function createSalesforceConnector(options: SalesforceConnectorOptions): Required<GtmConnector>;
+export declare function createSalesforceConnector(options: SalesforceConnectorOptions): SalesforceWritableConnector;

package/dist/connectors/salesforce.js

@@ -376,6 +376,139 @@ export function createSalesforceConnector(options) {
             detail: `Deleted ${sobjectType}/${operation.objectId}.`,
         };
     }
+    function normalizeSalesforceValue(value) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        return String(value).split("T")[0];
+    }
+    function fieldMappingFor(operation) {
+        const sobjectType = SOBJECT_TYPES[operation.objectType];
+        const mappingType = MAPPING_OBJECT_TYPES[operation.objectType];
+        if (!sobjectType || !mappingType || !operation.field)
+            return null;
+        const defaults = SALESFORCE_DEFAULT_FIELD_MAPPINGS[mappingType] ?? {};
+        return {
+            sobjectType,
+            field: mappedField(mappings, mappingType, operation.field, defaults[operation.field] ?? operation.field),
+        };
+    }
+    function compositeErrorDetail(result) {
+        const errors = Array.isArray(result?.errors) ? result.errors : [];
+        const message = errors
+            .map((error) => [error?.statusCode, error?.message].filter(Boolean).join(": "))
+            .filter(Boolean)
+            .join("; ");
+        return message ? `Salesforce rejected this record: ${message.slice(0, 300)}.` : "Salesforce rejected this record.";
+    }
+    async function applySetFieldBatch(operations) {
+        const out = new Map();
+        const mapped = operations.map((operation) => ({ operation, mapping: fieldMappingFor(operation) }));
+        for (const item of mapped) {
+            if (!item.mapping) {
+                out.set(item.operation.id, {
+                    operationId: item.operation.id,
+                    status: "skipped",
+                    detail: "Field writes are only supported for accounts, contacts, and deals with an explicit field.",
+                });
+            }
+        }
+        const clean = mapped.filter((item) => Boolean(item.mapping));
+        if (clean.length === 0)
+            return operations.map((operation) => out.get(operation.id));
+        const sobjectType = clean[0].mapping.sobjectType;
+        const fields = [...new Set(clean.map((item) => item.mapping.field))];
+        const liveById = new Map();
+        const ids = [...new Set(clean.map((item) => item.operation.objectId))];
+        for (let i = 0; i < ids.length; i += 200) {
+            const idList = ids.slice(i, i + 200).map((id) => `'${id.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(",");
+            const rows = await query(`SELECT Id, ${fields.join(", ")} FROM ${sobjectType} WHERE Id IN (${idList})`);
+            for (const row of rows)
+                liveById.set(String(row.Id), row);
+        }
+        const toWrite = [];
+        for (const { operation, mapping } of clean) {
+            const row = liveById.get(operation.objectId);
+            const current = row?.[mapping.field] ?? null;
+            const expected = normalizeSalesforceValue(operation.beforeValue);
+            const found = normalizeSalesforceValue(current);
+            if (!row || expected !== found) {
+                out.set(operation.id, {
+                    operationId: operation.id,
+                    status: "conflict",
+                    detail: `Value drifted since the plan was proposed: expected ${expected ?? "∅"}, found ${found ?? "∅"}. Re-run the audit.`,
+                    providerData: { currentValue: current ?? null },
+                });
+                continue;
+            }
+            toWrite.push({ operation, field: mapping.field });
+        }
+        for (let i = 0; i < toWrite.length; i += 200) {
+            const chunk = toWrite.slice(i, i + 200);
+            const records = chunk.map(({ operation, field }) => ({
+                attributes: { type: sobjectType },
+                Id: operation.objectId,
+                [field]: operation.operation === "clear_field" ? null : String(operation.afterValue ?? ""),
+            }));
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects`, {
+                    method: "PATCH",
+                    body: JSON.stringify({ allOrNone: false, records }),
+                }));
+            }
+            catch (error) {
+                for (const { operation } of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const { operation, field } = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Set ${field} on ${sobjectType}/${operation.objectId}.`, providerData: { sobjectType, field } }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch update did not process this operation." });
+    }
+    async function applyArchiveBatch(operations) {
+        const sobjectType = SOBJECT_TYPES[operations[0]?.objectType];
+        if (!sobjectType)
+            return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "archive_record is supported for accounts, contacts, and deals." }));
+        const out = new Map();
+        for (let i = 0; i < operations.length; i += 200) {
+            const chunk = operations.slice(i, i + 200);
+            const ids = chunk.map((operation) => encodeURIComponent(operation.objectId)).join(",");
+            let response;
+            try {
+                response = (await request(`/services/data/${apiVersion}/composite/sobjects?ids=${ids}&allOrNone=false`, { method: "DELETE" }));
+            }
+            catch (error) {
+                for (const operation of chunk)
+                    out.set(operation.id, { operationId: operation.id, status: "failed", detail: error instanceof Error ? error.message : String(error) });
+                continue;
+            }
+            for (let j = 0; j < chunk.length; j++) {
+                const operation = chunk[j];
+                const result = Array.isArray(response) ? response[j] : undefined;
+                out.set(operation.id, result?.success
+                    ? { operationId: operation.id, status: "applied", detail: `Deleted ${sobjectType}/${operation.objectId}.` }
+                    : { operationId: operation.id, status: "failed", detail: compositeErrorDetail(result) });
+            }
+        }
+        return operations.map((operation) => out.get(operation.id) ?? { operationId: operation.id, status: "failed", detail: "Batch delete did not process this operation." });
+    }
+    async function applyBatch(operations) {
+        if (operations.length === 0)
+            return [];
+        if (operations.every((operation) => (operation.operation === "set_field" || operation.operation === "clear_field") && operation.objectType === operations[0].objectType)) {
+            return applySetFieldBatch(operations);
+        }
+        if (operations.every((operation) => operation.operation === "archive_record" && operation.objectType === operations[0].objectType)) {
+            return applyArchiveBatch(operations);
+        }
+        return operations.map((operation) => ({ operationId: operation.id, status: "skipped", detail: "This mixed operation batch is not supported." }));
+    }
     function escapeXml(value) {
         return value
             .replace(/&/g, "&amp;")
@@ -738,6 +871,8 @@ export function createSalesforceConnector(options) {
         fetchChanges,
         applyOperation,
         applyCreateContactsBatch,
+        applyBatch,
+        applyBatchLimit: 200,
         readField,
     };
 }

package/dist/connectors/signalSources.js

@@ -20,6 +20,7 @@
  */
 import { readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
+import { FREE_EMAIL_DOMAINS } from "../freeEmailDomains.js";
 import { SIGNAL_BUCKETS } from "../signals.js";
 import { parseSpoolText, spoolFilesIn } from "../spoolFiles.js";
 // ---------------------------------------------------------------------------
@@ -243,22 +244,12 @@ function fieldValue(values, name) {
     }
     return "";
 }
-const FREE_MAIL = new Set([
-    "gmail.com",
-    "yahoo.com",
-    "hotmail.com",
-    "outlook.com",
-    "icloud.com",
-    "aol.com",
-    "proton.me",
-    "protonmail.com",
-]);
 /** Company domain from an email, or "" for free-mail / no email. */
 function corporateDomain(email) {
     if (!email.includes("@"))
         return "";
     const domain = email.split("@").at(-1).trim().toLowerCase();
-    if (!domain || FREE_MAIL.has(domain))
+    if (!domain || FREE_EMAIL_DOMAINS.has(domain))
         return "";
     return domain;
 }