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

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-proof.js

@@ -1,514 +0,0 @@
-import { ProviderProtocolClient } from "../../../capacity/providers/capacity-provider.js";
-import { MarketClient } from "../../../entrypoints/clients/market-client.js";
-import { activateInternalCapacityAllocationSet, createInternalCapacityAllocationSet } from "../../../market-client/internal-capacity-allocation.js";
-import { runLocalAutonomousStarterAcceptances } from "../../support/acceptance/live-acceptance-starters.js";
-import { configuredLiveAcceptanceValue } from "../../support/acceptance/live-acceptance-values.js";
-import { cleanupCapacityAssignmentProof } from "./live-acceptance-capacity-cleanup.js";
-import { provisionLocalCapacityCompetition } from "./live-acceptance-capacity-competition.js";
-import { capacityAcceptanceConfig, capacityGrantForAcceptance, createTreeDxProxyAuditEvidence, effectiveActiveAllocation, ensureLocalCapacityTreeDxBinding, provisionLocalCapacityAcceptanceProvider, resolveLocalCapacityAcceptanceScope, syncLocalAcceptanceAgentClass } from "./live-acceptance-capacity-context.js";
-import { proveLocalCapacityGovernance } from "./live-acceptance-capacity-governance.js";
-import { assertCapacityAcceptancePolicyUnchanged, capacityAcceptancePolicyFingerprint } from "./live-acceptance-capacity-guards.js";
-import { createLocalCapacityAcceptanceScope } from "./live-acceptance-capacity-scope.js";
-import { verifyCapacityAcceptanceTerminal } from "./live-acceptance-capacity-terminal.js";
-const configuredValue = configuredLiveAcceptanceValue;
-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`, 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}`
-  });
-  let cleanupLocalScope = null;
-  if (input.environment === "local") {
-    if (!config.teamId || !config.projectId) {
-      const scope = await createLocalCapacityAcceptanceScope(adminClient, input.runId);
-      Object.assign(config, scope);
-      cleanupLocalScope = scope.cleanup;
-    } else {
-      Object.assign(config, await resolveLocalCapacityAcceptanceScope(adminClient, config.projectId));
-      await ensureLocalCapacityTreeDxBinding(adminClient, config);
-    }
-  }
-  let cleanupProvisionedProvider = null, cleanupGovernanceProof = null;
-  let cleanupCapacityCompetition = null, governanceProof, starterProofs;
-  let governanceAcceptance = null, provisionedRuntime = null;
-  try {
-    if (input.environment === "local" && (!config.providerId || !config.membershipId || !config.providerAccessToken)) {
-      const provisioned = await provisionLocalCapacityAcceptanceProvider({
-        adminClient,
-        apiUrl: config.apiUrl,
-        teamId: config.teamId,
-        runId: input.runId,
-        fetchImpl: input.fetchImpl
-      });
-      Object.assign(config, provisioned);
-      provisionedRuntime = provisioned;
-      cleanupProvisionedProvider = provisioned.cleanup;
-    }
-    if (!config.providerId || !config.membershipId || !config.providerAccessToken) {
-      throw new Error("Capacity acceptance provider identity, membership, and access token were not resolved.");
-    }
-    if (input.environment === "local" && provisionedRuntime && input.capacityAssignmentExecutor) {
-      governanceAcceptance = await proveLocalCapacityGovernance({
-        adminClient,
-        apiUrl: config.apiUrl,
-        runId: input.runId,
-        primaryTeamId: config.teamId,
-        primaryMembershipId: config.membershipId,
-        privateJwk: provisionedRuntime.privateJwk,
-        fetchImpl: input.fetchImpl
-      });
-      cleanupGovernanceProof = governanceAcceptance.cleanup;
-    }
-  } catch (error) {
-    const cleanupErrors = [];
-    for (const cleanup of [cleanupGovernanceProof, cleanupProvisionedProvider, cleanupLocalScope]) {
-      if (!cleanup) continue;
-      try {
-        await cleanup();
-      } catch (cleanupError) {
-        cleanupErrors.push(cleanupError);
-      }
-    }
-    if (cleanupErrors.length > 0) {
-      throw new AggregateError([error, ...cleanupErrors], "Capacity acceptance preparation and cleanup both failed.");
-    }
-    throw error;
-  }
-  const providerClient = new ProviderProtocolClient({
-    marketUrl: config.apiUrl,
-    accessToken: config.providerAccessToken,
-    fetchImpl: input.fetchImpl,
-    userAgent: `treeseed-live-acceptance/${input.runId}`
-  });
-  let sessionIdForCleanup = "";
-  let grantIdForCleanup = "";
-  let workdayIdForCleanup = "";
-  let workdayRunIdForCleanup = "";
-  let completedAssignmentId = "";
-  let humanPolicyFingerprint = "";
-  const executionThroughAgentRuntime = Boolean(input.capacityAssignmentExecutor && provisionedRuntime);
-  let agentClassId = executionThroughAgentRuntime ? "testing" : config.agentClassId, assignmentError = null;
-  try {
-    let availabilitySession = await providerClient.createAvailabilitySession({
-      id: `${input.prefix}-session`,
-      environment: input.environment,
-      status: "open",
-      capabilities: ["planning", "repo_read", "agent_mode_run", "usage_report"],
-      grants: [],
-      nativeLimits: { availableAgentSeconds: 1800, maxConcurrentRunners: 1, wallMinutes: { session: 30 } },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      constraints: { liveAcceptance: true, outboundOnly: true },
-      metadata,
-      executionProviders: [{
-        id: "codex",
-        adapter: "codex",
-        status: "available",
-        capabilities: ["planning", "agent_mode_run", "repo_read", "usage_report"],
-        maxConcurrentRunners: 1,
-        activeRunners: 0,
-        nativeLimits: { availableAgentSeconds: 1800 },
-        lanes: [{ id: "codex-operation", executionProviderId: "codex", purpose: "operation", status: "active", capabilities: [], maxConcurrentRunners: 1, activeRunners: 0, nativeLimits: {} }]
-      }]
-    });
-    sessionIdForCleanup = String(availabilitySession.payload.id ?? "");
-    if (executionThroughAgentRuntime && input.environment === "local") {
-      const synchronized = await syncLocalAcceptanceAgentClass(adminClient, { projectId: config.projectId, agentClassId, runId: input.runId });
-      agentClassId = synchronized.payload.id;
-    } else {
-      const existingClasses = await adminClient.projectAgentClasses(config.projectId).catch(() => ({ payload: { items: [] } }));
-      const hasAgentClass = existingClasses.payload.items.some((entry) => entry.id === agentClassId || entry.slug === agentClassId);
-      if (!hasAgentClass) {
-        await adminClient.createProjectAgentClass(config.projectId, {
-          id: agentClassId,
-          slug: agentClassId,
-          name: "Planning",
-          status: "active",
-          allowedModes: ["planning"],
-          requiredCapabilities: ["agent_mode_run"],
-          metadata
-        }, `live-acceptance:${input.runId}:agent-class:${agentClassId}`);
-      }
-    }
-    const grants = await adminClient.capacityGrants(config.teamId, { limit: 200 }).catch(() => ({ payload: { items: [] } }));
-    let acceptanceGrant = capacityGrantForAcceptance(Array.isArray(grants.payload.items) ? grants.payload.items : [], config, input.environment);
-    if (!acceptanceGrant && input.environment === "local" && cleanupProvisionedProvider) {
-      const grantId = `${input.prefix}-grant`;
-      const created = await adminClient.createCapacityGrant(config.teamId, {
-        schemaVersion: 2,
-        id: grantId,
-        membershipId: config.membershipId,
-        providerId: config.providerId,
-        projectId: config.projectId,
-        environment: input.environment,
-        status: "planned",
-        executionProviderIds: ["codex"],
-        laneIds: [],
-        capabilities: ["planning", "agent_mode_run", "repo_read", "usage_report"],
-        allowedModes: ["planning"],
-        dailyAgentSecondsLimit: 1800,
-        monthlyAgentSecondsLimit: 1800,
-        maxConcurrentAssignments: 1,
-        metadata
-      }, `capacity-acceptance:${input.runId}:grant-create`);
-      await adminClient.transitionCapacityGrant(config.teamId, grantId, "activate", `capacity-acceptance:${input.runId}:grant-activate`);
-      acceptanceGrant = created.payload;
-      grantIdForCleanup = grantId;
-    }
-    if (!acceptanceGrant) {
-      throw new Error(`Capacity acceptance did not find an active checked-in grant for project ${config.projectId} and provider ${config.providerId}.`);
-    }
-    const allocations = await adminClient.capacityAllocationSets(config.teamId, { limit: 200 });
-    let activeAllocation = effectiveActiveAllocation(Array.isArray(allocations.payload.items) ? allocations.payload.items : []);
-    if (!activeAllocation?.id && input.environment === "local" && cleanupProvisionedProvider) {
-      const allocationId = `${input.prefix}-allocation`;
-      const created = await createInternalCapacityAllocationSet(adminClient, config.teamId, {
-        id: allocationId,
-        effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
-        effectiveUntil: new Date(Date.now() + 10 * 6e4).toISOString(),
-        reservePolicy: { percent: 0, overflow: "deny" },
-        slices: [{
-          id: `${allocationId}:project`,
-          scope: "project",
-          targetId: config.projectId,
-          policy: { minPercent: 0, targetPercent: 100, maxPercent: 100, hardCapPercent: 100 }
-        }],
-        borrowingRules: [],
-        metadata
-      }, `capacity-acceptance:${input.runId}:allocation-create`);
-      activeAllocation = (await activateInternalCapacityAllocationSet(
-        adminClient,
-        config.teamId,
-        String(created.payload.id),
-        `capacity-acceptance:${input.runId}:allocation-activate`
-      )).payload;
-    }
-    if (!activeAllocation?.id) throw new Error("Capacity acceptance requires an active team allocation set.");
-    humanPolicyFingerprint = await capacityAcceptancePolicyFingerprint({
-      adminClient,
-      teamId: config.teamId,
-      grantId: String(acceptanceGrant.id),
-      allocationId: String(activeAllocation.id)
-    });
-    availabilitySession = await providerClient.refreshAvailabilitySession(String(availabilitySession.payload.id), {
-      expectedSequence: availabilitySession.payload.sequence,
-      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: { availableAgentSeconds: 1800, maxConcurrentRunners: 1, wallMinutes: { session: 30 } },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      constraints: { liveAcceptance: true, outboundOnly: true },
-      metadata,
-      executionProviders: [{
-        id: "codex",
-        adapter: "codex",
-        status: "available",
-        capabilities: ["planning", "agent_mode_run", "repo_read", "usage_report"],
-        maxConcurrentRunners: 1,
-        activeRunners: 0,
-        nativeLimits: { availableAgentSeconds: 1800 },
-        lanes: [{ id: "codex-operation", executionProviderId: "codex", purpose: "operation", status: "active", capabilities: [], maxConcurrentRunners: 1, activeRunners: 0, nativeLimits: {} }]
-      }]
-    });
-    const sessionId = String(availabilitySession.payload.id ?? "");
-    if (!sessionId) throw new Error("Capacity acceptance availability session did not return a session id.");
-    if (input.capacityAssignmentExecutor && provisionedRuntime) {
-      const workdayRunId = `${input.prefix}-run`;
-      await adminClient.createWorkdayRun(config.teamId, {
-        id: workdayRunId,
-        capacityProviderId: config.providerId,
-        environment: input.environment,
-        status: "running",
-        parameters: {
-          projects: [config.projectSlug || config.projectId],
-          durationSeconds: 1200,
-          allocationSetId: activeAllocation.id,
-          availableSeconds: 1200,
-          metadata
-        }
-      });
-      workdayRunIdForCleanup = workdayRunId;
-      await adminClient.tickWorkdayRun(config.teamId, workdayRunId, {
-        idempotencyKey: `capacity-acceptance:${input.runId}:tick`
-      });
-      const competition = governanceAcceptance ? await provisionLocalCapacityCompetition({
-        adminClient,
-        apiUrl: config.apiUrl,
-        runId: input.runId,
-        runtime: governanceAcceptance.runtime,
-        fetchImpl: input.fetchImpl
-      }) : null;
-      cleanupCapacityCompetition = competition?.cleanup ?? null;
-      const execution = await input.capacityAssignmentExecutor({
-        runId: input.runId,
-        apiUrl: config.apiUrl,
-        teamId: config.teamId,
-        projectId: config.projectId,
-        providerId: config.providerId,
-        membershipId: config.membershipId,
-        credentialId: provisionedRuntime.credentialId,
-        membershipCredential: provisionedRuntime.membershipCredential,
-        providerAccessToken: provisionedRuntime.providerAccessToken,
-        providerSessionId: sessionId,
-        providerSessionSequence: Number(availabilitySession.payload.sequence),
-        privateJwk: provisionedRuntime.privateJwk,
-        assignmentId: null,
-        executionProviderId: "codex",
-        ...competition ? { competingConnection: competition.connection } : {}
-      }).catch((error) => {
-        throw new Error(`Capacity acceptance Agent runtime executor failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-      const executedAssignmentId = execution.assignmentId;
-      if (!executedAssignmentId) throw new Error("Capacity acceptance Agent runtime executor did not identify its durable assignment.");
-      if (competition && governanceAcceptance) {
-        if (!execution.finalSlot) throw new Error("Capacity acceptance Agent runtime omitted provider-global final-slot evidence.");
-        const deferred = await adminClient.capacityProviderAssignment(
-          competition.connection.teamId,
-          competition.connection.assignmentId
-        );
-        const deferredAssignmentRemainedPending = deferred.payload.status === "pending";
-        if (!deferredAssignmentRemainedPending) {
-          throw new Error(`Competing second-team assignment left pending state under the exhausted provider-global slot: ${String(deferred.payload.status)}.`);
-        }
-        await competition.cleanup();
-        cleanupCapacityCompetition = null;
-        starterProofs = await runLocalAutonomousStarterAcceptances({
-          adminClient,
-          apiUrl: config.apiUrl,
-          runId: input.runId,
-          runtime: governanceAcceptance.runtime,
-          fetchImpl: input.fetchImpl,
-          privateJwk: provisionedRuntime.privateJwk,
-          executor: input.capacityAssignmentExecutor
-        });
-        governanceProof = await governanceAcceptance.finalize({
-          ...execution.finalSlot,
-          deferredAssignmentRemainedPending
-        });
-      }
-      const terminal = await verifyCapacityAcceptanceTerminal({ adminClient, config, assignmentId: executedAssignmentId });
-      await assertCapacityAcceptancePolicyUnchanged({
-        adminClient,
-        teamId: config.teamId,
-        grantId: String(acceptanceGrant.id),
-        allocationId: String(activeAllocation.id),
-        expectedFingerprint: humanPolicyFingerprint
-      });
-      completedAssignmentId = executedAssignmentId;
-      return {
-        sessionId,
-        assignmentId: executedAssignmentId,
-        mode,
-        runnerId: "provider-manager-dispatch",
-        governance: governanceProof,
-        ...starterProofs ?? {},
-        ...terminal
-      };
-    }
-    const workDayId = `${input.prefix}-workday`;
-    await adminClient.createWorkday({
-      id: workDayId,
-      projectId: config.projectId,
-      allocationSetId: activeAllocation.id,
-      environment: input.environment,
-      status: "active",
-      availableSeconds: 600,
-      envelope: { availableSeconds: 600, metadata },
-      metadata: { ...metadata, grantId: String(acceptanceGrant.id) }
-    }, `live-acceptance:${input.runId}:workday:${workDayId}`);
-    workdayIdForCleanup = workDayId;
-    const admission = await adminClient.admitCapacityAssignment(config.teamId, {
-      assignmentId,
-      reservationId: `${input.prefix}-reservation`,
-      projectId: config.projectId,
-      providerId: config.providerId,
-      membershipId: config.membershipId,
-      environment: input.environment,
-      providerSessionId: sessionId,
-      projectAgentClassId: agentClassId,
-      executionProviderId: "codex",
-      workDayId,
-      requestedSeconds: 300,
-      mode,
-      capacityEnvelope: {
-        teamId: config.teamId,
-        projectId: config.projectId,
-        providerId: config.providerId,
-        workDayId,
-        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
-    }, `capacity-acceptance:${input.runId}:${assignmentId}`);
-    const admittedAssignment = admission.payload?.assignment;
-    if (!admittedAssignment?.id) throw new Error("Capacity acceptance admission did not create an assignment.");
-    if (String(admittedAssignment.id) !== assignmentId) throw new Error(`Capacity acceptance admission created unexpected assignment ${String(admittedAssignment.id)}.`);
-    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.settleAssignment(leasedId, { activeSeconds: 0, elapsedSeconds: 0, metadata: { ...metadata, retiredStaleAcceptanceAssignment: true } }, `capacity-acceptance-stale-settlement:${leasedId}`);
-      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,
-      providerAccessToken: config.providerAccessToken,
-      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: {
-        activeSeconds: 0,
-        elapsedSeconds: 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.");
-    await providerClient.settleAssignment(assignmentId, {
-      modeRunId,
-      activeSeconds: 1,
-      elapsedSeconds: 1,
-      providerUnits: 1,
-      metadata
-    }, `capacity-acceptance-settlement:${input.runId}:${assignmentId}`);
-    const completed = await providerClient.completeAssignment(assignmentId, {
-      runnerId,
-      leaseToken,
-      modeRunId,
-      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"}".`);
-    }
-    await assertCapacityAcceptancePolicyUnchanged({
-      adminClient,
-      teamId: config.teamId,
-      grantId: String(acceptanceGrant.id),
-      allocationId: String(activeAllocation.id),
-      expectedFingerprint: humanPolicyFingerprint
-    });
-    completedAssignmentId = assignmentId;
-    const modeRuns = await adminClient.projectAgentModeRuns(config.projectId, { assignmentId });
-    const modeRunCount = modeRuns.payload.items.length;
-    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,
-      artifactCount: 0,
-      toolEventCount: 0,
-      usageActualCount: 0,
-      ledgerEntryCount: 0,
-      governance: governanceProof
-    };
-  } catch (error) {
-    assignmentError = error;
-    throw error;
-  } finally {
-    await cleanupCapacityAssignmentProof({
-      adminClient,
-      providerClient,
-      apiUrl: config.apiUrl,
-      runId: input.runId,
-      teamId: config.teamId,
-      membershipId: config.membershipId,
-      providerId: config.providerId,
-      grantId: grantIdForCleanup,
-      workdayId: workdayIdForCleanup,
-      workdayRunId: workdayRunIdForCleanup,
-      sessionId: sessionIdForCleanup,
-      completedAssignmentId,
-      provisionedRuntime,
-      cleanupCapacityCompetition,
-      cleanupProvisionedProvider,
-      cleanupGovernanceProof,
-      cleanupLocalScope,
-      assignmentError,
-      fetchImpl: input.fetchImpl
-    });
-  }
-}
-export {
-  runCapacityProviderAssignmentProof
-};

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-scope.d.ts

