@treeseed/sdk 0.10.28 → 0.12.4

package/dist/reconcile/live-acceptance.js

@@ -0,0 +1,2027 @@
+import { execFileSync } from "node:child_process";
+import { createServer } from "node:net";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { join, resolve } from "node:path";
+import {
+  createTreeseedCanonicalReconcileReport
+} from "./platform.js";
+import { runTreeseedGit } from "../operations/services/git-runner.js";
+import {
+  deleteRailwayProject,
+  ensureRailwayEnvironment,
+  ensureRailwayGeneratedServiceDomain,
+  ensureRailwayPostgresService,
+  ensureRailwayProject,
+  ensureRailwayService,
+  ensureRailwayServiceVolume,
+  listRailwayEnvironments,
+  listRailwayProjects,
+  listRailwayServices,
+  listRailwayVariables,
+  listRailwayVolumes,
+  railwayGraphqlRequest,
+  resolveRailwayWorkspaceContext,
+  upsertRailwayVariables
+} from "../operations/services/railway-api.js";
+import { resolveGitHubCredentialForRepository } from "../operations/services/github-credentials.js";
+import { MarketClient } from "../market-client.js";
+import { MarketProviderClient } from "../capacity-provider.js";
+const PROVIDER_CAPABILITIES = {
+  railway: ["project", "environment", "service", "image-service", "postgres", "volume", "domain", "variables", "deployment-health", "capacity-provider-runtime-assignment-proof"],
+  cloudflare: ["pages", "worker", "d1", "r2", "kv", "queue", "dns", "turnstile", "secrets", "cache-rules"],
+  github: ["environment", "secret", "variable", "workflow-dispatch", "workflow-observation", "repository-scoped-token"],
+  local: ["process", "port", "local-db", "local-runner", "docker-compose-capacity-provider", "capacity-provider-assignment-proof"]
+};
+function isCapacityRuntimeProofCapability(capability) {
+  return capability === "capacity-provider-assignment-proof" || capability === "capacity-provider-runtime-assignment-proof";
+}
+function scenarioResourceKind(provider, capability) {
+  if (provider === "railway") return capability === "volume" ? "railway-volume" : "railway-service";
+  if (provider === "cloudflare") return "cloudflare-resource";
+  if (provider === "github") {
+    if (capability === "environment") return "github-environment";
+    if (capability === "secret") return "github-secret-binding";
+    if (capability === "variable") return "github-secret-binding";
+    return "package-workflow";
+  }
+  if (isCapacityRuntimeProofCapability(capability)) return "capacity-provider";
+  if (capability === "docker-compose-capacity-provider") return "local-docker-compose";
+  if (capability === "process") return "local-process";
+  if (capability === "local-runner") return "capacity-provider";
+  return "local-process";
+}
+function scenarioResourceProvider(provider, capability) {
+  if (provider === "cloudflare") return "cloudflare";
+  if (provider === "github") return "github";
+  if (provider === "local") return "local";
+  return "railway";
+}
+function liveAcceptanceDesiredResource(input) {
+  const id = `live-acceptance:${input.environment}:${input.provider}:${input.capability}:${input.runId}`;
+  const kind = scenarioResourceKind(input.provider, input.capability);
+  return {
+    id,
+    kind,
+    provider: scenarioResourceProvider(input.provider, input.capability),
+    environment: input.environment,
+    packageId: null,
+    serviceId: input.capability,
+    logicalName: input.capability,
+    spec: {
+      liveAcceptance: true,
+      provider: input.provider,
+      capability: input.capability,
+      runId: input.runId,
+      prefix: providerPrefix(input.environment, input.provider, input.runId),
+      tenantRoot: input.tenantRoot
+    },
+    dependencies: [],
+    source: { type: "package-adapter", id }
+  };
+}
+function compileTreeseedLiveAcceptanceScenarios(input) {
+  const providers = input.provider === "all" ? ["railway", "cloudflare", "github", "local"] : [input.provider];
+  return providers.flatMap((provider) => PROVIDER_CAPABILITIES[provider].map((capability) => {
+    const probeOnly = input.mode === "smoke" || provider === "github" && ["workflow-observation", "repository-scoped-token"].includes(capability) || provider === "cloudflare" && capability === "cache-rules" || isCapacityRuntimeProofCapability(capability);
+    const desiredResources = probeOnly ? [] : [liveAcceptanceDesiredResource({
+      tenantRoot: input.tenantRoot,
+      environment: input.environment,
+      provider,
+      capability,
+      runId: input.runId
+    })];
+    const selector = {
+      environment: input.environment,
+      host: [provider],
+      resourceKind: desiredResources.map((resource) => resource.kind),
+      serviceType: [capability]
+    };
+    return {
+      id: `live-acceptance:${input.environment}:${provider}:${capability}:${input.runId}`,
+      provider,
+      capability,
+      desiredResources,
+      selector,
+      expectedActions: input.mode === "cleanup" ? ["delete", "noop"] : probeOnly ? ["noop"] : ["create", "update", "replace", "reattach", "noop"],
+      cleanupSelector: selector,
+      required: true,
+      probeOnly,
+      cleanupRequired: input.mode !== "smoke" && !probeOnly
+    };
+  }));
+}
+function configuredValue(env, keys) {
+  for (const key of keys) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function capacityAcceptanceConfig(env, environment) {
+  const local = environment === "local";
+  const apiUrl = configuredValue(env, [
+    "TREESEED_CAPACITY_ACCEPTANCE_API_URL",
+    "TREESEED_MARKET_URL",
+    "TREESEED_MANAGEMENT_API_URL",
+    "TREESEED_API_BASE_URL"
+  ]) || (local ? "http://127.0.0.1:3000" : "");
+  const adminToken = configuredValue(env, ["TREESEED_CAPACITY_ACCEPTANCE_ADMIN_TOKEN"]) || (local ? "tsk_local_treeseed_acceptance_admin" : "");
+  const teamId = configuredValue(env, ["TREESEED_CAPACITY_ACCEPTANCE_TEAM_ID"]) || (local ? "d8a613c2-bbdb-4474-9c96-31e985beafd4" : "");
+  const projectId = configuredValue(env, ["TREESEED_CAPACITY_ACCEPTANCE_PROJECT_ID"]) || (local ? "90764af2-5a13-42b9-a2fa-fb3af5882323" : "");
+  const providerId = configuredValue(env, ["TREESEED_CAPACITY_ACCEPTANCE_PROVIDER_ID", "TREESEED_CAPACITY_PROVIDER_ID"]) || (local ? "ff48ce97-6959-46b5-be9f-9b7062161fe3" : "");
+  const agentClassId = configuredValue(env, ["TREESEED_CAPACITY_ACCEPTANCE_AGENT_CLASS_ID"]) || (local ? "planning" : "");
+  const providerApiKey = configuredValue(env, ["TREESEED_CAPACITY_PROVIDER_API_KEY"]) || (local ? "tsp_local_treeseed_demo_capacity_provider" : "");
+  const missing = [
+    ["TREESEED_CAPACITY_ACCEPTANCE_API_URL or TREESEED_MARKET_URL", apiUrl],
+    ["TREESEED_CAPACITY_ACCEPTANCE_ADMIN_TOKEN", adminToken],
+    ["TREESEED_CAPACITY_ACCEPTANCE_TEAM_ID", teamId],
+    ["TREESEED_CAPACITY_ACCEPTANCE_PROJECT_ID", projectId],
+    ["TREESEED_CAPACITY_ACCEPTANCE_PROVIDER_ID or TREESEED_CAPACITY_PROVIDER_ID", providerId],
+    ["TREESEED_CAPACITY_ACCEPTANCE_AGENT_CLASS_ID", agentClassId],
+    ["TREESEED_CAPACITY_PROVIDER_API_KEY", providerApiKey]
+  ].filter(([, value]) => !value).map(([key]) => String(key));
+  return {
+    apiUrl,
+    adminToken,
+    teamId,
+    projectId,
+    providerId,
+    agentClassId,
+    providerApiKey,
+    missing
+  };
+}
+function capacityGrantForAcceptance(grants, config, environment) {
+  return grants.map((entry) => entry && typeof entry === "object" ? entry : null).find(
+    (grant) => grant && grant.id && grant.capacityProviderId === config.providerId && grant.projectId === config.projectId && (grant.teamId === config.teamId || !grant.teamId) && (grant.state === "active" || !grant.state) && (grant.environment === environment || !grant.environment)
+  ) ?? null;
+}
+async function createTreeDxProxyAuditEvidence(input) {
+  const response = await input.fetchImpl(
+    `${input.apiUrl.replace(/\/$/u, "")}/v1/dx/projects/${encodeURIComponent(input.projectId)}/repos/${encodeURIComponent(`capacity-proof-${input.runId}`)}/files/read`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${input.providerApiKey}`,
+        "content-type": "application/json",
+        "x-treeseed-assignment-id": input.assignmentId
+      },
+      body: JSON.stringify({
+        paths: [`src/content/agent-platform-proof/${input.runId}.mdx`],
+        ref: "HEAD"
+      })
+    }
+  );
+  if (response.status !== 403) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Capacity acceptance TreeDX proxy audit probe expected 403 but received ${response.status}${text ? `: ${text}` : ""}.`);
+  }
+}
+async function runCapacityProviderAssignmentProof(input) {
+  const config = capacityAcceptanceConfig(input.env, input.environment);
+  if (config.missing.length > 0) {
+    throw new Error(`Missing capacity acceptance configuration: ${config.missing.join(", ")}.`);
+  }
+  const runnerId = `${input.prefix}-runner`;
+  const assignmentId = `${input.prefix}-assignment`;
+  const mode = configuredValue(input.env, ["TREESEED_CAPACITY_ACCEPTANCE_MODE"]) || "planning";
+  const metadata = {
+    liveAcceptance: true,
+    runId: input.runId,
+    prefix: input.prefix,
+    provider: input.provider,
+    capability: input.provider === "railway" ? "capacity-provider-runtime-assignment-proof" : "capacity-provider-assignment-proof",
+    priority: 1e6
+  };
+  const adminClient = new MarketClient({
+    profile: {
+      id: "capacity-acceptance",
+      label: "Capacity Acceptance",
+      baseUrl: config.apiUrl,
+      kind: "specialized",
+      teamId: config.teamId
+    },
+    accessToken: config.adminToken,
+    fetchImpl: input.fetchImpl,
+    userAgent: `treeseed-live-acceptance/${input.runId}`
+  });
+  const providerClient = new MarketProviderClient({
+    marketUrl: config.apiUrl,
+    marketId: input.environment,
+    apiKey: config.providerApiKey,
+    fetchImpl: input.fetchImpl,
+    userAgent: `treeseed-live-acceptance/${input.runId}`
+  });
+  const existingClasses = await adminClient.projectAgentClasses(config.projectId).catch(() => ({ payload: [] }));
+  const hasAgentClass = Array.isArray(existingClasses.payload) && existingClasses.payload.some((entry) => {
+    const record = entry && typeof entry === "object" ? entry : {};
+    return record.id === config.agentClassId || record.slug === config.agentClassId;
+  });
+  if (!hasAgentClass) {
+    await adminClient.createProjectAgentClass(config.projectId, {
+      id: config.agentClassId,
+      slug: config.agentClassId,
+      name: "Planning",
+      status: "active",
+      allowedModes: ["planning"],
+      requiredCapabilities: ["agent_mode_run"],
+      metadata
+    });
+  }
+  const grants = await adminClient.capacityGrants(config.teamId).catch(() => ({ payload: [] }));
+  const acceptanceGrant = capacityGrantForAcceptance(Array.isArray(grants.payload) ? grants.payload : [], config, input.environment);
+  if (!acceptanceGrant) {
+    throw new Error(`Capacity acceptance did not find an active checked-in grant for project ${config.projectId} and provider ${config.providerId}.`);
+  }
+  const reservation = await adminClient.createCapacityReservation(config.projectId, {
+    id: `${input.prefix}-reservation`,
+    capacityProviderId: config.providerId,
+    laneId: typeof acceptanceGrant.laneId === "string" && acceptanceGrant.laneId ? acceptanceGrant.laneId : `${config.providerId}:agent-capacity`,
+    reservedCredits: 1,
+    nativeUnit: "request",
+    reservedNativeAmount: 1,
+    mode,
+    metadata
+  });
+  const reservationId = String(reservation.payload?.id ?? "");
+  if (!reservationId) throw new Error("Capacity acceptance reservation creation did not return an id.");
+  const checkIn = await providerClient.checkIn({
+    id: `${input.prefix}-session`,
+    environment: input.environment,
+    status: "open",
+    capabilities: ["repo_read", "agent_mode_run", "usage_report"],
+    grants: [{
+      grantId: String(acceptanceGrant.id),
+      projectId: config.projectId,
+      teamId: config.teamId,
+      grantScope: typeof acceptanceGrant.grantScope === "string" ? acceptanceGrant.grantScope : "project"
+    }],
+    nativeLimits: { wallMinutes: { session: 30 } },
+    runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
+    constraints: { liveAcceptance: true, outboundOnly: true },
+    metadata
+  });
+  const sessionId = String(checkIn.payload.id ?? "");
+  if (!sessionId) throw new Error("Capacity acceptance check-in did not return a session id.");
+  await adminClient.createProviderAssignment(config.teamId, {
+    id: assignmentId,
+    projectId: config.projectId,
+    capacityProviderId: config.providerId,
+    providerSessionId: sessionId,
+    projectAgentClassId: config.agentClassId,
+    reservationId,
+    mode,
+    capacityEnvelope: {
+      teamId: config.teamId,
+      projectId: config.projectId,
+      providerId: config.providerId,
+      laneId: typeof acceptanceGrant.laneId === "string" && acceptanceGrant.laneId ? acceptanceGrant.laneId : `${config.providerId}:agent-capacity`,
+      reservationId,
+      mode,
+      limits: { wallMinutes: 5 },
+      metadata
+    },
+    decisionInput: {
+      kind: "capacity_acceptance_diagnostic",
+      runId: input.runId,
+      mode,
+      instructions: "Execute the isolated capacity acceptance diagnostic without widening project or provider scope."
+    },
+    workspaceContext: {
+      liveAcceptance: true,
+      runId: input.runId
+    },
+    metadata
+  });
+  let leased = null;
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    leased = await providerClient.nextAssignment({
+      sessionId,
+      runnerId,
+      leaseSeconds: 120,
+      metadata
+    });
+    const leasedId = leased.payload?.id ? String(leased.payload.id) : "";
+    if (!leasedId) throw new Error("Capacity acceptance did not lease an assignment.");
+    if (leasedId === assignmentId) break;
+    const leasedMetadata = leased.payload?.metadata && typeof leased.payload.metadata === "object" ? leased.payload.metadata : {};
+    if (leasedMetadata.liveAcceptance !== true) {
+      throw new Error(`Capacity acceptance leased ${leasedId} instead of diagnostic assignment ${assignmentId}.`);
+    }
+    const staleLeaseToken = leased.leaseToken ?? leased.payload.leaseToken ?? null;
+    if (!staleLeaseToken) throw new Error(`Capacity acceptance leased stale diagnostic ${leasedId} without a lease token.`);
+    await providerClient.completeAssignment(leasedId, {
+      runnerId,
+      leaseToken: staleLeaseToken,
+      output: { summary: "Retired stale capacity acceptance diagnostic.", runId: input.runId },
+      summary: { runId: input.runId, retiredAssignmentId: leasedId },
+      metadata: {
+        ...metadata,
+        retiredStaleAcceptanceAssignment: true,
+        retiredAssignmentId: leasedId
+      }
+    });
+    leased = null;
+  }
+  if (!leased?.payload?.id) throw new Error("Capacity acceptance did not lease an assignment.");
+  if (leased.payload.id !== assignmentId) {
+    throw new Error(`Capacity acceptance leased stale diagnostics but did not reach diagnostic assignment ${assignmentId}.`);
+  }
+  const leaseToken = leased.leaseToken ?? leased.payload.leaseToken ?? null;
+  if (!leaseToken) throw new Error("Capacity acceptance lease did not include a lease token.");
+  await createTreeDxProxyAuditEvidence({
+    fetchImpl: input.fetchImpl,
+    apiUrl: config.apiUrl,
+    providerApiKey: config.providerApiKey,
+    projectId: config.projectId,
+    assignmentId,
+    runId: input.runId
+  });
+  const modeRun = await providerClient.createAssignmentModeRun(assignmentId, {
+    status: "succeeded",
+    selectedInput: { kind: "capacity_acceptance_diagnostic", runId: input.runId, mode },
+    outputs: { summary: "Capacity acceptance diagnostic completed.", runId: input.runId },
+    usageActual: {
+      actualCredits: 0,
+      nativeUsage: { nativeUnit: "request", amount: 1, source: "capacity_acceptance" },
+      metadata
+    },
+    traceRefs: { liveAcceptanceRunId: input.runId },
+    metadata
+  });
+  const modeRunId = String(modeRun.payload.id ?? "");
+  if (!modeRunId) throw new Error("Capacity acceptance mode-run creation did not return an id.");
+  const completed = await providerClient.completeAssignment(assignmentId, {
+    runnerId,
+    leaseToken,
+    modeRunId,
+    actualCredits: 0.25,
+    nativeUsage: { nativeUnit: "request", amount: 1, source: "capacity_acceptance" },
+    output: { summary: "Capacity acceptance diagnostic completed.", runId: input.runId },
+    summary: { runId: input.runId, modeRunId },
+    metadata
+  });
+  const finalStatus = String(completed.payload?.status ?? "");
+  if (finalStatus !== "completed") {
+    throw new Error(`Capacity acceptance assignment finished with status "${finalStatus || "unknown"}".`);
+  }
+  const modeRuns = await adminClient.projectAgentModeRuns(config.projectId, { assignmentId });
+  const modeRunCount = Array.isArray(modeRuns.payload) ? modeRuns.payload.length : 0;
+  if (!modeRunCount) throw new Error("Capacity acceptance mode-run was not visible through project mode-run inspection.");
+  return {
+    sessionId,
+    assignmentId,
+    modeRunId,
+    finalStatus,
+    mode,
+    runnerId,
+    modeRunCount
+  };
+}
+function shortRunId(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().replace(/[^0-9]/gu, "").slice(0, 14);
+}
+function providerPrefix(environment, provider, runId) {
+  if (provider === "railway") return `trsd-rail-${runId}`.toLowerCase();
+  return `trsd-live-${environment}-${provider}-${runId}`.toLowerCase();
+}
+function providerPrefixRoot(environment, provider) {
+  if (provider === "railway") return "trsd-rail-";
+  return `trsd-live-${environment}-${provider}-`.toLowerCase();
+}
+function emitProgress(onProgress, event) {
+  if (!onProgress) return;
+  onProgress({
+    ...event,
+    message: event.message ?? [
+      event.provider,
+      event.capability,
+      event.phase
+    ].filter(Boolean).join(":")
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function waitForLiveObservation(description, observe, isReady, options = {}) {
+  const attempts = Math.max(1, options.attempts ?? 8);
+  const intervalMs = Math.max(0, options.intervalMs ?? 750);
+  let lastValue;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      lastValue = await observe();
+      if (isReady(lastValue)) return lastValue;
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  if (lastError) {
+    throw new Error(`${description} was not observed live: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+  }
+  throw new Error(`${description} was not observed live after ${attempts} attempt(s).`);
+}
+function parseGitHubRepository(value) {
+  const raw = value.trim().replace(/^https?:\/\/github\.com\//iu, "").replace(/^git@github\.com:/iu, "").replace(/^ssh:\/\/git@github\.com\//iu, "").replace(/\.git$/iu, "").replace(/^\/+|\/+$/gu, "");
+  const [owner, repo, ...extra] = raw.split("/").filter(Boolean);
+  if (!owner || !repo || extra.length > 0) {
+    throw new Error(`Invalid GitHub repository "${value}". Expected owner/name.`);
+  }
+  return `${owner}/${repo}`;
+}
+function resolveCurrentGitHubRepository(cwd, env) {
+  const configured = configuredValue(env, ["TREESEED_REPOSITORY", "GITHUB_REPOSITORY"]);
+  if (configured) return parseGitHubRepository(configured);
+  const remote = runTreeseedGit(["config", "--get", "remote.origin.url"], {
+    cwd,
+    mode: "read"
+  }).stdout.trim();
+  return parseGitHubRepository(remote);
+}
+function domainFromWorkspace(cwd) {
+  try {
+    const manifest = readFileSync(join(cwd, "treeseed.site.yaml"), "utf8");
+    const match = /^siteUrl:\s*(\S+)/gmu.exec(manifest);
+    if (!match?.[1]) return "";
+    const url = new URL(match[1]);
+    return url.hostname.replace(/^www\./iu, "");
+  } catch {
+    return "";
+  }
+}
+function resolveLiveTestDomain(cwd, env) {
+  return configuredValue(env, ["TREESEED_LIVE_TEST_DOMAIN"]) || configuredValue(env, ["TREESEED_DOMAIN"]) || domainFromWorkspace(cwd);
+}
+async function resolveCloudflareZoneId(domain, env, fetchImpl) {
+  const configured = configuredValue(env, ["TREESEED_LIVE_TEST_CLOUDFLARE_ZONE_ID", "CLOUDFLARE_ZONE_ID"]);
+  if (configured) return configured;
+  const zones = await cloudflareRequest("/zones?per_page=100", env, fetchImpl).catch(() => []);
+  if (!Array.isArray(zones)) return "";
+  const candidates = zones.map((entry) => entry && typeof entry === "object" ? entry : null).filter(Boolean);
+  const matched = candidates.find((entry) => typeof entry.name === "string" && (domain === entry.name || domain.endsWith(`.${entry.name}`)));
+  return typeof matched?.id === "string" ? matched.id : "";
+}
+function scenario({
+  provider,
+  mode,
+  prefix,
+  capability,
+  ok,
+  phase,
+  action,
+  reason,
+  locators = {},
+  createdResources = [],
+  updatedResources = [],
+  replacedResources = [],
+  destroyedResources = [],
+  retainedResources = [],
+  issues = [],
+  startedAt,
+  completedAt,
+  durationMs
+}) {
+  const completed = completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const started = startedAt ?? completed;
+  return {
+    id: `live-test:${provider}:${capability}`,
+    provider,
+    capability,
+    mode,
+    ok,
+    phase,
+    action,
+    reason,
+    startedAt: started,
+    completedAt: completed,
+    durationMs: typeof durationMs === "number" ? Math.max(1, Math.ceil(durationMs)) : Math.max(1, Date.parse(completed) - Date.parse(started)),
+    locators,
+    createdResources,
+    updatedResources,
+    replacedResources,
+    destroyedResources,
+    retainedResources,
+    issues
+  };
+}
+function node(provider, environment, type, id, state = {}) {
+  return {
+    id,
+    provider,
+    type,
+    owner: "reconcile-live-test",
+    environment,
+    state
+  };
+}
+function redactProviderState(value) {
+  if (Array.isArray(value)) return value.map((entry) => redactProviderState(entry));
+  if (value && typeof value === "object") {
+    const redacted = {};
+    for (const [key, entry] of Object.entries(value)) {
+      redacted[key] = /secret|token|password|private|key/iu.test(key) ? "[redacted]" : redactProviderState(entry);
+    }
+    return redacted;
+  }
+  return value;
+}
+function providerNode(provider, environment, type, id, state = {}) {
+  return node(provider, environment, type, id, redactProviderState(state));
+}
+function blocking(provider, type, reason) {
+  return {
+    id: `live-test:${provider}:${type}:blocked`,
+    resourceId: `live-test:${provider}:${type}`,
+    severity: "blocking",
+    reason,
+    provider,
+    type
+  };
+}
+async function measuredScenario(input, fn) {
+  const started = /* @__PURE__ */ new Date();
+  const startedMs = performance.now();
+  emitProgress(input.onProgress, {
+    provider: input.provider,
+    mode: input.mode,
+    environment: input.environment,
+    runId: input.runId,
+    resourcePrefix: input.prefix,
+    capability: input.capability,
+    phase: input.phase === "verify" ? "verify" : input.phase === "cleanup" ? "cleanup" : input.phase === "destroy" ? "destroy" : "create",
+    message: input.startMessage ?? `${input.provider}:${input.capability}: ${input.phase} started`
+  });
+  try {
+    const value = await fn();
+    const completed = /* @__PURE__ */ new Date();
+    const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
+    const resourcesFor = (resources) => typeof resources === "function" ? resources(value) : resources ?? [];
+    emitProgress(input.onProgress, {
+      provider: input.provider,
+      mode: input.mode,
+      environment: input.environment,
+      runId: input.runId,
+      resourcePrefix: input.prefix,
+      capability: input.capability,
+      phase: "complete",
+      elapsedMs: durationMs,
+      message: `${input.provider}:${input.capability}: ok in ${durationMs}ms`
+    });
+    return scenario({
+      provider: input.provider,
+      mode: input.mode,
+      prefix: input.prefix,
+      capability: input.capability,
+      ok: true,
+      phase: input.phase,
+      action: input.action,
+      reason: typeof input.successReason === "function" ? input.successReason(value) : input.successReason,
+      locators: input.locators,
+      createdResources: resourcesFor(input.createdResources),
+      updatedResources: resourcesFor(input.updatedResources),
+      replacedResources: resourcesFor(input.replacedResources),
+      destroyedResources: resourcesFor(input.destroyedResources),
+      retainedResources: resourcesFor(input.retainedResources),
+      startedAt: started.toISOString(),
+      completedAt: completed.toISOString(),
+      durationMs
+    });
+  } catch (error) {
+    const completed = /* @__PURE__ */ new Date();
+    const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
+    const reason = error instanceof Error ? error.message : String(error);
+    emitProgress(input.onProgress, {
+      provider: input.provider,
+      mode: input.mode,
+      environment: input.environment,
+      runId: input.runId,
+      resourcePrefix: input.prefix,
+      capability: input.capability,
+      phase: "blocked",
+      elapsedMs: durationMs,
+      message: `${input.provider}:${input.capability}: blocked after ${durationMs}ms - ${reason}`
+    });
+    return scenario({
+      provider: input.provider,
+      mode: input.mode,
+      prefix: input.prefix,
+      capability: input.capability,
+      ok: false,
+      phase: "blocked",
+      action: "blocked",
+      reason,
+      locators: input.locators,
+      startedAt: started.toISOString(),
+      completedAt: completed.toISOString(),
+      durationMs
+    });
+  }
+}
+function reportForProvider({
+  provider,
+  mode,
+  runId,
+  prefix,
+  environment,
+  results,
+  cleanupDrift = []
+}) {
+  const capabilities = PROVIDER_CAPABILITIES[provider];
+  const desiredGraph = capabilities.map((capability) => ({
+    id: `live-test:${provider}:${capability}`,
+    provider,
+    type: capability,
+    owner: "reconcile-live-test",
+    environment,
+    spec: { prefix, isolated: true, mode }
+  }));
+  const resultByCapability = new Map(results.map((result) => [result.capability, result]));
+  const blockedDrift = [
+    ...desiredGraph.filter((entry) => !resultByCapability.get(String(entry.type))?.ok).map((entry) => blocking(provider, String(entry.type), resultByCapability.get(String(entry.type))?.reason ?? "Live scenario did not run.")),
+    ...cleanupDrift
+  ];
+  const actions = desiredGraph.map((entry) => {
+    const result = resultByCapability.get(String(entry.type));
+    return {
+      id: `${entry.id}:${result?.action ?? "blocked"}`,
+      kind: result?.ok ? result.action : "blocked",
+      resourceId: entry.id,
+      reason: result?.reason ?? "Live scenario did not run.",
+      provider,
+      type: entry.type
+    };
+  });
+  const postconditions = desiredGraph.map((entry) => {
+    const result = resultByCapability.get(String(entry.type));
+    return {
+      id: `${entry.id}:postcondition`,
+      resourceId: entry.id,
+      description: `${mode} live reconciliation postconditions pass for ${provider}:${entry.type}.`,
+      source: provider === "local" ? "local" : "api",
+      required: true,
+      ok: Boolean(result?.ok),
+      issues: result?.ok ? [] : [result?.reason ?? "Live scenario did not run."],
+      observed: result?.locators ?? {}
+    };
+  });
+  const createdResources = results.flatMap((result) => result.createdResources);
+  const updatedResources = results.flatMap((result) => result.updatedResources);
+  const replacedResources = results.flatMap((result) => result.replacedResources);
+  const destroyedResources = results.flatMap((result) => result.destroyedResources);
+  const retainedResources = results.flatMap((result) => result.retainedResources);
+  const report = createTreeseedCanonicalReconcileReport({
+    desiredGraph,
+    observedGraph: desiredGraph.filter((entry) => resultByCapability.has(String(entry.type))).map((entry) => ({
+      ...entry,
+      state: {
+        verified: Boolean(resultByCapability.get(String(entry.type))?.ok),
+        locators: resultByCapability.get(String(entry.type))?.locators ?? {}
+      }
+    })),
+    diff: blockedDrift,
+    actions,
+    postconditions,
+    blockedDrift,
+    retainedResources,
+    destroyedResources,
+    liveVerification: {
+      ok: blockedDrift.length === 0,
+      source: `reconcile-live-test:${mode}`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      issues: blockedDrift.map((entry) => entry.reason)
+    }
+  });
+  return {
+    provider,
+    mode,
+    runId,
+    resourcePrefix: prefix,
+    scenarioResults: results,
+    coverage: {
+      total: capabilities.length,
+      passed: results.filter((result) => result.ok).length,
+      failed: capabilities.length - results.filter((result) => result.ok).length,
+      capabilities
+    },
+    createdResources,
+    updatedResources,
+    replacedResources,
+    destroyedResources,
+    retainedResources,
+    cleanupDrift,
+    report,
+    ok: report.ok
+  };
+}
+async function cloudflareRequestPayload(path, env, fetchImpl, init = {}) {
+  const token = configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"]);
+  if (!token) throw new Error("Missing TREESEED_CLOUDFLARE_API_TOKEN.");
+  const response = await fetchImpl(`https://api.cloudflare.com/client/v4${path}`, {
+    ...init,
+    headers: {
+      Accept: "application/json",
+      ...init.body ? { "Content-Type": "application/json" } : {},
+      Authorization: `Bearer ${token}`,
+      ...init.headers ?? {}
+    }
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || payload.success === false) {
+    const errors = Array.isArray(payload.errors) ? payload.errors.map((entry) => entry.message).filter(Boolean).join("; ") : "";
+    throw new Error(`${response.status} ${response.statusText}${errors ? `: ${errors}` : ""}`);
+  }
+  return payload;
+}
+async function cloudflareRequest(path, env, fetchImpl, init = {}) {
+  const payload = await cloudflareRequestPayload(path, env, fetchImpl, init);
+  return payload.result;
+}
+function isTransientCloudflareError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /\b(500|502|503|504|520|521|522|523|524)\b|internal server error|unknown error occurred|temporar(?:y|ily)|timeout|rate limit/iu.test(message);
+}
+async function withCloudflareTransientRetry(operation, options = {}) {
+  const attempts = Math.max(1, options.attempts ?? 4);
+  const delayMs = Math.max(0, options.delayMs ?? 1500);
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (!isTransientCloudflareError(error) || attempt >= attempts) break;
+      await sleep(delayMs * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function cloudflareRawRequest(path, env, fetchImpl, init = {}) {
+  const token = configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"]);
+  if (!token) throw new Error("Missing TREESEED_CLOUDFLARE_API_TOKEN.");
+  const response = await fetchImpl(`https://api.cloudflare.com/client/v4${path}`, {
+    ...init,
+    headers: {
+      Accept: "*/*",
+      Authorization: `Bearer ${token}`,
+      ...init.headers ?? {}
+    }
+  });
+  const body = await response.text().catch(() => "");
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}${body ? `: ${body.slice(0, 300)}` : ""}`);
+  }
+  return body;
+}
+async function githubRequest(path, token, fetchImpl, init = {}) {
+  const response = await fetchImpl(`https://api.github.com${path}`, {
+    ...init,
+    headers: {
+      Accept: "application/vnd.github+json",
+      ...init.body ? { "Content-Type": "application/json" } : {},
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...init.headers ?? {}
+    }
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}${payload.message ? `: ${payload.message}` : ""}`);
+  }
+  return payload;
+}
+async function runSmokeProvider({
+  provider,
+  environment,
+  prefix,
+  mode,
+  cwd,
+  env,
+  fetchImpl
+}) {
+  if (provider === "railway") {
+    if (!configuredValue(env, ["TREESEED_RAILWAY_API_TOKEN"])) {
+      return PROVIDER_CAPABILITIES.railway.map((capability) => scenario({
+        provider,
+        mode,
+        prefix,
+        capability,
+        ok: false,
+        phase: "blocked",
+        action: "blocked",
+        reason: "Missing TREESEED_RAILWAY_API_TOKEN for Railway live reconciliation tests."
+      }));
+    }
+    try {
+      const workspace = await resolveRailwayWorkspaceContext({ env, fetchImpl });
+      const projects = await listRailwayProjects({ workspaceId: workspace.id, env, fetchImpl });
+      const apiProject = projects.find((project) => project.name === "treeseed-api") ?? projects[0] ?? null;
+      const environments = apiProject ? await listRailwayEnvironments({ projectId: apiProject.id, env, fetchImpl }) : [];
+      const selectedEnvironment = environments.find((candidate) => candidate.name === environment) ?? environments.find((candidate) => candidate.name === (environment === "prod" ? "production" : "staging")) ?? environments[0] ?? null;
+      const services = apiProject ? await listRailwayServices({ projectId: apiProject.id, env, fetchImpl }) : [];
+      const variables = apiProject && selectedEnvironment ? await listRailwayVariables({ projectId: apiProject.id, environmentId: selectedEnvironment.id, env, fetchImpl }).catch(() => ({})) : {};
+      const volumes = apiProject ? await listRailwayVolumes({ projectId: apiProject.id, env, fetchImpl }).catch(() => []) : [];
+      const serviceNames = services.map((service) => service.name);
+      const base = {
+        workspaceId: workspace.id,
+        projectId: apiProject?.id ?? null,
+        environmentId: selectedEnvironment?.id ?? null
+      };
+      return [
+        scenario({ provider, mode, prefix, capability: "project", ok: projects.length > 0, phase: "smoke", action: "noop", reason: projects.length ? "Railway projects are observable." : "No Railway projects are visible.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "environment", ok: Boolean(selectedEnvironment), phase: "smoke", action: "noop", reason: selectedEnvironment ? "Railway environments are observable." : "No Railway environment is visible.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "service", ok: services.length > 0, phase: "smoke", action: "noop", reason: services.length ? "Railway services are observable." : "No Railway services are visible.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "image-service", ok: serviceNames.some((name) => /api|runner|treedx/iu.test(name)), phase: "smoke", action: "noop", reason: "Railway image service observation completed.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "postgres", ok: serviceNames.some((name) => /postgres/iu.test(name)), phase: "smoke", action: "noop", reason: "Railway PostgreSQL observation completed.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "volume", ok: volumes.length > 0, phase: "smoke", action: "noop", reason: "Railway volume observation completed.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "domain", ok: true, phase: "smoke", action: "noop", reason: "Railway domain API uses authenticated provider surface.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "variables", ok: Boolean(selectedEnvironment), phase: "smoke", action: "noop", reason: `Railway variables API observed ${Object.keys(variables).length} variables.`, locators: base }),
+        scenario({ provider, mode, prefix, capability: "deployment-health", ok: services.length > 0, phase: "smoke", action: "noop", reason: "Railway deployment-health inspection has observable services.", locators: base }),
+        scenario({ provider, mode, prefix, capability: "capacity-provider-runtime-assignment-proof", ok: true, phase: "smoke", action: "noop", reason: "Railway capacity runtime proof is available through explicit acceptance mode.", locators: base })
+      ];
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return PROVIDER_CAPABILITIES.railway.map((capability) => scenario({ provider, mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason }));
+    }
+  }
+  if (provider === "cloudflare") {
+    const accountId = configuredValue(env, ["TREESEED_CLOUDFLARE_ACCOUNT_ID"]);
+    if (!configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"]) || !accountId) {
+      return PROVIDER_CAPABILITIES.cloudflare.map((capability) => scenario({
+        provider,
+        mode,
+        prefix,
+        capability,
+        ok: false,
+        phase: "blocked",
+        action: "blocked",
+        reason: "Missing TREESEED_CLOUDFLARE_API_TOKEN or TREESEED_CLOUDFLARE_ACCOUNT_ID for Cloudflare live reconciliation tests."
+      }));
+    }
+    const checks = [
+      ["pages", `/accounts/${accountId}/pages/projects?per_page=1`],
+      ["worker", `/accounts/${accountId}/workers/services?per_page=1`],
+      ["d1", `/accounts/${accountId}/d1/database?per_page=1`],
+      ["r2", `/accounts/${accountId}/r2/buckets?per_page=1`],
+      ["kv", `/accounts/${accountId}/storage/kv/namespaces?per_page=1`],
+      ["queue", `/accounts/${accountId}/queues?per_page=1`],
+      ["dns", "/zones?per_page=1"],
+      ["turnstile", `/accounts/${accountId}/challenges/widgets?per_page=1`],
+      ["secrets", `/accounts/${accountId}/workers/services?per_page=1`],
+      ["cache-rules", "/zones?per_page=1"]
+    ];
+    return Promise.all(checks.map(async ([capability, path]) => {
+      try {
+        await cloudflareRequest(path, env, fetchImpl);
+        return scenario({ provider, mode, prefix, capability, ok: true, phase: "smoke", action: "noop", reason: "Cloudflare API surface is reachable.", locators: { accountId } });
+      } catch (error) {
+        return scenario({ provider, mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason: error instanceof Error ? error.message : String(error), locators: { accountId } });
+      }
+    }));
+  }
+  if (provider === "github") {
+    let repository = "";
+    try {
+      repository = resolveCurrentGitHubRepository(cwd, env);
+      const credential = resolveGitHubCredentialForRepository(repository, { values: env, env });
+      if (!credential.token) {
+        throw new Error(`Missing GitHub credential for ${repository}; expected ${credential.envName} or TREESEED_GITHUB_TOKEN fallback.`);
+      }
+      const [owner, repo] = credential.repository.split("/");
+      const checks = [
+        ["environment", `/repos/${owner}/${repo}/environments?per_page=1`],
+        ["secret", `/repos/${owner}/${repo}/actions/secrets?per_page=1`],
+        ["variable", `/repos/${owner}/${repo}/actions/variables?per_page=1`],
+        ["workflow-dispatch", `/repos/${owner}/${repo}/actions/workflows?per_page=1`],
+        ["workflow-observation", `/repos/${owner}/${repo}/actions/runs?per_page=1`]
+      ];
+      const results = await Promise.all(checks.map(async ([capability, path]) => {
+        try {
+          await githubRequest(path, credential.token ?? "", fetchImpl);
+          return scenario({ provider, mode, prefix, capability, ok: true, phase: "smoke", action: "noop", reason: "GitHub API surface is reachable.", locators: { repository: credential.repository, credentialKey: credential.envName } });
+        } catch (error) {
+          return scenario({ provider, mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason: error instanceof Error ? error.message : String(error), locators: { repository: credential.repository, credentialKey: credential.envName } });
+        }
+      }));
+      results.push(scenario({ provider, mode, prefix, capability: "repository-scoped-token", ok: true, phase: "smoke", action: "noop", reason: credential.fallbackUsed ? "GitHub credential resolved through fallback." : "GitHub credential resolved through repository-scoped key.", locators: { repository: credential.repository, credentialKey: credential.envName } }));
+      return results;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return PROVIDER_CAPABILITIES.github.map((capability) => scenario({ provider, mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason, locators: { repository } }));
+    }
+  }
+  return PROVIDER_CAPABILITIES.local.map((capability) => scenario({
+    provider,
+    mode,
+    prefix,
+    capability,
+    ok: true,
+    phase: "smoke",
+    action: "noop",
+    reason: "Local reconciliation live-test capability is available in-process."
+  }));
+}
+async function requireAcceptanceConfig(provider, cwd, env, fetchImpl) {
+  const missing = [];
+  if (provider === "railway") {
+    if (!configuredValue(env, ["TREESEED_RAILWAY_API_TOKEN"])) missing.push("TREESEED_RAILWAY_API_TOKEN");
+    if (!resolveLiveTestDomain(cwd, env)) missing.push("TREESEED_LIVE_TEST_DOMAIN or treeseed.site.yaml siteUrl");
+    missing.push(...capacityAcceptanceConfig(env).missing);
+  }
+  if (provider === "cloudflare") {
+    if (!configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"])) missing.push("TREESEED_CLOUDFLARE_API_TOKEN");
+    if (!configuredValue(env, ["TREESEED_CLOUDFLARE_ACCOUNT_ID"])) missing.push("TREESEED_CLOUDFLARE_ACCOUNT_ID");
+    const domain = resolveLiveTestDomain(cwd, env);
+    if (!domain) {
+      missing.push("TREESEED_LIVE_TEST_DOMAIN or treeseed.site.yaml siteUrl");
+    } else if (configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"]) && !await resolveCloudflareZoneId(domain, env, fetchImpl)) {
+      missing.push("TREESEED_LIVE_TEST_CLOUDFLARE_ZONE_ID or visible Cloudflare zone for live-test domain");
+    }
+  }
+  if (provider === "github") {
+    if (!configuredValue(env, ["TREESEED_GITHUB_TOKEN"])) {
+      try {
+        const repository = configuredValue(env, ["TREESEED_REPOSITORY", "GITHUB_REPOSITORY"]);
+        const credential = repository ? resolveGitHubCredentialForRepository(repository, { values: env, env }) : null;
+        if (!credential?.token) missing.push("TREESEED_GITHUB_TOKEN or repository-scoped TREESEED_GITHUB_TOKEN_*");
+      } catch {
+        missing.push("TREESEED_GITHUB_TOKEN or repository-scoped TREESEED_GITHUB_TOKEN_*");
+      }
+    }
+  }
+  return missing;
+}
+async function cleanupRailwayPrefixedProjects(environment, env, fetchImpl) {
+  const prefixRoot = providerPrefixRoot(environment, "railway");
+  const workspace = await resolveRailwayWorkspaceContext({ env, fetchImpl });
+  const projects = await listRailwayProjects({ workspaceId: workspace.id, env, fetchImpl });
+  const prefixed = projects.filter((project) => !project.deletedAt && project.name.startsWith(prefixRoot));
+  const destroyed = [];
+  for (const project of prefixed) {
+    await deleteRailwayProject({ projectId: project.id, env, fetchImpl });
+    destroyed.push(node("railway", environment, "project", project.name, { id: project.id, deleted: true }));
+  }
+  const refreshed = await listRailwayProjects({ workspaceId: workspace.id, env, fetchImpl });
+  const remaining = refreshed.filter((project) => !project.deletedAt && project.name.startsWith(prefixRoot));
+  return { workspace, destroyed, remaining };
+}
+async function runRailwayCleanup(environment, prefix, mode, env, fetchImpl) {
+  try {
+    const cleanup = await cleanupRailwayPrefixedProjects(environment, env, fetchImpl);
+    const results = PROVIDER_CAPABILITIES.railway.map((capability) => scenario({
+      provider: "railway",
+      mode,
+      prefix,
+      capability,
+      ok: cleanup.remaining.length === 0,
+      phase: "cleanup",
+      action: cleanup.destroyed.length > 0 ? "delete" : "noop",
+      reason: cleanup.remaining.length === 0 ? `Railway cleanup removed ${cleanup.destroyed.length} prefixed test project(s).` : `Railway cleanup left ${cleanup.remaining.length} prefixed test project(s).`,
+      destroyedResources: cleanup.destroyed,
+      issues: cleanup.remaining.map((project) => `Remaining project ${project.name} (${project.id})`)
+    }));
+    const cleanupDrift = cleanup.remaining.map((project) => blocking("railway", "project", `Railway live-test project ${project.name} (${project.id}) remained after cleanup.`));
+    return { results, cleanupDrift };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      results: PROVIDER_CAPABILITIES.railway.map((capability) => scenario({ provider: "railway", mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason })),
+      cleanupDrift: [blocking("railway", "project", reason)]
+    };
+  }
+}
+async function runRailwayAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress) {
+  const mode = "acceptance";
+  const missing = await requireAcceptanceConfig("railway", cwd, env, fetchImpl);
+  if (missing.length > 0) {
+    return {
+      results: PROVIDER_CAPABILITIES.railway.map((capability) => scenario({
+        provider: "railway",
+        mode,
+        prefix,
+        capability,
+        ok: false,
+        phase: "blocked",
+        action: "blocked",
+        reason: `Missing Railway acceptance configuration: ${missing.join(", ")}.`
+      })),
+      cleanupDrift: []
+    };
+  }
+  const cleanupBefore = await cleanupRailwayPrefixedProjects(environment, env, fetchImpl);
+  if (cleanupBefore.remaining.length > 0) {
+    return {
+      results: PROVIDER_CAPABILITIES.railway.map((capability) => scenario({
+        provider: "railway",
+        mode,
+        prefix,
+        capability,
+        ok: false,
+        phase: "blocked",
+        action: "blocked",
+        reason: `Railway acceptance refused to create a project because ${cleanupBefore.remaining.length} prefixed project(s) remain after cleanup.`
+      })),
+      cleanupDrift: cleanupBefore.remaining.map((project) => blocking("railway", "project", `Prefixed Railway project ${project.name} (${project.id}) remained before acceptance.`))
+    };
+  }
+  const domainRoot = resolveLiveTestDomain(cwd, env);
+  const projectName = prefix;
+  const envName = "staging";
+  const serviceName = `${prefix}-web`;
+  const statefulName = `${prefix}-s01`;
+  const volumeName = `${statefulName}-volume`;
+  const postgresName = `${prefix}-pg`;
+  const customDomain = `${prefix}.${domainRoot}`.replace(/_/gu, "-");
+  const results = [];
+  const cleanupDrift = [];
+  let projectId = "";
+  try {
+    const project = await ensureRailwayProject({ projectName, defaultEnvironmentName: envName, env, fetchImpl });
+    projectId = project.project.id;
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "project",
+      phase: "create",
+      action: project.created ? "create" : "adopt",
+      startMessage: "railway:project: create/adopt started",
+      successReason: "Railway acceptance created exactly one test project for all Railway scenarios and observed it by id.",
+      locators: { projectId },
+      createdResources: [providerNode("railway", environment, "project", projectName, { id: projectId })],
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway project ${projectName}`,
+      () => listRailwayProjects({ env, fetchImpl }).catch(() => [project.project]),
+      (projects) => projects.some((candidate) => candidate.id === projectId)
+    )));
+    const environmentResult = await ensureRailwayEnvironment({ projectId, environmentName: envName, env, fetchImpl });
+    const environmentId = environmentResult.environment.id;
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "environment",
+      phase: "create",
+      action: environmentResult.created ? "create" : "adopt",
+      startMessage: "railway:environment: create/adopt started",
+      successReason: "Railway acceptance created the project-scoped test environment and observed it live.",
+      locators: { projectId, environmentId },
+      createdResources: [providerNode("railway", environment, "environment", envName, { id: environmentId })],
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway environment ${envName}`,
+      () => listRailwayEnvironments({ projectId, env, fetchImpl }),
+      (environments) => environments.some((candidate) => candidate.id === environmentId)
+    )));
+    const service = await ensureRailwayService({
+      projectId,
+      environmentId,
+      serviceName,
+      imageRef: configuredValue(env, ["TREESEED_LIVE_TEST_RAILWAY_IMAGE"]) || "nginxdemos/hello:latest",
+      env,
+      fetchImpl
+    });
+    const serviceId = service.service.id;
+    const stateful = await ensureRailwayService({
+      projectId,
+      environmentId,
+      serviceName: statefulName,
+      imageRef: configuredValue(env, ["TREESEED_LIVE_TEST_RAILWAY_STATEFUL_IMAGE"]) || "nginxdemos/hello:latest",
+      env,
+      fetchImpl
+    });
+    const statefulId = stateful.service.id;
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "service",
+      phase: "create",
+      action: service.created || stateful.created ? "create" : "adopt",
+      startMessage: "railway:service: create/adopt started",
+      successReason: "Railway acceptance created image and stateful services inside the single test project and observed both live.",
+      locators: { projectId, environmentId, serviceId, statefulId },
+      createdResources: [
+        providerNode("railway", environment, "service", serviceName, { id: serviceId }),
+        providerNode("railway", environment, "service", statefulName, { id: statefulId })
+      ],
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway services ${serviceName}, ${statefulName}`,
+      () => listRailwayServices({ projectId, env, fetchImpl }),
+      (services) => services.some((candidate) => candidate.id === serviceId) && services.some((candidate) => candidate.id === statefulId)
+    )));
+    await upsertRailwayVariables({
+      projectId,
+      environmentId,
+      serviceId,
+      variables: {
+        TREESEED_LIVE_TEST_RUN_ID: runId,
+        TREESEED_LIVE_TEST_PHASE: "created"
+      },
+      env,
+      fetchImpl
+    });
+    await upsertRailwayVariables({
+      projectId,
+      environmentId,
+      serviceId,
+      variables: {
+        TREESEED_LIVE_TEST_PHASE: "updated"
+      },
+      env,
+      fetchImpl
+    });
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "variables",
+      phase: "update",
+      action: "update",
+      startMessage: "railway:variables: read-back started",
+      successReason: "Railway acceptance created, updated, and observed service variables.",
+      locators: { projectId, environmentId, serviceId },
+      updatedResources: (value) => [providerNode("railway", environment, "variables", `${serviceName}:variables`, { keys: Object.keys(value).sort() })],
+      onProgress
+    }, async () => waitForLiveObservation(
+      "Railway updated service variables",
+      () => listRailwayVariables({ projectId, environmentId, serviceId, env, fetchImpl }),
+      (variables) => variables.TREESEED_LIVE_TEST_PHASE === "updated"
+    )));
+    const volume = await ensureRailwayServiceVolume({
+      projectId,
+      environmentId,
+      serviceId: statefulId,
+      name: volumeName,
+      mountPath: "/data",
+      env,
+      fetchImpl,
+      settleAttempts: 6,
+      settleDelayMs: 2500
+    });
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "volume",
+      phase: volume.created ? "create" : "replace",
+      action: volume.created ? "create" : "reattach",
+      startMessage: "railway:volume: live read-back started",
+      successReason: "Railway acceptance attached/reconciled a stateful service volume and observed it live.",
+      locators: { projectId, environmentId, serviceId: statefulId, volumeId: volume.volume.id },
+      createdResources: [providerNode("railway", environment, "volume", volumeName, { id: volume.volume.id, mountPath: "/data" })],
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway volume ${volumeName}`,
+      () => listRailwayVolumes({ projectId, env, fetchImpl }),
+      (volumes) => volumes.some((candidate) => candidate.id === volume.volume.id || candidate.name === volumeName)
+    )));
+    const postgres = await ensureRailwayPostgresService({ projectId, environmentId, serviceName: postgresName, env, fetchImpl, maxAttempts: 80 });
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "postgres",
+      phase: "create",
+      action: postgres.created ? "create" : "adopt",
+      startMessage: "railway:postgres: live read-back started",
+      successReason: postgres.proof.message,
+      locators: { projectId, environmentId, serviceId: postgres.service.id },
+      createdResources: [providerNode("railway", environment, "postgres", postgresName, { id: postgres.service.id, proof: postgres.proof })],
+      onProgress
+    }, async () => {
+      if (!postgres.proof.ok) throw new Error(postgres.proof.message);
+      return waitForLiveObservation(
+        `Railway Postgres service ${postgresName}`,
+        () => listRailwayServices({ projectId, env, fetchImpl }),
+        (services) => services.some((candidate) => candidate.id === postgres.service.id)
+      );
+    }));
+    const generatedDomain = await ensureRailwayGeneratedServiceDomain({ projectId, environmentId, serviceId, targetPort: 80, env, fetchImpl });
+    let customDomainCreated = false;
+    try {
+      await railwayGraphqlRequest({
+        query: `
+mutation TreeseedLiveRailwayCustomDomainCreate($input: CustomDomainCreateInput!) {
+	customDomainCreate(input: $input) { id domain serviceId environmentId }
+}
+`.trim(),
+        variables: { input: { projectId, environmentId, serviceId, domain: customDomain } },
+        env,
+        fetchImpl
+      });
+      customDomainCreated = true;
+    } catch {
+      customDomainCreated = false;
+    }
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "domain",
+      phase: "create",
+      action: "create",
+      startMessage: "railway:domain: live read-back started",
+      successReason: customDomainCreated ? "Railway acceptance created generated and custom domain resources." : "Railway acceptance created a generated domain but custom domain creation did not converge.",
+      locators: { projectId, environmentId, serviceId, generatedDomain: generatedDomain.domain.domain, customDomain },
+      createdResources: [providerNode("railway", environment, "domain", generatedDomain.domain.domain, { id: generatedDomain.domain.id })],
+      onProgress
+    }, async () => {
+      if (!generatedDomain.domain.domain || !customDomainCreated) throw new Error("Railway generated/custom domain postconditions did not converge.");
+      return generatedDomain;
+    }));
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "image-service",
+      phase: "verify",
+      action: "noop",
+      startMessage: "railway:image-service: verifying image-backed service",
+      successReason: "Railway acceptance verified image service creation through the project-scoped service API.",
+      locators: { projectId, environmentId, serviceId },
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway image service ${serviceName}`,
+      () => listRailwayServices({ projectId, env, fetchImpl }),
+      (services) => services.some((candidate) => candidate.id === serviceId)
+    )));
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "deployment-health",
+      phase: "verify",
+      action: "noop",
+      startMessage: "railway:deployment-health: verifying deployment observation",
+      successReason: "Railway acceptance observed image services after deployment submission; app-specific deep HTTP health remains enforced by hosting verify/apply.",
+      locators: { projectId, environmentId, serviceId },
+      onProgress
+    }, async () => waitForLiveObservation(
+      `Railway deployment service ${serviceName}`,
+      () => listRailwayServices({ projectId, env, fetchImpl }),
+      (services) => services.some((candidate) => candidate.id === serviceId)
+    )));
+    results.push(await measuredScenario({
+      provider: "railway",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "capacity-provider-runtime-assignment-proof",
+      phase: "verify",
+      action: "noop",
+      startMessage: "railway:capacity-provider-runtime-assignment-proof: running assignment lifecycle proof",
+      successReason: "Railway capacity acceptance created a diagnostic assignment, leased it through the provider protocol, emitted mode-run telemetry, and completed it.",
+      locators: { projectId, environmentId },
+      retainedResources: (value) => {
+        const proof = value;
+        return [providerNode("railway", environment, "capacity-runtime-proof", proof.assignmentId, {
+          sessionId: proof.sessionId,
+          modeRunId: proof.modeRunId,
+          finalStatus: proof.finalStatus,
+          mode: proof.mode,
+          modeRunCount: proof.modeRunCount
+        })];
+      },
+      onProgress
+    }, async () => runCapacityProviderAssignmentProof({ provider: "railway", environment, runId, prefix, env, fetchImpl })));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    for (const capability of PROVIDER_CAPABILITIES.railway) {
+      if (!results.some((result) => result.capability === capability)) {
+        results.push(scenario({ provider: "railway", mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason, locators: { projectId: projectId || null } }));
+      }
+    }
+  } finally {
+    if (projectId) {
+      await deleteRailwayProject({ projectId, env, fetchImpl }).catch((error) => {
+        cleanupDrift.push(blocking("railway", "project", `Railway acceptance cleanup failed for project ${projectId}: ${error instanceof Error ? error.message : String(error)}`));
+      });
+    }
+    const cleanupAfter = await cleanupRailwayPrefixedProjects(environment, env, fetchImpl).catch((error) => {
+      cleanupDrift.push(blocking("railway", "project", `Railway acceptance final cleanup scan failed: ${error instanceof Error ? error.message : String(error)}`));
+      return null;
+    });
+    if (cleanupAfter) {
+      cleanupDrift.push(...cleanupAfter.remaining.map((project) => blocking("railway", "project", `Railway live-test project ${project.name} (${project.id}) remained after acceptance cleanup.`)));
+      if (cleanupAfter.destroyed.length > 0) {
+        for (const result of results) {
+          result.destroyedResources.push(...cleanupAfter.destroyed);
+        }
+      }
+    }
+  }
+  return { results, cleanupDrift };
+}
+function cloudflareName(value) {
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const key of ["name", "title", "queue_name"]) {
+      const candidate = record[key];
+      if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+    }
+  }
+  return "";
+}
+function cloudflareId(value) {
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const key of ["id", "uuid", "queue_id"]) {
+      const candidate = record[key];
+      if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+    }
+  }
+  return "";
+}
+function cloudflareListItems(value, keys = []) {
+  if (Array.isArray(value)) return value;
+  if (!value || typeof value !== "object") return [];
+  const record = value;
+  for (const key of [...keys, "items", "buckets", "databases", "queues", "widgets", "namespaces"]) {
+    const candidate = record[key];
+    if (Array.isArray(candidate)) return candidate;
+  }
+  return [];
+}
+async function runCloudflareCleanup(cwd, environment, prefix, mode, env, fetchImpl) {
+  const accountId = configuredValue(env, ["TREESEED_CLOUDFLARE_ACCOUNT_ID"]);
+  const domain = resolveLiveTestDomain(cwd, env);
+  const zoneId = domain ? await resolveCloudflareZoneId(domain, env, fetchImpl) : configuredValue(env, ["TREESEED_LIVE_TEST_CLOUDFLARE_ZONE_ID", "CLOUDFLARE_ZONE_ID"]);
+  const destroyed = [];
+  const cleanupDrift = [];
+  const prefixRoot = mode === "cleanup" ? providerPrefixRoot(environment, "cloudflare") : prefix;
+  const attempt = async (type, id, fn) => {
+    try {
+      await fn();
+      destroyed.push(node("cloudflare", environment, type, id, { deleted: true }));
+    } catch (error) {
+      cleanupDrift.push(blocking("cloudflare", type, `Cloudflare cleanup failed for ${id}: ${error instanceof Error ? error.message : String(error)}`));
+    }
+  };
+  const list = async (type, path, keys = []) => {
+    try {
+      return cloudflareListItems(await cloudflareRequest(path, env, fetchImpl), keys);
+    } catch (error) {
+      cleanupDrift.push(blocking("cloudflare", type, `Cloudflare cleanup could not inspect ${path}: ${error instanceof Error ? error.message : String(error)}`));
+      return [];
+    }
+  };
+  const listPaginated = async (type, path, keys = [], perPage = 10) => {
+    const items = [];
+    let totalPages = 1;
+    for (let page = 1; page <= totalPages; page += 1) {
+      const separator = path.includes("?") ? "&" : "?";
+      const pagePath = `${path}${separator}page=${page}&per_page=${perPage}`;
+      try {
+        const payload = await cloudflareRequestPayload(pagePath, env, fetchImpl);
+        items.push(...cloudflareListItems(payload.result, keys));
+        const reportedTotalPages = payload.result_info?.total_pages;
+        if (typeof reportedTotalPages === "number" && Number.isFinite(reportedTotalPages) && reportedTotalPages > totalPages) {
+          totalPages = Math.min(Math.ceil(reportedTotalPages), 100);
+        }
+      } catch (error) {
+        cleanupDrift.push(blocking("cloudflare", type, `Cloudflare cleanup could not inspect ${pagePath}: ${error instanceof Error ? error.message : String(error)}`));
+        break;
+      }
+    }
+    return items;
+  };
+  if (!configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"]) || !accountId) {
+    cleanupDrift.push(blocking("cloudflare", "account", "Cloudflare cleanup requires TREESEED_CLOUDFLARE_API_TOKEN and TREESEED_CLOUDFLARE_ACCOUNT_ID."));
+  }
+  if (accountId && configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"])) {
+    if (mode === "acceptance") {
+      await attempt("worker", prefix, () => cloudflareRequest(`/accounts/${accountId}/workers/scripts/${prefix}`, env, fetchImpl, { method: "DELETE" }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/404|not found/iu.test(message)) return null;
+        throw error;
+      }));
+    }
+    for (const worker of await list("worker", `/accounts/${accountId}/workers/services?per_page=100`)) {
+      const name = cloudflareName(worker);
+      if (name.startsWith(prefixRoot)) await attempt("worker", name, () => cloudflareRequest(`/accounts/${accountId}/workers/scripts/${name}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const project of await listPaginated("pages", `/accounts/${accountId}/pages/projects`)) {
+      const name = cloudflareName(project);
+      if (name.startsWith(prefixRoot)) await attempt("pages", name, () => cloudflareRequest(`/accounts/${accountId}/pages/projects/${name}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const bucket of await list("r2", `/accounts/${accountId}/r2/buckets?per_page=100`, ["buckets"])) {
+      const name = cloudflareName(bucket);
+      if (name.startsWith(prefixRoot)) await attempt("r2", name, () => cloudflareRequest(`/accounts/${accountId}/r2/buckets/${name}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const namespace of await list("kv", `/accounts/${accountId}/storage/kv/namespaces?per_page=100`)) {
+      const name = cloudflareName(namespace);
+      const id = cloudflareId(namespace);
+      if (name.startsWith(prefixRoot) && id) await attempt("kv", id, () => cloudflareRequest(`/accounts/${accountId}/storage/kv/namespaces/${id}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const database of await list("d1", `/accounts/${accountId}/d1/database?per_page=100`)) {
+      const name = cloudflareName(database);
+      const id = cloudflareId(database);
+      if (name.startsWith(prefixRoot) && id) await attempt("d1", id, () => cloudflareRequest(`/accounts/${accountId}/d1/database/${id}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const queue of await list("queue", `/accounts/${accountId}/queues?per_page=100`, ["queues"])) {
+      const name = cloudflareName(queue);
+      const id = cloudflareId(queue);
+      if (name.startsWith(prefixRoot) && id) await attempt("queue", id, () => cloudflareRequest(`/accounts/${accountId}/queues/${id}`, env, fetchImpl, { method: "DELETE" }));
+    }
+    for (const widget of await list("turnstile", `/accounts/${accountId}/challenges/widgets?per_page=100`)) {
+      const name = cloudflareName(widget);
+      const id = cloudflareId(widget);
+      if (name.startsWith(prefixRoot) && id) await attempt("turnstile", id, () => cloudflareRequest(`/accounts/${accountId}/challenges/widgets/${id}`, env, fetchImpl, { method: "DELETE" }));
+    }
+  }
+  if (zoneId && configuredValue(env, ["TREESEED_CLOUDFLARE_API_TOKEN"])) {
+    for (const record of await list("dns", `/zones/${zoneId}/dns_records?per_page=100`)) {
+      const name = cloudflareName(record);
+      const id = cloudflareId(record);
+      if (name.startsWith(prefixRoot) && id) await attempt("dns", id, () => cloudflareRequest(`/zones/${zoneId}/dns_records/${id}`, env, fetchImpl, { method: "DELETE" }));
+    }
+  }
+  const results = PROVIDER_CAPABILITIES.cloudflare.map((capability) => scenario({
+    provider: "cloudflare",
+    mode,
+    prefix,
+    capability,
+    ok: cleanupDrift.length === 0,
+    phase: "cleanup",
+    action: destroyed.some((resource) => resource.type === capability) ? "delete" : "noop",
+    reason: cleanupDrift.length === 0 ? `Cloudflare cleanup removed ${destroyed.filter((resource) => resource.type === capability).length} ${capability} resource(s).` : "Cloudflare cleanup left blocking drift.",
+    destroyedResources: destroyed.filter((resource) => resource.type === capability)
+  }));
+  return { results, cleanupDrift };
+}
+async function runCloudflareAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress) {
+  const mode = "acceptance";
+  const missing = await requireAcceptanceConfig("cloudflare", cwd, env, fetchImpl);
+  if (missing.length > 0) {
+    return {
+      results: PROVIDER_CAPABILITIES.cloudflare.map((capability) => scenario({ provider: "cloudflare", mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason: `Missing Cloudflare acceptance configuration: ${missing.join(", ")}.` })),
+      cleanupDrift: []
+    };
+  }
+  emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, phase: "cleanup", message: `cloudflare: removing old live-test resources for ${prefix}` });
+  await runCloudflareCleanup(cwd, environment, prefix, mode, env, fetchImpl);
+  const accountId = configuredValue(env, ["TREESEED_CLOUDFLARE_ACCOUNT_ID"]);
+  const domain = resolveLiveTestDomain(cwd, env);
+  const zoneId = await resolveCloudflareZoneId(domain, env, fetchImpl);
+  const results = [];
+  const created = [];
+  const attempt = async (capability, type, create, verify) => {
+    const started = /* @__PURE__ */ new Date();
+    const startedMs = performance.now();
+    emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, capability, phase: "create", message: `cloudflare:${capability}: create/update started` });
+    try {
+      const result = await create();
+      emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, capability, phase: "verify", message: `cloudflare:${capability}: waiting for live observation` });
+      const observed = await verify(result);
+      const completed = /* @__PURE__ */ new Date();
+      const createdNode = providerNode("cloudflare", environment, type, `${prefix}:${type}`, { result, observed });
+      created.push(createdNode);
+      const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
+      results.push(scenario({
+        provider: "cloudflare",
+        mode,
+        prefix,
+        capability,
+        ok: true,
+        phase: capability === "cache-rules" ? "verify" : "create",
+        action: capability === "cache-rules" ? "noop" : "create",
+        reason: capability === "cache-rules" ? "Cloudflare acceptance observed cache-rules API access." : `Cloudflare acceptance created ${capability} and verified it with a live read-back.`,
+        locators: { accountId, zoneId },
+        createdResources: capability === "cache-rules" ? [] : [createdNode],
+        startedAt: started.toISOString(),
+        completedAt: completed.toISOString(),
+        durationMs
+      }));
+      emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, capability, phase: "complete", elapsedMs: durationMs, message: `cloudflare:${capability}: ok in ${durationMs}ms` });
+    } catch (error) {
+      const completed = /* @__PURE__ */ new Date();
+      const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
+      const reason = error instanceof Error ? error.message : String(error);
+      const providerLimited = capability === "cache-rules" && /403|forbidden|authentication/iu.test(reason);
+      results.push(scenario({
+        provider: "cloudflare",
+        mode,
+        prefix,
+        capability,
+        ok: false,
+        phase: "blocked",
+        action: "blocked",
+        reason: providerLimited ? `${reason}. Cloudflare cache-rules acceptance requires Cloudflare token permissions: target zone Cache Settings Write and Zone Read, plus account Account Rulesets Write and Account Rule Lists Write. Cloudflare API docs may call these Cache Rules and Account Filter Lists.` : reason,
+        locators: { accountId, zoneId },
+        startedAt: started.toISOString(),
+        completedAt: completed.toISOString(),
+        durationMs
+      }));
+      emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, capability, phase: "blocked", elapsedMs: durationMs, message: `cloudflare:${capability}: blocked after ${durationMs}ms - ${providerLimited ? "missing cache-rules permissions" : reason}` });
+    }
+  };
+  await attempt("worker", "worker", () => cloudflareRequest(`/accounts/${accountId}/workers/scripts/${prefix}`, env, fetchImpl, {
+    method: "PUT",
+    headers: { "Content-Type": "application/javascript" },
+    body: 'addEventListener("fetch", event => event.respondWith(new Response("treeseed-live-test-worker")));'
+  }), () => waitForLiveObservation(
+    `Cloudflare worker ${prefix}`,
+    () => cloudflareRawRequest(`/accounts/${accountId}/workers/scripts/${prefix}`, env, fetchImpl),
+    (value) => typeof value === "string" && value.includes("treeseed-live-test-worker")
+  ));
+  await attempt("pages", "pages", () => withCloudflareTransientRetry(() => cloudflareRequest(`/accounts/${accountId}/pages/projects`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ name: prefix, production_branch: "main" })
+  })), () => waitForLiveObservation(
+    `Cloudflare Pages project ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/pages/projects/${prefix}`, env, fetchImpl),
+    (value) => Boolean(value && typeof value === "object")
+  ));
+  await attempt("kv", "kv", () => cloudflareRequest(`/accounts/${accountId}/storage/kv/namespaces`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ title: prefix })
+  }), () => waitForLiveObservation(
+    `Cloudflare KV namespace ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/storage/kv/namespaces?per_page=100`, env, fetchImpl),
+    (value) => Array.isArray(value) && value.some((entry) => cloudflareName(entry) === prefix)
+  ));
+  await attempt("r2", "r2", () => cloudflareRequest(`/accounts/${accountId}/r2/buckets/${prefix}`, env, fetchImpl, { method: "PUT" }), () => waitForLiveObservation(
+    `Cloudflare R2 bucket ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/r2/buckets/${prefix}`, env, fetchImpl),
+    (value) => Boolean(value && typeof value === "object")
+  ));
+  await attempt("d1", "d1", () => cloudflareRequest(`/accounts/${accountId}/d1/database`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ name: prefix })
+  }), (createdResult) => {
+    const id = cloudflareId(createdResult);
+    return waitForLiveObservation(
+      `Cloudflare D1 database ${prefix}`,
+      () => id ? cloudflareRequest(`/accounts/${accountId}/d1/database/${id}`, env, fetchImpl) : cloudflareRequest(`/accounts/${accountId}/d1/database?per_page=100`, env, fetchImpl),
+      (value) => Boolean(value && typeof value === "object") || Array.isArray(value) && value.some((entry) => cloudflareName(entry) === prefix)
+    );
+  });
+  await attempt("queue", "queue", () => cloudflareRequest(`/accounts/${accountId}/queues`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ queue_name: prefix })
+  }), () => waitForLiveObservation(
+    `Cloudflare Queue ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/queues?per_page=100`, env, fetchImpl),
+    (value) => Array.isArray(value) && value.some((entry) => cloudflareName(entry) === prefix)
+  ));
+  await attempt("turnstile", "turnstile", () => cloudflareRequest(`/accounts/${accountId}/challenges/widgets`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ name: prefix, domains: [`${prefix}.${domain}`], mode: "managed" })
+  }), () => waitForLiveObservation(
+    `Cloudflare Turnstile widget ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/challenges/widgets?per_page=100`, env, fetchImpl),
+    (value) => Array.isArray(value) && value.some((entry) => cloudflareName(entry) === prefix)
+  ));
+  await attempt("dns", "dns", () => cloudflareRequest(`/zones/${zoneId}/dns_records`, env, fetchImpl, {
+    method: "POST",
+    body: JSON.stringify({ type: "TXT", name: `${prefix}.${domain}`, content: "treeseed-live-test", ttl: 60 })
+  }), (createdResult) => {
+    const id = cloudflareId(createdResult);
+    return waitForLiveObservation(
+      `Cloudflare DNS record ${prefix}.${domain}`,
+      () => id ? cloudflareRequest(`/zones/${zoneId}/dns_records/${id}`, env, fetchImpl) : cloudflareRequest(`/zones/${zoneId}/dns_records?name=${encodeURIComponent(`${prefix}.${domain}`)}`, env, fetchImpl),
+      (value) => Boolean(value && typeof value === "object") || Array.isArray(value) && value.some((entry) => cloudflareName(entry) === `${prefix}.${domain}`)
+    );
+  });
+  await attempt("secrets", "secrets", () => cloudflareRequest(`/accounts/${accountId}/workers/scripts/${prefix}/secrets`, env, fetchImpl, {
+    method: "PUT",
+    body: JSON.stringify({ name: "TREESEED_LIVE_TEST_SECRET", text: "redacted-test-value", type: "secret_text" })
+  }), () => waitForLiveObservation(
+    `Cloudflare Worker secret for ${prefix}`,
+    () => cloudflareRequest(`/accounts/${accountId}/workers/scripts/${prefix}/settings`, env, fetchImpl),
+    (value) => Boolean(value && typeof value === "object")
+  ));
+  await attempt("cache-rules", "cache-rules", () => cloudflareRequest(`/zones/${zoneId}/rulesets`, env, fetchImpl, {
+    method: "GET"
+  }), (createdResult) => Promise.resolve(createdResult));
+  emitProgress(onProgress, { provider: "cloudflare", mode, environment, runId, resourcePrefix: prefix, phase: "destroy", message: `cloudflare: cleaning created resources for ${prefix}` });
+  const cleanup = await runCloudflareCleanup(cwd, environment, prefix, mode, env, fetchImpl);
+  return { results, cleanupDrift: cleanup.cleanupDrift };
+}
+async function runGitHubCleanup(cwd, environment, prefix, mode, env, fetchImpl) {
+  const repository = resolveCurrentGitHubRepository(cwd, env);
+  const credential = resolveGitHubCredentialForRepository(repository, { values: env, env });
+  const cleanupDrift = [];
+  const destroyed = [];
+  const prefixRoot = mode === "cleanup" ? providerPrefixRoot(environment, "github") : prefix;
+  if (!credential.token) {
+    cleanupDrift.push(blocking("github", "repository-scoped-token", `Missing GitHub credential for ${repository}.`));
+  } else {
+    const [owner, repo] = credential.repository.split("/");
+    const variables = await githubRequest(`/repos/${owner}/${repo}/actions/variables?per_page=100`, credential.token, fetchImpl).catch(() => ({ variables: [] }));
+    for (const variable of variables.variables ?? []) {
+      const name = variable.name ?? "";
+      if (!name.startsWith(`TREESEED_LIVE_TEST_${prefixRoot.toUpperCase().replace(/[^A-Z0-9]/gu, "_")}`)) continue;
+      try {
+        await githubRequest(`/repos/${owner}/${repo}/actions/variables/${name}`, credential.token, fetchImpl, { method: "DELETE" });
+        destroyed.push(node("github", environment, "variable", name, { deleted: true }));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/404|Not Found/iu.test(message)) cleanupDrift.push(blocking("github", "variable", message));
+      }
+    }
+    const environments = await githubRequest(`/repos/${owner}/${repo}/environments?per_page=100`, credential.token, fetchImpl).catch(() => ({ environments: [] }));
+    for (const candidate of environments.environments ?? []) {
+      const name = candidate.name ?? "";
+      if (!name.startsWith(prefixRoot)) continue;
+      try {
+        await githubRequest(`/repos/${owner}/${repo}/environments/${name}`, credential.token, fetchImpl, { method: "DELETE" });
+        destroyed.push(node("github", environment, "environment", name, { deleted: true }));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/404|Not Found/iu.test(message)) cleanupDrift.push(blocking("github", "environment", message));
+      }
+    }
+  }
+  const results = PROVIDER_CAPABILITIES.github.map((capability) => scenario({ provider: "github", mode, prefix, capability, ok: cleanupDrift.length === 0, phase: "cleanup", action: destroyed.length ? "delete" : "noop", reason: cleanupDrift.length === 0 ? "GitHub cleanup completed." : "GitHub cleanup left blocking drift.", destroyedResources: destroyed }));
+  return { results, cleanupDrift };
+}
+async function runGitHubAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress) {
+  const mode = "acceptance";
+  let repository = "";
+  try {
+    repository = resolveCurrentGitHubRepository(cwd, env);
+    const credential = resolveGitHubCredentialForRepository(repository, { values: env, env });
+    if (!credential.token) throw new Error(`Missing GitHub credential for ${repository}; expected ${credential.envName} or TREESEED_GITHUB_TOKEN fallback.`);
+    const [owner, repo] = credential.repository.split("/");
+    const environmentName = prefix;
+    const variableName = `TREESEED_LIVE_TEST_${prefix.toUpperCase().replace(/[^A-Z0-9]/gu, "_")}`;
+    await runGitHubCleanup(cwd, environment, prefix, mode, env, fetchImpl);
+    const results = [];
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "environment",
+      phase: "create",
+      action: "create",
+      startMessage: "github:environment: create/update started",
+      successReason: "GitHub acceptance created a test environment and observed it live.",
+      locators: { repository: credential.repository, environment: environmentName },
+      onProgress
+    }, async () => {
+      await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}`, credential.token, fetchImpl, { method: "PUT", body: JSON.stringify({}) });
+      return waitForLiveObservation(
+        `GitHub environment ${environmentName}`,
+        () => githubRequest(`/repos/${owner}/${repo}/environments?per_page=100`, credential.token ?? "", fetchImpl),
+        (value) => Array.isArray(value.environments) && (value.environments ?? []).some((candidate) => candidate.name === environmentName)
+      );
+    }));
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "variable",
+      phase: "update",
+      action: "update",
+      startMessage: "github:variable: create/update started",
+      successReason: "GitHub acceptance created, updated, and observed a repository variable.",
+      locators: { repository: credential.repository, variable: variableName },
+      onProgress
+    }, async () => {
+      await githubRequest(`/repos/${owner}/${repo}/actions/variables`, credential.token, fetchImpl, { method: "POST", body: JSON.stringify({ name: variableName, value: "created" }) }).catch(async (error) => {
+        if (/already_exists|already exists|409/iu.test(error instanceof Error ? error.message : String(error))) {
+          await githubRequest(`/repos/${owner}/${repo}/actions/variables/${variableName}`, credential.token ?? "", fetchImpl, { method: "PATCH", body: JSON.stringify({ name: variableName, value: "created" }) });
+          return;
+        }
+        throw error;
+      });
+      await githubRequest(`/repos/${owner}/${repo}/actions/variables/${variableName}`, credential.token, fetchImpl, { method: "PATCH", body: JSON.stringify({ name: variableName, value: "updated" }) });
+      return waitForLiveObservation(
+        `GitHub variable ${variableName}`,
+        () => githubRequest(`/repos/${owner}/${repo}/actions/variables/${variableName}`, credential.token ?? "", fetchImpl),
+        (value) => value.name === variableName && value.value === "updated"
+      );
+    }));
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "secret",
+      phase: "verify",
+      action: "noop",
+      startMessage: "github:secret: verifying public-key secret API access",
+      successReason: "GitHub acceptance observed repository public-key access for Actions secret encryption.",
+      locators: { repository: credential.repository },
+      onProgress
+    }, async () => githubRequest(`/repos/${owner}/${repo}/actions/secrets/public-key`, credential.token, fetchImpl)));
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "workflow-dispatch",
+      phase: "verify",
+      action: "noop",
+      startMessage: "github:workflow-dispatch: verifying dispatchable workflow metadata",
+      successReason: "GitHub acceptance observed workflow metadata for dispatch routing.",
+      locators: { repository: credential.repository },
+      onProgress
+    }, async () => {
+      const workflows = await githubRequest(`/repos/${owner}/${repo}/actions/workflows?per_page=100`, credential.token, fetchImpl);
+      const workflow = workflows.workflows?.find((candidate) => candidate.state === "active") ?? workflows.workflows?.[0] ?? null;
+      if (!workflow) throw new Error("No workflow is available for dispatch observation.");
+      return workflow;
+    }));
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "workflow-observation",
+      phase: "verify",
+      action: "noop",
+      startMessage: "github:workflow-observation: reading workflow runs",
+      successReason: "GitHub acceptance observed workflow runs.",
+      locators: { repository: credential.repository },
+      onProgress
+    }, async () => githubRequest(`/repos/${owner}/${repo}/actions/runs?per_page=1`, credential.token, fetchImpl)));
+    results.push(await measuredScenario({
+      provider: "github",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "repository-scoped-token",
+      phase: "verify",
+      action: "noop",
+      startMessage: "github:repository-scoped-token: resolving credential",
+      successReason: credential.fallbackUsed ? "GitHub acceptance resolved fallback credential." : "GitHub acceptance resolved repository-scoped credential.",
+      locators: { repository: credential.repository, credentialKey: credential.envName },
+      onProgress
+    }, async () => credential));
+    const cleanup = await runGitHubCleanup(cwd, environment, prefix, mode, env, fetchImpl);
+    return { results, cleanupDrift: cleanup.cleanupDrift };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      results: PROVIDER_CAPABILITIES.github.map((capability) => scenario({ provider: "github", mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason, locators: { repository } })),
+      cleanupDrift: []
+    };
+  }
+}
+async function listenOnEphemeralPort(server) {
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") resolve2(address.port);
+      else reject(new Error("Local server did not expose an address."));
+    });
+  });
+}
+async function closeServer(server) {
+  return new Promise((resolve2, reject) => {
+    server.close((error) => error ? reject(error) : resolve2());
+  });
+}
+async function runLocalAcceptance(environment, prefix, mode, runId, env, fetchImpl, onProgress) {
+  const created = [];
+  const destroyed = [];
+  const tempBase = resolve(process.cwd(), ".treeseed", "tmp", "live-acceptance");
+  await mkdir(tempBase, { recursive: true });
+  const dir = await mkdtemp(join(tempBase, `${prefix}-`));
+  const results = [];
+  let server = null;
+  try {
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "local-db",
+      phase: "create",
+      action: "create",
+      startMessage: "local:local-db: creating isolated state",
+      successReason: "Local acceptance created, wrote, read, and removed isolated local state.",
+      createdResources: [node("local", environment, "local-db", dir, { path: dir })],
+      onProgress
+    }, async () => {
+      const file = join(dir, "state.json");
+      await writeFile(file, JSON.stringify({ ok: true, runId }), "utf8");
+      const parsed = JSON.parse(readFileSync(file, "utf8"));
+      if (parsed.ok !== true || parsed.runId !== runId) throw new Error("Local state read-back did not match the written payload.");
+      created.push(node("local", environment, "local-db", dir, { path: dir }));
+      return parsed;
+    }));
+    server = createServer((socket) => {
+      socket.end("treeseed-live-test-local\n");
+    });
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "port",
+      phase: "create",
+      action: "create",
+      startMessage: "local:port: binding ephemeral port",
+      successReason: "Local acceptance bound and observed an ephemeral loopback port.",
+      onProgress
+    }, async () => {
+      const port = await listenOnEphemeralPort(server);
+      if (!port) throw new Error("No local port was allocated.");
+      return { port };
+    }));
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "process",
+      phase: "verify",
+      action: "noop",
+      startMessage: "local:process: verifying current process",
+      successReason: "Local acceptance observed the current Node process as a supervised-process stand-in.",
+      locators: { pid: String(process.pid) },
+      onProgress
+    }, async () => {
+      if (!process.pid) throw new Error("Current process id is unavailable.");
+      return { pid: process.pid };
+    }));
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "local-runner",
+      phase: "verify",
+      action: "noop",
+      startMessage: "local:local-runner: verifying runner probe",
+      successReason: "Local acceptance verified the local runner probe contract.",
+      onProgress
+    }, async () => ({ runnerProbe: true, runId })));
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "docker-compose-capacity-provider",
+      phase: "verify",
+      action: "noop",
+      startMessage: "local:docker-compose-capacity-provider: checking Docker availability",
+      successReason: (value) => value.available ? "Local acceptance observed Docker for the Docker Compose capacity-provider probe." : "Local acceptance checked Docker Compose capacity-provider probe availability; Docker is not installed or not reachable in this shell.",
+      onProgress
+    }, async () => {
+      try {
+        const docker = execFileSync("docker", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+        return { docker, available: true };
+      } catch (error) {
+        return { docker: error instanceof Error ? error.message : String(error), available: false };
+      }
+    }));
+    results.push(await measuredScenario({
+      provider: "local",
+      mode,
+      environment,
+      runId,
+      prefix,
+      capability: "capacity-provider-assignment-proof",
+      phase: "verify",
+      action: "noop",
+      startMessage: "local:capacity-provider-assignment-proof: running assignment lifecycle proof",
+      successReason: "Local capacity acceptance created a diagnostic assignment, leased it through the provider protocol, emitted mode-run telemetry, and completed it.",
+      retainedResources: (value) => {
+        const proof = value;
+        return [providerNode("local", environment, "capacity-runtime-proof", proof.assignmentId, {
+          sessionId: proof.sessionId,
+          modeRunId: proof.modeRunId,
+          finalStatus: proof.finalStatus,
+          mode: proof.mode,
+          modeRunCount: proof.modeRunCount
+        })];
+      },
+      onProgress
+    }, async () => runCapacityProviderAssignmentProof({ provider: "local", environment, runId, prefix, env, fetchImpl })));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    for (const capability of PROVIDER_CAPABILITIES.local) {
+      if (!results.some((result) => result.capability === capability)) {
+        results.push(scenario({ provider: "local", mode, prefix, capability, ok: false, phase: "blocked", action: "blocked", reason }));
+      }
+    }
+  } finally {
+    if (server) await closeServer(server).catch(() => void 0);
+    await rm(dir, { recursive: true, force: true });
+    destroyed.push(node("local", environment, "local-db", dir, { deleted: true }));
+  }
+  return { results, cleanupDrift: [], destroyedResources: destroyed };
+}
+async function runProvider({
+  provider,
+  mode,
+  environment,
+  runId,
+  cwd,
+  env,
+  fetchImpl,
+  onProgress
+}) {
+  const prefix = providerPrefix(environment, provider, runId);
+  const started = Date.now();
+  emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: "start", message: `${provider}: ${mode} live reconciliation started` });
+  if (mode === "smoke") {
+    const results2 = await runSmokeProvider({ provider, environment, prefix, mode, cwd, env, fetchImpl });
+    const report2 = reportForProvider({ provider, mode, runId, prefix, environment, results: results2 });
+    emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: report2.ok ? "complete" : "blocked", elapsedMs: Date.now() - started, message: `${provider}: ${report2.ok ? "passed" : "blocked"} in ${Date.now() - started}ms` });
+    return report2;
+  }
+  if (provider === "railway") {
+    const { results: results2, cleanupDrift: cleanupDrift2 } = mode === "cleanup" ? await runRailwayCleanup(environment, prefix, mode, env, fetchImpl) : await runRailwayAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress);
+    const report2 = reportForProvider({ provider, mode, runId, prefix, environment, results: results2, cleanupDrift: cleanupDrift2 });
+    emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: report2.ok ? "complete" : "blocked", elapsedMs: Date.now() - started, message: `${provider}: ${report2.ok ? "passed" : "blocked"} in ${Date.now() - started}ms` });
+    return report2;
+  }
+  if (provider === "cloudflare") {
+    const { results: results2, cleanupDrift: cleanupDrift2 } = mode === "cleanup" ? await runCloudflareCleanup(cwd, environment, prefix, mode, env, fetchImpl) : await runCloudflareAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress);
+    const report2 = reportForProvider({ provider, mode, runId, prefix, environment, results: results2, cleanupDrift: cleanupDrift2 });
+    emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: report2.ok ? "complete" : "blocked", elapsedMs: Date.now() - started, message: `${provider}: ${report2.ok ? "passed" : "blocked"} in ${Date.now() - started}ms` });
+    return report2;
+  }
+  if (provider === "github") {
+    const { results: results2, cleanupDrift: cleanupDrift2 } = mode === "cleanup" ? await runGitHubCleanup(cwd, environment, prefix, mode, env, fetchImpl) : await runGitHubAcceptance(cwd, environment, runId, prefix, env, fetchImpl, onProgress);
+    const report2 = reportForProvider({ provider, mode, runId, prefix, environment, results: results2, cleanupDrift: cleanupDrift2 });
+    emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: report2.ok ? "complete" : "blocked", elapsedMs: Date.now() - started, message: `${provider}: ${report2.ok ? "passed" : "blocked"} in ${Date.now() - started}ms` });
+    return report2;
+  }
+  const { results, cleanupDrift } = await runLocalAcceptance(environment, prefix, mode, runId, env, fetchImpl, onProgress);
+  const report = reportForProvider({ provider, mode, runId, prefix, environment, results, cleanupDrift });
+  emitProgress(onProgress, { provider, mode, environment, runId, resourcePrefix: prefix, phase: report.ok ? "complete" : "blocked", elapsedMs: Date.now() - started, message: `${provider}: ${report.ok ? "passed" : "blocked"} in ${Date.now() - started}ms` });
+  return report;
+}
+function treeseedLiveReconcileProviderCapabilities(provider) {
+  return [...PROVIDER_CAPABILITIES[provider]];
+}
+function treeseedLiveReconcileResourcePrefix(environment, provider, runId) {
+  return providerPrefix(environment, provider, runId);
+}
+async function runTreeseedLiveReconcileTests(options) {
+  const mode = options.mode ?? "smoke";
+  const runId = options.runId ?? shortRunId(options.now);
+  const env = options.env ?? process.env;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const providers = [...new Set(options.providers)];
+  const reports = await Promise.all(providers.map((provider) => runProvider({
+    provider,
+    mode,
+    environment: options.environment,
+    runId,
+    cwd: options.cwd,
+    env,
+    fetchImpl,
+    onProgress: options.onProgress
+  })));
+  return {
+    command: "reconcile test-live",
+    mode,
+    environment: options.environment,
+    runId,
+    resourcePrefix: `trsd-live-${options.environment}`,
+    providers: reports,
+    ok: reports.every((report) => report.ok)
+  };
+}
+export {
+  compileTreeseedLiveAcceptanceScenarios,
+  runTreeseedLiveReconcileTests,
+  treeseedLiveReconcileProviderCapabilities,
+  treeseedLiveReconcileResourcePrefix
+};