dxcomplete 0.1.0

package/scripts/smoke-mcp-http.mjs

@@ -0,0 +1,3572 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createHash, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import handleDxcompleteWorkspaceHttpRequest, { closeDxcompleteHttpRuntime } from "../dist/http/server.js";
+import handleDxcompleteServiceRequest, { closeDxcompleteServiceRuntime } from "../dist/http/service.js";
+import { createGoogleActorContext } from "../dist/runtime/actor.js";
+import {
+  createOAuthAuthorizationCode,
+  createOAuthAuthorizationRequest,
+  ensureWorkspaceBootstrap,
+  issueMcpTokenPair,
+  upsertWorkspaceMembership
+} from "../dist/runtime/auth.js";
+import { connectRuntime } from "../dist/runtime/mongo.js";
+import {
+  appendDxcompleteTicketReply,
+  archiveDxcompleteTicket,
+  archiveRecord,
+  DXCOMPLETE_TICKET_COLLECTION_NAME
+} from "../dist/runtime/records.js";
+import { loadWorkspaceConfig } from "../dist/runtime/workspace.js";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const runId = `smoke-http-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+const expectedHostedToolCount = 49;
+const smokeTimeoutMs = 60_000;
+const smokeCleanupActorId = "dxcomplete-http-smoke";
+const smokeStartedAt = Date.now();
+let lastSmokeStepAt = smokeStartedAt;
+const selectableSmokeAreas = ["surface", "docs", "records", "weigh", "change", "tickets", "journal"];
+const smokeRecordTypes = [
+  "statements",
+  "journal_entries",
+  "environments",
+  "components",
+  "estimates",
+  "benefits",
+  "expectations",
+  "requirements",
+  "tasks",
+  "commitments",
+  "deferrals",
+  "changes",
+  "decisions",
+  "risks"
+];
+const smokeTitlePattern = /^DX Complete hosted MCP smoke /;
+
+process.env.DXC_GOOGLE_CLIENT_ID ||= "dxcomplete-http-smoke-client-id";
+process.env.DXC_GOOGLE_CLIENT_SECRET ||= "dxcomplete-http-smoke-client-secret";
+process.env.DXC_SERVICE_PROVISIONING_SECRET ||= `dxcomplete-http-smoke-provisioning-${runId}`;
+
+let runtime;
+let workspaceConfig;
+let server;
+let serviceServer;
+let client;
+let transport;
+let smokeActor;
+let createdTicketId;
+let createdStatementId;
+let createdExpectationId;
+let createdRequirementId;
+let createdEstimateId;
+let createdBenefitsId;
+let createdCommitmentId;
+let createdDeferralId;
+let createdChangeId;
+let createdDecisionId;
+let createdServiceClientId;
+
+const smokeSelection = parseSmokeSelection(process.argv.slice(2));
+
+if (smokeSelection.runner === "selected") {
+  await runSelectedSmoke(smokeSelection);
+  process.exit(0);
+}
+
+try {
+  smokeStep("connecting runtime");
+  runtime = await connectRuntime({ envFile: path.join(rootDir, ".env.local") });
+  workspaceConfig = await loadWorkspaceConfig({ cwd: rootDir });
+
+  await ensureWorkspaceBootstrap(runtime.db, workspaceConfig, smokeCleanupActorId);
+  await archiveStaleSmokeArtifacts(runtime.db, workspaceConfig.workspaceId);
+
+  smokeStep("starting local HTTP MCP server");
+  server = createServer((req, res) => {
+    void handleDxcompleteWorkspaceHttpRequest(req, res);
+  });
+  const baseUrl = await listen(server);
+  const mcpUrl = `${baseUrl}/api/mcp`;
+
+  smokeStep("checking unauthenticated metadata");
+  const unauthorized = await fetchWithTimeout(mcpUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} })
+  });
+  assert(unauthorized.status === 401, "Unauthenticated MCP request did not return 401.");
+  assert(
+    unauthorized.headers.get("www-authenticate")?.includes("/.well-known/oauth-protected-resource/api/mcp"),
+    "Unauthenticated MCP request did not advertise protected-resource metadata."
+  );
+  smokeStep("unauthenticated challenge ok");
+
+  const protectedMetadataResponse = await fetchWithTimeout(
+    `${baseUrl}/.well-known/oauth-protected-resource/api/mcp`
+  );
+  assert(protectedMetadataResponse.ok, "Protected-resource metadata was not reachable.");
+  const protectedMetadata = await protectedMetadataResponse.json();
+  assert(protectedMetadata.resource === mcpUrl, "Protected-resource metadata did not match the exact MCP URL.");
+  smokeStep("protected resource metadata ok");
+
+  const authMetadataResponse = await fetchWithTimeout(`${baseUrl}/.well-known/oauth-authorization-server`);
+  assert(authMetadataResponse.ok, "Authorization server metadata was not reachable.");
+  const authMetadata = await authMetadataResponse.json();
+  assert(
+    authMetadata.registration_endpoint === `${baseUrl}/api/dxcomplete/auth/register`,
+    "Authorization server metadata did not expose dynamic client registration."
+  );
+  smokeStep("authorization metadata ok");
+
+  const registrationResponse = await fetchWithTimeout(`${baseUrl}/api/dxcomplete/auth/register`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: `DX Complete HTTP smoke ${runId}`,
+      redirect_uris: ["https://client.example/callback"]
+    })
+  });
+  assert(registrationResponse.status === 201, "OAuth dynamic client registration failed.");
+  const registration = await registrationResponse.json();
+  smokeStep("dynamic client registration ok");
+  const authorizeUrl = new URL(`${baseUrl}/api/dxcomplete/auth/authorize`);
+  authorizeUrl.searchParams.set("client_id", registration.client_id);
+  authorizeUrl.searchParams.set("redirect_uri", "https://client.example/callback");
+  authorizeUrl.searchParams.set("response_type", "code");
+  authorizeUrl.searchParams.set("code_challenge", "smoke-code-challenge");
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  authorizeUrl.searchParams.set("resource", mcpUrl);
+
+  const authorizeResponse = await fetchWithTimeout(authorizeUrl, { redirect: "manual" });
+  assert(authorizeResponse.status === 302, "OAuth authorize did not redirect to Google.");
+  const googleLocation = new URL(authorizeResponse.headers.get("location"));
+  assert(googleLocation.hostname === "accounts.google.com", "OAuth authorize did not redirect to Google.");
+  assert(
+    googleLocation.searchParams.get("redirect_uri") === `${baseUrl}/api/auth/callback/google`,
+    "OAuth authorize did not use /api/auth/callback/google as the Google callback."
+  );
+  smokeStep("authorization redirect ok");
+
+  smokeStep("issuing smoke actor token");
+  const actor = createGoogleActorContext({
+    email: `http-smoke-${runId}@example.com`,
+    subject: runId,
+    displayName: "HTTP Smoke Actor"
+  });
+  smokeActor = actor;
+  await upsertWorkspaceMembership(runtime.db, {
+    workspaceId: workspaceConfig.workspaceId,
+    email: actor.email,
+    role: "member",
+    actorId: smokeCleanupActorId,
+    provider: "google",
+    providerSubject: actor.providerSubject
+  });
+
+  const tokenExchangeVerifier = `smoke-token-verifier-${runId}`;
+  const tokenExchangeChallenge = createHash("sha256").update(tokenExchangeVerifier).digest("base64url");
+  const tokenExchangeRequest = await createOAuthAuthorizationRequest(runtime.db, {
+    clientId: registration.client_id,
+    redirectUri: "https://client.example/callback",
+    codeChallenge: tokenExchangeChallenge,
+    codeChallengeMethod: "S256",
+    scope: "mcp:tools",
+    resource: mcpUrl,
+    workspaceId: workspaceConfig.workspaceId
+  });
+  const tokenExchangeCode = await createOAuthAuthorizationCode(runtime.db, tokenExchangeRequest, actor);
+  const tokenExchangeResponse = await fetchWithTimeout(`${baseUrl}/api/dxcomplete/auth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: registration.client_id,
+      code: tokenExchangeCode,
+      redirect_uri: "https://client.example/callback",
+      code_verifier: tokenExchangeVerifier,
+      resource: mcpUrl
+    })
+  });
+  assert(tokenExchangeResponse.status === 200, "OAuth authorization_code token exchange failed.");
+  assert(
+    tokenExchangeResponse.headers.get("cache-control")?.includes("no-store"),
+    "OAuth token response did not include Cache-Control: no-store."
+  );
+  assert(tokenExchangeResponse.headers.get("pragma") === "no-cache", "OAuth token response did not include Pragma: no-cache.");
+  const tokenExchangeBody = await tokenExchangeResponse.json();
+  assert(typeof tokenExchangeBody.access_token === "string", "OAuth token response did not include an access token.");
+  await runtime.db.collection("oauth_authorization_requests").deleteOne({ _id: tokenExchangeRequest._id });
+
+  const tokenPair = await issueMcpTokenPair(runtime.db, {
+    clientId: smokeCleanupActorId,
+    workspaceId: workspaceConfig.workspaceId,
+    actor,
+    resource: mcpUrl,
+    scope: "mcp:tools"
+  });
+
+  const noAcceptResponse = await fetchWithTimeout(mcpUrl, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${tokenPair.accessToken}`,
+      "content-type": "application/json",
+      "mcp-protocol-version": "2025-06-18"
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 3, method: "tools/list", params: {} })
+  });
+  assert(noAcceptResponse.status !== 406, "Authenticated MCP POST without explicit Accept returned 406.");
+  assert(
+    noAcceptResponse.headers.get("content-type")?.includes("application/json"),
+    "Authenticated MCP POST did not return a JSON response."
+  );
+
+  const nonMemberActor = createGoogleActorContext({
+    email: `http-smoke-nonmember-${runId}@example.com`,
+    subject: `${runId}-nonmember`
+  });
+  const nonMemberTokenPair = await issueMcpTokenPair(runtime.db, {
+    clientId: smokeCleanupActorId,
+    workspaceId: workspaceConfig.workspaceId,
+    actor: nonMemberActor,
+    resource: mcpUrl,
+    scope: "mcp:tools"
+  });
+  const forbidden = await fetchWithTimeout(mcpUrl, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${nonMemberTokenPair.accessToken}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })
+  });
+  assert(forbidden.status === 403, "Non-member token did not return 403.");
+
+  smokeStep("connecting MCP client");
+  client = new Client({ name: "dxcomplete-smoke-mcp-http", version: "0.1.0" });
+  transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+    requestInit: {
+      headers: {
+        authorization: `Bearer ${tokenPair.accessToken}`
+      }
+    }
+  });
+  await withTimeout(client.connect(transport), smokeTimeoutMs, "MCP client connect timed out.");
+
+  smokeStep("checking runtime status and tool surface");
+  const status = await callJsonTool("runtime_status", {});
+  assert(status.ok === true, "runtime_status did not return ok: true.");
+  assert(status.actor?.provider === "google", "Hosted runtime did not expose Google actor context.");
+  assert(status.actor?.email === actor.email, "Hosted runtime actor email did not match token actor.");
+  assert(status.workspace?.workspaceId === workspaceConfig.workspaceId, "Hosted runtime did not expose repo workspace config.");
+  assert(status.server?.toolCount === expectedHostedToolCount, `Expected ${expectedHostedToolCount} hosted tools.`);
+  assert(!status.server.tools.includes("create_workspace"), "Hosted surface should not expose create_workspace.");
+  assert(
+    status.server?.surfaceVersion === "dxc-mcp-surface",
+    "Hosted runtime did not expose the expected MCP surface version."
+  );
+  assert(status.server?.workspaceCompatibility === 1, "Hosted runtime did not expose the expected workspace compatibility version.");
+  assert(typeof status.server?.packageVersion === "string", "Hosted runtime did not expose a package version.");
+  assert(
+    typeof status.server?.surfaceFingerprint === "string" &&
+      /^[a-f0-9]{16}$/.test(status.server.surfaceFingerprint),
+    "Hosted runtime did not expose a stable MCP surface fingerprint."
+  );
+  assert(
+    Array.isArray(status.server?.surfaceIncludes) &&
+      status.server.surfaceIncludes.includes("tools") &&
+      status.server.surfaceIncludes.includes("toolSchemas") &&
+      status.server.surfaceIncludes.includes("processGuide") &&
+      status.server.surfaceIncludes.includes("docReferences"),
+    "Hosted runtime did not describe what the MCP surface fingerprint covers."
+  );
+  assert(
+    status.server?.http?.canonicalMcpUrl === mcpUrl,
+    "Hosted runtime did not report the canonical MCP URL."
+  );
+  assert(
+    status.server?.http?.protectedResourceMetadataUrl === `${baseUrl}/.well-known/oauth-protected-resource/api/mcp`,
+    "Hosted runtime did not report the protected-resource metadata URL."
+  );
+  assert(
+    status.server?.http?.googleCallbackUrl === `${baseUrl}/api/auth/callback/google`,
+    "Hosted runtime did not report the Google callback URL."
+  );
+
+  const manifestByName = new Map(status.server.toolManifest.map((tool) => [tool.name, tool]));
+  assert(status.server.tools.includes("get_doc"), "Hosted surface is missing get_doc.");
+  for (const oldToolName of [
+    "create_intake_item",
+    "append_intake_item",
+    "get_intake_item",
+    "list_intake_items",
+    "archive_intake_item"
+  ]) {
+    assert(
+      !status.server.tools.includes(oldToolName),
+      `Hosted runtime should not expose old intake tool ${oldToolName}.`
+    );
+  }
+  for (const ticketToolName of [
+    "create_dxcomplete_ticket",
+    "append_dxcomplete_ticket",
+    "list_dxcomplete_tickets",
+    "archive_dxcomplete_ticket",
+    "list_unread_dxcomplete_ticket_replies",
+    "read_dxcomplete_ticket"
+  ]) {
+    assert(status.server.tools.includes(ticketToolName), `Hosted surface is missing ${ticketToolName}.`);
+  }
+  assert(
+    !status.server.tools.includes("mark_dxcomplete_ticket_replies_read"),
+    "Hosted runtime should not expose mark_dxcomplete_ticket_replies_read."
+  );
+  assert(
+    !status.server.tools.includes("get_dxcomplete_ticket"),
+    "Hosted runtime should not expose get_dxcomplete_ticket."
+  );
+  assert(
+    !status.server.tools.includes("get_next_steps"),
+    "Hosted runtime should not expose a server-side get_next_steps tool."
+  );
+  for (const expectationToolName of ["create_expectation", "update_expectation"]) {
+    assert(status.server.tools.includes(expectationToolName), `Hosted surface is missing ${expectationToolName}.`);
+  }
+  for (const statementToolName of ["create_statement", "update_statement"]) {
+    assert(status.server.tools.includes(statementToolName), `Hosted surface is missing ${statementToolName}.`);
+  }
+  assert(status.server.tools.includes("append_review_note"), "Hosted surface is missing append_review_note.");
+  assert(status.server.tools.includes("create_commitment"), "Hosted surface is missing create_commitment.");
+  assert(status.server.tools.includes("create_deferral"), "Hosted surface is missing create_deferral.");
+  assert(status.server.tools.includes("append_deferral_event"), "Hosted surface is missing append_deferral_event.");
+  assert(status.server.tools.includes("create_change"), "Hosted surface is missing create_change.");
+  assert(status.server.tools.includes("append_change_event"), "Hosted surface is missing append_change_event.");
+  assert(status.server.tools.includes("link_decision_input"), "Hosted surface is missing link_decision_input.");
+  assert(status.server.tools.includes("unlink_records"), "Hosted surface is missing unlink_records.");
+  assert(status.server.tools.includes("append_decision_entry"), "Hosted surface is missing append_decision_entry.");
+  assert(status.server.tools.includes("append_task_entry"), "Hosted surface is missing append_task_entry.");
+  assert(!status.server.tools.includes("update_decision"), "Hosted surface should not expose update_decision.");
+  assert(!status.server.tools.includes("update_task"), "Hosted surface should not expose update_task.");
+  assert(status.server.tools.includes("create_estimate"), "Hosted surface is missing create_estimate.");
+  assert(status.server.tools.includes("update_estimate"), "Hosted surface is missing update_estimate.");
+  assert(status.server.tools.includes("create_benefits"), "Hosted surface is missing create_benefits.");
+  assert(status.server.tools.includes("update_benefits"), "Hosted surface is missing update_benefits.");
+  for (const registryToolName of [
+    "create_environment",
+    "update_environment",
+    "list_environments",
+    "create_component",
+    "update_component",
+    "list_components"
+  ]) {
+    assert(status.server.tools.includes(registryToolName), `Hosted surface is missing ${registryToolName}.`);
+  }
+  for (const journalToolName of [
+    "append_journal_note",
+    "read_journal",
+    "get_journal_entry",
+    "append_journal_summary"
+  ]) {
+    assert(status.server.tools.includes(journalToolName), `Hosted surface is missing ${journalToolName}.`);
+  }
+  assert(
+    manifestByName.get("append_journal_note")?.description.includes("no better dedicated record home"),
+    "Hosted append_journal_note should describe Journal as fallback after dedicated records."
+  );
+  for (const removedToolName of [
+    "get_service_charter",
+    "update_service_charter",
+    "create_initiative",
+    "create_business_case",
+    "create_cost_baseline",
+    "create_cost_actual",
+    "create_benefit_measurement",
+    "create_cost_estimate",
+    "create_benefit_estimate"
+  ]) {
+    assert(
+      !status.server.tools.includes(removedToolName),
+      `Hosted runtime should not expose removed tool ${removedToolName}.`
+    );
+  }
+  assert(
+    manifestByName.get("get_doc")?.inputFields.join(",") === "page,term",
+    "Hosted get_doc should expose page and optional term inputs."
+  );
+  assert(
+    manifestByName.get("update_expectation")?.inputFields.includes("revisionNote"),
+    "Hosted update_expectation should expose revisionNote."
+  );
+  assert(
+    manifestByName.get("update_requirement")?.inputFields.includes("revisionNote"),
+    "Hosted update_requirement should expose revisionNote."
+  );
+  assert(
+    manifestByName.get("update_estimate")?.inputFields.includes("revisionNote"),
+    "Hosted update_estimate should expose revisionNote."
+  );
+  for (const toolName of [
+    "get_doc",
+    "create_record",
+    "get_record",
+    "create_statement",
+    "update_statement",
+    "create_expectation",
+    "update_expectation",
+    "append_review_note",
+    "create_environment",
+    "update_environment",
+    "list_environments",
+    "create_component",
+    "update_component",
+    "list_components",
+    "create_estimate",
+    "update_estimate",
+    "create_benefits",
+    "update_benefits",
+    "create_requirement",
+    "create_task",
+    "append_task_entry",
+    "create_commitment",
+    "create_deferral",
+    "append_deferral_event",
+    "create_change",
+    "append_change_event",
+    "create_decision",
+    "append_decision_entry",
+    "link_decision_input",
+    "append_journal_note",
+    "read_journal",
+    "get_journal_entry",
+    "append_journal_summary",
+    "list_records",
+    "list_linked_records",
+    "update_record",
+    "update_requirement",
+    "archive_record",
+    "link_records",
+    "unlink_records"
+  ]) {
+    assert(
+      !manifestByName.get(toolName)?.inputFields.includes("workspaceId"),
+      `${toolName} should not expose workspaceId on the hosted surface.`
+    );
+  }
+
+  const processGuide = await callJsonTool("get_process_guide", {});
+  assert(processGuide.surfaceVersion === status.server.surfaceVersion, "Hosted process guide surface version did not match runtime_status.");
+  assert(
+    processGuide.surfaceFingerprint === status.server.surfaceFingerprint,
+    "Hosted process guide surface fingerprint did not match runtime_status."
+  );
+  assert(
+    processGuide.status?.includes("lean guide") &&
+      processGuide.clientGuidance?.some((entry) => entry.includes("Use get_doc")),
+    "Hosted process guide did not describe itself as lean or point clients to get_doc."
+  );
+  assert(Array.isArray(processGuide.phases) && processGuide.phases.length === 7, "Hosted process guide did not return seven phases.");
+  assert(
+    processGuide.currentFlow?.join(",") === "Statement,Expectation,Requirement,Commitment",
+    "Hosted process guide did not return the expected Statement-first flow."
+  );
+  assert(
+    processGuide.phaseGuidance?.some((entry) => entry.includes("non-terminal") && entry.includes("re-enterable")),
+    "Hosted process guide did not describe phases as non-terminal and re-enterable."
+  );
+  assert(
+    processGuide.crossCuttingRecords?.some(
+      (entry) =>
+        entry.record === "Task" &&
+        entry.use.includes("Statement, Expectation, Requirement, Commitment")
+    ),
+    "Hosted process guide should describe Task as cross-cutting without naming a separate sequence concept."
+  );
+  assert(
+    processGuide.recordRoutingGuidance?.sharpTest?.includes("Will anything reference or depend on this") &&
+      processGuide.recordRoutingGuidance?.routingOrder?.some(
+        (entry) => entry.use === "Use Journal." && entry.when.includes("no better home")
+      ),
+    "Hosted process guide should include compact record-routing guidance."
+  );
+  assert(
+    processGuide.phases.map((phase) => phase.id).join(",") === "orient,elicit,weigh,build,go_live,operate,measure",
+    "Hosted process guide returned an unexpected phase order."
+  );
+  assert(
+    processGuide.nextStepGuidance?.responsibility?.includes("MCP client derives the next step") &&
+      processGuide.nextStepGuidance?.responsibility?.includes("does not compute or prescribe"),
+    "Hosted process guide did not describe next-step reasoning as client-side guidance."
+  );
+  assert(
+    processGuide.phases.every(
+      (phase) =>
+        phase.operatingGuidance?.clientRole &&
+        Array.isArray(phase.operatingGuidance.conductRules) &&
+        Array.isArray(phase.operatingGuidance.questionsToAsk) &&
+        Array.isArray(phase.operatingGuidance.expectedOutput) &&
+        phase.operatingGuidance.exitCheck &&
+        Array.isArray(phase.operatingGuidance.checkpointNotes)
+    ),
+    "Hosted process guide did not return operating guidance for every phase."
+  );
+  const orientGuidance = processGuide.phases.find((phase) => phase.id === "orient")?.operatingGuidance;
+  const orientGuidanceText = JSON.stringify(orientGuidance).toLowerCase();
+  assert(orientGuidanceText.includes("statement"), "Orient guidance should tell the client to elicit Statement.");
+  assert(orientGuidanceText.includes("do not invent"), "Orient guidance should tell the client not to invent the raw input.");
+  assert(
+    orientGuidanceText.includes("confirm that wording before recording"),
+    "Orient guidance should describe capture-confirmation as conduct."
+  );
+  assert(
+    orientGuidanceText.includes("plain outcome language"),
+    "Orient guidance should require plain outcome language."
+  );
+  assert(
+    orientGuidanceText.includes("do not move into technical solution design"),
+    "Orient guidance should keep technical solution design out of Orient."
+  );
+  const expectationConcept = processGuide.processConcepts?.find((concept) => concept.name === "Expectation");
+  assert(
+    expectationConcept?.status === "runtime_record" && expectationConcept.currentRuntimeRecordType === "expectations",
+    "Expectation should be described as a runtime record."
+  );
+  const statementConcept = processGuide.processConcepts?.find((concept) => concept.name === "Statement");
+  assert(
+    statementConcept?.status === "runtime_record" && statementConcept.currentRuntimeRecordType === "statements",
+    "Statement should be described as a runtime record."
+  );
+  const voiceConcept = processGuide.processConcepts?.find((concept) => concept.name === "Voice");
+  assert(
+    voiceConcept === undefined,
+    "Voice should not remain a current process concept."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("statements"),
+    "statements should appear as a current runtime record type."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("expectations"),
+    "expectations should appear as a current runtime record type."
+  );
+  const checkpointGuidanceText = JSON.stringify(processGuide.checkpointGuidance ?? []).toLowerCase();
+  assert(
+    checkpointGuidanceText.includes("formally accepted as risk by the owner"),
+    "Hosted process guide should describe Owner-level risk acceptance."
+  );
+  assert(
+    checkpointGuidanceText.includes("proceeded past with open risk"),
+    "Hosted process guide should distinguish proceeding past open risk."
+  );
+  assert(
+    checkpointGuidanceText.includes("proceeding does not close or accept the risk"),
+    "Hosted process guide should say proceeding is not risk acceptance."
+  );
+  assert(
+    JSON.stringify(processGuide.clientGuidance ?? []).includes("link_decision_input") &&
+      JSON.stringify(processGuide.clientGuidance ?? []).includes("informed_by"),
+    "Hosted process guide should point clients to decision input links."
+  );
+  assert(
+    JSON.stringify(processGuide.recordGuidance ?? []).toLowerCase().includes("version history") &&
+      JSON.stringify(processGuide.clientGuidance ?? []).includes("update_expectation") &&
+      JSON.stringify(processGuide.clientGuidance ?? []).includes("update_requirement"),
+    "Hosted process guide should describe versioned Expectation and Requirement updates."
+  );
+  const processGuideText = JSON.stringify(processGuide).toLowerCase();
+  assert(processGuideText.includes("review notes"), "Hosted process guide should mention review notes.");
+  assert(
+    processGuideText.includes("do not require the owner to acknowledge or answer"),
+    "Hosted process guide should say important review notes do not require an Owner response."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("changes"),
+    "changes should appear as a current runtime record type."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("commitments") &&
+      processGuide.runtimeRecordTypes?.includes("deferrals"),
+    "commitments and deferrals should appear as current runtime record types."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("estimates"),
+    "estimates should appear as a current runtime record type."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("benefits"),
+    "benefits should appear as a current runtime record type."
+  );
+  assert(
+    processGuide.runtimeRecordTypes?.includes("environments") &&
+      processGuide.runtimeRecordTypes?.includes("components"),
+    "environments and components should appear as current runtime record types."
+  );
+  for (const removedRuntimeRecordType of [
+    "service_charters",
+    "business_cases",
+    "cost_baselines",
+    "cost_actuals",
+    "benefit_measurements",
+    "cost_estimates",
+    "benefit_estimates"
+  ]) {
+    assert(
+      !processGuide.runtimeRecordTypes?.includes(removedRuntimeRecordType),
+      `Hosted process guide should not include removed runtime record type ${removedRuntimeRecordType}.`
+    );
+  }
+  assert(
+    processGuideText.includes("commitment") &&
+      processGuideText.includes("deferral") &&
+      processGuideText.includes("phase outcome-neutral"),
+    "Hosted process guide should describe Weigh as Commitment-or-Deferral guidance."
+  );
+  assert(
+    processGuideText.includes("engineer cost estimate") &&
+      processGuideText.includes("owner-authored benefits") &&
+      processGuideText.includes("budget") &&
+      processGuideText.includes("informed_by"),
+    "Hosted process guide should describe separate Estimate and Benefits Weigh guidance."
+  );
+  assert(
+    processGuideText.includes("operations plan") &&
+      processGuideText.includes("append-only change events") &&
+      processGuideText.includes("does not perform or enforce"),
+    "Hosted process guide should describe Change as append-only record-layer service-change guidance."
+  );
+  assert(
+    processGuideText.includes("operational registry") &&
+      processGuideText.includes("environment") &&
+      processGuideText.includes("component"),
+    "Hosted process guide should describe Operational Registry routing."
+  );
+
+  const rolesDoc = await callJsonTool("get_doc", { page: "roles" });
+  assert(rolesDoc.surfaceVersion === status.server.surfaceVersion, "Hosted get_doc surface version did not match runtime_status.");
+  assert(
+    rolesDoc.surfaceFingerprint === status.server.surfaceFingerprint,
+    "Hosted get_doc surface fingerprint did not match runtime_status."
+  );
+  const expectedRoleNames = [
+    "Owner",
+    "Engineer",
+    "Tester",
+    "Operator",
+    "Support Agent",
+    "End User"
+  ];
+  const actualRoleNames = rolesDoc.roles?.map((role) => role.name) ?? [];
+  assert(
+    JSON.stringify(actualRoleNames) === JSON.stringify(expectedRoleNames),
+    `Hosted get_doc roles should return exactly the locked six-role model. Received: ${actualRoleNames.join(", ")}`
+  );
+  for (const roleName of expectedRoleNames) {
+    assert(
+      rolesDoc.roles?.some((role) => role.name === roleName),
+      `Hosted get_doc roles did not include ${roleName}.`
+    );
+  }
+  for (const oldRoleName of ["Director", "Product Lead", "Product", "Engineering", "Coder", "QA", "Operations", "Support", "Admin", "Client/User"]) {
+    assert(!actualRoleNames.includes(oldRoleName), `Hosted get_doc roles should not include old role ${oldRoleName}.`);
+  }
+
+  const glossaryDoc = await callJsonTool("get_doc", { page: "glossary" });
+  assert(
+    Array.isArray(glossaryDoc.terms) && glossaryDoc.terms.some((entry) => entry.term === "Expectation"),
+    "Hosted get_doc glossary should return glossary entries when no term is provided."
+  );
+  const glossaryTerms = glossaryDoc.terms?.map((entry) => entry.term) ?? [];
+  assert(glossaryTerms.includes("Change"), "Hosted get_doc glossary did not include Change.");
+  assert(!glossaryTerms.includes("Change Request"), "Hosted get_doc glossary should not include Change Request.");
+  assert(glossaryTerms.includes("Decision Input"), "Hosted get_doc glossary did not include Decision Input.");
+  assert(glossaryTerms.includes("Decision Entry"), "Hosted get_doc glossary did not include Decision Entry.");
+  assert(glossaryTerms.includes("Task Entry"), "Hosted get_doc glossary did not include Task Entry.");
+  assert(glossaryTerms.includes("Informed By"), "Hosted get_doc glossary did not include Informed By.");
+  assert(glossaryTerms.includes("Version History"), "Hosted get_doc glossary did not include Version History.");
+  for (const changeTerm of ["Change Plan", "Emergency Change", "Execution Plan", "Rollback Plan", "Veto"]) {
+    assert(glossaryTerms.includes(changeTerm), `Hosted get_doc glossary did not include ${changeTerm}.`);
+  }
+  for (const weighTerm of ["Commitment", "Condition", "Deferral", "Reservation", "Weigh"]) {
+    assert(glossaryTerms.includes(weighTerm), `Hosted get_doc glossary did not include ${weighTerm}.`);
+  }
+  for (const estimateTerm of ["Benefits", "Benefit Item", "Estimate", "Estimate Line Item", "Roll-up"]) {
+    assert(glossaryTerms.includes(estimateTerm), `Hosted get_doc glossary did not include ${estimateTerm}.`);
+  }
+  for (const registryTerm of ["Operational Registry", "Environment", "Component", "Locator", "Secret Pointer"]) {
+    assert(glossaryTerms.includes(registryTerm), `Hosted get_doc glossary did not include ${registryTerm}.`);
+  }
+  for (const removedTerm of ["Business Case", "Cost Estimate", "Benefit Estimate"]) {
+    assert(!glossaryTerms.includes(removedTerm), `Hosted get_doc glossary should not include removed term ${removedTerm}.`);
+  }
+  assert(!glossaryTerms.includes("Commit"), "Hosted get_doc glossary should not include Commit as a current phase term.");
+  assert(glossaryTerms.includes("Statement"), "Hosted get_doc glossary did not include Statement.");
+  assert(!glossaryTerms.includes("Voice"), "Hosted get_doc glossary should not include Voice.");
+  for (const roleTerm of ["Owner", "Engineer", "Tester", "Operator", "Support Agent", "End User"]) {
+    assert(glossaryTerms.includes(roleTerm), `Hosted get_doc glossary did not include role term ${roleTerm}.`);
+  }
+  for (const oldRoleTerm of ["Director", "Product Lead", "Product", "Engineering", "Coder", "QA", "Operations", "Support", "Admin", "Client/User"]) {
+    assert(!glossaryTerms.includes(oldRoleTerm), `Hosted get_doc glossary should not include old standalone role ${oldRoleTerm}.`);
+  }
+  const codexDoc = await callJsonTool("get_doc", { page: "glossary", term: "codex" });
+  assert(codexDoc.term?.definition.includes("not a role"), "Hosted get_doc glossary should describe Codex as not a role.");
+  const statementDoc = await callJsonTool("get_doc", { page: "glossary", term: "statement" });
+  assert(
+    statementDoc.term?.definition.includes("before they are interpreted or translated"),
+    "Hosted get_doc glossary should define Statement as raw uninterpreted input."
+  );
+  const reviewNoteDoc = await callJsonTool("get_doc", { page: "glossary", term: "review note" });
+  assert(
+    reviewNoteDoc.term?.definition.includes("does not block progress") &&
+      reviewNoteDoc.term?.definition.includes("require an Owner response"),
+    "Hosted get_doc glossary should describe review notes as non-blocking."
+  );
+  await expectToolError("get_doc", { page: "glossary", term: "voice" }, "Glossary term not found");
+  const riskAcceptanceDoc = await callJsonTool("get_doc", { page: "glossary", term: "risk acceptance" });
+  assert(
+    riskAcceptanceDoc.term?.definition.includes("Owner decision"),
+    "Hosted get_doc glossary should describe risk acceptance as Owner-level."
+  );
+  const proceedingPastDoc = await callJsonTool("get_doc", {
+    page: "glossary",
+    term: "proceeding past an open checkpoint"
+  });
+  assert(
+    proceedingPastDoc.term?.definition.includes("not formally accepted"),
+    "Hosted get_doc glossary should distinguish proceeding past an open checkpoint from risk acceptance."
+  );
+  const changeDoc = await callJsonTool("get_doc", { page: "glossary", term: "change" });
+  assert(
+    changeDoc.term?.definition.includes("discrete alteration") &&
+      changeDoc.term?.definition.includes("without enforcing the operation"),
+    "Hosted get_doc glossary should describe Change as a record-layer service change."
+  );
+  const decisionInputDoc = await callJsonTool("get_doc", { page: "glossary", term: "decision input" });
+  assert(
+    decisionInputDoc.term?.definition.includes("informed a decision"),
+    "Hosted get_doc glossary should define Decision Input."
+  );
+  const decisionDoc = await callJsonTool("get_doc", { page: "glossary", term: "decision" });
+  assert(
+    decisionDoc.term?.definition.includes("latest decision entry") &&
+      decisionDoc.term?.definition.includes("earlier arguments"),
+    "Hosted get_doc glossary should define Decision as latest-entry based."
+  );
+  const taskDoc = await callJsonTool("get_doc", { page: "glossary", term: "task" });
+  assert(
+    taskDoc.term?.definition.includes("latest status-change entry"),
+    "Hosted get_doc glossary should define Task as latest-status-entry based."
+  );
+  const versionHistoryDoc = await callJsonTool("get_doc", { page: "glossary", term: "version history" });
+  assert(
+    versionHistoryDoc.term?.definition.includes("Prior versions") &&
+      versionHistoryDoc.term?.definition.includes("expectation or requirement"),
+    "Hosted get_doc glossary should define Version History."
+  );
+  const commitmentDoc = await callJsonTool("get_doc", { page: "glossary", term: "commitment" });
+  assert(
+    commitmentDoc.term?.definition.includes("Owner record") &&
+      commitmentDoc.term?.definition.includes("reservations"),
+    "Hosted get_doc glossary should define Commitment."
+  );
+  const deferralDoc = await callJsonTool("get_doc", { page: "glossary", term: "deferral" });
+  assert(
+    deferralDoc.term?.definition.includes("not committing yet") &&
+      deferralDoc.term?.definition.includes("future Commitment"),
+    "Hosted get_doc glossary should define Deferral."
+  );
+  const estimateDoc = await callJsonTool("get_doc", { page: "glossary", term: "estimate" });
+  assert(
+    estimateDoc.term?.definition.includes("itemized") &&
+      estimateDoc.term?.definition.includes("cost estimate") &&
+      !estimateDoc.term?.definition.includes("benefit record"),
+    "Hosted get_doc glossary should define Estimate as an itemized cost record."
+  );
+  const estimateLineItemDoc = await callJsonTool("get_doc", { page: "glossary", term: "estimate line item" });
+  assert(
+    estimateLineItemDoc.term?.definition.includes("One cost item inside an Estimate") &&
+      !estimateLineItemDoc.term?.definition.includes("cost or benefit"),
+    "Hosted get_doc glossary should define Estimate Line Item."
+  );
+  const benefitsDoc = await callJsonTool("get_doc", { page: "glossary", term: "benefits" });
+  assert(
+    benefitsDoc.term?.definition.includes("Owner-authored benefit record") &&
+      benefitsDoc.term?.definition.includes("quantified or qualitative"),
+    "Hosted get_doc glossary should define Benefits."
+  );
+  const benefitItemDoc = await callJsonTool("get_doc", { page: "glossary", term: "benefit item" });
+  assert(
+    benefitItemDoc.term?.definition.includes("One item inside Benefits") &&
+      benefitItemDoc.term?.definition.includes("qualitative with no amount"),
+    "Hosted get_doc glossary should define Benefit Item."
+  );
+  const rollupDoc = await callJsonTool("get_doc", { page: "glossary", term: "roll-up" });
+  const rollupDefinition = rollupDoc.term?.definition.toLowerCase() ?? "";
+  assert(
+    rollupDefinition.includes("grouped totals") &&
+      rollupDefinition.includes("one-time") &&
+      rollupDefinition.includes("recurring") &&
+      rollupDefinition.includes("currencies"),
+    "Hosted get_doc glossary should define Roll-up."
+  );
+
+  const recordsDoc = await callJsonTool("get_doc", { page: "records" });
+  const recordNames = recordsDoc.groups?.flatMap((group) => group.records.map((record) => record.name)) ?? [];
+  assert(recordNames.includes("Change"), "Hosted get_doc records should include Change.");
+  assert(recordNames.includes("Environment"), "Hosted get_doc records should include Environment.");
+  assert(recordNames.includes("Component"), "Hosted get_doc records should include Component.");
+  assert(recordNames.includes("Commitment"), "Hosted get_doc records should include Commitment.");
+  assert(recordNames.includes("Deferral"), "Hosted get_doc records should include Deferral.");
+  assert(recordNames.includes("Estimate"), "Hosted get_doc records should include Estimate.");
+  assert(recordNames.includes("Benefits"), "Hosted get_doc records should include Benefits.");
+  assert(!recordNames.includes("Change Request"), "Hosted get_doc records should not include Change Request.");
+  const expectationRecord = recordsDoc.groups
+    ?.flatMap((group) => group.records)
+    .find((record) => record.name === "Expectation");
+  const requirementRecord = recordsDoc.groups
+    ?.flatMap((group) => group.records)
+    .find((record) => record.name === "Requirement");
+  assert(
+    expectationRecord?.summary?.includes("Prior versions") &&
+      requirementRecord?.summary?.includes("Prior versions"),
+    "Hosted get_doc records should describe Expectation and Requirement prior versions."
+  );
+  const decisionRecord = recordsDoc.groups
+    ?.flatMap((group) => group.records)
+    .find((record) => record.name === "Decision");
+  const taskRecord = recordsDoc.groups
+    ?.flatMap((group) => group.records)
+    .find((record) => record.name === "Task");
+  assert(
+    decisionRecord?.summary?.includes("ordered entries") &&
+      decisionRecord?.summary?.includes("records that informed it"),
+    "Hosted get_doc records should describe Decision entries and inputs."
+  );
+  assert(
+    taskRecord?.summary?.includes("latest status-change entry"),
+    "Hosted get_doc records should describe Task current status derivation."
+  );
+  smokeStep("process guide and documentation checks ok");
+
+  const expectationDoc = await callJsonTool("get_doc", { page: "glossary", term: "expectation" });
+  assert(expectationDoc.page === "glossary", "Hosted get_doc glossary term did not return the glossary page.");
+  assert(expectationDoc.term?.term === "Expectation", "Hosted get_doc glossary term did not return Expectation.");
+  assert(!Object.hasOwn(expectationDoc, "terms"), "Hosted get_doc glossary term should not return the full glossary.");
+  assert(
+    expectationDoc.surfaceFingerprint === status.server.surfaceFingerprint,
+    "Hosted get_doc glossary term surface fingerprint did not match runtime_status."
+  );
+  await expectToolError("get_doc", { page: "glossary", term: "not-a-term" }, "Glossary term not found");
+
+  const statement = await callJsonTool("create_statement", {
+    title: `DX Complete hosted MCP smoke statement ${runId}`,
+    statement: "The hosted MCP smoke run can track a first-class statement.",
+    source: "hosted smoke"
+  });
+  createdStatementId = statement._id;
+  assert(statement.recordType === "statements", "Hosted create_statement created the wrong record type.");
+  assert(statement.workspaceId === workspaceConfig.workspaceId, "Hosted Statement was not workspace-scoped.");
+  assert(statement.fields.statement?.includes("first-class statement"), "Hosted Statement text was not stored.");
+
+  const updatedStatement = await callJsonTool("update_statement", {
+    id: statement._id,
+    source: "updated hosted smoke",
+    revisionNote: "Smoke test statement source revision."
+  });
+  assert(updatedStatement.fields.source === "updated hosted smoke", "Hosted update_statement did not update source.");
+  assert(updatedStatement.fields.versionHistory?.length === 1, "Hosted update_statement did not append version history.");
+
+  const expectation = await callJsonTool("create_expectation", {
+    title: `DX Complete hosted MCP smoke expectation ${runId}`,
+    statementId: statement._id,
+    statement: "The hosted MCP smoke run can track a first-class expectation.",
+    successRecognition: "The expectation can be listed, updated, linked to a requirement, and archived."
+  });
+  createdExpectationId = expectation._id;
+  assert(expectation.recordType === "expectations", "Hosted create_expectation created the wrong record type.");
+  assert(expectation.workspaceId === workspaceConfig.workspaceId, "Hosted expectation was not workspace-scoped.");
+  assert(expectation.fields.statement?.includes("first-class expectation"), "Hosted expectation statement was not stored.");
+  assert(expectation.fields.approvalState === "draft", "Hosted expectation did not default/store approval state.");
+
+  const notApprovedExpectation = await callJsonTool("update_expectation", {
+    id: expectation._id,
+    approvalState: "not_approved",
+    revisionNote: "Smoke test expectation approval-state revision."
+  });
+  assert(
+    notApprovedExpectation.fields.approvalState === "not_approved",
+    "Hosted update_expectation did not accept not_approved approval state."
+  );
+  const firstExpectationVersionHistory = notApprovedExpectation.fields.versionHistory ?? [];
+  assert(firstExpectationVersionHistory.length === 1, "Hosted update_expectation did not append version history.");
+  const firstExpectationVersion = firstExpectationVersionHistory[0];
+  assert(
+    firstExpectationVersion.fromVersion === 1 &&
+      firstExpectationVersion.toVersion === 2 &&
+      firstExpectationVersion.changedFields.includes("fields.approvalState") &&
+      firstExpectationVersion.revisionNote === "Smoke test expectation approval-state revision.",
+    "Hosted expectation version history did not record version metadata."
+  );
+  assert(
+    firstExpectationVersion.previousSnapshot.fields.approvalState === "draft" &&
+      firstExpectationVersion.nextSnapshot.fields.approvalState === "not_approved",
+    "Hosted expectation version history did not preserve before/after snapshots."
+  );
+  assert(
+    !Object.hasOwn(firstExpectationVersion.previousSnapshot.fields, "versionHistory") &&
+      !Object.hasOwn(firstExpectationVersion.nextSnapshot.fields, "versionHistory") &&
+      !Object.hasOwn(firstExpectationVersion.previousSnapshot.fields, "reviewNotes") &&
+      !Object.hasOwn(firstExpectationVersion.nextSnapshot.fields, "reviewNotes"),
+    "Hosted expectation version snapshots should exclude versionHistory and reviewNotes."
+  );
+
+  const approvedAt = new Date().toISOString();
+  const updatedExpectation = await callJsonTool("update_expectation", {
+    id: expectation._id,
+    approvalState: "approved",
+    approvedBy: actor.actorId,
+    approvedAt,
+    source: "hosted-smoke",
+    revisionNote: "Smoke test expectation approval revision."
+  });
+  assert(updatedExpectation.fields.approvalState === "approved", "Hosted update_expectation did not update approval state.");
+  assert(updatedExpectation.fields.approvedBy === actor.actorId, "Hosted update_expectation did not update approvedBy.");
+  assert(
+    updatedExpectation.fields.versionHistory?.length === 2,
+    "Hosted update_expectation did not append a second version history entry."
+  );
+
+  const noOpExpectation = await callJsonTool("update_expectation", {
+    id: expectation._id,
+    approvalState: "approved",
+    approvedBy: actor.actorId,
+    approvedAt,
+    source: "hosted-smoke",
+    revisionNote: "No-op expectation update should not append history."
+  });
+  assert(
+    noOpExpectation.fields.versionHistory?.length === 2,
+    "Hosted no-op update_expectation should not append version history."
+  );
+
+  const listedExpectations = await callJsonTool("list_records", { recordType: "expectations", limit: 25 });
+  assert(
+    listedExpectations.some((record) => record._id === expectation._id),
+    "Hosted list_records did not include the created expectation."
+  );
+
+  const fetchedExpectation = await callJsonTool("get_record", {
+    recordType: "expectations",
+    id: expectation._id
+  });
+  assert(fetchedExpectation._id === expectation._id, "Hosted get_record did not fetch the created expectation.");
+
+  const expectationWithReviewNote = await callJsonTool("append_review_note", {
+    recordType: "expectations",
+    id: expectation._id,
+    body: "Engineer review note for expectation.",
+    important: true
+  });
+  const expectationReviewNotes = expectationWithReviewNote.fields.reviewNotes ?? [];
+  assert(expectationReviewNotes.length === 1, "Hosted append_review_note did not append to expectation.");
+  assert(expectationReviewNotes[0].body === "Engineer review note for expectation.", "Hosted expectation review note body was not stored.");
+  assert(expectationReviewNotes[0].important === true, "Hosted expectation review note important flag was not stored.");
+  assert(expectationReviewNotes[0].createdBy === actor.actorId, "Hosted expectation review note was not attributed to the token actor.");
+  assert(
+    expectationWithReviewNote.fields.versionHistory?.length === 2,
+    "Hosted append_review_note should not append expectation version history."
+  );
+
+  await expectToolError(
+    "create_expectation",
+    {
+      title: `DX Complete hosted MCP bad expectation ${runId}`,
+      statement: "This should fail.",
+      fields: { initiativeId: "not-allowed-here" }
+    },
+    "removed Initiative layer"
+  );
+
+  await expectToolError(
+    "create_expectation",
+    {
+      title: `DX Complete hosted MCP accepted-risk expectation ${runId}`,
+      statement: "This should fail.",
+      approvalState: "accepted_risk"
+    },
+    "not_approved"
+  );
+
+  await expectToolError(
+    "update_expectation",
+    {
+      id: expectation._id,
+      approvalState: "accepted_risk"
+    },
+    "not_approved"
+  );
+
+  await expectToolError(
+    "create_expectation",
+    {
+      title: `DX Complete hosted MCP old-field expectation ${runId}`,
+      statement: "This should fail.",
+      fields: { confirmationState: "approved" }
+    },
+    "confirmationState is not part of the current Expectation model"
+  );
+
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "expectations",
+      title: `DX Complete hosted MCP direct review notes expectation ${runId}`,
+      fields: { reviewNotes: [] }
+    },
+    "append_review_note"
+  );
+
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "expectations",
+      title: `DX Complete hosted MCP direct version history expectation ${runId}`,
+      fields: { versionHistory: [] }
+    },
+    "versionHistory"
+  );
+
+  await expectToolError(
+    "update_expectation",
+    {
+      id: expectation._id,
+      fields: { reviewNotes: [] }
+    },
+    "append_review_note"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "expectations",
+      id: expectation._id,
+      fields: { statement: "Generic update should not change managed expectation fields." }
+    },
+    "update_expectation"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "expectations",
+      id: expectation._id,
+      fields: { versionHistory: [] }
+    },
+    "versionHistory"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "expectations",
+      id: expectation._id,
+      unsetFields: ["reviewNotes"]
+    },
+    "append_review_note"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "expectations",
+      id: expectation._id,
+      unsetFields: ["versionHistory"]
+    },
+    "versionHistory"
+  );
+
+  await expectToolError(
+    "create_requirement",
+    {
+      title: `DX Complete hosted MCP bad requirement ${runId}`,
+      statement: "This should fail.",
+      fields: { expectationId: expectation._id }
+    },
+    "expectationId is a relationship input"
+  );
+
+  const requirement = await callJsonTool("create_requirement", {
+    title: `DX Complete hosted MCP smoke requirement ${runId}`,
+    statement: "A requirement can satisfy a first-class expectation.",
+    expectationId: expectation._id,
+    acceptanceCriteria: ["The requirement links to the expectation with relationship satisfies."]
+  });
+  createdRequirementId = requirement._id;
+  assert(requirement.recordType === "requirements", "Hosted create_requirement created the wrong record type.");
+  assert(
+    requirement.links.some(
+      (link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "satisfies"
+    ),
+    "Hosted create_requirement did not create a satisfies link to the expectation."
+  );
+
+  const updatedRequirement = await callJsonTool("update_requirement", {
+    id: requirement._id,
+    priority: "high",
+    status: "ready",
+    acceptanceCriteria: [
+      "The requirement links to the expectation with relationship satisfies.",
+      "Requirement version history records before and after snapshots."
+    ],
+    revisionNote: "Smoke test requirement readiness revision."
+  });
+  const requirementVersionHistory = updatedRequirement.fields.versionHistory ?? [];
+  assert(requirementVersionHistory.length === 1, "Hosted update_requirement did not append version history.");
+  const firstRequirementVersion = requirementVersionHistory[0];
+  assert(
+    firstRequirementVersion.fromVersion === 1 &&
+      firstRequirementVersion.toVersion === 2 &&
+      firstRequirementVersion.changedFields.includes("fields.status") &&
+      firstRequirementVersion.changedFields.includes("fields.priority") &&
+      firstRequirementVersion.revisionNote === "Smoke test requirement readiness revision.",
+    "Hosted requirement version history did not record version metadata."
+  );
+  assert(
+    firstRequirementVersion.previousSnapshot.fields.status === "draft" &&
+      firstRequirementVersion.nextSnapshot.fields.status === "ready",
+    "Hosted requirement version history did not preserve before/after snapshots."
+  );
+  assert(
+    !Object.hasOwn(firstRequirementVersion.previousSnapshot.fields, "versionHistory") &&
+      !Object.hasOwn(firstRequirementVersion.nextSnapshot.fields, "versionHistory") &&
+      !Object.hasOwn(firstRequirementVersion.previousSnapshot.fields, "reviewNotes") &&
+      !Object.hasOwn(firstRequirementVersion.nextSnapshot.fields, "reviewNotes"),
+    "Hosted requirement version snapshots should exclude versionHistory and reviewNotes."
+  );
+
+  const noOpRequirement = await callJsonTool("update_requirement", {
+    id: requirement._id,
+    priority: "high",
+    status: "ready",
+    acceptanceCriteria: [
+      "The requirement links to the expectation with relationship satisfies.",
+      "Requirement version history records before and after snapshots."
+    ],
+    revisionNote: "No-op requirement update should not append history."
+  });
+  assert(
+    noOpRequirement.fields.versionHistory?.length === 1,
+    "Hosted no-op update_requirement should not append version history."
+  );
+
+  const requirementWithReviewNote = await callJsonTool("append_review_note", {
+    recordType: "requirements",
+    id: requirement._id,
+    body: "Engineer review note for requirement."
+  });
+  const requirementReviewNotes = requirementWithReviewNote.fields.reviewNotes ?? [];
+  assert(requirementReviewNotes.length === 1, "Hosted append_review_note did not append to requirement.");
+  assert(requirementReviewNotes[0].important === undefined, "Hosted requirement review note should omit important when false.");
+  assert(requirementReviewNotes[0].body === "Engineer review note for requirement.", "Hosted requirement review note body was not stored.");
+  assert(
+    requirementWithReviewNote.fields.versionHistory?.length === 1,
+    "Hosted append_review_note should not append requirement version history."
+  );
+
+  await expectToolError(
+    "create_requirement",
+    {
+      title: `DX Complete hosted MCP direct review notes requirement ${runId}`,
+      statement: "This should fail.",
+      fields: { reviewNotes: [] }
+    },
+    "append_review_note"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "requirements",
+      id: requirement._id,
+      fields: { acceptanceCriteria: ["Generic update should not change managed requirement fields."] }
+    },
+    "update_requirement"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "requirements",
+      id: requirement._id,
+      unsetFields: ["versionHistory"]
+    },
+    "versionHistory"
+  );
+
+  const requirementLinks = await callJsonTool("list_linked_records", {
+    recordType: "requirements",
+    id: requirement._id,
+    relationship: "satisfies"
+  });
+  assert(
+    requirementLinks.outbound.some((entry) => entry.record._id === expectation._id),
+    "Hosted list_linked_records did not return the linked expectation."
+  );
+  const expectationStatementLinks = await callJsonTool("list_linked_records", {
+    recordType: "expectations",
+    id: expectation._id,
+    relationship: "derives_from"
+  });
+  assert(
+    expectationStatementLinks.outbound.some((entry) => entry.record._id === statement._id),
+    "Hosted list_linked_records did not return the linked Statement."
+  );
+  smokeStep("expectation and requirement checks ok");
+
+  await expectToolError(
+    "create_estimate",
+    {
+      title: `DX Complete hosted MCP targetless estimate ${runId}`,
+      lineItems: [
+        {
+          label: "Targetless line item",
+          timing: "one_time",
+          currency: "USD",
+          amount: { kind: "single", value: 100 }
+        }
+      ]
+    },
+    "requires at least one requirementId or expectationId"
+  );
+
+  await expectToolError(
+    "create_estimate",
+    {
+      title: `DX Complete hosted MCP direction estimate ${runId}`,
+      requirementIds: [requirement._id],
+      lineItems: [
+        {
+          label: "Direction should be rejected",
+          direction: "cost",
+          timing: "one_time",
+          currency: "USD",
+          amount: { kind: "single", value: 100 }
+        }
+      ]
+    },
+    "direction"
+  );
+
+  await expectToolError(
+    "create_estimate",
+    {
+      title: `DX Complete hosted MCP recurring estimate without period ${runId}`,
+      requirementIds: [requirement._id],
+      lineItems: [
+        {
+          label: "Missing period",
+          timing: "recurring",
+          currency: "USD",
+          amount: { kind: "single", value: 100 }
+        }
+      ]
+    },
+    "requires period"
+  );
+
+  await expectToolError(
+    "create_estimate",
+    {
+      title: `DX Complete hosted MCP invalid range estimate ${runId}`,
+      requirementIds: [requirement._id],
+      lineItems: [
+        {
+          label: "Invalid range",
+          timing: "one_time",
+          currency: "USD",
+          amount: { kind: "range", min: 300, expected: 200, max: 100 }
+        }
+      ]
+    },
+    "min <= expected <= max"
+  );
+
+  await expectToolError(
+    "create_estimate",
+    {
+      title: `DX Complete hosted MCP direct rollup estimate ${runId}`,
+      requirementIds: [requirement._id],
+      lineItems: [
+        {
+          label: "Direct rollup guard",
+          timing: "one_time",
+          currency: "USD",
+          amount: { kind: "single", value: 100 }
+        }
+      ],
+      fields: { rollup: {} }
+    },
+    "rollup"
+  );
+
+  const estimate = await callJsonTool("create_estimate", {
+    title: `DX Complete hosted MCP smoke estimate ${runId}`,
+    summary: "Estimate used by the hosted MCP Weigh smoke test.",
+    requirementIds: [requirement._id],
+    expectationIds: [expectation._id],
+    lineItems: [
+      {
+        label: "Build work",
+        timing: "one_time",
+        currency: "USD",
+        amount: { kind: "range", min: 1000, expected: 1500, max: 2000 }
+      },
+      {
+        label: "Run support",
+        timing: "recurring",
+        period: "monthly",
+        currency: "USD",
+        amount: { kind: "single", value: 100 }
+      }
+    ]
+  });
+  createdEstimateId = estimate._id;
+  assert(estimate.recordType === "estimates", "Hosted create_estimate created the wrong record type.");
+  assert(estimate.workspaceId === workspaceConfig.workspaceId, "Hosted Estimate was not workspace-scoped.");
+  assert(Array.isArray(estimate.fields.lineItems) && estimate.fields.lineItems.length === 2, "Hosted Estimate did not store line items.");
+  assert(
+    estimate.fields.lineItems.every((lineItem) => typeof lineItem.id === "string" && lineItem.id.length > 0),
+    "Hosted Estimate did not generate line item IDs."
+  );
+  assert(
+    estimate.fields.lineItems.every((lineItem) => lineItem.direction === undefined),
+    "Hosted Estimate should not store direction on line items."
+  );
+  assert(
+    estimate.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "estimates") &&
+      estimate.links.some((link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "estimates"),
+    "Hosted create_estimate did not create estimates links to scoped records."
+  );
+  assertEstimateAmount(
+    estimate.fields.rollup?.currencies?.USD?.one_time,
+    { min: 1000, expected: 1500, max: 2000 },
+    "Hosted Estimate roll-up did not total one-time USD costs."
+  );
+  assertEstimateAmount(
+    estimate.fields.rollup?.currencies?.USD?.recurring?.monthly,
+    { min: 100, expected: 100, max: 100 },
+    "Hosted Estimate roll-up did not total recurring monthly USD costs."
+  );
+  assert(
+    estimate.fields.rollup?.currencies?.USD?.cost === undefined &&
+      estimate.fields.rollup?.currencies?.USD?.benefit === undefined,
+    "Hosted Estimate roll-up should be cost-only, not direction-split."
+  );
+
+  const revisedEstimateLineItems = estimate.fields.lineItems.map((lineItem) =>
+    lineItem.label === "Build work"
+      ? { ...lineItem, amount: { kind: "range", min: 1200, expected: 1700, max: 2200 } }
+      : lineItem
+  );
+  const updatedEstimate = await callJsonTool("update_estimate", {
+    id: estimate._id,
+    lineItems: revisedEstimateLineItems,
+    revisionNote: "Smoke test estimate line-item revision."
+  });
+  assertEstimateAmount(
+    updatedEstimate.fields.rollup?.currencies?.USD?.one_time,
+    { min: 1200, expected: 1700, max: 2200 },
+    "Hosted update_estimate did not recompute one-time USD costs."
+  );
+  const estimateVersionHistory = updatedEstimate.fields.versionHistory ?? [];
+  assert(estimateVersionHistory.length === 1, "Hosted update_estimate did not append version history.");
+  assert(
+    estimateVersionHistory[0].changedFields.includes("fields.lineItems") &&
+      estimateVersionHistory[0].changedFields.includes("fields.rollup") &&
+      estimateVersionHistory[0].revisionNote === "Smoke test estimate line-item revision.",
+    "Hosted Estimate version history did not record changed fields and revision note."
+  );
+  assert(
+    estimateVersionHistory[0].previousSnapshot.fields.rollup?.currencies?.USD?.one_time?.expected === 1500 &&
+      estimateVersionHistory[0].nextSnapshot.fields.rollup?.currencies?.USD?.one_time?.expected === 1700,
+    "Hosted Estimate version history did not preserve roll-up before/after snapshots."
+  );
+
+  const noOpEstimate = await callJsonTool("update_estimate", {
+    id: estimate._id,
+    lineItems: updatedEstimate.fields.lineItems,
+    revisionNote: "No-op estimate update should not append history."
+  });
+  assert(
+    noOpEstimate.fields.versionHistory?.length === 1,
+    "Hosted no-op update_estimate should not append version history."
+  );
+
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "estimates",
+      title: `DX Complete hosted MCP direct line items estimate ${runId}`,
+      fields: { lineItems: [] }
+    },
+    "create_estimate or update_estimate"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "estimates",
+      id: estimate._id,
+      fields: { rollup: {} }
+    },
+    "update_estimate"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "estimates",
+      id: estimate._id,
+      unsetFields: ["versionHistory"]
+    },
+    "versionHistory"
+  );
+
+  await expectToolError(
+    "create_benefits",
+    {
+      title: `DX Complete hosted MCP targetless benefits ${runId}`,
+      benefitItems: [{ label: "Targetless benefit" }]
+    },
+    "requires at least one requirementId or expectationId"
+  );
+
+  await expectToolError(
+    "create_benefits",
+    {
+      title: `DX Complete hosted MCP qualitative benefits with amount fields ${runId}`,
+      requirementIds: [requirement._id],
+      benefitItems: [{ label: "Qualitative with currency", currency: "USD" }]
+    },
+    "qualitative"
+  );
+
+  await expectToolError(
+    "create_benefits",
+    {
+      title: `DX Complete hosted MCP recurring benefits without period ${runId}`,
+      requirementIds: [requirement._id],
+      benefitItems: [
+        {
+          label: "Missing period benefit",
+          timing: "recurring",
+          currency: "USD",
+          amount: { kind: "single", value: 100 }
+        }
+      ]
+    },
+    "requires period"
+  );
+
+  const benefits = await callJsonTool("create_benefits", {
+    title: `DX Complete hosted MCP smoke benefits ${runId}`,
+    summary: "Benefits used by the hosted MCP Weigh smoke test.",
+    requirementIds: [requirement._id],
+    expectationIds: [expectation._id],
+    benefitItems: [
+      {
+        label: "User time saved",
+        timing: "recurring",
+        period: "monthly",
+        currency: "USD",
+        amount: { kind: "range", min: 200, expected: 300, max: 400 }
+      },
+      {
+        label: "Clearer decisions"
+      }
+    ]
+  });
+  createdBenefitsId = benefits._id;
+  assert(benefits.recordType === "benefits", "Hosted create_benefits created the wrong record type.");
+  assert(benefits.workspaceId === workspaceConfig.workspaceId, "Hosted Benefits was not workspace-scoped.");
+  assert(Array.isArray(benefits.fields.benefitItems) && benefits.fields.benefitItems.length === 2, "Hosted Benefits did not store benefit items.");
+  assert(
+    benefits.fields.benefitItems.every((benefitItem) => typeof benefitItem.id === "string" && benefitItem.id.length > 0),
+    "Hosted Benefits did not generate benefit item IDs."
+  );
+  assert(
+    benefits.fields.benefitItems.some((benefitItem) => benefitItem.label === "Clearer decisions" && benefitItem.amount === undefined),
+    "Hosted Benefits did not preserve qualitative benefit items."
+  );
+  assert(
+    benefits.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "benefits") &&
+      benefits.links.some((link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "benefits"),
+    "Hosted create_benefits did not create benefits links to scoped records."
+  );
+  assertEstimateAmount(
+    benefits.fields.rollup?.currencies?.USD?.recurring?.monthly,
+    { min: 200, expected: 300, max: 400 },
+    "Hosted Benefits roll-up did not total quantified recurring monthly USD benefits."
+  );
+  assert(
+    !JSON.stringify(benefits.fields.rollup ?? {}).includes("Clearer decisions"),
+    "Hosted Benefits roll-up should not sum qualitative benefit items."
+  );
+
+  const revisedBenefitItems = benefits.fields.benefitItems.map((benefitItem) =>
+    benefitItem.label === "User time saved"
+      ? { ...benefitItem, amount: { kind: "range", min: 250, expected: 350, max: 450 } }
+      : benefitItem
+  );
+  const updatedBenefits = await callJsonTool("update_benefits", {
+    id: benefits._id,
+    benefitItems: revisedBenefitItems,
+    revisionNote: "Smoke test benefits item revision."
+  });
+  assertEstimateAmount(
+    updatedBenefits.fields.rollup?.currencies?.USD?.recurring?.monthly,
+    { min: 250, expected: 350, max: 450 },
+    "Hosted update_benefits did not recompute quantified benefits."
+  );
+  const benefitsVersionHistory = updatedBenefits.fields.versionHistory ?? [];
+  assert(benefitsVersionHistory.length === 1, "Hosted update_benefits did not append version history.");
+  assert(
+    benefitsVersionHistory[0].changedFields.includes("fields.benefitItems") &&
+      benefitsVersionHistory[0].changedFields.includes("fields.rollup") &&
+      benefitsVersionHistory[0].revisionNote === "Smoke test benefits item revision.",
+    "Hosted Benefits version history did not record changed fields and revision note."
+  );
+  const noOpBenefits = await callJsonTool("update_benefits", {
+    id: benefits._id,
+    benefitItems: updatedBenefits.fields.benefitItems,
+    revisionNote: "No-op benefits update should not append history."
+  });
+  assert(
+    noOpBenefits.fields.versionHistory?.length === 1,
+    "Hosted no-op update_benefits should not append version history."
+  );
+
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "benefits",
+      title: `DX Complete hosted MCP direct benefit items ${runId}`,
+      fields: { benefitItems: [] }
+    },
+    "create_benefits or update_benefits"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "benefits",
+      id: benefits._id,
+      fields: { rollup: {} }
+    },
+    "update_benefits"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "benefits",
+      id: benefits._id,
+      unsetFields: ["versionHistory"]
+    },
+    "versionHistory"
+  );
+  smokeStep("estimate and benefits checks ok");
+
+  const deferral = await callJsonTool("create_deferral", {
+    title: `DX Complete hosted MCP smoke deferral ${runId}`,
+    reason: "The smoke run needs an explicit unmet condition before committing.",
+    conditions: ["Confirm the smoke condition can be addressed."],
+    requirementIds: [requirement._id],
+    expectationIds: [expectation._id]
+  });
+  createdDeferralId = deferral._id;
+  assert(deferral.recordType === "deferrals", "Hosted create_deferral created the wrong record type.");
+  assert(deferral.workspaceId === workspaceConfig.workspaceId, "Hosted Deferral was not workspace-scoped.");
+  assert(deferral.fields.status === "open", "Hosted Deferral did not default to open status.");
+  assert(deferral.fields.reason?.includes("unmet condition"), "Hosted Deferral did not store reason.");
+  assert(
+    Array.isArray(deferral.fields.conditions) &&
+      deferral.fields.conditions.length === 1 &&
+      deferral.fields.conditions[0].state === "open",
+    "Hosted Deferral did not create open conditions."
+  );
+  assert(
+    deferral.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "defers") &&
+      deferral.links.some((link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "defers"),
+    "Hosted create_deferral did not create defers links."
+  );
+  const conditionId = deferral.fields.conditions[0].id;
+
+  const deferralWithAddressedCondition = await callJsonTool("append_deferral_event", {
+    deferralId: deferral._id,
+    eventType: "condition_addressed",
+    conditionId,
+    summary: "Smoke condition addressed."
+  });
+  assert(
+    deferralWithAddressedCondition.fields.conditions[0].state === "addressed" &&
+      deferralWithAddressedCondition.fields.conditionEvents?.at(-1)?.eventType === "condition_addressed",
+    "Hosted append_deferral_event did not address the condition and append history."
+  );
+
+  const deferralWithReopenedCondition = await callJsonTool("append_deferral_event", {
+    deferralId: deferral._id,
+    eventType: "condition_reopened",
+    conditionId,
+    summary: "Smoke condition reopened."
+  });
+  assert(
+    deferralWithReopenedCondition.fields.conditions[0].state === "open" &&
+      deferralWithReopenedCondition.fields.conditionEvents?.at(-1)?.eventType === "condition_reopened",
+    "Hosted append_deferral_event did not reopen the condition and append history."
+  );
+  smokeStep("deferral condition checks ok");
+
+  const deferralWithConditionNote = await callJsonTool("append_deferral_event", {
+    deferralId: deferral._id,
+    eventType: "condition_note_added",
+    conditionId,
+    note: "Smoke condition note."
+  });
+  assert(
+    deferralWithConditionNote.fields.conditionEvents?.at(-1)?.note === "Smoke condition note.",
+    "Hosted append_deferral_event did not append the condition note."
+  );
+
+  await expectToolError(
+    "append_deferral_event",
+    {
+      deferralId: deferral._id,
+      eventType: "condition_addressed",
+      summary: "Missing conditionId should fail."
+    },
+    "condition_addressed requires conditionId"
+  );
+
+  const commitment = await callJsonTool("create_commitment", {
+    title: `DX Complete hosted MCP smoke commitment ${runId}`,
+    commitmentStatement: "The smoke run commits the requirement into Build.",
+    requirementIds: [requirement._id],
+    expectationIds: [expectation._id],
+    reservationNotes: ["Smoke reservation kept visible."],
+    deferralId: deferral._id
+  });
+  createdCommitmentId = commitment._id;
+  assert(commitment.recordType === "commitments", "Hosted create_commitment created the wrong record type.");
+  assert(commitment.workspaceId === workspaceConfig.workspaceId, "Hosted Commitment was not workspace-scoped.");
+  assert(commitment.fields.commitmentStatement?.includes("commits the requirement"), "Hosted Commitment did not store statement.");
+  assert(commitment.fields.reservations?.[0]?.note === "Smoke reservation kept visible.", "Hosted Commitment did not store reservations.");
+  assert(
+    commitment.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "commits") &&
+      commitment.links.some((link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "commits") &&
+      commitment.links.some((link) => link.toType === "deferrals" && link.toId === deferral._id && link.relationship === "resolves_deferral"),
+    "Hosted create_commitment did not create expected links."
+  );
+
+  const commitmentWithEstimateInput = await callJsonTool("link_records", {
+    fromType: "commitments",
+    fromId: commitment._id,
+    toType: "estimates",
+    toId: estimate._id,
+    relationship: "informed_by"
+  });
+  assert(
+    commitmentWithEstimateInput.links.some(
+      (link) => link.toType === "estimates" && link.toId === estimate._id && link.relationship === "informed_by"
+    ),
+    "Hosted link_records did not link Commitment to Estimate as informed_by."
+  );
+
+  const commitmentWithBenefitsInput = await callJsonTool("link_records", {
+    fromType: "commitments",
+    fromId: commitment._id,
+    toType: "benefits",
+    toId: benefits._id,
+    relationship: "informed_by"
+  });
+  assert(
+    commitmentWithBenefitsInput.links.some(
+      (link) => link.toType === "benefits" && link.toId === benefits._id && link.relationship === "informed_by"
+    ),
+    "Hosted link_records did not link Commitment to Benefits as informed_by."
+  );
+  smokeStep("commitment checks ok");
+
+  const resolvedDeferral = await callJsonTool("append_deferral_event", {
+    deferralId: deferral._id,
+    eventType: "deferral_resolved",
+    commitmentId: commitment._id,
+    summary: "Smoke deferral resolved into commitment."
+  });
+  assert(
+    resolvedDeferral.fields.status === "resolved" &&
+      resolvedDeferral.fields.conditionEvents?.at(-1)?.commitmentId === commitment._id,
+    "Hosted append_deferral_event did not resolve the Deferral."
+  );
+  const commitmentDeferralLinks = await callJsonTool("list_linked_records", {
+    recordType: "commitments",
+    id: commitment._id,
+    relationship: "resolves_deferral"
+  });
+  assert(
+    commitmentDeferralLinks.outbound.some((entry) => entry.record._id === deferral._id),
+    "Hosted Deferral resolution did not link Commitment back to Deferral."
+  );
+
+  await expectToolError(
+    "create_commitment",
+    {
+      title: `DX Complete hosted MCP targetless commitment ${runId}`,
+      commitmentStatement: "This should fail."
+    },
+    "requires at least one requirementId or expectationId"
+  );
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "commitments",
+      title: `DX Complete hosted MCP direct commitment ${runId}`,
+      fields: { commitmentStatement: "This should fail." }
+    },
+    "create_commitment"
+  );
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "deferrals",
+      title: `DX Complete hosted MCP direct deferral ${runId}`,
+      fields: { conditions: [] }
+    },
+    "create_deferral"
+  );
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "deferrals",
+      id: deferral._id,
+      unsetFields: ["conditionEvents"]
+    },
+    "append_deferral_event"
+  );
+
+  const change = await callJsonTool("create_change", {
+    title: `DX Complete hosted MCP smoke change ${runId}`,
+    summary: "Change used by the hosted MCP smoke test.",
+    changePlan: "Record a harmless smoke-test service change.",
+    executionSteps: ["Create the Change record.", "Append the smoke-test events."],
+    rollbackPlan: "Archive the smoke-test records during cleanup.",
+    riskImpact: "No service impact; test data only.",
+    plannedFor: new Date().toISOString(),
+    requirementId: requirement._id
+  });
+  createdChangeId = change._id;
+  assert(change.recordType === "changes", "Hosted create_change created the wrong record type.");
+  assert(change.workspaceId === workspaceConfig.workspaceId, "Hosted Change was not workspace-scoped.");
+  assert(change.fields.changePlan === "Record a harmless smoke-test service change.", "Hosted Change did not store changePlan.");
+  assert(Array.isArray(change.fields.executionSteps) && change.fields.executionSteps.length === 2, "Hosted Change did not store executionSteps.");
+  assert(change.fields.rollbackPlan?.includes("Archive"), "Hosted Change did not store rollbackPlan.");
+  assert(change.fields.riskImpact?.includes("No service impact"), "Hosted Change did not store riskImpact.");
+  assert(
+    change.links.some((link) => link.toType === "requirements" && link.toId === requirement._id && link.relationship === "for_requirement"),
+    "Hosted create_change did not link to the requirement."
+  );
+
+  const changeWithNotice = await callJsonTool("append_change_event", {
+    changeId: change._id,
+    eventType: "notice_given",
+    notice: "Smoke test notice.",
+    noticeTo: ["Operator", "Engineer"],
+    effectiveAt: new Date().toISOString()
+  });
+  const noticeEvent = changeWithNotice.fields.events?.at(-1);
+  assert(noticeEvent?.eventType === "notice_given", "Hosted append_change_event did not append notice event.");
+  assert(noticeEvent?.createdBy === actor.actorId, "Hosted Change event was not attributed to the token actor.");
+  assert(noticeEvent?.notice === "Smoke test notice.", "Hosted Change notice event content was not stored.");
+
+  const changeWithVeto = await callJsonTool("append_change_event", {
+    changeId: change._id,
+    eventType: "veto_recorded",
+    vetoByRole: "Engineer",
+    reason: "Smoke test veto."
+  });
+  assert(
+    changeWithVeto.fields.events?.at(-1)?.vetoByRole === "Engineer",
+    "Hosted Change veto event did not store the veto role."
+  );
+
+  await expectToolError(
+    "append_change_event",
+    {
+      changeId: change._id,
+      eventType: "emergency_declared",
+      importance: "Smoke test importance without immediacy."
+    },
+    "emergency_declared requires immediacy"
+  );
+
+  await expectToolError(
+    "append_change_event",
+    {
+      changeId: change._id,
+      eventType: "veto_recorded",
+      vetoByRole: "Operator",
+      reason: "This should fail."
+    },
+    "Invalid option"
+  );
+
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "changes",
+      title: `DX Complete hosted MCP direct events change ${runId}`,
+      fields: { events: [] }
+    },
+    "append_change_event"
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "changes",
+      id: change._id,
+      unsetFields: ["events"]
+    },
+    "append_change_event"
+  );
+
+  const changedLinks = await callJsonTool("list_linked_records", {
+    recordType: "changes",
+    id: change._id,
+    relationship: "for_requirement"
+  });
+  assert(
+    changedLinks.outbound.some((entry) => entry.record._id === requirement._id),
+    "Hosted list_linked_records did not return the linked requirement for Change."
+  );
+
+  const referencedRequirement = await callJsonTool("link_records", {
+    fromType: "requirements",
+    fromId: requirement._id,
+    toType: "expectations",
+    toId: expectation._id,
+    relationship: "references"
+  });
+  assert(
+    referencedRequirement.links.some(
+      (link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "references"
+    ),
+    "Hosted link_records did not create a removable references link."
+  );
+  const unlinkedRequirement = await callJsonTool("unlink_records", {
+    fromType: "requirements",
+    fromId: requirement._id,
+    toType: "expectations",
+    toId: expectation._id,
+    relationship: "references"
+  });
+  assert(
+    !unlinkedRequirement.links.some(
+      (link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "references"
+    ) &&
+      unlinkedRequirement.links.some(
+        (link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "satisfies"
+      ),
+    "Hosted unlink_records did not remove only the selected relationship."
+  );
+  const idempotentRequirementUnlink = await callJsonTool("unlink_records", {
+    fromType: "requirements",
+    fromId: requirement._id,
+    toType: "expectations",
+    toId: expectation._id,
+    relationship: "references"
+  });
+  assert(
+    idempotentRequirementUnlink.links.length === unlinkedRequirement.links.length,
+    "Hosted unlink_records should be idempotent when a link is already absent."
+  );
+
+  await expectToolError(
+    "create_decision",
+    {
+      title: `DX Complete hosted MCP direct decision inputs ${runId}`,
+      matter: "Should direct decision inputs be accepted?",
+      fields: { informedBy: [expectation._id] }
+    },
+    "link_decision_input"
+  );
+  await expectToolError(
+    "create_record",
+    {
+      recordType: "decisions",
+      title: `DX Complete hosted MCP direct decision entries ${runId}`,
+      fields: { entries: [] }
+    },
+    "append_decision_entry"
+  );
+
+  const decision = await callJsonTool("create_decision", {
+    title: `DX Complete hosted MCP smoke decision ${runId}`,
+    matter: "Should the hosted smoke test link decision inputs?",
+    initialEntries: [
+      {
+        entryType: "argument",
+        body: "Expectation inputs show the desired outcome."
+      },
+      {
+        entryType: "argument",
+        body: "Change inputs show run-side control evidence."
+      }
+    ],
+    initialDecision: {
+      body: "Link decision inputs before archiving smoke records.",
+      decidedBy: "Owner",
+      rationale: "The smoke run needs to prove outbound and inbound informed_by traversal."
+    }
+  });
+  createdDecisionId = decision._id;
+  assert(decision.recordType === "decisions", "Hosted create_decision created the wrong record type.");
+  assert(
+    decision.fields.currentDecision?.body === "Link decision inputs before archiving smoke records." &&
+      decision.fields.entries?.length === 3,
+    "Hosted create_decision did not seed ledger entries and current decision."
+  );
+
+  await expectToolError(
+    "append_decision_entry",
+    {
+      decisionId: decision._id,
+      entryType: "argument",
+      body: "Invalid argument entry.",
+      rationale: "Arguments cannot carry decision-only rationale."
+    },
+    "rationale"
+  );
+
+  const supersededDecision = await callJsonTool("append_decision_entry", {
+    decisionId: decision._id,
+    entryType: "decision",
+    body: "Link decision inputs and verify later decision entries take primacy.",
+    decidedBy: "Owner"
+  });
+  assert(
+    supersededDecision.fields.currentDecision?.body === "Link decision inputs and verify later decision entries take primacy." &&
+      supersededDecision.fields.entries?.length === 4 &&
+      supersededDecision.fields.entries.some((entry) => entry.body === "Link decision inputs before archiving smoke records."),
+    "Hosted append_decision_entry did not derive current decision from the latest decision entry while preserving prior entries."
+  );
+
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "decisions",
+      id: decision._id,
+      fields: { currentDecision: { body: "mutated" } }
+    },
+    "append_decision_entry"
+  );
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "decisions",
+      id: decision._id,
+      fields: { status: "decided" }
+    },
+    "append_decision_entry"
+  );
+  await expectToolError(
+    "update_record",
+    {
+      recordType: "decisions",
+      id: decision._id,
+      unsetFields: ["currentDecision"]
+    },
+    "append_decision_entry"
+  );
+
+  const decisionWithExpectationInput = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "expectations",
+    inputId: expectation._id
+  });
+  assert(
+    decisionWithExpectationInput.links.some(
+      (link) =>
+        link.toType === "expectations" &&
+        link.toId === expectation._id &&
+        link.relationship === "informed_by"
+    ),
+    "Hosted link_decision_input did not link the Decision to the Expectation."
+  );
+
+  const decisionWithChangeInput = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "changes",
+    inputId: change._id
+  });
+  assert(
+    decisionWithChangeInput.links.some(
+      (link) =>
+        link.toType === "changes" &&
+        link.toId === change._id &&
+        link.relationship === "informed_by"
+    ),
+    "Hosted link_decision_input did not link the Decision to the Change."
+  );
+
+  const decisionWithEstimateInput = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "estimates",
+    inputId: estimate._id
+  });
+  assert(
+    decisionWithEstimateInput.links.some(
+      (link) =>
+        link.toType === "estimates" &&
+        link.toId === estimate._id &&
+        link.relationship === "informed_by"
+    ),
+    "Hosted link_decision_input did not link the Decision to the Estimate."
+  );
+
+  const decisionWithBenefitsInput = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "benefits",
+    inputId: benefits._id
+  });
+  assert(
+    decisionWithBenefitsInput.links.some(
+      (link) =>
+        link.toType === "benefits" &&
+        link.toId === benefits._id &&
+        link.relationship === "informed_by"
+    ),
+    "Hosted link_decision_input did not link the Decision to Benefits."
+  );
+  smokeStep("decision input checks ok");
+
+  const repeatedDecisionInput = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "expectations",
+    inputId: expectation._id
+  });
+  const expectationInputLinks = repeatedDecisionInput.links.filter(
+    (link) =>
+      link.toType === "expectations" &&
+      link.toId === expectation._id &&
+      link.relationship === "informed_by"
+  );
+  assert(expectationInputLinks.length === 1, "Hosted link_decision_input should not duplicate links.");
+
+  const decisionInputs = await callJsonTool("list_linked_records", {
+    recordType: "decisions",
+    id: decision._id,
+    direction: "outbound",
+    relationship: "informed_by"
+  });
+  assert(
+    decisionInputs.outbound.some((entry) => entry.record._id === expectation._id) &&
+      decisionInputs.outbound.some((entry) => entry.record._id === change._id) &&
+      decisionInputs.outbound.some((entry) => entry.record._id === estimate._id),
+    "Hosted list_linked_records did not return the Decision inputs."
+  );
+
+  const expectationInboundDecisionLinks = await callJsonTool("list_linked_records", {
+    recordType: "expectations",
+    id: expectation._id,
+    direction: "inbound",
+    relationship: "informed_by"
+  });
+  assert(
+    expectationInboundDecisionLinks.inbound.some((entry) => entry.record._id === decision._id),
+    "Hosted list_linked_records did not return inbound Decision input links."
+  );
+
+  const decisionWithoutBenefitsInput = await callJsonTool("unlink_records", {
+    fromType: "decisions",
+    fromId: decision._id,
+    toType: "benefits",
+    toId: benefits._id,
+    relationship: "informed_by"
+  });
+  assert(
+    !decisionWithoutBenefitsInput.links.some(
+      (link) => link.toType === "benefits" && link.toId === benefits._id && link.relationship === "informed_by"
+    ) &&
+      decisionWithoutBenefitsInput.links.some(
+        (link) => link.toType === "expectations" && link.toId === expectation._id && link.relationship === "informed_by"
+      ),
+    "Hosted unlink_records did not remove the selected Decision input link while preserving other inputs."
+  );
+  const benefitsInboundDecisionLinks = await callJsonTool("list_linked_records", {
+    recordType: "benefits",
+    id: benefits._id,
+    direction: "inbound",
+    relationship: "informed_by"
+  });
+  assert(
+    !benefitsInboundDecisionLinks.inbound.some((entry) => entry.record._id === decision._id),
+    "Hosted list_linked_records still returned an inbound Decision input after unlink_records."
+  );
+
+  await expectToolError(
+    "link_decision_input",
+    {
+      decisionId: decision._id,
+      inputRecordType: "tasks",
+      inputId: "not-a-canonical-input"
+    },
+    "Invalid option"
+  );
+
+  const archivedDecision = await callJsonTool("archive_record", {
+    recordType: "decisions",
+    id: decision._id
+  });
+  assert(archivedDecision.archivedAt, "Hosted archive_record did not archive the smoke Decision.");
+  createdDecisionId = undefined;
+
+  const archivedChange = await callJsonTool("archive_record", {
+    recordType: "changes",
+    id: change._id
+  });
+  assert(archivedChange.archivedAt, "Hosted archive_record did not archive the smoke Change.");
+  createdChangeId = undefined;
+
+  const archivedEstimate = await callJsonTool("archive_record", {
+    recordType: "estimates",
+    id: estimate._id
+  });
+  assert(archivedEstimate.archivedAt, "Hosted archive_record did not archive the smoke Estimate.");
+  createdEstimateId = undefined;
+
+  const archivedBenefits = await callJsonTool("archive_record", {
+    recordType: "benefits",
+    id: benefits._id
+  });
+  assert(archivedBenefits.archivedAt, "Hosted archive_record did not archive the smoke Benefits.");
+  createdBenefitsId = undefined;
+
+  const archivedRequirement = await callJsonTool("archive_record", {
+    recordType: "requirements",
+    id: requirement._id
+  });
+  assert(archivedRequirement.archivedAt, "Hosted archive_record did not archive the smoke requirement.");
+  createdRequirementId = undefined;
+
+  const archivedExpectation = await callJsonTool("archive_record", {
+    recordType: "expectations",
+    id: expectation._id
+  });
+  assert(archivedExpectation.archivedAt, "Hosted archive_record did not archive the smoke expectation.");
+  createdExpectationId = undefined;
+
+  const ticket = await callJsonTool("create_dxcomplete_ticket", {
+    title: `DX Complete hosted MCP smoke ticket ${runId}`,
+    body: "Hosted MCP smoke ticket body."
+  });
+  createdTicketId = ticket._id;
+  assert(ticket.recordType === DXCOMPLETE_TICKET_COLLECTION_NAME, "Hosted ticket had the wrong record type.");
+  assert(!ticket.workspaceId, "Hosted DX Complete Ticket should not be workspace-scoped.");
+  assert(ticket.createdBy === actor.actorId, "Hosted DX Complete Ticket was not attributed to the token actor.");
+  assert(ticket.fields.entries?.[0]?.direction === "submitter_entry", "Hosted ticket first entry had the wrong direction.");
+
+  const listed = await callJsonTool("list_dxcomplete_tickets", { limit: 10 });
+  assert(
+    listed.some((record) => record._id === ticket._id),
+    "Hosted list_dxcomplete_tickets did not return the created ticket."
+  );
+
+  const ticketWithReply = await appendDxcompleteTicketReply(
+    runtime.db,
+    {
+      id: ticket._id,
+      body: "Hosted DX Complete smoke reply.",
+      addressedToActorId: actor.actorId
+    },
+    smokeCleanupActorId
+  );
+  const reply = ticketWithReply.fields.entries.find((entry) => entry.direction === "dxcomplete_reply");
+  assert(reply?.addressedToActorId === actor.actorId, "Hosted DX Complete reply was not addressed to the actor.");
+
+  const unreadReplies = await callJsonTool("list_unread_dxcomplete_ticket_replies", { limit: 10 });
+  const unreadTicket = unreadReplies.find((entry) => entry.ticketId === ticket._id);
+  assert(
+    unreadTicket?.replies.some((item) => item.id === reply.id),
+    "Hosted unread reply list did not include the DX Complete reply."
+  );
+  assert(unreadTicket.unreadReplyCount === 1, "Hosted unread reply list did not include the expected unread reply count.");
+  assert(unreadTicket.newestReplyAt === reply.createdAt, "Hosted unread reply list did not include the newest reply timestamp.");
+  assert(
+    unreadTicket.replies.every((item) => item.body === undefined && item.readAt === undefined),
+    "Hosted unread reply list should not expose full reply bodies or read state."
+  );
+
+  const readTicket = await callJsonTool("read_dxcomplete_ticket", {
+    id: ticket._id
+  });
+  assert(
+    readTicket.fields.entries.some((entry) => entry.id === reply.id && entry.readAt),
+    "Hosted read_dxcomplete_ticket did not set readAt."
+  );
+
+  const unreadAfterRead = await callJsonTool("list_unread_dxcomplete_ticket_replies", { limit: 10 });
+  assert(
+    !unreadAfterRead.some((entry) => entry.ticketId === ticket._id && entry.replies.some((item) => item.id === reply.id)),
+    "Hosted read reply still appeared in unread results."
+  );
+
+  const archived = await callJsonTool("archive_dxcomplete_ticket", { id: ticket._id });
+  assert(archived.archivedAt, "Hosted archive_dxcomplete_ticket did not archive the ticket.");
+
+  console.log(JSON.stringify({
+    ok: true,
+    depth: "deep",
+    areas: selectableSmokeAreas,
+    workspaceId: workspaceConfig.workspaceId,
+    surfaceVersion: status.server.surfaceVersion,
+    surfaceFingerprint: status.server.surfaceFingerprint,
+    toolCount: status.server.toolCount,
+    totalSeconds: elapsedSeconds(smokeStartedAt),
+    mcpUrl
+  }, null, 2));
+} finally {
+  await archiveCreatedRecord("decisions", createdDecisionId);
+  await archiveCreatedRecord("requirements", createdRequirementId);
+  await archiveCreatedRecord("estimates", createdEstimateId);
+  await archiveCreatedRecord("benefits", createdBenefitsId);
+  await archiveCreatedRecord("changes", createdChangeId);
+  await archiveCreatedRecord("commitments", createdCommitmentId);
+  await archiveCreatedRecord("deferrals", createdDeferralId);
+  await archiveCreatedRecord("expectations", createdExpectationId);
+  await archiveCreatedRecord("statements", createdStatementId);
+  await archiveCreatedTicket(createdTicketId);
+  await transport?.close?.().catch(() => undefined);
+  await closeDxcompleteHttpRuntime().catch(() => undefined);
+  await runtime?.close?.().catch(() => undefined);
+  await closeServer(server);
+}
+
+function parseSmokeSelection(args) {
+  let depth = "light";
+  const areas = new Set();
+
+  for (const arg of args) {
+    if (arg === "--depth=deep" || arg === "--deep" || arg === "deep" || arg === "full") {
+      depth = "deep";
+      continue;
+    }
+    if (arg === "--depth=light" || arg === "--light" || arg === "light") {
+      depth = "light";
+      continue;
+    }
+    if (arg.startsWith("--area=")) {
+      for (const area of arg.slice("--area=".length).split(",")) {
+        areas.add(readSmokeArea(area));
+      }
+      continue;
+    }
+    if (arg.startsWith("--areas=")) {
+      for (const area of arg.slice("--areas=".length).split(",")) {
+        areas.add(readSmokeArea(area));
+      }
+      continue;
+    }
+    if (selectableSmokeAreas.includes(arg)) {
+      areas.add(arg);
+      continue;
+    }
+    throw new Error(`Unknown smoke argument: ${arg}`);
+  }
+
+  return {
+    runner: "selected",
+    depth,
+    areas: areas.size > 0 ? [...areas] : depth === "deep" ? selectableSmokeAreas : ["surface", "light_write"]
+  };
+}
+
+function readSmokeArea(value) {
+  const area = value.trim();
+  if (area === "light_write") {
+    return area;
+  }
+  if (!selectableSmokeAreas.includes(area)) {
+    throw new Error(`Unknown smoke area: ${value}`);
+  }
+  return area;
+}
+
+async function runSelectedSmoke(selection) {
+  const timings = [];
+  const cleanupRecords = [];
+  const cleanupTickets = [];
+  let status;
+  let mcpUrl;
+
+  try {
+    const setup = await timedSmokeSection(timings, "setup", setupSelectedHostedSmoke);
+    mcpUrl = setup.mcpUrl;
+
+    if (selection.areas.includes("surface")) {
+      status = await timedSmokeSection(timings, "surface", () => runSurfaceSection({ mcpUrl: setup.mcpUrl, actor: setup.actor }));
+    } else {
+      status = await readSmokeStatus({ mcpUrl: setup.mcpUrl, actor: setup.actor });
+    }
+
+    for (const area of selection.areas) {
+      if (area === "surface") {
+        continue;
+      }
+      if (area === "light_write") {
+        await timedSmokeSection(timings, "light_write", () => runLightWriteSection(cleanupRecords));
+        continue;
+      }
+      await timedSmokeSection(timings, area, () => runSmokeAreaSection(area, cleanupRecords, cleanupTickets));
+    }
+
+    const totalSeconds = elapsedSeconds(smokeStartedAt);
+    console.log(JSON.stringify({
+      ok: true,
+      depth: selection.depth,
+      areas: selection.areas,
+      workspaceId: workspaceConfig.workspaceId,
+      surfaceVersion: status.server.surfaceVersion,
+      surfaceFingerprint: status.server.surfaceFingerprint,
+      toolCount: status.server.toolCount,
+      totalSeconds,
+      sectionTimings: timings,
+      mcpUrl
+    }, null, 2));
+  } finally {
+    await cleanupSelectedSmokeArtifacts(cleanupRecords, cleanupTickets);
+    await withTimeout(client?.close?.() ?? Promise.resolve(), 2_000, "MCP client close timed out.").catch(() => undefined);
+    await withTimeout(transport?.close?.() ?? Promise.resolve(), 2_000, "MCP transport close timed out.").catch(() => undefined);
+    await closeDxcompleteHttpRuntime().catch(() => undefined);
+    await closeDxcompleteServiceRuntime().catch(() => undefined);
+    await runtime?.close?.().catch(() => undefined);
+    await closeServer(server);
+    await closeServer(serviceServer);
+  }
+}
+
+async function setupSelectedHostedSmoke() {
+  smokeStep("connecting runtime");
+  runtime = await connectRuntime({ envFile: path.join(rootDir, ".env.local") });
+  workspaceConfig = await loadWorkspaceConfig({ cwd: rootDir });
+
+  await archiveStaleSmokeArtifacts(runtime.db, workspaceConfig.workspaceId);
+
+  const actor = createGoogleActorContext({
+    email: `http-smoke-${runId}@example.com`,
+    subject: runId,
+    displayName: "HTTP Smoke Actor"
+  });
+  smokeActor = actor;
+
+  smokeStep("starting central service");
+  serviceServer = createServer((req, res) => {
+    void handleDxcompleteServiceRequest(req, res);
+  });
+  const serviceBaseUrl = await listen(serviceServer);
+
+  const missingServiceCredentialResponse = await fetchWithTimeout(`${serviceBaseUrl}/api/dxcomplete/service/mcp`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} })
+  });
+  assert(missingServiceCredentialResponse.status === 401, "Central service did not reject missing service credentials.");
+
+  const invalidServiceCredentialResponse = await fetchWithTimeout(`${serviceBaseUrl}/api/dxcomplete/service/mcp`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-dxc-service-client-id": "invalid",
+      "x-dxc-service-client-secret": "invalid",
+      "x-dxc-workspace-id": workspaceConfig.workspaceId
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} })
+  });
+  assert(invalidServiceCredentialResponse.status === 401, "Central service did not reject invalid service credentials.");
+
+  const provisionResponse = await fetchWithTimeout(`${serviceBaseUrl}/api/dxcomplete/service/provision`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${process.env.DXC_SERVICE_PROVISIONING_SECRET}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      workspaceId: workspaceConfig.workspaceId,
+      name: workspaceConfig.name,
+      ...(workspaceConfig.mode ? { mode: workspaceConfig.mode } : {}),
+      ownerEmail: actor.email,
+      serviceClientName: `DX Complete HTTP smoke ${runId}`
+    })
+  });
+  assert(provisionResponse.status === 201, "Central provisioning endpoint failed.");
+  const provisioned = await provisionResponse.json();
+  assert(provisioned.ownerMembership?.roles?.includes("owner"), "Provisioning did not seed owner membership.");
+  assert(provisioned.serviceClient?.clientId && provisioned.serviceClient?.secret, "Provisioning did not return a service client.");
+  createdServiceClientId = provisioned.serviceClient.clientId;
+  process.env.DXC_SERVICE_URL = serviceBaseUrl;
+  process.env.DXC_SERVICE_CLIENT_ID = provisioned.serviceClient.clientId;
+  process.env.DXC_SERVICE_CLIENT_SECRET = provisioned.serviceClient.secret;
+
+  smokeStep("starting local workspace MCP proxy");
+  server = createServer((req, res) => {
+    void handleDxcompleteWorkspaceHttpRequest(req, res);
+  });
+  const baseUrl = await listen(server);
+  const mcpUrl = `${baseUrl}/api/mcp`;
+
+  smokeStep("checking unauthenticated metadata");
+  const unauthorized = await fetchWithTimeout(mcpUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} })
+  });
+  assert(unauthorized.status === 401, "Unauthenticated MCP request did not return 401.");
+  assert(
+    unauthorized.headers.get("www-authenticate")?.includes("/.well-known/oauth-protected-resource/api/mcp"),
+    "Unauthenticated MCP request did not advertise protected-resource metadata."
+  );
+
+  const protectedMetadataResponse = await fetchWithTimeout(`${baseUrl}/.well-known/oauth-protected-resource/api/mcp`);
+  assert(protectedMetadataResponse.ok, "Protected-resource metadata was not reachable.");
+  const protectedMetadata = await protectedMetadataResponse.json();
+  assert(protectedMetadata.resource === mcpUrl, "Protected-resource metadata did not match the exact MCP URL.");
+
+  const authMetadataResponse = await fetchWithTimeout(`${baseUrl}/.well-known/oauth-authorization-server`);
+  assert(authMetadataResponse.ok, "Authorization server metadata was not reachable.");
+  const authMetadata = await authMetadataResponse.json();
+  assert(
+    authMetadata.registration_endpoint === `${baseUrl}/api/dxcomplete/auth/register`,
+    "Authorization server metadata did not expose dynamic client registration."
+  );
+
+  const registrationResponse = await fetchWithTimeout(`${baseUrl}/api/dxcomplete/auth/register`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: `DX Complete HTTP smoke ${runId}`,
+      redirect_uris: ["https://client.example/callback"]
+    })
+  });
+  assert(registrationResponse.status === 201, "OAuth dynamic client registration failed.");
+  const registration = await registrationResponse.json();
+
+  const authorizeUrl = new URL(`${baseUrl}/api/dxcomplete/auth/authorize`);
+  authorizeUrl.searchParams.set("client_id", registration.client_id);
+  authorizeUrl.searchParams.set("redirect_uri", "https://client.example/callback");
+  authorizeUrl.searchParams.set("response_type", "code");
+  authorizeUrl.searchParams.set("code_challenge", "smoke-code-challenge");
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  authorizeUrl.searchParams.set("resource", mcpUrl);
+  const authorizeResponse = await fetchWithTimeout(authorizeUrl, { redirect: "manual" });
+  assert(authorizeResponse.status === 302, "OAuth authorize did not redirect to Google.");
+  const googleLocation = new URL(authorizeResponse.headers.get("location"));
+  assert(googleLocation.hostname === "accounts.google.com", "OAuth authorize did not redirect to Google.");
+  assert(
+    googleLocation.searchParams.get("redirect_uri") === `${baseUrl}/api/auth/callback/google`,
+    "OAuth authorize did not use /api/auth/callback/google as the Google callback."
+  );
+
+  smokeStep("issuing smoke actor token");
+
+  const tokenExchangeVerifier = `smoke-token-verifier-${runId}`;
+  const tokenExchangeChallenge = createHash("sha256").update(tokenExchangeVerifier).digest("base64url");
+  const tokenExchangeRequest = await createOAuthAuthorizationRequest(runtime.db, {
+    clientId: registration.client_id,
+    redirectUri: "https://client.example/callback",
+    codeChallenge: tokenExchangeChallenge,
+    codeChallengeMethod: "S256",
+    scope: "mcp:tools",
+    resource: mcpUrl,
+    workspaceId: workspaceConfig.workspaceId
+  });
+  const tokenExchangeCode = await createOAuthAuthorizationCode(runtime.db, tokenExchangeRequest, actor);
+  const tokenExchangeResponse = await fetchWithTimeout(`${baseUrl}/api/dxcomplete/auth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: registration.client_id,
+      code: tokenExchangeCode,
+      redirect_uri: "https://client.example/callback",
+      code_verifier: tokenExchangeVerifier,
+      resource: mcpUrl
+    })
+  });
+  assert(tokenExchangeResponse.status === 200, "OAuth authorization_code token exchange failed.");
+  const tokenExchangeBody = await tokenExchangeResponse.json();
+  assert(typeof tokenExchangeBody.access_token === "string", "OAuth token response did not include an access token.");
+  await runtime.db.collection("oauth_authorization_requests").deleteOne({ _id: tokenExchangeRequest._id });
+
+  const nonMemberActor = createGoogleActorContext({
+    email: `http-smoke-nonmember-${runId}@example.com`,
+    subject: `${runId}-nonmember`
+  });
+  const nonMemberTokenPair = await issueMcpTokenPair(runtime.db, {
+    clientId: smokeCleanupActorId,
+    workspaceId: workspaceConfig.workspaceId,
+    actor: nonMemberActor,
+    resource: mcpUrl,
+    scope: "mcp:tools"
+  });
+  const forbidden = await fetchWithTimeout(mcpUrl, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${nonMemberTokenPair.accessToken}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })
+  });
+  assert(forbidden.status === 403, "Non-member token did not return 403.");
+
+  smokeStep("connecting MCP client");
+  client = new Client({ name: "dxcomplete-smoke-mcp-http", version: "0.1.0" });
+  transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+    requestInit: {
+      headers: {
+        authorization: `Bearer ${tokenExchangeBody.access_token}`
+      }
+    }
+  });
+  await withTimeout(client.connect(transport), smokeTimeoutMs, "MCP client connect timed out.");
+
+  return { mcpUrl, actor, serviceBaseUrl };
+}
+
+async function runSurfaceSection({ mcpUrl, actor }) {
+  const status = await readSmokeStatus({ mcpUrl, actor });
+
+  const manifestByName = new Map(status.server.toolManifest.map((tool) => [tool.name, tool]));
+  for (const toolName of [
+    "runtime_status",
+    "get_process_guide",
+    "get_doc",
+    "create_statement",
+    "update_statement",
+    "create_expectation",
+    "create_requirement",
+    "create_task",
+    "append_task_entry",
+    "create_environment",
+    "update_environment",
+    "list_environments",
+    "create_component",
+    "update_component",
+    "list_components",
+    "create_estimate",
+    "create_benefits",
+    "create_change",
+    "create_decision",
+    "append_decision_entry",
+    "link_decision_input",
+    "append_journal_note",
+    "read_journal",
+    "get_journal_entry",
+    "append_journal_summary",
+    "create_dxcomplete_ticket",
+    "read_dxcomplete_ticket"
+  ]) {
+    assert(status.server.tools.includes(toolName), `Hosted surface is missing ${toolName}.`);
+  }
+  assert(!status.server.tools.includes("get_dxcomplete_ticket"), "Hosted runtime should not expose get_dxcomplete_ticket.");
+  assert(!status.server.tools.includes("mark_dxcomplete_ticket_replies_read"), "Hosted runtime should not expose mark_dxcomplete_ticket_replies_read.");
+  assert(!status.server.tools.includes("update_decision"), "Hosted runtime should not expose update_decision.");
+  assert(!status.server.tools.includes("update_task"), "Hosted runtime should not expose update_task.");
+  for (const removedToolName of [
+    "get_service_charter",
+    "update_service_charter",
+    "create_initiative",
+    "create_business_case",
+    "create_cost_baseline",
+    "create_cost_actual",
+    "create_benefit_measurement",
+    "create_cost_estimate",
+    "create_benefit_estimate"
+  ]) {
+    assert(!status.server.tools.includes(removedToolName), `Hosted runtime should not expose removed tool ${removedToolName}.`);
+  }
+  assert(manifestByName.get("get_doc")?.inputFields.join(",") === "page,term", "Hosted get_doc should expose page and optional term inputs.");
+  for (const toolName of ["get_doc", "create_statement", "update_statement", "create_expectation", "create_task", "append_task_entry", "create_environment", "update_environment", "list_environments", "create_component", "update_component", "list_components", "create_estimate", "create_benefits", "create_change", "create_decision", "append_decision_entry", "link_decision_input", "append_journal_note", "read_journal", "get_journal_entry", "append_journal_summary"]) {
+    assert(!manifestByName.get(toolName)?.inputFields.includes("workspaceId"), `${toolName} should not expose workspaceId on the hosted surface.`);
+  }
+
+  return status;
+}
+
+async function readSmokeStatus({ mcpUrl, actor }) {
+  const status = await callJsonTool("runtime_status", {});
+  assert(status.ok === true, "runtime_status did not return ok: true.");
+  assert(status.actor?.provider === "google", "Hosted runtime did not expose Google actor context.");
+  assert(status.actor?.email === actor.email, "Hosted runtime actor email did not match token actor.");
+  assert(status.workspace?.workspaceId === workspaceConfig.workspaceId, "Hosted runtime did not expose repo workspace config.");
+  assert(status.server?.toolCount === expectedHostedToolCount, `Expected ${expectedHostedToolCount} hosted tools.`);
+  assert(status.server?.surfaceVersion === "dxc-mcp-surface", "Hosted runtime did not expose the expected MCP surface version.");
+  assert(status.server?.workspaceCompatibility === 1, "Hosted runtime did not expose the expected workspace compatibility version.");
+  assert(typeof status.server?.packageVersion === "string", "Hosted runtime did not expose a package version.");
+  assert(typeof status.server?.surfaceFingerprint === "string", "Hosted runtime did not expose a surface fingerprint.");
+  assert(status.server?.http?.canonicalMcpUrl === mcpUrl, "Hosted runtime did not report the canonical MCP URL.");
+  return status;
+}
+
+async function runSmokeAreaSection(area, cleanupRecords, cleanupTickets) {
+  switch (area) {
+    case "docs":
+      await runDocsSection();
+      return;
+    case "records":
+      await runRecordsSection(cleanupRecords);
+      return;
+    case "weigh":
+      await runWeighSection(cleanupRecords);
+      return;
+    case "change":
+      await runChangeSection(cleanupRecords);
+      return;
+    case "tickets":
+      await runTicketsSection(cleanupTickets);
+      return;
+    case "journal":
+      await runJournalSection(cleanupRecords);
+      return;
+    default:
+      throw new Error(`Unsupported smoke area: ${area}`);
+  }
+}
+
+async function runDocsSection() {
+  const status = await callJsonTool("runtime_status", {});
+  const processGuide = await callJsonTool("get_process_guide", {});
+  assert(processGuide.surfaceVersion === status.server.surfaceVersion, "Process guide surface version did not match runtime_status.");
+  assert(processGuide.surfaceFingerprint === status.server.surfaceFingerprint, "Process guide fingerprint did not match runtime_status.");
+  assert(processGuide.currentFlow?.join(",") === "Statement,Expectation,Requirement,Commitment", "Process guide returned an unexpected current flow.");
+  assert(
+    processGuide.phaseGuidance?.some((entry) => entry.includes("non-terminal") && entry.includes("re-enterable")),
+    "Process guide should describe phases as non-terminal and re-enterable."
+  );
+  assert(
+    processGuide.crossCuttingRecords?.some(
+      (entry) =>
+        entry.record === "Task" &&
+        entry.use.includes("Statement, Expectation, Requirement, Commitment")
+    ),
+    "Process guide should describe Task as cross-cutting without naming a separate sequence concept."
+  );
+  assert(
+    processGuide.recordRoutingGuidance?.principle?.includes("dedicated record first") &&
+      processGuide.recordRoutingGuidance?.sharpTest?.includes("Will anything reference or depend on this"),
+    "Process guide should include compact record-routing guidance."
+  );
+  assert(processGuide.phases.map((phase) => phase.id).join(",") === "orient,elicit,weigh,build,go_live,operate,measure", "Process guide returned an unexpected phase order.");
+  assert(processGuide.runtimeRecordTypes?.includes("statements"), "Process guide should include statements.");
+  assert(processGuide.runtimeRecordTypes?.includes("journal_entries"), "Process guide should include journal_entries.");
+  assert(processGuide.runtimeRecordTypes?.includes("environments"), "Process guide should include environments.");
+  assert(processGuide.runtimeRecordTypes?.includes("components"), "Process guide should include components.");
+  assert(processGuide.runtimeRecordTypes?.includes("benefits"), "Process guide should include benefits.");
+  assert(!processGuide.runtimeRecordTypes?.includes("initiatives"), "Process guide should not include initiatives.");
+  for (const removedRuntimeRecordType of ["service_charters", "cost_baselines", "cost_actuals", "benefit_measurements"]) {
+    assert(!processGuide.runtimeRecordTypes?.includes(removedRuntimeRecordType), `Process guide should not include ${removedRuntimeRecordType}.`);
+  }
+
+  const rolesDoc = await callJsonTool("get_doc", { page: "roles" });
+  assert(rolesDoc.surfaceFingerprint === status.server.surfaceFingerprint, "Roles doc fingerprint did not match runtime_status.");
+  assert(rolesDoc.roles?.map((role) => role.name).join(",") === "Owner,Engineer,Tester,Operator,Support Agent,End User", "Roles doc did not return the locked six-role model.");
+
+  const recordsDoc = await callJsonTool("get_doc", { page: "records" });
+  const recordNames = recordsDoc.groups?.flatMap((group) => group.records.map((record) => record.name)) ?? [];
+  assert(
+    recordNames.includes("Statement") &&
+      recordNames.includes("Journal") &&
+      recordNames.includes("Environment") &&
+      recordNames.includes("Component") &&
+      recordNames.includes("Estimate") &&
+      recordNames.includes("Benefits"),
+    "Records doc should include Statement, Journal, Environment, Component, Estimate, and Benefits."
+  );
+  assert(
+    recordsDoc.routingGuidance?.sharpTest?.includes("Will anything reference or depend on this") &&
+      recordsDoc.routingGuidance?.axes?.some((axis) => axis.name === "Attachment") &&
+      recordsDoc.routingGuidance?.promotion?.includes("promoted") &&
+      recordsDoc.routingGuidance?.futureContainers?.some((entry) => entry.name === "Operational Registry"),
+    "Records doc should include full record-routing guidance."
+  );
+  for (const removedRecordName of ["Service Charter", "Cost Baseline", "Actual Cost", "Benefit Measurement", "Initiative", "Business Case", "Cost Estimate", "Benefit Estimate"]) {
+    assert(!recordNames.includes(removedRecordName), `Records doc should not include removed record ${removedRecordName}.`);
+  }
+
+  const statementDoc = await callJsonTool("get_doc", { page: "glossary", term: "statement" });
+  assert(statementDoc.term?.definition.includes("traceable root"), "Statement glossary term should describe traceability.");
+  const benefitsDoc = await callJsonTool("get_doc", { page: "glossary", term: "benefits" });
+  assert(benefitsDoc.term?.definition.includes("quantified or qualitative"), "Benefits glossary term should mention quantified or qualitative items.");
+  const journalDoc = await callJsonTool("get_doc", { page: "glossary", term: "journal" });
+  assert(journalDoc.term?.definition.includes("shared workspace"), "Journal glossary term should describe shared workspace context.");
+  const readableIdDoc = await callJsonTool("get_doc", { page: "glossary", term: "readable id" });
+  assert(readableIdDoc.term?.definition.includes("REQ-0001"), "Readable ID glossary term should mention the human-facing reference format.");
+  const registryDoc = await callJsonTool("get_doc", { page: "glossary", term: "operational registry" });
+  assert(
+    registryDoc.term?.definition.includes("Environments and Components") &&
+      registryDoc.term?.definition.includes("not monitoring"),
+    "Operational Registry glossary term should describe inventory-only boundaries."
+  );
+  const componentDoc = await callJsonTool("get_doc", { page: "glossary", term: "component" });
+  assert(componentDoc.term?.definition.includes("one Environment"), "Component glossary term should describe one-environment scope.");
+  const secretPointerDoc = await callJsonTool("get_doc", { page: "glossary", term: "secret pointer" });
+  assert(secretPointerDoc.term?.definition.includes("should not contain the secret value"), "Secret Pointer glossary term should warn against secret values.");
+  await expectToolError("get_doc", { page: "glossary", term: "voice" }, "Glossary term not found");
+}
+
+async function runLightWriteSection(cleanupRecords) {
+  const expectation = await callJsonTool("create_expectation", {
+    title: `DX Complete hosted MCP smoke light expectation ${runId}`,
+    statement: "The light smoke run can create and archive one workspace-scoped record.",
+    successRecognition: "The record can be created, read, and archived through the hosted MCP endpoint."
+  });
+  cleanupRecords.push(["expectations", expectation._id]);
+  assert(/^EXP-\d{4,}$/.test(expectation.readableId ?? ""), "Light smoke expectation did not receive a readable ID.");
+  const fetched = await callJsonTool("get_record", { recordType: "expectations", id: expectation._id });
+  assert(fetched._id === expectation._id, "Light smoke did not read the created expectation.");
+  const fetchedByReadableId = await callJsonTool("get_record", { recordType: "expectations", id: expectation.readableId });
+  assert(fetchedByReadableId._id === expectation._id, "Light smoke did not read the created expectation by readable ID.");
+  const archived = await callJsonTool("archive_record", { recordType: "expectations", id: expectation.readableId });
+  assert(archived.archivedAt, "Light smoke did not archive the created expectation.");
+  assert(archived.readableId === expectation.readableId, "Light smoke archive did not preserve readable ID.");
+  cleanupRecords.splice(cleanupRecords.findIndex((entry) => entry[0] === "expectations" && entry[1] === expectation._id), 1);
+}
+
+async function createExpectationRequirementFixture(cleanupRecords) {
+  const statement = await callJsonTool("create_statement", {
+    title: `DX Complete hosted MCP smoke statement ${runId}`,
+    statement: "The selected smoke run can preserve a source statement.",
+    source: "hosted smoke"
+  });
+  cleanupRecords.push(["statements", statement._id]);
+  assert(/^STM-\d{4,}$/.test(statement.readableId ?? ""), "Statement did not receive a readable ID.");
+  const expectation = await callJsonTool("create_expectation", {
+    title: `DX Complete hosted MCP smoke expectation ${runId}`,
+    statementId: statement._id,
+    statement: "The selected smoke run can track an expectation.",
+    successRecognition: "The expectation can be linked and cleaned up."
+  });
+  cleanupRecords.push(["expectations", expectation._id]);
+  assert(/^EXP-\d{4,}$/.test(expectation.readableId ?? ""), "Expectation did not receive a readable ID.");
+  const requirement = await callJsonTool("create_requirement", {
+    title: `DX Complete hosted MCP smoke requirement ${runId}`,
+    expectationId: expectation._id,
+    statement: "The selected smoke run can track a requirement.",
+    acceptanceCriteria: ["The requirement links to its expectation."]
+  });
+  cleanupRecords.push(["requirements", requirement._id]);
+  assert(/^REQ-\d{4,}$/.test(requirement.readableId ?? ""), "Requirement did not receive a readable ID.");
+  return { statement, expectation, requirement };
+}
+
+async function runRecordsSection(cleanupRecords) {
+  const { statement, expectation, requirement } = await createExpectationRequirementFixture(cleanupRecords);
+  const statementLinks = await callJsonTool("list_linked_records", {
+    recordType: "expectations",
+    id: expectation._id,
+    relationship: "derives_from"
+  });
+  assert(statementLinks.outbound.some((entry) => entry.record._id === statement._id), "Records smoke did not return derives_from Statement link.");
+  const updatedExpectation = await callJsonTool("update_expectation", {
+    id: expectation._id,
+    approvalState: "not_approved",
+    revisionNote: "Selected records smoke revision."
+  });
+  assert(updatedExpectation.fields.versionHistory?.length === 1, "Records smoke did not append expectation version history.");
+  const requirementWithReviewNote = await callJsonTool("append_review_note", {
+    recordType: "requirements",
+    id: requirement._id,
+    body: "Selected records smoke review note.",
+    important: true
+  });
+  assert(requirementWithReviewNote.fields.reviewNotes?.length === 1, "Records smoke did not append review note.");
+  const linked = await callJsonTool("list_linked_records", {
+    recordType: "requirements",
+    id: requirement.readableId,
+    relationship: "satisfies"
+  });
+  assert(linked.outbound.some((entry) => entry.record._id === expectation._id), "Records smoke did not return satisfies link.");
+  const task = await callJsonTool("create_task", {
+    title: `DX Complete hosted MCP smoke task ${runId}`,
+    description: "Exercise the ledger-style Task shape.",
+    requirementId: requirement._id,
+    assignee: "Engineer",
+    assignor: "Owner",
+    initialStatus: "open"
+  });
+  cleanupRecords.push(["tasks", task._id]);
+  assert(task.fields.currentStatus?.status === "open", "Records smoke task did not derive initial current status.");
+  assert(task.fields.entries?.length === 1, "Records smoke task did not seed an initial status entry.");
+  await expectToolError("create_record", {
+    recordType: "tasks",
+    title: `DX Complete hosted MCP direct task entries ${runId}`,
+    fields: { entries: [] }
+  }, "append_task_entry");
+  const activeTask = await callJsonTool("append_task_entry", {
+    taskId: task._id,
+    entryType: "status_change",
+    body: "Work started.",
+    status: "in_progress"
+  });
+  assert(
+    activeTask.fields.currentStatus?.status === "in_progress" &&
+      activeTask.fields.entries?.length === 2,
+    "Records smoke append_task_entry did not derive current status from the latest status_change entry."
+  );
+  const commentedTask = await callJsonTool("append_task_entry", {
+    taskId: task._id,
+    entryType: "comment",
+    body: "Progress comment."
+  });
+  assert(
+    commentedTask.fields.currentStatus?.status === "in_progress" &&
+      commentedTask.fields.entries?.length === 3,
+    "Records smoke task comment should not change current status."
+  );
+  await expectToolError("append_task_entry", {
+    taskId: task._id,
+    entryType: "comment",
+    body: "Invalid task comment.",
+    status: "done"
+  }, "status is only valid");
+  await expectToolError("update_record", {
+    recordType: "tasks",
+    id: task._id,
+    fields: { currentStatus: { status: "done" } }
+  }, "append_task_entry");
+  await expectToolError("update_record", {
+    recordType: "tasks",
+    id: task._id,
+    fields: { status: "done" }
+  }, "append_task_entry");
+  await expectToolError("update_record", {
+    recordType: "tasks",
+    id: task._id,
+    unsetFields: ["currentStatus"]
+  }, "append_task_entry");
+  const listedTasks = await callJsonTool("list_records", { recordType: "tasks", includeArchived: true, limit: 100 });
+  assert(
+    listedTasks.every(
+      (record) =>
+        Array.isArray(record.fields.entries) &&
+        record.fields.entries.length > 0 &&
+        record.fields.description &&
+        record.fields.currentStatus &&
+        !Object.hasOwn(record.fields, "status") &&
+        !Object.hasOwn(record.fields, "details")
+    ),
+    "Records smoke found a Task without the ledger shape."
+  );
+  await expectToolError("create_requirement", {
+    title: `DX Complete hosted MCP invalid readable sequence requirement ${runId}`,
+    statement: "This create should fail before allocation.",
+    fields: { expectationId: expectation._id }
+  }, "expectationId");
+  const afterFailedCreate = await callJsonTool("create_requirement", {
+    title: `DX Complete hosted MCP sequence requirement ${runId}`,
+    expectationId: expectation._id,
+    statement: "The next valid create should not skip a readable ID after a failed create.",
+    acceptanceCriteria: ["The readable ID increments by exactly one from the prior requirement."]
+  });
+  cleanupRecords.push(["requirements", afterFailedCreate._id]);
+  assert(
+    readableIdNumber(afterFailedCreate.readableId) === readableIdNumber(requirement.readableId) + 1,
+    "Failed create burned a readable ID sequence number."
+  );
+  const environment = await callJsonTool("create_environment", {
+    name: `DX Complete hosted MCP smoke environment ${runId}`,
+    summary: "Records smoke environment.",
+    description: "A temporary operating context for registry smoke coverage."
+  });
+  cleanupRecords.push(["environments", environment._id]);
+  assert(environment.recordType === "environments", "Records smoke Environment had the wrong record type.");
+  assert(/^ENV-\d{4,}$/.test(environment.readableId ?? ""), "Environment did not receive an ENV readable ID.");
+  assert(environment.fields.name.includes(runId), "Environment name was not stored.");
+  const updatedEnvironment = await callJsonTool("update_environment", {
+    id: environment._id,
+    description: "Updated temporary operating context for registry smoke coverage.",
+    revisionNote: "Records smoke environment revision."
+  });
+  assert(
+    updatedEnvironment.fields.description?.includes("Updated temporary") &&
+      updatedEnvironment.fields.versionHistory?.length === 1,
+    "Records smoke update_environment did not update versioned state."
+  );
+  const component = await callJsonTool("create_component", {
+    name: `DX Complete hosted MCP smoke component ${runId}`,
+    environmentId: environment._id,
+    kind: "temporary smoke service",
+    summary: "Records smoke component.",
+    locator: {
+      url: "https://example.com/smoke",
+      route: "/smoke",
+      region: "local"
+    },
+    identifiers: {
+      project: "dxcomplete-smoke",
+      databaseName: "dxcomplete"
+    },
+    secretPointers: [
+      {
+        store: "Vercel",
+        key: "dxc-smoke-secret",
+        location: "Production",
+        note: "Pointer only; no secret value."
+      }
+    ],
+    notes: "Temporary Component for registry smoke coverage."
+  });
+  cleanupRecords.push(["components", component._id]);
+  assert(component.recordType === "components", "Records smoke Component had the wrong record type.");
+  assert(/^CMP-\d{4,}$/.test(component.readableId ?? ""), "Component did not receive a CMP readable ID.");
+  assert(component.fields.environmentId === environment._id, "Component did not store its Environment reference.");
+  assert(component.fields.kind === "temporary smoke service", "Component kind was not stored as free text.");
+  assert(component.fields.locator?.url === "https://example.com/smoke", "Component structured locator was not stored.");
+  assert(component.fields.secretPointers?.[0]?.key === "dxc-smoke-secret", "Component secret pointer was not stored.");
+  assert(
+    component.links?.some(
+      (link) =>
+        link.relationship === "belongs_to_environment" &&
+        link.toType === "environments" &&
+        link.toId === environment._id
+    ),
+    "Component did not link to Environment with belongs_to_environment."
+  );
+  const componentsForEnvironment = await callJsonTool("list_components", {
+    environmentId: environment._id,
+    includeArchived: true,
+    limit: 100
+  });
+  assert(
+    componentsForEnvironment.some((record) => record._id === component._id),
+    "list_components did not return the Component for its Environment."
+  );
+  const otherEnvironment = await callJsonTool("create_environment", {
+    name: `DX Complete hosted MCP smoke other environment ${runId}`
+  });
+  cleanupRecords.push(["environments", otherEnvironment._id]);
+  const componentsForOtherEnvironment = await callJsonTool("list_components", {
+    environmentId: otherEnvironment._id,
+    includeArchived: true,
+    limit: 100
+  });
+  assert(
+    !componentsForOtherEnvironment.some((record) => record._id === component._id),
+    "list_components returned a Component from another Environment."
+  );
+  const linkedEnvironment = await callJsonTool("list_linked_records", {
+    recordType: "components",
+    id: component._id,
+    relationship: "belongs_to_environment"
+  });
+  assert(
+    linkedEnvironment.outbound.some((entry) => entry.record._id === environment._id),
+    "Generic link traversal did not return the Component's Environment."
+  );
+  const updatedComponent = await callJsonTool("update_component", {
+    id: component._id,
+    locator: {
+      url: "https://example.com/smoke-updated",
+      route: "/smoke-updated",
+      region: "local"
+    },
+    notes: "Updated temporary Component for registry smoke coverage.",
+    revisionNote: "Records smoke component revision."
+  });
+  assert(
+    updatedComponent.fields.locator?.url === "https://example.com/smoke-updated" &&
+      updatedComponent.fields.versionHistory?.length === 1,
+    "Records smoke update_component did not update versioned state."
+  );
+  await expectToolError("create_component", {
+    name: `DX Complete hosted MCP missing environment component ${runId}`,
+    environmentId: `missing-${runId}`,
+    kind: "temporary smoke service",
+    locator: { url: "https://example.com/missing" }
+  }, "Environment not found");
+  await expectToolError("create_record", {
+    recordType: "components",
+    title: `DX Complete hosted MCP direct component env ${runId}`,
+    fields: { environmentId: environment._id }
+  }, "environmentId");
+  await expectToolError("update_record", {
+    recordType: "components",
+    id: component._id,
+    fields: { locator: { url: "https://example.com/direct" } }
+  }, "update_component");
+  await expectToolError("update_record", {
+    recordType: "environments",
+    id: environment._id,
+    fields: { description: "Direct environment mutation should fail." }
+  }, "update_environment");
+  await expectToolError("update_record", {
+    recordType: "components",
+    id: component._id,
+    unsetFields: ["versionHistory"]
+  }, "versionHistory");
+  await assertReadableIdsContiguous();
+  await expectToolError("update_record", {
+    recordType: "requirements",
+    id: requirement._id,
+    fields: { statement: "Direct mutation should fail." }
+  }, "update_requirement");
+}
+
+async function createWeighFixture(cleanupRecords) {
+  const { expectation, requirement } = await createExpectationRequirementFixture(cleanupRecords);
+  return { expectation, requirement };
+}
+
+async function runWeighSection(cleanupRecords) {
+  const { expectation, requirement } = await createWeighFixture(cleanupRecords);
+  await expectToolError("create_estimate", {
+    title: `DX Complete hosted MCP bad estimate ${runId}`,
+    requirementIds: [requirement._id],
+    lineItems: [{
+      label: "Direction should fail",
+      direction: "cost",
+      timing: "one_time",
+      currency: "USD",
+      amount: { kind: "single", value: 1 }
+    }]
+  }, "direction");
+  const estimate = await callJsonTool("create_estimate", {
+    title: `DX Complete hosted MCP smoke estimate ${runId}`,
+    requirementIds: [requirement._id],
+    lineItems: [{
+      label: "Build work",
+      timing: "one_time",
+      currency: "USD",
+      amount: { kind: "range", min: 100, expected: 150, max: 200 }
+    }]
+  });
+  cleanupRecords.push(["estimates", estimate._id]);
+  assert(estimate.fields.rollup?.currencies?.USD?.one_time?.expected === 150, "Weigh smoke did not compute estimate roll-up.");
+
+  const benefits = await callJsonTool("create_benefits", {
+    title: `DX Complete hosted MCP smoke benefits ${runId}`,
+    expectationIds: [expectation._id],
+    benefitItems: [{ label: "Qualitative value" }]
+  });
+  cleanupRecords.push(["benefits", benefits._id]);
+  assert(benefits.fields.benefitItems?.[0]?.amount === undefined, "Weigh smoke did not preserve qualitative Benefits item.");
+
+  const deferral = await callJsonTool("create_deferral", {
+    title: `DX Complete hosted MCP smoke deferral ${runId}`,
+    reason: "Selected smoke deferral.",
+    conditions: ["Selected smoke condition."],
+    requirementIds: [requirement._id]
+  });
+  cleanupRecords.push(["deferrals", deferral._id]);
+  const commitment = await callJsonTool("create_commitment", {
+    title: `DX Complete hosted MCP smoke commitment ${runId}`,
+    commitmentStatement: "Selected smoke commitment.",
+    requirementIds: [requirement._id],
+    deferralId: deferral._id
+  });
+  cleanupRecords.push(["commitments", commitment._id]);
+  const commitmentWithBenefits = await callJsonTool("link_records", {
+    fromType: "commitments",
+    fromId: commitment._id,
+    toType: "benefits",
+    toId: benefits._id,
+    relationship: "informed_by"
+  });
+  assert(commitmentWithBenefits.links.some((link) => link.toType === "benefits" && link.relationship === "informed_by"), "Weigh smoke did not link Commitment to Benefits.");
+}
+
+async function runChangeSection(cleanupRecords) {
+  const { expectation, requirement } = await createWeighFixture(cleanupRecords);
+  const change = await callJsonTool("create_change", {
+    title: `DX Complete hosted MCP smoke change ${runId}`,
+    changePlan: "Selected smoke change plan.",
+    executionSteps: ["Execute selected smoke change."],
+    rollbackPlan: "Rollback selected smoke change.",
+    riskImpact: "Low selected smoke risk.",
+    requirementId: requirement._id
+  });
+  cleanupRecords.push(["changes", change._id]);
+  const changeWithNotice = await callJsonTool("append_change_event", {
+    changeId: change._id,
+    eventType: "notice_given",
+    notice: "Selected smoke notice."
+  });
+  assert(changeWithNotice.fields.events?.at(-1)?.eventType === "notice_given", "Change smoke did not append notice event.");
+  const decision = await callJsonTool("create_decision", {
+    title: `DX Complete hosted MCP smoke decision ${runId}`,
+    matter: "What informed the selected smoke decision?",
+    initialDecision: {
+      body: "Use the selected smoke input."
+    }
+  });
+  cleanupRecords.push(["decisions", decision._id]);
+  const linkedDecision = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "changes",
+    inputId: change._id
+  });
+  assert(linkedDecision.links.some((link) => link.toType === "changes" && link.relationship === "informed_by"), "Change smoke did not link Decision to Change.");
+  const inbound = await callJsonTool("list_linked_records", {
+    recordType: "changes",
+    id: change._id,
+    direction: "inbound",
+    relationship: "informed_by"
+  });
+  assert(inbound.inbound.some((entry) => entry.record._id === decision._id), "Change smoke did not return inbound decision input.");
+  await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "expectations",
+    inputId: expectation._id
+  });
+  const listedDecisions = await callJsonTool("list_records", { recordType: "decisions", includeArchived: true, limit: 100 });
+  assert(
+    listedDecisions.every(
+      (record) =>
+        Array.isArray(record.fields.entries) &&
+        record.fields.entries.length > 0 &&
+        record.fields.matter &&
+        !Object.hasOwn(record.fields, "question") &&
+        !Object.hasOwn(record.fields, "decision") &&
+        !Object.hasOwn(record.fields, "argumentsConsidered") &&
+        !Object.hasOwn(record.fields, "status")
+    ),
+    "Change smoke found a Decision without the ledger shape."
+  );
+}
+
+async function runTicketsSection(cleanupTickets) {
+  const ticket = await callJsonTool("create_dxcomplete_ticket", {
+    title: `DX Complete hosted MCP smoke ticket ${runId}`,
+    body: "Selected tickets smoke body."
+  });
+  cleanupTickets.push(ticket._id);
+  const listed = await callJsonTool("list_dxcomplete_tickets", { limit: 10 });
+  assert(listed.some((record) => record._id === ticket._id), "Tickets smoke did not list created ticket.");
+  const ticketWithReply = await appendDxcompleteTicketReply(runtime.db, {
+    id: ticket._id,
+    body: "Selected tickets smoke reply.",
+    addressedToActorId: smokeActor.actorId
+  }, smokeCleanupActorId);
+  const reply = ticketWithReply.fields.entries.find((entry) => entry.direction === "dxcomplete_reply");
+  const unread = await callJsonTool("list_unread_dxcomplete_ticket_replies", { limit: 10 });
+  assert(unread.some((entry) => entry.ticketId === ticket._id && entry.replies.some((item) => item.id === reply.id)), "Tickets smoke did not list unread reply.");
+  const read = await callJsonTool("read_dxcomplete_ticket", { id: ticket._id });
+  assert(read.fields.entries.some((entry) => entry.id === reply.id && entry.readAt), "Tickets smoke did not mark reply read.");
+  const archived = await callJsonTool("archive_dxcomplete_ticket", { id: ticket._id });
+  assert(archived.archivedAt, "Tickets smoke did not archive ticket.");
+  cleanupTickets.splice(cleanupTickets.indexOf(ticket._id), 1);
+}
+
+async function runJournalSection(cleanupRecords) {
+  const firstNote = await callJsonTool("append_journal_note", {
+    body: `DX Complete hosted MCP smoke journal note one ${runId}`,
+    tag: "smoke"
+  });
+  cleanupRecords.push(["journal_entries", firstNote._id]);
+  assert(firstNote.recordType === "journal_entries", "Journal smoke did not create a journal entry.");
+  assert(firstNote.fields.kind === "note", "Journal smoke note did not store kind note.");
+  assert(/^JRN-\d{4,}$/.test(firstNote.readableId ?? ""), "Journal note did not receive a readable ID.");
+
+  const secondNote = await callJsonTool("append_journal_note", {
+    body: `DX Complete hosted MCP smoke journal note two ${runId}`,
+    tag: "smoke"
+  });
+  cleanupRecords.push(["journal_entries", secondNote._id]);
+
+  const hotBeforeSummary = await callJsonTool("read_journal", { limit: 20 });
+  assert(hotBeforeSummary.readTier === "hot", "Journal default read should return the hot tier.");
+  assert(
+    hotBeforeSummary.entries.some((entry) => entry._id === firstNote._id) &&
+      hotBeforeSummary.entries.some((entry) => entry._id === secondNote._id),
+    "Journal hot read did not include active raw notes."
+  );
+  assert(
+    hotBeforeSummary.compaction?.threshold === 200,
+    "Journal read did not report the fixed compaction threshold."
+  );
+
+  const summary = await callJsonTool("append_journal_summary", {
+    body: `DX Complete hosted MCP smoke journal summary ${runId}`,
+    covers: [firstNote._id, secondNote.readableId],
+    tag: "smoke-summary"
+  });
+  cleanupRecords.push(["journal_entries", summary._id]);
+  assert(summary.fields.kind === "summary", "Journal summary did not store kind summary.");
+  assert(summary.fields.covers?.includes(firstNote._id), "Journal summary did not cover the first note by UUID.");
+  assert(summary.fields.covers?.includes(secondNote._id), "Journal summary did not resolve readable ID covers to UUID.");
+
+  const hotAfterSummary = await callJsonTool("read_journal", { limit: 20 });
+  assert(hotAfterSummary.entries.some((entry) => entry._id === summary._id), "Journal hot read did not include the active summary.");
+  assert(
+    !hotAfterSummary.entries.some((entry) => entry._id === firstNote._id || entry._id === secondNote._id),
+    "Journal hot read included raw notes after they were summarized."
+  );
+
+  const archivedNote = await callJsonTool("get_journal_entry", { id: firstNote._id });
+  assert(archivedNote.archivedAt, "Journal covered note was not archived after summary compaction.");
+  assert(
+    archivedNote.fields.coveredBySummaryId === summary._id,
+    "Journal covered note did not point back to the covering summary."
+  );
+
+  const coldRead = await callJsonTool("read_journal", { includeArchived: true, limit: 20 });
+  assert(coldRead.readTier === "cold", "Journal includeArchived read should identify the cold tier.");
+  assert(coldRead.entries.some((entry) => entry._id === firstNote._id), "Journal cold read did not include archived raw notes.");
+
+  const decision = await callJsonTool("create_decision", {
+    title: `DX Complete hosted MCP smoke journal decision ${runId}`,
+    matter: "Can a journal entry inform a decision?",
+    initialDecision: {
+      body: "Yes."
+    }
+  });
+  cleanupRecords.push(["decisions", decision._id]);
+  const linkedDecision = await callJsonTool("link_decision_input", {
+    decisionId: decision._id,
+    inputRecordType: "journal_entries",
+    inputId: firstNote._id
+  });
+  assert(
+    linkedDecision.links.some((link) => link.toType === "journal_entries" && link.toId === firstNote._id && link.relationship === "informed_by"),
+    "Journal entry was not accepted as a Decision input."
+  );
+  const inbound = await callJsonTool("list_linked_records", {
+    recordType: "journal_entries",
+    id: firstNote._id,
+    direction: "inbound",
+    relationship: "informed_by",
+    includeArchived: true
+  });
+  assert(inbound.inbound.some((entry) => entry.record._id === decision._id), "Journal entry did not return inbound Decision links.");
+
+  await expectToolError("create_record", {
+    recordType: "journal_entries",
+    title: `DX Complete hosted MCP invalid journal entry ${runId}`,
+    fields: { kind: "note", body: "Direct journal mutation should fail." }
+  }, "append_journal_note");
+}
+
+async function cleanupSelectedSmokeArtifacts(records, tickets) {
+  if (runtime && workspaceConfig?.workspaceId) {
+    for (const [recordType, id] of [...records].reverse()) {
+      await archiveRecord(runtime.db, {
+        recordType,
+        id,
+        workspaceId: workspaceConfig.workspaceId,
+        reason: "Hosted MCP smoke cleanup"
+      }, smokeCleanupActorId).catch(() => undefined);
+    }
+  }
+
+  for (const id of tickets) {
+    if (smokeActor && runtime) {
+      await archiveDxcompleteTicket(runtime.db, { id }, smokeActor).catch(() => undefined);
+      continue;
+    }
+    if (runtime) {
+      await archiveDxcompleteTicketById(runtime.db, id).catch(() => undefined);
+    }
+  }
+
+  if (runtime && createdServiceClientId) {
+    await runtime.db.collection("workspace_service_clients").deleteOne({ _id: createdServiceClientId }).catch(() => undefined);
+  }
+}
+
+async function timedSmokeSection(timings, name, fn) {
+  const startedAt = Date.now();
+  try {
+    const result = await fn();
+    const seconds = elapsedSeconds(startedAt);
+    timings.push({ name, seconds });
+    smokeStep(`${name} ok (${seconds}s)`);
+    return result;
+  } catch (error) {
+    const seconds = elapsedSeconds(startedAt);
+    smokeStep(`${name} failed after ${seconds}s`);
+    throw error;
+  }
+}
+
+async function callJsonTool(name, args) {
+  const result = await withTimeout(client.callTool({ name, arguments: args }), smokeTimeoutMs, `${name} timed out.`);
+  const text = result.content?.find((entry) => entry.type === "text")?.text;
+  assert(typeof text === "string", `${name} did not return text content.`);
+  if (result.isError) {
+    throw new Error(`${name} failed: ${text}`);
+  }
+  return JSON.parse(text);
+}
+
+async function expectToolError(name, args, expectedMessagePart) {
+  const result = await withTimeout(client.callTool({ name, arguments: args }), smokeTimeoutMs, `${name} timed out.`);
+  const text = result.content?.find((entry) => entry.type === "text")?.text ?? "";
+  assert(result.isError === true, `${name} was expected to fail.`);
+  assert(
+    text.includes(expectedMessagePart),
+    `${name} error did not include "${expectedMessagePart}". Received: ${text}`
+  );
+}
+
+function readableIdNumber(readableId) {
+  assert(typeof readableId === "string" && /^[A-Z]{3}-\d{4,}$/.test(readableId), `Invalid readable ID: ${readableId}`);
+  return Number(readableId.split("-")[1]);
+}
+
+async function assertReadableIdsContiguous() {
+  if (!runtime || !workspaceConfig?.workspaceId) {
+    return;
+  }
+
+  const readableIdTypes = {
+    statements: "STM",
+    journal_entries: "JRN",
+    environments: "ENV",
+    components: "CMP",
+    expectations: "EXP",
+    requirements: "REQ",
+    tasks: "TSK",
+    commitments: "CMT",
+    deferrals: "DFR",
+    decisions: "DEC",
+    changes: "CHG",
+    risks: "RSK",
+    estimates: "EST",
+    benefits: "BFT"
+  };
+
+  for (const [recordType, prefix] of Object.entries(readableIdTypes)) {
+    const records = await runtime.db
+      .collection(recordType)
+      .find({ workspaceId: workspaceConfig.workspaceId }, { projection: { readableId: 1, createdAt: 1, _id: 1 } })
+      .sort({ readableId: 1 })
+      .toArray();
+
+    for (let index = 0; index < records.length; index += 1) {
+      const expected = `${prefix}-${String(index + 1).padStart(4, "0")}`;
+      assert(records[index].readableId === expected, `${recordType} readable IDs are not contiguous at ${expected}.`);
+    }
+  }
+}
+
+async function archiveCreatedRecord(recordType, id) {
+  if (!id) {
+    return;
+  }
+
+  if (client) {
+    try {
+      await callJsonTool("archive_record", { recordType, id });
+      return;
+    } catch {
+      // Fall back to direct cleanup when the MCP client is unavailable or already closing.
+    }
+  }
+
+  if (!runtime || !workspaceConfig?.workspaceId) {
+    return;
+  }
+
+  await archiveRecord(runtime.db, {
+    recordType,
+    id,
+    workspaceId: workspaceConfig.workspaceId,
+    reason: "Hosted MCP smoke cleanup"
+  }, smokeCleanupActorId).catch(() => undefined);
+}
+
+async function archiveCreatedTicket(id) {
+  if (!id) {
+    return;
+  }
+
+  if (client) {
+    try {
+      await callJsonTool("archive_dxcomplete_ticket", { id });
+      return;
+    } catch {
+      // Fall back to direct cleanup when the MCP client is unavailable or already closing.
+    }
+  }
+
+  if (!runtime) {
+    return;
+  }
+
+  if (smokeActor) {
+    await archiveDxcompleteTicket(runtime.db, { id }, smokeActor).catch(() => undefined);
+    return;
+  }
+
+  await archiveDxcompleteTicketById(runtime.db, id);
+}
+
+async function archiveStaleSmokeArtifacts(db, workspaceId) {
+  let archivedCount = 0;
+
+  for (const recordType of smokeRecordTypes) {
+    const records = await db.collection(recordType)
+      .find({
+        workspaceId,
+        archivedAt: { $exists: false },
+        title: smokeTitlePattern
+      }, { projection: { _id: 1 } })
+      .toArray();
+
+    for (const record of records) {
+      try {
+        await archiveRecord(db, {
+          recordType,
+          id: record._id,
+          workspaceId,
+          reason: "Hosted MCP smoke cleanup"
+        }, smokeCleanupActorId);
+        archivedCount += 1;
+      } catch {
+        // Best-effort stale cleanup should not block the smoke test itself.
+      }
+    }
+  }
+
+  const now = new Date().toISOString();
+  const ticketCleanupResult = await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).updateMany(
+    {
+      archivedAt: { $exists: false },
+      $or: [
+        { title: smokeTitlePattern },
+        { "fields.ownerActorId": /^google:http-smoke-/ }
+      ]
+    },
+    {
+      $set: {
+        archivedAt: now,
+        archivedBy: smokeCleanupActorId,
+        archiveReason: "Hosted MCP smoke cleanup",
+        updatedAt: now,
+        updatedBy: smokeCleanupActorId
+      }
+    }
+  );
+  archivedCount += ticketCleanupResult.modifiedCount;
+
+  if (archivedCount > 0) {
+    smokeStep(`archived ${archivedCount} stale smoke artifact${archivedCount === 1 ? "" : "s"}`);
+  }
+}
+
+async function archiveDxcompleteTicketById(db, id) {
+  const now = new Date().toISOString();
+  await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).updateOne(
+    {
+      _id: id,
+      archivedAt: { $exists: false }
+    },
+    {
+      $set: {
+        archivedAt: now,
+        archivedBy: smokeCleanupActorId,
+        archiveReason: "Hosted MCP smoke cleanup",
+        updatedAt: now,
+        updatedBy: smokeCleanupActorId
+      }
+    }
+  );
+}
+
+function withTimeout(promise, timeoutMs, message) {
+  let timeout;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+  });
+
+  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timeout));
+}
+
+async function fetchWithTimeout(url, options = {}, timeoutMs = smokeTimeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    return await fetch(url, {
+      ...options,
+      signal: options.signal ?? controller.signal
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error(`fetch timed out: ${String(url)}`);
+    }
+
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function listen(httpServer) {
+  return new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => {
+      const address = httpServer.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Unable to determine HTTP smoke server address."));
+        return;
+      }
+      resolve(`http://127.0.0.1:${address.port}`);
+    });
+  });
+}
+
+function closeServer(httpServer) {
+  if (!httpServer?.listening) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    httpServer.closeIdleConnections?.();
+    httpServer.closeAllConnections?.();
+    const timeout = setTimeout(() => resolve(), 2_000);
+    httpServer.close((error) => {
+      clearTimeout(timeout);
+      return error ? reject(error) : resolve();
+    });
+  });
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function elapsedSeconds(startedAt) {
+  return Number(((Date.now() - startedAt) / 1000).toFixed(2));
+}
+
+function smokeStep(message) {
+  const now = Date.now();
+  const deltaSeconds = ((now - lastSmokeStepAt) / 1000).toFixed(2);
+  const totalSeconds = ((now - smokeStartedAt) / 1000).toFixed(2);
+  lastSmokeStepAt = now;
+  console.error(`[smoke:mcp:http +${deltaSeconds}s total=${totalSeconds}s] ${message}`);
+}
+
+function assertEstimateAmount(actual, expected, message) {
+  assert(
+    actual?.min === expected.min &&
+      actual?.expected === expected.expected &&
+      actual?.max === expected.max,
+    `${message} Received: ${JSON.stringify(actual)}`
+  );
+}