fullstackgtm 0.46.0 → 0.48.0

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,

package/dist/relationships.d.ts

@@ -0,0 +1,39 @@
+import type { CanonicalGtmSnapshot } from "./types.ts";
+export type StakeholderRole = "economic_buyer" | "decision_maker" | "technical_buyer" | "champion" | "influencer" | "unknown";
+export type StakeholderSentiment = "positive" | "neutral" | "negative" | "unknown";
+export type StakeholderNode = {
+    contactId: string;
+    name: string;
+    title?: string;
+    email?: string;
+    role: StakeholderRole;
+    sentiment: StakeholderSentiment;
+    lastActivityAt?: string;
+    evidence: string[];
+};
+export type RelationshipMap = {
+    account: {
+        accountId: string;
+        name: string;
+        domain?: string;
+    };
+    stakeholders: StakeholderNode[];
+    openDeals: Array<{
+        dealId: string;
+        name: string;
+        stage?: string;
+        amount?: number;
+        ownerId?: string;
+    }>;
+    gaps: string[];
+    counts: {
+        stakeholders: number;
+        openDeals: number;
+        activities: number;
+    };
+};
+export declare function buildRelationshipMap(snapshot: CanonicalGtmSnapshot, selector: {
+    accountId?: string;
+    domain?: string;
+}): RelationshipMap;
+export declare function relationshipMapToMarkdown(map: RelationshipMap): string;

package/dist/relationships.js

@@ -0,0 +1,101 @@
+import { normalizeDomain } from "./merge.js";
+function fullName(contact) {
+    return [contact.firstName, contact.lastName].filter(Boolean).join(" ") || contact.email || contact.id;
+}
+function inferRole(title) {
+    const t = (title ?? "").toLowerCase();
+    if (/\b(cfo|ceo|coo|cro|chief|founder|owner|president)\b/.test(t))
+        return "economic_buyer";
+    if (/\b(vp|vice president|head of|director|gm|general manager)\b/.test(t))
+        return "decision_maker";
+    if (/\b(cto|cio|security|it|engineering|architect|developer|technical|data)\b/.test(t))
+        return "technical_buyer";
+    if (/\b(champion|revops|sales ops|revenue operations|operations)\b/.test(t))
+        return "champion";
+    if (t)
+        return "influencer";
+    return "unknown";
+}
+function inferSentiment(text) {
+    const lower = text.toLowerCase();
+    if (/\b(blocked|concern|risk|no budget|not interested|detractor|negative|unhappy)\b/.test(lower))
+        return "negative";
+    if (/\b(champion|excited|interested|positive|approved|referred|next step|pilot)\b/.test(lower))
+        return "positive";
+    return "neutral";
+}
+function maxSentiment(a, b) {
+    const rank = { unknown: 0, neutral: 1, positive: 2, negative: 3 };
+    return rank[b] > rank[a] ? b : a;
+}
+function findAccount(snapshot, selector) {
+    if (selector.accountId)
+        return snapshot.accounts.find((account) => String(account.id) === selector.accountId) ?? null;
+    if (selector.domain) {
+        const domain = normalizeDomain(selector.domain);
+        return snapshot.accounts.find((account) => normalizeDomain(account.domain) === domain) ?? null;
+    }
+    return null;
+}
+export function buildRelationshipMap(snapshot, selector) {
+    const account = findAccount(snapshot, selector);
+    if (!account)
+        throw new Error("relationships: account not found (use --account-id or --domain)");
+    const contacts = snapshot.contacts.filter((contact) => contact.accountId === account.id);
+    const contactIds = new Set(contacts.map((contact) => contact.id));
+    const activities = snapshot.activities.filter((activity) => activity.accountId === account.id || (activity.contactId ? contactIds.has(activity.contactId) : false));
+    const evidenceByContact = new Map();
+    const sentimentByContact = new Map();
+    for (const activity of activities) {
+        if (!activity.contactId || !contactIds.has(activity.contactId))
+            continue;
+        const text = [activity.subject, activity.type, activity.occurredAt].filter(Boolean).join(" — ");
+        evidenceByContact.set(activity.contactId, [...(evidenceByContact.get(activity.contactId) ?? []), text]);
+        sentimentByContact.set(activity.contactId, maxSentiment(sentimentByContact.get(activity.contactId) ?? "unknown", inferSentiment(text)));
+    }
+    const stakeholders = contacts.map((contact) => ({
+        contactId: String(contact.id),
+        name: fullName(contact),
+        ...(contact.title ? { title: contact.title } : {}),
+        ...(contact.email ? { email: contact.email } : {}),
+        role: inferRole(contact.title),
+        sentiment: sentimentByContact.get(contact.id) ?? "unknown",
+        ...(contact.lastActivityAt ? { lastActivityAt: contact.lastActivityAt } : {}),
+        evidence: evidenceByContact.get(contact.id) ?? [],
+    })).sort((a, b) => a.role.localeCompare(b.role) || a.name.localeCompare(b.name));
+    const openDeals = snapshot.deals.filter((deal) => deal.accountId === account.id && !deal.isClosed).map((deal) => ({
+        dealId: String(deal.id),
+        name: deal.name,
+        ...(deal.stage ? { stage: deal.stage } : {}),
+        ...(deal.amount !== undefined ? { amount: deal.amount } : {}),
+        ...(deal.ownerId ? { ownerId: deal.ownerId } : {}),
+    }));
+    const roles = new Set(stakeholders.map((s) => s.role));
+    const gaps = [];
+    if (!roles.has("economic_buyer"))
+        gaps.push("No obvious economic buyer found from titles.");
+    if (!roles.has("decision_maker"))
+        gaps.push("No obvious decision maker found from titles.");
+    if (stakeholders.every((s) => s.sentiment === "unknown"))
+        gaps.push("No stakeholder activity evidence attached to this account.");
+    return { account: { accountId: String(account.id), name: account.name, ...(account.domain ? { domain: account.domain } : {}) }, stakeholders, openDeals, gaps, counts: { stakeholders: stakeholders.length, openDeals: openDeals.length, activities: activities.length } };
+}
+export function relationshipMapToMarkdown(map) {
+    const lines = [`# Relationship map: ${map.account.name}`, "", `${map.counts.stakeholders} stakeholder(s), ${map.counts.openDeals} open deal(s), ${map.counts.activities} activity record(s).`, "", "## Stakeholders"];
+    for (const s of map.stakeholders) {
+        lines.push(`- ${s.name} — ${s.role}, ${s.sentiment}${s.title ? ` (${s.title})` : ""}`);
+        for (const evidence of s.evidence.slice(0, 3))
+            lines.push(`  - evidence: ${evidence}`);
+    }
+    if (map.openDeals.length) {
+        lines.push("", "## Open deals");
+        for (const deal of map.openDeals)
+            lines.push(`- ${deal.name} (${deal.dealId})${deal.stage ? ` — ${deal.stage}` : ""}${deal.amount !== undefined ? ` — ${deal.amount}` : ""}`);
+    }
+    if (map.gaps.length) {
+        lines.push("", "## Gaps");
+        for (const gap of map.gaps)
+            lines.push(`- ${gap}`);
+    }
+    return lines.join("\n");
+}

