@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/agent-capacity/contracts/runtime/runtime-observability.d.ts

@@ -0,0 +1,335 @@
+import type { CapacityPageInfo } from '../../../capacity/capacity-core/capacity-pagination.js';
+import type { ExecutionCapabilityDemand, ExecutionCapabilitySupply } from '../../../types/agents.js';
+import type { AgentCapacityEnvelope, AgentExecutionMode, AgentModeRun, DecisionExecutionInput, ProviderAssignment, ProviderAssignmentSynthesisSource, TreeDxProxyHandle, WorkdayCapacityEnvelope } from '../capacity/assignments/assignment-records.js';
+import type { AgentKernelPolicy, AgentKernelProfile } from '../projects/agents/project-agent-class.js';
+import type { CapacityLedgerEntry, CapacityReservation, CapacityUsageActual } from '../support/financial-records.js';
+import type { WorkdayCapacityEnvelopeRecord } from '../support/planning-records.js';
+export type AgentKernelModeExecutionStatus = 'completed' | 'waiting' | 'failed' | 'returned';
+export type AgentKernelModeFallbackCode = 'assignment_missing_project_or_agent' | 'assignment_governance_provenance_missing' | '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_repository_ref_scope_invalid' | '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 interface AgentCapacityPlan {
+    teamId: string;
+    projectId: string;
+    environment: string;
+    allocationSetId?: string | null;
+    workday: WorkdayCapacityEnvelope;
+    assignableProviders: Array<{
+        capacityProviderId: string;
+        executionProviderId?: string | null;
+        availableAgentSeconds?: number | null;
+        reasons?: string[];
+        metadata?: Record<string, unknown>;
+    }>;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelModeFallback {
+    code: AgentKernelModeFallbackCode | string;
+    reason: string;
+    retryable: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelModeExecutionInput {
+    assignment: ProviderAssignment;
+    modeRunId?: string | null;
+    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;
+    artifactManifest?: import('../../artifacts.js').AgentArtifactManifest | null;
+    fallback?: AgentKernelModeFallback | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentKernelQueueObservation {
+    planningReady?: number | null;
+    actingReady?: number | null;
+    fallbackReady?: number | null;
+    planningBudgetSeconds?: number | null;
+    actingBudgetSeconds?: 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 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: CapacityLedgerEntry[];
+    fallbackOutputs: Array<Record<string, unknown>>;
+    diagnostics: CapacityRuntimeBlockerVm[];
+    windows: {
+        assignments: CapacityPageInfo & {
+            total: number;
+        };
+        modeRuns: CapacityPageInfo & {
+            total: number;
+        };
+        treeDxProxyAudit: CapacityPageInfo & {
+            total: number;
+        };
+        ledgerEntries: CapacityPageInfo & {
+            total: number;
+        };
+        fallbackOutputs: CapacityPageInfo & {
+            total: number;
+        };
+    };
+}
+export interface CapacitySettlementInvariantViolation {
+    code: string;
+    message: string;
+    severity: 'warning' | 'error';
+}
+export interface CapacitySettlementInvariantResult {
+    ok: boolean;
+    status: 'pass' | 'warning' | 'fail';
+    violations: CapacitySettlementInvariantViolation[];
+}
+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;
+    requestedSeconds: number;
+    reservedSeconds: number;
+    activeSeconds: number;
+    elapsedSeconds: number;
+    releasedSeconds: number;
+    overrunSeconds: number;
+    nativeUsage: Record<string, unknown>;
+    providerConfidence: 'high' | 'medium' | 'low' | 'blocked' | string;
+    warnings: string[];
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+}
+export interface CapacityEvidenceWindow<T> {
+    items: T[];
+    page: CapacityPageInfo;
+    total: number;
+}
+export interface WorkdayCapacitySummaryTotals {
+    assignments: {
+        total: number;
+        pending: number;
+        leased: number;
+        completed: number;
+        failed: number;
+        returned: number;
+        cancelled: number;
+    };
+    modeRuns: {
+        total: number;
+        queued: number;
+        running: number;
+        succeeded: number;
+        failed: number;
+        usageReported: number;
+    };
+    reservations: number;
+    usageActuals: number;
+    ledgerEntries: number;
+}
+export interface WorkdayCapacitySummaryPayload {
+    workday: WorkdayCapacityEnvelopeRecord;
+    totals: WorkdayCapacitySummaryTotals;
+    settlement: CapacitySettlementSummary;
+    evidence: {
+        assignments?: CapacityEvidenceWindow<ProviderAssignment>;
+        modeRuns?: CapacityEvidenceWindow<AgentModeRun>;
+        reservations?: CapacityEvidenceWindow<CapacityReservation>;
+        usageActuals?: CapacityEvidenceWindow<CapacityUsageActual>;
+        ledgerEntries?: CapacityEvidenceWindow<CapacityLedgerEntry>;
+    } | null;
+}

package/dist/agent-capacity/contracts/support/agent-atlas.d.ts

@@ -0,0 +1,185 @@
+import type { DecisionAssignmentGraphEdge, DecisionAssignmentGraphNode } from "./decision-work.js";
+export declare const AGENT_ATLAS_TOPOLOGY_CONTRACT: "treeseed.agent-atlas-topology/v1";
+export declare const agentAtlasSizingMetrics: readonly ["activity", "queue", "executions", "artifacts", "cost", "attention"];
+export type AgentAtlasSizingMetric = (typeof agentAtlasSizingMetrics)[number];
+export declare const agentAtlasEventCategories: readonly ["question", "note", "proposal", "assignment", "estimate", "execution", "message", "artifact", "tool", "signal", "usage", "failure"];
+export type AgentAtlasEventCategory = (typeof agentAtlasEventCategories)[number];
+export interface AgentAtlasScope {
+    teamId: string;
+    selectedDate: string;
+    workdayIds: string[];
+    projectIds: string[];
+    groupIds: string[];
+    agentIds: string[];
+    activityProfiles: string[];
+    sizingMetric: AgentAtlasSizingMetric;
+}
+export type AgentAtlasNodeKind = "project" | "group" | "agent" | "external";
+export type AgentAtlasEdgeKind = "group-membership" | "declared-signal" | "observed-signal" | "assignment" | "artifact";
+export interface AgentAtlasTopologyNode {
+    id: string;
+    kind: AgentAtlasNodeKind;
+    projectId: string | null;
+    parentId: string | null;
+    name: string;
+    slug: string;
+    capacityClass: string | null;
+    activityProfile: string | null;
+    directGroupIds: string[];
+    effectiveGroupIds: string[];
+    contentPath: string | null;
+    metadata: Record<string, unknown>;
+}
+export interface AgentAtlasTopologyEdge {
+    id: string;
+    kind: AgentAtlasEdgeKind;
+    fromNodeId: string;
+    toNodeId: string;
+    contractId: string | null;
+    direction: "input" | "output" | "relation";
+    metadata: Record<string, unknown>;
+}
+export interface AgentAtlasTopologySnapshot {
+    contract: typeof AGENT_ATLAS_TOPOLOGY_CONTRACT;
+    revision: string;
+    projectId: string;
+    immutableRef: string;
+    capturedAt: string;
+    planningGraphRevision: string;
+    nodes: AgentAtlasTopologyNode[];
+    edges: AgentAtlasTopologyEdge[];
+}
+export interface AgentAtlasMetricReading {
+    metric: AgentAtlasSizingMetric;
+    rawValue: number;
+    normalizedValue: number;
+    unit: string;
+}
+export interface AgentAtlasNodeState {
+    nodeId: string;
+    workdayIds: string[];
+    status: "idle" | "queued" | "running" | "waiting" | "blocked" | "degraded" | "completed";
+    progressPercent: number | null;
+    elapsedSeconds: number | null;
+    timeboxSeconds: number | null;
+    metrics: AgentAtlasMetricReading[];
+    activeAssignmentIds: string[];
+    lastEventSequence: number | null;
+    observedAt: string | null;
+}
+export interface AgentAtlasReplayCursor {
+    cursor: string | null;
+    observedAt: string;
+    positions: Record<string, number>;
+}
+export interface AgentAtlasPlayback {
+    mode: "live" | "historical";
+    startedAt: string;
+    endedAt: string | null;
+    liveEdgeAt: string;
+    cursor: AgentAtlasReplayCursor;
+}
+export interface AgentAtlasAssignmentSummary {
+    id: string;
+    projectId: string;
+    workdayId: string;
+    agentId: string | null;
+    name: string;
+    status: string;
+    progressPercent: number | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    decisionId: string | null;
+    proposalId: string | null;
+    graphId: string | null;
+    graphNodeId: string | null;
+}
+export interface AgentAtlasActivityItem {
+    id: string;
+    workdayId: string;
+    sequence: number;
+    timestamp: string;
+    category: AgentAtlasEventCategory;
+    direction: "input" | "output" | "internal";
+    severity: "debug" | "info" | "warning" | "error";
+    summary: string;
+    projectId: string | null;
+    agentId: string | null;
+    activityProfile: string | null;
+    signalContractId: string | null;
+    assignmentId: string | null;
+    artifactRefs: Record<string, unknown>[];
+    metadata: Record<string, unknown>;
+}
+export interface AgentAtlasWorkdaySummary {
+    id: string;
+    title: string;
+    status: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    assignments: {
+        total: number;
+        active: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+    };
+    eventCount: number;
+    message: string;
+}
+export interface AgentAtlasProjection {
+    revision: string;
+    generatedAt: string;
+    timeZone: string;
+    scope: AgentAtlasScope;
+    topologies: AgentAtlasTopologySnapshot[];
+    nodeStates: AgentAtlasNodeState[];
+    assignments: AgentAtlasAssignmentSummary[];
+    activity: AgentAtlasActivityItem[];
+    workdaySummary: AgentAtlasWorkdaySummary | null;
+    activityWindow: {
+        total: number;
+        loaded: number;
+        truncated: boolean;
+    };
+    playback: AgentAtlasPlayback;
+    alerts: Array<{
+        id: string;
+        severity: "info" | "warning" | "error";
+        message: string;
+    }>;
+}
+export interface AgentAtlasDelta {
+    revision: string;
+    generatedAt: string;
+    cursor: AgentAtlasReplayCursor;
+    nodeUpserts: AgentAtlasNodeState[];
+    removedNodeIds: string[];
+    assignmentUpserts: AgentAtlasAssignmentSummary[];
+    removedAssignmentIds: string[];
+    activity: AgentAtlasActivityItem[];
+}
+export type AgentAtlasContextKind = "project" | "group" | "agent" | "profile" | "workday" | "event" | "signal" | "assignment" | "artifact" | "proposal" | "decision";
+export interface AgentAtlasContextReference {
+    kind: AgentAtlasContextKind;
+    id: string;
+    projectId: string;
+    workdayId?: string;
+    eventSequence?: number;
+    immutableRef?: string;
+    path?: string;
+    digest?: string;
+}
+export interface AgentAtlasAssignmentGraphProjection {
+    id: string;
+    projectId: string;
+    decisionId: string;
+    proposalId: string | null;
+    status: string;
+    nodes: Array<DecisionAssignmentGraphNode & {
+        assignmentIds: string[];
+        progressPercent: number | null;
+    }>;
+    edges: DecisionAssignmentGraphEdge[];
+}
+export declare function isAgentAtlasContextReference(value: unknown): value is AgentAtlasContextReference;

package/dist/agent-capacity/contracts/support/agent-atlas.js

@@ -0,0 +1,47 @@
+const AGENT_ATLAS_TOPOLOGY_CONTRACT = "treeseed.agent-atlas-topology/v1";
+const agentAtlasSizingMetrics = [
+  "activity",
+  "queue",
+  "executions",
+  "artifacts",
+  "cost",
+  "attention"
+];
+const agentAtlasEventCategories = [
+  "question",
+  "note",
+  "proposal",
+  "assignment",
+  "estimate",
+  "execution",
+  "message",
+  "artifact",
+  "tool",
+  "signal",
+  "usage",
+  "failure"
+];
+function isAgentAtlasContextReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  const kinds = [
+    "project",
+    "group",
+    "agent",
+    "profile",
+    "workday",
+    "event",
+    "signal",
+    "assignment",
+    "artifact",
+    "proposal",
+    "decision"
+  ];
+  return kinds.includes(candidate.kind) && typeof candidate.id === "string" && Boolean(candidate.id) && typeof candidate.projectId === "string" && Boolean(candidate.projectId) && (candidate.eventSequence === void 0 || Number.isInteger(candidate.eventSequence) && Number(candidate.eventSequence) >= 0);
+}
+export {
+  AGENT_ATLAS_TOPOLOGY_CONTRACT,
+  agentAtlasEventCategories,
+  agentAtlasSizingMetrics,
+  isAgentAtlasContextReference
+};

