@happyvertical/smrt-sales 0.39.2

package/dist/chunks/crm-DwEz7E2r.js

@@ -0,0 +1,1428 @@
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+import { TenantScoped, tenantId } from "@happyvertical/smrt-tenancy";
+//#region src/crm/models/Lead.ts
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$6(target, key, result);
+	return result;
+};
+var LEAD_STATUS_TRANSITIONS = {
+	new: [
+		"working",
+		"qualified",
+		"disqualified",
+		"merged"
+	],
+	working: [
+		"qualified",
+		"disqualified",
+		"merged"
+	],
+	qualified: ["merged"],
+	disqualified: ["working", "merged"],
+	merged: []
+};
+var loadedLeadStatus = /* @__PURE__ */ new WeakMap();
+var Lead = class extends SmrtObject {
+	tenantId = null;
+	name = "";
+	/** Primary human contact name. */
+	contactName = "";
+	/** Primary contact email. */
+	email = "";
+	/** Primary contact phone. */
+	phone = "";
+	/** Prospect organization/company name. */
+	organizationName = "";
+	profileId = "";
+	ownerRepId = "";
+	/** Lifecycle status; transitions are save-guarded (see module map). */
+	status = "new";
+	/**
+	* Generic acquisition-source kind (open string): `'campaign'`,
+	* `'referral'`, `'import'`, `'web_form'`, … CRM stores the pointer without
+	* interpreting it — referral attribution lives in the referrals module.
+	*/
+	sourceKind = "";
+	/** Identifier within the `sourceKind` namespace. */
+	sourceId = "";
+	/**
+	* Preserved acquisition history as a JSON object string. Use
+	* {@link getAcquisitionContext}/{@link setAcquisitionContext}. Merges append
+	* the losing lead's context under a `mergedSources` array — both sides'
+	* histories survive.
+	*/
+	acquisitionContext = "{}";
+	/**
+	* Generic external intake-draft reference (open string) — e.g. the id of a
+	* form submission, imported CSV row, or referral intake draft that this
+	* lead was materialized from.
+	*/
+	intakeRef = "";
+	mergedIntoId = "";
+	/** When the lead was qualified into an opportunity. */
+	qualifiedAt = null;
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.contactName !== void 0) this.contactName = options.contactName;
+		if (options.email !== void 0) this.email = options.email;
+		if (options.phone !== void 0) this.phone = options.phone;
+		if (options.organizationName !== void 0) this.organizationName = options.organizationName;
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.ownerRepId !== void 0) this.ownerRepId = options.ownerRepId;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.sourceKind !== void 0) this.sourceKind = options.sourceKind;
+		if (options.sourceId !== void 0) this.sourceId = options.sourceId;
+		if (options.acquisitionContext !== void 0) this.acquisitionContext = options.acquisitionContext;
+		if (options.intakeRef !== void 0) this.intakeRef = options.intakeRef;
+		if (options.mergedIntoId !== void 0) this.mergedIntoId = options.mergedIntoId;
+		if (options.qualifiedAt !== void 0) this.qualifiedAt = options.qualifiedAt;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the lead has been folded into another lead (terminal). */
+	isMerged() {
+		return this.status === "merged";
+	}
+	/** Whether the lead has been qualified into an opportunity. */
+	isQualified() {
+		return this.status === "qualified";
+	}
+	/** Parse the acquisition-context JSON string; `{}` on malformed content. */
+	getAcquisitionContext() {
+		try {
+			const parsed = JSON.parse(this.acquisitionContext);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the acquisition-context object. */
+	setAcquisitionContext(context) {
+		this.acquisitionContext = JSON.stringify(context);
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+	/**
+	* Capture the status the row was loaded with so the save-time transition
+	* guard can reject illegal status flips made via raw field assignment
+	* (mass-assignment on the generated update route, a stale caller, etc.).
+	* Only persisted rows carry a prior status.
+	*/
+	async initialize() {
+		await super.initialize();
+		if (await this.isSaved()) loadedLeadStatus.set(this, this.status);
+		return this;
+	}
+	/**
+	* Validate the status transition before persisting, then save. A forged
+	* `status` (e.g. un-merging a merged lead) is rejected here regardless of
+	* how the instance was constructed.
+	*/
+	async save() {
+		const prior = await this.resolvePriorStatus();
+		this.assertLeadStatusTransition(prior);
+		const result = await super.save();
+		loadedLeadStatus.set(this, this.status);
+		return result;
+	}
+	/**
+	* Reject an illegal status flip done via raw assignment. No-op transitions
+	* and brand-new rows are always allowed.
+	*/
+	assertLeadStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(LEAD_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`Lead ${this.name || this.id}: illegal status transition '${prior}' \u2192 '${this.status}'.`);
+	}
+	/**
+	* Resolve the AUTHORITATIVE prior status (commerce Contract pattern). The
+	* WeakMap is only populated when {@link initialize} loaded the row from the
+	* DB; it is empty for an instance built via
+	* `collection.create({ id: <existing>, _skipLoad: true })` — the upsert
+	* path that writes onto an existing row without hydrating it. Trusting an
+	* empty WeakMap there would treat the write as a brand-new row and skip the
+	* guard entirely (a poisonable prior-state).
+	*
+	* So when this instance carries an `id`, read the persisted row straight
+	* from the database and treat its `status` as the prior. Only when no row
+	* exists (truly new) do we fall back to the WeakMap. The raw row's `status`
+	* column is single-word (no snake_case transform).
+	*/
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedLeadStatus.get(this);
+	}
+};
+__decorateClass$6([tenantId({ nullable: true })], Lead.prototype, "tenantId", 2);
+__decorateClass$6([field({ required: true })], Lead.prototype, "name", 2);
+__decorateClass$6([crossPackageRef("@happyvertical/smrt-profiles:Profile")], Lead.prototype, "profileId", 2);
+__decorateClass$6([foreignKey("SalesRepresentative")], Lead.prototype, "ownerRepId", 2);
+__decorateClass$6([foreignKey("Lead")], Lead.prototype, "mergedIntoId", 2);
+Lead = __decorateClass$6([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	cli: true
+})], Lead);
+//#endregion
+//#region src/crm/models/Opportunity.ts
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$5(target, key, result);
+	return result;
+};
+var OPPORTUNITY_STATUS_TRANSITIONS = {
+	open: ["won", "lost"],
+	won: [],
+	lost: []
+};
+var loadedOpportunityStatus = /* @__PURE__ */ new WeakMap();
+var Opportunity = class extends SmrtObject {
+	tenantId = null;
+	name = "";
+	leadId = "";
+	ownerRepId = "";
+	pipelineId = "";
+	stageId = "";
+	/** Expected deal value in integer cents (INTEGER column). */
+	expectedValueCents = 0;
+	/** ISO 4217 currency code for `expectedValueCents`. */
+	currency = "USD";
+	/**
+	* Win probability (`0`–`1`, DECIMAL). Adopted from the current stage's
+	* default on stage moves unless explicitly overridden.
+	*/
+	probability = 0;
+	/** Forecasted close date. */
+	expectedCloseAt = null;
+	/** Lifecycle status; `open → won|lost` is save-guarded, terminal after. */
+	status = "open";
+	/**
+	* Human-readable outcome note — conventionally the loss reason
+	* (`'budget cut'`) or a win annotation.
+	*/
+	outcomeReason = "";
+	/** When the deal closed as won. */
+	wonAt = null;
+	/** When the deal closed as lost. */
+	lostAt = null;
+	/**
+	* Acquisition source copied from the originating lead at qualification
+	* time (open string), kept denormalized for reporting.
+	*/
+	sourceKind = "";
+	/** Identifier within the `sourceKind` namespace (copied from the lead). */
+	sourceId = "";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.leadId !== void 0) this.leadId = options.leadId;
+		if (options.ownerRepId !== void 0) this.ownerRepId = options.ownerRepId;
+		if (options.pipelineId !== void 0) this.pipelineId = options.pipelineId;
+		if (options.stageId !== void 0) this.stageId = options.stageId;
+		if (options.expectedValueCents !== void 0) this.expectedValueCents = options.expectedValueCents;
+		if (options.currency !== void 0) this.currency = options.currency;
+		if (options.probability !== void 0) this.probability = options.probability;
+		if (options.expectedCloseAt !== void 0) this.expectedCloseAt = options.expectedCloseAt;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.outcomeReason !== void 0) this.outcomeReason = options.outcomeReason;
+		if (options.wonAt !== void 0) this.wonAt = options.wonAt;
+		if (options.lostAt !== void 0) this.lostAt = options.lostAt;
+		if (options.sourceKind !== void 0) this.sourceKind = options.sourceKind;
+		if (options.sourceId !== void 0) this.sourceId = options.sourceId;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the deal is still in play. */
+	isOpen() {
+		return this.status === "open";
+	}
+	/** Whether the deal closed (won or lost). */
+	isClosed() {
+		return this.status !== "open";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+	/**
+	* Capture the status the row was loaded with so the save-time transition
+	* guard can reject illegal status flips made via raw field assignment.
+	* Only persisted rows carry a prior status.
+	*/
+	async initialize() {
+		await super.initialize();
+		if (await this.isSaved()) loadedOpportunityStatus.set(this, this.status);
+		return this;
+	}
+	/**
+	* Validate the status transition before persisting, then save. A forged
+	* `status` (e.g. re-opening a lost deal) is rejected here regardless of
+	* how the instance was constructed.
+	*/
+	async save() {
+		const prior = await this.resolvePriorStatus();
+		this.assertOpportunityStatusTransition(prior);
+		const result = await super.save();
+		loadedOpportunityStatus.set(this, this.status);
+		return result;
+	}
+	/**
+	* Reject an illegal status flip done via raw assignment. No-op transitions
+	* and brand-new rows are always allowed.
+	*/
+	assertOpportunityStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(OPPORTUNITY_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`Opportunity ${this.name || this.id}: illegal status transition '${prior}' \u2192 '${this.status}'.`);
+	}
+	/**
+	* Resolve the AUTHORITATIVE prior status (commerce Contract pattern): when
+	* this instance carries an `id`, re-read the persisted row and use its
+	* `status` as the prior — a create-onto-existing is an update, and an
+	* un-hydrated instance must not bypass the guard. Falls back to the
+	* load-time WeakMap (empty for truly new rows → `undefined` = new).
+	*/
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedOpportunityStatus.get(this);
+	}
+};
+__decorateClass$5([tenantId({ nullable: true })], Opportunity.prototype, "tenantId", 2);
+__decorateClass$5([field({ required: true })], Opportunity.prototype, "name", 2);
+__decorateClass$5([foreignKey("Lead")], Opportunity.prototype, "leadId", 2);
+__decorateClass$5([foreignKey("SalesRepresentative")], Opportunity.prototype, "ownerRepId", 2);
+__decorateClass$5([foreignKey("PipelineDefinition")], Opportunity.prototype, "pipelineId", 2);
+__decorateClass$5([foreignKey("PipelineStage")], Opportunity.prototype, "stageId", 2);
+Opportunity = __decorateClass$5([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], Opportunity);
+//#endregion
+//#region src/crm/models/PipelineStage.ts
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$4(target, key, result);
+	return result;
+};
+var PipelineStage = class extends SmrtObject {
+	tenantId = null;
+	pipelineId = "";
+	key = "";
+	/** Human-readable stage name shown on board columns. */
+	name = "";
+	/** Ordering within the pipeline (ascending). Seeded in steps of 10. */
+	sortOrder = 0;
+	/**
+	* Default win probability (`0`–`1`, DECIMAL) adopted by an opportunity
+	* entering this stage unless the move overrides it.
+	*/
+	probability = 0;
+	/** Terminal flag: moving an opportunity here closes it as `won`. */
+	isWon = false;
+	/** Terminal flag: moving an opportunity here closes it as `lost`. */
+	isLost = false;
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.pipelineId !== void 0) this.pipelineId = options.pipelineId;
+		if (options.key !== void 0) this.key = options.key;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+		if (options.probability !== void 0) this.probability = options.probability;
+		if (options.isWon !== void 0) this.isWon = options.isWon;
+		if (options.isLost !== void 0) this.isLost = options.isLost;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether entering this stage closes the opportunity (won or lost). */
+	isTerminal() {
+		return this.isWon || this.isLost;
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass$4([tenantId({ nullable: true })], PipelineStage.prototype, "tenantId", 2);
+__decorateClass$4([foreignKey("PipelineDefinition", { required: true })], PipelineStage.prototype, "pipelineId", 2);
+__decorateClass$4([field({ required: true })], PipelineStage.prototype, "key", 2);
+PipelineStage = __decorateClass$4([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: false,
+	conflictColumns: ["pipeline_id", "key"]
+})], PipelineStage);
+//#endregion
+//#region src/crm/collections/PipelineStageCollection.ts
+var PipelineStageCollection = class extends SmrtCollection {
+	static _itemClass = PipelineStage;
+	/**
+	* List a pipeline's stages in board order.
+	*
+	* @param pipelineId - Owning PipelineDefinition id
+	* @returns Stages ordered by `sortOrder` ascending
+	*/
+	async findByPipeline(pipelineId) {
+		return await this.list({
+			where: { pipelineId },
+			orderBy: "sort_order ASC"
+		});
+	}
+	/**
+	* Find one stage by its natural key within a pipeline.
+	*
+	* @param pipelineId - Owning PipelineDefinition id
+	* @param key - Stage machine key (e.g. `'proposal'`)
+	* @returns The stage, or null when the key does not exist in the pipeline
+	*/
+	async findByKey(pipelineId, key) {
+		return (await this.list({
+			where: {
+				pipelineId,
+				key
+			},
+			limit: 1
+		}))[0] ?? null;
+	}
+};
+//#endregion
+//#region src/crm/models/SalesActivity.ts
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$3(target, key, result);
+	return result;
+};
+var SalesActivity = class extends SmrtObject {
+	tenantId = null;
+	/** Which model the activity attaches to: `'lead'` or `'opportunity'`. */
+	subjectKind = "lead";
+	subjectId = "";
+	/**
+	* Kind of activity — OPEN string so consumers can extend the vocabulary
+	* without schema changes. See `SALES_ACTIVITY_KINDS` for the recommended
+	* kinds (framework-written rows use `qualification`, `stage_change`,
+	* `merge`).
+	*/
+	activityKind = "note";
+	/** One-line human-readable description. */
+	summary = "";
+	/** Next-action due date — set for `task`-like activities. */
+	dueAt = null;
+	/** When the next action was completed; `null` while open. */
+	completedAt = null;
+	actorProfileId = "";
+	/**
+	* Free-form JSON object stored as a string (framework audit rows carry
+	* structured detail here, e.g. `stage_change` from/to ids or the full
+	* loser snapshot on `merge`). Use {@link getMetadata}/{@link setMetadata}.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.subjectKind !== void 0) this.subjectKind = options.subjectKind;
+		if (options.subjectId !== void 0) this.subjectId = options.subjectId;
+		if (options.activityKind !== void 0) this.activityKind = options.activityKind;
+		if (options.summary !== void 0) this.summary = options.summary;
+		if (options.dueAt !== void 0) this.dueAt = options.dueAt;
+		if (options.completedAt !== void 0) this.completedAt = options.completedAt;
+		if (options.actorProfileId !== void 0) this.actorProfileId = options.actorProfileId;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether this is an open next action (due date set, not completed). */
+	isOpenTask() {
+		return this.dueAt !== null && this.completedAt === null;
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass$3([tenantId({ nullable: true })], SalesActivity.prototype, "tenantId", 2);
+__decorateClass$3([field({ required: true })], SalesActivity.prototype, "subjectId", 2);
+__decorateClass$3([crossPackageRef("@happyvertical/smrt-profiles:Profile")], SalesActivity.prototype, "actorProfileId", 2);
+SalesActivity = __decorateClass$3([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"create",
+		"list",
+		"get"
+	] },
+	mcp: { include: ["list", "create"] },
+	cli: false
+})], SalesActivity);
+//#endregion
+//#region src/crm/collections/SalesActivityCollection.ts
+var SalesActivityCollection = class extends SmrtCollection {
+	static _itemClass = SalesActivity;
+	/**
+	* Full trail for one subject, oldest first (chronological reading order).
+	*
+	* @param subjectKind - `'lead'` or `'opportunity'`
+	* @param subjectId - Subject row id
+	*/
+	async findBySubject(subjectKind, subjectId) {
+		return await this.list({
+			where: {
+				subjectKind,
+				subjectId
+			},
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* Open next actions for one subject: activities with a due date
+	* (`dueAt` set) that have not been completed (`completedAt` null),
+	* soonest due first.
+	*
+	* @param subjectKind - `'lead'` or `'opportunity'`
+	* @param subjectId - Subject row id
+	*/
+	async findOpenTasks(subjectKind, subjectId) {
+		return await this.list({
+			where: {
+				subjectKind,
+				subjectId,
+				"dueAt !=": null,
+				completedAt: null
+			},
+			orderBy: "due_at ASC"
+		});
+	}
+};
+//#endregion
+//#region src/crm/collections/OpportunityCollection.ts
+var OpportunityCollection = class extends SmrtCollection {
+	static _itemClass = Opportunity;
+	stageCollectionPromise = null;
+	activityCollectionPromise = null;
+	/** Sibling stage collection sharing this collection's DB connection. */
+	async getStageCollection() {
+		if (!this.stageCollectionPromise) this.stageCollectionPromise = PipelineStageCollection.create({ db: this.db });
+		return this.stageCollectionPromise;
+	}
+	/** Sibling activity collection sharing this collection's DB connection. */
+	async getActivityCollection() {
+		if (!this.activityCollectionPromise) this.activityCollectionPromise = SalesActivityCollection.create({ db: this.db });
+		return this.activityCollectionPromise;
+	}
+	/**
+	* Opportunities originating from a given lead, oldest first (the first row
+	* is the one `LeadCollection.qualify()` treats as canonical).
+	*/
+	async findByLead(leadId) {
+		return await this.list({
+			where: { leadId },
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* Open (still in play) opportunities, optionally narrowed to one pipeline.
+	*/
+	async findOpen(pipelineId) {
+		return await this.list({
+			where: {
+				status: "open",
+				...pipelineId ? { pipelineId } : {}
+			},
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* Move an opportunity to another stage of ITS pipeline, with the full
+	* consequence set:
+	*
+	* - validates the target stage belongs to the opportunity's pipeline
+	*   (an opportunity created without a pipeline adopts the stage's);
+	* - adopts the stage's default `probability` unless
+	*   `probabilityOverride` is given;
+	* - terminal stages close the deal: `isWon` sets `status: 'won'` +
+	*   `wonAt`; `isLost` sets `status: 'lost'` + `lostAt` (record the loss
+	*   reason via `outcomeReason`);
+	* - writes a `stage_change` SalesActivity carrying from/to detail.
+	*
+	* Moves after a terminal status are rejected — a closed deal's history is
+	* settled; reopening is not supported (create a new opportunity instead).
+	*
+	* @returns The updated opportunity
+	*/
+	async moveToStage(params) {
+		const opportunity = await this.get({ id: params.opportunityId });
+		if (!opportunity) throw new Error(`OpportunityCollection.moveToStage: opportunity '${params.opportunityId}' not found`);
+		if (opportunity.status !== "open") throw new Error(`OpportunityCollection.moveToStage: opportunity '${params.opportunityId}' is '${opportunity.status}' \u2014 stage moves after a terminal status are not allowed`);
+		const stage = await (await this.getStageCollection()).get({ id: params.stageId });
+		if (!stage) throw new Error(`OpportunityCollection.moveToStage: stage '${params.stageId}' not found`);
+		if (opportunity.pipelineId && stage.pipelineId !== opportunity.pipelineId) throw new Error(`OpportunityCollection.moveToStage: stage '${stage.key || stage.id}' belongs to pipeline '${stage.pipelineId}', not the opportunity's pipeline '${opportunity.pipelineId}'`);
+		const fromStageId = opportunity.stageId;
+		const fromStatus = opportunity.status;
+		if (!opportunity.pipelineId) opportunity.pipelineId = stage.pipelineId;
+		opportunity.stageId = stage.id ?? "";
+		opportunity.probability = params.probabilityOverride ?? stage.probability;
+		if (params.outcomeReason !== void 0) opportunity.outcomeReason = params.outcomeReason;
+		if (stage.isWon) {
+			opportunity.status = "won";
+			opportunity.wonAt = params.now ?? /* @__PURE__ */ new Date();
+		} else if (stage.isLost) {
+			opportunity.status = "lost";
+			opportunity.lostAt = params.now ?? /* @__PURE__ */ new Date();
+		}
+		await opportunity.save();
+		await (await this.getActivityCollection()).create({
+			...opportunity.tenantId !== null ? { tenantId: opportunity.tenantId } : {},
+			subjectKind: "opportunity",
+			subjectId: opportunity.id ?? "",
+			activityKind: "stage_change",
+			summary: `Moved to stage '${stage.key}'`,
+			actorProfileId: params.actorProfileId ?? "",
+			metadata: JSON.stringify({
+				fromStageId,
+				toStageId: stage.id ?? "",
+				toStageKey: stage.key,
+				fromStatus,
+				toStatus: opportunity.status,
+				probability: opportunity.probability,
+				...params.outcomeReason !== void 0 ? { outcomeReason: params.outcomeReason } : {}
+			})
+		});
+		return opportunity;
+	}
+};
+//#endregion
+//#region src/crm/models/PipelineDefinition.ts
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$2(target, key, result);
+	return result;
+};
+var PipelineDefinition = class extends SmrtObject {
+	tenantId = null;
+	key = "";
+	/** Human-readable pipeline name shown on CRM surfaces. */
+	name = "";
+	/**
+	* Marks the tenant's default pipeline. Informational for pickers/UI; the
+	* seeded default pipeline sets it `true`.
+	*/
+	isDefault = false;
+	/** `active` pipelines accept new opportunities; `archived` are read-only history. */
+	status = "active";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.key !== void 0) this.key = options.key;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.isDefault !== void 0) this.isDefault = options.isDefault;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the pipeline accepts new opportunities. */
+	isActive() {
+		return this.status === "active";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass$2([tenantId({ nullable: true })], PipelineDefinition.prototype, "tenantId", 2);
+__decorateClass$2([field({ required: true })], PipelineDefinition.prototype, "key", 2);
+PipelineDefinition = __decorateClass$2([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true,
+	conflictColumns: ["tenant_id", "key"]
+})], PipelineDefinition);
+//#endregion
+//#region src/crm/types.ts
+var SALES_REPRESENTATIVE_STATUSES = [
+	"active",
+	"inactive",
+	"suspended"
+];
+var LEAD_STATUSES = [
+	"new",
+	"working",
+	"qualified",
+	"disqualified",
+	"merged"
+];
+var PIPELINE_STATUSES = ["active", "archived"];
+var OPPORTUNITY_STATUSES = [
+	"open",
+	"won",
+	"lost"
+];
+var SALES_ACTIVITY_SUBJECT_KINDS = ["lead", "opportunity"];
+var SALES_ACTIVITY_KINDS = [
+	"note",
+	"call",
+	"email",
+	"meeting",
+	"task",
+	"assignment",
+	"qualification",
+	"stage_change",
+	"merge",
+	"status_change"
+];
+var DEFAULT_PIPELINE_KEY = "default";
+var DEFAULT_PIPELINE_STAGES = [
+	{
+		key: "new",
+		name: "New",
+		probability: .1
+	},
+	{
+		key: "qualified",
+		name: "Qualified",
+		probability: .25
+	},
+	{
+		key: "discovery",
+		name: "Discovery",
+		probability: .4
+	},
+	{
+		key: "proposal",
+		name: "Proposal",
+		probability: .6
+	},
+	{
+		key: "negotiation",
+		name: "Negotiation",
+		probability: .8
+	},
+	{
+		key: "closed_won",
+		name: "Closed Won",
+		probability: 1,
+		isWon: true
+	},
+	{
+		key: "closed_lost",
+		name: "Closed Lost",
+		probability: 0,
+		isLost: true
+	}
+];
+//#endregion
+//#region src/crm/collections/PipelineDefinitionCollection.ts
+function requireId$1(value, what) {
+	if (!value) throw new Error(`PipelineDefinitionCollection: ${what} has no id`);
+	return value;
+}
+var PipelineDefinitionCollection = class extends SmrtCollection {
+	static _itemClass = PipelineDefinition;
+	stageCollectionPromise = null;
+	/** Sibling stage collection sharing this collection's DB connection. */
+	async getStageCollection() {
+		if (!this.stageCollectionPromise) this.stageCollectionPromise = PipelineStageCollection.create({ db: this.db });
+		return this.stageCollectionPromise;
+	}
+	/**
+	* Find one pipeline by its machine key (natural key within the tenant
+	* scope — ambient tenancy auto-filters the lookup).
+	*/
+	async findByKey(key) {
+		return (await this.list({
+			where: { key },
+			limit: 1
+		}))[0] ?? null;
+	}
+	/**
+	* Find the pipeline flagged `isDefault` (informational designation).
+	*/
+	async findDefault() {
+		return (await this.list({
+			where: { isDefault: true },
+			orderBy: "created_at ASC",
+			limit: 1
+		}))[0] ?? null;
+	}
+	/**
+	* A pipeline's stages in board order (`sortOrder` ascending).
+	*/
+	async getStages(pipelineId) {
+		return await (await this.getStageCollection()).findByPipeline(pipelineId);
+	}
+	/**
+	* Idempotently find-or-create the seeded default pipeline (key
+	* `'default'`, `isDefault: true`) and its 7 default stages:
+	* `new(0.1) → qualified(0.25) → discovery(0.4) → proposal(0.6) →
+	* negotiation(0.8) → closed_won(1.0, isWon) → closed_lost(0.0, isLost)`.
+	*
+	* Idempotency is per stage KEY: a second call creates nothing, and a
+	* partially-seeded pipeline (e.g. an interrupted first run) is healed by
+	* creating only the missing keys. Existing stages are never overwritten —
+	* renames, re-weights, reorders, and custom stages added via normal
+	* PipelineStage operations all survive re-runs.
+	*
+	* Tenancy: under an ambient `withTenant()` context the pipeline/stages
+	* auto-scope to that tenant; pass `tenantId` to seed for a specific tenant
+	* from a system/global context. Lookup is by natural key, so each tenant
+	* gets exactly one seeded default pipeline.
+	*
+	* @returns The pipeline plus ALL of its stages ordered by `sortOrder`
+	*   (including any custom stages added since seeding)
+	*/
+	async ensureDefaultPipeline(params = {}) {
+		const tenantScope = params.tenantId !== void 0 ? { tenantId: params.tenantId } : {};
+		let pipeline = (await this.list({
+			where: {
+				key: DEFAULT_PIPELINE_KEY,
+				...tenantScope
+			},
+			limit: 1
+		}))[0];
+		if (!pipeline) pipeline = await this.create({
+			...tenantScope,
+			key: DEFAULT_PIPELINE_KEY,
+			name: "Default Sales Pipeline",
+			isDefault: true,
+			status: "active"
+		});
+		const pipelineId = requireId$1(pipeline.id, "default pipeline");
+		const stagesCollection = await this.getStageCollection();
+		const existing = await stagesCollection.findByPipeline(pipelineId);
+		const existingKeys = new Set(existing.map((stage) => stage.key));
+		const stageTenantScope = pipeline.tenantId !== null ? { tenantId: pipeline.tenantId } : tenantScope;
+		for (const [index, seed] of DEFAULT_PIPELINE_STAGES.entries()) {
+			if (existingKeys.has(seed.key)) continue;
+			await stagesCollection.create({
+				...stageTenantScope,
+				pipelineId,
+				key: seed.key,
+				name: seed.name,
+				sortOrder: (index + 1) * 10,
+				probability: seed.probability,
+				isWon: seed.isWon ?? false,
+				isLost: seed.isLost ?? false
+			});
+		}
+		const stages = await stagesCollection.findByPipeline(pipelineId);
+		return {
+			pipeline,
+			stages
+		};
+	}
+};
+//#endregion
+//#region src/crm/collections/LeadCollection.ts
+var MERGE_FILL_CONTACT_FIELDS = [
+	"contactName",
+	"email",
+	"phone",
+	"organizationName"
+];
+function requireId(value, what) {
+	if (!value) throw new Error(`LeadCollection: ${what} has no id`);
+	return value;
+}
+var LeadCollection = class extends SmrtCollection {
+	static _itemClass = Lead;
+	opportunityCollectionPromise = null;
+	pipelineCollectionPromise = null;
+	activityCollectionPromise = null;
+	/** Sibling opportunity collection sharing this collection's DB connection. */
+	async getOpportunityCollection() {
+		if (!this.opportunityCollectionPromise) this.opportunityCollectionPromise = OpportunityCollection.create({ db: this.db });
+		return this.opportunityCollectionPromise;
+	}
+	/** Sibling pipeline collection sharing this collection's DB connection. */
+	async getPipelineCollection() {
+		if (!this.pipelineCollectionPromise) this.pipelineCollectionPromise = PipelineDefinitionCollection.create({ db: this.db });
+		return this.pipelineCollectionPromise;
+	}
+	/** Sibling activity collection sharing this collection's DB connection. */
+	async getActivityCollection() {
+		if (!this.activityCollectionPromise) this.activityCollectionPromise = SalesActivityCollection.create({ db: this.db });
+		return this.activityCollectionPromise;
+	}
+	/** Leads in a given lifecycle status, newest first. */
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/** Leads owned by a given sales rep, newest first. */
+	async findByOwner(ownerRepId) {
+		return await this.list({
+			where: { ownerRepId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Qualify a lead into an Opportunity.
+	*
+	* Transitions the lead to `qualified` (stamping `qualifiedAt` once) and
+	* creates an Opportunity at the FIRST stage of the target pipeline —
+	* `pipelineId` when given, otherwise the seeded default pipeline
+	* (`ensureDefaultPipeline()`). The opportunity adopts the first stage's
+	* probability, copies the lead's `sourceKind`/`sourceId` for reporting,
+	* and defaults its name/owner from the lead. A `qualification`
+	* SalesActivity is written on BOTH the lead and the opportunity.
+	*
+	* IDEMPOTENT: when the lead is already `qualified` and an opportunity
+	* exists for it, that opportunity is returned unchanged (no new rows, no
+	* new activities). A qualified lead with no opportunity (interrupted
+	* earlier run) is healed by creating the missing opportunity.
+	*
+	* Illegal source statuses are rejected by the lead's save-time transition
+	* guard (`disqualified`/`merged` leads cannot be qualified).
+	*
+	* @returns The (existing or newly created) opportunity
+	*/
+	async qualify(params) {
+		const lead = await this.get({ id: params.leadId });
+		if (!lead) throw new Error(`LeadCollection.qualify: lead '${params.leadId}' not found`);
+		const leadId = requireId(lead.id, `lead '${params.leadId}'`);
+		const opportunities = await this.getOpportunityCollection();
+		if (lead.status === "qualified") {
+			const existing = await opportunities.findByLead(leadId);
+			if (existing[0]) return existing[0];
+		}
+		const pipelines = await this.getPipelineCollection();
+		let pipeline;
+		let stages;
+		if (params.pipelineId) {
+			const found = await pipelines.get({ id: params.pipelineId });
+			if (!found) throw new Error(`LeadCollection.qualify: pipeline '${params.pipelineId}' not found`);
+			pipeline = found;
+			stages = await pipelines.getStages(requireId(pipeline.id, "pipeline"));
+		} else ({pipeline, stages} = await pipelines.ensureDefaultPipeline({ ...lead.tenantId !== null ? { tenantId: lead.tenantId } : {} }));
+		const firstStage = stages[0];
+		if (!firstStage) throw new Error(`LeadCollection.qualify: pipeline '${pipeline.key || pipeline.id}' has no stages`);
+		if (lead.status !== "qualified") {
+			lead.status = "qualified";
+			if (!lead.qualifiedAt) lead.qualifiedAt = params.now ?? /* @__PURE__ */ new Date();
+			await lead.save();
+		}
+		const opportunity = await opportunities.create({
+			...lead.tenantId !== null ? { tenantId: lead.tenantId } : {},
+			name: params.opportunityName ?? lead.name,
+			leadId,
+			ownerRepId: params.ownerRepId ?? lead.ownerRepId,
+			pipelineId: pipeline.id ?? "",
+			stageId: firstStage.id ?? "",
+			probability: firstStage.probability,
+			expectedValueCents: params.expectedValueCents ?? 0,
+			currency: params.currency ?? "USD",
+			expectedCloseAt: params.expectedCloseAt ?? null,
+			status: "open",
+			sourceKind: lead.sourceKind,
+			sourceId: lead.sourceId
+		});
+		const opportunityId = requireId(opportunity.id, "created opportunity");
+		const activities = await this.getActivityCollection();
+		const tenantScope = lead.tenantId !== null ? { tenantId: lead.tenantId } : {};
+		await activities.create({
+			...tenantScope,
+			subjectKind: "lead",
+			subjectId: leadId,
+			activityKind: "qualification",
+			summary: `Qualified into opportunity '${opportunity.name}'`,
+			metadata: JSON.stringify({
+				opportunityId,
+				pipelineId: pipeline.id ?? "",
+				stageId: firstStage.id ?? "",
+				stageKey: firstStage.key
+			})
+		});
+		await activities.create({
+			...tenantScope,
+			subjectKind: "opportunity",
+			subjectId: opportunityId,
+			activityKind: "qualification",
+			summary: `Created from qualified lead '${lead.name}'`,
+			metadata: JSON.stringify({
+				leadId,
+				pipelineId: pipeline.id ?? "",
+				stageId: firstStage.id ?? "",
+				stageKey: firstStage.key
+			})
+		});
+		return opportunity;
+	}
+	/**
+	* Audited duplicate merge: fold the `loserId` lead into the `winnerId`
+	* lead.
+	*
+	* Validations: the ids must differ, both leads must exist, the loser must
+	* not already be merged, the winner must not itself be merged (merge into
+	* the chain head instead), and the merge must not create a
+	* `mergedIntoId` cycle.
+	*
+	* Effects:
+	* - EMPTY winner contact fields (`contactName`/`email`/`phone`/
+	*   `organizationName`) are filled from the loser; non-empty winner data
+	*   is never overwritten;
+	* - the loser's acquisition context is appended into the winner's under a
+	*   `mergedSources` array (both histories preserved verbatim);
+	* - the loser becomes terminal: `status: 'merged'` +
+	*   `mergedIntoId: winnerId`;
+	* - a `merge` SalesActivity is written on BOTH leads, each carrying a full
+	*   pre-merge loser snapshot in metadata;
+	* - the loser's existing activities STAY attached to the loser (history
+	*   preserved in place) — read the combined trail via
+	*   {@link activitiesIncludingMerged}.
+	*/
+	async mergeLeads(params) {
+		const { winnerId, loserId } = params;
+		if (winnerId === loserId) throw new Error(`LeadCollection.mergeLeads: winner and loser must be distinct leads (got '${winnerId}' twice)`);
+		const winner = await this.get({ id: winnerId });
+		if (!winner) throw new Error(`LeadCollection.mergeLeads: winner lead '${winnerId}' not found`);
+		const loser = await this.get({ id: loserId });
+		if (!loser) throw new Error(`LeadCollection.mergeLeads: loser lead '${loserId}' not found`);
+		if (loser.status === "merged") throw new Error(`LeadCollection.mergeLeads: lead '${loserId}' is already merged into '${loser.mergedIntoId}'`);
+		if (winner.status === "merged") throw new Error(`LeadCollection.mergeLeads: winner lead '${winnerId}' has itself been merged into '${winner.mergedIntoId}' \u2014 merge into the chain head instead`);
+		const visited = /* @__PURE__ */ new Set([winnerId]);
+		let cursor = winner.mergedIntoId;
+		while (cursor) {
+			if (cursor === loserId) throw new Error(`LeadCollection.mergeLeads: merging '${loserId}' into '${winnerId}' would create a merge cycle`);
+			if (visited.has(cursor)) break;
+			visited.add(cursor);
+			cursor = (await this.get({ id: cursor }))?.mergedIntoId ?? "";
+		}
+		const loserSnapshot = loser.toJSON();
+		const filledFields = [];
+		for (const fieldName of MERGE_FILL_CONTACT_FIELDS) if (winner[fieldName] === "" && loser[fieldName] !== "") {
+			winner[fieldName] = loser[fieldName];
+			filledFields.push(fieldName);
+		}
+		const winnerContext = winner.getAcquisitionContext();
+		const priorSources = winnerContext.mergedSources;
+		const mergedSources = Array.isArray(priorSources) ? [...priorSources] : [];
+		mergedSources.push({
+			leadId: loserId,
+			mergedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			sourceKind: loser.sourceKind,
+			sourceId: loser.sourceId,
+			acquisitionContext: loser.getAcquisitionContext()
+		});
+		winner.setAcquisitionContext({
+			...winnerContext,
+			mergedSources
+		});
+		await winner.save();
+		loser.status = "merged";
+		loser.mergedIntoId = winnerId;
+		await loser.save();
+		const activities = await this.getActivityCollection();
+		const actorProfileId = params.actorProfileId ?? "";
+		const auditDetail = {
+			winnerId,
+			loserId,
+			reason: params.reason ?? "",
+			filledFields,
+			loserSnapshot
+		};
+		await activities.create({
+			...winner.tenantId !== null ? { tenantId: winner.tenantId } : {},
+			subjectKind: "lead",
+			subjectId: winnerId,
+			activityKind: "merge",
+			summary: `Merged duplicate lead '${loser.name}' into this lead`,
+			actorProfileId,
+			metadata: JSON.stringify({
+				...auditDetail,
+				direction: "absorbed"
+			})
+		});
+		await activities.create({
+			...loser.tenantId !== null ? { tenantId: loser.tenantId } : {},
+			subjectKind: "lead",
+			subjectId: loserId,
+			activityKind: "merge",
+			summary: `Merged into lead '${winner.name}'`,
+			actorProfileId,
+			metadata: JSON.stringify({
+				...auditDetail,
+				direction: "merged_away"
+			})
+		});
+		return {
+			winner,
+			loser
+		};
+	}
+	/**
+	* The lead's activity trail INCLUDING the trails of every lead merged into
+	* it, transitively (losers keep their own activities; this read
+	* re-assembles the full history across `mergedIntoId` chains).
+	*
+	* Traversal is breadth-first over merge children with a visited-set guard,
+	* so malformed cyclic data cannot loop. Results are in chronological
+	* order.
+	*/
+	async activitiesIncludingMerged(leadId) {
+		const visited = /* @__PURE__ */ new Set();
+		let frontier = [leadId];
+		while (frontier.length > 0) {
+			const batch = frontier.filter((id) => id && !visited.has(id));
+			if (batch.length === 0) break;
+			for (const id of batch) visited.add(id);
+			frontier = (await this.list({ where: { "mergedIntoId in": batch } })).map((child) => child.id ?? "").filter((id) => id !== "");
+		}
+		return await (await this.getActivityCollection()).list({
+			where: {
+				subjectKind: "lead",
+				"subjectId in": Array.from(visited)
+			},
+			orderBy: "created_at ASC"
+		});
+	}
+};
+//#endregion
+//#region src/crm/models/OpportunityConversion.ts
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+var OpportunityConversion = class extends SmrtObject {
+	tenantId = null;
+	opportunityId = "";
+	targetKind = "";
+	targetId = "";
+	/** Optional human-readable note about the conversion. */
+	note = "";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.opportunityId !== void 0) this.opportunityId = options.opportunityId;
+		if (options.targetKind !== void 0) this.targetKind = options.targetKind;
+		if (options.targetId !== void 0) this.targetId = options.targetId;
+		if (options.note !== void 0) this.note = options.note;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+	/**
+	* Save with the append-only guard: a fresh instance whose
+	* `(opportunityId, targetKind, targetId)` natural key already belongs to
+	* a DIFFERENT row is refused — the conflict-column upsert would replace
+	* the existing conversion link (note and id) without the won-opportunity
+	* validation. Idempotent linking goes through
+	* `OpportunityConversionCollection.recordConversion()`, which finds
+	* first and reports `{ created: false }`.
+	*/
+	async save() {
+		if (this.opportunityId && this.targetKind && this.targetId) try {
+			const res = await this.db.query(`SELECT id FROM ${this.tableName} WHERE opportunity_id = $1 AND target_kind = $2 AND target_id = $3`, this.opportunityId, this.targetKind, this.targetId);
+			if ((Array.isArray(res) ? res : res.rows ?? []).find((row) => row.id !== this.id)) throw new Error(`OpportunityConversion ${this.opportunityId}/${this.targetKind}/${this.targetId}: this conversion link already exists \u2014 conversion links are append-only. Use OpportunityConversionCollection.recordConversion() for idempotent linking.`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("append-only")) throw error;
+		}
+		return await super.save();
+	}
+};
+__decorateClass$1([tenantId({ nullable: true })], OpportunityConversion.prototype, "tenantId", 2);
+__decorateClass$1([foreignKey("Opportunity", { required: true })], OpportunityConversion.prototype, "opportunityId", 2);
+__decorateClass$1([field({ required: true })], OpportunityConversion.prototype, "targetKind", 2);
+__decorateClass$1([field({ required: true })], OpportunityConversion.prototype, "targetId", 2);
+OpportunityConversion = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: false,
+	conflictColumns: [
+		"opportunity_id",
+		"target_kind",
+		"target_id"
+	]
+})], OpportunityConversion);
+//#endregion
+//#region src/crm/collections/OpportunityConversionCollection.ts
+var OpportunityConversionCollection = class extends SmrtCollection {
+	static _itemClass = OpportunityConversion;
+	opportunityCollectionPromise = null;
+	/** Sibling opportunity collection sharing this collection's DB connection. */
+	async getOpportunityCollection() {
+		if (!this.opportunityCollectionPromise) this.opportunityCollectionPromise = OpportunityCollection.create({ db: this.db });
+		return this.opportunityCollectionPromise;
+	}
+	/** All conversion links recorded for one opportunity, oldest first. */
+	async findByOpportunity(opportunityId) {
+		return await this.list({
+			where: { opportunityId },
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* Record that a WON opportunity materialized into a downstream record,
+	* idempotently on the natural key `(opportunityId, targetKind, targetId)`.
+	*
+	* Preconditions: the opportunity must exist and its status must be `'won'`
+	* — conversions from open or lost deals are rejected with a clear error.
+	* CRM only records the link; creating the downstream record itself
+	* (client, project, contract, subscription, …) is the caller's job.
+	*
+	* @returns `{ conversion, created }` — `created: false` when the link
+	*   already existed (the existing row is returned untouched)
+	*/
+	async recordConversion(params) {
+		const opportunity = await (await this.getOpportunityCollection()).get({ id: params.opportunityId });
+		if (!opportunity) throw new Error(`OpportunityConversionCollection.recordConversion: opportunity '${params.opportunityId}' not found`);
+		if (opportunity.status !== "won") throw new Error(`OpportunityConversionCollection.recordConversion: opportunity '${params.opportunityId}' has status '${opportunity.status}' \u2014 conversions can only be recorded for won opportunities`);
+		const existing = await this.list({
+			where: {
+				opportunityId: params.opportunityId,
+				targetKind: params.targetKind,
+				targetId: params.targetId
+			},
+			limit: 1
+		});
+		if (existing[0]) return {
+			conversion: existing[0],
+			created: false
+		};
+		return {
+			conversion: await this.create({
+				...opportunity.tenantId !== null ? { tenantId: opportunity.tenantId } : {},
+				opportunityId: params.opportunityId,
+				targetKind: params.targetKind,
+				targetId: params.targetId,
+				note: params.note ?? ""
+			}),
+			created: true
+		};
+	}
+};
+//#endregion
+//#region src/crm/models/SalesRepresentative.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var SalesRepresentative = class extends SmrtObject {
+	tenantId = null;
+	profileId = "";
+	earnerId = "";
+	/** Role status — only `active` reps should receive new assignments. */
+	status = "active";
+	/** Job title shown on CRM surfaces (e.g. `'Account Executive'`). */
+	title = "";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.earnerId !== void 0) this.earnerId = options.earnerId;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.title !== void 0) this.title = options.title;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the rep may receive new lead/opportunity assignments. */
+	isActive() {
+		return this.status === "active";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass([tenantId({ nullable: true })], SalesRepresentative.prototype, "tenantId", 2);
+__decorateClass([crossPackageRef("@happyvertical/smrt-profiles:Profile")], SalesRepresentative.prototype, "profileId", 2);
+__decorateClass([foreignKey("Earner")], SalesRepresentative.prototype, "earnerId", 2);
+SalesRepresentative = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], SalesRepresentative);
+//#endregion
+//#region src/crm/collections/SalesRepresentativeCollection.ts
+var SalesRepresentativeCollection = class extends SmrtCollection {
+	static _itemClass = SalesRepresentative;
+	/**
+	* Find rep roles held by a given profile (a profile may hold the role in
+	* several tenants/contexts).
+	*
+	* @param profileId - smrt-profiles Profile id
+	* @returns Reps for that profile, newest first
+	*/
+	async findByProfile(profileId) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find all active reps (eligible for new lead/opportunity assignment).
+	*/
+	async findActive() {
+		return await this.list({
+			where: { status: "active" },
+			orderBy: "created_at DESC"
+		});
+	}
+};
+//#endregion
+export { Lead as S, SalesActivityCollection as _, LeadCollection as a, PipelineStage as b, DEFAULT_PIPELINE_STAGES as c, PIPELINE_STATUSES as d, SALES_ACTIVITY_KINDS as f, OpportunityCollection as g, PipelineDefinition as h, OpportunityConversion as i, LEAD_STATUSES as l, SALES_REPRESENTATIVE_STATUSES as m, SalesRepresentative as n, PipelineDefinitionCollection as o, SALES_ACTIVITY_SUBJECT_KINDS as p, OpportunityConversionCollection as r, DEFAULT_PIPELINE_KEY as s, SalesRepresentativeCollection as t, OPPORTUNITY_STATUSES as u, SalesActivity as v, Opportunity as x, PipelineStageCollection as y };
+
+//# sourceMappingURL=crm-DwEz7E2r.js.map