@treeseed/sdk 0.13.0-rc.6 → 0.13.0-rc.8

package/dist/reconcile/repositories/live-acceptance-github.js

@@ -1,301 +0,0 @@
-import { resolveGitHubCredentialForRepository } from "../../operations/services/configuration/github-credentials.js";
-import { encryptGitHubSecret } from "../../operations/services/github-api/paginate-git-hub-environment-names.js";
-import {
-  PROVIDER_CAPABILITIES,
-  blocking,
-  measuredScenario,
-  node,
-  providerPrefixRoot,
-  scenario,
-  waitForLiveObservation
-} from "../runtime/live-acceptance-runtime.js";
-import { githubRequest, resolveCurrentGitHubRepository } from "./live-acceptance-github-client.js";
-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", "central-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 branches = await githubRequest(`/repos/${owner}/${repo}/git/matching-refs/heads/${encodeURIComponent(prefixRoot)}`, credential.token, fetchImpl).catch(() => []);
-    for (const candidate of branches) {
-      const ref = candidate.ref ?? "";
-      if (!ref.startsWith(`refs/heads/${prefixRoot}`)) continue;
-      const branchName = ref.replace(/^refs\/heads\//u, "");
-      try {
-        await githubRequest(`/repos/${owner}/${repo}/branches/${encodeURIComponent(branchName)}/protection`, credential.token, fetchImpl, { method: "DELETE" }).catch((error) => {
-          const message = error instanceof Error ? error.message : String(error);
-          if (!/404|Not Found|Branch not protected/iu.test(message)) throw error;
-        });
-        await githubRequest(`/repos/${owner}/${repo}/git/refs/heads/${encodeURIComponent(branchName)}`, credential.token, fetchImpl, { method: "DELETE" });
-        destroyed.push(node("github", environment, "branch", branchName, { deleted: true }));
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (!/404|Not Found/iu.test(message)) cleanupDrift.push(blocking("github", "branch", message));
-      }
-    }
-  }
-  const results = PROVIDER_CAPABILITIES.github.map((capability, index) => 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: index === 0 ? 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}.`);
-    const [owner, repo] = credential.repository.split("/");
-    const environmentName = prefix;
-    const branchName = prefix;
-    const resourceName = `TREESEED_LIVE_TEST_${prefix.toUpperCase().replace(/[^A-Z0-9]/gu, "_")}`;
-    const variableName = `${resourceName}_VARIABLE`;
-    const secretName = `${resourceName}_SECRET`;
-    await runGitHubCleanup(cwd, environment, prefix, mode, env, fetchImpl);
-    const results = [];
-    const repositoryRecord = await githubRequest(`/repos/${owner}/${repo}`, credential.token, fetchImpl);
-    const defaultBranch = repositoryRecord.default_branch ?? "main";
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "repository-adoption",
-      phase: "verify",
-      action: "adopt",
-      successReason: "GitHub acceptance adopted and read back the existing portfolio repository without creating a duplicate.",
-      locators: { repository: credential.repository },
-      onProgress
-    }, async () => {
-      if (repositoryRecord.full_name !== credential.repository || repositoryRecord.archived === true) throw new Error("The selected GitHub repository identity is missing, mismatched, or archived.");
-      return repositoryRecord;
-    }));
-    let bootstrapSha = "";
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "bootstrap",
-      phase: "verify",
-      action: "noop",
-      successReason: "GitHub acceptance observed the default branch bootstrap commit.",
-      locators: { repository: credential.repository, branch: defaultBranch },
-      onProgress
-    }, async () => {
-      const branch = await githubRequest(`/repos/${owner}/${repo}/branches/${encodeURIComponent(defaultBranch)}`, credential.token, fetchImpl);
-      bootstrapSha = branch.commit?.sha ?? "";
-      if (!/^[a-f0-9]{40}$/u.test(bootstrapSha)) throw new Error(`Default branch ${defaultBranch} has no observable bootstrap commit.`);
-      return branch;
-    }));
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "branch",
-      phase: "create",
-      action: "create",
-      successReason: "GitHub acceptance created an isolated branch from the exact default-branch commit and observed it live.",
-      locators: { repository: credential.repository, branch: branchName },
-      createdResources: [node("github", environment, "branch", branchName)],
-      onProgress
-    }, async () => {
-      await githubRequest(`/repos/${owner}/${repo}/git/refs`, credential.token, fetchImpl, { method: "POST", body: JSON.stringify({ ref: `refs/heads/${branchName}`, sha: bootstrapSha }) });
-      return waitForLiveObservation(`GitHub branch ${branchName}`, () => githubRequest(`/repos/${owner}/${repo}/branches/${encodeURIComponent(branchName)}`, credential.token ?? "", fetchImpl), (value) => value.name === branchName);
-    }));
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "branch-rules",
-      phase: "create",
-      action: "create",
-      successReason: "GitHub acceptance applied and read back the isolated branch safety policy.",
-      locators: { repository: credential.repository, branch: branchName },
-      onProgress
-    }, async () => {
-      await githubRequest(`/repos/${owner}/${repo}/branches/${encodeURIComponent(branchName)}/protection`, credential.token, fetchImpl, { method: "PUT", body: JSON.stringify({ required_status_checks: null, enforce_admins: true, required_pull_request_reviews: null, restrictions: null, allow_force_pushes: false, allow_deletions: false }) });
-      const protection = await githubRequest(`/repos/${owner}/${repo}/branches/${encodeURIComponent(branchName)}/protection`, credential.token, fetchImpl);
-      if (protection.enforce_admins?.enabled !== true || protection.allow_force_pushes?.enabled === true || protection.allow_deletions?.enabled === true) throw new Error("Isolated GitHub branch protection did not match the required safety policy.");
-      return protection;
-    }));
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "actions-settings",
-      phase: "verify",
-      action: "noop",
-      successReason: "GitHub acceptance observed enabled Actions settings without changing repository-wide policy.",
-      locators: { repository: credential.repository },
-      onProgress
-    }, async () => {
-      const settings = await githubRequest(`/repos/${owner}/${repo}/actions/permissions`, credential.token, fetchImpl);
-      if (settings.enabled !== true) throw new Error("GitHub Actions is disabled for the selected repository.");
-      return settings;
-    }));
-    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({ deployment_branch_policy: { protected_branches: false, custom_branch_policies: true } }) });
-      await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}/deployment-branch-policies`, credential.token, fetchImpl, { method: "POST", body: JSON.stringify({ name: branchName, type: "branch" }) });
-      return waitForLiveObservation(
-        `GitHub environment ${environmentName}`,
-        async () => ({ environment: await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}`, credential.token ?? "", fetchImpl), policies: await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}/deployment-branch-policies?per_page=100`, credential.token ?? "", fetchImpl) }),
-        (value) => (value.policies?.branch_policies ?? []).some((candidate) => candidate.name === branchName)
-      );
-    }));
-    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: "create",
-      action: "create",
-      startMessage: "github:secret: creating isolated environment secret",
-      successReason: "GitHub acceptance encrypted, created, and observed an isolated environment secret.",
-      locators: { repository: credential.repository, environment: environmentName, secret: secretName },
-      onProgress
-    }, async () => {
-      const key = await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}/secrets/public-key`, credential.token, fetchImpl);
-      const encryptedValue = await encryptGitHubSecret("isolated-live-acceptance-value", key.key ?? "");
-      await githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}/secrets/${secretName}`, credential.token, fetchImpl, { method: "PUT", body: JSON.stringify({ encrypted_value: encryptedValue, key_id: key.key_id }) });
-      return waitForLiveObservation(`GitHub secret ${secretName}`, () => githubRequest(`/repos/${owner}/${repo}/environments/${environmentName}/secrets?per_page=100`, credential.token ?? "", fetchImpl), (value) => (value.secrets ?? []).some((candidate) => candidate.name === secretName));
-    }));
-    results.push(await measuredScenario({
-      provider: "github",
-      mode,
-      environment,
-      runId,
-      prefix,
-      capability: "workflow-presence",
-      phase: "verify",
-      action: "noop",
-      startMessage: "github:workflow-presence: verifying workflow metadata",
-      successReason: "GitHub acceptance observed an active verification workflow without dispatching deployment.",
-      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: "central-token",
-      phase: "verify",
-      action: "noop",
-      startMessage: "github:central-token: resolving credential",
-      successReason: credential.envName === "TREESEED_GITHUB_TOKEN" ? "GitHub acceptance resolved the central first-party credential." : "GitHub acceptance resolved an imported third-party repository override.",
-      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: []
-    };
-  }
-}
-export {
-  runGitHubAcceptance,
-  runGitHubCleanup
-};

