@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/agent-capacity/authority/agent-authority-presets.d.ts

@@ -0,0 +1,13 @@
+import type { AgentActivityPermissions, AgentActivityProfile, AgentActivityType, AgentToolPolicy } from '../../types/agents.js';
+export declare const AGENT_AUTHORITY_PRESET_IDS: readonly ["messaging", "direction", "influence", "estimation", "plan-contribution", "source-execution", "review-authority", "reporting"];
+export type AgentAuthorityPresetId = (typeof AGENT_AUTHORITY_PRESET_IDS)[number];
+export interface CompiledAgentAuthoritySnapshot {
+    presetIds: AgentAuthorityPresetId[];
+    permissions?: AgentActivityPermissions;
+    tools: AgentToolPolicy;
+    branchPolicy: AgentActivityProfile['branchPolicy'];
+    diagnostics: string[];
+}
+export declare function defaultAgentAuthorityPresets(activityType: AgentActivityType): ("reporting" | "messaging" | "direction" | "influence" | "estimation" | "plan-contribution" | "source-execution" | "review-authority")[];
+export declare function compileAgentAuthoritySnapshot(activityType: AgentActivityType, profile: AgentActivityProfile): CompiledAgentAuthoritySnapshot;
+export declare function allowedSafetyModesForActivity(activityType: AgentActivityType): Array<'planning' | 'acting'>;

package/dist/agent-capacity/authority/agent-authority-presets.js

