dxcomplete 0.1.0 → 0.2.1

package/src/runtime/records.ts

@@ -16,6 +16,11 @@ export const COLLECTION_NAMES = [
   "commitments",
   "deferrals",
   "changes",
+  "incidents",
+  "problems",
+  "maintenance_schedules",
+  "support_requests",
+  "value_realizations",
   "decisions",
   "risks"
 ] as const;
@@ -46,6 +51,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"
@@ -90,6 +100,7 @@ export type DxcRecord = {
   createdBy: string;
   updatedAt: string;
   updatedBy: string;
+  derived?: Record<string, unknown>;
 };
 
 export type ReviewableRecordType = "expectations" | "requirements";
@@ -123,7 +134,6 @@ export type RecordVersionHistoryEntry = {
 export type ChangeEventType =
   | "notice_given"
   | "veto_recorded"
-  | "emergency_declared"
   | "decision_recorded"
   | "result_reported"
   | "recovery_recorded"
@@ -185,6 +195,70 @@ export type TaskEntry = {
   status?: TaskStatus;
 };
 
+export type RiskEntryType = "identified" | "assessment" | "treatment" | "monitor_note" | "closed" | "reopened";
+export type RiskLevel = "low" | "medium" | "high";
+export type RiskTreatment = "accept" | "mitigate" | "transfer" | "avoid";
+
+export type RiskEntry = {
+  id: string;
+  entryType: RiskEntryType;
+  body: string;
+  createdAt: string;
+  createdBy: string;
+  likelihood?: RiskLevel;
+  impact?: RiskLevel;
+  treatment?: RiskTreatment;
+  treatmentRationale?: string;
+};
+
+export type IncidentEntryType = "detected" | "update" | "severity" | "resolved" | "reopened" | "note";
+export type IncidentSeverity = "low" | "medium" | "high" | "critical";
+
+export type IncidentEntry = {
+  id: string;
+  entryType: IncidentEntryType;
+  body: string;
+  createdAt: string;
+  createdBy: string;
+  severity?: IncidentSeverity;
+};
+
+export type ProblemEntryType =
+  | "identified"
+  | "investigation"
+  | "root_cause"
+  | "known_error"
+  | "resolved"
+  | "reopened"
+  | "note";
+
+export type ProblemEntry = {
+  id: string;
+  entryType: ProblemEntryType;
+  body: string;
+  createdAt: string;
+  createdBy: string;
+  rootCause?: string;
+};
+
+export type SupportRequestEntryType =
+  | "raised"
+  | "triage"
+  | "update"
+  | "escalated"
+  | "resolved"
+  | "reopened"
+  | "note";
+
+export type SupportRequestEntry = {
+  id: string;
+  entryType: SupportRequestEntryType;
+  body: string;
+  createdAt: string;
+  createdBy: string;
+  incidentId?: string;
+};
+
 export type JournalEntryKind = "note" | "summary";
 
 export type AppendJournalNoteInput = {
@@ -282,6 +356,41 @@ export type AppendTaskEntryInput = {
   status?: TaskStatus;
 };
 
+export type AppendRiskEntryInput = {
+  workspaceId: string;
+  riskId: string;
+  entryType: RiskEntryType;
+  body: string;
+  likelihood?: RiskLevel;
+  impact?: RiskLevel;
+  treatment?: RiskTreatment;
+  treatmentRationale?: string;
+};
+
+export type AppendIncidentEntryInput = {
+  workspaceId: string;
+  incidentId: string;
+  entryType: IncidentEntryType;
+  body: string;
+  severity?: IncidentSeverity;
+};
+
+export type AppendProblemEntryInput = {
+  workspaceId: string;
+  problemId: string;
+  entryType: ProblemEntryType;
+  body: string;
+  rootCause?: string;
+};
+
+export type AppendSupportRequestEntryInput = {
+  workspaceId: string;
+  supportRequestId: string;
+  entryType: SupportRequestEntryType;
+  body: string;
+  incidentId?: string;
+};
+
 export type UnlinkRecordsInput = {
   fromType: CollectionName;
   fromId: string;
@@ -374,7 +483,9 @@ const VERSIONED_RECORD_TYPES = [
   "expectations",
   "requirements",
   "estimates",
-  "benefits"
+  "benefits",
+  "maintenance_schedules",
+  "value_realizations"
 ] as const;
 const VERSION_HISTORY_FIELD = "versionHistory";
 const CHANGE_MANAGED_FIELDS = [
@@ -382,6 +493,11 @@ const CHANGE_MANAGED_FIELDS = [
   "executionSteps",
   "rollbackPlan",
   "riskImpact",
+  "changeType",
+  "impactGrade",
+  "emergencyImportance",
+  "emergencyImmediacy",
+  "emergencyRationaleGaps",
   "plannedFor",
   "events"
 ] as const;
@@ -399,6 +515,23 @@ const COMPONENT_MANAGED_FIELDS = [
   "secretPointers",
   "notes"
 ] as const;
+const MAINTENANCE_SCHEDULE_MANAGED_FIELDS = [
+  "name",
+  "kind",
+  "cadence",
+  "startDate",
+  "rationale",
+  "notes"
+] as const;
+const SUPPORT_REQUEST_LEDGER_MANAGED_FIELDS = [
+  "reporter",
+  "kind",
+  "reportedExperience",
+  "entries",
+  "currentStatus",
+  "status"
+] as const;
+const VALUE_REALIZATION_MANAGED_FIELDS = ["metrics"] as const;
 const DECISION_LEDGER_MANAGED_FIELDS = [
   "matter",
   "entries",
@@ -420,6 +553,32 @@ const TASK_LEDGER_MANAGED_FIELDS = [
   "details",
   "status"
 ] as const;
+const RISK_LEDGER_MANAGED_FIELDS = [
+  "topic",
+  "entries",
+  "currentStatus",
+  "currentAssessment",
+  "currentTreatment",
+  "likelihood",
+  "impact",
+  "mitigation"
+] as const;
+const INCIDENT_LEDGER_MANAGED_FIELDS = [
+  "description",
+  "entries",
+  "currentStatus",
+  "currentSeverity",
+  "status",
+  "severity"
+] as const;
+const PROBLEM_LEDGER_MANAGED_FIELDS = [
+  "description",
+  "entries",
+  "currentStatus",
+  "currentRootCause",
+  "status",
+  "rootCause"
+] as const;
 const DECISION_INPUT_MANAGED_FIELDS = ["informedBy", "informedByIds", "inputRecords"] as const;
 const JOURNAL_ENTRY_MANAGED_FIELDS = ["kind", "body", "tag", "covers", "coveredBySummaryId"] as const;
 const JOURNAL_COMPACTION_THRESHOLD = 200;
@@ -430,7 +589,9 @@ const VERSIONED_TYPED_FIELDS: Partial<Record<CollectionName, string[]>> = {
   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: Partial<Record<CollectionName, string[]>> = {
@@ -439,6 +600,7 @@ const RESERVED_RELATIONSHIP_FIELDS: Partial<Record<CollectionName, string[]>> =
   deferrals: ["requirementIds", "expectationIds"],
   estimates: ["requirementIds", "expectationIds"],
   benefits: ["requirementIds", "expectationIds"],
+  value_realizations: ["requirementIds", "expectationIds", "commitmentIds"],
   expectations: ["statementId"],
   requirements: ["expectationId"],
   tasks: ["requirementId"]
@@ -503,11 +665,11 @@ export async function createRecord(
     } finally {
       await session.endSession();
     }
-    return record;
+    return withDerivedRecordFields(db, record);
   }
 
   await db.collection<DxcRecord>(recordType).insertOne(record);
-  return record;
+  return withDerivedRecordFields(db, record);
 }
 
 export async function listRecords(
@@ -526,12 +688,14 @@ export async function listRecords(
     filter.archivedAt = { $exists: false };
   }
 
-  return db
+  const records = await db
     .collection<DxcRecord>(recordType)
     .find(filter)
     .sort({ createdAt: -1 })
     .limit(limit)
     .toArray();
+
+  return Promise.all(records.map((record) => withDerivedRecordFields(db, record)));
 }
 
 export async function getRecord(
@@ -550,7 +714,8 @@ export async function getRecord(
     filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
   }
 
-  return db.collection<DxcRecord>(recordType).findOne(filter);
+  const record = await db.collection<DxcRecord>(recordType).findOne(filter);
+  return record ? withDerivedRecordFields(db, record) : null;
 }
 
 export async function listLinkedRecords(
@@ -648,6 +813,266 @@ export async function listLinkedRecords(
   return result;
 }
 
+async function withDerivedRecordFields(db: Db, record: DxcRecord): Promise<DxcRecord> {
+  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: Db, record: DxcRecord): Promise<Record<string, unknown>> {
+  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: Db,
+  schedule: DxcRecord
+): Promise<Array<{ recordType: "changes" | "tasks"; id: string; readableId?: string; occurredAt: string }>> {
+  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<DxcRecord>("changes").find(linkFilter).toArray(),
+    db.collection<DxcRecord>("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: DxcRecord): Array<{ recordType: "changes"; id: string; readableId?: string; occurredAt: string }> {
+  const events = Array.isArray(record.fields.events) ? record.fields.events : [];
+  const event = [...events]
+    .reverse()
+    .find((entry): entry is Record<string, unknown> =>
+      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: DxcRecord): Array<{ recordType: "tasks"; id: string; readableId?: string; occurredAt: string }> {
+  const entries = Array.isArray(record.fields.entries) ? record.fields.entries : [];
+  const doneEntry = [...entries]
+    .reverse()
+    .find((entry): entry is Record<string, unknown> =>
+      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 }];
+}
+
+type MaintenanceCadence = {
+  count: number;
+  unit: "day" | "week" | "month" | "quarter" | "year";
+};
+
+function parseMaintenanceCadence(value: unknown): MaintenanceCadence | undefined {
+  if (!value || typeof value !== "object") {
+    return undefined;
+  }
+  const cadence = value as Partial<MaintenanceCadence>;
+  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 as number, unit: cadence.unit };
+  }
+  return undefined;
+}
+
+function parseDateString(value: unknown): Date | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+function addMaintenanceCadence(date: Date, cadence: MaintenanceCadence): Date {
+  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: DxcRecord): Record<string, unknown> {
+  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
+  };
+}
+
+type ValueRealizationMetric = {
+  id: string;
+  name: string;
+  unit: string;
+  direction: "lower_is_better" | "higher_is_better";
+  baseline: {
+    value: number;
+    measuredAt: string;
+  };
+  actual?: {
+    value: number;
+    measuredAt: string;
+  };
+};
+
+function normalizeValueRealizationMetrics(value: unknown): ValueRealizationMetric[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.filter(isValueRealizationMetric);
+}
+
+function isValueRealizationMetric(value: unknown): value is ValueRealizationMetric {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const metric = value as ValueRealizationMetric;
+  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: unknown): value is { value: number; measuredAt: string } {
+  return (
+    Boolean(value) &&
+    typeof value === "object" &&
+    typeof (value as { value?: unknown }).value === "number" &&
+    Number.isFinite((value as { value: number }).value) &&
+    typeof (value as { measuredAt?: unknown }).measuredAt === "string"
+  );
+}
+
+function compactRuntimeObject(input: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+
 export async function migrateLegacyIntakeItemsToDxcompleteTickets(db: Db): Promise<{ copied: number; skipped: number }> {
   const legacyCollection = db.collection<DxcRecord>(LEGACY_INTAKE_COLLECTION_NAME);
   const ticketCollection = db.collection<DxcRecord>(DXCOMPLETE_TICKET_COLLECTION_NAME);
@@ -1204,6 +1629,233 @@ export async function appendTaskEntry(
   return updated;
 }
 
+export async function appendRiskEntry(
+  db: Db,
+  input: AppendRiskEntryInput,
+  actorId: string
+): Promise<DxcRecord> {
+  const collection = db.collection<DxcRecord>("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: RiskEntry = {
+    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: Record<string, unknown> = {
+    $push: {
+      "fields.entries": entry
+    },
+    $set: {
+      updatedAt: now,
+      updatedBy: actorId
+    }
+  };
+
+  if (entry.entryType === "identified" || entry.entryType === "reopened") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = riskEntryToCurrentStatus(entry, "open");
+  }
+
+  if (entry.entryType === "closed") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = riskEntryToCurrentStatus(entry, "closed");
+  }
+
+  if (entry.entryType === "assessment") {
+    (update.$set as Record<string, unknown>)["fields.currentAssessment"] = riskEntryToCurrentAssessment(entry);
+  }
+
+  if (entry.entryType === "treatment") {
+    (update.$set as Record<string, unknown>)["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: Db,
+  input: AppendIncidentEntryInput,
+  actorId: string
+): Promise<DxcRecord> {
+  const collection = db.collection<DxcRecord>("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: IncidentEntry = {
+    id: randomUUID(),
+    entryType: input.entryType,
+    body: input.body,
+    createdAt: now,
+    createdBy: actorId,
+    ...(input.severity ? { severity: input.severity } : {})
+  };
+  const update: Record<string, unknown> = {
+    $push: {
+      "fields.entries": entry
+    },
+    $set: {
+      updatedAt: now,
+      updatedBy: actorId
+    }
+  };
+
+  if (entry.entryType === "detected" || entry.entryType === "reopened") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = incidentEntryToCurrentStatus(entry, "open");
+  }
+
+  if (entry.entryType === "resolved") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = incidentEntryToCurrentStatus(entry, "resolved");
+  }
+
+  if (entry.entryType === "severity") {
+    (update.$set as Record<string, unknown>)["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: Db,
+  input: AppendProblemEntryInput,
+  actorId: string
+): Promise<DxcRecord> {
+  const collection = db.collection<DxcRecord>("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: ProblemEntry = {
+    id: randomUUID(),
+    entryType: input.entryType,
+    body: input.body,
+    createdAt: now,
+    createdBy: actorId,
+    ...(input.rootCause ? { rootCause: input.rootCause } : {})
+  };
+  const update: Record<string, unknown> = {
+    $push: {
+      "fields.entries": entry
+    },
+    $set: {
+      updatedAt: now,
+      updatedBy: actorId
+    }
+  };
+
+  if (entry.entryType === "identified" || entry.entryType === "reopened") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "open");
+  }
+
+  if (entry.entryType === "known_error") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "known_error");
+  }
+
+  if (entry.entryType === "resolved") {
+    (update.$set as Record<string, unknown>)["fields.currentStatus"] = problemEntryToCurrentStatus(entry, "resolved");
+  }
+
+  if (entry.entryType === "root_cause") {
+    (update.$set as Record<string, unknown>)["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: Db,
+  input: AppendSupportRequestEntryInput,
+  actorId: string
+): Promise<DxcRecord> {
+  const collection = db.collection<DxcRecord>("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: SupportRequestEntry = {
+    id: randomUUID(),
+    entryType: input.entryType,
+    body: input.body,
+    createdAt: now,
+    createdBy: actorId,
+    ...(input.incidentId ? { incidentId: input.incidentId } : {})
+  };
+  const update: Record<string, unknown> = {
+    $push: {
+      "fields.entries": entry
+    },
+    $set: {
+      updatedAt: now,
+      updatedBy: actorId
+    }
+  };
+  const currentStatus = supportRequestEntryToCurrentStatus(entry, readSupportRequestStatus(existing));
+  if (currentStatus) {
+    (update.$set as Record<string, unknown>)["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: DecisionEntry): Record<string, unknown> {
   return {
     entryId: entry.id,
@@ -1229,6 +1881,138 @@ export function taskEntryToCurrentStatus(entry: TaskEntry): Record<string, unkno
   };
 }
 
+export function riskEntryToCurrentStatus(entry: RiskEntry, status: "open" | "closed"): Record<string, unknown> {
+  return {
+    entryId: entry.id,
+    status,
+    body: entry.body,
+    createdAt: entry.createdAt,
+    createdBy: entry.createdBy
+  };
+}
+
+export function riskEntryToCurrentAssessment(entry: RiskEntry): Record<string, unknown> {
+  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: RiskEntry): Record<string, unknown> {
+  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: IncidentEntry, status: "open" | "resolved"): Record<string, unknown> {
+  return {
+    entryId: entry.id,
+    status,
+    body: entry.body,
+    createdAt: entry.createdAt,
+    createdBy: entry.createdBy
+  };
+}
+
+export function incidentEntryToCurrentSeverity(entry: IncidentEntry): Record<string, unknown> {
+  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: ProblemEntry,
+  status: "open" | "known_error" | "resolved"
+): Record<string, unknown> {
+  return {
+    entryId: entry.id,
+    status,
+    body: entry.body,
+    createdAt: entry.createdAt,
+    createdBy: entry.createdBy
+  };
+}
+
+export function problemEntryToCurrentRootCause(entry: ProblemEntry): Record<string, unknown> {
+  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: SupportRequestEntry,
+  previousStatus?: Record<string, unknown>
+): Record<string, unknown> | undefined {
+  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: SupportRequestEntryType): "open" | "triaged" | "escalated" | "resolved" | undefined {
+  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: DxcRecord): Record<string, unknown> | undefined {
+  return record.fields.currentStatus && typeof record.fields.currentStatus === "object"
+    ? (record.fields.currentStatus as Record<string, unknown>)
+    : undefined;
+}
+
 function assertDecisionEntryInput(input: AppendDecisionEntryInput): void {
   if (input.entryType !== "decision" && (input.decidedBy || input.rationale)) {
     throw new Error("decidedBy and rationale are only valid on decision entries.");
@@ -1245,6 +2029,50 @@ function assertTaskEntryInput(input: AppendTaskEntryInput): void {
   }
 }
 
+function assertRiskEntryInput(input: AppendRiskEntryInput): void {
+  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: AppendIncidentEntryInput): void {
+  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: AppendProblemEntryInput): void {
+  if (input.entryType !== "root_cause" && input.rootCause) {
+    throw new Error("rootCause is only valid on root_cause entries.");
+  }
+}
+
+function assertSupportRequestEntryInput(input: AppendSupportRequestEntryInput): void {
+  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: DxcRecord,
   event: DeferralEvent,
@@ -1531,7 +2359,7 @@ export async function updateRecord(db: Db, input: UpdateRecordInput, actorId: st
     const existingVersionHistory = normalizeVersionHistory(existing.fields.versionHistory);
 
     if (changedFields.length === 0) {
-      return existing;
+      return withDerivedRecordFields(db, existing);
     }
 
     set["fields.versionHistory"] = [
@@ -1556,7 +2384,7 @@ export async function updateRecord(db: Db, input: UpdateRecordInput, actorId: st
     throw new Error(`Updated record not found: ${input.recordType}/${input.id}`);
   }
 
-  return updated;
+  return withDerivedRecordFields(db, updated);
 }
 
 function applyRecordUpdate(record: DxcRecord, input: UpdateRecordInput): DxcRecord {
@@ -1751,7 +2579,7 @@ export async function archiveRecord(db: Db, input: ArchiveRecordInput, actorId:
     throw new Error(`Archived record not found: ${input.recordType}/${input.id}`);
   }
 
-  return updated;
+  return withDerivedRecordFields(db, updated);
 }
 
 export async function linkRecords(
@@ -1809,7 +2637,7 @@ export async function linkRecords(
     throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
   }
 
-  return updated;
+  return withDerivedRecordFields(db, updated);
 }
 
 export async function unlinkRecords(
@@ -1866,7 +2694,7 @@ export async function unlinkRecords(
     throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
   }
 
-  return updated;
+  return withDerivedRecordFields(db, updated);
 }
 
 function assertFieldName(key: string): void {
@@ -1926,8 +2754,14 @@ function assertNotManagedField(recordType: CollectionName, key: string): void {
   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);
 }
@@ -2030,6 +2864,36 @@ function assertNotComponentManagedField(recordType: CollectionName, key: string)
   );
 }
 
+function assertNotMaintenanceScheduleManagedField(recordType: CollectionName, key: string): void {
+  if (recordType !== "maintenance_schedules" || !(MAINTENANCE_SCHEDULE_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
+  if (recordType !== "support_requests" || !(SUPPORT_REQUEST_LEDGER_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
+  if (recordType !== "value_realizations" || !(VALUE_REALIZATION_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
   if (recordType !== "decisions" || !(DECISION_LEDGER_MANAGED_FIELDS as readonly string[]).includes(key)) {
     return;
@@ -2050,6 +2914,36 @@ function assertNotTaskLedgerManagedField(recordType: CollectionName, key: string
   );
 }
 
+function assertNotRiskLedgerManagedField(recordType: CollectionName, key: string): void {
+  if (recordType !== "risks" || !(RISK_LEDGER_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
+  if (recordType !== "incidents" || !(INCIDENT_LEDGER_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
+  if (recordType !== "problems" || !(PROBLEM_LEDGER_MANAGED_FIELDS as readonly string[]).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: CollectionName, key: string): void {
   if (recordType !== "decisions" || !(DECISION_INPUT_MANAGED_FIELDS as readonly string[]).includes(key)) {
     return;
@@ -2091,6 +2985,14 @@ function versionedUpdateToolName(recordType: CollectionName): string {
     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";
   }