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

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

@@ -1,439 +0,0 @@
-import {
-  capacityProviderPublicIdentity,
-  ProviderProtocolClient,
-  signCapacityProviderProof
-} from "../../capacity/providers/capacity-provider.js";
-import { createInternalCapacityAllocationSet, supersedeInternalCapacityAllocationSet } from "../../market-client/internal-capacity-allocation.js";
-import { bindLocalCapacityTreeDxRepository, syncLocalAcceptanceAgentClasses } from "../capacity/capacity-core/live-acceptance-capacity-context.js";
-const LIVE_PROVIDER_ASSIGNMENT_BUDGET_SECONDS = 600;
-const TERMINAL_WORKDAY_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed", "degraded"]);
-function localStarterDurationSeconds(config) {
-  const durationSeconds = config.durationSeconds ?? Math.max(LIVE_PROVIDER_ASSIGNMENT_BUDGET_SECONDS, config.agentSeconds);
-  if (!Number.isInteger(durationSeconds) || durationSeconds <= 0) {
-    throw new Error("Starter acceptance duration must be a positive whole number of seconds.");
-  }
-  return durationSeconds;
-}
-function localStarterProjectSlug(starter, runId) {
-  return `${starter}-${runId.replace(/[^a-z0-9]/giu, "").toLowerCase().slice(-20)}`;
-}
-async function finalizeLocalStarterAcceptance(cleanup, executionError, label) {
-  try {
-    await cleanup(executionError ? "cancelled" : "completed");
-  } catch (cleanupError) {
-    if (executionError) throw new AggregateError([executionError, cleanupError], `${label} execution and cleanup both failed.`);
-    throw cleanupError;
-  }
-}
-async function terminalizeStarterWorkdayRun(input) {
-  const observed = await input.adminClient.workdayRun(input.teamId, input.workdayRunId);
-  const status = String(observed.payload.run.status ?? "");
-  if (TERMINAL_WORKDAY_RUN_STATUSES.has(status)) return observed.payload.run;
-  return (await input.adminClient.updateWorkdayRun(input.teamId, input.workdayRunId, {
-    status: input.status,
-    summary: input.summary
-  })).payload;
-}
-function projectRecord(payload) {
-  const nested = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : payload;
-  const id = String(nested.id ?? "");
-  const slug = String(nested.slug ?? id);
-  if (!id) throw new Error("Starter acceptance project creation omitted its id.");
-  return { id, slug };
-}
-async function provisionLocalStarterProject(input) {
-  const slug = localStarterProjectSlug(input.config.starter, input.runId);
-  const created = await input.adminClient.createProject(input.runtime.teamId, {
-    slug,
-    name: `${input.config.starter} starter acceptance ${input.runId}`,
-    description: `Isolated live acceptance project bound to the reconciled ${input.config.starter} starter.`,
-    metadata: { liveAcceptance: true, runId: input.runId, ...input.config.projectMetadata }
-  });
-  const project = projectRecord(created.payload);
-  const cleanup = async () => void 0;
-  try {
-    const binding = await bindLocalCapacityTreeDxRepository(input.adminClient, {
-      projectId: project.id,
-      projectSlug: project.slug,
-      teamId: input.runtime.teamId
-    }, { repositoryName: input.config.repositoryName, contentPath: "template/src/content" });
-    const synchronized = await syncLocalAcceptanceAgentClasses(input.adminClient, {
-      projectId: project.id,
-      repositoryId: String(binding.repositoryId),
-      agentPaths: input.config.agentPaths,
-      runId: input.runId
-    });
-    return { project, binding, synchronized, cleanup };
-  } catch (error) {
-    await cleanup().catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Starter project provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-async function provisionLocalStarterCapacity(input) {
-  const key = `${input.config.starter}-starter:${input.runId}`;
-  const provisionedProject = await provisionLocalStarterProject(input);
-  const project = provisionedProject.project;
-  const bootstrapProtocol = new ProviderProtocolClient({ marketUrl: input.apiUrl, fetchImpl: input.fetchImpl });
-  let protocol = bootstrapProtocol;
-  let starterAccessToken = "";
-  const grantId = `${key}:grant`;
-  const allocationId = `${key}:allocation`;
-  const workdayRunId = `${key}:run`;
-  const durationSeconds = localStarterDurationSeconds(input.config);
-  let sessionId = "";
-  let sessionCreated = false;
-  let grantCreated = false;
-  let runCreated = false;
-  const cleanup = async (runStatus = "completed") => {
-    const errors = [];
-    const run = async (label, operation) => {
-      try {
-        await operation();
-      } catch (error) {
-        errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    };
-    if (runCreated) await run(`${runStatus} workday run`, () => terminalizeStarterWorkdayRun({
-      adminClient: input.adminClient,
-      teamId: input.runtime.teamId,
-      workdayRunId,
-      status: runStatus,
-      summary: { liveAcceptance: true, cleanupStatus: runStatus }
-    }));
-    if (sessionCreated) await run("close availability session", async () => {
-      const accessKey = `${key}:cleanup-access:${Date.now()}`;
-      const accessProof = await signCapacityProviderProof({
-        privateJwk: input.privateJwk,
-        publicJwk: capacityProviderPublicIdentity(input.privateJwk),
-        method: "POST",
-        path: "/v1/provider/access-tokens",
-        audience: input.apiUrl,
-        body: { credentialId: input.runtime.credentialId, idempotencyKey: accessKey }
-      });
-      const access = await bootstrapProtocol.issueAccessToken(
-        input.runtime.membershipCredential,
-        input.runtime.credentialId,
-        accessProof,
-        accessKey
-      );
-      await new ProviderProtocolClient({
-        marketUrl: input.apiUrl,
-        accessToken: access.accessToken,
-        fetchImpl: input.fetchImpl
-      }).closeAvailabilitySession(sessionId);
-    });
-    if (grantCreated) await run("revoke grant", () => input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "revoke", `${key}:grant-revoke`));
-    await run("delete project", provisionedProject.cleanup);
-    if (errors.length) throw new Error(`Starter acceptance cleanup failed: ${errors.join("; ")}`);
-  };
-  try {
-    const accessKey = `${key}:access:${crypto.randomUUID()}`;
-    const accessProof = await signCapacityProviderProof({
-      privateJwk: input.privateJwk,
-      publicJwk: capacityProviderPublicIdentity(input.privateJwk),
-      method: "POST",
-      path: "/v1/provider/access-tokens",
-      audience: input.apiUrl,
-      body: { credentialId: input.runtime.credentialId, idempotencyKey: accessKey }
-    });
-    const access = await bootstrapProtocol.issueAccessToken(
-      input.runtime.membershipCredential,
-      input.runtime.credentialId,
-      accessProof,
-      accessKey
-    );
-    starterAccessToken = access.accessToken;
-    protocol = new ProviderProtocolClient({
-      marketUrl: input.apiUrl,
-      accessToken: starterAccessToken,
-      fetchImpl: input.fetchImpl
-    });
-    const { binding, synchronized } = provisionedProject;
-    const executionProvider = {
-      id: "codex",
-      adapter: "codex",
-      status: "available",
-      capabilities: input.config.capabilities,
-      maxConcurrentRunners: 1,
-      activeRunners: 0,
-      nativeLimits: { availableAgentSeconds: input.config.agentSeconds },
-      lanes: [{ id: "codex-operation", purpose: "operation", maxConcurrentRunners: 1, activeRunners: 0, capabilities: input.config.capabilities, nativeLimits: {} }]
-    };
-    let availability = await protocol.createAvailabilitySession({
-      environment: "local",
-      status: "open",
-      capabilities: input.config.capabilities,
-      grants: [],
-      nativeLimits: { availableAgentSeconds: input.config.agentSeconds, maxConcurrentRunners: 1 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      metadata: { liveAcceptance: true, runId: input.runId, starter: input.config.starter },
-      executionProviders: [executionProvider]
-    });
-    sessionId = String(availability.payload.id ?? "");
-    if (!sessionId) throw new Error("Starter availability session omitted its id.");
-    sessionCreated = true;
-    await input.adminClient.createCapacityGrant(input.runtime.teamId, {
-      schemaVersion: 2,
-      id: grantId,
-      membershipId: input.runtime.membershipId,
-      providerId: input.runtime.providerId,
-      projectId: project.id,
-      environment: "local",
-      status: "planned",
-      executionProviderIds: ["codex"],
-      laneIds: [],
-      capabilities: input.config.capabilities,
-      allowedModes: input.config.allowedModes,
-      dailyAgentSecondsLimit: input.config.agentSeconds,
-      monthlyAgentSecondsLimit: input.config.agentSeconds,
-      maxConcurrentAssignments: 1,
-      metadata: { liveAcceptance: true, runId: input.runId, starter: input.config.starter }
-    }, `${key}:grant-create`);
-    grantCreated = true;
-    await input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "activate", `${key}:grant-activate`);
-    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
-      id: allocationId,
-      effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
-      effectiveUntil: new Date(Date.now() + (durationSeconds + 300) * 1e3).toISOString(),
-      reservePolicy: { percent: 0, overflow: "deny" },
-      slices: [{ id: `${allocationId}:project`, scope: "project", targetId: project.id, policy: { minPercent: 0, targetPercent: 100, maxPercent: 100, hardCapPercent: 100 } }],
-      borrowingRules: [],
-      metadata: { liveAcceptance: true, runId: input.runId, starter: input.config.starter }
-    }, `${key}:allocation-create`);
-    const active = (await input.adminClient.capacityAllocationSets(input.runtime.teamId, { limit: 200 })).payload.items.find((entry) => entry && typeof entry === "object" && entry.status === "active");
-    await supersedeInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
-    availability = await protocol.refreshAvailabilitySession(sessionId, {
-      expectedSequence: availability.payload.sequence,
-      environment: "local",
-      status: "open",
-      capabilities: input.config.capabilities,
-      grants: [{ grantId, projectId: project.id, teamId: input.runtime.teamId, grantScope: "project" }],
-      nativeLimits: { availableAgentSeconds: input.config.agentSeconds, maxConcurrentRunners: 1 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 1 },
-      metadata: { liveAcceptance: true, runId: input.runId, starter: input.config.starter },
-      executionProviders: [executionProvider]
-    });
-    const configuredParameters = typeof input.config.parameters === "function" ? input.config.parameters({ projectId: project.id, projectSlug: project.slug, allocationSetId: String(allocation.payload.id), repositoryRef: synchronized.resolvedRef }) : input.config.parameters;
-    await input.adminClient.createWorkdayRun(input.runtime.teamId, {
-      id: workdayRunId,
-      capacityProviderId: input.runtime.providerId,
-      environment: "local",
-      status: "running",
-      parameters: { projects: [project.slug], durationSeconds, allocationSetId: allocation.payload.id, availableSeconds: input.config.agentSeconds, ...configuredParameters }
-    });
-    runCreated = true;
-    return {
-      key,
-      project,
-      binding,
-      grantId,
-      allocationId: String(allocation.payload.id),
-      workdayRunId,
-      connection: {
-        ...input.runtime,
-        providerAccessToken: starterAccessToken,
-        projectId: project.id,
-        providerSessionId: sessionId,
-        providerSessionSequence: Number(availability.payload.sequence)
-      },
-      cleanup
-    };
-  } catch (error) {
-    await cleanup("cancelled").catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Starter provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-async function provisionLocalStarterPortfolioCapacity(input) {
-  if (input.configs.length !== 2 || new Set(input.configs.map((config) => config.starter)).size !== 2) {
-    throw new Error("Concurrent starter acceptance requires exactly one engineering and one research project.");
-  }
-  const key = `concurrent-starters:${input.runId}`;
-  const provisions = await Promise.allSettled(input.configs.map((config) => provisionLocalStarterProject({
-    ...input,
-    runId: `${input.runId}-portfolio`,
-    config
-  })));
-  const failed = provisions.filter((result) => result.status === "rejected");
-  if (failed.length) {
-    const cleanupResults = await Promise.allSettled(provisions.filter((result) => result.status === "fulfilled").map((result) => result.value.cleanup()));
-    const cleanupFailures = cleanupResults.filter((result) => result.status === "rejected");
-    throw new AggregateError(
-      [...failed.map((result) => result.reason), ...cleanupFailures.map((result) => result.reason)],
-      "Concurrent starter project provisioning failed."
-    );
-  }
-  const projects = provisions.map((result) => result.value);
-  const bootstrapProtocol = new ProviderProtocolClient({ marketUrl: input.apiUrl, fetchImpl: input.fetchImpl });
-  let protocol = bootstrapProtocol;
-  const agentSeconds = input.configs.reduce((total, config) => total + config.agentSeconds, 0);
-  const capabilities = [...new Set(input.configs.flatMap((config) => config.capabilities))];
-  const grants = [];
-  const workdayRunIds = [];
-  let sessionId = "";
-  let sessionCreated = false;
-  let availabilitySequence = 0;
-  const cleanup = async (runStatus = "completed") => {
-    const errors = [];
-    const run = async (label, operation) => {
-      try {
-        await operation();
-      } catch (error) {
-        errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    };
-    for (const workdayRunId of workdayRunIds) await run(`${runStatus} ${workdayRunId}`, () => terminalizeStarterWorkdayRun({
-      adminClient: input.adminClient,
-      teamId: input.runtime.teamId,
-      workdayRunId,
-      status: runStatus,
-      summary: { liveAcceptance: true, concurrent: true, cleanupStatus: runStatus }
-    }));
-    if (sessionCreated) await run("close shared availability session", async () => {
-      const accessKey = `${key}:cleanup-access:${Date.now()}`;
-      const proof = await signCapacityProviderProof({
-        privateJwk: input.privateJwk,
-        publicJwk: capacityProviderPublicIdentity(input.privateJwk),
-        method: "POST",
-        path: "/v1/provider/access-tokens",
-        audience: input.apiUrl,
-        body: { credentialId: input.runtime.credentialId, idempotencyKey: accessKey }
-      });
-      const access = await bootstrapProtocol.issueAccessToken(input.runtime.membershipCredential, input.runtime.credentialId, proof, accessKey);
-      await new ProviderProtocolClient({ marketUrl: input.apiUrl, accessToken: access.accessToken, fetchImpl: input.fetchImpl }).closeAvailabilitySession(sessionId);
-    });
-    for (const grant of grants) await run(`revoke ${grant.grantId}`, () => input.adminClient.transitionCapacityGrant(input.runtime.teamId, grant.grantId, "revoke", `${key}:revoke:${grant.projectId}`));
-    for (const project of [...projects].reverse()) await run(`delete ${project.project.id}`, project.cleanup);
-    if (errors.length) throw new Error(`Concurrent starter cleanup failed: ${errors.join("; ")}`);
-  };
-  try {
-    const accessKey = `${key}:access:${crypto.randomUUID()}`;
-    const proof = await signCapacityProviderProof({
-      privateJwk: input.privateJwk,
-      publicJwk: capacityProviderPublicIdentity(input.privateJwk),
-      method: "POST",
-      path: "/v1/provider/access-tokens",
-      audience: input.apiUrl,
-      body: { credentialId: input.runtime.credentialId, idempotencyKey: accessKey }
-    });
-    const access = await bootstrapProtocol.issueAccessToken(input.runtime.membershipCredential, input.runtime.credentialId, proof, accessKey);
-    protocol = new ProviderProtocolClient({ marketUrl: input.apiUrl, accessToken: access.accessToken, fetchImpl: input.fetchImpl });
-    const executionProvider = {
-      id: "codex",
-      adapter: "codex",
-      status: "available",
-      capabilities,
-      maxConcurrentRunners: 2,
-      activeRunners: 0,
-      nativeLimits: { availableAgentSeconds: agentSeconds, maxConcurrentRunners: 2 },
-      lanes: [
-        { id: "codex-communication", purpose: "communication", maxConcurrentRunners: 1, activeRunners: 0, capabilities, nativeLimits: {} },
-        { id: "codex-operation", purpose: "operation", maxConcurrentRunners: 1, activeRunners: 0, capabilities, nativeLimits: {} }
-      ]
-    };
-    let availability = await protocol.createAvailabilitySession({
-      environment: "local",
-      status: "open",
-      capabilities,
-      grants: [],
-      nativeLimits: { availableAgentSeconds: agentSeconds, maxConcurrentRunners: 2 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 2 },
-      metadata: { liveAcceptance: true, runId: input.runId, concurrentStarters: true },
-      executionProviders: [executionProvider]
-    });
-    sessionId = String(availability.payload.id ?? "");
-    if (!sessionId) throw new Error("Concurrent starter availability session omitted its id.");
-    sessionCreated = true;
-    for (let index = 0; index < projects.length; index += 1) {
-      const project = projects[index].project;
-      const config = input.configs[index];
-      const grantId = `${key}:grant:${config.starter}`;
-      await input.adminClient.createCapacityGrant(input.runtime.teamId, {
-        schemaVersion: 2,
-        id: grantId,
-        membershipId: input.runtime.membershipId,
-        providerId: input.runtime.providerId,
-        projectId: project.id,
-        environment: "local",
-        status: "planned",
-        executionProviderIds: ["codex"],
-        laneIds: [],
-        capabilities: config.capabilities,
-        allowedModes: config.allowedModes,
-        dailyAgentSecondsLimit: config.agentSeconds,
-        monthlyAgentSecondsLimit: config.agentSeconds,
-        maxConcurrentAssignments: 1,
-        metadata: { liveAcceptance: true, runId: input.runId, concurrentStarters: true, starter: config.starter }
-      }, `${key}:grant-create:${config.starter}`);
-      await input.adminClient.transitionCapacityGrant(input.runtime.teamId, grantId, "activate", `${key}:grant-activate:${config.starter}`);
-      grants.push({ grantId, projectId: project.id, teamId: input.runtime.teamId, grantScope: "project" });
-    }
-    const durationSeconds = Math.max(...input.configs.map(localStarterDurationSeconds));
-    const allocationId = `${key}:allocation`;
-    const allocation = await createInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, {
-      id: allocationId,
-      effectiveFrom: new Date(Date.now() - 1e3).toISOString(),
-      effectiveUntil: new Date(Date.now() + (durationSeconds + 300) * 1e3).toISOString(),
-      reservePolicy: { percent: 0, overflow: "deny" },
-      borrowingRules: [],
-      slices: projects.map((entry, index) => ({ id: `${allocationId}:${input.configs[index].starter}`, scope: "project", targetId: entry.project.id, policy: { minPercent: 0, targetPercent: 50, maxPercent: 60, hardCapPercent: 60 } })),
-      metadata: { liveAcceptance: true, runId: input.runId, concurrentStarters: true }
-    }, `${key}:allocation-create`);
-    const active = (await input.adminClient.capacityAllocationSets(input.runtime.teamId, { limit: 200 })).payload.items.find((entry) => entry && typeof entry === "object" && entry.status === "active");
-    await supersedeInternalCapacityAllocationSet(input.adminClient, input.runtime.teamId, String(allocation.payload.id), { expectedActiveAllocationSetId: active?.id ?? null }, `${key}:allocation-supersede`);
-    availability = await protocol.refreshAvailabilitySession(sessionId, {
-      expectedSequence: availability.payload.sequence,
-      environment: "local",
-      status: "open",
-      capabilities,
-      grants,
-      nativeLimits: { availableAgentSeconds: agentSeconds, maxConcurrentRunners: 2 },
-      runnerPressure: { activeRunners: 0, maxConcurrentRunners: 2 },
-      metadata: { liveAcceptance: true, runId: input.runId, concurrentStarters: true },
-      executionProviders: [executionProvider]
-    });
-    availabilitySequence = Number(availability.payload.sequence);
-    const workdayRunId = `${key}:run:portfolio`;
-    await input.adminClient.createWorkdayRun(input.runtime.teamId, {
-      id: workdayRunId,
-      capacityProviderId: input.runtime.providerId,
-      environment: "local",
-      status: "running",
-      parameters: {
-        projects: projects.map((entry) => entry.project.slug),
-        durationSeconds,
-        allocationSetId: allocation.payload.id,
-        availableSeconds: agentSeconds,
-        planningOnly: true,
-        metadata: { liveAcceptance: true, concurrentStarters: true }
-      }
-    });
-    workdayRunIds.push(workdayRunId);
-    return {
-      projects,
-      workdayRunIds,
-      allocationId: String(allocation.payload.id),
-      grants,
-      capabilities,
-      connection: { ...input.runtime, providerAccessToken: access.accessToken, providerSessionId: sessionId, providerSessionSequence: availabilitySequence },
-      cleanup
-    };
-  } catch (error) {
-    await cleanup("cancelled").catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Concurrent starter provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-export {
-  finalizeLocalStarterAcceptance,
-  localStarterDurationSeconds,
-  localStarterProjectSlug,
-  provisionLocalStarterCapacity,
-  provisionLocalStarterPortfolioCapacity,
-  provisionLocalStarterProject,
-  terminalizeStarterWorkdayRun
-};

package/dist/reconcile/support/acceptance/live-acceptance-starter-concurrency.d.ts

@@ -1,19 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import type { CapacityAcceptanceProof } from '../../capacity/capacity-core/live-acceptance-capacity-context.js';
-import type { CapacityAcceptanceExecutionInput } from '../../capacity/capacity-core/live-acceptance-capacity-executor.js';
-import type { CapacityGovernanceRuntimeConnection } from '../../capacity/capacity-core/live-acceptance-capacity-governance.js';
-import type { RunLiveReconcileTestsOptions } from './live-acceptance.js';
-export declare function concurrentProjectClassTransitionKey(runId: string, projectId: string, transition: string, classSlug: string): string;
-export declare function hasConcurrentUsageAndExactlyOnceSettlement(terminals: Array<{
-    usageActualCount: number;
-    ledgerEntryCount: number;
-}>): boolean;
-export declare function runLocalConcurrentStarterAcceptance(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<NonNullable<CapacityAcceptanceProof['starterConcurrency']>>;

package/dist/reconcile/support/acceptance/live-acceptance-starter-concurrency.js

@@ -1,128 +0,0 @@
-import { resolve } from "node:path";
-import { runGitText } from "../../../operations/services/operations/git-runner.js";
-import { verifyCapacityAcceptanceTerminal } from "../../capacity/capacity-core/live-acceptance-capacity-terminal.js";
-import { finalizeLocalStarterAcceptance, provisionLocalStarterPortfolioCapacity } from "../../runtime/live-acceptance-starter-runtime.js";
-import { engineeringStarterCapacityConfig } from "./live-acceptance-starter-engineering.js";
-import { researchStarterCapacityConfig } from "./live-acceptance-starter-planning.js";
-const DECISION_ID = "normalize-release-channel-inputs";
-function concurrentProjectClassTransitionKey(runId, projectId, transition, classSlug) {
-  return `concurrent-starters:${runId}:project:${projectId}:${transition}:${classSlug}`;
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function timestamp(value) {
-  const parsed = Date.parse(String(value ?? ""));
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-function workspaceId(assignment) {
-  return String(record(assignment.treedxProxyHandle).workspaceId ?? record(record(assignment.workspaceContext).treedxProxyHandle).workspaceId ?? "");
-}
-function hasConcurrentUsageAndExactlyOnceSettlement(terminals) {
-  return terminals.every((terminal) => terminal.usageActualCount > 0 && terminal.ledgerEntryCount === 1);
-}
-async function runLocalConcurrentStarterAcceptance(input) {
-  const engineeringRoot = resolve(process.cwd(), "starters/engineering");
-  const exactBaseRef = runGitText(["rev-parse", "HEAD"], { cwd: engineeringRoot, mode: "read" }).trim();
-  if (!/^[a-f0-9]{40}$/u.test(exactBaseRef)) throw new Error("Concurrent starter acceptance could not resolve the engineering exact source commit.");
-  const portfolio = await provisionLocalStarterPortfolioCapacity({
-    ...input,
-    configs: [engineeringStarterCapacityConfig(`${input.runId}-concurrent`, exactBaseRef), researchStarterCapacityConfig()]
-  });
-  const engineering = portfolio.projects[0];
-  const research = portfolio.projects[1];
-  let executionError;
-  try {
-    for (const classSlug of ["engineering", "release", "reporting", "research", "review", "technical-writing", "testing"]) {
-      await input.adminClient.updateProjectAgentClass(engineering.project.id, `${engineering.project.id}:${classSlug}`, { status: "paused" }, concurrentProjectClassTransitionKey(input.runId, engineering.project.id, "pause", classSlug));
-    }
-    await input.adminClient.updateProjectAgentClass(engineering.project.id, `${engineering.project.id}:architecture`, { status: "active", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, engineering.project.id, "activate", "architecture"));
-    await Promise.all([
-      input.adminClient.updateProjectAgentClass(research.project.id, `${research.project.id}:research`, { status: "active", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, research.project.id, "activate", "research")),
-      ...["review", "technical-writing", "reporting"].map((classSlug) => input.adminClient.updateProjectAgentClass(research.project.id, `${research.project.id}:${classSlug}`, { status: "paused", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, research.project.id, "pause", classSlug)))
-    ]);
-    await input.adminClient.createPlanningInputRequest(DECISION_ID, {
-      id: `concurrent-engineering-proposal:${input.runId}`,
-      projectId: engineering.project.id,
-      projectAgentClassId: `${engineering.project.id}:architecture`,
-      mode: "planning",
-      prompt: "Create the linked test-first release-channel proposal.",
-      metadata: { agentId: "architect", objectiveId: "ship-the-first-guided-change", planningSource: "concurrent-live-proposal", priority: 100 }
-    });
-    const workflowId = `concurrent-research:${input.runId}`;
-    await input.adminClient.createResearchWorkflow(research.project.id, {
-      id: workflowId,
-      objectiveRef: "objective:publish-the-first-knowledge-pack",
-      questionRef: "question:what-should-this-research-map-first",
-      minimumIndependentSources: 2,
-      maxRevisionCycles: 3,
-      idempotencyKey: `${workflowId}:create`,
-      metadata: { liveAcceptance: true, concurrentStarters: true }
-    });
-    await Promise.all(portfolio.workdayRunIds.map((runId, index) => input.adminClient.tickWorkdayRun(input.runtime.teamId, runId, {
-      idempotencyKey: `concurrent-starters:${input.runId}:tick:${index}`
-    })));
-    const execution = await input.executor({
-      runId: `${input.runId}-concurrent-starters`,
-      apiUrl: input.apiUrl,
-      teamId: portfolio.connection.teamId,
-      projectId: engineering.project.id,
-      providerId: portfolio.connection.providerId,
-      membershipId: portfolio.connection.membershipId,
-      credentialId: portfolio.connection.credentialId,
-      membershipCredential: portfolio.connection.membershipCredential,
-      providerAccessToken: portfolio.connection.providerAccessToken,
-      providerSessionId: portfolio.connection.providerSessionId,
-      providerSessionSequence: portfolio.connection.providerSessionSequence,
-      privateJwk: input.privateJwk,
-      assignmentId: null,
-      expectedAssignmentCount: 2,
-      maxConcurrentRunners: 2,
-      executionProviderId: "codex",
-      capabilities: portfolio.capabilities
-    });
-    const assignmentIds = execution.assignmentIds ?? [execution.assignmentId];
-    if (assignmentIds.length !== 2) throw new Error(`Concurrent provider execution returned ${assignmentIds.length} assignments instead of two.`);
-    const assignments = await Promise.all(assignmentIds.map(async (assignmentId) => (await input.adminClient.capacityProviderAssignment(input.runtime.teamId, assignmentId)).payload));
-    const expectedProjects = /* @__PURE__ */ new Set([engineering.project.id, research.project.id]);
-    if (new Set(assignments.map((assignment) => String(assignment.projectId))).size !== 2 || assignments.some((assignment) => !expectedProjects.has(String(assignment.projectId)))) {
-      throw new Error(`Concurrent provider assignments crossed project scope: ${JSON.stringify(assignments.map((entry) => ({ id: entry.id, projectId: entry.projectId })))}`);
-    }
-    const terminals = await Promise.all(assignments.map((assignment) => verifyCapacityAcceptanceTerminal({
-      adminClient: input.adminClient,
-      config: { teamId: input.runtime.teamId, projectId: String(assignment.projectId) },
-      assignmentId: String(assignment.id),
-      minimumArtifactCount: 1
-    })));
-    const starts = assignments.map((assignment) => timestamp(assignment.claimedAt ?? assignment.assignedAt));
-    const ends = assignments.map((assignment) => timestamp(assignment.completedAt ?? assignment.updatedAt));
-    const overlapMs = Math.min(...ends) - Math.max(...starts);
-    if (starts.some((value) => value === 0) || ends.some((value) => value === 0) || overlapMs <= 0) {
-      throw new Error(`Concurrent assignments did not retain overlapping durable lease intervals: ${JSON.stringify({ starts, ends, overlapMs })}`);
-    }
-    const workspaceIds = assignments.map(workspaceId);
-    if (workspaceIds.some((id) => !id) || new Set(workspaceIds).size !== 2) throw new Error("Concurrent assignments did not retain independent TreeDX workspaces.");
-    if (!hasConcurrentUsageAndExactlyOnceSettlement(terminals)) {
-      throw new Error(`Concurrent assignments did not retain usage evidence and exactly one ledger settlement per project: ${JSON.stringify(terminals)}`);
-    }
-    return {
-      projectIds: [...expectedProjects],
-      assignmentIds,
-      workspaceIds,
-      overlapMs,
-      usageActualCount: terminals.reduce((total, terminal) => total + terminal.usageActualCount, 0),
-      ledgerEntryCount: terminals.reduce((total, terminal) => total + terminal.ledgerEntryCount, 0),
-      artifactCount: terminals.reduce((total, terminal) => total + terminal.artifactCount, 0)
-    };
-  } catch (error) {
-    executionError = error;
-    throw error;
-  } finally {
-    await finalizeLocalStarterAcceptance(portfolio.cleanup, executionError, "Concurrent starter");
-  }
-}
-export {
-  concurrentProjectClassTransitionKey,
-  hasConcurrentUsageAndExactlyOnceSettlement,
-  runLocalConcurrentStarterAcceptance
-};

package/dist/reconcile/support/acceptance/live-acceptance-starter-engineering.d.ts

@@ -1,18 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import type { CapacityAcceptanceProof } from '../../capacity/capacity-core/live-acceptance-capacity-context.js';
-import type { CapacityAcceptanceExecutionInput } from '../../capacity/capacity-core/live-acceptance-capacity-executor.js';
-import type { CapacityGovernanceRuntimeConnection } from '../../capacity/capacity-core/live-acceptance-capacity-governance.js';
-import { type LocalStarterCapacityConfig } from '../../runtime/live-acceptance-starter-runtime.js';
-import type { RunLiveReconcileTestsOptions } from './live-acceptance.js';
-export declare const ENGINEERING_STARTER_CAPABILITIES: string[];
-export declare function engineeringStarterCapacityConfig(runId: string, exactBaseRef: string): LocalStarterCapacityConfig;
-export declare function createdEngineeringProposalId(assignment: Record<string, unknown>): string | null;
-export declare function runLocalEngineeringStarterAcceptance(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<NonNullable<CapacityAcceptanceProof['starterEngineering']>>;