@treeseed/sdk 0.8.7 → 0.8.9

package/dist/capacity.d.ts

@@ -1,4 +1,4 @@
-import type { CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProviderLane, CapacityReservation, TaskEstimateProfile } from './sdk-types.ts';
+import type { CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityReservation, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, RecordCapacityUsageRequest, TaskEstimateProfile } from './sdk-types.ts';
 import type { AgentProviderProfile } from './types/agents.ts';
 export type ProcessingEnvironment = 'local' | 'staging' | 'prod';
 export interface CapacityProviderRegistration {
@@ -62,6 +62,111 @@ export interface CapacityLaneScore {
     costPenalty: number;
     reasons: string[];
 }
+export interface CapacityTaskEstimate {
+    taskSignature: string;
+    confidence: CapacityEstimateConfidence;
+    estimatedCreditsP50: number;
+    estimatedCreditsP90: number;
+    reservedCredits: number;
+}
+export interface TeamCapacitySummary {
+    teamId: string;
+    monthlyCredits: number | null;
+    monthlyUsedCredits: number;
+    monthlyRemainingCredits: number | null;
+    dailyCredits: number | null;
+    dailyUsedCredits: number;
+    dailyReservedCredits: number;
+    dailyRemainingCredits: number | null;
+    providerCount: number;
+    activeProviderCount: number;
+    degradedProviderCount: number;
+    grantCount: number;
+    blockedTaskCount: number;
+    approvalRequiredCount: number;
+}
+export interface ProjectCapacitySummary extends TeamCapacitySummary {
+    projectId: string;
+    environment: ProcessingEnvironment;
+    readiness: 'ready' | 'waiting_for_budget' | 'waiting_for_provider' | 'paused_by_policy' | 'needs_approval';
+    reasons: string[];
+}
+export interface RouteAndReserveInput {
+    plan: CapacityPlan;
+    estimate: CapacityTaskEstimate;
+    taskId?: string | null;
+    workDayId?: string | null;
+    taskKind?: string | null;
+    requiredCapabilities?: string[];
+    modelClass?: string | null;
+    priorityClass?: string | null;
+    allowDegradedProviders?: boolean;
+    repositoryMutation?: boolean;
+    production?: boolean;
+    selectedModel?: string | null;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+export type RouteAndReserveBlockCode = 'no_capacity_provider' | 'no_capacity_grant' | 'no_eligible_lane' | 'insufficient_budget' | 'approval_required';
+export interface RouteAndReserveCandidate {
+    providerId: string;
+    laneId: string;
+    grantId: string;
+    remainingCredits: number | null;
+    score: CapacityLaneScore;
+    eligible: boolean;
+    reasons: string[];
+}
+export type RouteAndReserveResult = {
+    ok: true;
+    provider: CapacityProvider;
+    lane: CapacityProviderLane;
+    grant: CapacityGrant;
+    estimate: CapacityTaskEstimate;
+    remainingCreditsBefore: number | null;
+    reservation: CreateCapacityReservationRequest;
+    routingDecision: CreateCapacityRoutingDecisionRequest;
+    ledgerEntry: RecordCapacityUsageRequest;
+    capacityMetadata: {
+        providerId: string;
+        laneId: string;
+        grantId: string;
+        reservationId: string | null;
+        routingDecisionId: string | null;
+        estimatedCreditsP50: number;
+        estimatedCreditsP90: number;
+        reservedCredits: number;
+    };
+    candidates: RouteAndReserveCandidate[];
+} | {
+    ok: false;
+    code: RouteAndReserveBlockCode;
+    reason: string;
+    estimate: CapacityTaskEstimate;
+    candidates: RouteAndReserveCandidate[];
+};
+export interface CapacitySettlementInput {
+    reservation: CapacityReservation;
+    actualCredits: number;
+    actualProviderUnits?: number | null;
+    actualUsd?: number | null;
+    teamId?: string | null;
+    projectId?: string | null;
+    workDayId?: string | null;
+    taskId?: string | null;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CapacitySettlement {
+    reservationId: string;
+    state: 'consumed' | 'overran_pending_approval';
+    consumeEntry: RecordCapacityUsageRequest;
+    releaseEntry: RecordCapacityUsageRequest | null;
+    overrunEntry: RecordCapacityUsageRequest | null;
+    consumedCredits: number;
+    releasedCredits: number;
+    overrunCredits: number;
+}
 export declare function reserveCreditsForEstimate(input: CapacityEstimateInput): {
     taskSignature: string;
     confidence: CapacityEstimateConfidence;
@@ -78,9 +183,23 @@ export declare function summarizeCapacityPlan(plan: CapacityPlan): {
     laneCount: number;
     grantCount: number;
 };
+export declare function summarizeTeamCapacityPlan(plan: CapacityPlan): TeamCapacitySummary;
+export declare function summarizeProjectCapacityPlan(plan: CapacityPlan, options?: {
+    workPolicyEnabled?: boolean | null;
+    approvalRequiredCount?: number;
+    blockedTaskCount?: number;
+}): ProjectCapacitySummary;
 export declare function scoreCapacityLane(input: CapacityLaneCandidate): CapacityLaneScore;
 export declare function selectBestCapacityLane(candidates: CapacityLaneCandidate[]): {
     selected: CapacityLaneScore;
     scores: CapacityLaneScore[];
 };
 export declare function reservationHasCapacity(reservation: CapacityReservation): boolean;
+export declare function createReservationReleaseEntry(input: {
+    reservation: CapacityReservation;
+    credits?: number | null;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}): RecordCapacityUsageRequest;
+export declare function settleCapacityActuals(input: CapacitySettlementInput): CapacitySettlement;
+export declare function routeAndReserveCapacity(input: RouteAndReserveInput): RouteAndReserveResult;

package/dist/capacity.js

@@ -6,6 +6,97 @@ function scarcityPenalty(level) {
   if (level === "medium") return 15;
   return 0;
 }
+function metadataStatus(value) {
+  const status = value?.status;
+  return typeof status === "string" ? status : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function reservationDebit(reservation) {
+  if (reservation.state === "released" || reservation.state === "expired" || reservation.state === "cancelled") {
+    return 0;
+  }
+  if (reservation.state === "consumed" || reservation.state === "failed") {
+    return Math.max(0, reservation.consumedCredits);
+  }
+  return Math.max(reservation.reservedCredits, reservation.consumedCredits, 0);
+}
+function activeReservationDebit(reservation) {
+  if (reservation.state === "reserved" || reservation.state === "consuming") {
+    return Math.max(reservation.reservedCredits, reservation.consumedCredits, 0);
+  }
+  if (reservation.state === "consumed" || reservation.state === "failed") {
+    return Math.max(reservation.consumedCredits, 0);
+  }
+  return 0;
+}
+function grantMatchesReservation(grant, reservation) {
+  if (grant.teamId !== reservation.teamId) return false;
+  if (grant.capacityProviderId !== reservation.capacityProviderId) return false;
+  if (grant.laneId && grant.laneId !== reservation.laneId) return false;
+  if (grant.projectId && grant.projectId !== reservation.projectId) return false;
+  return true;
+}
+function grantRemainingCredits(plan, grant) {
+  const limit = grant.dailyCreditLimit ?? grant.monthlyCreditLimit;
+  if (limit === null || limit === void 0) return null;
+  const debits = plan.activeReservations.filter((reservation) => grantMatchesReservation(grant, reservation)).reduce((total, reservation) => total + reservationDebit(reservation), 0);
+  return Math.max(0, Number(limit) - debits);
+}
+function providerIsEligible(provider, input) {
+  if (provider.status === "active") return true;
+  if (provider.status === "degraded" && input.allowDegradedProviders) return true;
+  return false;
+}
+function grantIsEligible(grant, input) {
+  if (grant.state !== "active") return false;
+  if (grant.teamId !== input.plan.teamId) return false;
+  if (grant.environment && grant.environment !== input.plan.environment) return false;
+  if (grant.projectId && grant.projectId !== input.plan.projectId) return false;
+  return true;
+}
+function lanePolicyReasons(lane, input) {
+  const reasons = [];
+  const laneStatus = metadataStatus(lane.metadata);
+  if (laneStatus && laneStatus !== "active") reasons.push(`lane_status:${laneStatus}`);
+  const policy = lane.routingPolicy ?? {};
+  const taskKinds = stringArray(policy.taskKinds);
+  const taskKind = input.taskKind ?? input.estimate.taskSignature;
+  if (taskKinds.length > 0 && !taskKinds.includes(taskKind)) reasons.push("task_kind_mismatch");
+  const requiredCapabilities = stringArray(policy.requiredCapabilities);
+  const missingCapabilities = (input.requiredCapabilities ?? []).filter((capability) => !requiredCapabilities.includes(capability));
+  if (requiredCapabilities.length > 0 && missingCapabilities.length > 0) {
+    reasons.push("capability_mismatch");
+  }
+  const allowedEnvironments = stringArray(policy.allowedEnvironments);
+  if (allowedEnvironments.length > 0 && !allowedEnvironments.includes(input.plan.environment)) {
+    reasons.push("environment_mismatch");
+  }
+  const maxCreditsPerTask = numberValue(policy.maxCreditsPerTask);
+  if (maxCreditsPerTask !== null && input.estimate.reservedCredits > maxCreditsPerTask) {
+    reasons.push("task_credit_limit_exceeded");
+  }
+  const approvalThreshold = numberValue(policy.requiresApprovalAboveCredits);
+  if (approvalThreshold !== null && input.estimate.reservedCredits > approvalThreshold) {
+    reasons.push("approval_required");
+  }
+  const repositoryMutationAllowed = booleanValue(policy.repositoryMutationAllowed);
+  if (input.repositoryMutation && repositoryMutationAllowed === false) {
+    reasons.push("repository_mutation_not_allowed");
+  }
+  const productionAllowed = booleanValue(policy.productionAllowed);
+  if (input.production && productionAllowed === false) {
+    reasons.push("production_not_allowed");
+  }
+  return reasons;
+}
 function reserveCreditsForEstimate(input) {
   const profileP50 = finiteNumber(input.profile?.creditsP50);
   const profileP90 = finiteNumber(input.profile?.creditsP90);
@@ -26,7 +117,7 @@ function reserveCreditsForEstimate(input) {
   };
 }
 function summarizeCapacityPlan(plan) {
-  const reservedCredits = plan.activeReservations.filter((reservation) => reservation.state === "reserved").reduce((total, reservation) => total + reservation.reservedCredits, 0);
+  const reservedCredits = plan.activeReservations.filter((reservation) => reservation.state === "reserved" || reservation.state === "consuming").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 {
@@ -39,6 +130,55 @@ function summarizeCapacityPlan(plan) {
     grantCount: plan.grants.length
   };
 }
+function summarizeTeamCapacityPlan(plan) {
+  const dailyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.dailyCreditLimit ?? 0), 0);
+  const monthlyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.monthlyCreditLimit ?? 0), 0);
+  const dailyReservedCredits = plan.activeReservations.reduce((total, reservation) => total + activeReservationDebit(reservation), 0);
+  const dailyUsedCredits = plan.activeReservations.reduce((total, reservation) => total + Math.max(0, reservation.consumedCredits), 0);
+  return {
+    teamId: plan.teamId,
+    monthlyCredits: monthlyCredits > 0 ? monthlyCredits : null,
+    monthlyUsedCredits: dailyUsedCredits,
+    monthlyRemainingCredits: monthlyCredits > 0 ? Math.max(0, monthlyCredits - dailyUsedCredits) : null,
+    dailyCredits: dailyCredits > 0 ? dailyCredits : null,
+    dailyUsedCredits,
+    dailyReservedCredits,
+    dailyRemainingCredits: dailyCredits > 0 ? Math.max(0, dailyCredits - dailyReservedCredits - dailyUsedCredits) : null,
+    providerCount: plan.providers.length,
+    activeProviderCount: plan.providers.filter((provider) => provider.status === "active").length,
+    degradedProviderCount: plan.providers.filter((provider) => provider.status === "degraded").length,
+    grantCount: plan.grants.length,
+    blockedTaskCount: 0,
+    approvalRequiredCount: 0
+  };
+}
+function summarizeProjectCapacityPlan(plan, options = {}) {
+  const summary = summarizeTeamCapacityPlan(plan);
+  const reasons = [];
+  let readiness = "ready";
+  if (options.workPolicyEnabled === false) {
+    readiness = "paused_by_policy";
+    reasons.push("work_policy_disabled");
+  } else if (summary.activeProviderCount <= 0) {
+    readiness = "waiting_for_provider";
+    reasons.push("no_active_provider");
+  } else if (summary.dailyRemainingCredits !== null && summary.dailyRemainingCredits <= 0) {
+    readiness = "waiting_for_budget";
+    reasons.push("daily_budget_exhausted");
+  } else if ((options.approvalRequiredCount ?? 0) > 0) {
+    readiness = "needs_approval";
+    reasons.push("approval_required");
+  }
+  return {
+    ...summary,
+    projectId: plan.projectId,
+    environment: plan.environment,
+    readiness,
+    reasons,
+    blockedTaskCount: options.blockedTaskCount ?? summary.blockedTaskCount,
+    approvalRequiredCount: options.approvalRequiredCount ?? summary.approvalRequiredCount
+  };
+}
 function scoreCapacityLane(input) {
   const reasons = [];
   let agentFit = 0;
@@ -91,10 +231,239 @@ function selectBestCapacityLane(candidates) {
 function reservationHasCapacity(reservation) {
   return reservation.state === "reserved" && reservation.reservedCredits > reservation.consumedCredits;
 }
+function createReservationReleaseEntry(input) {
+  const credits = Math.max(0, Number(input.credits ?? input.reservation.reservedCredits - input.reservation.consumedCredits));
+  return {
+    capacityProviderId: input.reservation.capacityProviderId,
+    laneId: input.reservation.laneId,
+    reservationId: input.reservation.id,
+    teamId: input.reservation.teamId,
+    projectId: input.reservation.projectId,
+    workDayId: input.reservation.workDayId,
+    taskId: input.reservation.taskId,
+    phase: "reservation_released",
+    credits: -credits,
+    source: input.source ?? "capacity_coordinator",
+    metadata: input.metadata ?? {}
+  };
+}
+function settleCapacityActuals(input) {
+  const consumedCredits = Math.max(0, Number(input.actualCredits ?? 0));
+  const releasedCredits = Math.max(0, input.reservation.reservedCredits - consumedCredits);
+  const overrunCredits = Math.max(0, consumedCredits - input.reservation.reservedCredits);
+  const base = {
+    capacityProviderId: input.reservation.capacityProviderId,
+    laneId: input.reservation.laneId,
+    reservationId: input.reservation.id,
+    teamId: input.teamId ?? input.reservation.teamId,
+    projectId: input.projectId ?? input.reservation.projectId,
+    workDayId: input.workDayId ?? input.reservation.workDayId,
+    taskId: input.taskId ?? input.reservation.taskId,
+    source: input.source ?? "capacity_coordinator",
+    metadata: input.metadata ?? {}
+  };
+  const consumeEntry = {
+    ...base,
+    phase: "task_completed_actual_settlement",
+    credits: consumedCredits,
+    providerUnits: input.actualProviderUnits ?? null,
+    usd: input.actualUsd ?? null
+  };
+  const releaseEntry = releasedCredits > 0 ? {
+    ...base,
+    phase: "reservation_released",
+    credits: -releasedCredits
+  } : null;
+  const overrunEntry = overrunCredits > 0 ? {
+    ...base,
+    phase: "overrun_hold",
+    credits: overrunCredits
+  } : null;
+  return {
+    reservationId: input.reservation.id,
+    state: overrunCredits > 0 ? "overran_pending_approval" : "consumed",
+    consumeEntry,
+    releaseEntry,
+    overrunEntry,
+    consumedCredits,
+    releasedCredits,
+    overrunCredits
+  };
+}
+function routeAndReserveCapacity(input) {
+  const providers = input.plan.providers.filter((provider2) => providerIsEligible(provider2, input));
+  const grants = input.plan.grants.filter((grant2) => grantIsEligible(grant2, input));
+  const candidates = [];
+  for (const grant2 of grants) {
+    const provider2 = providers.find((candidate) => candidate.id === grant2.capacityProviderId);
+    if (!provider2) continue;
+    const lanes = input.plan.lanes.filter(
+      (lane2) => lane2.capacityProviderId === provider2.id && (!grant2.laneId || grant2.laneId === lane2.id)
+    );
+    for (const lane2 of lanes) {
+      const reasons = lanePolicyReasons(lane2, input);
+      const remainingCredits = grantRemainingCredits(input.plan, grant2);
+      if (remainingCredits !== null && remainingCredits < input.estimate.reservedCredits && (grant2.overflowPolicy === "deny" || grant2.overflowPolicy === "hard_grant")) {
+        reasons.push("insufficient_budget");
+      }
+      if (remainingCredits !== null && remainingCredits < input.estimate.reservedCredits && grant2.overflowPolicy === "approval_required") {
+        reasons.push("approval_required");
+      }
+      const score = scoreCapacityLane({
+        lane: lane2,
+        grant: grant2,
+        remainingCredits,
+        taskKind: input.taskKind ?? input.estimate.taskSignature,
+        requiredCapabilities: input.requiredCapabilities,
+        modelClass: input.modelClass ?? null
+      });
+      candidates.push({
+        providerId: provider2.id,
+        laneId: lane2.id,
+        grantId: grant2.id,
+        remainingCredits,
+        score,
+        eligible: reasons.length === 0,
+        reasons
+      });
+    }
+  }
+  if (input.plan.providers.length === 0 || providers.length === 0) {
+    return {
+      ok: false,
+      code: "no_capacity_provider",
+      reason: "No active helper capacity provider is available.",
+      estimate: input.estimate,
+      candidates
+    };
+  }
+  if (grants.length === 0) {
+    return {
+      ok: false,
+      code: "no_capacity_grant",
+      reason: "No active capacity grant is available for this team, project, and environment.",
+      estimate: input.estimate,
+      candidates
+    };
+  }
+  const eligible = candidates.filter((candidate) => candidate.eligible).sort((left, right) => right.score.score - left.score.score || left.laneId.localeCompare(right.laneId));
+  const selected = eligible[0] ?? null;
+  if (!selected) {
+    const hasApprovalBlock = candidates.some((candidate) => candidate.reasons.includes("approval_required"));
+    const hasBudgetBlock = candidates.some((candidate) => candidate.reasons.includes("insufficient_budget"));
+    return {
+      ok: false,
+      code: hasApprovalBlock ? "approval_required" : hasBudgetBlock ? "insufficient_budget" : "no_eligible_lane",
+      reason: hasApprovalBlock ? "The requested helper task needs approval before capacity can be reserved." : hasBudgetBlock ? "The requested helper task is above the remaining approved budget." : "No provider lane matches the task policy and capability requirements.",
+      estimate: input.estimate,
+      candidates
+    };
+  }
+  const provider = providers.find((candidate) => candidate.id === selected.providerId);
+  const lane = input.plan.lanes.find((candidate) => candidate.id === selected.laneId);
+  const grant = grants.find((candidate) => candidate.id === selected.grantId);
+  if (!provider || !lane || !grant) {
+    return {
+      ok: false,
+      code: "no_eligible_lane",
+      reason: "The selected capacity lane could not be resolved.",
+      estimate: input.estimate,
+      candidates
+    };
+  }
+  const candidatePayload = candidates.map((candidate) => ({
+    providerId: candidate.providerId,
+    laneId: candidate.laneId,
+    grantId: candidate.grantId,
+    remainingCredits: candidate.remainingCredits,
+    eligible: candidate.eligible,
+    reasons: candidate.reasons,
+    score: candidate.score.score
+  }));
+  const scorePayload = Object.fromEntries(candidates.map((candidate) => [candidate.laneId, candidate.score]));
+  const reservation = {
+    capacityProviderId: provider.id,
+    laneId: lane.id,
+    teamId: input.plan.teamId,
+    projectId: input.plan.projectId,
+    workDayId: input.workDayId ?? null,
+    taskId: input.taskId ?? null,
+    state: "reserved",
+    reservedCredits: input.estimate.reservedCredits,
+    metadata: {
+      ...input.metadata ?? {},
+      grantId: grant.id,
+      taskSignature: input.estimate.taskSignature,
+      estimatedCreditsP50: input.estimate.estimatedCreditsP50,
+      estimatedCreditsP90: input.estimate.estimatedCreditsP90
+    }
+  };
+  const routingDecision = {
+    taskId: input.taskId ?? null,
+    workDayId: input.workDayId ?? null,
+    projectId: input.plan.projectId,
+    selectedProviderId: provider.id,
+    selectedLaneId: lane.id,
+    selectedModel: input.selectedModel ?? null,
+    decision: "selected",
+    reason: selected.score.reasons.length > 0 ? selected.score.reasons.join(",") : "best_eligible_lane",
+    candidates: candidatePayload,
+    scores: scorePayload,
+    metadata: {
+      ...input.metadata ?? {},
+      grantId: grant.id,
+      remainingCreditsBefore: selected.remainingCredits,
+      reservedCredits: input.estimate.reservedCredits
+    }
+  };
+  const ledgerEntry = {
+    capacityProviderId: provider.id,
+    laneId: lane.id,
+    teamId: input.plan.teamId,
+    projectId: input.plan.projectId,
+    workDayId: input.workDayId ?? null,
+    taskId: input.taskId ?? null,
+    phase: "reservation_created",
+    credits: input.estimate.reservedCredits,
+    source: input.source ?? "capacity_coordinator",
+    metadata: {
+      ...input.metadata ?? {},
+      grantId: grant.id,
+      taskSignature: input.estimate.taskSignature
+    }
+  };
+  return {
+    ok: true,
+    provider,
+    lane,
+    grant,
+    estimate: input.estimate,
+    remainingCreditsBefore: selected.remainingCredits,
+    reservation,
+    routingDecision,
+    ledgerEntry,
+    capacityMetadata: {
+      providerId: provider.id,
+      laneId: lane.id,
+      grantId: grant.id,
+      reservationId: reservation.id ?? null,
+      routingDecisionId: routingDecision.id ?? null,
+      estimatedCreditsP50: input.estimate.estimatedCreditsP50,
+      estimatedCreditsP90: input.estimate.estimatedCreditsP90,
+      reservedCredits: input.estimate.reservedCredits
+    },
+    candidates
+  };
+}
 export {
+  createReservationReleaseEntry,
   reservationHasCapacity,
   reserveCreditsForEstimate,
+  routeAndReserveCapacity,
   scoreCapacityLane,
   selectBestCapacityLane,
-  summarizeCapacityPlan
+  settleCapacityActuals,
+  summarizeCapacityPlan,
+  summarizeProjectCapacityPlan,
+  summarizeTeamCapacityPlan
 };

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

@@ -1,5 +1,5 @@
 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';
+import type { AgentMessageRecord, AgentStatusRecord, DirectBoardItemSummary, InboxItem, LaunchProjectRequest, LaunchProjectResult, ProjectOverviewSummary, ReleaseDetail, ReleaseSummary, SharePackageStatus, TeamHomeSummary, TeamMemberSummary, WorkstreamDetail, WorkstreamSummary } from './project-workflow.ts';
 export interface ControlPlaneClientOptions {
     baseUrl: string;
     accessToken?: string | null;

package/dist/d1-store.d.ts

@@ -1,6 +1,6 @@
 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 { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamSummary } from './project-workflow.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 {
@@ -91,7 +91,7 @@ export declare class MemoryAgentDatabase implements AgentDatabase {
     private readonly prioritySnapshots;
     private readonly taskCreditLedger;
     private readonly scaleDecisions;
-    private readonly knowledgeCoop;
+    private readonly projectWorkflow;
     private messageId;
     constructor(seed?: {
         subscriptions?: SdkSubscriptionEntity[];
@@ -235,7 +235,7 @@ export declare class CloudflareD1AgentDatabase implements AgentDatabase {
     private readonly cursors;
     private readonly leases;
     private readonly operational;
-    private readonly knowledgeCoop;
+    private readonly projectWorkflow;
     constructor(db: D1DatabaseLike);
     get(request: SdkGetRequest): Promise<Record<string, unknown> | null>;
     search(request: SdkSearchRequest): Promise<Record<string, unknown>[]>;
@@ -318,11 +318,11 @@ export declare class CloudflareD1AgentDatabase implements AgentDatabase {
         projectId: string;
         title: string;
         summary: string | null;
-        state: import("./knowledge-coop.ts").WorkstreamState;
+        state: import("./project-workflow.ts").WorkstreamState;
         branchName: string | null;
         branchRef: string | null;
         owner: string | null;
-        linkedItems: import("./knowledge-coop.ts").LinkedProjectRecordRef[];
+        linkedItems: import("./project-workflow.ts").LinkedProjectRecordRef[];
         verificationStatus: "completed" | "failed" | "waiting" | null;
         verificationSummary: string | null;
         lastSaveAt: string | null;