@@ -1,14 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-export declare const LOCAL_CAPACITY_ACCEPTANCE_TEAM_PREFIX = "capacity-live-acceptance-";
-export declare const LOCAL_CAPACITY_GOVERNANCE_TEAM_PREFIX = "capacity-live-governance-";
-export declare function isLocalCapacityAcceptanceTeam(team: Record<string, unknown>): boolean;
-export declare function deleteLocalCapacityAcceptanceTeam(adminClient: MarketClient, team: {
-    id: string;
-    name: string;
-}): Promise<void>;
-export declare function createLocalCapacityAcceptanceScope(adminClient: MarketClient, runId: string): Promise<{
-    teamId: any;
-    projectId: string;
-    projectSlug: string;
-    cleanup: () => Promise<void>;
-}>;

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-scope.js

@@ -1,122 +0,0 @@
-import { bindLocalCapacityTreeDxRepository } from "./live-acceptance-capacity-context.js";
-const LOCAL_CAPACITY_ACCEPTANCE_TEAM_PREFIX = "capacity-live-acceptance-";
-const LOCAL_CAPACITY_GOVERNANCE_TEAM_PREFIX = "capacity-live-governance-";
-function isLocalCapacityAcceptanceTeam(team) {
-  const name = typeof team.name === "string" ? team.name : "";
-  const metadata = team.metadata && typeof team.metadata === "object" && !Array.isArray(team.metadata) ? team.metadata : {};
-  return metadata.liveAcceptance === true && (name.startsWith(LOCAL_CAPACITY_ACCEPTANCE_TEAM_PREFIX) || name.startsWith(LOCAL_CAPACITY_GOVERNANCE_TEAM_PREFIX));
-}
-function runSuffix(runId) {
-  return runId.replace(/[^a-z0-9]/giu, "").toLowerCase().slice(-14) || "run";
-}
-async function terminalizeProjectCapacity(adminClient, teamId, projectId) {
-  const runs = await adminClient.workdayRuns(teamId, { limit: 200 });
-  if (runs.payload.page.hasMore) {
-    throw new Error(`Capacity acceptance team ${teamId} has more workday runs than bounded cleanup can safely inspect.`);
-  }
-  for (const run of runs.payload.items) {
-    const runId = typeof run.id === "string" ? run.id : "";
-    const status = typeof run.status === "string" ? run.status : "";
-    if (!runId || !["queued", "running"].includes(status)) continue;
-    await adminClient.updateWorkdayRun(teamId, runId, { status: "cancelled" });
-  }
-  const before = await adminClient.projectDeletionBlockers(projectId);
-  for (const blocker of before.payload) {
-    if (blocker.code !== "active_workday" || typeof blocker.id !== "string") continue;
-    await adminClient.cancelWorkday(
-      blocker.id,
-      `capacity-acceptance-cleanup:${blocker.id}:cancel`
-    );
-  }
-  const assignments = await adminClient.capacityProviderAssignments(teamId, { projectId, limit: 200 });
-  for (const assignment of assignments.payload.items) {
-    const assignmentId = typeof assignment.id === "string" ? assignment.id : "";
-    const status = typeof assignment.status === "string" ? assignment.status : "";
-    if (!assignmentId || !["pending", "returned", "expired"].includes(status)) continue;
-    await adminClient.cancelCapacityAssignment(teamId, assignmentId, {
-      idempotencyKey: `capacity-acceptance-cleanup:${assignmentId}:cancel`,
-      reason: "Isolated live-acceptance team cleanup resolved the abandoned assignment."
-    });
-  }
-  const remaining = (await adminClient.projectDeletionBlockers(projectId)).payload;
-  if (remaining.length > 0) {
-    throw new Error(`Capacity acceptance project ${projectId} still has deletion blockers: ${remaining.map((entry) => `${String(entry.code)}:${String(entry.id ?? "")}`).join(", ")}.`);
-  }
-}
-async function deleteLocalCapacityAcceptanceTeam(adminClient, team) {
-  const projects = await adminClient.projects(team.id);
-  for (const project of projects.payload) {
-    const projectId = typeof project.id === "string" ? project.id : "";
-    if (!projectId) continue;
-    await terminalizeProjectCapacity(adminClient, team.id, projectId);
-  }
-  const deleted = await adminClient.deleteTeamPermanently(team.id, {
-    confirmation: team.name,
-    localAcceptanceCleanup: true
-  });
-  if (!deleted.ok) {
-    throw new Error(`Capacity acceptance could not delete isolated team ${team.id}: ${deleted.message ?? deleted.code ?? "unknown error"}.`);
-  }
-}
-async function createLocalCapacityAcceptanceScope(adminClient, runId) {
-  const suffix = runSuffix(runId);
-  const name = `${LOCAL_CAPACITY_ACCEPTANCE_TEAM_PREFIX}${suffix}`;
-  const createdTeam = await adminClient.createTeam({
-    name,
-    displayName: `Capacity live acceptance ${suffix}`,
-    metadata: { liveAcceptance: true, runId, purpose: "isolated-capacity-runtime" }
-  });
-  const teamId = createdTeam.payload.id;
-  const cleanup = () => deleteLocalCapacityAcceptanceTeam(adminClient, { id: teamId, name });
-  try {
-    const createdProject = await adminClient.createProject(teamId, {
-      slug: `capacity-${suffix}`,
-      name: `Capacity acceptance ${suffix}`,
-      description: "Isolated control-plane project for the local capacity acceptance lifecycle.",
-      metadata: {
-        liveAcceptance: true,
-        runId,
-        purpose: "isolated-capacity-runtime",
-        architecture: {
-          topology: "single_repository_site",
-          rootPath: ".",
-          sitePath: ".",
-          contentPath: "src/content",
-          contentRuntimeSource: "treedx_snapshot",
-          localContentMaterialization: "none"
-        }
-      }
-    });
-    const payload = createdProject.payload;
-    const nested = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : payload;
-    const projectId = String(nested.id ?? "");
-    const projectSlug = String(nested.slug ?? "");
-    if (!projectId || !projectSlug) throw new Error("Capacity acceptance project creation omitted its id or slug.");
-    await bindLocalCapacityTreeDxRepository(adminClient, {
-      projectId,
-      projectSlug,
-      teamId
-    }, {
-      repositoryName: "treeseed-market",
-      contentPath: "src/content"
-    });
-    return {
-      teamId,
-      projectId,
-      projectSlug,
-      cleanup
-    };
-  } catch (error) {
-    await cleanup().catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Capacity acceptance scope provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-export {
-  LOCAL_CAPACITY_ACCEPTANCE_TEAM_PREFIX,
-  LOCAL_CAPACITY_GOVERNANCE_TEAM_PREFIX,
-  createLocalCapacityAcceptanceScope,
-  deleteLocalCapacityAcceptanceTeam,
-  isLocalCapacityAcceptanceTeam
-};

package/dist/reconcile/capacity/capacity-core/live-acceptance-capacity-terminal.d.ts

@@ -1,17 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import { capacityAcceptanceConfig } from './live-acceptance-capacity-context.js';
-export declare function hasAuthenticatedCommittedContentReferences(contentReferences: unknown[], toolEvents: unknown[], minimumArtifactCount: number): boolean;
-export declare function verifyCapacityAcceptanceTerminal(input: {
-    adminClient: MarketClient;
-    config: Pick<ReturnType<typeof capacityAcceptanceConfig>, 'teamId' | 'projectId'>;
-    assignmentId: string;
-    minimumArtifactCount?: number;
-}): Promise<{
-    finalStatus: string;
-    modeRunId: string;
-    modeRunCount: any;
-    artifactCount: number;
-    toolEventCount: number;
-    usageActualCount: any;
-    ledgerEntryCount: any;
-}>;