@treeseed/sdk 0.10.28 → 0.12.4

package/dist/agent-capacity.d.ts

@@ -0,0 +1,916 @@
+import type { CapacityGrant, CapacityLedgerEntry, CapacityPlan as LegacyCapacityPlan, CapacityProvider, CapacityReservation, ExecutionProvider, TaskUsageActual } from './sdk-types.js';
+import type { AgentRuntimeSpec, AgentWorkPackage, ExecutionCapabilityDemand, ExecutionCapabilitySupply, ExecutionProviderDescriptor, ExecutionResourceNeed } from './types/agents.js';
+export type AgentExecutionMode = 'planning' | 'acting';
+export type AllocationSetStatus = 'draft' | 'active' | 'superseded' | 'archived';
+export type ProjectAgentClassStatus = 'active' | 'paused' | 'archived';
+export type ProviderAvailabilitySessionStatus = 'open' | 'draining' | 'closed' | 'expired';
+export type ProviderAssignmentStatus = 'pending' | 'leased' | 'running' | 'completed' | 'failed' | 'returned' | 'expired';
+export type ProviderAssignmentLeaseState = 'unleased' | 'leased' | 'released' | 'expired';
+export type AgentModeRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type AgentKernelModeExecutionStatus = 'completed' | 'waiting' | 'failed' | 'returned';
+export type DecisionExecutionReadinessStatus = 'draft' | 'blocked' | 'ready' | 'stale' | 'waived';
+export type PlanningInputRequestStatus = 'requested' | 'complete' | 'waived' | 'rejected' | 'stale';
+export type DecisionExecutionInputStatus = 'proposed' | 'accepted' | 'revision_requested' | 'rejected' | 'stale';
+export type WorkdayCapacityEnvelopeStatus = 'draft' | 'active' | 'paused' | 'completed' | 'cancelled';
+export type DurableAgentCapacityPlanStatus = 'draft' | 'accepted' | 'revision_requested' | 'deferred' | 'scheduled' | 'active' | 'completed' | 'superseded';
+export type ProviderAssignmentSynthesisSource = 'approved_decision' | 'planning_input_request' | 'capacity_plan' | 'verification_failure' | 'fallback_queue' | 'fixture';
+export type AgentKernelModeFallbackCode = 'assignment_missing_project_or_agent' | 'assignment_lease_expired' | 'assignment_mode_not_allowed' | 'assignment_missing_capacity_envelope' | 'assignment_missing_decision_input' | 'assignment_handler_failed' | 'assignment_project_not_synced' | 'assignment_agent_not_found' | 'assignment_insufficient_capability' | 'assignment_decision_not_ready' | 'assignment_capacity_plan_not_accepted' | 'assignment_capacity_not_reserved' | 'assignment_capability_handle_invalid' | 'assignment_capability_handle_secret_material' | 'assignment_capability_handle_write_not_ready' | 'assignment_capability_handle_workspace_denied' | 'assignment_workflow_operation_denied' | 'assignment_eligibility_capability_mismatch' | 'assignment_retry_policy_exceeded' | 'assignment_treedx_proxy_scope_invalid' | 'assignment_fallback_quota_exceeded' | 'assignment_output_invalid';
+export declare const AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES: readonly ["context_only", "workspace_write", "brokered_workspace", "full_workspace_no_credentials", "trusted_direct"];
+export type AgentAssignmentWorkspaceAccessMode = (typeof AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES)[number];
+export type AgentAssignmentCapabilityHandleKind = 'repository_access' | 'treedx_workspace' | 'workflow_operation' | 'secret_use';
+export type AgentAssignmentCapabilityOperation = 'read' | 'write' | 'test' | 'release' | 'dispatch_workflow' | 'commit' | 'push' | string;
+export interface AllocationSetSlice {
+    projectId: string | null;
+    capacityProviderId: string;
+    laneId?: string | null;
+    environment?: string | null;
+    priorityWeight?: number | null;
+    overflowPolicy?: string | null;
+    percent?: number | null;
+    dailyCreditLimit?: number | null;
+    monthlyCreditLimit?: number | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AllocationSet {
+    id: string;
+    teamId: string;
+    version: string;
+    status: AllocationSetStatus | string;
+    effectiveFrom?: string | null;
+    effectiveUntil?: string | null;
+    policy: Record<string, unknown>;
+    slices: AllocationSetSlice[];
+    createdById?: string | null;
+    activatedAt?: string | null;
+    supersededById?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export type CapacityAllocationSet = AllocationSet;
+export interface AgentKernelProfile {
+    id?: string;
+    name?: string;
+    defaultMode?: AgentExecutionMode;
+    allowedModes?: AgentExecutionMode[];
+    planningBudgetPercent?: number;
+    actingBudgetPercent?: number;
+    maxConcurrentModeRuns?: number;
+    fallbackMode?: AgentExecutionMode | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelPolicy {
+    modeSelection?: Record<string, unknown>;
+    budgetSplit?: Record<string, unknown>;
+    fallback?: Record<string, unknown>;
+    outputValidation?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface ProjectAgentClass {
+    id: string;
+    teamId: string;
+    projectId: string;
+    slug: string;
+    name: string;
+    status: ProjectAgentClassStatus | string;
+    allowedModes: AgentExecutionMode[];
+    requiredCapabilities: string[];
+    kernelProfile: AgentKernelProfile;
+    kernelPolicy: AgentKernelPolicy;
+    handlerRefs: Record<string, unknown>;
+    outputContracts: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface WorkdayCapacityEnvelope {
+    teamId: string;
+    projectId: string;
+    workDayId?: string | null;
+    environment?: string | null;
+    allocationSetId?: string | null;
+    availableCredits?: number | null;
+    reservedCredits?: number | null;
+    consumedCredits?: number | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCapacityEnvelope extends WorkdayCapacityEnvelope {
+    mode: AgentExecutionMode;
+    projectAgentClassId?: string | null;
+    capacityProviderId?: string | null;
+    executionProviderId?: string | null;
+    laneId?: string | null;
+    reservationId?: string | null;
+    nativeUnit?: string | null;
+    reservedNativeAmount?: number | null;
+    limits?: Record<string, unknown>;
+}
+export interface DecisionExecutionInput {
+    teamId: string;
+    projectId: string;
+    projectAgentClassId: string;
+    mode: AgentExecutionMode;
+    taskId?: string | null;
+    workDayId?: string | null;
+    agentId?: string | null;
+    handlerId?: string | null;
+    capacity: AgentCapacityEnvelope;
+    input: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCapacityPlan {
+    teamId: string;
+    projectId: string;
+    environment: string;
+    allocationSetId?: string | null;
+    workday: WorkdayCapacityEnvelope;
+    assignableProviders: Array<{
+        capacityProviderId: string;
+        executionProviderId?: string | null;
+        laneId?: string | null;
+        availableCredits?: number | null;
+        reasons?: string[];
+        metadata?: Record<string, unknown>;
+    }>;
+    legacyPlan?: LegacyCapacityPlan | Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+}
+export type CapacityPlan = AgentCapacityPlan;
+export interface ProviderAvailabilitySession {
+    id: string;
+    teamId: string;
+    capacityProviderId: string;
+    registrationId?: string | null;
+    environment?: string | null;
+    status: ProviderAvailabilitySessionStatus | string;
+    checkedInAt: string;
+    availableFrom?: string | null;
+    availableUntil?: string | null;
+    executionProviders: ExecutionProvider[];
+    capabilities: string[];
+    grants: CapacityGrant[];
+    nativeLimits?: Record<string, unknown>;
+    runnerPressure?: Record<string, unknown>;
+    constraints?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+    closedAt?: string | null;
+}
+export interface ProviderAssignment {
+    id: string;
+    teamId: string;
+    projectId: string;
+    capacityProviderId: string;
+    providerSessionId?: string | null;
+    executionProviderId?: string | null;
+    allocationSetId?: string | null;
+    projectAgentClassId: string;
+    reservationId?: string | null;
+    workDayId?: string | null;
+    taskId?: string | null;
+    mode: AgentExecutionMode;
+    status: ProviderAssignmentStatus | string;
+    leaseState: ProviderAssignmentLeaseState | string;
+    leaseExpiresAt?: string | null;
+    leaseToken?: string | null;
+    leaseRenewedAt?: string | null;
+    runnerId?: string | null;
+    agentId?: string | null;
+    handlerId?: string | null;
+    capacityEnvelope: AgentCapacityEnvelope;
+    decisionInput: DecisionExecutionInput | Record<string, unknown>;
+    workspaceContext?: Record<string, unknown>;
+    allowedOutputs?: Record<string, unknown>;
+    explanation?: Record<string, unknown>;
+    attemptCount?: number;
+    assignedAt?: string | null;
+    claimedAt?: string | null;
+    completedAt?: string | null;
+    returnedAt?: string | null;
+    failedAt?: string | null;
+    lifecycleReason?: string | null;
+    lifecycleCode?: string | null;
+    lifecycleOutput?: Record<string, unknown>;
+    synthesizedFrom?: ProviderAssignmentSynthesisSource | string | null;
+    synthesisKey?: string | null;
+    decisionId?: string | null;
+    proposalId?: string | null;
+    fallbackOutputId?: string | null;
+    treedxProxyHandle?: TreeDxProxyHandle | Record<string, unknown> | null;
+    capabilityHandles?: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ProviderAssignmentLifecycleRequest {
+    runnerId?: string | null;
+    leaseToken?: string | null;
+    leaseSeconds?: number | null;
+    reason?: string | null;
+    code?: string | null;
+    message?: string | null;
+    retryable?: boolean | null;
+    output?: Record<string, unknown> | null;
+    summary?: Record<string, unknown> | null;
+    fallbackOutput?: Record<string, unknown> | null;
+    usageActualId?: string | null;
+    modeRunId?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderCheckInRequest {
+    id?: string;
+    registrationId?: string | null;
+    environment?: string | null;
+    status?: ProviderAvailabilitySessionStatus | string;
+    availableFrom?: string | null;
+    availableUntil?: string | null;
+    executionProviders?: ExecutionProvider[];
+    capabilities?: string[];
+    grants?: CapacityGrant[];
+    nativeLimits?: Record<string, unknown>;
+    runnerPressure?: Record<string, unknown>;
+    constraints?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderNextAssignmentRequest {
+    sessionId?: string | null;
+    runnerId?: string | null;
+    leaseSeconds?: number | null;
+    capabilities?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderAssignmentLifecycleResult {
+    ok: true;
+    payload: ProviderAssignment | null;
+    assignment?: ProviderAssignment | null;
+    leaseToken?: string | null;
+    leaseSeconds?: number | null;
+    diagnostics?: Record<string, unknown> | null;
+    leaseDiagnostics?: Record<string, unknown> | null;
+}
+export interface AgentModeRunUsageSettlement {
+    taskUsageActualId?: string | null;
+    capacityLedgerEntryId?: string | null;
+    actualCredits?: number | null;
+    actualUsd?: number | null;
+    nativeUsage?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentModeRun {
+    id: string;
+    teamId: string;
+    projectId: string;
+    providerAssignmentId: string;
+    capacityProviderId: string;
+    executionProviderId?: string | null;
+    projectAgentClassId: string;
+    agentId?: string | null;
+    handlerId?: string | null;
+    mode: AgentExecutionMode;
+    status: AgentModeRunStatus | string;
+    selectedInput: Record<string, unknown>;
+    capacityEnvelope: AgentCapacityEnvelope;
+    outputs?: Record<string, unknown>;
+    traceRefs?: Record<string, unknown>;
+    usageActual?: AgentModeRunUsageSettlement | Record<string, unknown>;
+    validation?: Record<string, unknown>;
+    fallbackReason?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    failedAt?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface AgentKernelModeFallback {
+    code: AgentKernelModeFallbackCode | string;
+    reason: string;
+    retryable: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelModeExecutionInput {
+    assignment: ProviderAssignment;
+    projectAgentClass?: ProjectAgentClass | null;
+    kernelProfile?: AgentKernelProfile | null;
+    kernelPolicy?: AgentKernelPolicy | null;
+    capacityEnvelope?: AgentCapacityEnvelope | null;
+    decisionInput?: DecisionExecutionInput | null;
+    leaseToken?: string | null;
+    runnerId?: string | null;
+    readiness?: DecisionPlanningStatus | null;
+    treedxProxyHandle?: TreeDxProxyHandle | null;
+    now?: string | Date;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelModeExecutionResult {
+    status: AgentKernelModeExecutionStatus;
+    mode: AgentExecutionMode;
+    assignmentId: string;
+    projectId: string;
+    projectAgentClassId: string;
+    agentId?: string | null;
+    handlerId?: string | null;
+    summary: string;
+    outputs?: Record<string, unknown>;
+    selectedInput: Record<string, unknown>;
+    capacityEnvelope: AgentCapacityEnvelope;
+    traceRefs?: Record<string, unknown>;
+    usageActual?: AgentModeRunUsageSettlement | Record<string, unknown> | null;
+    fallback?: AgentKernelModeFallback | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelQueueObservation {
+    planningReady?: number | null;
+    actingReady?: number | null;
+    fallbackReady?: number | null;
+    planningBudgetCredits?: number | null;
+    actingBudgetCredits?: number | null;
+    modePreference?: AgentExecutionMode | 'fallback' | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelModeDecision {
+    kind: 'mode' | 'fallback' | 'idle';
+    mode?: AgentExecutionMode | null;
+    reason: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelOutputValidationResult {
+    ok: boolean;
+    reason?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface DecisionPlanningStatus {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    humanApprovalState?: string | null;
+    executionReadiness: DecisionExecutionReadinessStatus | string;
+    planningInputsStatus: PlanningInputRequestStatus | string;
+    scopeHash: string;
+    staleReason?: string | null;
+    readyAt?: string | null;
+    staleAt?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface PlanningInputRequest {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    projectAgentClassId?: string | null;
+    mode: AgentExecutionMode;
+    status: PlanningInputRequestStatus | string;
+    scopeHash: string;
+    prompt?: string | null;
+    response?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+    requestedAt?: string;
+    completedAt?: string | null;
+    staleAt?: string | null;
+}
+export interface DecisionExecutionInputRecord {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    projectAgentClassId: string;
+    mode: AgentExecutionMode;
+    status: DecisionExecutionInputStatus | string;
+    scopeHash: string;
+    input: DecisionExecutionInput;
+    acceptedAt?: string | null;
+    revisionRequestedAt?: string | null;
+    staleAt?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface WorkdayCapacityEnvelopeRecord {
+    id: string;
+    teamId: string;
+    projectId: string;
+    allocationSetId?: string | null;
+    status: WorkdayCapacityEnvelopeStatus | string;
+    startedAt?: string | null;
+    pausedAt?: string | null;
+    completedAt?: string | null;
+    envelope: WorkdayCapacityEnvelope;
+    modeSplits: Record<string, unknown>;
+    caps: Record<string, unknown>;
+    reserves: Record<string, unknown>;
+    borrowingRules: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface AgentCapacityPlanWorkUnit {
+    id: string;
+    decisionExecutionInputId: string;
+    decisionId: string;
+    projectAgentClassId: string;
+    mode: AgentExecutionMode;
+    taskId?: string | null;
+    agentId?: string | null;
+    handlerId?: string | null;
+    workDayId?: string | null;
+    expectedCredits: number;
+    highCredits: number;
+    requiredCapabilities: string[];
+    dependencies: string[];
+    blockers: string[];
+    risk: Record<string, unknown>;
+    assumptions: string[];
+    confidence?: number | null;
+    capacityEnvelope: AgentCapacityEnvelope;
+    decisionInput: DecisionExecutionInput;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCapacityPlanRecord {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    status: DurableAgentCapacityPlanStatus | string;
+    scopeHash: string;
+    allocationSetId?: string | null;
+    workDayId?: string | null;
+    expectedCredits: number;
+    highCredits: number;
+    workUnits: AgentCapacityPlanWorkUnit[];
+    capabilityNeeds: string[];
+    environmentNeeds: string[];
+    reserves: Record<string, unknown>;
+    blockers: string[];
+    priorityRationale?: string | null;
+    review?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    acceptedAt?: string | null;
+    scheduledAt?: string | null;
+    supersededAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ProviderAssignmentSynthesisCandidate {
+    id?: string;
+    teamId: string;
+    projectId: string;
+    capacityProviderId: string;
+    executionProviderId?: string | null;
+    projectAgentClassId: string;
+    mode: AgentExecutionMode;
+    source: ProviderAssignmentSynthesisSource | string;
+    sourceId: string;
+    synthesisKey: string;
+    priority?: number | null;
+    readiness?: DecisionPlanningStatus | null;
+    capacityEnvelope: AgentCapacityEnvelope;
+    decisionInput: DecisionExecutionInput;
+    workspaceContext?: Record<string, unknown>;
+    explanation?: ProviderAssignmentExplanation | Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderAssignmentExplanation {
+    id?: string;
+    teamId: string;
+    assignmentId: string;
+    source: ProviderAssignmentSynthesisSource | string;
+    sourceId?: string | null;
+    eligible: boolean;
+    reasons: string[];
+    gates: Record<string, unknown>;
+    allocationPolicyVersion?: string | null;
+    grantScope?: string | null;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionCapabilityGateInput {
+    grantMatches?: boolean;
+    availabilityMatches?: boolean;
+    runnerPressureAllows?: boolean;
+    budgetAllows?: boolean;
+    readinessAllows?: boolean;
+    capabilityHandlesCanBeIssued?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionProviderEligibilityResult {
+    eligible: boolean;
+    requiredCapabilities: string[];
+    preferredCapabilities: string[];
+    availableCapabilities: string[];
+    aliasCapabilities: string[];
+    missingCapabilities: string[];
+    reasonCodes: string[];
+    gates: {
+        grantMatches: boolean;
+        availabilityMatches: boolean;
+        runnerPressureAllows: boolean;
+        budgetAllows: boolean;
+        readinessAllows: boolean;
+        capabilityHandlesCanBeIssued: boolean;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface BuildExecutionProviderAssignmentExplanationInput {
+    source: ProviderAssignmentSynthesisSource | string;
+    sourceId?: string | null;
+    demand: ExecutionCapabilityDemand;
+    supply: ExecutionCapabilitySupply;
+    eligibility: ExecutionProviderEligibilityResult;
+    allocationPolicyVersion?: string | null;
+    grantId?: string | null;
+    grantScope?: string | null;
+    readinessGate?: Record<string, unknown> | null;
+    allocationBudgetGate?: Record<string, unknown> | null;
+    capabilityHandleGate?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionProviderVisibilitySummary {
+    executionProviderId: string | null;
+    executionProviderKind: string | null;
+    adapterStatus: string | null;
+    externalRef: string | null;
+    externalUrl: string | null;
+    blockerReason: string | null;
+    usage: unknown[];
+    artifacts: unknown[];
+    requiredCapabilities: string[];
+    preferredCapabilities: string[];
+    availableCapabilities: string[];
+    aliasCapabilities: string[];
+    missingCapabilities: string[];
+    selectedProvider: string | null;
+    selectedExecutionProvider: string | null;
+    capabilityEligible: boolean | null;
+    reasonCodes: string[];
+    metadata: Record<string, unknown>;
+}
+export type CapacityRuntimeBlockerOwner = 'project' | 'team_admin' | 'provider_operator' | 'system';
+export type CapacityRuntimeBlockerSeverity = 'info' | 'warning' | 'danger';
+export interface CapacityRuntimeBlockerVm {
+    code: string;
+    severity: CapacityRuntimeBlockerSeverity;
+    title: string;
+    message: string;
+    owner: CapacityRuntimeBlockerOwner;
+    assignmentId?: string | null;
+    projectId?: string | null;
+    providerId?: string | null;
+    nextAction: string;
+    evidence: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+export interface CapacityRuntimeDiagnosticsResponse {
+    projectId: string;
+    teamId: string;
+    generatedAt: string;
+    assignments: ProviderAssignment[];
+    explanations: ProviderAssignmentExplanation[];
+    modeRuns: AgentModeRun[];
+    treeDxProxyAudit: Array<Record<string, unknown>>;
+    ledgerEntries: Array<CapacityLedgerEntry & {
+        assignmentId?: string | null;
+        modeRunId?: string | null;
+    }>;
+    fallbackOutputs: Array<Record<string, unknown>>;
+    diagnostics: CapacityRuntimeBlockerVm[];
+}
+export interface CapacitySettlementInvariantViolation {
+    code: string;
+    message: string;
+    severity: 'warning' | 'error';
+}
+export interface CapacitySettlementInvariantResult {
+    ok: boolean;
+    status: 'pass' | 'warning' | 'fail';
+    violations: CapacitySettlementInvariantViolation[];
+}
+export interface TreeDxProxyHandle {
+    id: string;
+    teamId: string;
+    projectId: string;
+    assignmentId?: string | null;
+    repositoryId?: string | null;
+    workspaceId?: string | null;
+    status?: 'issued' | 'active' | 'revoked' | 'expired' | string;
+    scopes: string[];
+    expiresAt?: string | null;
+    issuedAt?: string | null;
+    revokedAt?: string | null;
+    auditId?: string | null;
+    token?: string | null;
+    tokenHash?: string | null;
+    allowedOperations?: string[];
+    allowedPaths?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderAssignmentCapabilityHandleBase {
+    id: string;
+    kind: AgentAssignmentCapabilityHandleKind;
+    teamId: string;
+    projectId: string;
+    assignmentId: string;
+    status?: 'active' | 'issued' | 'revoked' | 'expired' | 'blocked' | string;
+    workspaceAccessMode?: AgentAssignmentWorkspaceAccessMode | string | null;
+    operations?: AgentAssignmentCapabilityOperation[];
+    expiresAt?: string | null;
+    issuedAt?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderRepositoryAccessHandle extends ProviderAssignmentCapabilityHandleBase {
+    kind: 'repository_access';
+    repositoryId?: string | null;
+    repository?: string | null;
+    provider?: 'github_app' | 'treedx_proxy' | 'local_workspace' | 'workflow_operation' | string;
+    allowedRefs?: string[];
+    allowedPaths?: string[];
+    credentialMode?: 'none' | 'brokered' | 'ephemeral_trusted_direct' | string;
+}
+export interface ProviderTreeDxWorkspaceHandle extends ProviderAssignmentCapabilityHandleBase {
+    kind: 'treedx_workspace';
+    proxyHandleId: string;
+    repositoryId?: string | null;
+    workspaceId?: string | null;
+    allowedOperations?: string[];
+    allowedPaths?: string[];
+}
+export interface ProviderWorkflowOperationHandle extends ProviderAssignmentCapabilityHandleBase {
+    kind: 'workflow_operation';
+    operationId: string;
+    repository: string;
+    workflowFile: string;
+    ref?: string | null;
+    environment?: string | null;
+    secretBearing?: boolean;
+    trustedExecutionSetId?: string | null;
+    allowedInputs?: Record<string, unknown>;
+}
+export interface ProviderSecretUseHandle extends ProviderAssignmentCapabilityHandleBase {
+    kind: 'secret_use';
+    secretIds?: string[];
+    secretClasses?: string[];
+    custodyMode?: string | null;
+    revealAllowed?: false;
+}
+export type ProviderAssignmentCapabilityHandle = ProviderRepositoryAccessHandle | ProviderTreeDxWorkspaceHandle | ProviderWorkflowOperationHandle | ProviderSecretUseHandle;
+export interface ProviderAssignmentCapabilityHandles {
+    workspaceAccessMode: AgentAssignmentWorkspaceAccessMode;
+    repository?: ProviderRepositoryAccessHandle[];
+    treeDx?: ProviderTreeDxWorkspaceHandle[];
+    workflowOperations?: ProviderWorkflowOperationHandle[];
+    secrets?: ProviderSecretUseHandle[];
+    metadata?: Record<string, unknown>;
+}
+export interface TreeDxProxyAccessRequest {
+    teamId?: string | null;
+    projectId: string;
+    assignmentId?: string | null;
+    repositoryId?: string | null;
+    workspaceId?: string | null;
+    operation?: string | null;
+    path?: string | null;
+    token?: string | null;
+    now?: Date;
+}
+export interface TreeDxProxyAccessResult {
+    ok: boolean;
+    code?: string;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeDxProjectProxyAuditRecord {
+    id: string;
+    teamId: string;
+    projectId: string;
+    assignmentId?: string | null;
+    actorType: 'user' | 'capacity_provider' | string;
+    actorId?: string | null;
+    method: string;
+    path: string;
+    handle?: TreeDxProxyHandle | Record<string, unknown> | null;
+    resultStatus: string;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+}
+export interface AgentFallbackOutput {
+    id: string;
+    teamId: string;
+    projectId: string;
+    assignmentId?: string | null;
+    mode: AgentExecutionMode;
+    code: AgentKernelModeFallbackCode | string;
+    status: 'draft' | 'emitted' | 'suppressed' | 'duplicate' | 'quota_exceeded' | string;
+    output: Record<string, unknown>;
+    provenance: Record<string, unknown>;
+    quota: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+}
+export interface CapacitySettlementSummary {
+    id?: string;
+    teamId: string;
+    projectId?: string | null;
+    workDayId?: string | null;
+    allocationSetId?: string | null;
+    policyVersion?: string | null;
+    reservedCredits: number;
+    consumedCredits: number;
+    releasedCredits: number;
+    refundedCredits: number;
+    nativeUsage: Record<string, unknown>;
+    providerConfidence: 'high' | 'medium' | 'low' | 'blocked' | string;
+    warnings: string[];
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+}
+export declare function computeDecisionScopeHash(scope: unknown): string;
+export declare function isDecisionReadyForActing(status?: Pick<DecisionPlanningStatus, 'executionReadiness' | 'planningInputsStatus'> | null): boolean;
+export declare function isPlanningInputOpen(request: Pick<PlanningInputRequest, 'status'>): boolean;
+export declare function isDecisionExecutionInputAccepted(input: Pick<DecisionExecutionInputRecord, 'status'>): boolean;
+export declare function isAgentCapacityPlanAccepted(plan?: Pick<AgentCapacityPlanRecord, 'status'> | null): boolean;
+export declare function normalizeDecisionExecutionEstimate(input: DecisionExecutionInputRecord | DecisionExecutionInput): {
+    expectedCredits: number;
+    highCredits: number;
+    requiredCapabilities: string[];
+    dependencies: string[];
+    blockers: string[];
+    assumptions: string[];
+    confidence: number | null;
+    environmentNeeds: string[];
+    risk: Record<string, unknown>;
+};
+export declare function buildAgentCapacityPlanDraft(input: {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    scopeHash: string;
+    executionInputs: DecisionExecutionInputRecord[];
+    allocationSetId?: string | null;
+    workDayId?: string | null;
+    status?: DurableAgentCapacityPlanStatus | string;
+    metadata?: Record<string, unknown>;
+    now?: string;
+}): AgentCapacityPlanRecord;
+export declare function isProviderAssignmentCandidateEligible(candidate: ProviderAssignmentSynthesisCandidate): boolean;
+export declare function validateTreeDxProxyHandle(handle: TreeDxProxyHandle | null | undefined, expected: {
+    teamId?: string | null;
+    projectId: string;
+    assignmentId?: string | null;
+}): AgentKernelModeFallback | null;
+export declare function redactedProviderAssignmentCapabilityHandles(handles: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null | undefined): ProviderAssignmentCapabilityHandles;
+export declare function providerAssignmentCapabilityHandlesContainSecretMaterial(value: unknown): boolean;
+export declare function validateProviderAssignmentCapabilityHandles(input: {
+    assignment: Pick<ProviderAssignment, 'id' | 'teamId' | 'projectId' | 'mode' | 'metadata' | 'decisionInput' | 'capacityEnvelope' | 'synthesizedFrom'> & {
+        capabilityHandles?: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
+    };
+    capabilityHandles?: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
+    decisionInput?: DecisionExecutionInput | null;
+    capacityEnvelope?: AgentCapacityEnvelope | null;
+    now?: Date;
+}): AgentKernelModeFallback | null;
+export declare function evaluateTreeDxProxyHandleAccess(handle: TreeDxProxyHandle | null | undefined, request: TreeDxProxyAccessRequest): TreeDxProxyAccessResult;
+export declare function compileExecutionCapabilityDemand(input: {
+    agent?: Pick<AgentRuntimeSpec, 'execution' | 'outputs'> | null;
+    projectAgentClass?: Pick<ProjectAgentClass, 'requiredCapabilities'> | null;
+    decisionInput?: DecisionExecutionInput | Record<string, unknown> | null;
+    capacityEnvelope?: AgentCapacityEnvelope | Record<string, unknown> | null;
+    workUnit?: Pick<AgentCapacityPlanWorkUnit, 'requiredCapabilities' | 'metadata'> | null;
+    assignment?: Pick<ProviderAssignment, 'mode' | 'metadata' | 'workspaceContext' | 'capabilityHandles' | 'allowedOutputs'> | null;
+    workPackage?: AgentWorkPackage | null;
+    mode?: AgentExecutionMode | string | null;
+    resourceNeeds?: ExecutionResourceNeed[];
+    metadata?: Record<string, unknown>;
+}): ExecutionCapabilityDemand;
+export declare function compileExecutionCapabilitySupply(input: {
+    capacityProviderId: string;
+    executionProviderId?: string | null;
+    kind?: string | null;
+    descriptor?: ExecutionProviderDescriptor | null;
+    executionProvider?: ExecutionProvider | null;
+    availabilitySession?: ProviderAvailabilitySession | null;
+    providerCapabilities?: string[] | unknown[] | null;
+    checkInCapabilities?: string[] | unknown[] | null;
+    grants?: CapacityGrant[];
+    pressure?: ExecutionCapabilitySupply['pressure'];
+    maxConcurrentAssignments?: number | null;
+    metadata?: Record<string, unknown>;
+}): ExecutionCapabilitySupply;
+export declare function evaluateExecutionProviderEligibility(input: {
+    demand: ExecutionCapabilityDemand;
+    supply: ExecutionCapabilitySupply;
+    gates?: ExecutionCapabilityGateInput;
+}): ExecutionProviderEligibilityResult;
+export declare function buildProviderAssignmentExplanation(input: {
+    source: ProviderAssignmentSynthesisSource | string;
+    sourceId?: string | null;
+    eligible: boolean;
+    reasons?: string[];
+    gates?: Record<string, unknown>;
+    allocationPolicyVersion?: string | null;
+    grantScope?: string | null;
+    metadata?: Record<string, unknown>;
+}): ProviderAssignmentExplanation;
+export declare function buildExecutionProviderAssignmentExplanation(input: BuildExecutionProviderAssignmentExplanationInput): ProviderAssignmentExplanation;
+export declare function summarizeExecutionProviderVisibility(input: {
+    assignment?: Record<string, unknown> | null;
+    modeRun?: Record<string, unknown> | null;
+    explanation?: Record<string, unknown> | null;
+}): ExecutionProviderVisibilitySummary;
+export declare function decorateExecutionProviderVisibility<T extends Record<string, unknown>>(recordInput: T, options?: {
+    explanation?: Record<string, unknown> | null;
+    modeRun?: Record<string, unknown> | null;
+}): T & {
+    executionVisibility: ExecutionProviderVisibilitySummary;
+};
+export declare function evaluateFallbackQuota(input: {
+    existingCount?: number | null;
+    quota?: number | null;
+}): AgentKernelModeFallback | null;
+export declare function deriveAllocationSetFromCapacityGrants(input: {
+    id: string;
+    teamId: string;
+    version?: string;
+    status?: AllocationSetStatus | string;
+    grants: CapacityGrant[];
+    createdById?: string | null;
+    now?: string;
+    metadata?: Record<string, unknown>;
+}): AllocationSet;
+export declare function deriveProviderAvailabilitySession(input: {
+    id: string;
+    provider: CapacityProvider;
+    registrationId?: string | null;
+    environment?: string | null;
+    executionProviders?: ExecutionProvider[];
+    grants?: CapacityGrant[];
+    runnerPressure?: Record<string, unknown>;
+    constraints?: Record<string, unknown>;
+    now?: string;
+    metadata?: Record<string, unknown>;
+}): ProviderAvailabilitySession;
+export declare function deriveAgentCapacityPlanFromCapacityPlan(plan: LegacyCapacityPlan | Record<string, unknown>): AgentCapacityPlan;
+export declare function deriveAgentCapacityEnvelopeFromReservation(input: {
+    reservation: CapacityReservation;
+    mode: AgentExecutionMode;
+    projectAgentClassId?: string | null;
+    allocationSetId?: string | null;
+    environment?: string | null;
+    limits?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}): AgentCapacityEnvelope;
+export declare function deriveModeRunUsageSettlement(actual: TaskUsageActual): AgentModeRunUsageSettlement;
+export declare function isAgentExecutionMode(value: unknown): value is AgentExecutionMode;
+export declare function normalizeAgentExecutionMode(value: unknown, fallback?: AgentExecutionMode): AgentExecutionMode;
+export declare function createAgentKernelModeFallback(code: AgentKernelModeFallbackCode | string, reason: string, options?: {
+    retryable?: boolean;
+    metadata?: Record<string, unknown>;
+}): AgentKernelModeFallback;
+export declare function isAgentModeAllowedForClass(mode: AgentExecutionMode, agentClass?: Pick<ProjectAgentClass, 'allowedModes' | 'status'> | null, profile?: Pick<AgentKernelProfile, 'allowedModes'> | null): boolean;
+export declare function deriveAgentCapacityEnvelopeFromAssignment(assignment: Pick<ProviderAssignment, 'teamId' | 'projectId' | 'mode' | 'capacityProviderId' | 'executionProviderId' | 'allocationSetId' | 'projectAgentClassId' | 'reservationId' | 'workDayId' | 'capacityEnvelope'>): AgentCapacityEnvelope;
+export declare function deriveDecisionExecutionInputFromAssignment(assignment: Pick<ProviderAssignment, 'teamId' | 'projectId' | 'projectAgentClassId' | 'mode' | 'taskId' | 'workDayId' | 'agentId' | 'handlerId' | 'decisionInput' | 'capacityEnvelope'>): DecisionExecutionInput;
+export declare function validateAgentKernelModeExecutionInput(input: AgentKernelModeExecutionInput): AgentKernelModeFallback | null;
+export declare function selectAgentKernelModeDecision(observation: AgentKernelQueueObservation): AgentKernelModeDecision;
+export declare function validateAgentKernelOutputs(input: {
+    mode: AgentExecutionMode;
+    outputs?: Record<string, unknown> | null;
+    allowedOutputs?: Record<string, unknown> | null;
+}): AgentKernelOutputValidationResult;
+export declare function treeDxProxyHeaders(handle: TreeDxProxyHandle): Record<string, string>;
+export declare function isAgentCapacityPlanStaleOrSuperseded(plan: Pick<AgentCapacityPlanRecord, 'status'> & {
+    scopeHash?: string | null;
+}, currentScopeHash?: string | null): boolean;
+export declare function hasAcceptedCapacityPlanProvenance(input: {
+    assignment?: Pick<ProviderAssignment, 'metadata' | 'decisionInput' | 'capacityEnvelope' | 'synthesizedFrom'> | null;
+    decisionInput?: DecisionExecutionInput | null;
+    capacityEnvelope?: AgentCapacityEnvelope | null;
+}): boolean;
+export declare function isProviderAssignmentLeaseExpired(assignment: Pick<ProviderAssignment, 'leaseExpiresAt'>, now?: Date): boolean;
+export declare function isProviderAssignmentLeasable(assignment: Pick<ProviderAssignment, 'status' | 'leaseState' | 'leaseExpiresAt'>, now?: Date): boolean;
+export declare function summarizeCapacityRuntimeDiagnostics(input: {
+    projectId: string;
+    teamId: string;
+    generatedAt?: string;
+    assignments: ProviderAssignment[];
+    explanations?: ProviderAssignmentExplanation[];
+    modeRuns?: AgentModeRun[];
+    treeDxProxyAudit?: Array<Record<string, unknown>>;
+    ledgerEntries?: Array<CapacityLedgerEntry & {
+        assignmentId?: string | null;
+        modeRunId?: string | null;
+    }>;
+    fallbackOutputs?: Array<Record<string, unknown>>;
+}): CapacityRuntimeDiagnosticsResponse;
+export declare function validateCapacitySettlementInvariant(input: {
+    assignment: ProviderAssignment;
+    reservation?: CapacityReservation | null;
+    ledgerEntries: Array<CapacityLedgerEntry & {
+        assignmentId?: string | null;
+        modeRunId?: string | null;
+    }>;
+}): CapacitySettlementInvariantResult;