package/dist/route.d.ts

@@ -0,0 +1,46 @@
+import { type AssignmentPolicy } from "./assign.ts";
+import type { CanonicalGtmSnapshot, PatchPlan } from "./types.ts";
+/**
+ * Lead-to-account matching and routing recipes.
+ *
+ * This is the first packaged Traction-Complete-style workflow in the OSS CLI:
+ * take ownerless/unmatched leads, deterministically match them to accounts, and
+ * emit normal approval-gated patch operations. No writes happen here.
+ */
+export type LeadRouteOptions = {
+    /** Match contact email domains to account domains. Default true. */
+    matchByDomain?: boolean;
+    /** Also try raw company/name fields against account names when domain misses. */
+    matchByCompanyName?: boolean;
+    /** When an ownerless contact matches an owned account, set contact ownerId to the account owner. Default true. */
+    inheritAccountOwner?: boolean;
+    /** Reassign contacts that already have an owner when the matched account owner differs. Default false. */
+    reassignExistingOwner?: boolean;
+    /** Optional fallback policy for contacts that still do not have an owner. */
+    assignmentPolicy?: AssignmentPolicy;
+    /** Refuse to build larger plans unless explicitly raised. Default 500. */
+    maxOperations?: number;
+    reason?: string;
+};
+export type LeadRouteCounts = {
+    contactsScanned: number;
+    /** Contacts that ended with an unambiguous account context (existing link, domain match, or company-name match). */
+    matchedContacts: number;
+    matchedExistingAccount: number;
+    matchedByDomain: number;
+    matchedByCompanyName: number;
+    ambiguousAccountMatches: number;
+    skippedFreeEmail: number;
+    linkOperations: number;
+    /** Owner set_field operations proposed (account-owner inheritance + policy fallback). */
+    ownerOperations: number;
+    /** Alias for ownerOperations, named for reports that talk about owner-assigned leads. */
+    ownerAssigned: number;
+    policyAssigned: number;
+    unmatched: number;
+};
+export type LeadRouteResult = {
+    plan: PatchPlan;
+    counts: LeadRouteCounts;
+};
+export declare function buildLeadRoutePlan(snapshot: CanonicalGtmSnapshot, options?: LeadRouteOptions): LeadRouteResult;