dxcomplete 0.1.0 → 0.2.1

package/dist/mcp/server.js

@@ -4,7 +4,7 @@ import * as z from "zod/v4";
 import { DOC_PAGE_IDS, DOC_REFERENCE, getDocReference } from "./docs.js";
 import { createLocalActorContext } from "../runtime/actor.js";
 import { DXCOMPLETE_PACKAGE_VERSION, MCP_SURFACE_ID, WORKSPACE_COMPATIBILITY_VERSION } from "../version.js";
-import { COLLECTION_NAMES, RUNTIME_ACTOR_ID, appendChangeEvent, appendDecisionEntry, appendDeferralEvent, appendJournalNote, appendJournalSummary, appendReviewNote, appendTaskEntry, archiveRecord, appendDxcompleteTicket, archiveDxcompleteTicket, decisionEntryToCurrentDecision, createDxcompleteTicket, createRecord, getJournalEntry, getRecord, linkRecords, listDxcompleteTickets, listLinkedRecords, listUnreadDxcompleteTicketReplies, listRecords, readJournal, readDxcompleteTicket, taskEntryToCurrentStatus, unlinkRecords, updateRecord } from "../runtime/records.js";
+import { COLLECTION_NAMES, RUNTIME_ACTOR_ID, appendChangeEvent, appendDecisionEntry, appendDeferralEvent, appendIncidentEntry, appendJournalNote, appendJournalSummary, appendProblemEntry, appendReviewNote, appendRiskEntry, appendSupportRequestEntry, appendTaskEntry, archiveRecord, appendDxcompleteTicket, archiveDxcompleteTicket, decisionEntryToCurrentDecision, createDxcompleteTicket, createRecord, getJournalEntry, getRecord, incidentEntryToCurrentSeverity, incidentEntryToCurrentStatus, linkRecords, listDxcompleteTickets, listLinkedRecords, listUnreadDxcompleteTicketReplies, listRecords, readJournal, readDxcompleteTicket, problemEntryToCurrentStatus, riskEntryToCurrentAssessment, riskEntryToCurrentStatus, riskEntryToCurrentTreatment, supportRequestEntryToCurrentStatus, taskEntryToCurrentStatus, unlinkRecords, updateRecord } from "../runtime/records.js";
 const collectionSchema = z.enum(COLLECTION_NAMES);
 const workspaceScopedCollectionNames = COLLECTION_NAMES.filter((name) => name !== "workspaces");
 const hostedCollectionSchema = z.enum(workspaceScopedCollectionNames);
