dxcomplete 0.1.0 → 0.2.1

package/dist/runtime/records.js

@@ -13,6 +13,11 @@ export const COLLECTION_NAMES = [
     "commitments",
     "deferrals",
     "changes",
+    "incidents",
+    "problems",
+    "maintenance_schedules",
+    "support_requests",
+    "value_realizations",
     "decisions",
     "risks"
 ];
@@ -42,6 +47,11 @@ export const READABLE_ID_TYPE_CODES = {
     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"
@@ -56,7 +66,9 @@ const VERSIONED_RECORD_TYPES = [
     "expectations",
     "requirements",
     "estimates",
-    "benefits"
+    "benefits",
+    "maintenance_schedules",
+    "value_realizations"
 ];
 const VERSION_HISTORY_FIELD = "versionHistory";
 const CHANGE_MANAGED_FIELDS = [
@@ -64,6 +76,11 @@ const CHANGE_MANAGED_FIELDS = [
     "executionSteps",
     "rollbackPlan",
     "riskImpact",
+    "changeType",
+    "impactGrade",
+    "emergencyImportance",
+    "emergencyImmediacy",
+    "emergencyRationaleGaps",
     "plannedFor",
     "events"
 ];
@@ -81,6 +98,23 @@ const COMPONENT_MANAGED_FIELDS = [
     "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",
@@ -102,6 +136,32 @@ const TASK_LEDGER_MANAGED_FIELDS = [
     "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;
@@ -112,7 +172,9 @@ const VERSIONED_TYPED_FIELDS = {
     estimates: ["lineItems", "rollup"],
     benefits: ["benefitItems", "rollup"],
     environments: ["name", "description"],
-    components: ["name", "environmentId", "kind", "locator", "identifiers", "secretPointers", "notes"]
+    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"],
@@ -120,6 +182,7 @@ const RESERVED_RELATIONSHIP_FIELDS = {
     deferrals: ["requirementIds", "expectationIds"],
     estimates: ["requirementIds", "expectationIds"],
     benefits: ["requirementIds", "expectationIds"],
+    value_realizations: ["requirementIds", "expectationIds", "commitmentIds"],
     expectations: ["statementId"],
     requirements: ["expectationId"],
     tasks: ["requirementId"]
@@ -173,10 +236,10 @@ export async function createRecord(db, recordType, input, actorId) {
         finally {
             await session.endSession();
         }
-        return record;
+        return withDerivedRecordFields(db, record);
     }
     await db.collection(recordType).insertOne(record);
-    return record;
+    return withDerivedRecordFields(db, record);
 }
 export async function listRecords(db, recordType, limit, options = {}) {
     const filter = {};
@@ -186,12 +249,13 @@ export async function listRecords(db, recordType, limit, options = {}) {
     if (!options.includeArchived) {
         filter.archivedAt = { $exists: false };
     }
-    return db
+    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);
@@ -200,7 +264,8 @@ export async function getRecord(db, recordType, id, options = {}) {
         isCurrentCollection(recordType)) {
         filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
     }
-    return db.collection(recordType).findOne(filter);
+    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 });
@@ -270,6 +335,204 @@ export async function listLinkedRecords(db, input) {
     }
     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);
@@ -681,6 +944,178 @@ export async function appendTaskEntry(db, input, actorId) {
     }
     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,
@@ -703,6 +1138,117 @@ export function taskEntryToCurrentStatus(entry) {
         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.");
@@ -716,6 +1262,41 @@ function assertTaskEntryInput(input) {
         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";
@@ -936,7 +1517,7 @@ export async function updateRecord(db, input, actorId) {
         const changedFields = listSnapshotChanges(previousSnapshot, nextSnapshot);
         const existingVersionHistory = normalizeVersionHistory(existing.fields.versionHistory);
         if (changedFields.length === 0) {
-            return existing;
+            return withDerivedRecordFields(db, existing);
         }
         set["fields.versionHistory"] = [
             ...existingVersionHistory,
@@ -957,7 +1538,7 @@ export async function updateRecord(db, input, actorId) {
     if (!updated) {
         throw new Error(`Updated record not found: ${input.recordType}/${input.id}`);
     }
-    return updated;
+    return withDerivedRecordFields(db, updated);
 }
 function applyRecordUpdate(record, input) {
     const fields = { ...record.fields };
@@ -1096,7 +1677,7 @@ export async function archiveRecord(db, input, actorId) {
     if (!updated) {
         throw new Error(`Archived record not found: ${input.recordType}/${input.id}`);
     }
-    return updated;
+    return withDerivedRecordFields(db, updated);
 }
 export async function linkRecords(db, input, actorId) {
     const sourceCollection = db.collection(input.fromType);
@@ -1132,7 +1713,7 @@ export async function linkRecords(db, input, actorId) {
     if (!updated) {
         throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
     }
-    return updated;
+    return withDerivedRecordFields(db, updated);
 }
 export async function unlinkRecords(db, input, actorId) {
     const sourceCollection = db.collection(input.fromType);
@@ -1168,7 +1749,7 @@ export async function unlinkRecords(db, input, actorId) {
     if (!updated) {
         throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
     }
-    return updated;
+    return withDerivedRecordFields(db, updated);
 }
 function assertFieldName(key) {
     if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key)) {
@@ -1211,8 +1792,14 @@ function assertNotManagedField(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);
 }
@@ -1276,6 +1863,24 @@ function assertNotComponentManagedField(recordType, key) {
     }
     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;
@@ -1288,6 +1893,24 @@ function assertNotTaskLedgerManagedField(recordType, key) {
     }
     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;
@@ -1316,6 +1939,12 @@ function versionedUpdateToolName(recordType) {
     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";
     }