package/dist/reconcile/runtime/live-acceptance-local.d.ts

@@ -1,16 +0,0 @@
-import type { LiveAcceptanceEnv } from '../support/acceptance/live-acceptance-values.js';
-import type { LiveReconcileEnvironment, LiveReconcileMode, LiveReconcileScenarioResult, RunLiveReconcileTestsOptions } from '../support/acceptance/live-acceptance.js';
-import type { CanonicalDrift, CanonicalGraphNode } from '../support/state/platform.js';
-type LiveProgress = RunLiveReconcileTestsOptions['onProgress'];
-type LiveEnv = LiveAcceptanceEnv;
-export declare function runLocalAcceptance(environment: LiveReconcileEnvironment, prefix: string, mode: LiveReconcileMode, runId: string, env: LiveEnv, fetchImpl: typeof fetch, onProgress?: LiveProgress, capacityAssignmentExecutor?: RunLiveReconcileTestsOptions['capacityAssignmentExecutor']): Promise<{
-    results: LiveReconcileScenarioResult[];
-    cleanupDrift: never[];
-    destroyedResources: CanonicalGraphNode[];
-}>;
-export declare function runLocalCleanup(environment: LiveReconcileEnvironment, prefix: string, mode: LiveReconcileMode, env: LiveEnv, fetchImpl: typeof fetch, onProgress?: LiveProgress): Promise<{
-    results: LiveReconcileScenarioResult[];
-    cleanupDrift: CanonicalDrift[];
-    destroyedResources: CanonicalGraphNode[];
-}>;
-export {};