@@ -0,0 +1,106 @@
+const AGENT_AUTHORITY_PRESET_IDS = [
+  "messaging",
+  "direction",
+  "influence",
+  "estimation",
+  "plan-contribution",
+  "source-execution",
+  "review-authority",
+  "reporting"
+];
+const OPERATIONAL_TOOLS = ["treeseed.status", "treeseed.assignment_activity", "treeseed.assignment_plan", "treeseed.assignment_status_update", "treeseed.assignment_summary"];
+const MESSAGING_TOOLS = ["treeseed.discussion.read", "treeseed.discussion.follow", "treeseed.discussion.respond", "treeseed.discussion.request_handoff"];
+const CONTENT_TOOLS = ["treeseed.content.describe", "treeseed.content.query", "treeseed.content.read", "treeseed.content.create", "treeseed.content.update", "treeseed.content.link", "treeseed.content.validate", "treeseed.content.commit"];
+const SOURCE_READ_TOOLS = ["treeseed.repository.read_file", "treeseed.repository.search", "treeseed.changed_paths", "treeseed.verify"];
+const SOURCE_EXECUTION_TOOLS = [...SOURCE_READ_TOOLS, "treeseed.checkpoint"];
+const RAW_CONTENT_MUTATION_TOOLS = /* @__PURE__ */ new Set(["treedx.apply_workspace_changeset", "treedx.commit_workspace"]);
+const CHAT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  ...OPERATIONAL_TOOLS,
+  ...MESSAGING_TOOLS,
+  ...CONTENT_TOOLS,
+  "treedx.build_context",
+  "treedx.read_repository_files",
+  "treedx.search_workspace",
+  "treedx.read_workspace_file",
+  "treeseed.discussion.create_artifact",
+  "treeseed.operation.prepare_handoff",
+  "treeseed.client_session.request_action"
+]);
+const PROFILE_PRESETS = {
+  planning: ["influence", "plan-contribution"],
+  estimating: ["messaging", "estimation"],
+  acting: ["source-execution", "influence"],
+  reviewing: ["review-authority", "plan-contribution"],
+  reporting: ["messaging", "reporting"],
+  chat: ["influence"]
+};
+function toolsForPreset(preset) {
+  if (preset === "messaging") return MESSAGING_TOOLS;
+  if (preset === "direction") return CONTENT_TOOLS;
+  if (preset === "influence") return [...MESSAGING_TOOLS, ...CONTENT_TOOLS];
+  if (preset === "estimation") return MESSAGING_TOOLS;
+  if (preset === "plan-contribution") return [];
+  if (preset === "source-execution") return SOURCE_EXECUTION_TOOLS;
+  if (preset === "review-authority") return [...MESSAGING_TOOLS, ...CONTENT_TOOLS, ...SOURCE_READ_TOOLS];
+  return [...MESSAGING_TOOLS, ...CONTENT_TOOLS];
+}
+const OPERATIONAL_MODELS = /* @__PURE__ */ new Set(["assignment_plan", "assignment_status", "assignment_summary"]);
+const MUTABLE_MODELS = {
+  planning: /* @__PURE__ */ new Set(["proposal", "question", "note", "discussion_message", ...OPERATIONAL_MODELS]),
+  estimating: /* @__PURE__ */ new Set(["note", "question", "discussion_message", ...OPERATIONAL_MODELS]),
+  acting: /* @__PURE__ */ new Set(),
+  reviewing: /* @__PURE__ */ new Set(["note", "question", "discussion_message", ...OPERATIONAL_MODELS]),
+  reporting: /* @__PURE__ */ new Set(["note", "discussion_message", ...OPERATIONAL_MODELS]),
+  chat: /* @__PURE__ */ new Set(["proposal", "question", "note", "discussion_message", ...OPERATIONAL_MODELS])
+};
+function boundedPermissions(activityType, permissions) {
+  if (!permissions) return permissions;
+  const content = Object.fromEntries(Object.entries(permissions.content ?? {}).map(([model, policy]) => {
+    if (activityType === "acting" || MUTABLE_MODELS[activityType].has(model)) return [model, policy];
+    return [model, { ...policy, operations: policy.operations.filter((operation) => ["describe", "query", "read", "validate"].includes(operation)) }];
+  }).filter(([, policy]) => policy.operations.length));
+  if (activityType === "acting") return { ...permissions, content };
+  return {
+    ...permissions,
+    content,
+    repository: { ...permissions.repository ?? {}, writePaths: [], allowCodeMutation: false },
+    commit: { allowed: Object.entries(content).some(([model, policy]) => MUTABLE_MODELS[activityType].has(model) && (policy.operations.includes("create") || policy.operations.includes("update") || policy.operations.includes("link") || policy.operations.includes("commit"))) },
+    network: permissions.network,
+    shell: { ...permissions.shell ?? {}, allowCommands: false, allowedCommands: [] }
+  };
+}
+function defaultAgentAuthorityPresets(activityType) {
+  return [...PROFILE_PRESETS[activityType]];
+}
+function compileAgentAuthoritySnapshot(activityType, profile) {
+  const declared = profile.authorityPresets?.length ? profile.authorityPresets : defaultAgentAuthorityPresets(activityType);
+  const presetIds = [...new Set(declared)];
+  const diagnostics = [];
+  for (const preset of presetIds) if (!AGENT_AUTHORITY_PRESET_IDS.includes(preset)) diagnostics.push(`Unknown authority preset ${preset}.`);
+  const declaredTools = [.../* @__PURE__ */ new Set([...OPERATIONAL_TOOLS, ...presetIds.flatMap(toolsForPreset), ...profile.tools?.allowed ?? []])];
+  const hasModelAwareContentMutation = declaredTools.some((tool) => /^treeseed\.content\.(?:create|update|link|commit)$/u.test(tool));
+  const allowed = hasModelAwareContentMutation ? declaredTools.filter((tool) => !RAW_CONTENT_MUTATION_TOOLS.has(tool)) : declaredTools;
+  const denied = new Set(profile.tools?.denied ?? []);
+  const profileAllowed = activityType === "acting" ? allowed : activityType === "reviewing" ? allowed.filter((tool) => tool !== "treeseed.checkpoint") : activityType === "chat" ? allowed.filter((tool) => CHAT_ALLOWED_TOOLS.has(tool)) : allowed.filter((tool) => tool !== "treeseed.checkpoint" && !tool.startsWith("treeseed.repository.") && tool !== "treeseed.changed_paths" && tool !== "treeseed.verify");
+  if (activityType === "chat") {
+    for (const tool of allowed) if (!CHAT_ALLOWED_TOOLS.has(tool)) diagnostics.push(`Chat cannot use ${tool}.`);
+  }
+  const tools = { allowed: profileAllowed.filter((tool) => !denied.has(tool)), ...denied.size ? { denied: [...denied] } : {} };
+  if (activityType !== "acting" && profile.permissions?.repository?.allowCodeMutation === true) diagnostics.push(`${activityType} cannot enable repository code mutation.`);
+  if (activityType === "reviewing" && tools.allowed.includes("treeseed.checkpoint")) diagnostics.push("Review authority cannot checkpoint or modify the reviewed implementation.");
+  if (activityType === "acting" && profile.permissions?.repository?.allowCodeMutation !== true && profile.permissions?.commit?.allowed !== true) diagnostics.push("Acting requires explicit source-mutation or governed content-commit authority.");
+  const permissions = boundedPermissions(activityType, profile.permissions);
+  const branchPolicy = profile.branchPolicy;
+  return { presetIds, permissions, tools, branchPolicy, diagnostics };
+}
+function allowedSafetyModesForActivity(activityType) {
+  if (activityType === "acting") return ["acting"];
+  if (activityType === "reviewing") return ["planning", "acting"];
+  return ["planning"];
+}
+export {
+  AGENT_AUTHORITY_PRESET_IDS,
+  allowedSafetyModesForActivity,
+  compileAgentAuthoritySnapshot,
+  defaultAgentAuthorityPresets
+};

