fullstackgtm 0.47.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/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): GtmConnector;
+export declare function createHubspotConnector(options: HubspotConnectorOptions): HubspotWritableConnector;

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): GtmConnector;
+export declare function createSalesforceConnector(options: SalesforceConnectorOptions): SalesforceWritableConnector;

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;
 }

package/dist/format.js

@@ -1,8 +1,7 @@
-// `summary: true` renders only the header + the Findings-by-Rule table + an
-// operation count, for read verbs like `audit` where the full per-operation
-// dump (1,400+ lines on a real portal) buries the signal. Defaults to the full
-// view so write-preview callers (bulk-update, fix, dedupe, plans show, MCP) —
-// where you approve specific operations — keep every operation's detail.
+// `summary: true` renders the compact audit view: header, findings summary,
+// assumptions/open questions, and an operation count. Defaults to the full view
+// so write-preview callers (bulk-update, fix, dedupe, plans show, MCP) — where
+// you approve specific operations — keep every operation's detail.
 export function patchPlanToMarkdown(plan, opts = {}) {
     const lines = [
         `# ${plan.title}`,
@@ -25,6 +24,7 @@ export function patchPlanToMarkdown(plan, opts = {}) {
         });
         lines.push("");
     }
+    appendAssumptionsAndDecisionPoints(lines, plan);
     if (opts.summary) {
         const ops = plan.operations.length;
         lines.push(ops === 0
@@ -96,6 +96,32 @@ export function formatPatchPlanRun(run) {
     }
     return `${lines.join("\n")}\n`;
 }
+function appendAssumptionsAndDecisionPoints(lines, plan) {
+    const assumptions = [...(plan.assumptions ?? [])].sort((left, right) => {
+        if (left.confidence === "guess" && right.confidence !== "guess")
+            return -1;
+        if (left.confidence !== "guess" && right.confidence === "guess")
+            return 1;
+        return 0;
+    });
+    const openQuestions = plan.openQuestions ?? [];
+    if (assumptions.length === 0 && openQuestions.length === 0)
+        return;
+    lines.push("## Assumptions & decision points", "");
+    for (const assumption of assumptions) {
+        const warning = assumption.confidence === "guess" ? "⚠️ " : "";
+        lines.push(`- ${warning}${assumption.text}${assumption.source ? ` _(source: ${assumption.source})_` : ""}`);
+    }
+    if (openQuestions.length > 0) {
+        if (assumptions.length > 0)
+            lines.push("");
+        lines.push("### Open questions", "");
+        for (const question of openQuestions) {
+            lines.push(`- ${question}`);
+        }
+    }
+    lines.push("");
+}
 function formatValue(value) {
     if (value === undefined || value === null || value === "")
         return "unset";

package/dist/freeEmailDomains.d.ts

@@ -0,0 +1 @@
+export declare const FREE_EMAIL_DOMAINS: Set<string>;

package/dist/freeEmailDomains.js

@@ -0,0 +1,14 @@
+// Shared free-mail domains that should never be treated as company domains.
+export const FREE_EMAIL_DOMAINS = new Set([
+    "gmail.com",
+    "googlemail.com",
+    "yahoo.com",
+    "outlook.com",
+    "hotmail.com",
+    "live.com",
+    "icloud.com",
+    "me.com",
+    "aol.com",
+    "proton.me",
+    "protonmail.com",
+]);

package/dist/hierarchy.d.ts

@@ -0,0 +1,29 @@
+import type { CanonicalGtmSnapshot } from "./types.ts";
+export type AccountHierarchyNode = {
+    accountId: string;
+    name: string;
+    domain?: string;
+    parentAccountId?: string;
+    parentReason?: string;
+    children: AccountHierarchyNode[];
+};
+export type AccountHierarchyConflict = {
+    type: "duplicate_domain" | "ambiguous_parent" | "cycle";
+    accountIds: string[];
+    key: string;
+    detail: string;
+};
+export type AccountHierarchyReport = {
+    generatedAt: string;
+    roots: AccountHierarchyNode[];
+    orphanAccounts: string[];
+    conflicts: AccountHierarchyConflict[];
+    counts: {
+        accounts: number;
+        roots: number;
+        linkedChildren: number;
+        conflicts: number;
+    };
+};
+export declare function buildAccountHierarchy(snapshot: CanonicalGtmSnapshot): AccountHierarchyReport;
+export declare function accountHierarchyToMarkdown(report: AccountHierarchyReport): string;

package/dist/hierarchy.js

@@ -0,0 +1,164 @@
+import { normalizeDomain } from "./merge.js";
+function rawString(account, keys) {
+    if (!account.raw || typeof account.raw !== "object")
+        return undefined;
+    const raw = account.raw;
+    for (const key of keys) {
+        const value = raw[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+        if (value && typeof value === "object") {
+            const nested = value;
+            for (const nestedKey of ["id", "value", "name"]) {
+                if (typeof nested[nestedKey] === "string" && String(nested[nestedKey]).trim())
+                    return String(nested[nestedKey]).trim();
+            }
+        }
+    }
+    return undefined;
+}
+function parentHint(account) {
+    return rawString(account, ["parentAccountId", "parent_account_id", "ParentId", "parentCompanyId", "hs_parent_company_id"]);
+}
+function cloneNode(account) {
+    return { accountId: String(account.id), name: account.name, ...(account.domain ? { domain: account.domain } : {}), children: [] };
+}
+function looksLikePublicSuffix(domain) {
+    const parts = domain.split(".");
+    if (parts.length !== 2)
+        return false;
+    const [label, tld] = parts;
+    return tld.length === 2 && ["ac", "co", "com", "edu", "gov", "net", "org"].includes(label);
+}
+function domainParent(childDomain, domains) {
+    const parts = childDomain.split(".");
+    for (let i = 1; i < parts.length - 1; i++) {
+        const candidate = parts.slice(i).join(".");
+        if (candidate.split(".").length < 2 || looksLikePublicSuffix(candidate))
+            continue;
+        const unique = new Map((domains.get(candidate) ?? []).map((account) => [String(account.id), account]));
+        if (unique.size > 1)
+            return "ambiguous";
+        if (unique.size === 1)
+            return [...unique.values()][0];
+    }
+    return null;
+}
+function detectCycles(parentByChild) {
+    const cyclic = new Set();
+    const cycles = [];
+    const emitted = new Set();
+    for (const start of parentByChild.keys()) {
+        const path = [];
+        const indexById = new Map();
+        let cursor = start;
+        while (cursor && parentByChild.has(cursor)) {
+            const seenAt = indexById.get(cursor);
+            if (seenAt !== undefined) {
+                const cycle = path.slice(seenAt);
+                for (const id of cycle)
+                    cyclic.add(id);
+                const key = [...cycle].sort().join("|");
+                if (!emitted.has(key)) {
+                    emitted.add(key);
+                    cycles.push(cycle);
+                }
+                break;
+            }
+            indexById.set(cursor, path.length);
+            path.push(cursor);
+            cursor = parentByChild.get(cursor)?.parentId;
+        }
+    }
+    return { accountIds: cyclic, cycles };
+}
+export function buildAccountHierarchy(snapshot) {
+    const byId = new Map(snapshot.accounts.map((account) => [String(account.id), account]));
+    const accounts = [...byId.values()];
+    const domains = new Map();
+    for (const account of accounts) {
+        const domain = normalizeDomain(account.domain);
+        if (domain)
+            domains.set(domain, [...(domains.get(domain) ?? []), account]);
+    }
+    const conflicts = [];
+    for (const [domain, accounts] of domains) {
+        const ids = [...new Set(accounts.map((account) => String(account.id)))];
+        if (ids.length > 1)
+            conflicts.push({ type: "duplicate_domain", accountIds: ids.sort(), key: domain, detail: `${ids.length} accounts share domain ${domain}; hierarchy inference will not choose between them.` });
+    }
+    const nodes = new Map(accounts.map((account) => [String(account.id), cloneNode(account)]));
+    const parentByChild = new Map();
+    for (const account of accounts) {
+        const id = String(account.id);
+        const hint = parentHint(account);
+        if (hint && byId.has(hint) && hint !== id) {
+            parentByChild.set(id, { parentId: hint, reason: "provider-parent" });
+            continue;
+        }
+        const domain = normalizeDomain(account.domain);
+        if (!domain)
+            continue;
+        const inferred = domainParent(domain, domains);
+        if (inferred === "ambiguous")
+            conflicts.push({ type: "ambiguous_parent", accountIds: [id], key: domain, detail: `Multiple possible parent accounts found for ${domain}; leaving account as a root.` });
+        else if (inferred && String(inferred.id) !== id)
+            parentByChild.set(id, { parentId: String(inferred.id), reason: "domain-subdomain" });
+    }
+    const cyclicAccounts = detectCycles(parentByChild);
+    for (const cycle of cyclicAccounts.cycles) {
+        const ordered = [...cycle].sort();
+        const key = ordered.join(" -> ");
+        conflicts.push({
+            type: "cycle",
+            accountIds: ordered,
+            key,
+            detail: `Cyclic parent hints detected among ${ordered.join(", ")}; leaving those accounts as roots instead of hiding them in a loop.`,
+        });
+    }
+    for (const accountId of cyclicAccounts.accountIds)
+        parentByChild.delete(accountId);
+    const roots = [];
+    const orphanAccounts = [];
+    const linkedChildren = new Set();
+    for (const account of accounts) {
+        const id = String(account.id);
+        const node = nodes.get(id);
+        const parent = parentByChild.get(id);
+        if (parent && nodes.has(parent.parentId)) {
+            node.parentAccountId = parent.parentId;
+            node.parentReason = parent.reason;
+            nodes.get(parent.parentId).children.push(node);
+            linkedChildren.add(id);
+        }
+        else {
+            roots.push(node);
+            if (!account.domain && !parentHint(account))
+                orphanAccounts.push(id);
+        }
+    }
+    const sortTree = (list) => {
+        list.sort((a, b) => a.name.localeCompare(b.name) || a.accountId.localeCompare(b.accountId));
+        for (const node of list)
+            sortTree(node.children);
+    };
+    sortTree(roots);
+    return { generatedAt: snapshot.generatedAt, roots, orphanAccounts: orphanAccounts.sort(), conflicts, counts: { accounts: accounts.length, roots: roots.length, linkedChildren: linkedChildren.size, conflicts: conflicts.length } };
+}
+export function accountHierarchyToMarkdown(report) {
+    const lines = ["# Account hierarchy", "", `${report.counts.accounts} account(s), ${report.counts.roots} root(s), ${report.counts.linkedChildren} inferred child link(s), ${report.counts.conflicts} conflict(s).`, ""];
+    const walk = (nodes, depth) => {
+        for (const node of nodes) {
+            const suffix = [node.domain, node.parentReason ? `via ${node.parentReason}` : undefined].filter(Boolean).join("; ");
+            lines.push(`${"  ".repeat(depth)}- ${node.name} (${node.accountId}${suffix ? ` — ${suffix}` : ""})`);
+            walk(node.children, depth + 1);
+        }
+    };
+    walk(report.roots, 0);
+    if (report.conflicts.length) {
+        lines.push("", "## Conflicts");
+        for (const conflict of report.conflicts)
+            lines.push(`- ${conflict.type} ${conflict.key}: ${conflict.detail}`);
+    }
+    return lines.join("\n");
+}

package/dist/index.d.ts

@@ -3,6 +3,9 @@ export { matchesTerritory, parseAssignmentPolicy, resolveAssignment, type Assign
 export { buildBulkUpdatePlan, isFilterableField, parseWhere, type BulkUpdateOptions } from "./bulkUpdate.ts";
 export { buildDedupePlan, dedupeKey, type DedupeOptions } from "./dedupe.ts";
 export { buildReassignPlans, type ReassignObjectType, type ReassignOptions } from "./reassign.ts";
+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 { 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";
@@ -23,11 +26,12 @@ export { mergeSnapshots, type MergeConflict, type MergeMatch, type MergeReport,
 export { createFilePlanStore, type PlanStore, type StoredPlan } from "./planStore.ts";
 export { computeApprovalDigests, loadOrCreateSigningKey, loadSigningKey, signApproval, verifyApprovalDigests, type ApprovalVerification, } from "./integrity.ts";
 export { buildAuditLog, verifyAuditLog, type AuditLogEntry, type AuditLogExport, type AuditLogVerification, } from "./auditLog.ts";
+export { FREE_EMAIL_DOMAINS } from "./freeEmailDomains.ts";
 export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.ts";
 export { computeHealth, summarizeHealth, healthToMarkdown, type HealthEntry, type HealthRollup, type HealthRuleDelta, } from "./health.ts";
 export { auditReportToHtml, auditReportToMarkdown, type ReportOptions } from "./report.ts";
 export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, type CrmObjectType, type FieldMappings, } from "./mappings.ts";
-export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.ts";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, isFindingsOnlyRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.ts";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, type CallDealSuggestion, type CallInsightType, type ExtractedCallInsight, type ParsedCall, type ParsedTranscriptSegment, } from "./calls.ts";
 export { sampleSnapshot } from "./sampleData.ts";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, classifyCallLlm, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, type CallScorecard, type LlmCallClassification, type LlmCredential, type LlmExtractedInsight, type LlmProvider, type Rubric, type RubricDimension, type ScoreBand, type ScoredDimension, } from "./llm.ts";
@@ -48,4 +52,4 @@ export { fetchAtsJobs, snippetFor, type AtsBoardSource, type AtsJob, } from "./c
 export { scoreBand, judgeRunId, normalizeSpan, isGroundedSpan, scoreAccount, accountRecentlyTouched, bestContactForAccount, deterministicDecision, deterministicWhyNow, JUDGE_SCHEMA, DEFAULT_JUDGE_PROMPT, judgeDecisionLlm, judgeSignals, judgeDir, createFileJudgeStore, type JudgeDecisionKind, type JudgeDecision, type JudgeRun, type JudgeBand, type AccountScore, type JudgeStore, } from "./judge.ts";
 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, PatchPlanRun, PatchPlanRunStatus, PatchVerification, PipelineFinding, PipelineFindingStatus, PipelineFindingType, ProviderIdentity, RiskLevel, SourceFreshness, } from "./types.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";

package/dist/index.js

@@ -3,6 +3,9 @@ export { matchesTerritory, parseAssignmentPolicy, resolveAssignment, } from "./a
 export { buildBulkUpdatePlan, isFilterableField, parseWhere } from "./bulkUpdate.js";
 export { buildDedupePlan, dedupeKey } from "./dedupe.js";
 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 { 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";
@@ -23,11 +26,12 @@ export { mergeSnapshots, } from "./merge.js";
 export { createFilePlanStore } from "./planStore.js";
 export { computeApprovalDigests, loadOrCreateSigningKey, loadSigningKey, signApproval, verifyApprovalDigests, } from "./integrity.js";
 export { buildAuditLog, verifyAuditLog, } from "./auditLog.js";
+export { FREE_EMAIL_DOMAINS } from "./freeEmailDomains.js";
 export { formatPatchPlanRun, patchPlanToMarkdown } from "./format.js";
 export { computeHealth, summarizeHealth, healthToMarkdown, } from "./health.js";
 export { auditReportToHtml, auditReportToMarkdown } from "./report.js";
 export { HUBSPOT_DEFAULT_FIELD_MAPPINGS, SALESFORCE_DEFAULT_FIELD_MAPPINGS, mappedField, mappedFields, normalizeFieldMappings, readMappedValue, } from "./mappings.js";
-export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.js";
+export { accountSingleSourceRule, activeDealAccountWithoutContactsRule, auditFindingId, buildSnapshotIndex, builtinAuditRules, closingSoonInactiveRule, isFindingsOnlyRule, duplicateAccountDomainRule, duplicateContactEmailRule, duplicateOpenDealRule, missingDealAccountRule, missingDealAmountRule, missingDealOwnerRule, orphanAccountRule, pastCloseDateRule, patchOperationId, provenanceSummary, requiresHumanInput, staleDealRule, } from "./rules.js";
 export { extractCallInsights, normalizeTranscript, parseCall, parseTranscript, suggestCallDeal, summarizeInsights, } from "./calls.js";
 export { sampleSnapshot } from "./sampleData.js";
 export { DEFAULT_MODELS, DEFAULT_RUBRIC, classifyCallLlm, detectProviderFromKey, extractInsightsLlm, forcedToolCall, parseRubric, resolveLlmCredential, scoreCallLlm, validateLlmKey, } from "./llm.js";

package/dist/mcp.js

@@ -129,6 +129,9 @@ function packageVersion() {
         return "0.0.0";
     }
 }
+function strictSchema(shape) {
+    return z.object(shape).strict();
+}
 // Single registration table. startMcpServer() registers exactly this list,
 // and fullstackgtm_capabilities reports its names from the same array — the
 // advertised inventory cannot drift from what is actually registered.
@@ -143,7 +146,7 @@ const toolDefinitions = [
             description: "Run a dry-run GTM hygiene audit and return a reviewable patch plan. " +
                 "Sources: the realistic zero-credential demo CRM (provider: \"demo\" — richest test data), " +
                 "the minimal sample dataset, a snapshot file, or a live provider.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 provider: z.enum(["sample", "demo", "hubspot", "salesforce", "stripe"]).optional(),
                 inputPath: z.string().optional(),
                 configPath: z.string().optional(),
@@ -151,7 +154,7 @@ const toolDefinitions = [
                 output: z.enum(["json", "markdown"]).optional(),
                 today: z.string().optional(),
                 staleDealDays: z.number().int().positive().optional(),
-            },
+            }),
         },
         handler: async ({ provider, inputPath, configPath, rules, output, today, staleDealDays }) => {
             const loaded = configPath ? loadConfig(configPath) : null;
@@ -176,11 +179,11 @@ const toolDefinitions = [
             description: "Derive values for a plan's requires_human_* placeholder operations from snapshot " +
                 "evidence (account-name matching, contact associations), with confidence levels and " +
                 "reasons. Read-only; feed accepted values into fullstackgtm_apply's valueOverrides.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 planPath: z.string(),
                 provider: z.enum(["sample", "demo", "hubspot", "salesforce", "stripe"]).optional(),
                 inputPath: z.string().optional(),
-            },
+            }),
         },
         handler: async ({ planPath, provider, inputPath }) => {
             const plan = JSON.parse(readFileSync(resolve(process.cwd(), planPath), "utf8"));
@@ -198,14 +201,14 @@ const toolDefinitions = [
                 "uses LLM extraction when an Anthropic/OpenAI key is configured in the server " +
                 "environment or credential store, else the free deterministic keyword baseline; " +
                 "'llm' and 'deterministic' force either. Read-only; every insight is provenance-marked.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 transcript: z.string().optional(),
                 transcriptPath: z.string().optional(),
                 title: z.string().optional(),
                 source: z.enum(["gong", "chorus", "fathom", "manual", "csv", "unknown"]).optional(),
                 extractor: z.enum(["auto", "llm", "deterministic"]).optional(),
                 model: z.string().optional(),
-            },
+            }),
         },
         handler: async ({ transcript, transcriptPath, title, source, extractor, model }) => {
             const raw = transcript ??
@@ -238,7 +241,7 @@ const toolDefinitions = [
                 "(exists | ambiguous | safe_to_create) with matches and a reason, using the same " +
                 "identity keys as the audit/merge engines (account domain, contact email, open-deal " +
                 "key). Read-only. Never create on 'exists' or 'ambiguous'.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 objectType: z.enum(["account", "contact", "deal"]),
                 name: z.string().optional(),
                 domain: z.string().optional(),
@@ -246,7 +249,7 @@ const toolDefinitions = [
                 accountId: z.string().optional(),
                 provider: z.enum(["sample", "demo", "hubspot", "salesforce", "stripe"]).optional(),
                 inputPath: z.string().optional(),
-            },
+            }),
         },
         handler: async ({ objectType, name, domain, email, accountId, provider, inputPath }) => {
             const snapshot = await readSnapshot(provider, inputPath);
@@ -259,7 +262,7 @@ const toolDefinitions = [
         config: {
             title: "List Audit Rules",
             description: "List the built-in deterministic audit rules with ids and descriptions.",
-            inputSchema: {},
+            inputSchema: strictSchema({}),
         },
         handler: async () => {
             return content(builtinAuditRules.map(({ id, title, description }) => ({ id, title, description })));
@@ -277,13 +280,13 @@ const toolDefinitions = [
                 "the store's HMAC approval digests — ids not approved with `plans approve` are " +
                 "refused — and the run is recorded onto the stored plan so `plans show` and " +
                 "`audit-log export` include it.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 provider: z.enum(["hubspot", "salesforce"]),
                 planPath: z.string(),
                 approvedOperationIds: z.array(z.string()).min(1),
                 valueOverrides: z.record(z.string(), z.string()).optional(),
                 output: z.enum(["json", "markdown"]).optional(),
-            },
+            }),
         },
         handler: async ({ provider, planPath, approvedOperationIds, valueOverrides, output }) => {
             // The file may be a raw PatchPlan (audit --out) or a StoredPlan envelope
@@ -400,11 +403,11 @@ const toolDefinitions = [
                 "and quote verbatim spans (≤300 chars) for every loud/quiet reading. Submit the full " +
                 "ObservationSet via fullstackgtm_market_observe — quotes are verified character-for-" +
                 "character against the captures, so never paraphrase.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 vendorId: z.string(),
                 configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
                 captureRun: z.string().optional(),
-            },
+            }),
         },
         handler: async ({ vendorId, configPath, captureRun }) => {
             const config = loadMarketConfigOrHint(resolve(process.cwd(), configPath ?? "market.config.json"));
@@ -420,10 +423,10 @@ const toolDefinitions = [
                 "Validates coverage, the verbatim-evidence rule, and mechanically verifies every quoted " +
                 "span against the stored capture it cites. Returns problems if rejected; nothing is " +
                 "stored unless the whole set passes. Observations are append-only — use a new runLabel.",
-            inputSchema: {
+            inputSchema: strictSchema({
                 observationsPath: z.string().describe("Path to the ObservationSet JSON file"),
                 configPath: z.string().optional().describe("Path to market.config.json (default ./market.config.json)"),
-            },
+            }),
         },
         handler: async ({ observationsPath, configPath }) => {
             const config = loadMarketConfigOrHint(resolve(process.cwd(), configPath ?? "market.config.json"));
@@ -454,6 +457,7 @@ toolDefinitions.unshift({
         description: "Machine-readable contract for this MCP server: the tool inventory (derived from the " +
             "server's own registration table, with per-tool CRM-write flags), safety defaults, and " +
             "the CLI entrypoints for everything the tools don't cover.",
+        inputSchema: strictSchema({}),
     },
     handler: async () => content({
         ok: true,