@treeseed/sdk 0.6.38 → 0.6.40

package/dist/capacity.d.ts

@@ -0,0 +1,53 @@
+import type { CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProviderLane, CapacityReservation, TaskEstimateProfile } from './sdk-types.ts';
+import type { AgentProviderProfile } from './types/agents.ts';
+export interface CapacityEstimateInput {
+    taskSignature?: string | null;
+    taskKind?: string | null;
+    confidence?: CapacityEstimateConfidence | null;
+    estimatedCreditsP50?: number | null;
+    estimatedCreditsP90?: number | null;
+    profile?: TaskEstimateProfile | null;
+    defaultCredits?: number | null;
+}
+export interface CapacityLaneCandidate {
+    lane: CapacityProviderLane;
+    grant?: CapacityGrant | null;
+    remainingCredits?: number | null;
+    agentProfile?: AgentProviderProfile | null;
+    taskKind?: string | null;
+    requiredCapabilities?: string[];
+    modelClass?: string | null;
+    region?: string | null;
+}
+export interface CapacityLaneScore {
+    laneId: string;
+    capacityProviderId: string;
+    score: number;
+    agentFit: number;
+    scarcityPenalty: number;
+    fairnessScore: number;
+    costPenalty: number;
+    reasons: string[];
+}
+export declare function reserveCreditsForEstimate(input: CapacityEstimateInput): {
+    taskSignature: string;
+    confidence: CapacityEstimateConfidence;
+    estimatedCreditsP50: number;
+    estimatedCreditsP90: number;
+    reservedCredits: number;
+};
+export declare function summarizeCapacityPlan(plan: CapacityPlan): {
+    grantedDailyCredits: number;
+    reservedCredits: number;
+    consumedCredits: number;
+    remainingDailyCredits: number | null;
+    providerCount: number;
+    laneCount: number;
+    grantCount: number;
+};
+export declare function scoreCapacityLane(input: CapacityLaneCandidate): CapacityLaneScore;
+export declare function selectBestCapacityLane(candidates: CapacityLaneCandidate[]): {
+    selected: CapacityLaneScore;
+    scores: CapacityLaneScore[];
+};
+export declare function reservationHasCapacity(reservation: CapacityReservation): boolean;

package/dist/capacity.js

