dxcomplete 0.2.1 → 0.2.2

package/dist/runtime/records.js

@@ -1,2092 +0,0 @@
-import { randomUUID } from "node:crypto";
-export const COLLECTION_NAMES = [
-    "workspaces",
-    "statements",
-    "journal_entries",
-    "environments",
-    "components",
-    "estimates",
-    "benefits",
-    "expectations",
-    "requirements",
-    "tasks",
-    "commitments",
-    "deferrals",
-    "changes",
-    "incidents",
-    "problems",
-    "maintenance_schedules",
-    "support_requests",
-    "value_realizations",
-    "decisions",
-    "risks"
-];
-export const LEGACY_COLLECTION_NAMES = [
-    "engagements",
-    "initiatives",
-    "service_charters",
-    "cost_baselines",
-    "cost_actuals",
-    "benefit_measurements"
-];
-export const DXCOMPLETE_TICKET_COLLECTION_NAME = "dxcomplete_tickets";
-export const LEGACY_INTAKE_COLLECTION_NAME = "intake_items";
-export const LEGACY_PRIVATE_COLLECTION_NAMES = [LEGACY_INTAKE_COLLECTION_NAME];
-export const INDEX_COLLECTION_NAMES = [...COLLECTION_NAMES, DXCOMPLETE_TICKET_COLLECTION_NAME];
-export const LINK_SCAN_COLLECTION_NAMES = [...COLLECTION_NAMES, ...LEGACY_COLLECTION_NAMES];
-export const READABLE_ID_SEQUENCES_COLLECTION = "readable_id_sequences";
-export const READABLE_ID_TYPE_CODES = {
-    statements: "STM",
-    journal_entries: "JRN",
-    environments: "ENV",
-    components: "CMP",
-    expectations: "EXP",
-    requirements: "REQ",
-    tasks: "TSK",
-    commitments: "CMT",
-    deferrals: "DFR",
-    decisions: "DEC",
-    changes: "CHG",
-    incidents: "INC",
-    problems: "PRB",
-    maintenance_schedules: "MNT",
-    support_requests: "SUP",
-    value_realizations: "VAL",
-    risks: "RSK",
-    estimates: "EST",
-    benefits: "BFT"
-};
-export const READABLE_ID_COLLECTION_NAMES = Object.keys(READABLE_ID_TYPE_CODES);
-export const RUNTIME_ACTOR_ID = "dxcomplete-runtime";
-const REVIEW_NOTE_RECORD_TYPES = ["expectations", "requirements"];
-const VERSIONED_RECORD_TYPES = [
-    "statements",
-    "environments",
-    "components",
-    "expectations",
-    "requirements",
-    "estimates",
-    "benefits",
-    "maintenance_schedules",
-    "value_realizations"
-];
-const VERSION_HISTORY_FIELD = "versionHistory";
-const CHANGE_MANAGED_FIELDS = [
-    "changePlan",
-    "executionSteps",
-    "rollbackPlan",
-    "riskImpact",
-    "changeType",
-    "impactGrade",
-    "emergencyImportance",
-    "emergencyImmediacy",
-    "emergencyRationaleGaps",
-    "plannedFor",
-    "events"
-];
-const COMMITMENT_MANAGED_FIELDS = ["commitmentStatement", "reservations"];
-const DEFERRAL_MANAGED_FIELDS = ["reason", "status", "conditions", "conditionEvents"];
-const ESTIMATE_MANAGED_FIELDS = ["lineItems", "rollup"];
-const BENEFITS_MANAGED_FIELDS = ["benefitItems", "rollup"];
-const ENVIRONMENT_MANAGED_FIELDS = ["name", "description"];
-const COMPONENT_MANAGED_FIELDS = [
-    "name",
-    "environmentId",
-    "kind",
-    "locator",
-    "identifiers",
-    "secretPointers",
-    "notes"
-];
-const MAINTENANCE_SCHEDULE_MANAGED_FIELDS = [
-    "name",
-    "kind",
-    "cadence",
-    "startDate",
-    "rationale",
-    "notes"
-];
-const SUPPORT_REQUEST_LEDGER_MANAGED_FIELDS = [
-    "reporter",
-    "kind",
-    "reportedExperience",
-    "entries",
-    "currentStatus",
-    "status"
-];
-const VALUE_REALIZATION_MANAGED_FIELDS = ["metrics"];
-const DECISION_LEDGER_MANAGED_FIELDS = [
-    "matter",
-    "entries",
-    "currentDecision",
-    "question",
-    "decision",
-    "decidedBy",
-    "rationale",
-    "argumentsConsidered",
-    "concerns",
-    "status"
-];
-const TASK_LEDGER_MANAGED_FIELDS = [
-    "description",
-    "assignee",
-    "assignor",
-    "entries",
-    "currentStatus",
-    "details",
-    "status"
-];
-const RISK_LEDGER_MANAGED_FIELDS = [
-    "topic",
-    "entries",
-    "currentStatus",
-    "currentAssessment",
-    "currentTreatment",
-    "likelihood",
-    "impact",
-    "mitigation"
-];
-const INCIDENT_LEDGER_MANAGED_FIELDS = [
-    "description",
-    "entries",
-    "currentStatus",
-    "currentSeverity",
-    "status",
-    "severity"
-];
-const PROBLEM_LEDGER_MANAGED_FIELDS = [
-    "description",
-    "entries",
-    "currentStatus",
-    "currentRootCause",
-    "status",
-    "rootCause"
-];
-const DECISION_INPUT_MANAGED_FIELDS = ["informedBy", "informedByIds", "inputRecords"];
-const JOURNAL_ENTRY_MANAGED_FIELDS = ["kind", "body", "tag", "covers", "coveredBySummaryId"];
-const JOURNAL_COMPACTION_THRESHOLD = 200;
-const VERSIONED_TYPED_FIELDS = {
-    statements: ["statement", "source"],
-    expectations: ["statement", "successRecognition", "approvalState", "approvedBy", "approvedAt", "source"],
-    requirements: ["statement", "acceptanceCriteria", "priority", "status"],
-    estimates: ["lineItems", "rollup"],
-    benefits: ["benefitItems", "rollup"],
-    environments: ["name", "description"],
-    components: ["name", "environmentId", "kind", "locator", "identifiers", "secretPointers", "notes"],
-    maintenance_schedules: ["name", "kind", "cadence", "startDate", "rationale", "notes"],
-    value_realizations: ["metrics"]
-};
-const RESERVED_RELATIONSHIP_FIELDS = {
-    changes: ["requirementId"],
-    commitments: ["requirementIds", "expectationIds", "deferralId"],
-    deferrals: ["requirementIds", "expectationIds"],
-    estimates: ["requirementIds", "expectationIds"],
-    benefits: ["requirementIds", "expectationIds"],
-    value_realizations: ["requirementIds", "expectationIds", "commitmentIds"],
-    expectations: ["statementId"],
-    requirements: ["expectationId"],
-    tasks: ["requirementId"]
-};
-const REMOVED_INITIATIVE_FIELD_RECORD_TYPES = [
-    "changes",
-    "estimates",
-    "benefits",
-    "expectations"
-];
-export function assertCollectionName(value) {
-    if (COLLECTION_NAMES.includes(value)) {
-        return value;
-    }
-    throw new Error(`Unsupported record type "${value}".`);
-}
-export async function createRecord(db, recordType, input, actorId) {
-    assertNoReservedRelationshipFields(recordType, input.fields);
-    if (input.allowManagedFields) {
-        assertNoReviewNotesField(recordType, input.fields);
-    }
-    else {
-        assertNoManagedField(recordType, input.fields);
-    }
-    const now = new Date().toISOString();
-    const workspaceId = workspaceIdForCreate(recordType, input.workspaceId);
-    if (workspaceId) {
-        await assertWorkspaceExists(db, workspaceId);
-    }
-    const record = {
-        _id: input.id ?? randomUUID(),
-        recordType,
-        ...(workspaceId ? { workspaceId } : {}),
-        title: input.title,
-        summary: input.summary,
-        fields: input.fields ?? {},
-        links: [],
-        createdAt: now,
-        createdBy: actorId,
-        updatedAt: now,
-        updatedBy: actorId
-    };
-    if (recordTypeSupportsReadableId(recordType)) {
-        const session = db.client.startSession();
-        try {
-            await session.withTransaction(async () => {
-                record.readableId = await allocateReadableId(db, recordType, workspaceId, actorId, now, session);
-                await db.collection(recordType).insertOne(record, { session });
-            });
-        }
-        finally {
-            await session.endSession();
-        }
-        return withDerivedRecordFields(db, record);
-    }
-    await db.collection(recordType).insertOne(record);
-    return withDerivedRecordFields(db, record);
-}
-export async function listRecords(db, recordType, limit, options = {}) {
-    const filter = {};
-    if (recordTypeRequiresWorkspace(recordType)) {
-        filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
-    }
-    if (!options.includeArchived) {
-        filter.archivedAt = { $exists: false };
-    }
-    const records = await db
-        .collection(recordType)
-        .find(filter)
-        .sort({ createdAt: -1 })
-        .limit(limit)
-        .toArray();
-    return Promise.all(records.map((record) => withDerivedRecordFields(db, record)));
-}
-export async function getRecord(db, recordType, id, options = {}) {
-    const filter = recordIdentityFilter(recordType, id);
-    if (recordTypeRequiresWorkspace(recordType) &&
-        !options.allowAnyWorkspace &&
-        isCurrentCollection(recordType)) {
-        filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
-    }
-    const record = await db.collection(recordType).findOne(filter);
-    return record ? withDerivedRecordFields(db, record) : null;
-}
-export async function listLinkedRecords(db, input) {
-    const source = await getRecord(db, input.recordType, input.id, { workspaceId: input.workspaceId });
-    if (!source) {
-        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
-    }
-    const direction = input.direction ?? "both";
-    const result = {
-        source,
-        outbound: [],
-        inbound: []
-    };
-    if (direction === "outbound" || direction === "both") {
-        for (const link of source.links.filter((link) => linkMatches(link, input.relationship))) {
-            const target = await getRecord(db, link.toType, link.toId, {
-                workspaceId: source.workspaceId,
-                allowAnyWorkspace: !source.workspaceId
-            });
-            if (!target ||
-                (!input.includeArchived && target.archivedAt) ||
-                !recordBelongsToWorkspace(target, source.workspaceId)) {
-                continue;
-            }
-            result.outbound.push({
-                edge: {
-                    fromType: source.recordType,
-                    fromId: source._id,
-                    ...link
-                },
-                record: target
-            });
-        }
-    }
-    if (direction === "inbound" || direction === "both") {
-        for (const collectionName of LINK_SCAN_COLLECTION_NAMES) {
-            const filter = {
-                links: {
-                    $elemMatch: {
-                        toType: input.recordType,
-                        toId: source._id,
-                        ...(input.relationship ? { relationship: input.relationship } : {})
-                    }
-                }
-            };
-            if (source.workspaceId && recordTypeRequiresWorkspace(collectionName)) {
-                filter.workspaceId = source.workspaceId;
-            }
-            if (!input.includeArchived) {
-                filter.archivedAt = { $exists: false };
-            }
-            const records = await db.collection(collectionName).find(filter).toArray();
-            for (const record of records) {
-                for (const link of record.links.filter((link) => link.toType === input.recordType &&
-                    link.toId === source._id &&
-                    linkMatches(link, input.relationship))) {
-                    result.inbound.push({
-                        edge: {
-                            fromType: record.recordType,
-                            fromId: record._id,
-                            ...link
-                        },
-                        record
-                    });
-                }
-            }
-        }
-    }
-    return result;
-}
-async function withDerivedRecordFields(db, record) {
-    if (record.recordType === "maintenance_schedules") {
-        return {
-            ...record,
-            derived: await deriveMaintenanceScheduleState(db, record)
-        };
-    }
-    if (record.recordType === "value_realizations") {
-        return {
-            ...record,
-            derived: deriveValueRealizationState(record)
-        };
-    }
-    return record;
-}
-async function deriveMaintenanceScheduleState(db, record) {
-    const cadence = parseMaintenanceCadence(record.fields.cadence);
-    const startDate = parseDateString(record.fields.startDate);
-    const occurrences = await findMaintenanceOccurrences(db, record);
-    const latestOccurrence = occurrences[0];
-    const latestOccurrenceAt = latestOccurrence?.occurredAt;
-    const basis = latestOccurrenceAt ?? startDate?.toISOString();
-    const nextDueAt = cadence && basis ? addMaintenanceCadence(new Date(basis), cadence).toISOString() : undefined;
-    return compactRuntimeObject({
-        occurrenceCount: occurrences.length,
-        latestOccurrence,
-        cadence: cadence ?? undefined,
-        startDate: startDate?.toISOString(),
-        nextDueAt,
-        overdue: nextDueAt ? new Date() > new Date(nextDueAt) : undefined
-    });
-}
-async function findMaintenanceOccurrences(db, schedule) {
-    const workspaceId = schedule.workspaceId;
-    if (!workspaceId) {
-        return [];
-    }
-    const linkFilter = {
-        workspaceId,
-        archivedAt: { $exists: false },
-        links: {
-            $elemMatch: {
-                toType: "maintenance_schedules",
-                toId: schedule._id,
-                relationship: "assigned_to"
-            }
-        }
-    };
-    const [changes, tasks] = await Promise.all([
-        db.collection("changes").find(linkFilter).toArray(),
-        db.collection("tasks").find(linkFilter).toArray()
-    ]);
-    const occurrences = [
-        ...changes.flatMap((record) => occurrenceFromChange(record)),
-        ...tasks.flatMap((record) => occurrenceFromTask(record))
-    ];
-    return occurrences.sort((left, right) => right.occurredAt.localeCompare(left.occurredAt));
-}
-function occurrenceFromChange(record) {
-    const events = Array.isArray(record.fields.events) ? record.fields.events : [];
-    const event = [...events]
-        .reverse()
-        .find((entry) => Boolean(entry &&
-        typeof entry === "object" &&
-        (entry.eventType === "result_reported" || entry.eventType === "recovery_recorded") &&
-        typeof entry.createdAt === "string"));
-    const plannedFor = typeof record.fields.plannedFor === "string" ? record.fields.plannedFor : undefined;
-    const occurredAt = typeof event?.createdAt === "string" ? event.createdAt : plannedFor ?? record.createdAt;
-    return [{ recordType: "changes", id: record._id, readableId: record.readableId, occurredAt }];
-}
-function occurrenceFromTask(record) {
-    const entries = Array.isArray(record.fields.entries) ? record.fields.entries : [];
-    const doneEntry = [...entries]
-        .reverse()
-        .find((entry) => Boolean(entry &&
-        typeof entry === "object" &&
-        entry.entryType === "status_change" &&
-        entry.status === "done" &&
-        typeof entry.createdAt === "string"));
-    const occurredAt = typeof doneEntry?.createdAt === "string" ? doneEntry.createdAt : record.createdAt;
-    return [{ recordType: "tasks", id: record._id, readableId: record.readableId, occurredAt }];
-}
-function parseMaintenanceCadence(value) {
-    if (!value || typeof value !== "object") {
-        return undefined;
-    }
-    const cadence = value;
-    if (Number.isInteger(cadence.count) &&
-        (cadence.count ?? 0) > 0 &&
-        (cadence.unit === "day" ||
-            cadence.unit === "week" ||
-            cadence.unit === "month" ||
-            cadence.unit === "quarter" ||
-            cadence.unit === "year")) {
-        return { count: cadence.count, unit: cadence.unit };
-    }
-    return undefined;
-}
-function parseDateString(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const date = new Date(value);
-    return Number.isNaN(date.getTime()) ? undefined : date;
-}
-function addMaintenanceCadence(date, cadence) {
-    const next = new Date(date);
-    switch (cadence.unit) {
-        case "day":
-            next.setUTCDate(next.getUTCDate() + cadence.count);
-            return next;
-        case "week":
-            next.setUTCDate(next.getUTCDate() + cadence.count * 7);
-            return next;
-        case "month":
-            next.setUTCMonth(next.getUTCMonth() + cadence.count);
-            return next;
-        case "quarter":
-            next.setUTCMonth(next.getUTCMonth() + cadence.count * 3);
-            return next;
-        case "year":
-            next.setUTCFullYear(next.getUTCFullYear() + cadence.count);
-            return next;
-    }
-}
-function deriveValueRealizationState(record) {
-    const metrics = normalizeValueRealizationMetrics(record.fields.metrics);
-    const comparisons = metrics.map((metric) => {
-        if (!metric.actual) {
-            return {
-                id: metric.id,
-                name: metric.name,
-                unit: metric.unit,
-                direction: metric.direction,
-                status: "open"
-            };
-        }
-        const absoluteChange = metric.actual.value - metric.baseline.value;
-        const ratio = metric.baseline.value === 0 ? null : metric.actual.value / metric.baseline.value;
-        const percentChange = ratio === null ? null : (ratio - 1) * 100;
-        const outcome = absoluteChange === 0
-            ? "unchanged"
-            : metric.direction === "higher_is_better"
-                ? absoluteChange > 0
-                    ? "improved"
-                    : "regressed"
-                : absoluteChange < 0
-                    ? "improved"
-                    : "regressed";
-        return {
-            id: metric.id,
-            name: metric.name,
-            unit: metric.unit,
-            direction: metric.direction,
-            status: "measured",
-            absoluteChange,
-            percentChange,
-            ratio,
-            outcome,
-            baselineMeasuredAt: metric.baseline.measuredAt,
-            actualMeasuredAt: metric.actual.measuredAt
-        };
-    });
-    return {
-        metricCount: metrics.length,
-        openMetricCount: comparisons.filter((comparison) => comparison.status === "open").length,
-        measuredMetricCount: comparisons.filter((comparison) => comparison.status === "measured").length,
-        comparisons
-    };
-}
-function normalizeValueRealizationMetrics(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isValueRealizationMetric);
-}
-function isValueRealizationMetric(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const metric = value;
-    return (typeof metric.id === "string" &&
-        typeof metric.name === "string" &&
-        typeof metric.unit === "string" &&
-        (metric.direction === "lower_is_better" || metric.direction === "higher_is_better") &&
-        isMeasuredValue(metric.baseline) &&
-        (metric.actual === undefined || isMeasuredValue(metric.actual)));
-}
-function isMeasuredValue(value) {
-    return (Boolean(value) &&
-        typeof value === "object" &&
-        typeof value.value === "number" &&
-        Number.isFinite(value.value) &&
-        typeof value.measuredAt === "string");
-}
-function compactRuntimeObject(input) {
-    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
-}
-export async function migrateLegacyIntakeItemsToDxcompleteTickets(db) {
-    const legacyCollection = db.collection(LEGACY_INTAKE_COLLECTION_NAME);
-    const ticketCollection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
-    const legacyRecords = await legacyCollection.find({}).toArray();
-    let copied = 0;
-    let skipped = 0;
-    for (const legacyRecord of legacyRecords) {
-        const existing = await ticketCollection.findOne({ _id: legacyRecord._id });
-        if (existing) {
-            skipped += 1;
-            continue;
-        }
-        const migratedRecord = {
-            ...legacyRecord,
-            recordType: DXCOMPLETE_TICKET_COLLECTION_NAME,
-            fields: {
-                ...legacyRecord.fields,
-                entries: normalizeTicketEntries(legacyRecord.fields.entries)
-            }
-        };
-        await ticketCollection.insertOne(migratedRecord);
-        copied += 1;
-    }
-    return { copied, skipped };
-}
-export async function createDxcompleteTicket(db, input, actor) {
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        body: input.body,
-        createdAt: now,
-        createdBy: actor.actorId,
-        direction: "submitter_entry"
-    };
-    const record = {
-        _id: randomUUID(),
-        recordType: DXCOMPLETE_TICKET_COLLECTION_NAME,
-        title: input.title,
-        fields: {
-            ownerActorId: actor.actorId,
-            entries: [entry]
-        },
-        links: [],
-        createdAt: now,
-        createdBy: actor.actorId,
-        updatedAt: now,
-        updatedBy: actor.actorId
-    };
-    await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).insertOne(record);
-    return record;
-}
-export async function getDxcompleteTicket(db, id, actor) {
-    const record = await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).findOne(ticketOwnerFilter(id, actor));
-    if (!record) {
-        throw new Error(`DX Complete Ticket not found: ${id}`);
-    }
-    return record;
-}
-export async function listDxcompleteTickets(db, actor, limit, options = {}) {
-    const filter = {
-        "fields.ownerActorId": actor.actorId
-    };
-    if (!options.includeArchived) {
-        filter.archivedAt = { $exists: false };
-    }
-    return db
-        .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
-        .find(filter)
-        .sort({ updatedAt: -1 })
-        .limit(limit)
-        .toArray();
-}
-export async function appendDxcompleteTicket(db, input, actor) {
-    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
-    const existing = await collection.findOne({
-        ...ticketOwnerFilter(input.id, actor),
-        archivedAt: { $exists: false }
-    });
-    if (!existing) {
-        throw new Error(`Active DX Complete Ticket not found: ${input.id}`);
-    }
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        body: input.body,
-        createdAt: now,
-        createdBy: actor.actorId,
-        direction: "submitter_entry"
-    };
-    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actor.actorId
-        }
-    });
-    return getDxcompleteTicket(db, input.id, actor);
-}
-export async function appendDxcompleteTicketReply(db, input, actorId = RUNTIME_ACTOR_ID) {
-    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
-    const existing = await collection.findOne({
-        _id: input.id,
-        "fields.ownerActorId": input.addressedToActorId,
-        archivedAt: { $exists: false }
-    });
-    if (!existing) {
-        throw new Error(`Active DX Complete Ticket not found for addressed actor: ${input.id}`);
-    }
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        direction: "dxcomplete_reply",
-        addressedToActorId: input.addressedToActorId
-    };
-    await collection.updateOne({ _id: input.id }, {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const record = await collection.findOne({ _id: input.id });
-    if (!record) {
-        throw new Error(`DX Complete Ticket not found after reply append: ${input.id}`);
-    }
-    return record;
-}
-export async function appendJournalNote(db, input, actorId) {
-    return createRecord(db, "journal_entries", {
-        workspaceId: input.workspaceId,
-        title: input.tag ? `Journal note: ${input.tag}` : "Journal note",
-        summary: input.body,
-        allowManagedFields: true,
-        fields: {
-            kind: "note",
-            body: input.body,
-            ...(input.tag ? { tag: input.tag } : {})
-        }
-    }, actorId);
-}
-export async function readJournal(db, input) {
-    const limit = clampJournalReadLimit(input.limit);
-    const filter = {
-        workspaceId: readRequiredWorkspaceId(input.workspaceId, "journal_entries")
-    };
-    if (!input.includeArchived) {
-        filter.archivedAt = { $exists: false };
-        filter["fields.kind"] = { $in: ["note", "summary"] };
-    }
-    const [entries, activeRawNoteCount] = await Promise.all([
-        db
-            .collection("journal_entries")
-            .find(filter)
-            .sort({ createdAt: 1 })
-            .limit(limit)
-            .toArray(),
-        db.collection("journal_entries").countDocuments({
-            workspaceId: input.workspaceId,
-            archivedAt: { $exists: false },
-            "fields.kind": "note"
-        })
-    ]);
-    return {
-        workspaceId: input.workspaceId,
-        readTier: input.includeArchived ? "cold" : "hot",
-        compaction: {
-            activeRawNoteCount,
-            threshold: JOURNAL_COMPACTION_THRESHOLD,
-            recommended: activeRawNoteCount >= JOURNAL_COMPACTION_THRESHOLD
-        },
-        entries
-    };
-}
-export async function getJournalEntry(db, input) {
-    const entry = await getRecord(db, "journal_entries", input.id, { workspaceId: input.workspaceId });
-    if (!entry) {
-        throw new Error(`Journal entry not found: journal_entries/${input.id}`);
-    }
-    return entry;
-}
-export async function appendJournalSummary(db, input, actorId) {
-    const coveredIds = [...new Set(input.covers.map((id) => id.trim()).filter(Boolean))];
-    if (coveredIds.length === 0) {
-        throw new Error("append_journal_summary requires at least one covered journal entry id.");
-    }
-    const coveredEntries = [];
-    for (const id of coveredIds) {
-        const entry = await getRecord(db, "journal_entries", id, { workspaceId: input.workspaceId });
-        if (!entry) {
-            throw new Error(`Covered journal entry not found: journal_entries/${id}`);
-        }
-        const kind = readJournalEntryKind(entry);
-        if (!kind) {
-            throw new Error(`Covered record is not a journal note or summary: journal_entries/${id}`);
-        }
-        coveredEntries.push(entry);
-    }
-    const summary = await createRecord(db, "journal_entries", {
-        workspaceId: input.workspaceId,
-        title: input.tag ? `Journal summary: ${input.tag}` : "Journal summary",
-        summary: input.body,
-        allowManagedFields: true,
-        fields: {
-            kind: "summary",
-            body: input.body,
-            covers: coveredEntries.map((entry) => entry._id),
-            ...(input.tag ? { tag: input.tag } : {})
-        }
-    }, actorId);
-    const now = new Date().toISOString();
-    await db.collection("journal_entries").updateMany({
-        workspaceId: input.workspaceId,
-        _id: { $in: coveredEntries.map((entry) => entry._id) },
-        archivedAt: { $exists: false }
-    }, {
-        $set: {
-            archivedAt: now,
-            archivedBy: actorId,
-            archiveReason: `Covered by journal summary ${summary._id}`,
-            "fields.coveredBySummaryId": summary._id,
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    return summary;
-}
-function clampJournalReadLimit(limit) {
-    if (!limit) {
-        return 100;
-    }
-    return Math.min(Math.max(limit, 1), 500);
-}
-function readJournalEntryKind(record) {
-    if (record.fields.kind === "note" || record.fields.kind === "summary") {
-        return record.fields.kind;
-    }
-    return undefined;
-}
-export async function appendReviewNote(db, input, actorId) {
-    const collection = db.collection(input.recordType);
-    const filter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
-    }
-    const now = new Date().toISOString();
-    const note = {
-        id: randomUUID(),
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.important ? { important: true } : {})
-    };
-    await collection.updateOne(filter, {
-        $push: {
-            "fields.reviewNotes": note
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await getRecord(db, input.recordType, input.id, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after review note append: ${input.recordType}/${input.id}`);
-    }
-    return updated;
-}
-export async function appendChangeEvent(db, input, actorId) {
-    const collection = db.collection("changes");
-    const filter = scopedRecordFilter("changes", input.changeId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: changes/${input.changeId}`);
-    }
-    const now = new Date().toISOString();
-    const event = {
-        ...input.event,
-        id: randomUUID(),
-        eventType: input.eventType,
-        createdAt: now,
-        createdBy: actorId
-    };
-    await collection.updateOne(filter, {
-        $push: {
-            "fields.events": event
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await getRecord(db, "changes", input.changeId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after change event append: changes/${input.changeId}`);
-    }
-    return updated;
-}
-export async function appendDeferralEvent(db, input, actorId) {
-    const collection = db.collection("deferrals");
-    const filter = scopedRecordFilter("deferrals", input.deferralId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: deferrals/${input.deferralId}`);
-    }
-    const now = new Date().toISOString();
-    const event = {
-        ...input.event,
-        id: randomUUID(),
-        eventType: input.eventType,
-        createdAt: now,
-        createdBy: actorId
-    };
-    const { conditions, status } = applyDeferralEventState(existing, event, actorId, now);
-    await collection.updateOne(filter, {
-        $push: {
-            "fields.conditionEvents": event
-        },
-        $set: {
-            "fields.conditions": conditions,
-            "fields.status": status,
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await getRecord(db, "deferrals", input.deferralId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after deferral event append: deferrals/${input.deferralId}`);
-    }
-    return updated;
-}
-export async function appendDecisionEntry(db, input, actorId) {
-    const collection = db.collection("decisions");
-    const filter = scopedRecordFilter("decisions", input.decisionId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: decisions/${input.decisionId}`);
-    }
-    assertDecisionEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.decidedBy ? { decidedBy: input.decidedBy } : {}),
-        ...(input.rationale ? { rationale: input.rationale } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    if (entry.entryType === "decision") {
-        update.$set["fields.currentDecision"] = decisionEntryToCurrentDecision(entry);
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "decisions", input.decisionId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after decision entry append: decisions/${input.decisionId}`);
-    }
-    return updated;
-}
-export async function appendTaskEntry(db, input, actorId) {
-    const collection = db.collection("tasks");
-    const filter = scopedRecordFilter("tasks", input.taskId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: tasks/${input.taskId}`);
-    }
-    assertTaskEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.status ? { status: input.status } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    if (entry.entryType === "status_change") {
-        update.$set["fields.currentStatus"] = taskEntryToCurrentStatus(entry);
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "tasks", input.taskId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after task entry append: tasks/${input.taskId}`);
-    }
-    return updated;
-}
-export async function appendRiskEntry(db, input, actorId) {
-    const collection = db.collection("risks");
-    const filter = scopedRecordFilter("risks", input.riskId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: risks/${input.riskId}`);
-    }
-    assertRiskEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.likelihood ? { likelihood: input.likelihood } : {}),
-        ...(input.impact ? { impact: input.impact } : {}),
-        ...(input.treatment ? { treatment: input.treatment } : {}),
-        ...(input.treatmentRationale ? { treatmentRationale: input.treatmentRationale } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    if (entry.entryType === "identified" || entry.entryType === "reopened") {
-        update.$set["fields.currentStatus"] = riskEntryToCurrentStatus(entry, "open");
-    }
-    if (entry.entryType === "closed") {
-        update.$set["fields.currentStatus"] = riskEntryToCurrentStatus(entry, "closed");
-    }
-    if (entry.entryType === "assessment") {
-        update.$set["fields.currentAssessment"] = riskEntryToCurrentAssessment(entry);
-    }
-    if (entry.entryType === "treatment") {
-        update.$set["fields.currentTreatment"] = riskEntryToCurrentTreatment(entry);
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "risks", input.riskId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after risk entry append: risks/${input.riskId}`);
-    }
-    return updated;
-}
-export async function appendIncidentEntry(db, input, actorId) {
-    const collection = db.collection("incidents");
-    const filter = scopedRecordFilter("incidents", input.incidentId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: incidents/${input.incidentId}`);
-    }
-    assertIncidentEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.severity ? { severity: input.severity } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    if (entry.entryType === "detected" || entry.entryType === "reopened") {
-        update.$set["fields.currentStatus"] = incidentEntryToCurrentStatus(entry, "open");
-    }
-    if (entry.entryType === "resolved") {
-        update.$set["fields.currentStatus"] = incidentEntryToCurrentStatus(entry, "resolved");
-    }
-    if (entry.entryType === "severity") {
-        update.$set["fields.currentSeverity"] = incidentEntryToCurrentSeverity(entry);
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "incidents", input.incidentId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after incident entry append: incidents/${input.incidentId}`);
-    }
-    return updated;
-}
-export async function appendProblemEntry(db, input, actorId) {
-    const collection = db.collection("problems");
-    const filter = scopedRecordFilter("problems", input.problemId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: problems/${input.problemId}`);
-    }
-    assertProblemEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.rootCause ? { rootCause: input.rootCause } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    if (entry.entryType === "identified" || entry.entryType === "reopened") {
-        update.$set["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "open");
-    }
-    if (entry.entryType === "known_error") {
-        update.$set["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "known_error");
-    }
-    if (entry.entryType === "resolved") {
-        update.$set["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "resolved");
-    }
-    if (entry.entryType === "root_cause") {
-        update.$set["fields.currentRootCause"] = problemEntryToCurrentRootCause(entry);
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "problems", input.problemId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after problem entry append: problems/${input.problemId}`);
-    }
-    return updated;
-}
-export async function appendSupportRequestEntry(db, input, actorId) {
-    const collection = db.collection("support_requests");
-    const filter = scopedRecordFilter("support_requests", input.supportRequestId, input.workspaceId);
-    const existing = await collection.findOne(filter);
-    if (!existing) {
-        throw new Error(`Record not found: support_requests/${input.supportRequestId}`);
-    }
-    assertSupportRequestEntryInput(input);
-    const now = new Date().toISOString();
-    const entry = {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt: now,
-        createdBy: actorId,
-        ...(input.incidentId ? { incidentId: input.incidentId } : {})
-    };
-    const update = {
-        $push: {
-            "fields.entries": entry
-        },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    };
-    const currentStatus = supportRequestEntryToCurrentStatus(entry, readSupportRequestStatus(existing));
-    if (currentStatus) {
-        update.$set["fields.currentStatus"] = currentStatus;
-    }
-    await collection.updateOne(filter, update);
-    const updated = await getRecord(db, "support_requests", input.supportRequestId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Record not found after support request entry append: support_requests/${input.supportRequestId}`);
-    }
-    return updated;
-}
-export function decisionEntryToCurrentDecision(entry) {
-    return {
-        entryId: entry.id,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy,
-        ...(entry.decidedBy ? { decidedBy: entry.decidedBy } : {}),
-        ...(entry.rationale ? { rationale: entry.rationale } : {})
-    };
-}
-export function taskEntryToCurrentStatus(entry) {
-    if (entry.entryType !== "status_change" || !entry.status) {
-        throw new Error("Task current status can only derive from a status_change entry.");
-    }
-    return {
-        entryId: entry.id,
-        status: entry.status,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function riskEntryToCurrentStatus(entry, status) {
-    return {
-        entryId: entry.id,
-        status,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function riskEntryToCurrentAssessment(entry) {
-    if (entry.entryType !== "assessment" || !entry.likelihood || !entry.impact) {
-        throw new Error("Risk current assessment can only derive from an assessment entry with likelihood and impact.");
-    }
-    return {
-        entryId: entry.id,
-        likelihood: entry.likelihood,
-        impact: entry.impact,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function riskEntryToCurrentTreatment(entry) {
-    if (entry.entryType !== "treatment" || !entry.treatment) {
-        throw new Error("Risk current treatment can only derive from a treatment entry.");
-    }
-    return {
-        entryId: entry.id,
-        treatment: entry.treatment,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy,
-        ...(entry.treatmentRationale ? { treatmentRationale: entry.treatmentRationale } : {})
-    };
-}
-export function incidentEntryToCurrentStatus(entry, status) {
-    return {
-        entryId: entry.id,
-        status,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function incidentEntryToCurrentSeverity(entry) {
-    if (entry.entryType !== "severity" || !entry.severity) {
-        throw new Error("Incident current severity can only derive from a severity entry.");
-    }
-    return {
-        entryId: entry.id,
-        severity: entry.severity,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function problemEntryToCurrentStatus(entry, status) {
-    return {
-        entryId: entry.id,
-        status,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function problemEntryToCurrentRootCause(entry) {
-    if (entry.entryType !== "root_cause") {
-        throw new Error("Problem current root cause can only derive from a root_cause entry.");
-    }
-    return {
-        entryId: entry.id,
-        rootCause: entry.rootCause ?? entry.body,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-export function supportRequestEntryToCurrentStatus(entry, previousStatus) {
-    const status = supportRequestStatusForEntryType(entry.entryType);
-    if (!status) {
-        return previousStatus;
-    }
-    return {
-        entryId: entry.id,
-        status,
-        body: entry.body,
-        createdAt: entry.createdAt,
-        createdBy: entry.createdBy
-    };
-}
-function supportRequestStatusForEntryType(entryType) {
-    switch (entryType) {
-        case "raised":
-        case "reopened":
-            return "open";
-        case "triage":
-            return "triaged";
-        case "escalated":
-            return "escalated";
-        case "resolved":
-            return "resolved";
-        case "update":
-        case "note":
-            return undefined;
-    }
-}
-function readSupportRequestStatus(record) {
-    return record.fields.currentStatus && typeof record.fields.currentStatus === "object"
-        ? record.fields.currentStatus
-        : undefined;
-}
-function assertDecisionEntryInput(input) {
-    if (input.entryType !== "decision" && (input.decidedBy || input.rationale)) {
-        throw new Error("decidedBy and rationale are only valid on decision entries.");
-    }
-}
-function assertTaskEntryInput(input) {
-    if (input.entryType === "status_change" && !input.status) {
-        throw new Error("status_change entries require status.");
-    }
-    if (input.entryType !== "status_change" && input.status) {
-        throw new Error("status is only valid on status_change entries.");
-    }
-}
-function assertRiskEntryInput(input) {
-    if (input.entryType === "assessment" && (!input.likelihood || !input.impact)) {
-        throw new Error("assessment entries require likelihood and impact.");
-    }
-    if (input.entryType !== "assessment" && (input.likelihood || input.impact)) {
-        throw new Error("likelihood and impact are only valid on assessment entries.");
-    }
-    if (input.entryType === "treatment" && !input.treatment) {
-        throw new Error("treatment entries require treatment.");
-    }
-    if (input.entryType !== "treatment" && (input.treatment || input.treatmentRationale)) {
-        throw new Error("treatment and treatmentRationale are only valid on treatment entries.");
-    }
-}
-function assertIncidentEntryInput(input) {
-    if (input.entryType === "severity" && !input.severity) {
-        throw new Error("severity entries require severity.");
-    }
-    if (input.entryType !== "severity" && input.severity) {
-        throw new Error("severity is only valid on severity entries.");
-    }
-}
-function assertProblemEntryInput(input) {
-    if (input.entryType !== "root_cause" && input.rootCause) {
-        throw new Error("rootCause is only valid on root_cause entries.");
-    }
-}
-function assertSupportRequestEntryInput(input) {
-    if (input.entryType === "escalated" && !input.incidentId) {
-        throw new Error("escalated support request entries require incidentId.");
-    }
-    if (input.entryType !== "escalated" && input.incidentId) {
-        throw new Error("incidentId is only valid on escalated support request entries.");
-    }
-}
-function applyDeferralEventState(existing, event, actorId, now) {
-    const conditions = normalizeDeferralConditions(existing.fields.conditions);
-    let status = typeof existing.fields.status === "string" ? existing.fields.status : "open";
-    switch (event.eventType) {
-        case "condition_addressed":
-            return {
-                conditions: updateDeferralConditionState(conditions, event, "addressed", actorId, now),
-                status
-            };
-        case "condition_reopened":
-            return {
-                conditions: updateDeferralConditionState(conditions, event, "open", actorId, now),
-                status
-            };
-        case "condition_note_added":
-            assertDeferralConditionExists(conditions, event);
-            return { conditions, status };
-        case "deferral_resolved":
-            status = "resolved";
-            return { conditions, status };
-        case "deferral_abandoned":
-            status = "abandoned";
-            return { conditions, status };
-    }
-}
-function normalizeDeferralConditions(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isDeferralCondition);
-}
-function isDeferralCondition(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const condition = value;
-    return (typeof condition.id === "string" &&
-        typeof condition.statement === "string" &&
-        (condition.state === "open" || condition.state === "addressed") &&
-        typeof condition.createdAt === "string" &&
-        typeof condition.createdBy === "string" &&
-        typeof condition.updatedAt === "string" &&
-        typeof condition.updatedBy === "string");
-}
-function updateDeferralConditionState(conditions, event, state, actorId, now) {
-    const conditionId = readRequiredDeferralEventString(event, "conditionId");
-    let found = false;
-    const updated = conditions.map((condition) => {
-        if (condition.id !== conditionId) {
-            return condition;
-        }
-        found = true;
-        return {
-            ...condition,
-            state,
-            updatedAt: now,
-            updatedBy: actorId
-        };
-    });
-    if (!found) {
-        throw new Error(`Deferral condition not found: ${conditionId}`);
-    }
-    return updated;
-}
-function assertDeferralConditionExists(conditions, event) {
-    const conditionId = readRequiredDeferralEventString(event, "conditionId");
-    if (!conditions.some((condition) => condition.id === conditionId)) {
-        throw new Error(`Deferral condition not found: ${conditionId}`);
-    }
-}
-function readRequiredDeferralEventString(event, key) {
-    const value = event[key];
-    if (typeof value !== "string" || !value.trim()) {
-        throw new Error(`${event.eventType} requires ${key}.`);
-    }
-    return value;
-}
-export async function listUnreadDxcompleteTicketReplies(db, actor, limit) {
-    const records = await db
-        .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
-        .find({
-        "fields.ownerActorId": actor.actorId,
-        archivedAt: { $exists: false },
-        "fields.entries": {
-            $elemMatch: {
-                direction: "dxcomplete_reply",
-                addressedToActorId: actor.actorId,
-                readAt: { $exists: false }
-            }
-        }
-    })
-        .sort({ updatedAt: -1 })
-        .limit(limit)
-        .toArray();
-    return records.map((record) => {
-        const replies = normalizeTicketEntries(record.fields.entries).filter((entry) => entry.direction === "dxcomplete_reply" &&
-            entry.addressedToActorId === actor.actorId &&
-            !entry.readAt);
-        const replySummaries = replies.map((entry) => ({
-            id: entry.id,
-            createdAt: entry.createdAt,
-            createdBy: entry.createdBy,
-            direction: "dxcomplete_reply",
-            ...(entry.addressedToActorId ? { addressedToActorId: entry.addressedToActorId } : {})
-        }));
-        const newestReplyAt = replySummaries.reduce((current, entry) => (!current || entry.createdAt > current ? entry.createdAt : current), undefined);
-        return {
-            ticketId: record._id,
-            ...(record.title ? { title: record.title } : {}),
-            updatedAt: record.updatedAt,
-            unreadReplyCount: replySummaries.length,
-            ...(newestReplyAt ? { newestReplyAt } : {}),
-            replies: replySummaries
-        };
-    });
-}
-export async function readDxcompleteTicket(db, input, actor) {
-    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
-    const existing = await collection.findOne(ticketOwnerFilter(input.id, actor));
-    if (!existing) {
-        throw new Error(`DX Complete Ticket not found: ${input.id}`);
-    }
-    const now = new Date().toISOString();
-    const entries = normalizeTicketEntries(existing.fields.entries);
-    let changed = false;
-    const nextEntries = entries.map((entry) => {
-        const shouldMark = entry.direction === "dxcomplete_reply" &&
-            entry.addressedToActorId === actor.actorId &&
-            !entry.readAt;
-        if (!shouldMark) {
-            return entry;
-        }
-        changed = true;
-        return {
-            ...entry,
-            readAt: now
-        };
-    });
-    if (!changed) {
-        return existing;
-    }
-    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
-        $set: {
-            "fields.entries": nextEntries,
-            updatedAt: now,
-            updatedBy: actor.actorId
-        }
-    });
-    return getDxcompleteTicket(db, input.id, actor);
-}
-export async function archiveDxcompleteTicket(db, input, actor) {
-    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
-    const existing = await collection.findOne(ticketOwnerFilter(input.id, actor));
-    if (!existing) {
-        throw new Error(`DX Complete Ticket not found: ${input.id}`);
-    }
-    if (existing.archivedAt) {
-        return existing;
-    }
-    const now = new Date().toISOString();
-    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
-        $set: {
-            archivedAt: now,
-            updatedAt: now,
-            updatedBy: actor.actorId
-        }
-    });
-    return getDxcompleteTicket(db, input.id, actor);
-}
-export async function updateRecord(db, input, actorId) {
-    const collection = db.collection(input.recordType);
-    const recordFilter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
-    const existing = await collection.findOne(recordFilter);
-    if (!existing) {
-        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
-    }
-    const now = new Date().toISOString();
-    const set = {
-        updatedAt: now,
-        updatedBy: actorId
-    };
-    const unset = {};
-    const versioned = recordTypeSupportsVersionHistory(input.recordType);
-    if (input.title !== undefined) {
-        set.title = input.title;
-    }
-    if (input.summary !== undefined) {
-        set.summary = input.summary;
-    }
-    for (const [key, value] of Object.entries(input.fields ?? {})) {
-        assertFieldName(key);
-        assertNotReservedRelationshipField(input.recordType, key);
-        if (input.allowManagedFields) {
-            assertNotReviewNotesField(input.recordType, key);
-            assertNotVersionHistoryField(input.recordType, key);
-        }
-        else {
-            assertNotManagedField(input.recordType, key);
-            assertNotVersionedTypedField(input.recordType, key);
-        }
-        set[`fields.${key}`] = value;
-    }
-    for (const key of input.unsetFields ?? []) {
-        assertFieldName(key);
-        if (input.allowManagedFields) {
-            assertNotReviewNotesField(input.recordType, key);
-            assertNotVersionHistoryField(input.recordType, key);
-        }
-        else {
-            assertNotManagedField(input.recordType, key);
-            assertNotVersionedTypedField(input.recordType, key);
-        }
-        unset[`fields.${key}`] = "";
-    }
-    if (versioned) {
-        const previousSnapshot = createRecordVersionSnapshot(existing);
-        const nextSnapshot = createRecordVersionSnapshot(applyRecordUpdate(existing, input));
-        const changedFields = listSnapshotChanges(previousSnapshot, nextSnapshot);
-        const existingVersionHistory = normalizeVersionHistory(existing.fields.versionHistory);
-        if (changedFields.length === 0) {
-            return withDerivedRecordFields(db, existing);
-        }
-        set["fields.versionHistory"] = [
-            ...existingVersionHistory,
-            createVersionHistoryEntry({
-                existingVersionHistory,
-                previousSnapshot,
-                nextSnapshot,
-                changedFields,
-                actorId,
-                createdAt: now,
-                revisionNote: input.revisionNote
-            })
-        ];
-    }
-    const update = Object.keys(unset).length > 0 ? { $set: set, $unset: unset } : { $set: set };
-    await collection.updateOne(recordFilter, update);
-    const updated = await collection.findOne(recordFilter);
-    if (!updated) {
-        throw new Error(`Updated record not found: ${input.recordType}/${input.id}`);
-    }
-    return withDerivedRecordFields(db, updated);
-}
-function applyRecordUpdate(record, input) {
-    const fields = { ...record.fields };
-    for (const [key, value] of Object.entries(input.fields ?? {})) {
-        fields[key] = value;
-    }
-    for (const key of input.unsetFields ?? []) {
-        delete fields[key];
-    }
-    return {
-        ...record,
-        ...(input.title !== undefined ? { title: input.title } : {}),
-        ...(input.summary !== undefined ? { summary: input.summary } : {}),
-        fields
-    };
-}
-function createRecordVersionSnapshot(record) {
-    return {
-        ...(record.title !== undefined ? { title: record.title } : {}),
-        ...(record.summary !== undefined ? { summary: record.summary } : {}),
-        fields: Object.fromEntries(Object.entries(record.fields)
-            .filter(([key]) => key !== VERSION_HISTORY_FIELD && key !== "reviewNotes")
-            .map(([key, value]) => [key, cloneSnapshotValue(value)]))
-    };
-}
-function listSnapshotChanges(previousSnapshot, nextSnapshot) {
-    const changedFields = [];
-    if (!valuesEqual(previousSnapshot.title, nextSnapshot.title)) {
-        changedFields.push("title");
-    }
-    if (!valuesEqual(previousSnapshot.summary, nextSnapshot.summary)) {
-        changedFields.push("summary");
-    }
-    const fieldNames = new Set([
-        ...Object.keys(previousSnapshot.fields),
-        ...Object.keys(nextSnapshot.fields)
-    ]);
-    for (const fieldName of [...fieldNames].sort()) {
-        if (!valuesEqual(previousSnapshot.fields[fieldName], nextSnapshot.fields[fieldName])) {
-            changedFields.push(`fields.${fieldName}`);
-        }
-    }
-    return changedFields;
-}
-function normalizeVersionHistory(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isVersionHistoryEntry);
-}
-function createVersionHistoryEntry(input) {
-    const fromVersion = input.existingVersionHistory.reduce((currentVersion, entry) => Math.max(currentVersion, entry.toVersion), 1);
-    return {
-        id: randomUUID(),
-        fromVersion,
-        toVersion: fromVersion + 1,
-        createdAt: input.createdAt,
-        createdBy: input.actorId,
-        changedFields: input.changedFields,
-        previousSnapshot: input.previousSnapshot,
-        nextSnapshot: input.nextSnapshot,
-        ...(input.revisionNote ? { revisionNote: input.revisionNote } : {})
-    };
-}
-function isVersionHistoryEntry(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const candidate = value;
-    return (typeof candidate.id === "string" &&
-        typeof candidate.fromVersion === "number" &&
-        typeof candidate.toVersion === "number" &&
-        typeof candidate.createdAt === "string" &&
-        typeof candidate.createdBy === "string" &&
-        Array.isArray(candidate.changedFields) &&
-        typeof candidate.previousSnapshot === "object" &&
-        typeof candidate.nextSnapshot === "object");
-}
-function cloneSnapshotValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((entry) => cloneSnapshotValue(entry));
-    }
-    if (value && typeof value === "object") {
-        return Object.fromEntries(Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => [key, cloneSnapshotValue(entry)]));
-    }
-    return value;
-}
-function valuesEqual(left, right) {
-    return stableStringify(left) === stableStringify(right);
-}
-function stableStringify(value) {
-    return JSON.stringify(cloneSnapshotValue(value));
-}
-export async function archiveRecord(db, input, actorId) {
-    const collection = db.collection(input.recordType);
-    const recordFilter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
-    const existing = await collection.findOne(recordFilter);
-    if (!existing) {
-        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
-    }
-    if ((input.supersededByType && !input.supersededById) || (!input.supersededByType && input.supersededById)) {
-        throw new Error("supersededByType and supersededById must be provided together.");
-    }
-    const supersedingRecord = input.supersededByType && input.supersededById
-        ? await getRecord(db, input.supersededByType, input.supersededById, {
-            workspaceId: existing.workspaceId
-        })
-        : null;
-    if (input.supersededByType && input.supersededById && !supersedingRecord) {
-        throw new Error(`Superseding record not found: ${input.supersededByType}/${input.supersededById}`);
-    }
-    const now = new Date().toISOString();
-    const links = [...existing.links];
-    if (input.supersededByType && input.supersededById) {
-        links.push({
-            toType: input.supersededByType,
-            toId: supersedingRecord?._id ?? input.supersededById,
-            relationship: "superseded_by",
-            createdAt: now,
-            createdBy: actorId
-        });
-    }
-    await collection.updateOne(recordFilter, {
-        $set: {
-            links,
-            archivedAt: now,
-            archivedBy: actorId,
-            archiveReason: input.reason ?? "Archived",
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await collection.findOne(recordFilter);
-    if (!updated) {
-        throw new Error(`Archived record not found: ${input.recordType}/${input.id}`);
-    }
-    return withDerivedRecordFields(db, updated);
-}
-export async function linkRecords(db, input, actorId) {
-    const sourceCollection = db.collection(input.fromType);
-    const source = await getRecord(db, input.fromType, input.fromId, {
-        workspaceId: input.workspaceId
-    });
-    const target = await getRecord(db, input.toType, input.toId, {
-        workspaceId: input.workspaceId
-    });
-    if (!source) {
-        throw new Error(`Source record not found: ${input.fromType}/${input.fromId}`);
-    }
-    if (!target) {
-        throw new Error(`Target record not found: ${input.toType}/${input.toId}`);
-    }
-    assertLinkWorkspaceBoundary(source, target);
-    const now = new Date().toISOString();
-    const link = {
-        toType: input.toType,
-        toId: target._id,
-        relationship: input.relationship ?? "related_to",
-        createdAt: now,
-        createdBy: actorId
-    };
-    await sourceCollection.updateOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId), {
-        $push: { links: link },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await sourceCollection.findOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId));
-    if (!updated) {
-        throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
-    }
-    return withDerivedRecordFields(db, updated);
-}
-export async function unlinkRecords(db, input, actorId) {
-    const sourceCollection = db.collection(input.fromType);
-    const source = await getRecord(db, input.fromType, input.fromId, {
-        workspaceId: input.workspaceId
-    });
-    const target = await getRecord(db, input.toType, input.toId, {
-        workspaceId: input.workspaceId
-    });
-    if (!source) {
-        throw new Error(`Source record not found: ${input.fromType}/${input.fromId}`);
-    }
-    if (!target) {
-        throw new Error(`Target record not found: ${input.toType}/${input.toId}`);
-    }
-    assertLinkWorkspaceBoundary(source, target);
-    const relationship = input.relationship ?? "related_to";
-    const remainingLinks = source.links.filter((link) => !(link.toType === input.toType &&
-        link.toId === target._id &&
-        link.relationship === relationship));
-    if (remainingLinks.length === source.links.length) {
-        return source;
-    }
-    const now = new Date().toISOString();
-    await sourceCollection.updateOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId), {
-        $set: {
-            links: remainingLinks,
-            updatedAt: now,
-            updatedBy: actorId
-        }
-    });
-    const updated = await sourceCollection.findOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId));
-    if (!updated) {
-        throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
-    }
-    return withDerivedRecordFields(db, updated);
-}
-function assertFieldName(key) {
-    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key)) {
-        throw new Error(`Invalid field name "${key}". Field updates only support top-level field names.`);
-    }
-}
-function assertNoReservedRelationshipFields(recordType, fields) {
-    for (const key of Object.keys(fields ?? {})) {
-        assertNotReservedRelationshipField(recordType, key);
-    }
-}
-function assertNoReviewNotesField(recordType, fields) {
-    for (const key of Object.keys(fields ?? {})) {
-        assertNotReviewNotesField(recordType, key);
-    }
-}
-function assertNoManagedField(recordType, fields) {
-    for (const key of Object.keys(fields ?? {})) {
-        assertNotManagedField(recordType, key);
-    }
-}
-function assertNotReservedRelationshipField(recordType, key) {
-    if (key === "workspaceId" && recordTypeRequiresWorkspace(recordType)) {
-        throw new Error(`fields.${key} is reserved for the workspace boundary on ${recordType}. Use the top-level ${key} argument instead.`);
-    }
-    if (key === "initiativeId" && REMOVED_INITIATIVE_FIELD_RECORD_TYPES.includes(recordType)) {
-        throw new Error(`fields.${key} belongs to the removed Initiative layer on ${recordType}. Records are scoped directly to workspace now.`);
-    }
-    if ((RESERVED_RELATIONSHIP_FIELDS[recordType] ?? []).includes(key)) {
-        throw new Error(`fields.${key} is reserved for relationships on ${recordType}. Use the typed relationship argument or link_records instead.`);
-    }
-}
-function assertNotManagedField(recordType, key) {
-    assertNotReviewNotesField(recordType, key);
-    assertNotVersionHistoryField(recordType, key);
-    assertNotChangeManagedField(recordType, key);
-    assertNotCommitmentManagedField(recordType, key);
-    assertNotDeferralManagedField(recordType, key);
-    assertNotEstimateManagedField(recordType, key);
-    assertNotBenefitsManagedField(recordType, key);
-    assertNotEnvironmentManagedField(recordType, key);
-    assertNotComponentManagedField(recordType, key);
-    assertNotMaintenanceScheduleManagedField(recordType, key);
-    assertNotSupportRequestLedgerManagedField(recordType, key);
-    assertNotValueRealizationManagedField(recordType, key);
-    assertNotDecisionLedgerManagedField(recordType, key);
-    assertNotTaskLedgerManagedField(recordType, key);
-    assertNotRiskLedgerManagedField(recordType, key);
-    assertNotIncidentLedgerManagedField(recordType, key);
-    assertNotProblemLedgerManagedField(recordType, key);
-    assertNotDecisionInputManagedField(recordType, key);
-    assertNotJournalEntryManagedField(recordType, key);
-}
-function assertNotVersionedTypedField(recordType, key) {
-    if (!(VERSIONED_TYPED_FIELDS[recordType] ?? []).includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on ${recordType}. Use ${versionedUpdateToolName(recordType)} to change it.`);
-}
-function assertNotReviewNotesField(recordType, key) {
-    if (key !== "reviewNotes" || !recordTypeSupportsReviewNotes(recordType)) {
-        return;
-    }
-    throw new Error(`fields.reviewNotes is append-only on ${recordType}. Use append_review_note instead of setting or unsetting it directly.`);
-}
-function assertNotVersionHistoryField(recordType, key) {
-    if (key !== VERSION_HISTORY_FIELD || !recordTypeSupportsVersionHistory(recordType)) {
-        return;
-    }
-    throw new Error(`fields.versionHistory is append-only on ${recordType}. Current content changes record version history automatically.`);
-}
-function assertNotChangeManagedField(recordType, key) {
-    if (recordType !== "changes" || !CHANGE_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on changes. Use create_change for the baseline and append_change_event for event history or plan revisions.`);
-}
-function assertNotCommitmentManagedField(recordType, key) {
-    if (recordType !== "commitments" || !COMMITMENT_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on commitments. Use create_commitment instead of setting or unsetting it directly.`);
-}
-function assertNotDeferralManagedField(recordType, key) {
-    if (recordType !== "deferrals" || !DEFERRAL_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on deferrals. Use create_deferral for the baseline and append_deferral_event for condition history or resolution.`);
-}
-function assertNotEstimateManagedField(recordType, key) {
-    if (recordType !== "estimates" || !ESTIMATE_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on estimates. Use create_estimate or update_estimate instead of setting or unsetting it directly.`);
-}
-function assertNotBenefitsManagedField(recordType, key) {
-    if (recordType !== "benefits" || !BENEFITS_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on benefits. Use create_benefits or update_benefits instead of setting or unsetting it directly.`);
-}
-function assertNotEnvironmentManagedField(recordType, key) {
-    if (recordType !== "environments" || !ENVIRONMENT_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on environments. Use create_environment or update_environment instead of setting or unsetting it directly.`);
-}
-function assertNotComponentManagedField(recordType, key) {
-    if (recordType !== "components" || !COMPONENT_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on components. Use create_component or update_component instead of setting or unsetting it directly.`);
-}
-function assertNotMaintenanceScheduleManagedField(recordType, key) {
-    if (recordType !== "maintenance_schedules" || !MAINTENANCE_SCHEDULE_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on maintenance schedules. Use create_maintenance_schedule or update_maintenance_schedule instead of setting or unsetting it directly.`);
-}
-function assertNotSupportRequestLedgerManagedField(recordType, key) {
-    if (recordType !== "support_requests" || !SUPPORT_REQUEST_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on support requests. Use create_support_request or append_support_request_entry instead of setting or unsetting it directly.`);
-}
-function assertNotValueRealizationManagedField(recordType, key) {
-    if (recordType !== "value_realizations" || !VALUE_REALIZATION_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on value realizations. Use create_value_realization or update_value_realization instead of setting or unsetting it directly.`);
-}
-function assertNotDecisionLedgerManagedField(recordType, key) {
-    if (recordType !== "decisions" || !DECISION_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on decisions. Use create_decision or append_decision_entry instead of setting or unsetting it directly.`);
-}
-function assertNotTaskLedgerManagedField(recordType, key) {
-    if (recordType !== "tasks" || !TASK_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on tasks. Use create_task or append_task_entry instead of setting or unsetting it directly.`);
-}
-function assertNotRiskLedgerManagedField(recordType, key) {
-    if (recordType !== "risks" || !RISK_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on risks. Use create_risk or append_risk_entry instead of setting or unsetting it directly.`);
-}
-function assertNotIncidentLedgerManagedField(recordType, key) {
-    if (recordType !== "incidents" || !INCIDENT_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on incidents. Use create_incident or append_incident_entry instead of setting or unsetting it directly.`);
-}
-function assertNotProblemLedgerManagedField(recordType, key) {
-    if (recordType !== "problems" || !PROBLEM_LEDGER_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on problems. Use create_problem or append_problem_entry instead of setting or unsetting it directly.`);
-}
-function assertNotDecisionInputManagedField(recordType, key) {
-    if (recordType !== "decisions" || !DECISION_INPUT_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on decisions. Use link_decision_input to record decision inputs.`);
-}
-function assertNotJournalEntryManagedField(recordType, key) {
-    if (recordType !== "journal_entries" || !JOURNAL_ENTRY_MANAGED_FIELDS.includes(key)) {
-        return;
-    }
-    throw new Error(`fields.${key} is managed on journal entries. Use append_journal_note or append_journal_summary instead of setting or unsetting it directly.`);
-}
-function linkMatches(link, relationship) {
-    return !relationship || link.relationship === relationship;
-}
-function recordTypeSupportsReviewNotes(recordType) {
-    return REVIEW_NOTE_RECORD_TYPES.includes(recordType);
-}
-function recordTypeSupportsVersionHistory(recordType) {
-    return VERSIONED_RECORD_TYPES.includes(recordType);
-}
-function versionedUpdateToolName(recordType) {
-    if (recordType === "environments") {
-        return "update_environment";
-    }
-    if (recordType === "components") {
-        return "update_component";
-    }
-    if (recordType === "maintenance_schedules") {
-        return "update_maintenance_schedule";
-    }
-    if (recordType === "value_realizations") {
-        return "update_value_realization";
-    }
-    if (recordType === "estimates") {
-        return "update_estimate";
-    }
-    if (recordType === "benefits") {
-        return "update_benefits";
-    }
-    if (recordType === "statements") {
-        return "update_statement";
-    }
-    return recordType === "expectations" ? "update_expectation" : "update_requirement";
-}
-function isCurrentCollection(recordType) {
-    return COLLECTION_NAMES.includes(recordType);
-}
-function recordTypeRequiresWorkspace(recordType) {
-    return recordType !== "workspaces" && recordType !== DXCOMPLETE_TICKET_COLLECTION_NAME;
-}
-function readRequiredWorkspaceId(workspaceId, recordType) {
-    const trimmed = workspaceId?.trim();
-    if (!trimmed) {
-        throw new Error(`${recordType} records require workspaceId.`);
-    }
-    return trimmed;
-}
-function workspaceIdForCreate(recordType, workspaceId) {
-    if (!recordTypeRequiresWorkspace(recordType)) {
-        if (workspaceId?.trim()) {
-            throw new Error("Workspace records do not accept workspaceId.");
-        }
-        return undefined;
-    }
-    return readRequiredWorkspaceId(workspaceId, recordType);
-}
-async function allocateReadableId(db, recordType, workspaceId, actorId, now, session) {
-    const scopedWorkspaceId = readRequiredWorkspaceId(workspaceId, recordType);
-    const sequenceId = `${scopedWorkspaceId}:${recordType}`;
-    const sequence = await db.collection(READABLE_ID_SEQUENCES_COLLECTION).findOneAndUpdate({ _id: sequenceId }, {
-        $inc: { nextNumber: 1 },
-        $set: {
-            updatedAt: now,
-            updatedBy: actorId
-        },
-        $setOnInsert: {
-            _id: sequenceId,
-            workspaceId: scopedWorkspaceId,
-            recordType,
-            createdAt: now,
-            createdBy: actorId
-        }
-    }, {
-        upsert: true,
-        returnDocument: "after",
-        session
-    });
-    if (!sequence || !Number.isInteger(sequence.nextNumber) || sequence.nextNumber < 1) {
-        throw new Error(`Readable ID sequence was not allocated for ${recordType}.`);
-    }
-    return `${READABLE_ID_TYPE_CODES[recordType]}-${String(sequence.nextNumber).padStart(4, "0")}`;
-}
-function recordTypeSupportsReadableId(recordType) {
-    return Object.hasOwn(READABLE_ID_TYPE_CODES, recordType);
-}
-function normalizeReadableId(value) {
-    return value.trim().toUpperCase();
-}
-function recordIdentityFilter(recordType, id) {
-    if (!recordTypeSupportsReadableId(recordType)) {
-        return { _id: id };
-    }
-    return {
-        $or: [
-            { _id: id },
-            { readableId: normalizeReadableId(id) }
-        ]
-    };
-}
-function scopedRecordFilter(recordType, id, workspaceId) {
-    const filter = recordIdentityFilter(recordType, id);
-    if (recordTypeRequiresWorkspace(recordType)) {
-        filter.workspaceId = readRequiredWorkspaceId(workspaceId, recordType);
-    }
-    return filter;
-}
-async function assertWorkspaceExists(db, workspaceId) {
-    const workspace = await db.collection("workspaces").findOne({
-        _id: workspaceId,
-        archivedAt: { $exists: false }
-    });
-    if (!workspace) {
-        throw new Error(`Workspace not found: workspaces/${workspaceId}`);
-    }
-    return workspace;
-}
-function recordBelongsToWorkspace(record, workspaceId) {
-    return !workspaceId || record.recordType === "workspaces" || record.workspaceId === workspaceId;
-}
-function assertLinkWorkspaceBoundary(source, target) {
-    if (!source.workspaceId || !target.workspaceId) {
-        return;
-    }
-    if (source.workspaceId !== target.workspaceId) {
-        throw new Error(`Cannot link records across workspaces: ${source.recordType}/${source._id} is in ${source.workspaceId}, while ${target.recordType}/${target._id} is in ${target.workspaceId}.`);
-    }
-}
-function ticketOwnerFilter(id, actor) {
-    return {
-        _id: id,
-        "fields.ownerActorId": actor.actorId
-    };
-}
-function normalizeTicketEntries(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.flatMap((entry, index) => normalizeTicketEntry(entry, index));
-}
-function normalizeTicketEntry(entry, index) {
-    if (!entry || typeof entry !== "object") {
-        return [];
-    }
-    const candidate = entry;
-    const body = typeof candidate.body === "string" ? candidate.body : "";
-    if (!body) {
-        return [];
-    }
-    const createdAt = typeof candidate.createdAt === "string" ? candidate.createdAt : new Date(0).toISOString();
-    const createdBy = typeof candidate.createdBy === "string" ? candidate.createdBy : RUNTIME_ACTOR_ID;
-    const direction = candidate.direction === "dxcomplete_reply" || candidate.direction === "submitter_entry"
-        ? candidate.direction
-        : "submitter_entry";
-    const normalized = {
-        id: typeof candidate.id === "string" && candidate.id ? candidate.id : `legacy-entry-${index + 1}`,
-        body,
-        createdAt,
-        createdBy,
-        direction
-    };
-    if (typeof candidate.addressedToActorId === "string" && candidate.addressedToActorId) {
-        normalized.addressedToActorId = candidate.addressedToActorId;
-    }
-    if (typeof candidate.readAt === "string" && candidate.readAt) {
-        normalized.readAt = candidate.readAt;
-    }
-    return [normalized];
-}