dxcomplete 0.1.0 → 0.2.1

package/scripts/smoke-mcp-http.mjs

@@ -25,7 +25,7 @@ import { loadWorkspaceConfig } from "../dist/runtime/workspace.js";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const runId = `smoke-http-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
-const expectedHostedToolCount = 49;
+const expectedHostedToolCount = 60;
 const smokeTimeoutMs = 60_000;
 const smokeCleanupActorId = "dxcomplete-http-smoke";
 const smokeStartedAt = Date.now();
@@ -44,6 +44,11 @@ const smokeRecordTypes = [
   "commitments",
   "deferrals",
   "changes",
+  "incidents",
+  "problems",
+  "maintenance_schedules",
+  "support_requests",
+  "value_realizations",
   "decisions",
   "risks"
 ];
@@ -69,6 +74,11 @@ let createdBenefitsId;
 let createdCommitmentId;
 let createdDeferralId;
 let createdChangeId;
+let createdChangeEnvironmentId;
+let createdChangeComponentId;
+let createdIncidentId;
+let createdProblemId;
+let createdRiskId;
 let createdDecisionId;
 let createdServiceClientId;
 
@@ -346,6 +356,16 @@ try {
   assert(status.server.tools.includes("append_deferral_event"), "Hosted surface is missing append_deferral_event.");
   assert(status.server.tools.includes("create_change"), "Hosted surface is missing create_change.");
   assert(status.server.tools.includes("append_change_event"), "Hosted surface is missing append_change_event.");
+  for (const itsmToolName of [
+    "create_risk",
+    "append_risk_entry",
+    "create_incident",
+    "append_incident_entry",
+    "create_problem",
+    "append_problem_entry"
+  ]) {
+    assert(status.server.tools.includes(itsmToolName), `Hosted surface is missing ${itsmToolName}.`);
+  }
   assert(status.server.tools.includes("link_decision_input"), "Hosted surface is missing link_decision_input.");
   assert(status.server.tools.includes("unlink_records"), "Hosted surface is missing unlink_records.");
   assert(status.server.tools.includes("append_decision_entry"), "Hosted surface is missing append_decision_entry.");
@@ -605,6 +625,11 @@ try {
       processGuide.runtimeRecordTypes?.includes("components"),
     "environments and components should appear as current runtime record types."
   );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("incidents") &&
+      processGuide.runtimeRecordTypes?.includes("problems"),
+    "incidents and problems should appear as current runtime record types."
+  );
   for (const removedRuntimeRecordType of [
     "service_charters",
     "business_cases",
@@ -644,6 +669,20 @@ try {
       processGuideText.includes("component"),
     "Hosted process guide should describe Operational Registry routing."
   );
+  const roleOperatingGuidanceText = JSON.stringify(processGuide.roleOperatingGuidance ?? []);
+  assert(
+    roleOperatingGuidanceText.includes("Default to Requirement -> Task") &&
+      roleOperatingGuidanceText.includes("Use Change for discrete run-side alterations") &&
+      roleOperatingGuidanceText.includes("DX Complete Ticket"),
+    "Hosted process guide should include compact role operating guidance."
+  );
+  const itsmGuidanceText = JSON.stringify(processGuide.itsmGuidance ?? []);
+  assert(
+    itsmGuidanceText.includes("Incident is the current first-class record") &&
+      itsmGuidanceText.includes("Problem is the current first-class record") &&
+      itsmGuidanceText.includes("Do not create ITSM-style records merely because work is happening"),
+    "Hosted process guide should describe current Incident/Problem records with restraint guidance."
+  );
 
   const rolesDoc = await callJsonTool("get_doc", { page: "roles" });
   assert(rolesDoc.surfaceVersion === status.server.surfaceVersion, "Hosted get_doc surface version did not match runtime_status.");
@@ -673,6 +712,21 @@ try {
   for (const oldRoleName of ["Director", "Product Lead", "Product", "Engineering", "Coder", "QA", "Operations", "Support", "Admin", "Client/User"]) {
     assert(!actualRoleNames.includes(oldRoleName), `Hosted get_doc roles should not include old role ${oldRoleName}.`);
   }
+  const operatingGuideDoc = await callJsonTool("get_doc", { page: "operating_guide" });
+  assert(
+    operatingGuideDoc.surfaceFingerprint === status.server.surfaceFingerprint,
+    "Hosted get_doc operating guide fingerprint did not match runtime_status."
+  );
+  const operatingGuideText = JSON.stringify(operatingGuideDoc);
+  assert(
+      operatingGuideDoc.roles?.some(
+        (role) => role.name === "Engineer and Codex assistance" && role.use.includes("Requirement to Task")
+      ) &&
+      operatingGuideDoc.roles?.some((role) => role.name === "Operator and administration" && role.defaultRecords.includes("Incident") && role.defaultRecords.includes("Problem")) &&
+      operatingGuideText.includes("specific service-impacting") &&
+      operatingGuideText.includes("DX Complete Ticket"),
+    "Hosted get_doc operating guide should include role routing, Change boundary, tickets, and Incident/Problem guidance."
+  );
 
   const glossaryDoc = await callJsonTool("get_doc", { page: "glossary" });
   assert(
@@ -1757,9 +1811,71 @@ try {
     "append_deferral_event"
   );
 
+  const risk = await callJsonTool("create_risk", {
+    title: `DX Complete hosted MCP smoke risk ${runId}`,
+    topic: "Smoke uncertainty.",
+    likelihood: "low",
+    impact: "low",
+    treatment: "mitigate",
+    treatmentRationale: "Smoke risk is mitigated by cleanup."
+  });
+  createdRiskId = risk._id;
+  assert(risk.recordType === "risks", "Hosted create_risk created the wrong record type.");
+  assert(risk.readableId?.startsWith("RSK-"), "Hosted Risk did not receive an RSK readable ID.");
+  assert(risk.fields.currentStatus?.status === "open", "Hosted Risk did not derive current status.");
+  assert(risk.fields.currentAssessment?.likelihood === "low", "Hosted Risk did not derive current assessment.");
+  assert(risk.fields.currentTreatment?.treatment === "mitigate", "Hosted Risk did not derive current treatment.");
+  const reassessedRisk = await callJsonTool("append_risk_entry", {
+    riskId: risk._id,
+    entryType: "assessment",
+    body: "Smoke reassessment.",
+    likelihood: "medium",
+    impact: "high"
+  });
+  assert(reassessedRisk.fields.currentAssessment?.impact === "high", "Hosted Risk assessment did not derive from latest assessment entry.");
+  const closedRisk = await callJsonTool("append_risk_entry", {
+    riskId: risk._id,
+    entryType: "closed",
+    body: "Smoke risk closed."
+  });
+  assert(closedRisk.fields.currentStatus?.status === "closed", "Hosted Risk status did not derive from closed entry.");
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "risks",
+      title: `DX Complete hosted MCP direct risk ${runId}`,
+      fields: { entries: [] }
+    },
+    "append_risk_entry"
+  );
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "risks",
+      id: risk._id,
+      unsetFields: ["currentStatus"]
+    },
+    "append_risk_entry"
+  );
+
+  const changeEnvironment = await callJsonTool("create_environment", {
+    name: `DX Complete hosted MCP smoke change environment ${runId}`,
+    summary: "Change smoke environment."
+  });
+  createdChangeEnvironmentId = changeEnvironment._id;
+  const changeComponent = await callJsonTool("create_component", {
+    name: `DX Complete hosted MCP smoke change component ${runId}`,
+    environmentId: changeEnvironment._id,
+    kind: "smoke component",
+    locator: { route: "/smoke-change" }
+  });
+  createdChangeComponentId = changeComponent._id;
+
   const change = await callJsonTool("create_change", {
     title: `DX Complete hosted MCP smoke change ${runId}`,
     summary: "Change used by the hosted MCP smoke test.",
+    changeType: "emergency",
+    emergencyImportance: "Smoke change importance is only test coverage.",
     changePlan: "Record a harmless smoke-test service change.",
     executionSteps: ["Create the Change record.", "Append the smoke-test events."],
     rollbackPlan: "Archive the smoke-test records during cleanup.",
@@ -1774,6 +1890,8 @@ try {
   assert(Array.isArray(change.fields.executionSteps) && change.fields.executionSteps.length === 2, "Hosted Change did not store executionSteps.");
   assert(change.fields.rollbackPlan?.includes("Archive"), "Hosted Change did not store rollbackPlan.");
   assert(change.fields.riskImpact?.includes("No service impact"), "Hosted Change did not store riskImpact.");
+  assert(change.fields.changeType === "emergency", "Hosted Change did not store changeType.");
+  assert(change.fields.emergencyRationaleGaps?.includes("emergencyImmediacy"), "Hosted emergency Change did not expose missing immediacy rationale.");
   assert(
     change.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "for_requirement"),
     "Hosted create_change did not link to the requirement."
@@ -1802,14 +1920,53 @@ try {
     "Hosted Change veto event did not store the veto role."
   );
 
+  const changeWithResultCommit = await callJsonTool("append_change_event", {
+    changeId: change._id,
+    eventType: "result_reported",
+    result: "completed",
+    summary: "Smoke result with Git reference.",
+    gitCommitReferences: [
+      {
+        commit: "abc1234",
+        repository: "smoke-repo",
+        url: "https://example.test/smoke-repo/commit/abc1234"
+      }
+    ]
+  });
+  const resultEvent = changeWithResultCommit.fields.events?.at(-1);
+  assert(resultEvent?.gitCommitReferences?.[0]?.commit === "abc1234", "Hosted Change result event did not store Git commit reference.");
+  assert(resultEvent?.gitCommitReferences?.[0]?.repository === "smoke-repo", "Hosted Change result event did not store Git repository reference.");
+
+  const changeWithRecoveryCommit = await callJsonTool("append_change_event", {
+    changeId: change._id,
+    eventType: "recovery_recorded",
+    summary: "Smoke recovery with rollback commit reference.",
+    gitCommitReferences: [{ commit: "def5678" }]
+  });
+  assert(
+    changeWithRecoveryCommit.fields.events?.at(-1)?.gitCommitReferences?.[0]?.commit === "def5678",
+    "Hosted Change recovery event did not store Git commit reference."
+  );
+
   await expectToolError(
     "append_change_event",
     {
       changeId: change._id,
       eventType: "emergency_declared",
-      importance: "Smoke test importance without immediacy."
+      note: "Emergency is modeled through changeType, not an event."
+    },
+    "Invalid option"
+  );
+
+  await expectToolError(
+    "append_change_event",
+    {
+      changeId: change._id,
+      eventType: "notice_given",
+      notice: "Smoke notice with invalid Git reference.",
+      gitCommitReferences: [{ commit: "abc1234" }]
     },
-    "emergency_declared requires immediacy"
+    "gitCommitReferences"
   );
 
   await expectToolError(
@@ -1853,6 +2010,111 @@ try {
     "Hosted list_linked_records did not return the linked requirement for Change."
   );
 
+  const incident = await callJsonTool("create_incident", {
+    title: `DX Complete hosted MCP smoke incident ${runId}`,
+    description: "Smoke Incident for Change linkage.",
+    severity: "low",
+    componentIds: [changeComponent._id]
+  });
+  createdIncidentId = incident._id;
+  assert(incident.recordType === "incidents", "Hosted create_incident created the wrong record type.");
+  assert(incident.readableId?.startsWith("INC-"), "Hosted Incident did not receive an INC readable ID.");
+  assert(incident.fields.currentStatus?.status === "open", "Hosted Incident did not derive current status.");
+  assert(incident.fields.currentSeverity?.severity === "low", "Hosted Incident did not derive current severity.");
+  assert(
+    incident.links.some((link) => link.toType === "components" && link.toId === changeComponent._id && link.relationship === "affects"),
+    "Hosted Incident did not link affected Component."
+  );
+
+  const resolvedIncident = await callJsonTool("append_incident_entry", {
+    incidentId: incident._id,
+    entryType: "resolved",
+    body: "Smoke Incident resolved."
+  });
+  assert(resolvedIncident.fields.currentStatus?.status === "resolved", "Hosted Incident status did not derive from resolved entry.");
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "incidents",
+      title: `DX Complete hosted MCP direct incident ${runId}`,
+      fields: { entries: [] }
+    },
+    "append_incident_entry"
+  );
+
+  const problem = await callJsonTool("create_problem", {
+    title: `DX Complete hosted MCP smoke problem ${runId}`,
+    description: "Smoke Problem evidenced by the smoke Incident.",
+    incidentIds: [incident._id],
+    componentIds: [changeComponent._id]
+  });
+  createdProblemId = problem._id;
+  assert(problem.recordType === "problems", "Hosted create_problem created the wrong record type.");
+  assert(problem.readableId?.startsWith("PRB-"), "Hosted Problem did not receive a PRB readable ID.");
+  assert(problem.fields.currentStatus?.status === "open", "Hosted Problem did not derive current status.");
+  assert(
+    problem.links.some((link) => link.toType === "incidents" && link.toId === incident._id && link.relationship === "evidenced_by"),
+    "Hosted Problem did not link to the evidencing Incident."
+  );
+
+  const problemWithRootCause = await callJsonTool("append_problem_entry", {
+    problemId: problem._id,
+    entryType: "root_cause",
+    body: "Smoke root cause.",
+    rootCause: "Smoke root cause."
+  });
+  assert(problemWithRootCause.fields.currentRootCause?.rootCause === "Smoke root cause.", "Hosted Problem root cause did not derive from entry.");
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "problems",
+      id: problem._id,
+      unsetFields: ["entries"]
+    },
+    "append_problem_entry"
+  );
+
+  await callJsonTool("link_records", {
+    fromType: "changes",
+    fromId: change._id,
+    toType: "components",
+    toId: changeComponent._id,
+    relationship: "affects"
+  });
+  await callJsonTool("link_records", {
+    fromType: "changes",
+    fromId: change._id,
+    toType: "incidents",
+    toId: incident._id,
+    relationship: "caused"
+  });
+  await callJsonTool("link_records", {
+    fromType: "changes",
+    fromId: change._id,
+    toType: "incidents",
+    toId: incident._id,
+    relationship: "resolved"
+  });
+  const changeComponentLinks = await callJsonTool("list_linked_records", {
+    recordType: "changes",
+    id: change._id,
+    relationship: "affects"
+  });
+  assert(
+    changeComponentLinks.outbound.some((entry) => entry.record._id === changeComponent._id),
+    "Hosted Change did not link to affected Component."
+  );
+  const changeIncidentLinks = await callJsonTool("list_linked_records", {
+    recordType: "incidents",
+    id: incident._id,
+    direction: "inbound",
+    relationship: "resolved"
+  });
+  assert(
+    changeIncidentLinks.inbound.some((entry) => entry.record._id === change._id),
+    "Hosted inbound traversal did not find Change resolved Incident link."
+  );
+
   const referencedRequirement = await callJsonTool("link_records", {
     fromType: "requirements",
     fromId: requirement._id,
@@ -2243,7 +2505,12 @@ try {
   await archiveCreatedRecord("requirements", createdRequirementId);
   await archiveCreatedRecord("estimates", createdEstimateId);
   await archiveCreatedRecord("benefits", createdBenefitsId);
+  await archiveCreatedRecord("problems", createdProblemId);
+  await archiveCreatedRecord("incidents", createdIncidentId);
   await archiveCreatedRecord("changes", createdChangeId);
+  await archiveCreatedRecord("components", createdChangeComponentId);
+  await archiveCreatedRecord("environments", createdChangeEnvironmentId);
+  await archiveCreatedRecord("risks", createdRiskId);
   await archiveCreatedRecord("commitments", createdCommitmentId);
   await archiveCreatedRecord("deferrals", createdDeferralId);
   await archiveCreatedRecord("expectations", createdExpectationId);
@@ -2568,6 +2835,12 @@ async function runSurfaceSection({ mcpUrl, actor }) {
     "create_estimate",
     "create_benefits",
     "create_change",
+    "create_incident",
+    "append_incident_entry",
+    "create_problem",
+    "append_problem_entry",
+    "create_risk",
+    "append_risk_entry",
     "create_decision",
     "append_decision_entry",
     "link_decision_input",
@@ -2598,7 +2871,7 @@ async function runSurfaceSection({ mcpUrl, actor }) {
     assert(!status.server.tools.includes(removedToolName), `Hosted runtime should not expose removed tool ${removedToolName}.`);
   }
   assert(manifestByName.get("get_doc")?.inputFields.join(",") === "page,term", "Hosted get_doc should expose page and optional term inputs.");
-  for (const toolName of ["get_doc", "create_statement", "update_statement", "create_expectation", "create_task", "append_task_entry", "create_environment", "update_environment", "list_environments", "create_component", "update_component", "list_components", "create_estimate", "create_benefits", "create_change", "create_decision", "append_decision_entry", "link_decision_input", "append_journal_note", "read_journal", "get_journal_entry", "append_journal_summary"]) {
+  for (const toolName of ["get_doc", "create_statement", "update_statement", "create_expectation", "create_task", "append_task_entry", "create_environment", "update_environment", "list_environments", "create_component", "update_component", "list_components", "create_estimate", "create_benefits", "create_change", "create_incident", "append_incident_entry", "create_problem", "append_problem_entry", "create_risk", "append_risk_entry", "create_decision", "append_decision_entry", "link_decision_input", "append_journal_note", "read_journal", "get_journal_entry", "append_journal_summary"]) {
     assert(!manifestByName.get(toolName)?.inputFields.includes("workspaceId"), `${toolName} should not expose workspaceId on the hosted surface.`);
   }
 
@@ -2668,12 +2941,31 @@ async function runDocsSection() {
       processGuide.recordRoutingGuidance?.sharpTest?.includes("Will anything reference or depend on this"),
     "Process guide should include compact record-routing guidance."
   );
+  const roleOperatingGuidanceText = JSON.stringify(processGuide.roleOperatingGuidance ?? []);
+  assert(
+    roleOperatingGuidanceText.includes("Default to Requirement -> Task") &&
+      roleOperatingGuidanceText.includes("Use Change for discrete run-side alterations") &&
+      roleOperatingGuidanceText.includes("DX Complete Ticket"),
+    "Process guide should include compact role operating guidance."
+  );
+  const itsmGuidanceText = JSON.stringify(processGuide.itsmGuidance ?? []);
+  assert(
+    itsmGuidanceText.includes("Incident is the current first-class record") &&
+      itsmGuidanceText.includes("Problem is the current first-class record") &&
+      itsmGuidanceText.includes("Do not create ITSM-style records merely because work is happening"),
+    "Process guide should describe current Incident/Problem records with restraint guidance."
+  );
   assert(processGuide.phases.map((phase) => phase.id).join(",") === "orient,elicit,weigh,build,go_live,operate,measure", "Process guide returned an unexpected phase order.");
   assert(processGuide.runtimeRecordTypes?.includes("statements"), "Process guide should include statements.");
   assert(processGuide.runtimeRecordTypes?.includes("journal_entries"), "Process guide should include journal_entries.");
   assert(processGuide.runtimeRecordTypes?.includes("environments"), "Process guide should include environments.");
   assert(processGuide.runtimeRecordTypes?.includes("components"), "Process guide should include components.");
+  assert(processGuide.runtimeRecordTypes?.includes("maintenance_schedules"), "Process guide should include maintenance_schedules.");
   assert(processGuide.runtimeRecordTypes?.includes("benefits"), "Process guide should include benefits.");
+  assert(processGuide.runtimeRecordTypes?.includes("value_realizations"), "Process guide should include value_realizations.");
+  assert(processGuide.runtimeRecordTypes?.includes("incidents"), "Process guide should include incidents.");
+  assert(processGuide.runtimeRecordTypes?.includes("problems"), "Process guide should include problems.");
+  assert(processGuide.runtimeRecordTypes?.includes("support_requests"), "Process guide should include support_requests.");
   assert(!processGuide.runtimeRecordTypes?.includes("initiatives"), "Process guide should not include initiatives.");
   for (const removedRuntimeRecordType of ["service_charters", "cost_baselines", "cost_actuals", "benefit_measurements"]) {
     assert(!processGuide.runtimeRecordTypes?.includes(removedRuntimeRecordType), `Process guide should not include ${removedRuntimeRecordType}.`);
@@ -2682,6 +2974,19 @@ async function runDocsSection() {
   const rolesDoc = await callJsonTool("get_doc", { page: "roles" });
   assert(rolesDoc.surfaceFingerprint === status.server.surfaceFingerprint, "Roles doc fingerprint did not match runtime_status.");
   assert(rolesDoc.roles?.map((role) => role.name).join(",") === "Owner,Engineer,Tester,Operator,Support Agent,End User", "Roles doc did not return the locked six-role model.");
+  const operatingGuideDoc = await callJsonTool("get_doc", { page: "operating_guide" });
+  assert(operatingGuideDoc.surfaceFingerprint === status.server.surfaceFingerprint, "Operating guide doc fingerprint did not match runtime_status.");
+  const operatingGuideText = JSON.stringify(operatingGuideDoc);
+  assert(
+      operatingGuideDoc.roles?.some(
+        (role) => role.name === "Engineer and Codex assistance" && role.use.includes("Requirement to Task")
+      ) &&
+      operatingGuideDoc.roles?.some((role) => role.name === "Operator and administration" && role.defaultRecords.includes("Incident") && role.defaultRecords.includes("Problem") && role.defaultRecords.includes("Maintenance Schedule")) &&
+      operatingGuideDoc.roles?.some((role) => role.name === "Support Agent" && role.defaultRecords.includes("Support Request")) &&
+      operatingGuideText.includes("specific service-impacting") &&
+      operatingGuideText.includes("DX Complete Ticket"),
+    "Operating guide doc should include role routing, Change boundary, tickets, and Incident/Problem guidance."
+  );
 
   const recordsDoc = await callJsonTool("get_doc", { page: "records" });
   const recordNames = recordsDoc.groups?.flatMap((group) => group.records.map((record) => record.name)) ?? [];
@@ -2690,9 +2995,14 @@ async function runDocsSection() {
       recordNames.includes("Journal") &&
       recordNames.includes("Environment") &&
       recordNames.includes("Component") &&
+      recordNames.includes("Maintenance Schedule") &&
       recordNames.includes("Estimate") &&
-      recordNames.includes("Benefits"),
-    "Records doc should include Statement, Journal, Environment, Component, Estimate, and Benefits."
+      recordNames.includes("Benefits") &&
+      recordNames.includes("Value Realization") &&
+      recordNames.includes("Incident") &&
+      recordNames.includes("Problem") &&
+      recordNames.includes("Support Request"),
+    "Records doc should include Statement, Journal, Environment, Component, Maintenance Schedule, Estimate, Benefits, Value Realization, Incident, Problem, and Support Request."
   );
   assert(
     recordsDoc.routingGuidance?.sharpTest?.includes("Will anything reference or depend on this") &&
@@ -2719,8 +3029,26 @@ async function runDocsSection() {
       registryDoc.term?.definition.includes("not monitoring"),
     "Operational Registry glossary term should describe inventory-only boundaries."
   );
+  const incidentDoc = await callJsonTool("get_doc", { page: "glossary", term: "incident" });
+  assert(
+    incidentDoc.term?.definition.includes("specific service-impacting") &&
+      incidentDoc.term?.definition.includes("ordered entries"),
+    "Incident glossary term should describe the current Incident ledger record."
+  );
+  const problemDoc = await callJsonTool("get_doc", { page: "glossary", term: "problem" });
+  assert(
+    problemDoc.term?.definition.includes("underlying or recurring cause") &&
+      problemDoc.term?.definition.includes("Incidents"),
+    "Problem glossary term should describe the current Problem ledger record."
+  );
   const componentDoc = await callJsonTool("get_doc", { page: "glossary", term: "component" });
   assert(componentDoc.term?.definition.includes("one Environment"), "Component glossary term should describe one-environment scope.");
+  const maintenanceDoc = await callJsonTool("get_doc", { page: "glossary", term: "maintenance schedule" });
+  assert(maintenanceDoc.term?.definition.includes("cadence"), "Maintenance Schedule glossary term should describe cadence.");
+  const supportRequestDoc = await callJsonTool("get_doc", { page: "glossary", term: "support request" });
+  assert(supportRequestDoc.term?.definition.includes("workspace-visible follow-up"), "Support Request glossary term should describe shared follow-up.");
+  const valueRealizationDoc = await callJsonTool("get_doc", { page: "glossary", term: "value realization" });
+  assert(valueRealizationDoc.term?.definition.includes("baseline") && valueRealizationDoc.term?.definition.includes("actual"), "Value Realization glossary term should describe baseline and actual metrics.");
   const secretPointerDoc = await callJsonTool("get_doc", { page: "glossary", term: "secret pointer" });
   assert(secretPointerDoc.term?.definition.includes("should not contain the secret value"), "Secret Pointer glossary term should warn against secret values.");
   await expectToolError("get_doc", { page: "glossary", term: "voice" }, "Glossary term not found");
@@ -2841,6 +3169,50 @@ async function runRecordsSection(cleanupRecords) {
     body: "Invalid task comment.",
     status: "done"
   }, "status is only valid");
+  const maintenanceSchedule = await callJsonTool("create_maintenance_schedule", {
+    name: `DX Complete hosted MCP smoke maintenance ${runId}`,
+    kind: "temporary smoke maintenance",
+    cadence: { count: 1, unit: "day" },
+    startDate: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString(),
+    rationale: "Exercise recurring operational hygiene tracking."
+  });
+  cleanupRecords.push(["maintenance_schedules", maintenanceSchedule._id]);
+  assert(maintenanceSchedule.recordType === "maintenance_schedules", "Records smoke Maintenance Schedule had the wrong record type.");
+  assert(/^MNT-\d{4,}$/.test(maintenanceSchedule.readableId ?? ""), "Maintenance Schedule did not receive an MNT readable ID.");
+  assert(maintenanceSchedule.derived?.overdue === true, "Maintenance Schedule should be overdue before a linked completion.");
+  await callJsonTool("link_records", {
+    fromType: "tasks",
+    fromId: task._id,
+    toType: "maintenance_schedules",
+    toId: maintenanceSchedule._id,
+    relationship: "assigned_to"
+  });
+  await callJsonTool("append_task_entry", {
+    taskId: task._id,
+    entryType: "status_change",
+    body: "Maintenance task completed.",
+    status: "done"
+  });
+  const maintenanceAfterCompletion = await callJsonTool("get_record", {
+    recordType: "maintenance_schedules",
+    id: maintenanceSchedule._id
+  });
+  assert(
+    maintenanceAfterCompletion.derived?.occurrenceCount >= 1 &&
+      maintenanceAfterCompletion.derived?.latestOccurrence?.recordType === "tasks",
+    "Maintenance Schedule did not derive occurrence state from a linked completed Task."
+  );
+  const updatedMaintenanceSchedule = await callJsonTool("update_maintenance_schedule", {
+    id: maintenanceSchedule._id,
+    notes: "Updated selected records smoke maintenance schedule.",
+    revisionNote: "Selected records smoke maintenance revision."
+  });
+  assert(updatedMaintenanceSchedule.fields.versionHistory?.length === 1, "Maintenance Schedule update did not preserve version history.");
+  await expectToolError("update_record", {
+    recordType: "maintenance_schedules",
+    id: maintenanceSchedule._id,
+    fields: { cadence: { count: 1, unit: "week" } }
+  }, "update_maintenance_schedule");
   await expectToolError("update_record", {
     recordType: "tasks",
     id: task._id,
@@ -3016,6 +3388,38 @@ async function runRecordsSection(cleanupRecords) {
     id: component._id,
     unsetFields: ["versionHistory"]
   }, "versionHistory");
+  const supportRequest = await callJsonTool("create_support_request", {
+    title: `DX Complete hosted MCP smoke support request ${runId}`,
+    reporter: "Smoke End User",
+    kind: "question",
+    reportedExperience: "The smoke user asked for help with a temporary workflow."
+  });
+  cleanupRecords.push(["support_requests", supportRequest._id]);
+  assert(supportRequest.recordType === "support_requests", "Records smoke Support Request had the wrong record type.");
+  assert(/^SUP-\d{4,}$/.test(supportRequest.readableId ?? ""), "Support Request did not receive an SUP readable ID.");
+  assert(supportRequest.fields.currentStatus?.status === "open", "Support Request did not derive initial open status.");
+  const triagedSupportRequest = await callJsonTool("append_support_request_entry", {
+    supportRequestId: supportRequest._id,
+    entryType: "triage",
+    body: "Support request triaged."
+  });
+  assert(triagedSupportRequest.fields.currentStatus?.status === "triaged", "Support Request triage did not derive current status.");
+  const resolvedSupportRequest = await callJsonTool("append_support_request_entry", {
+    supportRequestId: supportRequest._id,
+    entryType: "resolved",
+    body: "Support request resolved."
+  });
+  assert(resolvedSupportRequest.fields.currentStatus?.status === "resolved", "Support Request resolution did not derive current status.");
+  await expectToolError("create_record", {
+    recordType: "support_requests",
+    title: `DX Complete hosted MCP direct support request entries ${runId}`,
+    fields: { entries: [] }
+  }, "append_support_request_entry");
+  await expectToolError("append_support_request_entry", {
+    supportRequestId: supportRequest._id,
+    entryType: "escalated",
+    body: "Missing incident."
+  }, "incidentId");
   await assertReadableIdsContiguous();
   await expectToolError("update_record", {
     recordType: "requirements",
@@ -3085,6 +3489,54 @@ async function runWeighSection(cleanupRecords) {
     relationship: "informed_by"
   });
   assert(commitmentWithBenefits.links.some((link) => link.toType === "benefits" && link.relationship === "informed_by"), "Weigh smoke did not link Commitment to Benefits.");
+  const valueRealization = await callJsonTool("create_value_realization", {
+    title: `DX Complete hosted MCP smoke value realization ${runId}`,
+    requirementIds: [requirement._id],
+    commitmentIds: [commitment._id],
+    metrics: [
+      {
+        name: "Cycle time",
+        unit: "hours",
+        direction: "lower_is_better",
+        baseline: { value: 10, measuredAt: "2026-06-01T00:00:00.000Z" },
+        actual: { value: 7, measuredAt: "2026-06-02T00:00:00.000Z" }
+      },
+      {
+        name: "Satisfaction signal",
+        unit: "score",
+        direction: "higher_is_better",
+        baseline: { value: 3, measuredAt: "2026-06-01T00:00:00.000Z" }
+      }
+    ]
+  });
+  cleanupRecords.push(["value_realizations", valueRealization._id]);
+  assert(valueRealization.recordType === "value_realizations", "Weigh smoke Value Realization had the wrong record type.");
+  assert(/^VAL-\d{4,}$/.test(valueRealization.readableId ?? ""), "Value Realization did not receive a VAL readable ID.");
+  assert(
+    valueRealization.derived?.comparisons?.some((comparison) => comparison.name === "Cycle time" && comparison.outcome === "improved") &&
+      valueRealization.derived?.comparisons?.some((comparison) => comparison.name === "Satisfaction signal" && comparison.status === "open"),
+    "Value Realization did not derive measured/open comparisons."
+  );
+  const updatedValueRealization = await callJsonTool("update_value_realization", {
+    id: valueRealization._id,
+    metrics: [
+      {
+        id: valueRealization.fields.metrics[0].id,
+        name: "Cycle time",
+        unit: "hours",
+        direction: "lower_is_better",
+        baseline: { value: 10, measuredAt: "2026-06-01T00:00:00.000Z" },
+        actual: { value: 6, measuredAt: "2026-06-03T00:00:00.000Z" }
+      }
+    ],
+    revisionNote: "Weigh smoke value realization revision."
+  });
+  assert(updatedValueRealization.fields.versionHistory?.length === 1, "Value Realization update did not preserve version history.");
+  await expectToolError("update_record", {
+    recordType: "value_realizations",
+    id: valueRealization._id,
+    fields: { metrics: [] }
+  }, "update_value_realization");
 }
 
 async function runChangeSection(cleanupRecords) {
@@ -3342,6 +3794,8 @@ async function assertReadableIdsContiguous() {
     deferrals: "DFR",
     decisions: "DEC",
     changes: "CHG",
+    incidents: "INC",
+    problems: "PRB",
     risks: "RSK",
     estimates: "EST",
     benefits: "BFT"