package/dist/reconcile/runtime/live-acceptance-local.js

@@ -1,260 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import { createServer } from "node:net";
-import { join, resolve } from "node:path";
-import { MarketClient } from "../../entrypoints/clients/market-client.js";
-import { capacityAcceptanceConfig } from "../capacity/capacity-core/live-acceptance-capacity-context.js";
-import { runCapacityProviderAssignmentProof } from "../capacity/capacity-core/live-acceptance-capacity-proof.js";
-import { deleteLocalCapacityAcceptanceTeam, isLocalCapacityAcceptanceTeam } from "../capacity/capacity-core/live-acceptance-capacity-scope.js";
-import { cleanupLocalAcceptanceAgentWorktrees } from "../support/acceptance/live-acceptance-worktree-cleanup.js";
-import { PROVIDER_CAPABILITIES, blocking, emitProgress, measuredScenario, node, providerNode, providerPrefixRoot, scenario } from "./live-acceptance-runtime.js";
-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, capacityAssignmentExecutor) {
-  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 proved multi-team registration governance plus reconciled starter planning through the provider manager, runner, AgentKernel, TreeDX, usage, and settlement path.",
-      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,
-          artifactCount: proof.artifactCount,
-          toolEventCount: proof.toolEventCount,
-          usageActualCount: proof.usageActualCount,
-          ledgerEntryCount: proof.ledgerEntryCount,
-          starterPlanning: proof.starterPlanning,
-          starterEngineering: proof.starterEngineering,
-          starterConcurrency: proof.starterConcurrency,
-          governance: proof.governance
-        })];
-      },
-      onProgress
-    }, async () => runCapacityProviderAssignmentProof({ provider: "local", environment, runId, prefix, env, fetchImpl, capacityAssignmentExecutor })));
-  } 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 runLocalCleanup(environment, prefix, mode, env, fetchImpl, onProgress) {
-  const tempBase = resolve(process.cwd(), ".treeseed", "tmp", "live-acceptance");
-  const prefixRoot = providerPrefixRoot(environment, "local");
-  const destroyedResources = [];
-  const cleanupDrift = [];
-  const entries = await readdir(tempBase, { withFileTypes: true }).catch(() => []);
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !entry.name.startsWith(prefixRoot)) continue;
-    const path = join(tempBase, entry.name);
-    await rm(path, { recursive: true, force: true });
-    destroyedResources.push(node("local", environment, "local-db", path, { deleted: true }));
-  }
-  const worktreeCleanup = await cleanupLocalAcceptanceAgentWorktrees(process.cwd());
-  for (const removed of worktreeCleanup.removed) {
-    destroyedResources.push(node("local", environment, "assignment-worktree", removed.worktreeRoot, {
-      deleted: true,
-      repository: removed.repoRoot
-    }));
-  }
-  for (const failure of worktreeCleanup.failures) {
-    cleanupDrift.push(blocking("local", "assignment-worktree", `Local assignment-worktree cleanup failed: ${failure}`));
-  }
-  const config = capacityAcceptanceConfig(env, environment);
-  if (config.apiUrl && config.adminToken) {
-    const adminClient = new MarketClient({
-      profile: {
-        id: "capacity-acceptance-cleanup",
-        label: "Capacity Acceptance Cleanup",
-        baseUrl: config.apiUrl,
-        kind: "specialized"
-      },
-      accessToken: config.adminToken,
-      fetchImpl,
-      userAgent: "treeseed-live-acceptance-cleanup"
-    });
-    try {
-      const teams = await adminClient.teams();
-      const isolatedTeams = teams.payload.filter((team) => isLocalCapacityAcceptanceTeam(team));
-      for (const team of isolatedTeams) {
-        const id = typeof team.id === "string" ? team.id : "";
-        const name = typeof team.name === "string" ? team.name : "";
-        if (!id || !name) continue;
-        await deleteLocalCapacityAcceptanceTeam(adminClient, { id, name });
-        destroyedResources.push(node("local", environment, "capacity-acceptance-team", id, {
-          deleted: true,
-          name
-        }));
-      }
-    } catch (error) {
-      cleanupDrift.push(blocking(
-        "local",
-        "capacity-acceptance-team",
-        `Local capacity control-plane cleanup failed: ${error instanceof Error ? error.message : String(error)}`
-      ));
-    }
-  } else {
-    cleanupDrift.push(blocking(
-      "local",
-      "capacity-acceptance-team",
-      "Local capacity control-plane cleanup requires an API URL and admin token."
-    ));
-  }
-  const results = PROVIDER_CAPABILITIES.local.map((capability) => scenario({
-    provider: "local",
-    mode,
-    prefix,
-    capability,
-    ok: capability !== "capacity-provider-assignment-proof" || cleanupDrift.length === 0,
-    phase: "cleanup",
-    action: capability === "local-db" && destroyedResources.length ? "delete" : "noop",
-    reason: capability === "capacity-provider-assignment-proof" && cleanupDrift.length > 0 ? "Local cleanup could not prove removal of isolated capacity control-plane state." : capability === "local-db" && destroyedResources.length ? `Local cleanup removed ${destroyedResources.length} isolated live-acceptance director${destroyedResources.length === 1 ? "y" : "ies"}.` : "Local cleanup observed no isolated resource requiring mutation.",
-    destroyedResources: capability === "local-db" || capability === "capacity-provider-assignment-proof" ? destroyedResources : [],
-    issues: capability === "capacity-provider-assignment-proof" ? cleanupDrift.map((entry) => entry.reason) : []
-  }));
-  emitProgress(onProgress, {
-    provider: "local",
-    mode,
-    environment,
-    runId: prefix.slice(prefixRoot.length),
-    resourcePrefix: prefix,
-    phase: cleanupDrift.length === 0 ? "cleanup" : "blocked",
-    message: `local: cleanup removed ${destroyedResources.length} isolated resource(s) with ${cleanupDrift.length} blocking drift item(s)`
-  });
-  return { results, cleanupDrift, destroyedResources };
-}
-export {
-  runLocalAcceptance,
-  runLocalCleanup
-};