@@ -0,0 +1,100 @@
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function scarcityPenalty(level) {
+  if (level === "high") return 35;
+  if (level === "medium") return 15;
+  return 0;
+}
+function reserveCreditsForEstimate(input) {
+  const profileP50 = finiteNumber(input.profile?.creditsP50);
+  const profileP90 = finiteNumber(input.profile?.creditsP90);
+  const p50 = Math.max(1, Math.ceil(
+    finiteNumber(input.estimatedCreditsP50) ?? profileP50 ?? finiteNumber(input.defaultCredits) ?? 1
+  ));
+  const p90 = Math.max(p50, Math.ceil(
+    finiteNumber(input.estimatedCreditsP90) ?? profileP90 ?? p50 * 2
+  ));
+  const confidence = input.confidence ?? "medium";
+  const reserved = confidence === "high" ? Math.max(p50, Math.ceil((p50 + p90) * 0.75)) : p90;
+  return {
+    taskSignature: input.taskSignature ?? input.taskKind ?? "unknown",
+    confidence,
+    estimatedCreditsP50: p50,
+    estimatedCreditsP90: p90,
+    reservedCredits: reserved
+  };
+}
+function summarizeCapacityPlan(plan) {
+  const reservedCredits = plan.activeReservations.filter((reservation) => reservation.state === "reserved").reduce((total, reservation) => total + reservation.reservedCredits, 0);
+  const consumedCredits = plan.activeReservations.reduce((total, reservation) => total + reservation.consumedCredits, 0);
+  const grantedDailyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.dailyCreditLimit ?? 0), 0);
+  return {
+    grantedDailyCredits,
+    reservedCredits,
+    consumedCredits,
+    remainingDailyCredits: grantedDailyCredits > 0 ? Math.max(0, grantedDailyCredits - reservedCredits - consumedCredits) : null,
+    providerCount: plan.providers.length,
+    laneCount: plan.lanes.length,
+    grantCount: plan.grants.length
+  };
+}
+function scoreCapacityLane(input) {
+  const reasons = [];
+  let agentFit = 0;
+  const profile = input.agentProfile;
+  if (profile) {
+    const preferred = profile.preferredLanes.find(
+      (preference) => preference.laneId === input.lane.id || preference.providerId === input.lane.capacityProviderId || preference.modelClass && preference.modelClass === input.lane.modelClass || preference.provider && preference.provider === input.lane.capacityProviderId
+    );
+    if (preferred) {
+      agentFit += Math.max(0, preferred.weight);
+      reasons.push("agent_preference");
+    }
+    if (profile.disallowedProviders?.includes(input.lane.capacityProviderId)) {
+      agentFit -= 1e3;
+      reasons.push("agent_disallowed_provider");
+    }
+    if (input.region && profile.disallowedRegions?.includes(input.region)) {
+      agentFit -= 1e3;
+      reasons.push("agent_disallowed_region");
+    }
+  }
+  if (input.modelClass && input.lane.modelClass === input.modelClass) {
+    agentFit += 20;
+    reasons.push("model_class_match");
+  }
+  const fairnessScore = Math.max(0, (input.grant?.priorityWeight ?? 1) * 10);
+  const scarcity = scarcityPenalty(input.lane.scarcityLevel);
+  const remaining = input.remainingCredits;
+  const costPenalty = remaining !== null && remaining !== void 0 && remaining <= 0 ? 500 : 0;
+  if (scarcity > 0) reasons.push(`scarcity:${input.lane.scarcityLevel}`);
+  if (costPenalty > 0) reasons.push("capacity_exhausted");
+  return {
+    laneId: input.lane.id,
+    capacityProviderId: input.lane.capacityProviderId,
+    score: agentFit + fairnessScore - scarcity - costPenalty,
+    agentFit,
+    scarcityPenalty: scarcity,
+    fairnessScore,
+    costPenalty,
+    reasons
+  };
+}
+function selectBestCapacityLane(candidates) {
+  const scored = candidates.map(scoreCapacityLane).sort((left, right) => right.score - left.score || left.laneId.localeCompare(right.laneId));
+  return {
+    selected: scored[0] ?? null,
+    scores: scored
+  };
+}
+function reservationHasCapacity(reservation) {
+  return reservation.state === "reserved" && reservation.reservedCredits > reservation.consumedCredits;
+}
+export {
+  reservationHasCapacity,
+  reserveCreditsForEstimate,
+  scoreCapacityLane,
+  selectBestCapacityLane,
+  summarizeCapacityPlan
+};

