dxcomplete 0.2.0 → 0.2.2

package/dist/mcp/server.js

@@ -1,3059 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { createHash, randomUUID } from "node:crypto";
-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, 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);
-const amountSchema = z.number().finite().optional();
-const requiredAmountSchema = z.number().finite().nonnegative();
-const currencySchema = z.string().min(3).max(12).optional();
-const requiredCurrencySchema = z.string().min(3).max(12);
-const workspaceIdSchema = z.string().min(1);
-const workspaceModeSchema = z.enum(["transformation", "greenfield", "limited-disclosure"]);
-const expectationApprovalStateSchema = z.enum(["draft", "approved", "not_approved", "superseded"]);
-const requirementStatusSchema = z.enum(["draft", "ready", "approved", "superseded"]);
-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",
-    "requirements",
-    "commitments",
-    "deferrals",
-    "journal_entries",
-    "environments",
-    "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",
-    "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",
-    "condition_note_added",
-    "deferral_resolved",
-    "deferral_abandoned"
-]);
-const journalTagSchema = z.string().min(1).max(80);
-const recordFieldsSchema = z.record(z.string(), z.unknown()).optional();
-const amountInputSchema = z.union([
-    z.object({
-        kind: z.literal("single"),
-        value: requiredAmountSchema
-    }),
-    z.object({
-        kind: z.literal("range"),
-        min: requiredAmountSchema,
-        expected: requiredAmountSchema,
-        max: requiredAmountSchema
-    })
-]);
-const timingSchema = z.enum(["one_time", "recurring"]);
-const estimateLineItemSchema = z.object({
-    id: z.string().min(1).optional(),
-    label: z.string().min(1),
-    timing: timingSchema,
-    period: z.string().min(1).optional(),
-    currency: requiredCurrencySchema,
-    amount: amountInputSchema
-}).strict();
-const benefitItemSchema = z.object({
-    id: z.string().min(1).optional(),
-    label: z.string().min(1),
-    timing: timingSchema.optional(),
-    period: z.string().min(1).optional(),
-    currency: requiredCurrencySchema.optional(),
-    amount: amountInputSchema.optional()
-}).strict();
-const componentLocatorSchema = z.record(z.string().min(1), z.unknown()).refine((value) => Object.keys(value).length > 0, "locator must be a non-empty structured object.");
-const componentIdentifiersSchema = z.record(z.string().min(1), z.unknown()).optional();
-const secretPointerSchema = z.object({
-    store: z.string().min(1),
-    key: z.string().min(1),
-    location: z.string().min(1).optional(),
-    url: z.string().min(1).optional(),
-    note: z.string().min(1).optional()
-}).strict();
-const decisionInitialEntrySchema = z.object({
-    entryType: decisionEntryTypeSchema,
-    body: z.string().min(1),
-    decidedBy: z.string().min(1).optional(),
-    rationale: z.string().min(1).optional()
-}).strict();
-const initialDecisionSchema = z.object({
-    body: z.string().min(1),
-    decidedBy: z.string().min(1).optional(),
-    rationale: z.string().min(1).optional()
-}).strict();
-const fieldNameSchema = z
-    .string()
-    .regex(/^[A-Za-z_][A-Za-z0-9_-]*$/, "Only top-level field names are supported.");
-const SERVER_STARTED_AT = new Date().toISOString();
-const STATEMENT_TYPED_FIELDS = ["statement", "source"];
-const EXPECTATION_TYPED_FIELDS = [
-    "statement",
-    "successRecognition",
-    "approvalState",
-    "approvedBy",
-    "approvedAt",
-    "source"
-];
-const REQUIREMENT_TYPED_FIELDS = [
-    "statement",
-    "acceptanceCriteria",
-    "priority",
-    "status"
-];
-const CHANGE_TYPED_FIELDS = [
-    "changePlan",
-    "executionSteps",
-    "rollbackPlan",
-    "riskImpact",
-    "changeType",
-    "impactGrade",
-    "emergencyImportance",
-    "emergencyImmediacy",
-    "emergencyRationaleGaps",
-    "plannedFor",
-    "events"
-];
-const COMMITMENT_TYPED_FIELDS = ["commitmentStatement", "reservations"];
-const DEFERRAL_TYPED_FIELDS = ["reason", "status", "conditions", "conditionEvents"];
-const ESTIMATE_TYPED_FIELDS = ["lineItems", "rollup", "versionHistory"];
-const BENEFITS_TYPED_FIELDS = ["benefitItems", "rollup", "versionHistory"];
-const ENVIRONMENT_TYPED_FIELDS = ["name", "description", "versionHistory"];
-const COMPONENT_TYPED_FIELDS = [
-    "name",
-    "environmentId",
-    "kind",
-    "locator",
-    "identifiers",
-    "secretPointers",
-    "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 = [
-    "workspaceId",
-    "matter",
-    "entries",
-    "currentDecision",
-    "question",
-    "decision",
-    "decidedBy",
-    "rationale",
-    "argumentsConsidered",
-    "concerns",
-    "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.",
-    currentFlow: ["Statement", "Expectation", "Requirement", "Commitment"],
-    phaseGuidance: [
-        "These phases describe a typical first-pass order and each has a target end-state, but they are non-terminal and re-enterable: at any point the most useful next activity may belong to any phase, including returning to an earlier one, and no phase is ever closed or locked behind you."
-    ],
-    crossCuttingRecords: [
-        {
-            record: "Journal",
-            use: "Shared workspace context that does not yet belong in a dedicated record; use dedicated records first and Journal only as the fallback."
-        },
-        {
-            record: "Task",
-            use: "Execution work that can be created whenever a phase needs concrete action; Task is not part of the Statement, Expectation, Requirement, Commitment sequence."
-        },
-        {
-            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: {
-        principle: "Use the dedicated record first. Journal is the fallback for relevant workspace context only when no dedicated record fits.",
-        sharpTest: "Will anything reference or depend on this? If yes, prefer a dedicated record that can carry the relationship.",
-        routingOrder: [
-            {
-                when: "The information is desired truth, success criteria, or a buildable commitment.",
-                use: "Use Statement, Expectation, or Requirement."
-            },
-            {
-                when: "The information is a choice weighed between alternatives.",
-                use: "Use Decision."
-            },
-            {
-                when: "The information is an action someone needs to do.",
-                use: "Use Task."
-            },
-            {
-                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."
-            }
-        ],
-        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",
-            name: "Orient",
-            purpose: "Capture the desired outcome in plain terms, restate expectations, and confirm how success will be recognized where possible.",
-            commonRecords: ["Workspace", "Statement", "Expectation", "DX Complete Ticket"],
-            processConcepts: [],
-            handoff: "Expectations describe the desired outcome clearly enough to elicit requirements, or any missing approval is visible as open risk.",
-            operatingGuidance: {
-                clientRole: "Help the user express the desired outcome in their terms, confirm captured wording before recording, and prepare expectations for approval where needed.",
-                conductRules: [
-                    "Elicit the person's Statement; do not invent it.",
-                    "When the client articulates Statement or Expectation wording on a user's behalf, confirm that wording before recording it.",
-                    "Do not store same-person capture-confirmation as record state.",
-                    "Stay in plain outcome language.",
-                    "Do not move into technical solution design during Orient.",
-                    "Treat missing separate authority approval as visible open risk, not as a process block."
-                ],
-                questionsToAsk: [
-                    "What problem, need, or outcome should DX Complete help clarify?",
-                    "What would make this successful from the user's point of view?",
-                    "How will people recognize that the expected outcome has been met?",
-                    "Is this wording accurate enough to record and use as the basis for requirements?"
-                ],
-                expectedOutput: [
-                    "Statement record in the person's language.",
-                    "Restated Expectations with success recognition.",
-                    "Owner approval where available, or visible open risk where approval is missing."
-                ],
-                exitCheck: "Move to Elicit when expectations are clear enough to translate into requirements, or when proceeding without separate authority approval is visible as open risk.",
-                checkpointNotes: [
-                    "Owner approval reduces wrong-outcome risk.",
-                    "Unapproved expectations can move forward only when the risk is explicit."
-                ]
-            }
-        },
-        {
-            id: "elicit",
-            name: "Elicit",
-            purpose: "Translate expectations into requirements, dependencies, assumptions, unknowns, and risk.",
-            commonRecords: ["Statement", "Expectation", "Requirement", "Risk", "Decision", "DX Complete Ticket"],
-            processConcepts: ["Requirement"],
-            handoff: "The requirement set is clear enough to estimate cost, value, risk, and confidence, or the open risk is visible.",
-            operatingGuidance: {
-                clientRole: "Translate approved or visibly unapproved expectations into requirements and related delivery facts.",
-                conductRules: [
-                    "Keep each requirement tied to the expectation it is meant to satisfy.",
-                    "Separate requirements from implementation tasks.",
-                    "Surface dependencies, assumptions, unknowns, and risks before estimating.",
-                    "Use review notes for Engineer input on expectations or requirements; do not treat review notes as approval, objection state, or blockers.",
-                    "Do not treat uncertain details as settled requirements."
-                ],
-                questionsToAsk: [
-                    "What must be true for each expectation to be satisfied?",
-                    "What dependencies, constraints, or unknowns could affect the work?",
-                    "What assumptions are being made because information is incomplete?",
-                    "Which risks should be visible before the Owner weighs the work?"
-                ],
-                expectedOutput: [
-                    "A requirement set.",
-                    "Review notes where Engineer input should stay visible.",
-                    "Known dependencies, assumptions, unknowns, and risks.",
-                    "Open questions, visible risks, or follow-ups where clarity is incomplete."
-                ],
-                exitCheck: "Move to Weigh when the requirement set is clear enough to support cost, value, risk, and confidence discussion.",
-                checkpointNotes: [
-                    "Requirement clarity reduces estimate risk.",
-                    "Open unknowns can move forward when they are recorded as visible risk or follow-up."
-                ]
-            }
-        },
-        {
-            id: "weigh",
-            name: "Weigh",
-            purpose: "Compare expected cost, expected value, risks, and confidence before recording a Commitment or Deferral.",
-            commonRecords: [
-                "Estimate",
-                "Benefits",
-                "Commitment",
-                "Deferral",
-                "Decision",
-                "Risk"
-            ],
-            handoff: "The Owner records a Commitment that can move into Build, or a Deferral that makes unmet conditions visible.",
-            operatingGuidance: {
-                clientRole: "Help the decision authority compare the requirement set against cost, value, risk, and confidence.",
-                conductRules: [
-                    "Make current-state cost context visible where relevant, but do not require complete baseline data.",
-                    "Generate or review a scope-linked Engineer cost Estimate by default from the elicited requirement set.",
-                    "Record Owner-authored Benefits separately from Engineer cost Estimates.",
-                    "Consider important review notes, but do not require the Owner to acknowledge or answer them.",
-                    "Keep the phase outcome-neutral; do not force a Commitment.",
-                    "If budget or benefit basis was considered, link the Estimate, Benefits, or Decision rationale to the Commitment; if not, do not fabricate a waiver.",
-                    "Use Commitment when the Owner is moving forward, with any reservations recorded.",
-                    "Use Deferral when the Owner is not moving forward yet and wants the unmet conditions made explicit.",
-                    "Record uncertainty and confidence rather than hiding it.",
-                    "Do not compute a verdict; DX Complete preserves the basis for the Owner's judgment."
-                ],
-                questionsToAsk: [
-                    "What is known about current cost, proposed cost, and expected benefit?",
-                    "How confident is the cost estimate?",
-                    "Which Benefits, Estimate, or Decision rationale, if any, should inform the Commitment?",
-                    "What risks or missing information affect whether the Owner can commit?",
-                    "Is the Owner committing now, or deferring until named conditions are addressed?",
-                    "If committing, what reservations should be kept visible?",
-                    "If deferring, what conditions would make a future Commitment possible?"
-                ],
-                expectedOutput: [
-                    "Decision basis for the Owner's judgment.",
-                    "Scope-linked Engineer cost Estimate where available.",
-                    "Owner-authored Benefits where available, including qualitative benefits when they cannot be quantified.",
-                    "Important review notes considered as input where they exist.",
-                    "Commitment with linked requirements or expectations, or Deferral with explicit conditions.",
-                    "Decision with linked inputs where a separate rationale record is useful.",
-                    "Visible risks."
-                ],
-                exitCheck: "Move to Build only after a Commitment; otherwise keep the Deferral conditions visible or return to Elicit as recorded.",
-                checkpointNotes: [
-                    "Incomplete cost or benefit data does not block the decision.",
-                    "Proceeding with low confidence should leave the open risk visible.",
-                    "A Deferral is not failure; it is the recorded path to a possible future Commitment."
-                ]
-            }
-        },
-        {
-            id: "build",
-            name: "Build",
-            purpose: "Turn committed requirements into working changes.",
-            commonRecords: ["Commitment", "Requirement", "Task", "Decision", "Risk"],
-            handoff: "The change is ready for release preparation and readiness checks.",
-            operatingGuidance: {
-                clientRole: "Help the team break committed requirements into tasks and track implementation evidence.",
-                conductRules: [
-                    "Create tasks from requirements covered by a Commitment.",
-                    "Keep implementation detail connected to the requirement it supports.",
-                    "Use decisions for meaningful design or tradeoff choices.",
-                    "Surface blockers and delivery risk early."
-                ],
-                questionsToAsk: [
-                    "Which requirement does this task implement?",
-                    "What working change will satisfy the requirement?",
-                    "What decision, risk, or blocker affects the build?",
-                    "What evidence will show that the task is complete?"
-                ],
-                expectedOutput: [
-                    "Tasks linked to requirements.",
-                    "Working changes or implementation evidence.",
-                    "Recorded decisions and risks where needed."
-                ],
-                exitCheck: "Move to Go Live when the committed change is built and ready for release preparation.",
-                checkpointNotes: [
-                    "Task completion does not replace requirement verification.",
-                    "Known build risk should remain visible through release preparation."
-                ]
-            }
-        },
-        {
-            id: "go_live",
-            name: "Go Live",
-            purpose: "Prepare the change, confirm readiness, and put it into use.",
-            commonRecords: ["Change", "Task", "Decision", "Risk"],
-            handoff: "The change is completed, deferred, cancelled, rolled back, or left with its event history visible.",
-            operatingGuidance: {
-                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, 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, 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."
-                ],
-                questionsToAsk: [
-                    "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, 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."
-                ],
-                exitCheck: "Move to Operate when the change event history shows the change is completed, deferred, cancelled, rolled back, or ready to be monitored.",
-                checkpointNotes: [
-                    "Readiness checks reduce launch risk.",
-                    "A veto by Owner or Engineer is a serious recorded event, not a mechanical stop.",
-                    "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."
-                ]
-            }
-        },
-        {
-            id: "operate",
-            name: "Operate",
-            purpose: "Run the service, help users, and respond when something goes wrong.",
-            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 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."
-                ],
-                questionsToAsk: [
-                    "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 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.",
-                checkpointNotes: [
-                    "Operational work is part of the lifecycle, not an exception.",
-                    "Unresolved operating signals should remain visible until handled or accepted."
-                ]
-            }
-        },
-        {
-            id: "measure",
-            name: "Measure",
-            purpose: "Compare expected and actual cost or benefit when data is available.",
-            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."
-                ],
-                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."
-                ],
-                exitCheck: "Keep operating, refine estimates, or start new Orient/Elicit work when measurement reveals a new need.",
-                checkpointNotes: [
-                    "Actuals improve future estimates but do not block project closure.",
-                    "Missing measurement data should be visible without being treated as failure."
-                ]
-            }
-        }
-    ],
-    processConcepts: [
-        {
-            name: "Statement",
-            status: "runtime_record",
-            currentRuntimeRecordType: "statements",
-            use: "The user's own words before DX Complete interprets or translates them.",
-            handling: "Track as a workspace-scoped record. Expectations can derive from Statement records through the derives_from relationship."
-        },
-        {
-            name: "Expectation",
-            status: "runtime_record",
-            currentRuntimeRecordType: "expectations",
-            use: "The expected result and how success will be recognized, captured in user-facing language.",
-            handling: "Track as a workspace-scoped record that can link to statements, requirements, risks, and decisions. Separate authority approval is tracked as risk-reducing state; same-person capture-confirmation is client conduct."
-        },
-        {
-            name: "Requirement detail",
-            status: "requirement_detail",
-            currentRuntimeRecordType: "requirements",
-            use: "Optional implementation or verification detail kept with the requirement when needed.",
-            handling: "Do not treat Specification as a current first-class runtime record."
-        }
-    ],
-    checkpointGuidance: [
-        "Approval and other checkpoints reduce risk; they do not block progress by themselves.",
-        "A checkpoint can be approved or mitigated, formally accepted as risk by the Owner, or proceeded past with open risk still visible.",
-        "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 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.",
-        conductRules: [
-            "Use the current phase, record state, links, open questions, risks, and decisions to reason about what should happen next.",
-            "When the next step is uncertain, name the missing information or checkpoint rather than inventing certainty.",
-            "Treat the next-step answer as guidance for the user, not as a hidden server decision."
-        ]
-    },
-    runtimeRecordTypes: COLLECTION_NAMES,
-    deploymentModel: {
-        default: "one_mcp_endpoint_per_workspace",
-        workspaceBinding: "Hosted MCP endpoints get workspace scope from installed repo config, then proxy to the central DX Complete service. Shared record access is scoped by authenticated actor and authorized workspace context. Workspace scope is not an environment variable.",
-        databaseModel: "Workspace MCP servers do not hold database credentials. The central service owns database access, OAuth exchange, membership checks, readable ID allocation, and MCP tool execution.",
-        authorizationModel: "Workspace servers authenticate to the central service with a workspace service client. The central service verifies the human actor and derives allowed tool access from stored workspace roles."
-    },
-    recordGuidance: [
-        {
-            record: "Workspace",
-            use: "The boundary for one service scope, including its name, summary, and mode when useful."
-        },
-        {
-            record: "Statement",
-            use: "A user's own words before interpretation, kept as the traceable root for expectations and downstream work."
-        },
-        {
-            record: "Journal",
-            use: "Shared, append-only workspace notes for relevant background, preferences, observations, and context that has no dedicated record home. Journal notes are visible to workspace members and compacted through summary entries when the hot context grows."
-        },
-        {
-            record: "DX Complete Ticket",
-            use: "Private, appendable communication between the current actor and DX Complete before anyone decides whether shared follow-up is needed."
-        },
-        {
-            record: "Expectation",
-            use: "A user-facing condition of satisfaction that can be approved by separate authority, left not approved with open risk visible, linked to requirements, reviewed with non-blocking notes, and revised with version history."
-        },
-        {
-            record: "Requirement",
-            use: "A team-owned commitment that translates expectations into something buildable and verifiable, with optional non-blocking review notes and version history."
-        },
-        {
-            record: "Commitment",
-            use: "An Owner point-in-time authority record that commits requirements or expectations into Build, with optional reservations kept visible."
-        },
-        {
-            record: "Deferral",
-            use: "An Owner record for not committing yet, with explicit conditions and append-only condition history that can resolve into a Commitment."
-        },
-        {
-            record: "Task",
-            use: "Execution work with an append-only entry log; current status comes from the latest status_change entry."
-        },
-        {
-            record: "Change",
-            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",
-            use: "A named operating context such as local, staging, or production, with version history for operational-state changes."
-        },
-        {
-            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."
-        },
-        {
-            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."
-        }
-    ],
-    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, 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, 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.",
-        "Use update_expectation and update_requirement for current content changes so prior versions are preserved.",
-        "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."
-    ]
-};
-export function createMcpServer(runtime, options = {}) {
-    const server = new McpServer({
-        name: "dxcomplete",
-        version: DXCOMPLETE_PACKAGE_VERSION
-    });
-    const actor = options.actor ?? createLocalActorContext();
-    const recordActorId = options.recordActorId ?? (options.actor ? actor.actorId : RUNTIME_ACTOR_ID);
-    const hostedWorkspace = options.hostedWorkspace;
-    const hostedHttp = options.hostedHttp;
-    const activeCollectionSchema = hostedWorkspace ? hostedCollectionSchema : collectionSchema;
-    const toolManifestEntries = [];
-    function registerDxcTool(name, config, handler) {
-        if (hostedWorkspace && name === "create_workspace") {
-            return;
-        }
-        const inputSchema = hostedWorkspace ? omitWorkspaceId(config.inputSchema) : config.inputSchema;
-        toolManifestEntries.push({
-            name,
-            description: config.description,
-            inputFields: Object.keys(inputSchema).sort(),
-            inputSchemaFingerprint: getInputSchemaFingerprint(inputSchema)
-        });
-        server.registerTool(name, {
-            ...config,
-            inputSchema
-        }, (async (input) => {
-            const handlerInput = hostedWorkspace
-                ? injectHostedWorkspace(input, config.inputSchema, hostedWorkspace.workspaceId)
-                : input;
-            assertHostedWorkspaceAccess(name, handlerInput, hostedWorkspace?.workspaceId);
-            assertToolRoleAccess(name, options.workspaceRoles, handlerInput);
-            return handler(handlerInput);
-        }));
-    }
-    function getToolManifest() {
-        const tools = [...toolManifestEntries].sort((left, right) => left.name.localeCompare(right.name));
-        return {
-            toolCount: tools.length,
-            tools
-        };
-    }
-    function getMcpSurface() {
-        const toolManifest = getToolManifest();
-        const fingerprint = createHash("sha256")
-            .update(stableStringify({
-            surfaceId: MCP_SURFACE_ID,
-            workspaceCompatibility: WORKSPACE_COMPATIBILITY_VERSION,
-            tools: toolManifest.tools,
-            processGuide: PROCESS_GUIDE,
-            docReferences: DOC_REFERENCE
-        }))
-            .digest("hex")
-            .slice(0, 16);
-        return {
-            version: MCP_SURFACE_ID,
-            fingerprint,
-            workspaceCompatibility: WORKSPACE_COMPATIBILITY_VERSION,
-            ...toolManifest
-        };
-    }
-    registerDxcTool("runtime_status", {
-        description: "Check the DX Complete runtime connection and configured record collections.",
-        inputSchema: {}
-    }, async () => {
-        const surface = getMcpSurface();
-        return jsonResult({
-            ok: true,
-            databaseName: runtime.config.databaseName,
-            actorId: recordActorId,
-            actor,
-            ...(hostedWorkspace
-                ? {
-                    workspace: {
-                        workspaceId: hostedWorkspace.workspaceId,
-                        ...(hostedWorkspace.name ? { name: hostedWorkspace.name } : {}),
-                        source: "central_service_membership",
-                        ...(options.workspaceRoles ? { roles: options.workspaceRoles } : {})
-                    }
-                }
-                : {}),
-            collections: COLLECTION_NAMES,
-            server: {
-                pid: process.pid,
-                version: DXCOMPLETE_PACKAGE_VERSION,
-                packageVersion: DXCOMPLETE_PACKAGE_VERSION,
-                workspaceCompatibility: surface.workspaceCompatibility,
-                startedAt: SERVER_STARTED_AT,
-                surfaceVersion: surface.version,
-                surfaceFingerprint: surface.fingerprint,
-                surfaceIncludes: ["tools", "toolSchemas", "processGuide", "docReferences"],
-                ...(hostedHttp
-                    ? {
-                        http: hostedHttp
-                    }
-                    : {}),
-                toolCount: surface.toolCount,
-                tools: surface.tools.map((tool) => tool.name),
-                toolManifest: surface.tools
-            }
-        });
-    });
-    registerDxcTool("get_process_guide", {
-        description: "Get the current DX Complete process guide, including phases, common records, and handoff guidance.",
-        inputSchema: {}
-    }, async () => {
-        const surface = getMcpSurface();
-        return jsonResult({
-            surfaceVersion: surface.version,
-            surfaceFingerprint: surface.fingerprint,
-            workspaceCompatibility: surface.workspaceCompatibility,
-            ...PROCESS_GUIDE
-        });
-    });
-    registerDxcTool("get_doc", {
-        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()
-        }
-    }, async ({ page, term }) => {
-        const surface = getMcpSurface();
-        const doc = getDocReference(page, term);
-        return jsonResult({
-            surfaceVersion: surface.version,
-            surfaceFingerprint: surface.fingerprint,
-            workspaceCompatibility: surface.workspaceCompatibility,
-            ...doc
-        });
-    });
-    registerDxcTool("create_workspace", {
-        description: "Create a workspace, the shared-runtime boundary for one service scope.",
-        inputSchema: {
-            id: workspaceIdSchema.optional(),
-            name: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            mode: workspaceModeSchema.optional(),
-            fields: recordFieldsSchema
-        }
-    }, async ({ id, name, summary, mode, fields }) => {
-        const existing = id
-            ? await getRecord(runtime.db, "workspaces", id, { allowAnyWorkspace: true })
-            : null;
-        if (existing) {
-            return jsonResult(existing);
-        }
-        return jsonResult(await createRecord(runtime.db, "workspaces", {
-            ...(id ? { id } : {}),
-            title: name,
-            summary,
-            fields: {
-                name,
-                ...(mode ? { mode } : {}),
-                ...(fields ?? {})
-            }
-        }, recordActorId));
-    });
-    registerDxcTool("create_record", {
-        description: "Create a record in one of the DX Complete collections.",
-        inputSchema: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            title: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async ({ recordType, workspaceId, title, summary, fields }) => jsonResult(await createRecord(runtime.db, recordType, { workspaceId, title, summary, fields }, recordActorId)));
-    registerDxcTool("get_record", {
-        description: "Get one DX Complete record by type and id.",
-        inputSchema: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            id: z.string().min(1)
-        }
-    }, async ({ recordType, workspaceId, id }) => {
-        const record = await getRecord(runtime.db, recordType, id, { workspaceId });
-        if (!record) {
-            throw new Error(`Record not found: ${recordType}/${id}`);
-        }
-        return jsonResult(record);
-    });
-    registerDxcTool("create_dxcomplete_ticket", {
-        description: "Create a private DX Complete Ticket for a question, report, request, correction, or follow-up from the current actor. The body is stored as the first entry; summary is optional and is not generated automatically.",
-        inputSchema: {
-            title: z.string().min(1),
-            body: z.string().min(1)
-        }
-    }, async (input) => jsonResult(await createDxcompleteTicket(runtime.db, input, actor)));
-    registerDxcTool("append_dxcomplete_ticket", {
-        description: "Append a follow-up entry to one of the current actor's DX Complete Tickets while preserving earlier entries.",
-        inputSchema: {
-            id: z.string().min(1),
-            body: z.string().min(1)
-        }
-    }, async (input) => jsonResult(await appendDxcompleteTicket(runtime.db, input, actor)));
-    registerDxcTool("list_dxcomplete_tickets", {
-        description: "List the current actor's own DX Complete Tickets. Archived tickets are hidden unless includeArchived is true.",
-        inputSchema: {
-            limit: z.number().int().min(1).max(100).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async ({ limit, includeArchived }) => jsonResult(await listDxcompleteTickets(runtime.db, actor, limit ?? 20, { includeArchived })));
-    registerDxcTool("list_unread_dxcomplete_ticket_replies", {
-        description: "List tickets with unread DX Complete replies addressed to the current actor. This returns reply identifiers and timestamps only; use read_dxcomplete_ticket to read the ticket and mark replies read.",
-        inputSchema: {
-            limit: z.number().int().min(1).max(100).optional()
-        }
-    }, async ({ limit }) => jsonResult(await listUnreadDxcompleteTicketReplies(runtime.db, actor, limit ?? 20)));
-    registerDxcTool("read_dxcomplete_ticket", {
-        description: "Read one DX Complete Ticket owned by the current actor. Reading the ticket marks its unread DX Complete replies as read.",
-        inputSchema: {
-            id: z.string().min(1)
-        }
-    }, async (input) => jsonResult(await readDxcompleteTicket(runtime.db, input, actor)));
-    registerDxcTool("archive_dxcomplete_ticket", {
-        description: "Hide one DX Complete Ticket from the current actor's active ticket list. This is personal cleanup.",
-        inputSchema: {
-            id: z.string().min(1)
-        }
-    }, async ({ id }) => jsonResult(await archiveDxcompleteTicket(runtime.db, { id }, actor)));
-    registerDxcTool("append_journal_note", {
-        description: "Append a shared workspace Journal note only after checking that the information has no better dedicated record home. Any workspace member may append; author and timestamp are captured automatically.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            body: z.string().min(1),
-            tag: journalTagSchema.optional()
-        }
-    }, async (input) => jsonResult(await appendJournalNote(runtime.db, input, recordActorId)));
-    registerDxcTool("read_journal", {
-        description: "Read the workspace Journal fallback context. By default this returns the hot tier: active summaries plus active raw notes, not the full archive.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            limit: z.number().int().min(1).max(500).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async (input) => jsonResult(await readJournal(runtime.db, input)));
-    registerDxcTool("get_journal_entry", {
-        description: "Fetch one Journal entry by UUID or readable ID, including fallback context entries that have aged out of the hot Journal read.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1)
-        }
-    }, async (input) => jsonResult(await getJournalEntry(runtime.db, input)));
-    registerDxcTool("append_journal_summary", {
-        description: "Append a Journal summary for fallback context that covers existing Journal entries by UUID or readable ID, then archives the covered entries out of the hot read without deleting them.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            body: z.string().min(1),
-            covers: z.array(z.string().min(1)).min(1),
-            tag: journalTagSchema.optional()
-        }
-    }, async (input) => jsonResult(await appendJournalSummary(runtime.db, input, recordActorId)));
-    registerDxcTool("create_statement", {
-        description: "Create a Statement record that preserves a person's own words before interpretation.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            statement: z.string().min(1),
-            source: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createStatement(runtime, input, recordActorId)));
-    registerDxcTool("update_statement", {
-        description: "Update a Statement record while preserving prior versions.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            statement: z.string().min(1).optional(),
-            source: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional(),
-            revisionNote: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await updateStatement(runtime, input, recordActorId)));
-    registerDxcTool("list_environments", {
-        description: "List Operational Registry Environment records for the workspace.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            limit: z.number().int().min(1).max(100).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async ({ workspaceId, limit, includeArchived }) => jsonResult(await listRecords(runtime.db, "environments", limit ?? 20, { workspaceId, includeArchived })));
-    registerDxcTool("create_environment", {
-        description: "Create an Operational Registry Environment, such as local, staging, or production.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            name: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            description: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createEnvironment(runtime, input, recordActorId)));
-    registerDxcTool("update_environment", {
-        description: "Update an Operational Registry Environment while preserving prior versions.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            name: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            description: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional(),
-            revisionNote: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await updateEnvironment(runtime, input, recordActorId)));
-    registerDxcTool("list_components", {
-        description: "List Operational Registry Components that belong to one Environment.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            environmentId: z.string().min(1),
-            limit: z.number().int().min(1).max(100).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async (input) => jsonResult(await listComponents(runtime, input)));
-    registerDxcTool("create_component", {
-        description: "Create an Operational Registry Component for one Environment. Secret pointers are pointers only; do not paste credentials or secret values.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            name: z.string().min(1),
-            environmentId: z.string().min(1),
-            kind: z.string().min(1),
-            locator: componentLocatorSchema,
-            summary: z.string().min(1).optional(),
-            identifiers: componentIdentifiersSchema,
-            secretPointers: z.array(secretPointerSchema).optional(),
-            notes: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createComponent(runtime, input, recordActorId)));
-    registerDxcTool("update_component", {
-        description: "Update an Operational Registry Component while preserving prior versions. Secret pointers are pointers only; do not paste credentials or secret values.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            name: z.string().min(1).optional(),
-            kind: z.string().min(1).optional(),
-            locator: componentLocatorSchema.optional(),
-            summary: z.string().min(1).optional(),
-            identifiers: componentIdentifiersSchema,
-            secretPointers: z.array(secretPointerSchema).optional(),
-            notes: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional(),
-            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: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            lineItems: z.array(estimateLineItemSchema).min(1),
-            requirementIds: z.array(z.string().min(1)).optional(),
-            expectationIds: z.array(z.string().min(1)).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createEstimate(runtime, input, recordActorId)));
-    registerDxcTool("update_estimate", {
-        description: "Update an itemized Engineer cost estimate while preserving prior versions.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            lineItems: z.array(estimateLineItemSchema).min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional(),
-            revisionNote: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await updateEstimate(runtime, input, recordActorId)));
-    registerDxcTool("create_benefits", {
-        description: "Create an Owner-authored Benefits record for Weigh.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            benefitItems: z.array(benefitItemSchema).min(1),
-            requirementIds: z.array(z.string().min(1)).optional(),
-            expectationIds: z.array(z.string().min(1)).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createBenefits(runtime, input, recordActorId)));
-    registerDxcTool("update_benefits", {
-        description: "Update an Owner-authored Benefits record while preserving prior versions.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            benefitItems: z.array(benefitItemSchema).min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional(),
-            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: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            statement: z.string().min(1),
-            successRecognition: z.string().min(1).optional(),
-            approvalState: expectationApprovalStateSchema.optional(),
-            approvedBy: z.string().min(1).optional(),
-            approvedAt: z.string().min(1).optional(),
-            source: z.string().min(1).optional(),
-            statementId: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async ({ workspaceId, title, statement, successRecognition, approvalState, approvedBy, approvedAt, source, statementId, fields }) => jsonResult(await createExpectation(runtime, {
-        workspaceId,
-        title,
-        statement,
-        successRecognition,
-        approvalState,
-        approvedBy,
-        approvedAt,
-        source,
-        statementId,
-        fields
-    }, recordActorId)));
-    registerDxcTool("create_requirement", {
-        description: "Create a requirement record.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            expectationId: z.string().min(1).optional(),
-            statement: z.string().min(1),
-            acceptanceCriteria: z.array(z.string().min(1)).optional(),
-            priority: z.enum(["low", "medium", "high"]).optional(),
-            status: requirementStatusSchema.optional(),
-            fields: recordFieldsSchema
-        }
-    }, async ({ workspaceId, title, expectationId, statement, acceptanceCriteria, priority, status, fields }) => jsonResult(await createRequirement(runtime, { workspaceId, title, expectationId, statement, acceptanceCriteria, priority, status, fields }, recordActorId)));
-    registerDxcTool("create_task", {
-        description: "Create an execution task ledger. Current status is derived from the latest status_change entry.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            description: z.string().min(1),
-            assignee: z.string().min(1).optional(),
-            assignor: z.string().min(1).optional(),
-            requirementId: z.string().min(1).optional(),
-            initialStatus: taskStatusSchema.optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createTask(runtime, input, recordActorId)));
-    registerDxcTool("append_task_entry", {
-        description: "Append an immutable entry to a Task. Use status_change entries to change the derived current status.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            taskId: z.string().min(1),
-            entryType: taskEntryTypeSchema,
-            body: z.string().min(1),
-            status: taskStatusSchema.optional()
-        }
-    }, async (input) => jsonResult(await appendTaskEntry(runtime.db, input, recordActorId)));
-    registerDxcTool("create_commitment", {
-        description: "Create an Owner commitment record that moves requirements or expectations toward Build.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            commitmentStatement: z.string().min(1),
-            requirementIds: z.array(z.string().min(1)).optional(),
-            expectationIds: z.array(z.string().min(1)).optional(),
-            reservationNotes: z.array(z.string().min(1)).optional(),
-            deferralId: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createCommitment(runtime, input, recordActorId)));
-    registerDxcTool("create_deferral", {
-        description: "Create an Owner deferral record with explicit conditions required for a future Commitment.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            summary: z.string().min(1).optional(),
-            reason: z.string().min(1),
-            conditions: z.array(z.string().min(1)).min(1),
-            requirementIds: z.array(z.string().min(1)).optional(),
-            expectationIds: z.array(z.string().min(1)).optional(),
-            fields: recordFieldsSchema
-        }
-    }, async (input) => jsonResult(await createDeferral(runtime, input, recordActorId)));
-    registerDxcTool("append_deferral_event", {
-        description: "Append an immutable event to a Deferral record. Use this for condition updates, notes, resolution into Commitment, or abandonment.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            deferralId: z.string().min(1),
-            eventType: deferralEventTypeSchema,
-            conditionId: z.string().min(1).optional(),
-            note: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            reason: z.string().min(1).optional(),
-            commitmentId: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await appendDeferralEventForTool(runtime, input, recordActorId)));
-    registerDxcTool("create_change", {
-        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)
-                .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, 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),
-            eventType: changeEventTypeSchema,
-            notice: z.string().min(1).optional(),
-            noticeTo: z.array(z.string().min(1)).optional(),
-            effectiveAt: z.string().min(1).optional(),
-            vetoByRole: changeVetoRoleSchema.optional(),
-            reason: 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(),
-            revisedRiskImpact: z.string().min(1).optional(),
-            revisedPlannedFor: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await appendChangeEvent(runtime.db, {
-        workspaceId: input.workspaceId,
-        changeId: input.changeId,
-        eventType: input.eventType,
-        event: buildChangeEventContent(input)
-    }, recordActorId)));
-    registerDxcTool("create_decision", {
-        description: "Create a revisitable decision ledger. Current decision is derived from the latest decision entry.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            title: z.string().min(1),
-            matter: z.string().min(1),
-            initialEntries: z.array(decisionInitialEntrySchema).optional(),
-            initialDecision: initialDecisionSchema.optional(),
-            fields: recordFieldsSchema
-        }
-    }, async ({ workspaceId, title, matter, initialEntries, initialDecision, fields }) => {
-        assertNoTypedFields(fields, "create_decision", DECISION_TYPED_FIELDS);
-        assertNoDecisionInputFields(fields);
-        return jsonResult(await createDecision(runtime, { workspaceId, title, matter, initialEntries, initialDecision, fields }, recordActorId));
-    });
-    registerDxcTool("append_decision_entry", {
-        description: "Append an immutable entry to a Decision. Use decision entries to change the derived current decision.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            decisionId: z.string().min(1),
-            entryType: decisionEntryTypeSchema,
-            body: z.string().min(1),
-            decidedBy: z.string().min(1).optional(),
-            rationale: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await appendDecisionEntry(runtime.db, input, recordActorId)));
-    registerDxcTool("create_risk", {
-        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(),
-            body: z.string().min(1).optional(),
-            likelihood: riskLevelSchema.optional(),
-            impact: riskLevelSchema.optional(),
-            treatment: riskTreatmentSchema.optional(),
-            treatmentRationale: z.string().min(1).optional(),
-            fields: recordFieldsSchema
-        }
-    }, 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
-        }
-    }, 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: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            limit: z.number().int().min(1).max(100).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async ({ recordType, workspaceId, limit, includeArchived }) => jsonResult(await listRecords(runtime.db, recordType, limit ?? 20, { workspaceId, includeArchived })));
-    registerDxcTool("list_linked_records", {
-        description: "List records linked to or from a DX Complete record.",
-        inputSchema: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            id: z.string().min(1),
-            direction: z.enum(["outbound", "inbound", "both"]).optional(),
-            relationship: z.string().min(1).optional(),
-            includeArchived: z.boolean().optional()
-        }
-    }, async (input) => jsonResult(await listLinkedRecords(runtime.db, input)));
-    registerDxcTool("link_decision_input", {
-        description: "Link a Decision to one record that informed it using the informed_by relationship.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            decisionId: z.string().min(1),
-            inputRecordType: decisionInputRecordTypeSchema,
-            inputId: z.string().min(1)
-        }
-    }, async (input) => jsonResult(await linkDecisionInput(runtime, input, recordActorId)));
-    registerDxcTool("update_record", {
-        description: "Update a DX Complete record and optionally clear top-level fields.",
-        inputSchema: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            summary: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional()
-        }
-    }, async (input) => jsonResult(await updateRecord(runtime.db, input, recordActorId)));
-    registerDxcTool("update_expectation", {
-        description: "Update an expectation record with typed expectation fields.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            statement: z.string().min(1).optional(),
-            successRecognition: z.string().min(1).optional(),
-            approvalState: expectationApprovalStateSchema.optional(),
-            approvedBy: z.string().min(1).optional(),
-            approvedAt: z.string().min(1).optional(),
-            source: z.string().min(1).optional(),
-            revisionNote: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional()
-        }
-    }, async (input) => jsonResult(await updateExpectation(runtime, input, recordActorId)));
-    registerDxcTool("update_requirement", {
-        description: "Update a requirement record with typed requirement fields.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            id: z.string().min(1),
-            title: z.string().min(1).optional(),
-            statement: z.string().min(1).optional(),
-            acceptanceCriteria: z.array(z.string().min(1)).optional(),
-            priority: z.enum(["low", "medium", "high"]).optional(),
-            status: requirementStatusSchema.optional(),
-            revisionNote: z.string().min(1).optional(),
-            fields: recordFieldsSchema,
-            unsetFields: z.array(fieldNameSchema).optional()
-        }
-    }, async (input) => jsonResult(await updateRequirement(runtime, input, recordActorId)));
-    registerDxcTool("append_review_note", {
-        description: "Append a non-blocking review note to an expectation or requirement. The optional important flag only surfaces the note; it does not create an approval duty or workflow block.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            recordType: reviewableRecordTypeSchema,
-            id: z.string().min(1),
-            body: z.string().min(1),
-            important: z.boolean().optional()
-        }
-    }, async (input) => jsonResult(await appendReviewNote(runtime.db, input, recordActorId)));
-    registerDxcTool("archive_record", {
-        description: "Archive a DX Complete record without deleting it.",
-        inputSchema: {
-            recordType: activeCollectionSchema,
-            workspaceId: workspaceIdSchema.optional(),
-            id: z.string().min(1),
-            reason: z.string().min(1).optional(),
-            supersededByType: activeCollectionSchema.optional(),
-            supersededById: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await archiveRecord(runtime.db, input, recordActorId)));
-    registerDxcTool("link_records", {
-        description: "Link one DX Complete record to another.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            fromType: activeCollectionSchema,
-            fromId: z.string().min(1),
-            toType: activeCollectionSchema,
-            toId: z.string().min(1),
-            relationship: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await linkRecords(runtime.db, input, recordActorId)));
-    registerDxcTool("unlink_records", {
-        description: "Remove one relationship link from a DX Complete record to another record.",
-        inputSchema: {
-            workspaceId: workspaceIdSchema,
-            fromType: activeCollectionSchema,
-            fromId: z.string().min(1),
-            toType: activeCollectionSchema,
-            toId: z.string().min(1),
-            relationship: z.string().min(1).optional()
-        }
-    }, async (input) => jsonResult(await unlinkRecords(runtime.db, input, recordActorId)));
-    return server;
-}
-function omitWorkspaceId(schema) {
-    const result = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (key !== "workspaceId") {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function injectHostedWorkspace(input, originalSchema, workspaceId) {
-    if (!Object.hasOwn(originalSchema, "workspaceId")) {
-        return input;
-    }
-    return {
-        ...input,
-        workspaceId
-    };
-}
-function assertHostedWorkspaceAccess(toolName, input, workspaceId) {
-    if (!workspaceId) {
-        return;
-    }
-    for (const key of ["recordType", "fromType", "toType", "supersededByType"]) {
-        if (input[key] === "workspaces") {
-            throw new Error(`${toolName} cannot operate on workspace records through a hosted workspace MCP endpoint.`);
-        }
-    }
-    if (typeof input.workspaceId === "string" && input.workspaceId !== workspaceId) {
-        throw new Error("Hosted MCP workspace scope mismatch.");
-    }
-}
-function assertToolRoleAccess(toolName, roles, input) {
-    if (!roles) {
-        return;
-    }
-    if (roles.includes("owner") || memberAllowedTools.has(toolName)) {
-        return;
-    }
-    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 === "maintenance_schedules")) {
-        return;
-    }
-    throw new Error(`Workspace role access denied for ${toolName}.`);
-}
-const memberAllowedTools = new Set([
-    "runtime_status",
-    "get_process_guide",
-    "get_doc",
-    "get_record",
-    "list_records",
-    "list_linked_records",
-    "list_environments",
-    "list_components",
-    "create_dxcomplete_ticket",
-    "append_dxcomplete_ticket",
-    "list_dxcomplete_tickets",
-    "list_unread_dxcomplete_ticket_replies",
-    "read_dxcomplete_ticket",
-    "archive_dxcomplete_ticket",
-    "append_journal_note",
-    "read_journal",
-    "get_journal_entry",
-    "append_journal_summary"
-]);
-const engineerAllowedTools = new Set([
-    "create_estimate",
-    "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",
-    "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 {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(value, null, 2)
-            }
-        ]
-    };
-}
-function getInputSchemaFingerprint(inputSchema) {
-    return createHash("sha256")
-        .update(stableStringify(z.toJSONSchema(z.object(inputSchema))))
-        .digest("hex")
-        .slice(0, 16);
-}
-function stableStringify(value) {
-    return JSON.stringify(sortJsonValue(value));
-}
-function sortJsonValue(value) {
-    if (Array.isArray(value)) {
-        return value.map(sortJsonValue);
-    }
-    if (value && typeof value === "object") {
-        const input = value;
-        const output = {};
-        for (const key of Object.keys(input).sort()) {
-            output[key] = sortJsonValue(input[key]);
-        }
-        return output;
-    }
-    return value;
-}
-async function createStatement(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "create_statement", STATEMENT_TYPED_FIELDS);
-    return createRecord(runtime.db, "statements", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            statement: input.statement,
-            ...(input.source !== undefined ? { source: input.source } : {})
-        }
-    }, actorId);
-}
-async function updateStatement(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_statement", STATEMENT_TYPED_FIELDS);
-    return updateRecord(runtime.db, {
-        recordType: "statements",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(input.statement !== undefined ? { statement: input.statement } : {}),
-            ...(input.source !== undefined ? { source: input.source } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        revisionNote: input.revisionNote
-    }, actorId);
-}
-async function createEnvironment(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "create_environment", ENVIRONMENT_TYPED_FIELDS);
-    return createRecord(runtime.db, "environments", {
-        workspaceId: input.workspaceId,
-        title: input.name,
-        summary: input.summary,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            name: input.name,
-            ...(input.description !== undefined ? { description: input.description } : {})
-        }
-    }, actorId);
-}
-async function updateEnvironment(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_environment", ENVIRONMENT_TYPED_FIELDS);
-    assertNoTypedUnsetFields(input.unsetFields, "update_environment", ENVIRONMENT_TYPED_FIELDS);
-    return updateRecord(runtime.db, {
-        recordType: "environments",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.name,
-        summary: input.summary,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(input.name !== undefined ? { name: input.name } : {}),
-            ...(input.description !== undefined ? { description: input.description } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        revisionNote: input.revisionNote
-    }, actorId);
-}
-async function listComponents(runtime, input) {
-    const environment = await getRecord(runtime.db, "environments", input.environmentId, {
-        workspaceId: input.workspaceId
-    });
-    if (!environment) {
-        throw new Error(`Environment not found: environments/${input.environmentId}`);
-    }
-    const filter = {
-        workspaceId: input.workspaceId,
-        "fields.environmentId": environment._id
-    };
-    if (!input.includeArchived) {
-        filter.archivedAt = { $exists: false };
-    }
-    return runtime.db
-        .collection("components")
-        .find(filter)
-        .sort({ createdAt: 1, _id: 1 })
-        .limit(input.limit ?? 20)
-        .toArray();
-}
-async function createComponent(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "environmentId"]);
-    assertNoTypedFields(input.fields, "create_component", COMPONENT_TYPED_FIELDS);
-    const environment = await getRecord(runtime.db, "environments", input.environmentId, {
-        workspaceId: input.workspaceId
-    });
-    if (!environment) {
-        throw new Error(`Environment not found: environments/${input.environmentId}`);
-    }
-    const component = await createRecord(runtime.db, "components", {
-        workspaceId: input.workspaceId,
-        title: input.name,
-        summary: input.summary,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            name: input.name,
-            environmentId: environment._id,
-            kind: input.kind,
-            locator: input.locator,
-            ...(input.identifiers !== undefined ? { identifiers: input.identifiers } : {}),
-            ...(input.secretPointers !== undefined ? { secretPointers: input.secretPointers } : {}),
-            ...(input.notes !== undefined ? { notes: input.notes } : {})
-        }
-    }, actorId);
-    return ensureLinkRecords(runtime, {
-        workspaceId: input.workspaceId,
-        fromType: "components",
-        fromId: component._id,
-        toType: "environments",
-        toId: environment._id,
-        relationship: "belongs_to_environment"
-    }, actorId);
-}
-async function updateComponent(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_component", COMPONENT_TYPED_FIELDS);
-    assertNoTypedUnsetFields(input.unsetFields, "update_component", COMPONENT_TYPED_FIELDS);
-    return updateRecord(runtime.db, {
-        recordType: "components",
-        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.locator !== undefined ? { locator: input.locator } : {}),
-            ...(input.identifiers !== undefined ? { identifiers: input.identifiers } : {}),
-            ...(input.secretPointers !== undefined ? { secretPointers: input.secretPointers } : {}),
-            ...(input.notes !== undefined ? { notes: input.notes } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        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");
-    if (input.statementId) {
-        const statement = await getRecord(runtime.db, "statements", input.statementId, {
-            workspaceId: input.workspaceId
-        });
-        if (!statement) {
-            throw new Error(`Statement not found: statements/${input.statementId}`);
-        }
-    }
-    const expectation = await createRecord(runtime.db, "expectations", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            statement: input.statement,
-            ...(input.successRecognition !== undefined ? { successRecognition: input.successRecognition } : {}),
-            approvalState: input.approvalState ?? "draft",
-            ...(input.approvedBy !== undefined ? { approvedBy: input.approvedBy } : {}),
-            ...(input.approvedAt !== undefined ? { approvedAt: input.approvedAt } : {}),
-            ...(input.source !== undefined ? { source: input.source } : {})
-        }
-    }, actorId);
-    if (!input.statementId) {
-        return expectation;
-    }
-    return linkRecords(runtime.db, {
-        workspaceId: input.workspaceId,
-        fromType: "expectations",
-        fromId: expectation._id,
-        toType: "statements",
-        toId: input.statementId,
-        relationship: "derives_from"
-    }, actorId);
-}
-async function createEstimate(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "initiativeId", "requirementIds", "expectationIds"]);
-    assertNoTypedFields(input.fields, "create_estimate", ESTIMATE_TYPED_FIELDS);
-    assertAtLeastOneEstimateTarget(input.requirementIds, input.expectationIds);
-    await assertRecordsExist(runtime, "requirements", input.requirementIds ?? [], input.workspaceId);
-    await assertRecordsExist(runtime, "expectations", input.expectationIds ?? [], input.workspaceId);
-    const lineItems = normalizeEstimateLineItems(input.lineItems);
-    let estimate = await createRecord(runtime.db, "estimates", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.summary,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            lineItems,
-            rollup: computeQuantifiedRollup(lineItems)
-        }
-    }, actorId);
-    estimate = await linkManyRecords(runtime, estimate, "requirements", input.requirementIds ?? [], "estimates", actorId);
-    estimate = await linkManyRecords(runtime, estimate, "expectations", input.expectationIds ?? [], "estimates", actorId);
-    return estimate;
-}
-async function updateEstimate(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_estimate", ESTIMATE_TYPED_FIELDS);
-    assertNoTypedUnsetFields(input.unsetFields, "update_estimate", ESTIMATE_TYPED_FIELDS);
-    const lineItems = input.lineItems ? normalizeEstimateLineItems(input.lineItems) : undefined;
-    return updateRecord(runtime.db, {
-        recordType: "estimates",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.title,
-        summary: input.summary,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(lineItems ? { lineItems, rollup: computeQuantifiedRollup(lineItems) } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        revisionNote: input.revisionNote
-    }, actorId);
-}
-function normalizeEstimateLineItems(lineItems) {
-    const seenIds = new Set();
-    return lineItems.map((item, index) => {
-        const id = item.id ?? randomUUID();
-        if (seenIds.has(id)) {
-            throw new Error(`Estimate line item id must be unique: ${id}.`);
-        }
-        seenIds.add(id);
-        if (item.timing === "recurring" && !item.period) {
-            throw new Error(`Estimate line item ${index + 1} is recurring and requires period.`);
-        }
-        if (item.timing === "one_time" && item.period) {
-            throw new Error(`Estimate line item ${index + 1} is one_time and must omit period.`);
-        }
-        if (item.amount.kind === "range" && !(item.amount.min <= item.amount.expected && item.amount.expected <= item.amount.max)) {
-            throw new Error(`Estimate line item ${index + 1} range must satisfy min <= expected <= max.`);
-        }
-        return {
-            id,
-            label: item.label,
-            timing: item.timing,
-            ...(item.period ? { period: item.period } : {}),
-            currency: item.currency,
-            amount: item.amount
-        };
-    });
-}
-async function createBenefits(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "initiativeId", "requirementIds", "expectationIds"]);
-    assertNoTypedFields(input.fields, "create_benefits", BENEFITS_TYPED_FIELDS);
-    assertAtLeastOneBenefitsTarget(input.requirementIds, input.expectationIds);
-    await assertRecordsExist(runtime, "requirements", input.requirementIds ?? [], input.workspaceId);
-    await assertRecordsExist(runtime, "expectations", input.expectationIds ?? [], input.workspaceId);
-    const benefitItems = normalizeBenefitItems(input.benefitItems);
-    let benefits = await createRecord(runtime.db, "benefits", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.summary,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            benefitItems,
-            rollup: computeQuantifiedRollup(benefitItems.filter(isQuantifiedBenefitItem))
-        }
-    }, actorId);
-    benefits = await linkManyRecords(runtime, benefits, "requirements", input.requirementIds ?? [], "benefits", actorId);
-    benefits = await linkManyRecords(runtime, benefits, "expectations", input.expectationIds ?? [], "benefits", actorId);
-    return benefits;
-}
-async function updateBenefits(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_benefits", BENEFITS_TYPED_FIELDS);
-    assertNoTypedUnsetFields(input.unsetFields, "update_benefits", BENEFITS_TYPED_FIELDS);
-    const benefitItems = input.benefitItems ? normalizeBenefitItems(input.benefitItems) : undefined;
-    return updateRecord(runtime.db, {
-        recordType: "benefits",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.title,
-        summary: input.summary,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(benefitItems ? { benefitItems, rollup: computeQuantifiedRollup(benefitItems.filter(isQuantifiedBenefitItem)) } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        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) => {
-        const id = item.id ?? randomUUID();
-        if (seenIds.has(id)) {
-            throw new Error(`Benefit item id must be unique: ${id}.`);
-        }
-        seenIds.add(id);
-        if (!item.amount) {
-            if (item.timing || item.period || item.currency) {
-                throw new Error(`Benefit item ${index + 1} is qualitative and must omit timing, period, and currency.`);
-            }
-            return {
-                id,
-                label: item.label
-            };
-        }
-        if (!item.timing) {
-            throw new Error(`Benefit item ${index + 1} has amount and requires timing.`);
-        }
-        if (!item.currency) {
-            throw new Error(`Benefit item ${index + 1} has amount and requires currency.`);
-        }
-        if (item.timing === "recurring" && !item.period) {
-            throw new Error(`Benefit item ${index + 1} is recurring and requires period.`);
-        }
-        if (item.timing === "one_time" && item.period) {
-            throw new Error(`Benefit item ${index + 1} is one_time and must omit period.`);
-        }
-        if (item.amount.kind === "range" && !(item.amount.min <= item.amount.expected && item.amount.expected <= item.amount.max)) {
-            throw new Error(`Benefit item ${index + 1} range must satisfy min <= expected <= max.`);
-        }
-        return {
-            id,
-            label: item.label,
-            timing: item.timing,
-            ...(item.period ? { period: item.period } : {}),
-            currency: item.currency,
-            amount: item.amount
-        };
-    });
-}
-function isQuantifiedBenefitItem(item) {
-    return !!item.amount && !!item.timing && !!item.currency;
-}
-function computeQuantifiedRollup(lineItems) {
-    const currencies = {};
-    for (const item of lineItems) {
-        const currency = (currencies[item.currency] ??= createEmptyRollupTimingGroup());
-        const amount = normalizeRollupAmount(item.amount);
-        if (item.timing === "one_time") {
-            currency.one_time = addRollupAmounts(currency.one_time, amount);
-            continue;
-        }
-        const recurring = currency.recurring;
-        recurring[item.period ?? ""] = addRollupAmounts(recurring[item.period ?? ""], amount);
-    }
-    return { currencies };
-}
-function createEmptyRollupTimingGroup() {
-    return {
-        one_time: createZeroRollupAmount(),
-        recurring: {}
-    };
-}
-function createZeroRollupAmount() {
-    return { min: 0, expected: 0, max: 0 };
-}
-function normalizeRollupAmount(amount) {
-    if (amount.kind === "single") {
-        return { min: amount.value, expected: amount.value, max: amount.value };
-    }
-    return { min: amount.min, expected: amount.expected, max: amount.max };
-}
-function addRollupAmounts(left, right) {
-    const base = left ?? createZeroRollupAmount();
-    return {
-        min: base.min + right.min,
-        expected: base.expected + right.expected,
-        max: base.max + right.max
-    };
-}
-async function createRequirement(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "expectationId"]);
-    assertNoTypedFields(input.fields, "create_requirement", REQUIREMENT_TYPED_FIELDS);
-    if (input.expectationId) {
-        const expectation = await getRecord(runtime.db, "expectations", input.expectationId, {
-            workspaceId: input.workspaceId
-        });
-        if (!expectation) {
-            throw new Error(`Expectation not found: expectations/${input.expectationId}`);
-        }
-    }
-    const requirement = await createRecord(runtime.db, "requirements", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            statement: input.statement,
-            ...(input.acceptanceCriteria ? { acceptanceCriteria: input.acceptanceCriteria } : {}),
-            ...(input.priority ? { priority: input.priority } : {}),
-            status: input.status ?? "draft"
-        }
-    }, actorId);
-    if (!input.expectationId) {
-        return requirement;
-    }
-    return linkRecords(runtime.db, {
-        workspaceId: input.workspaceId,
-        fromType: "requirements",
-        fromId: requirement._id,
-        toType: "expectations",
-        toId: input.expectationId,
-        relationship: "satisfies"
-    }, actorId);
-}
-async function createTask(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "requirementId"]);
-    assertNoTypedFields(input.fields, "create_task", TASK_TYPED_FIELDS);
-    if (input.requirementId) {
-        const requirement = await getRecord(runtime.db, "requirements", input.requirementId, {
-            workspaceId: input.workspaceId
-        });
-        if (!requirement) {
-            throw new Error(`Requirement not found: requirements/${input.requirementId}`);
-        }
-    }
-    const now = new Date().toISOString();
-    const initialStatus = input.initialStatus ?? "open";
-    const initialStatusEntry = {
-        id: randomUUID(),
-        entryType: "status_change",
-        body: `Initial status: ${initialStatus}.`,
-        status: initialStatus,
-        createdAt: now,
-        createdBy: actorId
-    };
-    const task = await createRecord(runtime.db, "tasks", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.description,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            description: input.description,
-            ...(input.assignee !== undefined ? { assignee: input.assignee } : {}),
-            ...(input.assignor !== undefined ? { assignor: input.assignor } : {}),
-            entries: [initialStatusEntry],
-            currentStatus: taskEntryToCurrentStatus(initialStatusEntry)
-        }
-    }, actorId);
-    if (!input.requirementId) {
-        return task;
-    }
-    return linkRecords(runtime.db, {
-        workspaceId: input.workspaceId,
-        fromType: "tasks",
-        fromId: task._id,
-        toType: "requirements",
-        toId: input.requirementId,
-        relationship: "implements"
-    }, actorId);
-}
-async function createDecision(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "create_decision", DECISION_TYPED_FIELDS);
-    assertNoDecisionInputFields(input.fields);
-    const now = new Date().toISOString();
-    const entries = buildInitialDecisionEntries(input.initialEntries, input.initialDecision, actorId, now);
-    const latestDecisionEntry = [...entries].reverse().find((entry) => entry.entryType === "decision");
-    return createRecord(runtime.db, "decisions", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: latestDecisionEntry?.body ?? input.matter,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            matter: input.matter,
-            entries,
-            ...(latestDecisionEntry ? { currentDecision: decisionEntryToCurrentDecision(latestDecisionEntry) } : {})
-        }
-    }, actorId);
-}
-function buildInitialDecisionEntries(initialEntries, initialDecision, actorId, createdAt) {
-    const entries = (initialEntries ?? []).map((entry) => buildDecisionEntry({
-        entryType: entry.entryType,
-        body: entry.body,
-        decidedBy: entry.decidedBy,
-        rationale: entry.rationale
-    }, actorId, createdAt));
-    if (initialDecision) {
-        entries.push(buildDecisionEntry({
-            entryType: "decision",
-            body: initialDecision.body,
-            decidedBy: initialDecision.decidedBy,
-            rationale: initialDecision.rationale
-        }, actorId, createdAt));
-    }
-    return entries;
-}
-function buildDecisionEntry(input, actorId, createdAt) {
-    if (input.entryType !== "decision" && (input.decidedBy || input.rationale)) {
-        throw new Error("decidedBy and rationale are only valid on decision entries.");
-    }
-    return {
-        id: randomUUID(),
-        entryType: input.entryType,
-        body: input.body,
-        createdAt,
-        createdBy: actorId,
-        ...(input.decidedBy ? { decidedBy: input.decidedBy } : {}),
-        ...(input.rationale ? { rationale: input.rationale } : {})
-    };
-}
-async function createCommitment(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "requirementIds", "expectationIds", "deferralId"]);
-    assertNoTypedFields(input.fields, "create_commitment", COMMITMENT_TYPED_FIELDS);
-    assertAtLeastOneCommitmentTarget(input.requirementIds, input.expectationIds);
-    await assertRecordsExist(runtime, "requirements", input.requirementIds ?? [], input.workspaceId);
-    await assertRecordsExist(runtime, "expectations", input.expectationIds ?? [], input.workspaceId);
-    if (input.deferralId) {
-        const deferral = await getRecord(runtime.db, "deferrals", input.deferralId, {
-            workspaceId: input.workspaceId
-        });
-        if (!deferral) {
-            throw new Error(`Deferral not found: deferrals/${input.deferralId}`);
-        }
-    }
-    const now = new Date().toISOString();
-    let commitment = await createRecord(runtime.db, "commitments", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.summary ?? input.commitmentStatement,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            commitmentStatement: input.commitmentStatement,
-            reservations: (input.reservationNotes ?? []).map((note) => ({
-                id: randomUUID(),
-                note,
-                createdAt: now,
-                createdBy: actorId
-            }))
-        }
-    }, actorId);
-    commitment = await linkManyRecords(runtime, commitment, "requirements", input.requirementIds ?? [], "commits", actorId);
-    commitment = await linkManyRecords(runtime, commitment, "expectations", input.expectationIds ?? [], "commits", actorId);
-    if (input.deferralId) {
-        commitment = await ensureLinkRecords(runtime, {
-            workspaceId: input.workspaceId,
-            fromType: "commitments",
-            fromId: commitment._id,
-            toType: "deferrals",
-            toId: input.deferralId,
-            relationship: "resolves_deferral"
-        }, actorId);
-    }
-    return commitment;
-}
-async function createDeferral(runtime, input, actorId) {
-    assertNoReservedFields(input.fields, ["workspaceId", "requirementIds", "expectationIds"]);
-    assertNoTypedFields(input.fields, "create_deferral", DEFERRAL_TYPED_FIELDS);
-    await assertRecordsExist(runtime, "requirements", input.requirementIds ?? [], input.workspaceId);
-    await assertRecordsExist(runtime, "expectations", input.expectationIds ?? [], input.workspaceId);
-    const now = new Date().toISOString();
-    let deferral = await createRecord(runtime.db, "deferrals", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.summary ?? input.reason,
-        allowManagedFields: true,
-        fields: {
-            ...(input.fields ?? {}),
-            reason: input.reason,
-            status: "open",
-            conditions: input.conditions.map((statement) => ({
-                id: randomUUID(),
-                statement,
-                state: "open",
-                createdAt: now,
-                createdBy: actorId,
-                updatedAt: now,
-                updatedBy: actorId
-            })),
-            conditionEvents: []
-        }
-    }, actorId);
-    deferral = await linkManyRecords(runtime, deferral, "requirements", input.requirementIds ?? [], "defers", actorId);
-    deferral = await linkManyRecords(runtime, deferral, "expectations", input.expectationIds ?? [], "defers", actorId);
-    return deferral;
-}
-async function appendDeferralEventForTool(runtime, input, actorId) {
-    const event = buildDeferralEventContent(input);
-    if (input.eventType === "deferral_resolved") {
-        const commitment = await getRecord(runtime.db, "commitments", event.commitmentId, {
-            workspaceId: input.workspaceId
-        });
-        if (!commitment) {
-            throw new Error(`Commitment not found: commitments/${event.commitmentId}`);
-        }
-    }
-    const deferral = await appendDeferralEvent(runtime.db, {
-        workspaceId: input.workspaceId,
-        deferralId: input.deferralId,
-        eventType: input.eventType,
-        event
-    }, actorId);
-    if (input.eventType !== "deferral_resolved") {
-        return deferral;
-    }
-    await ensureLinkRecords(runtime, {
-        workspaceId: input.workspaceId,
-        fromType: "commitments",
-        fromId: event.commitmentId,
-        toType: "deferrals",
-        toId: deferral._id,
-        relationship: "resolves_deferral"
-    }, actorId);
-    const updated = await getRecord(runtime.db, "deferrals", input.deferralId, { workspaceId: input.workspaceId });
-    if (!updated) {
-        throw new Error(`Deferral not found after resolution link: deferrals/${input.deferralId}`);
-    }
-    return updated;
-}
-function buildDeferralEventContent(input) {
-    switch (input.eventType) {
-        case "condition_addressed":
-        case "condition_reopened":
-            return compactObject({
-                conditionId: requireDeferralEventField(input.conditionId, input.eventType, "conditionId"),
-                summary: input.summary
-            });
-        case "condition_note_added":
-            return compactObject({
-                conditionId: requireDeferralEventField(input.conditionId, input.eventType, "conditionId"),
-                note: requireDeferralEventField(input.note, input.eventType, "note")
-            });
-        case "deferral_resolved":
-            return compactObject({
-                commitmentId: requireDeferralEventField(input.commitmentId, input.eventType, "commitmentId"),
-                summary: input.summary
-            });
-        case "deferral_abandoned":
-            return compactObject({
-                reason: requireDeferralEventField(input.reason, input.eventType, "reason"),
-                summary: input.summary
-            });
-    }
-}
-function requireDeferralEventField(value, eventType, fieldName) {
-    if (value === undefined) {
-        throw new Error(`${eventType} requires ${fieldName}.`);
-    }
-    return value;
-}
-function assertAtLeastOneCommitmentTarget(requirementIds, expectationIds) {
-    if ((requirementIds?.length ?? 0) > 0 || (expectationIds?.length ?? 0) > 0) {
-        return;
-    }
-    throw new Error("create_commitment requires at least one requirementId or expectationId.");
-}
-function assertAtLeastOneEstimateTarget(requirementIds, expectationIds) {
-    if ((requirementIds?.length ?? 0) > 0 || (expectationIds?.length ?? 0) > 0) {
-        return;
-    }
-    throw new Error("create_estimate requires at least one requirementId or expectationId.");
-}
-function assertAtLeastOneBenefitsTarget(requirementIds, expectationIds) {
-    if ((requirementIds?.length ?? 0) > 0 || (expectationIds?.length ?? 0) > 0) {
-        return;
-    }
-    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 });
-        if (!record) {
-            throw new Error(`Record not found: ${recordType}/${id}`);
-        }
-    }
-}
-async function linkManyRecords(runtime, source, toType, toIds, relationship, actorId) {
-    if (!source) {
-        throw new Error("Source record not found.");
-    }
-    let current = source;
-    for (const toId of new Set(toIds)) {
-        current = await ensureLinkRecords(runtime, {
-            workspaceId: current.workspaceId ?? "",
-            fromType: current.recordType,
-            fromId: current._id,
-            toType,
-            toId,
-            relationship
-        }, actorId);
-    }
-    return current;
-}
-async function ensureLinkRecords(runtime, input, actorId) {
-    const source = await getRecord(runtime.db, input.fromType, input.fromId, {
-        workspaceId: input.workspaceId
-    });
-    if (!source) {
-        throw new Error(`Source record not found: ${input.fromType}/${input.fromId}`);
-    }
-    const target = await getRecord(runtime.db, input.toType, input.toId, {
-        workspaceId: input.workspaceId
-    });
-    if (!target) {
-        throw new Error(`Target record not found: ${input.toType}/${input.toId}`);
-    }
-    if (source.links.some((link) => link.toType === input.toType &&
-        link.toId === target._id &&
-        link.relationship === input.relationship)) {
-        return source;
-    }
-    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
-        });
-        if (!requirement) {
-            throw new Error(`Requirement not found: requirements/${input.requirementId}`);
-        }
-    }
-    let change = await createRecord(runtime.db, "changes", {
-        workspaceId: input.workspaceId,
-        title: input.title,
-        summary: input.summary ?? input.changePlan,
-        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,
-            riskImpact: input.riskImpact,
-            ...(input.plannedFor !== undefined ? { plannedFor: input.plannedFor } : {})
-        }
-    }, actorId);
-    if (input.requirementId) {
-        change = await linkRecords(runtime.db, {
-            workspaceId: input.workspaceId,
-            fromType: "changes",
-            fromId: change._id,
-            toType: "requirements",
-            toId: input.requirementId,
-            relationship: "for_requirement"
-        }, 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({
-                notice: requireChangeEventField(input.notice, input.eventType, "notice"),
-                noticeTo: input.noticeTo,
-                effectiveAt: input.effectiveAt
-            });
-        case "veto_recorded":
-            return compactObject({
-                vetoByRole: requireChangeEventField(input.vetoByRole, input.eventType, "vetoByRole"),
-                reason: input.reason,
-                summary: input.summary
-            });
-        case "decision_recorded":
-            return compactObject({
-                decision: requireChangeEventField(input.decision, input.eventType, "decision"),
-                reason: input.reason,
-                summary: input.summary
-            });
-        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"),
-                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,
-                revisedRiskImpact: input.revisedRiskImpact,
-                revisedPlannedFor: input.revisedPlannedFor
-            });
-            if (Object.keys(event).length === 0) {
-                throw new Error("plan_revised requires summary or at least one revised plan field.");
-            }
-            return event;
-        }
-        case "note_added":
-            return compactObject({
-                note: requireChangeEventField(input.note, input.eventType, "note")
-            });
-    }
-}
-function requireChangeEventField(value, eventType, fieldName) {
-    if (value === undefined) {
-        throw new Error(`${eventType} requires ${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));
-}
-async function updateExpectation(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_expectation", EXPECTATION_TYPED_FIELDS);
-    assertNoObsoleteExpectationFields(input.fields, "update_expectation");
-    return updateRecord(runtime.db, {
-        recordType: "expectations",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(input.statement !== undefined ? { statement: input.statement } : {}),
-            ...(input.successRecognition !== undefined ? { successRecognition: input.successRecognition } : {}),
-            ...(input.approvalState !== undefined ? { approvalState: input.approvalState } : {}),
-            ...(input.approvedBy !== undefined ? { approvedBy: input.approvedBy } : {}),
-            ...(input.approvedAt !== undefined ? { approvedAt: input.approvedAt } : {}),
-            ...(input.source !== undefined ? { source: input.source } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        revisionNote: input.revisionNote
-    }, actorId);
-}
-async function updateRequirement(runtime, input, actorId) {
-    assertNoTypedFields(input.fields, "update_requirement", REQUIREMENT_TYPED_FIELDS);
-    return updateRecord(runtime.db, {
-        recordType: "requirements",
-        workspaceId: input.workspaceId,
-        id: input.id,
-        title: input.title,
-        summary: input.statement,
-        fields: {
-            ...(input.fields ?? {}),
-            ...(input.statement !== undefined ? { statement: input.statement } : {}),
-            ...(input.acceptanceCriteria !== undefined ? { acceptanceCriteria: input.acceptanceCriteria } : {}),
-            ...(input.priority !== undefined ? { priority: input.priority } : {}),
-            ...(input.status !== undefined ? { status: input.status } : {})
-        },
-        unsetFields: input.unsetFields,
-        allowManagedFields: true,
-        revisionNote: input.revisionNote
-    }, actorId);
-}
-async function linkDecisionInput(runtime, input, actorId) {
-    if (input.inputRecordType === "decisions" && input.inputId === input.decisionId) {
-        throw new Error("A Decision cannot be linked to itself as a decision input.");
-    }
-    const decision = await getRecord(runtime.db, "decisions", input.decisionId, {
-        workspaceId: input.workspaceId
-    });
-    if (!decision) {
-        throw new Error(`Decision not found: decisions/${input.decisionId}`);
-    }
-    const inputRecord = await getRecord(runtime.db, input.inputRecordType, input.inputId, {
-        workspaceId: input.workspaceId
-    });
-    if (!inputRecord) {
-        throw new Error(`Decision input not found: ${input.inputRecordType}/${input.inputId}`);
-    }
-    if (decision.links.some((link) => link.toType === input.inputRecordType &&
-        link.toId === inputRecord._id &&
-        link.relationship === "informed_by")) {
-        return decision;
-    }
-    return linkRecords(runtime.db, {
-        workspaceId: input.workspaceId,
-        fromType: "decisions",
-        fromId: decision._id,
-        toType: input.inputRecordType,
-        toId: inputRecord._id,
-        relationship: "informed_by"
-    }, actorId);
-}
-function assertNoReservedFields(fields, reservedFields) {
-    for (const reservedField of reservedFields) {
-        if (fields && Object.hasOwn(fields, reservedField)) {
-            throw new Error(`${reservedField} is a relationship input on this tool. Use the top-level ${reservedField} argument instead of fields.${reservedField}.`);
-        }
-    }
-}
-function assertNoTypedFields(fields, toolName, typedFields) {
-    for (const typedField of typedFields) {
-        if (fields && Object.hasOwn(fields, typedField)) {
-            throw new Error(`${typedField} is a typed input on ${toolName}. Use the top-level ${typedField} argument instead of fields.${typedField}.`);
-        }
-    }
-}
-function assertNoTypedUnsetFields(unsetFields, toolName, typedFields) {
-    for (const unsetField of unsetFields ?? []) {
-        if (typedFields.includes(unsetField)) {
-            throw new Error(`${unsetField} is managed on ${toolName}. Use the typed inputs instead of unsetFields.${unsetField}.`);
-        }
-    }
-}
-function assertNoDecisionInputFields(fields) {
-    for (const fieldName of DECISION_INPUT_FIELDS) {
-        if (fields && Object.hasOwn(fields, fieldName)) {
-            throw new Error(`${fieldName} is managed on decisions. Use link_decision_input to record decision inputs.`);
-        }
-    }
-}
-function assertNoObsoleteExpectationFields(fields, toolName) {
-    for (const obsoleteField of OBSOLETE_EXPECTATION_FIELDS) {
-        if (fields && Object.hasOwn(fields, obsoleteField)) {
-            throw new Error(`${obsoleteField} is not part of the current Expectation model on ${toolName}. Use approvalState, approvedBy, or approvedAt where approval tracking is needed.`);
-        }
-    }
-}