package/dist/reconcile/runtime/live-acceptance-runtime.d.ts

@@ -1,67 +0,0 @@
-import { type CanonicalAction, type CanonicalDrift, type CanonicalGraphNode } from '../support/state/platform.js';
-import type { RunLiveReconcileTestsOptions, LiveReconcileEnvironment, LiveReconcileMode, LiveReconcileProgressEvent, LiveReconcileProvider, LiveReconcileProviderReport, LiveReconcileScenarioResult } from '../support/acceptance/live-acceptance.js';
-type LiveProgress = RunLiveReconcileTestsOptions['onProgress'];
-export declare const PROVIDER_CAPABILITIES: Record<LiveReconcileProvider, string[]>;
-export declare function shortRunId(now?: Date): string;
-export declare function providerPrefix(environment: string, provider: LiveReconcileProvider, runId: string): string;
-export declare function providerPrefixRoot(environment: string, provider: LiveReconcileProvider): string;
-export declare function emitProgress(onProgress: LiveProgress, event: Omit<LiveReconcileProgressEvent, 'message'> & {
-    message?: string;
-}): void;
-export declare function waitForLiveObservation<T>(description: string, observe: () => Promise<T>, isReady: (value: T) => boolean, options?: {
-    attempts?: number;
-    intervalMs?: number;
-}): Promise<T>;
-export declare function scenario({ provider, mode, prefix, capability, ok, phase, action, reason, locators, createdResources, updatedResources, replacedResources, destroyedResources, retainedResources, issues, startedAt, completedAt, durationMs, }: {
-    provider: LiveReconcileProvider;
-    mode: LiveReconcileMode;
-    prefix: string;
-    capability: string;
-    ok: boolean;
-    phase: LiveReconcileScenarioResult['phase'];
-    action: CanonicalAction['kind'];
-    reason: string;
-    locators?: Record<string, string | null>;
-    createdResources?: CanonicalGraphNode[];
-    updatedResources?: CanonicalGraphNode[];
-    replacedResources?: CanonicalGraphNode[];
-    destroyedResources?: CanonicalGraphNode[];
-    retainedResources?: CanonicalGraphNode[];
-    issues?: string[];
-    startedAt?: string;
-    completedAt?: string;
-    durationMs?: number;
-}): LiveReconcileScenarioResult;
-export declare function node(provider: LiveReconcileProvider, environment: string, type: string, id: string, state?: Record<string, unknown>): CanonicalGraphNode;
-export declare function providerNode(provider: LiveReconcileProvider, environment: string, type: string, id: string, state?: Record<string, unknown>): CanonicalGraphNode;
-export declare function blocking(provider: LiveReconcileProvider, type: string, reason: string): CanonicalDrift;
-export declare function describeLiveAcceptanceError(error: unknown): string;
-export declare function measuredScenario(input: {
-    provider: LiveReconcileProvider;
-    mode: LiveReconcileMode;
-    environment: LiveReconcileEnvironment;
-    runId: string;
-    prefix: string;
-    capability: string;
-    phase: LiveReconcileScenarioResult['phase'];
-    action: CanonicalAction['kind'];
-    startMessage?: string;
-    successReason: string | ((value: unknown) => string);
-    locators?: Record<string, string | null>;
-    createdResources?: CanonicalGraphNode[] | ((value: unknown) => CanonicalGraphNode[]);
-    updatedResources?: CanonicalGraphNode[] | ((value: unknown) => CanonicalGraphNode[]);
-    replacedResources?: CanonicalGraphNode[] | ((value: unknown) => CanonicalGraphNode[]);
-    destroyedResources?: CanonicalGraphNode[] | ((value: unknown) => CanonicalGraphNode[]);
-    retainedResources?: CanonicalGraphNode[] | ((value: unknown) => CanonicalGraphNode[]);
-    onProgress?: LiveProgress;
-}, fn: () => Promise<unknown>): Promise<LiveReconcileScenarioResult>;
-export declare function reportForProvider({ provider, mode, runId, prefix, environment, results, cleanupDrift, }: {
-    provider: LiveReconcileProvider;
-    mode: LiveReconcileMode;
-    runId: string;
-    prefix: string;
-    environment: LiveReconcileEnvironment;
-    results: LiveReconcileScenarioResult[];
-    cleanupDrift?: CanonicalDrift[];
-}): LiveReconcileProviderReport;
-export {};