package/dist/agent-capacity/contracts/capacity/assignments/assignment-records.d.ts

@@ -0,0 +1,269 @@
+export type AgentExecutionMode = 'planning' | 'acting';
+export type AgentWorkExecutionMode = import('../../support/execution-mode.js').AgentWorkExecutionMode;
+export type ProviderAssignmentStatus = 'pending' | 'leased' | 'running' | 'completed' | 'failed' | 'returned' | 'expired' | 'cancelled';
+export type ProviderAssignmentLeaseState = 'unleased' | 'leased' | 'released' | 'expired';
+export type AgentModeRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type ProviderAssignmentSynthesisSource = 'approved_decision' | 'planning_input_request' | 'capacity_plan' | 'workday_demand' | 'verification_failure' | 'fallback_queue';
+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 WorkdayCapacityEnvelope {
+    teamId: string;
+    projectId: string;
+    workDayId?: string | null;
+    environment?: string | null;
+    executionMode?: AgentWorkExecutionMode;
+    allocationSetId?: string | null;
+    availableSeconds?: number | null;
+    requestedSeconds?: number | null;
+    reservedSeconds?: number | null;
+    activeSeconds?: number | null;
+    elapsedSeconds?: number | null;
+    releasedSeconds?: number | null;
+    overrunSeconds?: number | null;
+    budget?: import('../../support/time-capacity.js').CapacityBudgetV2 | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCapacityEnvelope extends WorkdayCapacityEnvelope {
+    mode: AgentExecutionMode;
+    projectAgentClassId?: string | null;
+    capacityProviderId?: string | null;
+    executionProviderId?: 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;
+    executionMode?: AgentWorkExecutionMode;
+    activityType?: import('../../../../types/agents.js').AgentActivityType;
+    workGraphNodeId?: string | null;
+    estimateId?: string | null;
+    taskId?: string | null;
+    workDayId?: string | null;
+    agentId?: string | null;
+    handlerId?: string | null;
+    capacity: AgentCapacityEnvelope;
+    input: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeDxProxyHandle {
+    id: string;
+    teamId: string;
+    projectId: string;
+    assignmentId?: string | null;
+    executionMode?: AgentWorkExecutionMode;
+    repositoryId?: string | null;
+    workspaceId?: string | null;
+    baseCommitSha?: string | null;
+    baseRef?: string | null;
+    branchName?: 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[];
+    allowedReadPaths?: string[];
+    allowedWritePaths?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderAssignmentCapabilityHandleBase {
+    id: string;
+    kind: AgentAssignmentCapabilityHandleKind;
+    teamId: string;
+    projectId: string;
+    assignmentId: string;
+    executionMode?: AgentWorkExecutionMode;
+    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 ProviderAssignment {
+    id: string;
+    membershipId: string;
+    stateVersion: number;
+    teamId: string;
+    projectId: string;
+    capacityProviderId: string;
+    providerSessionId: string | null;
+    executionProviderId: string | null;
+    laneId: string | null;
+    lanePurpose?: import('../communication/communication-records.js').ProviderLanePurpose | null;
+    communicationOverflow?: boolean;
+    executionKind?: import('../communication/communication-records.js').CapacityExecutionKind;
+    triggerKind?: import('../communication/communication-records.js').CapacityTriggerKind;
+    invocationId?: string | null;
+    parentWorkdayId?: string | null;
+    parentAssignmentId?: string | null;
+    handoffRootId?: string | null;
+    handoffParentId?: string | null;
+    handoffDepth?: number;
+    sourceMessageRefs?: string[];
+    allocationSetId: string | null;
+    projectAgentClassId: string;
+    reservationId: string | null;
+    workDayId: string | null;
+    taskId: string | null;
+    mode: AgentExecutionMode;
+    executionMode?: AgentWorkExecutionMode;
+    status: ProviderAssignmentStatus;
+    leaseState: ProviderAssignmentLeaseState;
+    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 | 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;
+    modeRunId?: string | null;
+    metadata?: Record<string, unknown>;
+    completion?: import('../../support/time-capacity.js').AssignmentCompletionEvidence | null;
+    performance?: import('../../support/time-capacity.js').AssignmentPerformanceSummary | null;
+}
+export interface ProviderNextAssignmentRequest {
+    sessionId?: string | null;
+    runnerId?: string | null;
+    leaseSeconds?: number | null;
+    capabilities?: string[];
+    laneId?: string | null;
+    lanePurpose?: import('../communication/communication-records.js').ProviderLanePurpose | null;
+    waitSeconds?: number | null;
+    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 {
+    capacityUsageActualId: string | null;
+    capacityLedgerEntryId: string | null;
+    activeSeconds: number | null;
+    elapsedSeconds: 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;
+    executionMode?: AgentWorkExecutionMode;
+    status: AgentModeRunStatus;
+    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;
+}

package/dist/agent-capacity/contracts/capacity/assignments/assignment-records.js

@@ -0,0 +1,10 @@
+const AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES = [
+  "context_only",
+  "workspace_write",
+  "brokered_workspace",
+  "full_workspace_no_credentials",
+  "trusted_direct"
+];
+export {
+  AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES
+};

package/dist/agent-capacity/contracts/capacity/communication/communication-records.d.ts

@@ -0,0 +1,101 @@
+export type ProviderLanePurpose = 'communication' | 'operation';
+export type CapacityExecutionKind = 'workday' | 'conversation' | 'simulation' | 'recovery';
+export type CapacityTriggerKind = 'scheduled' | 'manual' | 'discussion' | 'agent-handoff';
+export type CommunicationPriorityClass = 'human-interactive' | 'workday-blocking-agent' | 'agent-asynchronous' | 'operational';
+export declare const COMMUNICATION_PRIORITY: Readonly<Record<CommunicationPriorityClass, number>>;
+export type AgentInvocationStatus = 'queued' | 'coalesced' | 'admitted' | 'running' | 'suspended' | 'blocked' | 'completed' | 'failed' | 'cancelled' | 'expired' | 'stale';
+export interface AgentInvocationRequest {
+    contract: 'treeseed.agent-invocation-request/v1';
+    id: string;
+    teamId: string;
+    projectId: string;
+    agentId: string;
+    projectAgentClassId: string;
+    agentRevision: string;
+    profileRevision: string;
+    executionKind: CapacityExecutionKind;
+    triggerKind: CapacityTriggerKind;
+    priorityClass: CommunicationPriorityClass;
+    priority: number;
+    sourceKind: string;
+    sourceRefs: string[];
+    subjectDigest: string;
+    idempotencyKey: string;
+    requestDigest: string;
+    status: AgentInvocationStatus;
+    availableAt: string;
+    expiresAt: string | null;
+    parentWorkdayId: string | null;
+    parentAssignmentId: string | null;
+    handoffRootId: string | null;
+    handoffParentId: string | null;
+    handoffDepth: number;
+    blocking: boolean;
+    recipientAgentIds: string[];
+    admittedDemandId: string | null;
+    executionId: string | null;
+    assignmentId: string | null;
+    finalMessageRef: string | null;
+    blocker: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+export interface DiscussionCoordinationPolicy {
+    contract: 'treeseed.discussion-coordination-policy/v1';
+    humanToAgentEnabled: boolean;
+    agentCoordinationEnabled: boolean;
+    outsideWorkdayEnabled: boolean;
+    maximumHandoffDepth: number;
+    maximumHandoffsPerRoot: number;
+    maximumRecipientsPerHandoff: number;
+    allowSelfHandoff: false;
+}
+export interface DiscussionHandoffContext {
+    contract: 'treeseed.discussion-handoff-context/v1';
+    rootInvocationId: string;
+    parentInvocationId: string;
+    sourceAgentId: string;
+    recipientAgentIds: string[];
+    subjectDigest: string;
+    sourceMessageRefs: string[];
+    parentWorkdayId: string | null;
+    parentAssignmentId: string | null;
+    depth: number;
+    blocking: boolean;
+}
+export type ClientActionKind = 'navigate' | 'reveal-resource' | 'set-view-filter' | 'populate-draft' | 'present-confirmation';
+export interface ClientActionRequest {
+    contract: 'treeseed.client-action-request/v1';
+    id: string;
+    idempotencyKey: string;
+    assignmentId: string;
+    userId: string;
+    teamId: string;
+    projectId: string;
+    sessionId: string | null;
+    action: ClientActionKind;
+    payload: Record<string, unknown>;
+    status: 'pending' | 'completed' | 'rejected' | 'expired' | 'failed' | 'unavailable';
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OperationHandoffRequest {
+    contract: 'treeseed.operation-handoff/v1';
+    id: string;
+    assignmentId: string;
+    invocationId: string;
+    teamId: string;
+    projectId: string;
+    discussionId: string;
+    sourceMessageRefs: string[];
+    target: string;
+    inputs: Record<string, unknown>;
+    expectedEffect: string;
+    requiredAuthority: string[];
+    proposalId: string | null;
+    decisionId: string | null;
+    approvalRequestId: string | null;
+    status: 'proposed' | 'awaiting-approval' | 'approved' | 'scheduled' | 'completed' | 'failed' | 'cancelled';
+}

package/dist/agent-capacity/contracts/capacity/communication/communication-records.js

@@ -0,0 +1,9 @@
+const COMMUNICATION_PRIORITY = {
+  "human-interactive": 400,
+  "workday-blocking-agent": 300,
+  "agent-asynchronous": 200,
+  operational: 100
+};
+export {
+  COMMUNICATION_PRIORITY
+};

package/dist/agent-capacity/contracts/capacity/providers/supply-policy.d.ts

@@ -0,0 +1,36 @@
+export declare const CAPACITY_SUPPLY_POLICY_CONTRACT: "treeseed.capacity-supply-policy/v1";
+export interface CapacitySupplyPolicy {
+    contract: typeof CAPACITY_SUPPLY_POLICY_CONTRACT;
+    generation: number;
+    reliabilityFloor: number;
+    maxFailovers: number;
+    allowPlanningFailover: boolean;
+    allowActingFailover: boolean;
+    preferredCapacityProviderIds?: string[];
+    preferredExecutionProviderIds?: string[];
+    disallowedCapacityProviderIds?: string[];
+    disallowedExecutionProviderIds?: string[];
+}
+export interface CapacitySupplyCandidate {
+    capacityProviderId: string;
+    membershipId: string;
+    providerSessionId: string;
+    grantId: string;
+    executionProviderId: string;
+    status: 'available' | 'unavailable' | 'degraded' | string;
+    capabilities: string[];
+    reliability: number;
+    pressure: 'idle' | 'normal' | 'busy' | 'throttled' | 'exhausted';
+    availableConcurrency: number;
+    preferred?: boolean;
+    estimatedCost?: number | null;
+    minimumAssignmentDuration?: import('../../../../capacity-provider/contracts/governance.js').MinimumAssignmentDuration;
+}
+export interface CapacitySupplySelection {
+    selected: CapacitySupplyCandidate | null;
+    eligible: CapacitySupplyCandidate[];
+    rejected: Array<{
+        candidate: CapacitySupplyCandidate;
+        reasons: string[];
+    }>;
+}

package/dist/agent-capacity/contracts/capacity/providers/supply-policy.js

@@ -0,0 +1,4 @@
+const CAPACITY_SUPPLY_POLICY_CONTRACT = "treeseed.capacity-supply-policy/v1";
+export {
+  CAPACITY_SUPPLY_POLICY_CONTRACT
+};