fullstackgtm 0.48.0 → 0.50.0

package/dist/hostedPatchPlan.js

@@ -0,0 +1,270 @@
+/** Broker-authenticated mirror for locally governed patch plans. */
+import { createHash } from "node:crypto";
+import { getCredential } from "./credentials.js";
+const ENDPOINT = "/api/cli/patch-plan";
+const TIMEOUT_MS = 5000;
+function broker() {
+    const value = getCredential("broker");
+    if (!value?.baseUrl || !value.accessToken)
+        return null;
+    try {
+        const url = new URL(value.baseUrl);
+        const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+        if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
+            return null;
+        return { baseUrl: url.href.replace(/\/+$/, ""), token: value.accessToken };
+    }
+    catch {
+        return null;
+    }
+}
+/** Review document intentionally omits evidence/findings and all mutable store security state. */
+export function hostedReviewDocument(plan) {
+    return {
+        id: plan.id,
+        title: plan.title,
+        createdAt: plan.createdAt,
+        status: "needs_approval",
+        dryRun: true,
+        summary: plan.summary,
+        operations: plan.operations,
+        ...(plan.filter ? { filter: plan.filter } : {}),
+        ...(plan.guards ? { guards: plan.guards } : {}),
+    };
+}
+export function hostedPlanDigest(plan) {
+    return createHash("sha256").update(JSON.stringify(hostedReviewDocument(plan))).digest("hex");
+}
+function mapOperation(op) {
+    return {
+        packageOpId: op.id,
+        objectType: op.objectType,
+        ...(op.objectId ? { objectId: op.objectId } : {}),
+        fieldOrAction: op.field ?? op.operation,
+        beforeValue: op.beforeValue ?? null,
+        afterValue: op.afterValue ?? null,
+        ...(op.reason ? { reason: op.reason } : {}),
+        ...(op.sourceRuleOrPolicy ? { sourceRuleOrPolicy: op.sourceRuleOrPolicy } : {}),
+        riskLevel: op.riskLevel,
+        approvalRequired: op.approvalRequired,
+        ...(op.rollback ? { rollback: op.rollback } : {}),
+    };
+}
+function parseState(value, baseUrl) {
+    if (!value || typeof value !== "object")
+        return null;
+    const row = value;
+    const id = typeof row.patchPlanId === "string" ? row.patchPlanId : null;
+    if (!id)
+        return null;
+    const approvedOperationIds = Array.isArray(row.approvedOperationIds) ? row.approvedOperationIds.filter((id) => typeof id === "string") : [];
+    const runRecord = parseRunRecord(row.runRecord, row.operationReceipts, row.externalPlanId, row.updatedAt);
+    return {
+        patchPlanId: id,
+        externalPlanId: typeof row.externalPlanId === "string" ? row.externalPlanId : "",
+        documentSha256: typeof row.documentSha256 === "string" ? row.documentSha256 : "",
+        status: typeof row.status === "string" ? row.status : "pending_approval",
+        approvedOperationIds,
+        valueOverrides: row.valueOverrides && typeof row.valueOverrides === "object" && !Array.isArray(row.valueOverrides) ? row.valueOverrides : {},
+        updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : Date.now(),
+        ...(runRecord ? { runRecord } : {}),
+        url: `${baseUrl}/dashboard/patch-plans?plan=${encodeURIComponent(id)}`,
+    };
+}
+function parseRunRecord(value, receiptsValue, externalPlanId, updatedAt) {
+    const row = value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    const planId = typeof row?.planId === "string" ? row.planId : typeof externalPlanId === "string" ? externalPlanId : undefined;
+    if (!planId)
+        return undefined;
+    const rawResults = Array.isArray(row?.results) ? row.results : Array.isArray(receiptsValue) ? receiptsValue : [];
+    const results = rawResults.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+            return [];
+        const receipt = entry;
+        const operationId = typeof receipt.operationId === "string" ? receipt.operationId : typeof receipt.packageOpId === "string" ? receipt.packageOpId : undefined;
+        const rawStatus = receipt.status;
+        const status = rawStatus === "applied" || rawStatus === "failed" || rawStatus === "skipped" || rawStatus === "conflict" ? rawStatus : undefined;
+        if (!operationId || !status)
+            return [];
+        return [{ operationId, status, ...(typeof receipt.detail === "string" ? { detail: receipt.detail } : typeof receipt.error === "string" ? { detail: receipt.error } : {}), ...(receipt.providerData !== undefined ? { providerData: receipt.providerData } : {}) }];
+    });
+    if (results.length === 0)
+        return undefined;
+    const timestamp = typeof updatedAt === "number" ? new Date(updatedAt).toISOString() : new Date().toISOString();
+    const provider = typeof row?.provider === "string" ? row.provider : "mock";
+    const status = row?.status === "applied" || row?.status === "partial" || row?.status === "failed" || row?.status === "rejected"
+        ? row.status : results.every((result) => result.status === "applied" || result.status === "skipped") ? "applied" : "partial";
+    return {
+        planId, provider,
+        startedAt: typeof row?.startedAt === "string" ? row.startedAt : timestamp,
+        finishedAt: typeof row?.finishedAt === "string" ? row.finishedAt : timestamp,
+        status,
+        results,
+    };
+}
+function failure(status) {
+    if (status === 409)
+        return { status: "conflict", reason: "hosted mirror has different immutable content" };
+    if (status === 401 || status === 403)
+        return { status: "unavailable", reason: "hosted authentication was rejected; pair the CLI again" };
+    return { status: "unavailable", reason: `hosted plan request failed (HTTP ${status})` };
+}
+export async function uploadHostedPatchPlan(stored, options = {}) {
+    const paired = broker();
+    if (!paired)
+        return { status: "unpaired" };
+    const document = hostedReviewDocument(stored.plan);
+    const digest = hostedPlanDigest(stored.plan);
+    const riskOrder = { low: 0, medium: 1, high: 2 };
+    const riskLevel = stored.plan.operations.reduce((risk, op) => riskOrder[op.riskLevel] > riskOrder[risk] ? op.riskLevel : risk, "low");
+    try {
+        const response = await (options.fetchImpl ?? fetch)(`${paired.baseUrl}${ENDPOINT}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${paired.token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                externalPlanId: stored.plan.id, documentSha256: digest, externalRevision: stored.revision,
+                title: stored.plan.title, summary: stored.plan.summary, riskLevel, document,
+                operations: stored.plan.operations.map(mapOperation), createdAt: Date.parse(stored.plan.createdAt),
+            }),
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return failure(response.status);
+        const raw = await response.json();
+        const state = parseState({ ...raw, externalPlanId: stored.plan.id, documentSha256: digest, approvedOperationIds: [], valueOverrides: {}, updatedAt: Date.now() }, paired.baseUrl);
+        return state ? { status: "saved", state } : { status: "unavailable", reason: "hosted plan response was invalid" };
+    }
+    catch {
+        return { status: "unavailable", reason: "hosted plan request was unavailable" };
+    }
+}
+export async function readHostedPatchPlan(planId, options = {}) {
+    const paired = broker();
+    if (!paired)
+        return { status: "unpaired" };
+    try {
+        const response = await (options.fetchImpl ?? fetch)(`${paired.baseUrl}${ENDPOINT}?externalPlanId=${encodeURIComponent(planId)}`, {
+            headers: { Authorization: `Bearer ${paired.token}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (response.status === 404)
+            return { status: "missing" };
+        if (!response.ok)
+            return failure(response.status);
+        const state = parseState(await response.json(), paired.baseUrl);
+        return state ? { status: "found", state } : { status: "unavailable", reason: "hosted plan response was invalid" };
+    }
+    catch {
+        return { status: "unavailable", reason: "hosted plan request was unavailable" };
+    }
+}
+/** Pull a peer's newer lifecycle into the local replica without weakening local integrity gates. */
+export async function reconcileHostedPatchPlan(store, stored, options = {}) {
+    const hosted = await readHostedPatchPlan(stored.plan.id, options);
+    if (hosted.status === "unpaired" || hosted.status === "missing")
+        return { status: hosted.status };
+    if (hosted.status === "unavailable" || hosted.status === "conflict")
+        return hosted;
+    if (hosted.state.documentSha256 !== hostedPlanDigest(stored.plan)) {
+        return { status: "conflict", reason: "hosted review content does not match the immutable local plan" };
+    }
+    if (!["approved", "rejected", "applied"].includes(hosted.state.status))
+        return { status: "unchanged" };
+    try {
+        const reconciled = await store.reconcileReplica(stored.plan.id, {
+            status: hosted.state.status,
+            approvedOperationIds: hosted.state.approvedOperationIds,
+            valueOverrides: hosted.state.valueOverrides,
+            ...(hosted.state.runRecord ? { run: hosted.state.runRecord } : {}),
+        });
+        return reconciled.changed
+            ? { status: "updated", stored: reconciled.stored, remoteStatus: hosted.state.status }
+            : { status: "unchanged" };
+    }
+    catch (error) {
+        return { status: "conflict", reason: error instanceof Error ? error.message : "replica reconciliation failed" };
+    }
+}
+export async function reportHostedPlanLifecycle(stored, options = {}) {
+    const paired = broker();
+    if (!paired)
+        return { status: "unpaired" };
+    const status = stored.status === "applied" ? "applied" : stored.status === "rejected" ? "rejected" : "approved";
+    const runRecord = status === "applied" ? stored.runs.at(-1) : undefined;
+    const operationReceipts = runRecord?.results.map((result) => ({
+        packageOpId: result.operationId,
+        status: result.status,
+        ...(result.detail ? { error: result.detail.slice(0, 1000) } : {}),
+        ...(result.providerData !== undefined ? { providerData: result.providerData } : {}),
+        updatedAt: Date.parse(runRecord.finishedAt),
+    }));
+    try {
+        const response = await (options.fetchImpl ?? fetch)(`${paired.baseUrl}${ENDPOINT}`, {
+            method: "POST", headers: { Authorization: `Bearer ${paired.token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ action: "lifecycle", externalPlanId: stored.plan.id, documentSha256: hostedPlanDigest(stored.plan), status, approvedOperationIds: stored.approvedOperationIds, ...(options.claimId ? { claimId: options.claimId } : {}), ...(runRecord ? { runRecord, operationReceipts } : {}) }),
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return failure(response.status);
+        const raw = await response.json();
+        const state = parseState({ ...raw, externalPlanId: stored.plan.id, documentSha256: hostedPlanDigest(stored.plan), approvedOperationIds: stored.approvedOperationIds, valueOverrides: stored.valueOverrides, updatedAt: Date.now() }, paired.baseUrl);
+        return state ? { status: "saved", state } : { status: "unavailable", reason: "hosted lifecycle response was invalid" };
+    }
+    catch {
+        return { status: "unavailable", reason: "hosted lifecycle request was unavailable" };
+    }
+}
+/** Coordinate online replicas before provider I/O; provider idempotency remains the offline fallback. */
+export async function claimHostedPlanApply(stored, options = {}) {
+    const paired = broker();
+    if (!paired)
+        return { status: "unpaired" };
+    try {
+        const response = await (options.fetchImpl ?? fetch)(`${paired.baseUrl}${ENDPOINT}`, {
+            method: "POST", headers: { Authorization: `Bearer ${paired.token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ action: "claim", externalPlanId: stored.plan.id, documentSha256: hostedPlanDigest(stored.plan) }),
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return failure(response.status);
+        const row = await response.json();
+        if (row.alreadyApplied === true || row.status === "applied")
+            return { status: "applied" };
+        if (row.status === "claimed" && typeof row.claimId === "string") {
+            return { status: "claimed", claimId: row.claimId, ...(typeof row.expiresAt === "number" ? { expiresAt: row.expiresAt } : {}) };
+        }
+        return { status: "unavailable", reason: "hosted apply claim response was invalid" };
+    }
+    catch {
+        return { status: "unavailable", reason: "hosted apply claim request was unavailable" };
+    }
+}
+/** Release a shared CLI claim only when preflight aborts before provider I/O. */
+export async function releaseHostedPlanApply(stored, claimId, reason, options = {}) {
+    const paired = broker();
+    if (!paired)
+        return { status: "unpaired" };
+    try {
+        const response = await (options.fetchImpl ?? fetch)(`${paired.baseUrl}${ENDPOINT}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${paired.token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                action: "release_claim",
+                externalPlanId: stored.plan.id,
+                documentSha256: hostedPlanDigest(stored.plan),
+                claimId,
+                reason,
+            }),
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return failure(response.status);
+        const row = await response.json();
+        return row.released === true
+            ? { status: "released" }
+            : { status: "unavailable", reason: "hosted apply claim release response was invalid" };
+    }
+    catch {
+        return { status: "unavailable", reason: "hosted apply claim release was unavailable" };
+    }
+}

package/dist/icp.js

@@ -158,6 +158,14 @@ const CRUSTDATA_INDUSTRY = {
     fintech: ["Financial Services"],
     "financial services": ["Financial Services"],
 };
+// Common NAICS groups translated into Crustdata's LinkedIn industry vocabulary.
+// This keeps an ICP authored with provider-neutral NAICS codes from silently
+// dropping its industry constraint on the Pipe0 path.
+const NAICS_CRUSTDATA_INDUSTRY = {
+    "5112": ["Software Development", "Computer Software"],
+    "5182": ["IT Services and IT Consulting", "Information Technology & Services"],
+    "5415": ["IT Services and IT Consulting", "Information Technology & Services"],
+};
 /**
  * pipe0 Crustdata people-search config.filters from the ICP. `current_job_titles`
  * matches real LinkedIn title strings (case-sensitive), so keywords are Title
@@ -185,9 +193,12 @@ export function icpToCrustdataFilters(icp) {
     if (icp.firmographics.geos?.length) {
         f.locations = icp.firmographics.geos.map((g) => COUNTRY_NAMES[g.toLowerCase()] ?? g);
     }
-    if (icp.firmographics.industries?.length) {
+    if (icp.firmographics.industries?.length || icp.firmographics.naics?.length) {
         const inds = [
-            ...new Set(icp.firmographics.industries.flatMap((i) => CRUSTDATA_INDUSTRY[i.toLowerCase()] ?? [titleCase(i)])),
+            ...new Set([
+                ...(icp.firmographics.industries ?? []).flatMap((i) => CRUSTDATA_INDUSTRY[i.toLowerCase()] ?? [titleCase(i)]),
+                ...(icp.firmographics.naics ?? []).flatMap((code) => NAICS_CRUSTDATA_INDUSTRY[code] ?? []),
+            ]),
         ];
         if (inds.length)
             f.current_employers_linkedin_industries = inds;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { auditSnapshot, defaultPolicy } from "./audit.ts";
+export { acquireCheckpointId, acquireCheckpointsDir, createFileAcquireCheckpointStore, validateAcquireCheckpoint, validateAcquireCheckpointKey, type AcquireCheckpoint, type AcquireCheckpointKey, type AcquireCheckpointStore, type AcquireContinuation, } from "./acquireCheckpoint.ts";
 export { matchesTerritory, parseAssignmentPolicy, resolveAssignment, type AssignmentContext, type AssignmentPolicy, type AssignmentResult, type AssignmentStrategy, type TerritoryRule, } from "./assign.ts";
 export { buildBulkUpdatePlan, isFilterableField, parseWhere, type BulkUpdateOptions } from "./bulkUpdate.ts";
 export { buildDedupePlan, dedupeKey, type DedupeOptions } from "./dedupe.ts";
@@ -6,18 +7,20 @@ export { buildReassignPlans, type ReassignObjectType, type ReassignOptions } fro
 export { buildLeadRoutePlan, type LeadRouteCounts, type LeadRouteOptions, type LeadRouteResult, } from "./route.ts";
 export { accountHierarchyToMarkdown, buildAccountHierarchy, type AccountHierarchyConflict, type AccountHierarchyNode, type AccountHierarchyReport, } from "./hierarchy.ts";
 export { buildRelationshipMap, relationshipMapToMarkdown, type RelationshipMap, type StakeholderNode, type StakeholderRole, type StakeholderSentiment, } from "./relationships.ts";
-export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, type FullstackgtmConfig, type LoadedConfig, } from "./config.ts";
+export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, rulePackageTrustFromCli, type FullstackgtmConfig, type LoadedConfig, type RulePackageTrust, } from "./config.ts";
 export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
 export { APPLY_STAGES, BACKFILL_STRIPE_STAGES, composeListeners, createProgressEmitter, CRM_SYNC_STAGES, nullProgressEmitter, SNAPSHOT_PULL_STAGES, STRIPE_SNAPSHOT_STAGES, type ProgressEmitter, type ProgressEvent, type ProgressListener, type ProgressSnapshot, } from "./progress.ts";
 export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";
 export { DEFAULT_LOOPBACK_PORT, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, type HubspotTokenSet, type LoopbackLoginOptions, } from "./connectors/hubspotAuth.ts";
 export { createSalesforceConnector, type SalesforceConnection, type SalesforceConnectorOptions, } from "./connectors/salesforce.ts";
-export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, type SalesforceDeviceAuthorization, type SalesforceTokenSet, } from "./connectors/salesforceAuth.ts";
+export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceOrigin, validateSalesforceToken, type SalesforceDeviceAuthorization, type SalesforceTokenSet, } from "./connectors/salesforceAuth.ts";
 export { createStripeConnector, fetchStripePaidInvoices, type StripeConnectorOptions, type StripePaidInvoice, } from "./connectors/stripe.ts";
 export { buildStripeBackfillPlan, DEFAULT_BACKFILL_MATCH_PROPERTY, type StripeBackfillCounts, type StripeBackfillOptions, type StripeBackfillResult, type StripeBackfillUnmatched, } from "./backfill.ts";
 export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, deleteCredential, getCredential, listProfiles, resolveHubspotAccessToken, resolveHubspotConnection, setActiveProfile, storeCredential, type HubspotConnection, type StoredCredential, } from "./credentials.ts";
 export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
-export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, type BuildEnrichPlanOptions, type EnrichAmbiguity, type EnrichConfig, type EnrichCounts, type EnrichFieldConfig, type EnrichMatchConfig, type EnrichMode, type EnrichObjectType, type EnrichPlanResult, type EnrichRun, type EnrichRunStore, type EnrichSourceConfig, type EnrichSourceRecord, type EnrichStamp, type EnrichWorkItem, type MatchOutcome, } from "./enrich.ts";
+export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, type BuildEnrichPlanOptions, type AcquireDiscoveryCheckpoint, type EnrichAmbiguity, type EnrichConfig, type EnrichCounts, type EnrichFieldConfig, type EnrichMatchConfig, type EnrichMode, type EnrichObjectType, type EnrichPlanResult, type EnrichRun, type EnrichRunStore, type EnrichSourceConfig, type EnrichSourceRecord, type EnrichStamp, type EnrichWorkItem, type MatchOutcome, } from "./enrich.ts";
+export { readHostedAcquireCheckpoint, writeHostedAcquireCheckpoint, type HostedAcquireCheckpoint, type HostedCheckpointReadResult, type HostedCheckpointWriteResult, } from "./hostedAcquireCheckpoint.ts";
+export { claimHostedPlanApply, hostedPlanDigest, hostedReviewDocument, readHostedPatchPlan, reconcileHostedPatchPlan, releaseHostedPlanApply, reportHostedPlanLifecycle, uploadHostedPatchPlan } from "./hostedPatchPlan.ts";
 export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, type InitProvider, type InitSource, type ScaffoldFile, type ScaffoldOptions, } from "./init.ts";
 export { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, type AccountTamClass, type AcvBasis, type DerivedAcv, type DerivedBuyers, type EstimateTamInput, type TamClassified, type TamCoverage, type TamCoverageCounts, type TamCrossCheck, type TamEta, type TamModel, type TamTargeting, type TamUniverse, } from "./tam.ts";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, type ApolloClient, type ApolloClientOptions, type ApolloPullKey, type ApolloPullResult, } from "./enrichApollo.ts";
@@ -53,3 +56,4 @@ export { scoreBand, judgeRunId, normalizeSpan, isGroundedSpan, scoreAccount, acc
 export { draft, authorOpeners, draftOpenerLlm, deterministicOpener, creditedTriggerSignal, draftEvidence, sanitizeOpener, firstLine, firstLineGroundedInTrigger, hasBannedGreeting, isStaleTrigger, draftOperationId, draftEvidenceId, DRAFT_CHANNELS, DRAFT_SCHEMA, DEFAULT_DRAFT_PROMPT, DEFAULT_FRESHNESS_DAYS, type Draft, type RejectedDraft, type DraftResult, type DraftChannel, } from "./draft.ts";
 export { DEFAULT_GOLDEN_SET, DEFAULT_MIN_ACCURACY, HOT_SCORE, defaultJudgeFn, gradeAgainstOutcomes, gradeJudge, parseGoldenSet, type Confusion, type EvalJudgeFn, type GoldenHistory, type GoldenRow, type GradeResult, type OutcomeCalibration, } from "./judgeEval.ts";
 export type { ApprovalStatus, AuditFinding, AuditFindingSeverity, CanonicalAccount, CanonicalActivity, CanonicalContact, CanonicalDeal, CanonicalGtmSnapshot, CanonicalUser, CrmProvider, GtmAuditRule, GtmConnector, GtmEvidence, GtmEvidenceSourceSystem, GtmObjectType, GtmPolicy, GtmRuleContext, GtmRuleResult, GtmSnapshotIndex, PatchOperation, PatchOperationResult, PatchOperationType, PatchPlan, PatchPlanAssumption, PatchPlanAssumptionConfidence, PatchPlanRun, PatchPlanRunStatus, PatchVerification, PipelineFinding, PipelineFindingStatus, PipelineFindingType, ProviderIdentity, RiskLevel, SourceFreshness, } from "./types.ts";
+export { ProviderHttpError } from "./providerError.ts";

package/dist/index.js

@@ -1,4 +1,5 @@
 export { auditSnapshot, defaultPolicy } from "./audit.js";
+export { acquireCheckpointId, acquireCheckpointsDir, createFileAcquireCheckpointStore, validateAcquireCheckpoint, validateAcquireCheckpointKey, } from "./acquireCheckpoint.js";
 export { matchesTerritory, parseAssignmentPolicy, resolveAssignment, } from "./assign.js";
 export { buildBulkUpdatePlan, isFilterableField, parseWhere } from "./bulkUpdate.js";
 export { buildDedupePlan, dedupeKey } from "./dedupe.js";
@@ -6,18 +7,20 @@ export { buildReassignPlans } from "./reassign.js";
 export { buildLeadRoutePlan, } from "./route.js";
 export { accountHierarchyToMarkdown, buildAccountHierarchy, } from "./hierarchy.js";
 export { buildRelationshipMap, relationshipMapToMarkdown, } from "./relationships.js";
-export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, } from "./config.js";
+export { CONFIG_FILE_NAME, loadConfig, mergePolicy, resolveConfiguredRules, rulePackageTrustFromCli, } from "./config.js";
 export { applyPatchPlan } from "./connector.js";
 export { APPLY_STAGES, BACKFILL_STRIPE_STAGES, composeListeners, createProgressEmitter, CRM_SYNC_STAGES, nullProgressEmitter, SNAPSHOT_PULL_STAGES, STRIPE_SNAPSHOT_STAGES, } from "./progress.js";
 export { createHubspotConnector } from "./connectors/hubspot.js";
 export { DEFAULT_LOOPBACK_PORT, DEFAULT_OAUTH_SCOPES, exchangeHubspotCode, refreshHubspotToken, runHubspotLoopbackLogin, validateHubspotToken, } from "./connectors/hubspotAuth.js";
 export { createSalesforceConnector, } from "./connectors/salesforce.js";
-export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceToken, } from "./connectors/salesforceAuth.js";
+export { pollSalesforceDeviceLogin, refreshSalesforceToken, startSalesforceDeviceLogin, validateSalesforceOrigin, validateSalesforceToken, } from "./connectors/salesforceAuth.js";
 export { createStripeConnector, fetchStripePaidInvoices, } from "./connectors/stripe.js";
 export { buildStripeBackfillPlan, DEFAULT_BACKFILL_MATCH_PROPERTY, } from "./backfill.js";
 export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, deleteCredential, getCredential, listProfiles, resolveHubspotAccessToken, resolveHubspotConnection, setActiveProfile, storeCredential, } from "./credentials.js";
 export { generateDemoSnapshot } from "./demo.js";
 export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, } from "./enrich.js";
+export { readHostedAcquireCheckpoint, writeHostedAcquireCheckpoint, } from "./hostedAcquireCheckpoint.js";
+export { claimHostedPlanApply, hostedPlanDigest, hostedReviewDocument, readHostedPatchPlan, reconcileHostedPatchPlan, releaseHostedPlanApply, reportHostedPlanLifecycle, uploadHostedPatchPlan } from "./hostedPatchPlan.js";
 export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, } from "./init.js";
 export { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, } from "./tam.js";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, } from "./enrichApollo.js";
@@ -52,3 +55,4 @@ export { fetchAtsJobs, snippetFor, } from "./connectors/atsBoards.js";
 export { scoreBand, judgeRunId, normalizeSpan, isGroundedSpan, scoreAccount, accountRecentlyTouched, bestContactForAccount, deterministicDecision, deterministicWhyNow, JUDGE_SCHEMA, DEFAULT_JUDGE_PROMPT, judgeDecisionLlm, judgeSignals, judgeDir, createFileJudgeStore, } from "./judge.js";
 export { draft, authorOpeners, draftOpenerLlm, deterministicOpener, creditedTriggerSignal, draftEvidence, sanitizeOpener, firstLine, firstLineGroundedInTrigger, hasBannedGreeting, isStaleTrigger, draftOperationId, draftEvidenceId, DRAFT_CHANNELS, DRAFT_SCHEMA, DEFAULT_DRAFT_PROMPT, DEFAULT_FRESHNESS_DAYS, } from "./draft.js";
 export { DEFAULT_GOLDEN_SET, DEFAULT_MIN_ACCURACY, HOT_SCORE, defaultJudgeFn, gradeAgainstOutcomes, gradeJudge, parseGoldenSet, } from "./judgeEval.js";
+export { ProviderHttpError } from "./providerError.js";

package/dist/market.d.ts

@@ -1,5 +1,6 @@
 import { type ProgressEmitter } from "./progress.ts";
 import type { GtmEvidence } from "./types.ts";
+export { assertPublicUrl } from "./publicHttp.ts";
 /**
  * The Market Map: a live model of the competitive category a company sells
  * into. Vendors publish claims constantly (pricing pages, feature pages,
@@ -162,7 +163,6 @@ export type FetchPage = (url: string) => Promise<{
     status: number;
     body: string;
 }>;
-export declare function assertPublicUrl(rawUrl: string): Promise<URL>;
 export type CaptureOptions = {
     /** Directory for captures; defaults to <marketHome>/captures. Ignored when `store` is given. */
     dir?: string;

package/dist/market.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { lookup } from "node:dns/promises";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { isIP } from "node:net";
 import { join } from "node:path";
 import { credentialsDir } from "./credentials.js";
 import { MARKET_CAPTURE_STAGES, nullProgressEmitter } from "./progress.js";
+import { publicHttpGet } from "./publicHttp.js";
+export { assertPublicUrl } from "./publicHttp.js";
 const INTENSITY_RANK = {
     loud: 3,
     quiet: 2,
@@ -152,136 +152,16 @@ export function extractReadableText(html) {
  * any host that is or resolves to a private/loopback/link-local/metadata
  * address, and (3) follow redirects manually, re-validating each hop.
  *
- * Residual gap (documented, not defended here): TOCTOU DNS rebinding between
- * our lookup and fetch's own resolution. Out of scope for fetching public
- * competitor pages; a hardened deployment should fetch through an egress proxy.
+ * The default transport resolves once, rejects mixed public/private answers,
+ * and pins a validated address into socket creation to prevent DNS rebinding.
  */
 const MAX_REDIRECTS = 5;
 const FETCH_TIMEOUT_MS = 15_000;
 const MAX_BODY_BYTES = 5_000_000;
-function ipv4IsPrivate(ip) {
-    const parts = ip.split(".").map((n) => Number(n));
-    if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
-        return true;
-    const [a, b] = parts;
-    if (a === 0 || a === 127)
-        return true; // this-host, loopback
-    if (a === 10)
-        return true; // private
-    if (a === 172 && b >= 16 && b <= 31)
-        return true; // private
-    if (a === 192 && b === 168)
-        return true; // private
-    if (a === 169 && b === 254)
-        return true; // link-local incl. 169.254.169.254 metadata
-    if (a === 100 && b >= 64 && b <= 127)
-        return true; // CGNAT
-    if (a >= 224)
-        return true; // multicast / reserved
-    return false;
-}
-function ipIsPrivate(ip) {
-    const family = isIP(ip);
-    if (family === 4)
-        return ipv4IsPrivate(ip);
-    if (family === 6) {
-        const lower = ip.toLowerCase();
-        if (lower === "::1" || lower === "::")
-            return true; // loopback / unspecified
-        // IPv4-mapped (::ffff:…) — Node normalizes ::ffff:127.0.0.1 to ::ffff:7f00:1,
-        // so accept both the dotted and the hex-pair forms, unwrap, check the v4.
-        const mapped = lower.match(/^::ffff:(.+)$/);
-        if (mapped) {
-            const rest = mapped[1];
-            if (rest.includes("."))
-                return ipv4IsPrivate(rest);
-            const groups = rest.split(":");
-            if (groups.length === 2) {
-                const hi = parseInt(groups[0], 16);
-                const lo = parseInt(groups[1], 16);
-                if (Number.isNaN(hi) || Number.isNaN(lo))
-                    return true;
-                return ipv4IsPrivate(`${(hi >> 8) & 0xff}.${hi & 0xff}.${(lo >> 8) & 0xff}.${lo & 0xff}`);
-            }
-            return true; // unrecognized mapped form → refuse
-        }
-        if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb"))
-            return true; // link-local fe80::/10
-        if (lower.startsWith("fc") || lower.startsWith("fd"))
-            return true; // unique-local fc00::/7
-        return false;
-    }
-    return true; // not a recognizable IP literal → refuse
-}
-export async function assertPublicUrl(rawUrl) {
-    let url;
-    try {
-        url = new URL(rawUrl);
-    }
-    catch {
-        throw new Error(`market capture: "${rawUrl}" is not a valid URL.`);
-    }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error(`market capture refuses ${url.protocol} URLs (only http/https): ${rawUrl}`);
-    }
-    const host = url.hostname.replace(/^\[|\]$/g, ""); // strip IPv6 brackets
-    if (isIP(host)) {
-        if (ipIsPrivate(host))
-            throw new Error(`market capture refuses private/loopback address ${host} (SSRF guard).`);
-        return url;
-    }
-    // Hostname: resolve and refuse if ANY address is private.
-    const addrs = await lookup(host, { all: true });
-    for (const { address } of addrs) {
-        if (ipIsPrivate(address)) {
-            throw new Error(`market capture refuses ${host} — it resolves to private/internal address ${address} (SSRF guard).`);
-        }
-    }
-    return url;
-}
 const defaultFetchPage = async (url) => {
-    let current = url;
-    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
-        await assertPublicUrl(current);
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-        let response;
-        try {
-            response = await fetch(current, {
-                headers: {
-                    "User-Agent": "fullstackgtm-market/0 (+https://github.com/fullstackgtm/core)",
-                    "Accept-Language": "en-US",
-                },
-                redirect: "manual",
-                signal: controller.signal,
-            });
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        if (response.status >= 300 && response.status < 400 && response.headers.get("location")) {
-            current = new URL(response.headers.get("location"), current).toString();
-            continue; // re-validate the redirect target on the next iteration
-        }
-        const reader = response.body?.getReader();
-        if (!reader)
-            return { status: response.status, body: await response.text() };
-        const chunks = [];
-        let total = 0;
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            total += value.length;
-            if (total > MAX_BODY_BYTES) {
-                await reader.cancel();
-                break;
-            }
-            chunks.push(value);
-        }
-        return { status: response.status, body: Buffer.concat(chunks).toString("utf8") };
-    }
-    throw new Error(`market capture: too many redirects (>${MAX_REDIRECTS}) for ${url}`);
+    const response = await publicHttpGet(url, { maxBytes: MAX_BODY_BYTES, maxRedirects: MAX_REDIRECTS,
+        timeoutMs: FETCH_TIMEOUT_MS, headers: { "User-Agent": "fullstackgtm-market/0 (+https://github.com/fullstackgtm/core)", "Accept-Language": "en-US" } });
+    return { status: response.status, body: Buffer.from(response.body).toString("utf8") };
 };
 export async function captureMarket(config, options = {}) {
     const store = options.store ?? createFileMarketStore(config.category, { capturesDir: options.dir });

package/dist/marketClassify.d.ts

@@ -51,6 +51,16 @@ export type MarketWorksheet = {
         captureHash: string;
         text: string;
     }>;
+    /** Deterministic retrieval hints: page lines that contain claim terms. These are not labels. */
+    claimHints: Array<{
+        claimId: string;
+        matches: Array<{
+            url: string;
+            captureHash: string;
+            term: string;
+            quote: string;
+        }>;
+    }>;
     instructions: string;
 };
 export declare function buildWorksheet(config: MarketConfig, vendorId: string, options?: {

package/dist/marketClassify.js

@@ -188,6 +188,56 @@ export async function classifyMarket(config, options) {
         retriedVendorIds,
     };
 }
+const HINT_STOPWORDS = new Set([
+    "the", "and", "for", "with", "from", "that", "this", "into", "your", "you", "are", "but", "not", "when", "how", "use", "uses", "using",
+    "claim", "claims", "vendor", "vendors", "page", "pages", "loud", "quiet", "absent", "capability", "specific", "differentiating",
+    "unknown", "buyer", "buyers", "pricing", "structure", "category", "support", "supported", "primary", "secondary", "mentioned", "mentions",
+]);
+function normalizeHintText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
+}
+function claimHintTerms(claim) {
+    const exact = [claim.id.replace(/[-_]+/g, " "), claim.capability, ...(claim.terms ?? [])]
+        .map(normalizeHintText)
+        .filter((term) => term.length >= 3);
+    const tokenSource = normalizeHintText(`${claim.capability} ${claim.definition} ${(claim.terms ?? []).join(" ")}`)
+        .split(" ")
+        .filter((term) => term.length >= 4 && !HINT_STOPWORDS.has(term));
+    return Array.from(new Set([...exact, ...tokenSource])).slice(0, 24);
+}
+function lineSnippet(line, term) {
+    const clean = line.trim().replace(/\s+/g, " ");
+    if (clean.length <= 300)
+        return clean;
+    const lower = clean.toLowerCase();
+    const idx = lower.indexOf(term.toLowerCase().split(" ")[0] ?? "");
+    const start = Math.max(0, idx < 0 ? 0 : idx - 120);
+    return clean.slice(start, start + 300).trim();
+}
+function buildClaimHints(claims, pages) {
+    return claims.map((claim) => {
+        const terms = claimHintTerms(claim);
+        const matches = [];
+        for (const page of pages) {
+            const lines = page.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+            for (const term of terms) {
+                const normalizedTerm = normalizeHintText(term);
+                const line = lines.find((candidate) => normalizeHintText(candidate).includes(normalizedTerm));
+                if (!line)
+                    continue;
+                const quote = lineSnippet(line, term);
+                if (quote && !matches.some((m) => m.quote === quote && m.url === page.url)) {
+                    matches.push({ url: page.url, captureHash: page.captureHash, term, quote });
+                }
+                if (matches.length >= 4)
+                    break;
+            }
+            if (matches.length >= 4)
+                break;
+        }
+        return { claimId: claim.id, matches };
+    });
+}
 export function buildWorksheet(config, vendorId, options = {}) {
     const vendor = config.vendors.find((candidate) => candidate.id === vendorId);
     if (!vendor)
@@ -211,6 +261,7 @@ export function buildWorksheet(config, vendorId, options = {}) {
         vendor: { id: vendor.id, name: vendor.name },
         claims: config.claims,
         pages,
-        instructions: "Produce one observation per claim (intensity loud|quiet|absent from these pages only; unobservable only if a page you need failed to capture). Every loud/quiet reading must quote a verbatim span (≤300 chars) from a page's text, with that page's url and captureHash in evidence metadata. Submit as an ObservationSet via `market observe --from <file>` — quotes are mechanically verified against the captures.",
+        claimHints: buildClaimHints(config.claims, pages),
+        instructions: "Produce one observation per claim from these pages only. Intensity rubric: loud = hero copy, primary positioning, or a named/dedicated product area; quiet = supported by a verbatim page quote but secondary, qualified, or merely available; absent = the pages do not support the claim; unobservable = no usable captured page exists for this vendor, not a synonym for absent. claimHints are deterministic retrieval hints only: use them to find candidate support, but do not mark a claim loud/quiet unless the quote truly supports the claim. Every loud/quiet reading must quote a verbatim span (≤300 chars) from a page's text, with that page's url and captureHash in evidence metadata. Submit as an ObservationSet via `market observe --from <file>` — quotes are mechanically verified against the captures.",
     };
 }