package/dist/control-plane-client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPool, AgentPoolRegistration, AgentPoolScaleDecision, CatalogArtifactVersion, CatalogItem, CatalogItemFilters, CreateProjectDeploymentRequest, PriorityOverride, PrioritySnapshot, ProjectConnection, ProjectDeployment, ProjectEnvironment, ProjectEnvironmentName, ProjectHosting, ProjectInfrastructureResource, ProjectWorkdaySummary, RecordAgentPoolRegistrationRequest, ScaleDecision, TeamStorageLocator, TeamWebHost, UpsertAgentPoolRequest, UpsertCatalogArtifactVersionRequest, UpsertCatalogItemRequest, UpsertProjectEnvironmentRequest, UpsertProjectHostingRequest, UpsertProjectInfrastructureResourceRequest, UpsertTeamStorageLocatorRequest, UpsertTeamWebHostRequest, WorkdayPolicy, SdkPriorityOverrideRequest, SdkUpsertWorkPolicyRequest } from './sdk-types.ts';
+import type { AgentPool, AgentPoolRegistration, AgentPoolScaleDecision, ApprovalRequest, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityReservation, CapacityRoutingDecision, CatalogArtifactVersion, CatalogItem, CatalogItemFilters, CreateApprovalRequestRequest, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, CreateProjectDeploymentRequest, CreateTaskEstimateRequest, CreateTaskUsageActualRequest, PriorityOverride, PrioritySnapshot, ProjectConnection, ProjectDeployment, ProjectEnvironment, ProjectEnvironmentName, ProjectHosting, ProjectInfrastructureResource, ProjectWorkdaySummary, RecordAgentPoolRegistrationRequest, RecordCapacityUsageRequest, RepositoryClaim, RunnerScaleDecision, ScaleDecision, SdkCreateWorkdayRequest, SdkRecordRepositoryClaimRequest, SdkRecordRunnerScaleDecisionRequest, SdkRecordWorkerRunnerRequest, TeamStorageLocator, TeamWebHost, TaskEstimate, UpsertAgentPoolRequest, UpsertCapacityGrantRequest, UpsertCapacityProviderLaneRequest, UpsertCapacityProviderRequest, UpsertCatalogArtifactVersionRequest, UpsertCatalogItemRequest, UpsertProjectEnvironmentRequest, UpsertProjectHostingRequest, UpsertProjectInfrastructureResourceRequest, UpsertTeamStorageLocatorRequest, UpsertTeamWebHostRequest, WorkdayPolicy, WorkdayRequest, WorkerRunner, SdkPriorityOverrideRequest, SdkUpsertWorkPolicyRequest } from './sdk-types.ts';
 import type { AgentMessageRecord, AgentStatusRecord, DirectBoardItemSummary, InboxItem, LaunchProjectRequest, LaunchProjectResult, ProjectOverviewSummary, ReleaseDetail, ReleaseSummary, SharePackageStatus, TeamHomeSummary, TeamMemberSummary, WorkstreamDetail, WorkstreamSummary } from './knowledge-coop.ts';
 export interface ControlPlaneClientOptions {
     baseUrl: string;
@@ -43,6 +43,10 @@ export declare class ControlPlaneClient {
     listAgentPoolScaleDecisions(projectId: string, poolId: string): Promise<AgentPoolScaleDecision[]>;
     getProjectWorkPolicy(projectId: string, environment?: ProjectEnvironmentName): Promise<WorkdayPolicy | null>;
     upsertProjectWorkPolicy(projectId: string, input: SdkUpsertWorkPolicyRequest): Promise<WorkdayPolicy>;
+    getProjectWorkdayPolicy(projectId: string, environment?: ProjectEnvironmentName): Promise<WorkdayPolicy | null>;
+    upsertProjectWorkdayPolicy(projectId: string, input: SdkUpsertWorkPolicyRequest): Promise<WorkdayPolicy>;
+    getProjectWorkdayStatus(projectId: string, environment?: ProjectEnvironmentName): Promise<Record<string, unknown>>;
+    createProjectWorkdayRequest(projectId: string, input: SdkCreateWorkdayRequest): Promise<WorkdayRequest>;
     listProjectPriorityOverrides(projectId: string): Promise<PriorityOverride[]>;
     upsertProjectPriorityOverride(projectId: string, input: SdkPriorityOverrideRequest): Promise<PriorityOverride>;
     listProjectPrioritySnapshots(projectId: string, workDayId?: string | null): Promise<PrioritySnapshot[]>;
@@ -53,6 +57,11 @@ export declare class ControlPlaneClient {
     recordRunnerAgentPoolRegistration(projectId: string, poolId: string, input: RecordAgentPoolRegistrationRequest): Promise<AgentPoolRegistration>;
     recordRunnerScaleDecision(projectId: string, poolName: string, input: Pick<ScaleDecision, 'environment' | 'workDayId' | 'desiredWorkers' | 'observedQueueDepth' | 'observedActiveLeases' | 'reason' | 'metadata'>): Promise<AgentPoolScaleDecision>;
     recordRunnerWorkdaySummary(projectId: string, input: ProjectWorkdaySummary): Promise<ProjectWorkdaySummary>;
+    recordWorkerRunner(projectId: string, input: SdkRecordWorkerRunnerRequest): Promise<WorkerRunner>;
+    listWorkerRunners(projectId: string, environment?: ProjectEnvironmentName): Promise<WorkerRunner[]>;
+    recordRepositoryClaim(projectId: string, input: SdkRecordRepositoryClaimRequest): Promise<RepositoryClaim>;
+    listRepositoryClaims(projectId: string, repositoryId?: string | null): Promise<RepositoryClaim[]>;
+    recordRunnerScaleDecisionV2(projectId: string, input: SdkRecordRunnerScaleDecisionRequest): Promise<RunnerScaleDecision>;
     getTeamHomeSummary(teamId: string): Promise<TeamHomeSummary>;
     listTeamInboxItems(teamId: string): Promise<InboxItem[]>;
     listTeamMembers(teamId: string): Promise<TeamMemberSummary[]>;
@@ -70,6 +79,37 @@ export declare class ControlPlaneClient {
         host: TeamWebHost;
         validation: Record<string, unknown> | null;
     }>;
+    listCapacityProviders(teamId: string): Promise<(CapacityProvider & {
+        lanes?: CapacityProviderLane[];
+    })[]>;
+    createCapacityProvider(teamId: string, input: UpsertCapacityProviderRequest): Promise<CapacityProvider>;
+    updateCapacityProvider(teamId: string, providerId: string, input: Partial<UpsertCapacityProviderRequest>): Promise<CapacityProvider>;
+    listCapacityProviderLanes(teamId: string, providerId: string): Promise<CapacityProviderLane[]>;
+    createCapacityProviderLane(teamId: string, providerId: string, input: UpsertCapacityProviderLaneRequest): Promise<CapacityProviderLane>;
+    listCapacityGrants(teamId: string, input?: {
+        projectId?: string | null;
+        providerId?: string | null;
+    }): Promise<CapacityGrant[]>;
+    createCapacityGrant(teamId: string, input: UpsertCapacityGrantRequest): Promise<CapacityGrant>;
+    getProjectCapacityPlan(projectId: string, environment?: ProjectEnvironmentName | 'local' | null): Promise<CapacityPlan>;
+    recordRunnerCapacityEstimate(projectId: string, input: CreateTaskEstimateRequest | {
+        estimates: CreateTaskEstimateRequest[];
+    }): Promise<TaskEstimate | TaskEstimate[]>;
+    createRunnerCapacityReservation(projectId: string, input: CreateCapacityReservationRequest): Promise<CapacityReservation>;
+    recordRunnerCapacityUsage(projectId: string, input: RecordCapacityUsageRequest & {
+        usageActual?: CreateTaskUsageActualRequest;
+    }): Promise<{
+        entry: unknown;
+        usageActual: unknown | null;
+    }>;
+    recordRunnerCapacityRoutingDecision(projectId: string, input: CreateCapacityRoutingDecisionRequest): Promise<CapacityRoutingDecision>;
+    createRunnerApprovalRequest(projectId: string, input: CreateApprovalRequestRequest): Promise<ApprovalRequest>;
+    decideApprovalRequest(approvalRequestId: string, input: {
+        state?: 'approved' | 'rejected';
+        optionId?: string | null;
+        note?: string | null;
+        decision?: Record<string, unknown>;
+    }): Promise<ApprovalRequest>;
     listTeamProducts(teamId: string): Promise<CatalogItem[]>;
     launchProject(teamId: string, input: LaunchProjectRequest): Promise<LaunchProjectResult>;
     getProjectSummary(projectId: string): Promise<ProjectOverviewSummary>;

package/dist/control-plane-client.js

@@ -159,6 +159,34 @@ class ControlPlaneClient {
       { body: input }
     );
   }
+  getProjectWorkdayPolicy(projectId, environment = "staging") {
+    return this.requestJson(
+      "GET",
+      `/v1/projects/${encodeURIComponent(projectId)}/workday-policy`,
+      { query: { environment } }
+    );
+  }
+  upsertProjectWorkdayPolicy(projectId, input) {
+    return this.requestJson(
+      "PUT",
+      `/v1/projects/${encodeURIComponent(projectId)}/workday-policy`,
+      { body: input }
+    );
+  }
+  getProjectWorkdayStatus(projectId, environment = "staging") {
+    return this.requestJson(
+      "GET",
+      `/v1/projects/${encodeURIComponent(projectId)}/workday-status`,
+      { query: { environment } }
+    );
+  }
+  createProjectWorkdayRequest(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/workday-requests`,
+      { body: input }
+    );
+  }
   listProjectPriorityOverrides(projectId) {
     return this.requestJson(
       "GET",
@@ -228,6 +256,41 @@ class ControlPlaneClient {
       { body: input }
     );
   }
+  recordWorkerRunner(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/worker-runners`,
+      { body: input }
+    );
+  }
+  listWorkerRunners(projectId, environment = "staging") {
+    return this.requestJson(
+      "GET",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/worker-runners`,
+      { query: { environment } }
+    );
+  }
+  recordRepositoryClaim(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/repository-claims`,
+      { body: input }
+    );
+  }
+  listRepositoryClaims(projectId, repositoryId) {
+    return this.requestJson(
+      "GET",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/repository-claims`,
+      { query: { repositoryId: repositoryId ?? null } }
+    );
+  }
+  recordRunnerScaleDecisionV2(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/runner-scale-decisions`,
+      { body: input }
+    );
+  }
   getTeamHomeSummary(teamId) {
     return this.requestJson("GET", `/v1/teams/${encodeURIComponent(teamId)}/home`);
   }
@@ -260,6 +323,97 @@ class ControlPlaneClient {
       { body: input }
     );
   }