package/dist/agent-capacity/contracts/support/agent-lab-monitoring.d.ts

@@ -0,0 +1,96 @@
+export declare const agentLabMetricKeys: readonly ["agents", "workdays", "systemEvents", "assignments", "executions", "artifacts", "passed", "failed", "running"];
+export type AgentLabMetricKey = typeof agentLabMetricKeys[number];
+export type AgentLabMetricSemantic = 'configured' | 'cumulative' | 'instantaneous' | 'exact-total';
+export type AgentLabEntityKind = 'agents' | 'workdays' | 'events' | 'assignments' | 'executions' | 'artifacts';
+export interface AgentLabMetricValue {
+    key: AgentLabMetricKey;
+    value: number;
+    secondary?: string | null;
+    semantic: AgentLabMetricSemantic;
+    observedAt: string;
+}
+export interface AgentLabWorkdaySummary {
+    id: string;
+    title: string;
+    status: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface AgentLabWorkdayContext {
+    selectedDate: string;
+    selectedWorkdayId: string | null;
+    latestWorkdayId: string | null;
+    workdays: AgentLabWorkdaySummary[];
+}
+export interface AgentLabOverview {
+    revision: string;
+    generatedAt: string;
+    timeZone: string;
+    operatingDay: {
+        start: string;
+        end: string;
+    };
+    team: {
+        id: string;
+        name: string;
+    };
+    workdayContext: AgentLabWorkdayContext;
+    metricTargets: AgentLabMetricTargets;
+    targetRevision: string | null;
+    connectivity: 'live' | 'idle' | 'degraded';
+    activeWorkdays: number;
+    activeProviders: number;
+    executionProviders: string[];
+    metrics: AgentLabMetricValue[];
+}
+export interface AgentLabActivityInterval {
+    id: string;
+    stateVersion: number;
+    projectId: string;
+    projectName: string;
+    agentId: string;
+    agentName: string;
+    agentClassId: string;
+    activityProfile: string;
+    assignmentId: string;
+    executionId: string;
+    status: string;
+    startedAt: string;
+    finishedAt: string | null;
+}
+export interface AgentLabMetricPoint {
+    id: string;
+    stateVersion: number;
+    timestamp: string;
+    values: Record<AgentLabMetricKey, number>;
+    statistics: Partial<Record<AgentLabMetricKey, {
+        semantic: AgentLabMetricSemantic;
+        exactTotal: number;
+        mean: number;
+        standardDeviation: number | null;
+        low: number;
+        high: number;
+        sampleSize: number;
+        observedAt: string;
+    }>>;
+}
+export type AgentLabMetricTargets = Partial<Record<AgentLabMetricKey, number>>;
+export interface AgentLabDelta<T> {
+    revision: string;
+    generatedAt: string;
+    cursor: string | null;
+    upserts: T[];
+    removedIds: string[];
+}
+export interface AgentLabEntitySummary {
+    id: string;
+    kind: AgentLabEntityKind;
+    title: string;
+    description: string;
+    status?: string | null;
+    projectId?: string | null;
+    projectName?: string | null;
+    workdayName?: string | null;
+    activityProfile?: string | null;
+    occurredAt?: string | null;
+}

package/dist/agent-capacity/contracts/support/agent-lab-monitoring.js

@@ -0,0 +1,14 @@
+const agentLabMetricKeys = [
+  "agents",
+  "workdays",
+  "systemEvents",
+  "assignments",
+  "executions",
+  "artifacts",
+  "passed",
+  "failed",
+  "running"
+];
+export {
+  agentLabMetricKeys
+};

package/dist/agent-capacity/contracts/support/authority/execution-mode.d.ts

@@ -0,0 +1,10 @@
+export declare const AGENT_WORK_EXECUTION_MODES: readonly ["simulation", "production"];
+/** Repository-publication authority. This is independent from planning/acting safety mode. */
+export type AgentWorkExecutionMode = (typeof AGENT_WORK_EXECUTION_MODES)[number];
+export declare const UPSTREAM_MUTATION_POLICIES: readonly ["denied", "checkpoint-only", "exact-approved-ref"];
+export type UpstreamMutationPolicy = (typeof UPSTREAM_MUTATION_POLICIES)[number];
+export declare function upstreamMutationPolicyFor(input: {
+    executionMode: AgentWorkExecutionMode;
+    authority: 'assignment' | 'platform-integration';
+}): UpstreamMutationPolicy;
+export declare function parseAgentWorkExecutionMode(value: unknown): AgentWorkExecutionMode;