@@ -19,6 +19,37 @@ const requirementStatusSchema = z.enum(["draft", "ready", "approved", "supersede
 const taskStatusSchema = z.enum(["open", "in_progress", "blocked", "done"]);
 const decisionEntryTypeSchema = z.enum(["argument", "decision", "note"]);
 const taskEntryTypeSchema = z.enum(["comment", "status_change", "note"]);
+const riskEntryTypeSchema = z.enum(["identified", "assessment", "treatment", "monitor_note", "closed", "reopened"]);
+const riskLevelSchema = z.enum(["low", "medium", "high"]);
+const riskTreatmentSchema = z.enum(["accept", "mitigate", "transfer", "avoid"]);
+const incidentEntryTypeSchema = z.enum(["detected", "update", "severity", "resolved", "reopened", "note"]);
+const incidentSeveritySchema = z.enum(["low", "medium", "high", "critical"]);
+const problemEntryTypeSchema = z.enum([
+    "identified",
+    "investigation",
+    "root_cause",
+    "known_error",
+    "resolved",
+    "reopened",
+    "note"
+]);
+const supportRequestEntryTypeSchema = z.enum(["raised", "triage", "update", "escalated", "resolved", "reopened", "note"]);
+const maintenanceCadenceSchema = z.object({
+    count: z.number().int().min(1),
+    unit: z.enum(["day", "week", "month", "quarter", "year"])
+}).strict();
+const valueMetricMeasurementSchema = z.object({
+    value: z.number().finite(),
+    measuredAt: z.string().min(1)
+}).strict();
+const valueMetricSchema = z.object({
+    id: z.string().min(1).optional(),
+    name: z.string().min(1),
+    unit: z.string().min(1),
+    direction: z.enum(["lower_is_better", "higher_is_better"]),
+    baseline: valueMetricMeasurementSchema,
+    actual: valueMetricMeasurementSchema.optional()
+}).strict();
 const reviewableRecordTypeSchema = z.enum(["expectations", "requirements"]);
 const decisionInputRecordTypes = [
     "expectations",
@@ -30,24 +61,35 @@ const decisionInputRecordTypes = [
     "components",
     "estimates",
     "benefits",
+    "maintenance_schedules",
+    "support_requests",
+    "value_realizations",
     "risks",
     "changes",
+    "incidents",
+    "problems",
     "decisions"
 ];
 const decisionInputRecordTypeSchema = z.enum(decisionInputRecordTypes);
 const changeEventTypeSchema = z.enum([
     "notice_given",
     "veto_recorded",
-    "emergency_declared",
     "decision_recorded",
     "result_reported",
     "recovery_recorded",
     "plan_revised",
     "note_added"
 ]);
+const changeTypeSchema = z.enum(["standard", "normal", "emergency"]);
+const changeImpactGradeSchema = z.enum(["minor", "significant", "major"]);
 const changeVetoRoleSchema = z.enum(["Owner", "Engineer"]);
 const changeDecisionSchema = z.enum(["proceed", "defer", "cancel"]);
 const changeResultSchema = z.enum(["completed", "failed", "rolled_back"]);
+const gitCommitReferenceSchema = z.object({
+    commit: z.string().min(1),
+    repository: z.string().min(1).optional(),
+    url: z.string().min(1).optional()
+});
 const deferralEventTypeSchema = z.enum([
     "condition_addressed",
     "condition_reopened",
@@ -130,6 +172,11 @@ const CHANGE_TYPED_FIELDS = [
     "executionSteps",
     "rollbackPlan",
     "riskImpact",
+    "changeType",
+    "impactGrade",
+    "emergencyImportance",
+    "emergencyImmediacy",
+    "emergencyRationaleGaps",
     "plannedFor",
     "events"
 ];
@@ -148,6 +195,25 @@ const COMPONENT_TYPED_FIELDS = [
     "notes",
     "versionHistory"
 ];
+const MAINTENANCE_SCHEDULE_TYPED_FIELDS = [
+    "name",
+    "kind",
+    "cadence",
+    "startDate",
+    "rationale",
+    "notes",
+    "versionHistory"
+];
+const SUPPORT_REQUEST_TYPED_FIELDS = [
+    "workspaceId",
+    "reporter",
+    "kind",
+    "reportedExperience",
+    "entries",
+    "currentStatus",
+    "status"
+];
+const VALUE_REALIZATION_TYPED_FIELDS = ["metrics", "versionHistory"];
 const OBSOLETE_EXPECTATION_FIELDS = ["confirmationState", "ratifiedBy", "ratifiedAt"];
 const DECISION_INPUT_FIELDS = ["informedBy", "informedByIds", "inputRecords"];
 const DECISION_TYPED_FIELDS = [
@@ -164,6 +230,19 @@ const DECISION_TYPED_FIELDS = [
     "status"
 ];
 const TASK_TYPED_FIELDS = ["workspaceId", "description", "assignee", "assignor", "entries", "currentStatus", "details", "status"];
+const RISK_TYPED_FIELDS = [
+    "workspaceId",
+    "topic",
+    "entries",
+    "currentStatus",
+    "currentAssessment",
+    "currentTreatment",
+    "likelihood",
+    "impact",
+    "mitigation"
+];
+const INCIDENT_TYPED_FIELDS = ["workspaceId", "description", "entries", "currentStatus", "currentSeverity", "status", "severity"];
+const PROBLEM_TYPED_FIELDS = ["workspaceId", "description", "entries", "currentStatus", "currentRootCause", "status", "rootCause"];
 const PROCESS_GUIDE = {
     name: "DX Complete process guide",
     status: "Current operating guidance for working inside DX Complete. It is a lean guide for MCP clients; it is not the full reference, not a final model, and not a validation rule.",
@@ -183,6 +262,10 @@ const PROCESS_GUIDE = {
         {
             record: "Decision",
             use: "A recorded choice that can appear in any phase when a meaningful decision needs to remain legible."
+        },
+        {
+            record: "Support Request",
+            use: "Shared user-facing support follow-up for a reported experience, question, request, or issue."
         }
     ],
     recordRoutingGuidance: {
@@ -202,13 +285,41 @@ const PROCESS_GUIDE = {
                 use: "Use Task."
             },
             {
-                when: "The information is an event or controlled service/process history.",
-                use: "Use Change, Risk, or the matching event/history record."
+                when: "The information is a discrete alteration to the running service.",
+                use: "Use Change."
+            },
+            {
+                when: "The information is a specific service-impacting occurrence that needs response.",
+                use: "Use Incident."
+            },
+            {
+                when: "The information is an underlying or recurring cause behind one or more incidents.",
+                use: "Use Problem."
+            },
+            {
+                when: "The information is uncertainty or exposure.",
+                use: "Use Risk."
             },
             {
                 when: "The information is operational infrastructure state.",
                 use: "Use Environment and Component records in the Operational Registry; do not use Journal as the long-term home."
             },
+            {
+                when: "The information is recurring operational hygiene, such as a scheduled review, rotation, backup check, or maintenance duty.",
+                use: "Use Maintenance Schedule."
+            },
+            {
+                when: "The information is a user-facing question, request, or issue that needs shared support follow-up.",
+                use: "Use Support Request."
+            },
+            {
+                when: "The information is measured before/after value for an approved outcome or commitment.",
+                use: "Use Value Realization."
+            },
+            {
+                when: "The information is a private question, report, request, correction, or follow-up with DX Complete.",
+                use: "Use DX Complete Ticket."
+            },
             {
                 when: "The information is relevant context with no better home.",
                 use: "Use Journal."
@@ -216,6 +327,42 @@ const PROCESS_GUIDE = {
         ],
         promotion: "If Journal content becomes load-bearing, promote it to the appropriate dedicated record and link back where useful."
     },
+    roleOperatingGuidance: [
+        {
+            role: "Owner",
+            guidance: "Use Statement, Expectation, Benefits, Commitment, Deferral, Decision, Value Realization, and Risk records for direction, expected value, measured value, commitment, deferral, formal risk acceptance, and authority decisions."
+        },
+        {
+            role: "Engineer",
+            guidance: "Default to Requirement -> Task for implementation work. Use Decision for meaningful choices, Risk for uncertainty, Journal for relevant context with no better home, and Change only when the work becomes a run-side alteration."
+        },
+        {
+            role: "Codex assistance",
+            guidance: "Codex is a coding-capable tool used by the Engineer, not a DX Complete role. A fresh Codex instance should orient from get_process_guide, get_doc({ page: \"operating_guide\" }), and the installed Codex guidance before choosing records."
+        },
+        {
+            role: "Tester",
+            guidance: "Use Task entries, review notes, Risk, Decision, or Journal to keep verification evidence visible. Do not create Change records merely because testing is happening."
+        },
+        {
+            role: "Operator",
+            guidance: "Use Change for discrete run-side alterations, Incident for specific service-impacting occurrences, Problem for underlying or recurring causes, Environment and Component for operational inventory, Maintenance Schedule for recurring operational hygiene, and Risk or Decision where operations need accountability. Administration duties such as users, permissions, settings, provisioning, and run-side security live here."
+        },
+        {
+            role: "Support Agent",
+            guidance: "Use Support Request for shared user-facing support follow-up. Use DX Complete Ticket only for private questions, reports, requests, corrections, and follow-ups with DX Complete itself. Promote to Statement, Requirement, Task, Incident, Problem, Risk, Decision, Change, or Journal only when the signal has that meaning."
+        },
+        {
+            role: "End User",
+            guidance: "End User is not a DX Complete operator and does not approve records. Their input is captured by another role as Statement, report, request, correction, feedback signal, or ticket."
+        }
+    ],
+    itsmGuidance: [
+        "Change is the current first-class run-side control record.",
+        "Incident is the current first-class record for a specific service-impacting or potentially service-impacting occurrence.",
+        "Problem is the current first-class record for an underlying or recurring cause evidenced by one or more incidents.",
+        "Do not create ITSM-style records merely because work is happening; use Change, Incident, Problem, and Risk only when the record meaning fits."
+    ],
     phases: [
         {
             id: "orient",
@@ -382,10 +529,11 @@ const PROCESS_GUIDE = {
                 clientRole: "Help the Operator record the intended service change, readiness basis, execution path, rollback path, and resulting events.",
                 conductRules: [
                     "Use Change for a discrete alteration to the running service; reserve Operations Plan for a future standing operating model.",
-                    "Record the original change plan, execution steps, rollback plan, and risk or impact as the baseline.",
-                    "Use append-only Change events for notice, veto, emergency, decision, result, recovery, notes, and plan revisions.",
+                    "Record the original change plan, execution steps, rollback plan, and risk, impact, and downstream impact as the baseline.",
+                    "Classify the Change as standard, normal, or emergency, then use append-only Change events for notice, veto, decision, result, recovery, notes, and plan revisions.",
+                    "When result or recovery events have Git commits behind them, record optional Git commit references for that execution attempt or rollback.",
                     "Check readiness before putting the change into use.",
-                    "Make release, rollback, notice, veto, emergency, and communication risks visible.",
+                    "Make release, rollback, notice, veto, change type, and communication risks visible.",
                     "Do not treat vetoes or readiness checks as mechanical blockers; DX Complete records accountability and does not perform or enforce the operation.",
                     "Record open readiness risk when a readiness concern remains open."
                 ],
@@ -393,13 +541,15 @@ const PROCESS_GUIDE = {
                     "What is changing, why, and when is it planned?",
                     "What steps will carry out the change?",
                     "What rollback or recovery path exists if something goes wrong?",
+                    "What else may be affected, and what depends on what is changing?",
                     "Who needs to know about the change?",
                     "Has anyone recorded a veto or concern?",
                     "What readiness concerns are still open?"
                 ],
                 expectedOutput: [
-                    "Change record with change plan, execution steps, rollback plan, and risk or impact.",
-                    "Append-only Change events for notice, veto, emergency, decision, result, recovery, notes, or revisions where they occur.",
+                    "Change record with change plan, execution steps, rollback plan, and risk, impact, and downstream-impact notes.",
+                    "Append-only Change events for notice, veto, decision, result, recovery, notes, or revisions where they occur.",
+                    "Optional Git commit references on result or recovery events where they help trace the execution attempt.",
                     "Readiness basis.",
                     "Release or service-change decision context.",
                     "Visible open risks and any Owner risk-acceptance decisions."
@@ -408,7 +558,7 @@ const PROCESS_GUIDE = {
                 checkpointNotes: [
                     "Readiness checks reduce launch risk.",
                     "A veto by Owner or Engineer is a serious recorded event, not a mechanical stop.",
-                    "Emergency changes require both importance and immediacy to be recorded.",
+                    "Emergency changes should record both importance and immediacy where available; missing rationale remains visible but does not block the record.",
                     "Open readiness concerns can move forward only when the risk remains visible or is formally accepted by the Owner."
                 ]
             }
@@ -417,14 +567,16 @@ const PROCESS_GUIDE = {
             id: "operate",
             name: "Operate",
             purpose: "Run the service, help users, and respond when something goes wrong.",
-            commonRecords: ["Change", "DX Complete Ticket", "Risk", "Decision", "Task"],
+            commonRecords: ["Incident", "Problem", "Support Request", "Change", "Environment", "Component", "Maintenance Schedule", "DX Complete Ticket", "Risk", "Decision", "Task"],
             handoff: "Operational signals are handled or sent into measurement, improvement, or new work.",
             operatingGuidance: {
                 clientRole: "Help keep the service legible while it is running and route operational signals to the right follow-up.",
                 conductRules: [
                     "Separate immediate user-facing help from deeper improvement work.",
-                    "Record incidents, risks, decisions, or tasks when operational signals require shared follow-up.",
+                    "Record Incident for a specific service-impacting occurrence, Problem for an underlying or recurring cause, and Risk, Decision, or Task when those meanings fit.",
+                    "Use Support Request for shared user-facing support follow-up.",
                     "Use Change when the follow-up is a discrete alteration to the running service.",
+                    "Use Maintenance Schedule for recurring operational hygiene and link completed Changes or Tasks to it when the work is performed.",
                     "Do not assume the service is finished just because there is no active build.",
                     "Surface recurring signals for later improvement or measurement."
                 ],
@@ -432,11 +584,12 @@ const PROCESS_GUIDE = {
                     "Is the service running as intended?",
                     "What user-facing issue, operational issue, or risk needs attention?",
                     "Does this signal need immediate response, a task, a decision, or later improvement?",
+                    "Is this a shared support request, an incident, a problem, or recurring maintenance?",
                     "What operational follow-up remains open?"
                 ],
                 expectedOutput: [
                     "Handled operational signal or routed follow-up.",
-                    "Visible incidents, risks, decisions, or tasks where needed.",
+                    "Visible support requests, incidents, problems, maintenance schedules, risks, decisions, or tasks where needed.",
                     "Ongoing operating state."
                 ],
                 exitCheck: "Move to Measure when cost, benefit, reliability, or other operating data is available for comparison or learning.",
@@ -450,12 +603,13 @@ const PROCESS_GUIDE = {
             id: "measure",
             name: "Measure",
             purpose: "Compare expected and actual cost or benefit when data is available.",
-            commonRecords: ["Estimate", "Benefits", "Decision", "Risk"],
+            commonRecords: ["Value Realization", "Estimate", "Benefits", "Decision", "Risk"],
             handoff: "Learning from actuals is available for future estimates and decisions.",
             operatingGuidance: {
                 clientRole: "Help compare estimates to actuals where data exists and feed learning into future decisions.",
                 conductRules: [
                     "Capture actual cost or benefit observations when available.",
+                    "Use Value Realization for before/after metrics tied to expectations, requirements, or commitments.",
                     "Do not block closure or continued operation because actuals are unavailable.",
                     "Compare measured results to earlier estimates where possible.",
                     "Turn meaningful differences into learning, risk, decision context, or future work."
@@ -463,11 +617,13 @@ const PROCESS_GUIDE = {
                 questionsToAsk: [
                     "What actual cost or benefit data is available?",
                     "How does it compare with the estimate?",
+                    "Which value metric has a baseline, an actual measurement, or an open measurement gap?",
                     "What should future estimates or decisions learn from this?",
                     "Is new work, risk, or a decision needed because of the measurement?"
                 ],
                 expectedOutput: [
                     "Actual cost or benefit observations where available.",
+                    "Value Realization records for measured or still-open value metrics where useful.",
                     "Comparison to estimates where possible.",
                     "Learning for future estimates and decisions."
                 ],
@@ -508,7 +664,7 @@ const PROCESS_GUIDE = {
         "Formal risk acceptance is an Owner-level decision; domain actors may proceed, but proceeding does not close or accept the risk.",
         "Use Risk and Decision records to capture Owner risk acceptance or proceeding past an open checkpoint until dedicated checkpoint fields or tools are proven necessary.",
         "Use Decision input links to preserve which records informed important choices.",
-        "Use Change records for run-side service changes where notice, veto, emergency posture, execution, rollback, and result need an ordered audit trail."
+        "Use Change records for run-side service changes where change type, notice, veto, execution, rollback, result, and optional Git commit references need an ordered audit trail."
     ],
     nextStepGuidance: {
         responsibility: "The MCP client derives the next step from the current records, phase handoffs, operating guidance, open risks, and unanswered questions. DX Complete does not compute or prescribe a single server-side next step.",
@@ -564,7 +720,15 @@ const PROCESS_GUIDE = {
         },
         {
             record: "Change",
-            use: "A discrete service change record with baseline plan sections and append-only events for notice, veto, emergency posture, decision, result, recovery, notes, and revisions."
+            use: "A discrete service change record with baseline change type, plan sections, and append-only events for notice, veto, decision, result, recovery, notes, and revisions."
+        },
+        {
+            record: "Incident",
+            use: "A specific service-impacting or potentially service-impacting occurrence with an append-only entry log; current status and severity come from the latest relevant entries."
+        },
+        {
+            record: "Problem",
+            use: "An underlying or recurring cause evidenced by one or more Incidents, with an append-only entry log and current root cause derived from entries."
         },
         {
             record: "Environment",
@@ -574,6 +738,10 @@ const PROCESS_GUIDE = {
             record: "Component",
             use: "One environment-specific operational component with kind, structured locator, identifiers, secret pointers, notes, and version history."
         },
+        {
+            record: "Maintenance Schedule",
+            use: "A recurring operational hygiene record with cadence, start date, rationale, version history, and due state derived from linked completed Changes or Tasks."
+        },
         {
             record: "Estimate",
             use: "An Engineer cost input for Weigh, with itemized line items, scope links, cost-only roll-up totals, and version history."
@@ -582,6 +750,14 @@ const PROCESS_GUIDE = {
             record: "Benefits",
             use: "An Owner-authored benefit input for Weigh, with qualitative or quantified benefit items, scope links, quantified roll-up totals where amounts exist, and version history."
         },
+        {
+            record: "Value Realization",
+            use: "A measured-value record for before/after metrics tied to expectations, requirements, or commitments, with comparisons derived from baseline and actual values."
+        },
+        {
+            record: "Support Request",
+            use: "A shared support ledger for a user-facing reported experience, question, request, or issue; current status comes from ordered entries."
+        },
         {
             record: "Decision",
             use: "A revisitable choice record with an append-only entry log; current decision comes from the latest decision entry while earlier arguments and decisions remain visible."
@@ -589,9 +765,10 @@ const PROCESS_GUIDE = {
     ],
     clientGuidance: [
         "Use get_process_guide when you need the current DX Complete phase language.",
-        "Use get_doc for the fuller reference on outcomes, flow, records, roles, and glossary terms.",
+        "Use get_doc for the fuller reference on outcomes, flow, records, roles, operating guide, and glossary terms.",
+        "Use get_doc({ page: \"operating_guide\" }) when a fresh client or agent needs role-by-role record routing.",
         "Use DX Complete Ticket tools for private questions, reports, requests, corrections, or follow-ups.",
-        "Use Journal tools only after checking whether the information belongs in Statement, Expectation, Requirement, Decision, Task, Change, Risk, Environment, Component, or another dedicated record.",
+        "Use Journal tools only after checking whether the information belongs in Statement, Expectation, Requirement, Decision, Task, Change, Incident, Problem, Support Request, Risk, Environment, Component, Maintenance Schedule, Value Realization, or another dedicated record.",
         "Use workspace-scoped records for shared process work.",
         "Use readableId values such as REQ-0001 as human-facing references when a tool accepts an existing record id; UUID remains the primary key and link target.",
         "Hosted MCP access derives workspace scope from installed repo config and actor scope from OAuth.",
@@ -599,6 +776,8 @@ const PROCESS_GUIDE = {
         "Use append_decision_entry and append_task_entry for Decision and Task history; do not rewrite their current decision or status directly.",
         "Use link_decision_input when a record informed a Decision; use list_linked_records with relationship informed_by to review the decision inputs.",
         "Use Benefits for Owner-authored benefit lists; use Estimate for Engineer cost estimates.",
+        "Use Value Realization for measured before/after value, not for expected benefits.",
+        "Use Support Request for shared user-facing support follow-up; use DX Complete Ticket for private communication with DX Complete.",
         "Use link_records and unlink_records for other relationships between records."
     ]
 };
@@ -716,7 +895,7 @@ export function createMcpServer(runtime, options = {}) {
         });
     });
     registerDxcTool("get_doc", {
-        description: "Get an on-demand DX Complete reference page for MCP clients. Use this for fuller outcomes, flow, records, roles, and glossary content without loading all documentation into the process guide.",
+        description: "Get an on-demand DX Complete reference page for MCP clients. Use this for fuller outcomes, flow, records, roles, operating guide, and glossary content without loading all documentation into the process guide.",
         inputSchema: {
             page: z.enum(DOC_PAGE_IDS),
             term: z.string().min(1).optional()
@@ -948,6 +1127,37 @@ export function createMcpServer(runtime, options = {}) {
             revisionNote: z.string().min(1).optional()
         }
     }, async (input) => jsonResult(await updateComponent(runtime, input, recordActorId)));
+    registerDxcTool("create_maintenance_schedule", {
+        description: "Create a Maintenance Schedule for recurring operational hygiene. Due state is derived from cadence and linked completed Changes or Tasks.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            name: z.string().min(1),
+            kind: z.string().min(1),
+            cadence: maintenanceCadenceSchema,
+            startDate: z.string().min(1),
+            summary: z.string().min(1).optional(),
+            rationale: z.string().min(1).optional(),
+            notes: z.string().min(1).optional(),
+            fields: recordFieldsSchema
+        }
+    }, async (input) => jsonResult(await createMaintenanceSchedule(runtime, input, recordActorId)));
+    registerDxcTool("update_maintenance_schedule", {
+        description: "Update a Maintenance Schedule while preserving prior versions.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            id: z.string().min(1),
+            name: z.string().min(1).optional(),
+            kind: z.string().min(1).optional(),
+            cadence: maintenanceCadenceSchema.optional(),
+            startDate: z.string().min(1).optional(),
+            summary: z.string().min(1).optional(),
+            rationale: z.string().min(1).optional(),
+            notes: z.string().min(1).optional(),
+            fields: recordFieldsSchema,
+            unsetFields: z.array(fieldNameSchema).optional(),
+            revisionNote: z.string().min(1).optional()
+        }
+    }, async (input) => jsonResult(await updateMaintenanceSchedule(runtime, input, recordActorId)));
     registerDxcTool("create_estimate", {
         description: "Create an itemized Engineer cost estimate for Weigh.",
         inputSchema: {
@@ -998,6 +1208,32 @@ export function createMcpServer(runtime, options = {}) {
             revisionNote: z.string().min(1).optional()
         }
     }, async (input) => jsonResult(await updateBenefits(runtime, input, recordActorId)));
+    registerDxcTool("create_value_realization", {
+        description: "Create a Value Realization record for measured before/after value. Comparisons are derived from baseline and actual metric values.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            title: z.string().min(1),
+            summary: z.string().min(1).optional(),
+            metrics: z.array(valueMetricSchema).min(1),
+            requirementIds: z.array(z.string().min(1)).optional(),
+            expectationIds: z.array(z.string().min(1)).optional(),
+            commitmentIds: z.array(z.string().min(1)).optional(),
+            fields: recordFieldsSchema
+        }
+    }, async (input) => jsonResult(await createValueRealization(runtime, input, recordActorId)));
+    registerDxcTool("update_value_realization", {
+        description: "Update a Value Realization record while preserving prior metric versions.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            id: z.string().min(1),
+            title: z.string().min(1).optional(),
+            summary: z.string().min(1).optional(),
+            metrics: z.array(valueMetricSchema).min(1).optional(),
+            fields: recordFieldsSchema,
+            unsetFields: z.array(fieldNameSchema).optional(),
+            revisionNote: z.string().min(1).optional()
+        }
+    }, async (input) => jsonResult(await updateValueRealization(runtime, input, recordActorId)));
     registerDxcTool("create_expectation", {
         description: "Create an expectation record.",
         inputSchema: {
@@ -1101,22 +1337,29 @@ export function createMcpServer(runtime, options = {}) {
         }
     }, async (input) => jsonResult(await appendDeferralEventForTool(runtime, input, recordActorId)));
     registerDxcTool("create_change", {
-        description: "Create a service change record with baseline plan, execution, rollback, and risk/impact sections.",
+        description: "Create a service change record with baseline type, plan, execution, rollback, and risk/impact sections. Use riskImpact to include downstream impact or blast radius when known.",
         inputSchema: {
             workspaceId: workspaceIdSchema,
             title: z.string().min(1),
             summary: z.string().min(1).optional(),
+            changeType: changeTypeSchema.optional(),
+            impactGrade: changeImpactGradeSchema.optional(),
+            emergencyImportance: z.string().min(1).optional(),
+            emergencyImmediacy: z.string().min(1).optional(),
             changePlan: z.string().min(1),
             executionSteps: z.array(z.string().min(1)).min(1),
             rollbackPlan: z.string().min(1),
-            riskImpact: z.string().min(1),
+            riskImpact: z
+                .string()
+                .min(1)
+                .describe("Risk, impact, open concerns, and downstream impact for this Change. Include what else may be affected, what depends on what is changing, and the blast-radius conclusion identified by the Engineer or their tool when available. This is documentary and absence of analysis is visible; it is not a separate blocker."),
             plannedFor: z.string().min(1).optional(),
             requirementId: z.string().min(1).optional(),
             fields: recordFieldsSchema
         }
     }, async (input) => jsonResult(await createChange(runtime, input, recordActorId)));
     registerDxcTool("append_change_event", {
-        description: "Append an immutable event to a Change record. Use this for notice, veto, emergency posture, decision, result, recovery, plan revisions, and notes.",
+        description: "Append an immutable event to a Change record. Use this for notice, veto, decision, result, recovery, plan revisions, and notes. Result and recovery events may include optional Git commit references as documentary traceability.",
         inputSchema: {
             workspaceId: workspaceIdSchema,
             changeId: z.string().min(1),
@@ -1126,12 +1369,19 @@ export function createMcpServer(runtime, options = {}) {
             effectiveAt: z.string().min(1).optional(),
             vetoByRole: changeVetoRoleSchema.optional(),
             reason: z.string().min(1).optional(),
-            importance: z.string().min(1).optional(),
-            immediacy: z.string().min(1).optional(),
             decision: changeDecisionSchema.optional(),
             result: changeResultSchema.optional(),
+            gitCommitReferences: z
+                .array(gitCommitReferenceSchema)
+                .min(1)
+                .optional()
+                .describe("Optional Git commit references for result or recovery events. Each reference stores a commit identifier plus optional repository and URL. DX Complete records these as provided and does not validate or inspect Git."),
             summary: z.string().min(1).optional(),
             note: z.string().min(1).optional(),
+            revisedChangeType: changeTypeSchema.optional(),
+            revisedImpactGrade: changeImpactGradeSchema.optional(),
+            revisedEmergencyImportance: z.string().min(1).optional(),
+            revisedEmergencyImmediacy: z.string().min(1).optional(),
             revisedChangePlan: z.string().min(1).optional(),
             revisedExecutionSteps: z.array(z.string().min(1)).optional(),
             revisedRollbackPlan: z.string().min(1).optional(),
@@ -1171,27 +1421,102 @@ export function createMcpServer(runtime, options = {}) {
         }
     }, async (input) => jsonResult(await appendDecisionEntry(runtime.db, input, recordActorId)));
     registerDxcTool("create_risk", {
-        description: "Create a risk record.",
+        description: "Create a Risk ledger for uncertainty or exposure. Current status, assessment, and treatment derive from entries.",
         inputSchema: {
             workspaceId: workspaceIdSchema,
             title: z.string().min(1),
+            topic: z.string().min(1),
             summary: z.string().min(1).optional(),
-            likelihood: z.enum(["low", "medium", "high"]).optional(),
-            impact: z.enum(["low", "medium", "high"]).optional(),
-            mitigation: z.string().min(1).optional(),
+            body: z.string().min(1).optional(),
+            likelihood: riskLevelSchema.optional(),
+            impact: riskLevelSchema.optional(),
+            treatment: riskTreatmentSchema.optional(),
+            treatmentRationale: z.string().min(1).optional(),
             fields: recordFieldsSchema
         }
-    }, async ({ workspaceId, title, summary, likelihood, impact, mitigation, fields }) => jsonResult(await createRecord(runtime.db, "risks", {
-        workspaceId,
-        title,
-        summary,
-        fields: {
-            ...(likelihood ? { likelihood } : {}),
-            ...(impact ? { impact } : {}),
-            ...(mitigation ? { mitigation } : {}),
-            ...(fields ?? {})
+    }, async (input) => jsonResult(await createRisk(runtime, input, recordActorId, options.workspaceRoles)));
+    registerDxcTool("append_risk_entry", {
+        description: "Append an immutable entry to a Risk. Use assessment entries for likelihood/impact and treatment entries for accept, mitigate, transfer, or avoid.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            riskId: z.string().min(1),
+            entryType: riskEntryTypeSchema,
+            body: z.string().min(1),
+            likelihood: riskLevelSchema.optional(),
+            impact: riskLevelSchema.optional(),
+            treatment: riskTreatmentSchema.optional(),
+            treatmentRationale: z.string().min(1).optional()
+        }
+    }, async (input) => {
+        assertRiskAcceptanceAccess(input.treatment, options.workspaceRoles);
+        return jsonResult(await appendRiskEntry(runtime.db, input, recordActorId));
+    });
+    registerDxcTool("create_incident", {
+        description: "Create an Incident ledger for a specific service-impacting or potentially service-impacting occurrence.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            title: z.string().min(1),
+            description: z.string().min(1),
+            summary: z.string().min(1).optional(),
+            severity: incidentSeveritySchema.optional(),
+            componentIds: z.array(z.string().min(1)).optional(),
+            fields: recordFieldsSchema
         }
-    }, recordActorId)));
+    }, async (input) => jsonResult(await createIncident(runtime, input, recordActorId)));
+    registerDxcTool("append_incident_entry", {
+        description: "Append an immutable entry to an Incident. Current status and severity derive from the latest relevant entries.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            incidentId: z.string().min(1),
+            entryType: incidentEntryTypeSchema,
+            body: z.string().min(1),
+            severity: incidentSeveritySchema.optional()
+        }
+    }, async (input) => jsonResult(await appendIncidentEntry(runtime.db, input, recordActorId)));
+    registerDxcTool("create_support_request", {
+        description: "Create a shared Support Request ledger for a reported user experience, question, request, or issue. This is distinct from a private DX Complete Ticket.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            title: z.string().min(1),
+            reporter: z.string().min(1),
+            kind: z.string().min(1),
+            reportedExperience: z.string().min(1),
+            summary: z.string().min(1).optional(),
+            fields: recordFieldsSchema
+        }
+    }, async (input) => jsonResult(await createSupportRequest(runtime, input, recordActorId)));
+    registerDxcTool("append_support_request_entry", {
+        description: "Append an immutable entry to a Support Request. Escalated entries require an Incident link; current status derives from the latest status-bearing entry.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            supportRequestId: z.string().min(1),
+            entryType: supportRequestEntryTypeSchema,
+            body: z.string().min(1),
+            incidentId: z.string().min(1).optional()
+        }
+    }, async (input) => jsonResult(await appendSupportRequestEntryForTool(runtime, input, recordActorId)));
+    registerDxcTool("create_problem", {
+        description: "Create a Problem ledger for an underlying or recurring cause evidenced by one or more Incidents.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            title: z.string().min(1),
+            description: z.string().min(1),
+            summary: z.string().min(1).optional(),
+            incidentIds: z.array(z.string().min(1)).min(1),
+            componentIds: z.array(z.string().min(1)).optional(),
+            fields: recordFieldsSchema
+        }
+    }, async (input) => jsonResult(await createProblem(runtime, input, recordActorId)));
+    registerDxcTool("append_problem_entry", {
+        description: "Append an immutable entry to a Problem. Current status and root cause derive from the latest relevant entries.",
+        inputSchema: {
+            workspaceId: workspaceIdSchema,
+            problemId: z.string().min(1),
+            entryType: problemEntryTypeSchema,
+            body: z.string().min(1),
+            rootCause: z.string().min(1).optional()
+        }
+    }, async (input) => jsonResult(await appendProblemEntry(runtime.db, input, recordActorId)));
     registerDxcTool("list_records", {
         description: "List records from a DX Complete collection.",
         inputSchema: {
@@ -1351,12 +1676,18 @@ function assertToolRoleAccess(toolName, roles, input) {
     if (roles.includes("engineer") && engineerAllowedTools.has(toolName)) {
         return;
     }
+    if (roles.includes("tester") && testerAllowedTools.has(toolName)) {
+        return;
+    }
     if (roles.includes("operator") && operatorAllowedTools.has(toolName)) {
         return;
     }
+    if (roles.includes("support_agent") && supportAgentAllowedTools.has(toolName)) {
+        return;
+    }
     if (roles.includes("operator") &&
         toolName === "archive_record" &&
-        (input.recordType === "environments" || input.recordType === "components")) {
+        (input.recordType === "environments" || input.recordType === "components" || input.recordType === "maintenance_schedules")) {
         return;
     }
     throw new Error(`Workspace role access denied for ${toolName}.`);
@@ -1386,15 +1717,36 @@ const engineerAllowedTools = new Set([
     "update_estimate",
     "create_task",
     "append_task_entry",
+    "create_risk",
+    "append_risk_entry",
+    "append_review_note"
+]);
+const testerAllowedTools = new Set([
+    "create_risk",
+    "append_risk_entry",
     "append_review_note"
 ]);
 const operatorAllowedTools = new Set([
     "create_change",
     "append_change_event",
+    "create_risk",
+    "append_risk_entry",
+    "create_incident",
+    "append_incident_entry",
+    "create_problem",
+    "append_problem_entry",
     "create_environment",
     "update_environment",
     "create_component",
-    "update_component"
+    "update_component",
+    "create_maintenance_schedule",
+    "update_maintenance_schedule"
+]);
+const supportAgentAllowedTools = new Set([
+    "create_incident",
+    "append_incident_entry",
+    "create_support_request",
+    "append_support_request_entry"
 ]);
 function jsonResult(value) {
     return {
@@ -1571,6 +1923,47 @@ async function updateComponent(runtime, input, actorId) {
         revisionNote: input.revisionNote
     }, actorId);
 }
+async function createMaintenanceSchedule(runtime, input, actorId) {
+    assertNoTypedFields(input.fields, "create_maintenance_schedule", MAINTENANCE_SCHEDULE_TYPED_FIELDS);
+    return createRecord(runtime.db, "maintenance_schedules", {
+        workspaceId: input.workspaceId,
+        title: input.name,
+        summary: input.summary ?? input.rationale,
+        allowManagedFields: true,
+        fields: {
+            ...(input.fields ?? {}),
+            name: input.name,
+            kind: input.kind,
+            cadence: input.cadence,
+            startDate: input.startDate,
+            ...(input.rationale !== undefined ? { rationale: input.rationale } : {}),
+            ...(input.notes !== undefined ? { notes: input.notes } : {})
+        }
+    }, actorId);
+}
+async function updateMaintenanceSchedule(runtime, input, actorId) {
+    assertNoTypedFields(input.fields, "update_maintenance_schedule", MAINTENANCE_SCHEDULE_TYPED_FIELDS);
+    assertNoTypedUnsetFields(input.unsetFields, "update_maintenance_schedule", MAINTENANCE_SCHEDULE_TYPED_FIELDS);
+    return updateRecord(runtime.db, {
+        recordType: "maintenance_schedules",
+        workspaceId: input.workspaceId,
+        id: input.id,
+        title: input.name,
+        summary: input.summary,
+        fields: {
+            ...(input.fields ?? {}),
+            ...(input.name !== undefined ? { name: input.name } : {}),
+            ...(input.kind !== undefined ? { kind: input.kind } : {}),
+            ...(input.cadence !== undefined ? { cadence: input.cadence } : {}),
+            ...(input.startDate !== undefined ? { startDate: input.startDate } : {}),
+            ...(input.rationale !== undefined ? { rationale: input.rationale } : {}),
+            ...(input.notes !== undefined ? { notes: input.notes } : {})
+        },
+        unsetFields: input.unsetFields,
+        allowManagedFields: true,
+        revisionNote: input.revisionNote
+    }, actorId);
+}
 async function createExpectation(runtime, input, actorId) {
     assertNoTypedFields(input.fields, "create_expectation", EXPECTATION_TYPED_FIELDS);
     assertNoObsoleteExpectationFields(input.fields, "create_expectation");
@@ -1717,6 +2110,69 @@ async function updateBenefits(runtime, input, actorId) {
         revisionNote: input.revisionNote
     }, actorId);
 }
+async function createValueRealization(runtime, input, actorId) {
+    assertNoReservedFields(input.fields, ["workspaceId", "requirementIds", "expectationIds", "commitmentIds"]);
+    assertNoTypedFields(input.fields, "create_value_realization", VALUE_REALIZATION_TYPED_FIELDS);
+    assertAtLeastOneValueRealizationTarget(input.requirementIds, input.expectationIds, input.commitmentIds);
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "requirements", uniqueIds(input.requirementIds ?? []));
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "expectations", uniqueIds(input.expectationIds ?? []));
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "commitments", uniqueIds(input.commitmentIds ?? []));
+    let valueRealization = await createRecord(runtime.db, "value_realizations", {
+        workspaceId: input.workspaceId,
+        title: input.title,
+        summary: input.summary,
+        allowManagedFields: true,
+        fields: {
+            ...(input.fields ?? {}),
+            metrics: normalizeValueMetrics(input.metrics)
+        }
+    }, actorId);
+    valueRealization = await linkManyRecords(runtime, valueRealization, "requirements", input.requirementIds ?? [], "realizes_value_for", actorId);
+    valueRealization = await linkManyRecords(runtime, valueRealization, "expectations", input.expectationIds ?? [], "realizes_value_for", actorId);
+    valueRealization = await linkManyRecords(runtime, valueRealization, "commitments", input.commitmentIds ?? [], "realizes_value_for", actorId);
+    return valueRealization;
+}
+async function updateValueRealization(runtime, input, actorId) {
+    assertNoTypedFields(input.fields, "update_value_realization", VALUE_REALIZATION_TYPED_FIELDS);
+    assertNoTypedUnsetFields(input.unsetFields, "update_value_realization", VALUE_REALIZATION_TYPED_FIELDS);
+    return updateRecord(runtime.db, {
+        recordType: "value_realizations",
+        workspaceId: input.workspaceId,
+        id: input.id,
+        title: input.title,
+        summary: input.summary,
+        fields: {
+            ...(input.fields ?? {}),
+            ...(input.metrics ? { metrics: normalizeValueMetrics(input.metrics) } : {})
+        },
+        unsetFields: input.unsetFields,
+        allowManagedFields: true,
+        revisionNote: input.revisionNote
+    }, actorId);
+}
+function normalizeValueMetrics(metrics) {
+    const seenIds = new Set();
+    return metrics.map((metric, index) => {
+        const id = metric.id ?? randomUUID();
+        if (seenIds.has(id)) {
+            throw new Error(`Value metric id must be unique: ${id}.`);
+        }
+        seenIds.add(id);
+        assertMeasuredAtDate(metric.baseline.measuredAt, `Value metric ${index + 1} baseline`);
+        if (metric.actual) {
+            assertMeasuredAtDate(metric.actual.measuredAt, `Value metric ${index + 1} actual`);
+        }
+        return {
+            ...metric,
+            id
+        };
+    });
+}
+function assertMeasuredAtDate(value, label) {
+    if (Number.isNaN(new Date(value).getTime())) {
+        throw new Error(`${label} measuredAt must be a valid date string.`);
+    }
+}
 function normalizeBenefitItems(benefitItems) {
     const seenIds = new Set();
     return benefitItems.map((item, index) => {
@@ -2089,6 +2545,12 @@ function assertAtLeastOneBenefitsTarget(requirementIds, expectationIds) {
     }
     throw new Error("create_benefits requires at least one requirementId or expectationId.");
 }
+function assertAtLeastOneValueRealizationTarget(requirementIds, expectationIds, commitmentIds) {
+    if ((requirementIds?.length ?? 0) > 0 || (expectationIds?.length ?? 0) > 0 || (commitmentIds?.length ?? 0) > 0) {
+        return;
+    }
+    throw new Error("create_value_realization requires at least one requirementId, expectationId, or commitmentId.");
+}
 async function assertRecordsExist(runtime, recordType, ids, workspaceId) {
     for (const id of new Set(ids)) {
         const record = await getRecord(runtime.db, recordType, id, { workspaceId });
@@ -2134,9 +2596,228 @@ async function ensureLinkRecords(runtime, input, actorId) {
     }
     return linkRecords(runtime.db, input, actorId);
 }
+async function createRisk(runtime, input, actorId, roles) {
+    assertNoReservedFields(input.fields, ["workspaceId"]);
+    assertNoTypedFields(input.fields, "create_risk", RISK_TYPED_FIELDS);
+    assertRiskAcceptanceAccess(input.treatment, roles);
+    if ((input.likelihood && !input.impact) || (!input.likelihood && input.impact)) {
+        throw new Error("create_risk requires both likelihood and impact when creating an initial assessment.");
+    }
+    const now = new Date().toISOString();
+    const identifiedEntry = {
+        id: randomUUID(),
+        entryType: "identified",
+        body: input.body ?? input.topic,
+        createdAt: now,
+        createdBy: actorId
+    };
+    const entries = [identifiedEntry];
+    const fields = {
+        ...(input.fields ?? {}),
+        topic: input.topic,
+        entries,
+        currentStatus: riskEntryToCurrentStatus(identifiedEntry, "open")
+    };
+    if (input.likelihood && input.impact) {
+        const assessmentEntry = {
+            id: randomUUID(),
+            entryType: "assessment",
+            body: "Initial risk assessment.",
+            likelihood: input.likelihood,
+            impact: input.impact,
+            createdAt: now,
+            createdBy: actorId
+        };
+        entries.push(assessmentEntry);
+        fields.currentAssessment = riskEntryToCurrentAssessment(assessmentEntry);
+    }
+    if (input.treatment) {
+        const treatmentEntry = {
+            id: randomUUID(),
+            entryType: "treatment",
+            body: input.treatmentRationale ?? `Initial risk treatment: ${input.treatment}.`,
+            treatment: input.treatment,
+            ...(input.treatmentRationale ? { treatmentRationale: input.treatmentRationale } : {}),
+            createdAt: now,
+            createdBy: actorId
+        };
+        entries.push(treatmentEntry);
+        fields.currentTreatment = riskEntryToCurrentTreatment(treatmentEntry);
+    }
+    return createRecord(runtime.db, "risks", {
+        workspaceId: input.workspaceId,
+        title: input.title,
+        summary: input.summary ?? input.topic,
+        allowManagedFields: true,
+        fields
+    }, actorId);
+}
+async function createIncident(runtime, input, actorId) {
+    assertNoReservedFields(input.fields, ["workspaceId", "componentIds"]);
+    assertNoTypedFields(input.fields, "create_incident", INCIDENT_TYPED_FIELDS);
+    const componentIds = uniqueIds(input.componentIds ?? []);
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "components", componentIds);
+    const now = new Date().toISOString();
+    const detectedEntry = {
+        id: randomUUID(),
+        entryType: "detected",
+        body: input.description,
+        createdAt: now,
+        createdBy: actorId
+    };
+    const entries = [detectedEntry];
+    const fields = {
+        ...(input.fields ?? {}),
+        description: input.description,
+        entries,
+        currentStatus: incidentEntryToCurrentStatus(detectedEntry, "open")
+    };
+    if (input.severity) {
+        const severityEntry = {
+            id: randomUUID(),
+            entryType: "severity",
+            body: `Initial severity: ${input.severity}.`,
+            severity: input.severity,
+            createdAt: now,
+            createdBy: actorId
+        };
+        entries.push(severityEntry);
+        fields.currentSeverity = incidentEntryToCurrentSeverity(severityEntry);
+    }
+    let incident = await createRecord(runtime.db, "incidents", {
+        workspaceId: input.workspaceId,
+        title: input.title,
+        summary: input.summary ?? input.description,
+        allowManagedFields: true,
+        fields
+    }, actorId);
+    for (const componentId of componentIds) {
+        incident = await ensureLinkRecords(runtime, {
+            workspaceId: input.workspaceId,
+            fromType: "incidents",
+            fromId: incident._id,
+            toType: "components",
+            toId: componentId,
+            relationship: "affects"
+        }, actorId);
+    }
+    return incident;
+}
+async function createSupportRequest(runtime, input, actorId) {
+    assertNoReservedFields(input.fields, ["workspaceId"]);
+    assertNoTypedFields(input.fields, "create_support_request", SUPPORT_REQUEST_TYPED_FIELDS);
+    const now = new Date().toISOString();
+    const raisedEntry = {
+        id: randomUUID(),
+        entryType: "raised",
+        body: input.reportedExperience,
+        createdAt: now,
+        createdBy: actorId
+    };
+    return createRecord(runtime.db, "support_requests", {
+        workspaceId: input.workspaceId,
+        title: input.title,
+        summary: input.summary ?? input.reportedExperience,
+        allowManagedFields: true,
+        fields: {
+            ...(input.fields ?? {}),
+            reporter: input.reporter,
+            kind: input.kind,
+            reportedExperience: input.reportedExperience,
+            entries: [raisedEntry],
+            currentStatus: supportRequestEntryToCurrentStatus(raisedEntry)
+        }
+    }, actorId);
+}
+async function appendSupportRequestEntryForTool(runtime, input, actorId) {
+    if (input.incidentId) {
+        const incident = await getRecord(runtime.db, "incidents", input.incidentId, {
+            workspaceId: input.workspaceId
+        });
+        if (!incident) {
+            throw new Error(`Incident not found: incidents/${input.incidentId}`);
+        }
+    }
+    const supportRequest = await appendSupportRequestEntry(runtime.db, input, actorId);
+    if (!input.incidentId) {
+        return supportRequest;
+    }
+    return ensureLinkRecords(runtime, {
+        workspaceId: input.workspaceId,
+        fromType: "support_requests",
+        fromId: supportRequest._id,
+        toType: "incidents",
+        toId: input.incidentId,
+        relationship: "spawned_incident"
+    }, actorId);
+}
+async function createProblem(runtime, input, actorId) {
+    assertNoReservedFields(input.fields, ["workspaceId", "incidentIds", "componentIds"]);
+    assertNoTypedFields(input.fields, "create_problem", PROBLEM_TYPED_FIELDS);
+    const incidentIds = uniqueIds(input.incidentIds);
+    const componentIds = uniqueIds(input.componentIds ?? []);
+    if (incidentIds.length === 0) {
+        throw new Error("create_problem requires at least one incidentId.");
+    }
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "incidents", incidentIds);
+    await assertRuntimeRecordsExist(runtime, input.workspaceId, "components", componentIds);
+    const now = new Date().toISOString();
+    const identifiedEntry = {
+        id: randomUUID(),
+        entryType: "identified",
+        body: input.description,
+        createdAt: now,
+        createdBy: actorId
+    };
+    let problem = await createRecord(runtime.db, "problems", {
+        workspaceId: input.workspaceId,
+        title: input.title,
+        summary: input.summary ?? input.description,
+        allowManagedFields: true,
+        fields: {
+            ...(input.fields ?? {}),
+            description: input.description,
+            entries: [identifiedEntry],
+            currentStatus: problemEntryToCurrentStatus(identifiedEntry, "open")
+        }
+    }, actorId);
+    for (const incidentId of incidentIds) {
+        problem = await ensureLinkRecords(runtime, {
+            workspaceId: input.workspaceId,
+            fromType: "problems",
+            fromId: problem._id,
+            toType: "incidents",
+            toId: incidentId,
+            relationship: "evidenced_by"
+        }, actorId);
+    }
+    for (const componentId of componentIds) {
+        problem = await ensureLinkRecords(runtime, {
+            workspaceId: input.workspaceId,
+            fromType: "problems",
+            fromId: problem._id,
+            toType: "components",
+            toId: componentId,
+            relationship: "affects"
+        }, actorId);
+    }
+    return problem;
+}
+function uniqueIds(ids) {
+    return [...new Set(ids.map((id) => id.trim()).filter(Boolean))];
+}
+async function assertRuntimeRecordsExist(runtime, workspaceId, recordType, ids) {
+    for (const id of ids) {
+        const record = await getRecord(runtime.db, recordType, id, { workspaceId });
+        if (!record) {
+            throw new Error(`Record not found: ${recordType}/${id}`);
+        }
+    }
+}
 async function createChange(runtime, input, actorId) {
     assertNoReservedFields(input.fields, ["workspaceId", "initiativeId", "requirementId"]);
     assertNoTypedFields(input.fields, "create_change", CHANGE_TYPED_FIELDS);
+    assertChangeTypeInput(input);
     if (input.requirementId) {
         const requirement = await getRecord(runtime.db, "requirements", input.requirementId, {
             workspaceId: input.workspaceId
@@ -2152,6 +2833,11 @@ async function createChange(runtime, input, actorId) {
         allowManagedFields: true,
         fields: {
             ...(input.fields ?? {}),
+            changeType: input.changeType ?? "normal",
+            ...(input.impactGrade !== undefined ? { impactGrade: input.impactGrade } : {}),
+            ...(input.emergencyImportance !== undefined ? { emergencyImportance: input.emergencyImportance } : {}),
+            ...(input.emergencyImmediacy !== undefined ? { emergencyImmediacy: input.emergencyImmediacy } : {}),
+            ...emergencyRationaleGapFields(input),
             changePlan: input.changePlan,
             executionSteps: input.executionSteps,
             rollbackPlan: input.rollbackPlan,
@@ -2172,6 +2858,9 @@ async function createChange(runtime, input, actorId) {
     return change;
 }
 function buildChangeEventContent(input) {
+    if (input.gitCommitReferences && input.eventType !== "result_reported" && input.eventType !== "recovery_recorded") {
+        throw new Error("gitCommitReferences are only valid on result_reported or recovery_recorded Change events.");
+    }
     switch (input.eventType) {
         case "notice_given":
             return compactObject({
@@ -2185,12 +2874,6 @@ function buildChangeEventContent(input) {
                 reason: input.reason,
                 summary: input.summary
             });
-        case "emergency_declared":
-            return compactObject({
-                importance: requireChangeEventField(input.importance, input.eventType, "importance"),
-                immediacy: requireChangeEventField(input.immediacy, input.eventType, "immediacy"),
-                summary: input.summary
-            });
         case "decision_recorded":
             return compactObject({
                 decision: requireChangeEventField(input.decision, input.eventType, "decision"),
@@ -2200,15 +2883,21 @@ function buildChangeEventContent(input) {
         case "result_reported":
             return compactObject({
                 result: requireChangeEventField(input.result, input.eventType, "result"),
+                gitCommitReferences: input.gitCommitReferences,
                 summary: input.summary
             });
         case "recovery_recorded":
             return compactObject({
-                summary: requireChangeEventField(input.summary, input.eventType, "summary")
+                summary: requireChangeEventField(input.summary, input.eventType, "summary"),
+                gitCommitReferences: input.gitCommitReferences
             });
         case "plan_revised": {
             const event = compactObject({
                 summary: input.summary,
+                revisedChangeType: input.revisedChangeType,
+                revisedImpactGrade: input.revisedImpactGrade,
+                revisedEmergencyImportance: input.revisedEmergencyImportance,
+                revisedEmergencyImmediacy: input.revisedEmergencyImmediacy,
                 revisedChangePlan: input.revisedChangePlan,
                 revisedExecutionSteps: input.revisedExecutionSteps,
                 revisedRollbackPlan: input.revisedRollbackPlan,
@@ -2232,6 +2921,31 @@ function requireChangeEventField(value, eventType, fieldName) {
     }
     return value;
 }
+function assertRiskAcceptanceAccess(treatment, roles) {
+    if (treatment !== "accept" || !roles || roles.includes("owner")) {
+        return;
+    }
+    throw new Error("Formal risk acceptance requires the Owner role. Other roles may record non-acceptance treatment or proceed with visible open risk.");
+}
+function assertChangeTypeInput(input) {
+    const changeType = input.changeType ?? "normal";
+    if (input.impactGrade && changeType !== "normal") {
+        throw new Error("impactGrade is only valid for normal changes.");
+    }
+    if ((input.emergencyImportance || input.emergencyImmediacy) && changeType !== "emergency") {
+        throw new Error("emergencyImportance and emergencyImmediacy are only valid for emergency changes.");
+    }
+}
+function emergencyRationaleGapFields(input) {
+    if ((input.changeType ?? "normal") !== "emergency") {
+        return {};
+    }
+    const missing = [
+        ...(input.emergencyImportance ? [] : ["emergencyImportance"]),
+        ...(input.emergencyImmediacy ? [] : ["emergencyImmediacy"])
+    ];
+    return missing.length > 0 ? { emergencyRationaleGaps: missing } : {};
+}
 function compactObject(input) {
     return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
 }