+  listCapacityProviders(teamId) {
+    return this.requestJson(
+      "GET",
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers`
+    );
+  }
+  createCapacityProvider(teamId, input) {
+    return this.requestJson("POST", `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers`, {
+      body: input
+    });
+  }
+  updateCapacityProvider(teamId, providerId, input) {
+    return this.requestJson(
+      "PATCH",
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}`,
+      { body: input }
+    );
+  }
+  listCapacityProviderLanes(teamId, providerId) {
+    return this.requestJson(
+      "GET",
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}/lanes`
+    );
+  }
+  createCapacityProviderLane(teamId, providerId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}/lanes`,
+      { body: input }
+    );
+  }
+  listCapacityGrants(teamId, input = {}) {
+    return this.requestJson("GET", `/v1/teams/${encodeURIComponent(teamId)}/capacity-grants`, {
+      query: {
+        projectId: input.projectId ?? null,
+        providerId: input.providerId ?? null
+      }
+    });
+  }
+  createCapacityGrant(teamId, input) {
+    return this.requestJson("POST", `/v1/teams/${encodeURIComponent(teamId)}/capacity-grants`, {
+      body: input
+    });
+  }
+  getProjectCapacityPlan(projectId, environment) {
+    return this.requestJson("GET", `/v1/projects/${encodeURIComponent(projectId)}/capacity-plan`, {
+      query: { environment: environment ?? null }
+    });
+  }
+  recordRunnerCapacityEstimate(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/capacity/estimates`,
+      { body: input }
+    );
+  }
+  createRunnerCapacityReservation(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/capacity/reservations`,
+      { body: input }
+    );
+  }
+  recordRunnerCapacityUsage(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/capacity/usage`,
+      { body: input }
+    );
+  }
+  recordRunnerCapacityRoutingDecision(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/capacity/routing-decisions`,
+      { body: input }
+    );
+  }
+  createRunnerApprovalRequest(projectId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/projects/${encodeURIComponent(projectId)}/runner/approval-requests`,
+      { body: input }
+    );
+  }
+  decideApprovalRequest(approvalRequestId, input) {
+    return this.requestJson(
+      "POST",
+      `/v1/approval-requests/${encodeURIComponent(approvalRequestId)}/decide`,
+      { body: input }
+    );
+  }
   listTeamProducts(teamId) {
     return this.requestJson("GET", `/v1/teams/${encodeURIComponent(teamId)}/products`);
   }

package/dist/control-plane.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPoolAutoscalePolicy, ProjectDeploymentKind, ProjectDeploymentStatus, ProjectEnvironmentName, ProjectInfrastructureResourceKind, ProjectInfrastructureResourceProvider, TreeseedHostingKind, TreeseedHostingRegistration } from './sdk-types.ts';
+import type { AgentPoolAutoscalePolicy, ApprovalRequest, CapacityPlan, CapacityReservation, CapacityRoutingDecision, CreateApprovalRequestRequest, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, ProjectDeploymentKind, ProjectDeploymentStatus, ProjectEnvironmentName, ProjectInfrastructureResourceKind, ProjectInfrastructureResourceProvider, RecordCapacityUsageRequest, TreeseedHostingKind, TreeseedHostingRegistration } from './sdk-types.ts';
 import type { TreeseedDeployConfig } from './platform/contracts.ts';
 export type ControlPlaneReporterKind = 'noop' | 'market_http' | 'self_http';
 export interface ControlPlaneEnvironmentReport {
@@ -78,6 +78,11 @@ export interface ControlPlaneReporter {
     registerAgentPoolHeartbeat(input: ControlPlaneAgentPoolHeartbeat): Promise<void>;
     reportScaleDecision(input: ControlPlaneScaleDecisionReport): Promise<void>;
     reportWorkdaySummary(input: ControlPlaneWorkdaySummaryReport): Promise<void>;
+    getProjectCapacityPlan(environment?: ProjectEnvironmentName | 'local' | null): Promise<CapacityPlan | null>;
+    createCapacityReservation(input: CreateCapacityReservationRequest): Promise<CapacityReservation | null>;
+    reportCapacityUsage(input: RecordCapacityUsageRequest): Promise<void>;
+    reportCapacityRoutingDecision(input: CreateCapacityRoutingDecisionRequest): Promise<CapacityRoutingDecision | null>;
+    createApprovalRequest(input: CreateApprovalRequestRequest): Promise<ApprovalRequest | null>;
 }
 export interface ControlPlaneReporterOptions {
     kind?: ControlPlaneReporterKind | null;

package/dist/control-plane.js

@@ -41,6 +41,20 @@ class NoopControlPlaneReporter {
   }
   async reportWorkdaySummary() {
   }
+  async getProjectCapacityPlan() {
+    return null;
+  }
+  async createCapacityReservation() {
+    return null;
+  }
+  async reportCapacityUsage() {
+  }
+  async reportCapacityRoutingDecision() {
+    return null;
+  }
+  async createApprovalRequest() {
+    return null;
+  }
 }
 class HttpControlPlaneReporter {
   constructor(kind, projectId, baseUrl, runnerToken, fetchImpl = fetch) {
@@ -59,7 +73,7 @@ class HttpControlPlaneReporter {
   enabled;
   async request(method, pathname, body) {
     if (!this.enabled || !this.baseUrl || !this.runnerToken) {
-      return;
+      return null;
     }
     const response = await this.fetchImpl(new URL(pathname, this.baseUrl), {
       method,
@@ -67,11 +81,13 @@ class HttpControlPlaneReporter {
         authorization: `Bearer ${this.runnerToken}`,
         "content-type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: body === void 0 ? void 0 : JSON.stringify(body)
     });
     if (!response.ok) {
       throw new Error(`Control-plane request failed for ${pathname}: ${response.status} ${response.statusText}`);
     }
+    const envelope = await response.json().catch(() => null);
+    return envelope?.payload ?? null;
   }
   async reportEnvironment(input) {
     if (!this.projectId) return;
@@ -109,6 +125,27 @@ class HttpControlPlaneReporter {
     if (!this.projectId) return;
     await this.request("POST", `/v1/projects/${this.projectId}/runner/workdays`, input);
   }
+  async getProjectCapacityPlan(environment) {
+    if (!this.projectId) return null;
+    const suffix = environment ? `?environment=${encodeURIComponent(environment)}` : "";
+    return this.request("GET", `/v1/projects/${this.projectId}/capacity-plan${suffix}`);
+  }
+  async createCapacityReservation(input) {
+    if (!this.projectId) return null;
+    return this.request("POST", `/v1/projects/${this.projectId}/runner/capacity/reservations`, input);
+  }
+  async reportCapacityUsage(input) {
+    if (!this.projectId) return;
+    await this.request("POST", `/v1/projects/${this.projectId}/runner/capacity/usage`, input);
+  }
+  async reportCapacityRoutingDecision(input) {
+    if (!this.projectId) return null;
+    return this.request("POST", `/v1/projects/${this.projectId}/runner/capacity/routing-decisions`, input);
+  }
+  async createApprovalRequest(input) {
+    if (!this.projectId) return null;
+    return this.request("POST", `/v1/projects/${this.projectId}/runner/approval-requests`, input);
+  }
 }
 function createControlPlaneReporter(options = {}) {
   const kind = resolveReporterKind(options);

package/dist/d1-store.d.ts

@@ -1,7 +1,7 @@
 import type { ContentLeaseRecord } from './types/agents.ts';
 import type { D1DatabaseLike } from './types/cloudflare.ts';
 import type { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamSummary } from './knowledge-coop.ts';
-import type { SdkAppendTaskEventRequest, SdkAckMessageRequest, SdkClaimMessageRequest, SdkClaimTaskRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateReportRequest, SdkCreateMessageRequest, SdkCreatePrioritySnapshotRequest, SdkCreateTaskRequest, SdkCursorEntity, SdkCursorRequest, SdkFailTaskRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkLeaseEntity, SdkLeaseReleaseRequest, SdkManagerContextPayload, SdkMessageEntity, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkPriorityOverrideRequest, SdkRecordRunRequest, SdkRecordScaleDecisionRequest, SdkRecordTaskCreditsRequest, SdkReportEntity, SdkRunEntity, SdkSearchRequest, SdkStartWorkDayRequest, SdkSubscriptionEntity, SdkTaskEntity, SdkTaskSearchRequest, SdkUpsertWorkPolicyRequest, SdkTaskProgressRequest, SdkUpdateRequest, SdkWorkDayEntity, ScaleDecision, TaskCreditLedgerEntry, WorkdayPolicy, PrioritySnapshot } from './sdk-types.ts';
+import type { SdkAppendTaskEventRequest, SdkAckMessageRequest, SdkClaimMessageRequest, SdkClaimTaskRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateReportRequest, SdkCreateMessageRequest, SdkCreatePrioritySnapshotRequest, SdkCreateTaskRequest, SdkCursorEntity, SdkCursorRequest, SdkFailTaskRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkLeaseEntity, SdkLeaseReleaseRequest, SdkManagerContextPayload, SdkMessageEntity, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkPriorityOverrideRequest, SdkClaimWorkdayManagerLeaseRequest, SdkCreateWorkdayRequest, SdkRecordRepositoryClaimRequest, SdkRecordRunnerScaleDecisionRequest, SdkRecordWorkerRunnerRequest, SdkRecordRunRequest, SdkRecordScaleDecisionRequest, SdkRecordTaskCreditsRequest, SdkReleaseWorkdayManagerLeaseRequest, SdkReportEntity, SdkRunEntity, SdkSearchRequest, SdkStartWorkDayRequest, SdkSubscriptionEntity, SdkTaskEntity, SdkTaskSearchRequest, SdkUpsertWorkPolicyRequest, SdkTaskProgressRequest, SdkUpdateWorkDayGraphRequest, SdkUpdateRequest, SdkWorkDayEntity, RepositoryClaim, RunnerScaleDecision, ScaleDecision, TaskCreditLedgerEntry, WorkdayManagerLease, WorkdayPolicy, WorkdayRequest, WorkerRunner, PrioritySnapshot } from './sdk-types.ts';
 import { type LeaseClaimInput } from './stores/lease-store.ts';
 export interface TryClaimContentLeaseInput extends LeaseClaimInput {
 }
@@ -37,6 +37,17 @@ export interface AgentDatabase {
     getManagerContext(taskId: string): Promise<SdkManagerContextPayload>;
     getWorkPolicy(projectId: string, environment?: string): Promise<WorkdayPolicy | null>;
     upsertWorkPolicy(request: SdkUpsertWorkPolicyRequest): Promise<WorkdayPolicy | null>;
+    createWorkdayRequest(request: SdkCreateWorkdayRequest): Promise<WorkdayRequest | null>;
+    listWorkdayRequests(projectId: string, environment: string, state?: string | null): Promise<WorkdayRequest[]>;
+    claimWorkdayManagerLease(request: SdkClaimWorkdayManagerLeaseRequest): Promise<WorkdayManagerLease | null>;
+    releaseWorkdayManagerLease(request: SdkReleaseWorkdayManagerLeaseRequest): Promise<WorkdayManagerLease | null>;
+    recordWorkerRunner(request: SdkRecordWorkerRunnerRequest): Promise<WorkerRunner | null>;
+    listWorkerRunners(projectId: string, environment: string): Promise<WorkerRunner[]>;
+    recordRepositoryClaim(request: SdkRecordRepositoryClaimRequest): Promise<RepositoryClaim | null>;
+    listRepositoryClaims(projectId: string, repositoryId?: string | null): Promise<RepositoryClaim[]>;
+    recordRunnerScaleDecision(request: SdkRecordRunnerScaleDecisionRequest): Promise<RunnerScaleDecision | null>;
+    listRunnerScaleDecisions(projectId: string, environment: string, workDayId?: string | null): Promise<RunnerScaleDecision[]>;
+    updateWorkDayGraph(request: SdkUpdateWorkDayGraphRequest): Promise<SdkWorkDayEntity | null>;
     listPriorityOverrides(projectId: string): Promise<Record<string, unknown>[]>;
     upsertPriorityOverride(request: SdkPriorityOverrideRequest): Promise<Record<string, unknown> | null>;
     createPrioritySnapshot(request: SdkCreatePrioritySnapshotRequest): Promise<PrioritySnapshot | null>;
@@ -71,6 +82,11 @@ export declare class MemoryAgentDatabase implements AgentDatabase {
     private readonly graphRuns;
     private readonly reports;
     private readonly workPolicies;
+    private readonly workdayRequests;
+    private readonly workdayManagerLeases;
+    private readonly workerRunners;
+    private readonly repositoryClaims;
+    private readonly runnerScaleDecisions;
     private readonly priorityOverrides;
     private readonly prioritySnapshots;
     private readonly taskCreditLedger;
@@ -145,6 +161,41 @@ export declare class MemoryAgentDatabase implements AgentDatabase {
     }>;
     getWorkPolicy(projectId: string, environment?: string): Promise<WorkdayPolicy | null>;
     upsertWorkPolicy(request: SdkUpsertWorkPolicyRequest): Promise<WorkdayPolicy>;
+    createWorkdayRequest(request: SdkCreateWorkdayRequest): Promise<WorkdayRequest>;
+    listWorkdayRequests(projectId: string, environment: string, state?: string | null): Promise<WorkdayRequest[]>;
+    claimWorkdayManagerLease(request: SdkClaimWorkdayManagerLeaseRequest): Promise<WorkdayManagerLease | null>;
+    releaseWorkdayManagerLease(request: SdkReleaseWorkdayManagerLeaseRequest): Promise<{
+        state: "released";
+        updatedAt: string;
+        id: string;
+        projectId: string;
+        environment: import("./sdk-types.ts").ProjectEnvironmentName | "local";
+        workDayId: string | null;
+        managerId: string;
+        heartbeatAt: string;
+        expiresAt: string;
+        metadata?: Record<string, unknown>;
+        createdAt: string;
+    } | null>;
+    recordWorkerRunner(request: SdkRecordWorkerRunnerRequest): Promise<WorkerRunner>;
+    listWorkerRunners(projectId: string, environment: string): Promise<WorkerRunner[]>;
+    recordRepositoryClaim(request: SdkRecordRepositoryClaimRequest): Promise<RepositoryClaim>;
+    listRepositoryClaims(projectId: string, repositoryId?: string | null): Promise<RepositoryClaim[]>;
+    recordRunnerScaleDecision(request: SdkRecordRunnerScaleDecisionRequest): Promise<RunnerScaleDecision>;
+    listRunnerScaleDecisions(projectId: string, environment: string, workDayId?: string | null): Promise<RunnerScaleDecision[]>;
+    updateWorkDayGraph(request: SdkUpdateWorkDayGraphRequest): Promise<{
+        graphVersion: string;
+        summaryJson: string;
+        updatedAt: string;
+        id: string;
+        projectId: string;
+        state: string;
+        capacityBudget: number;
+        capacityUsed: number;
+        startedAt: string;
+        endedAt: string | null;
+        createdAt: string;
+    } | null>;
     listPriorityOverrides(projectId: string): Promise<Record<string, unknown>[]>;
     upsertPriorityOverride(request: SdkPriorityOverrideRequest): Promise<{
         id: string;
@@ -230,6 +281,17 @@ export declare class CloudflareD1AgentDatabase implements AgentDatabase {
     }>;
     getWorkPolicy(projectId: string, environment?: string): Promise<WorkdayPolicy | null>;
     upsertWorkPolicy(request: SdkUpsertWorkPolicyRequest): Promise<WorkdayPolicy | null>;
+    createWorkdayRequest(request: SdkCreateWorkdayRequest): Promise<WorkdayRequest | null>;
+    listWorkdayRequests(projectId: string, environment: string, state?: string | null): Promise<WorkdayRequest[]>;
+    claimWorkdayManagerLease(request: SdkClaimWorkdayManagerLeaseRequest): Promise<WorkdayManagerLease | null>;
+    releaseWorkdayManagerLease(request: SdkReleaseWorkdayManagerLeaseRequest): Promise<WorkdayManagerLease | null>;
+    recordWorkerRunner(request: SdkRecordWorkerRunnerRequest): Promise<WorkerRunner | null>;
+    listWorkerRunners(projectId: string, environment: string): Promise<WorkerRunner[]>;
+    recordRepositoryClaim(request: SdkRecordRepositoryClaimRequest): Promise<RepositoryClaim | null>;
+    listRepositoryClaims(projectId: string, repositoryId?: string | null): Promise<RepositoryClaim[]>;
+    recordRunnerScaleDecision(request: SdkRecordRunnerScaleDecisionRequest): Promise<RunnerScaleDecision | null>;
+    listRunnerScaleDecisions(projectId: string, environment: string, workDayId?: string | null): Promise<RunnerScaleDecision[]>;
+    updateWorkDayGraph(request: SdkUpdateWorkDayGraphRequest): Promise<SdkWorkDayEntity | null>;
     listPriorityOverrides(projectId: string): Promise<import("./stores/helpers.ts").DatabaseRow[]>;
     upsertPriorityOverride(request: SdkPriorityOverrideRequest): Promise<{
         id: string;