@knpkv/control-center 0.1.0

package/dist/server/domain/index.js

@@ -0,0 +1,52 @@
+import { $ as MAXIMUM_NORMALIZED_ISSUE_HISTORY, $n as readinessObservationIsDeliveryActivity, $t as MAX_READINESS_EVIDENCE_REFERENCES, A as EvidenceAttribution, An as ReadinessVerdict, Ar as GovernedActionAuthorizationId, At as ReleaseRelayAlgorithm, B as RelationshipConfidence, Bn as deriveReadinessStages, Br as RelationshipRepairProposalId, Bt as HumanActor, C as DeliveryEntityDetails, Cn as ReadinessReleaseRevision, Cr as EntityId, Ct as ReleaseServiceName, D as DeliveryEntityStatusGroup, Dn as ReadinessScope, Dr as EvidenceId, Dt as RELEASE_RELAY_V1_ALGORITHM, E as DeliveryEntityService, En as ReadinessRuleVersion, Er as EvidenceClaimId, Et as RELEASE_RELAY_V1_ADJECTIVES, F as EvidenceValue, Fn as compareReadinessText, Fr as PersonId, Ft as ReleaseRelaySymbolIndices, G as RelationshipScope, Gn as deriveReleaseReadinessVerdict, Gr as ShareId, Gt as RoleAssignment, H as RelationshipKind, Hn as deriveReleaseReadinessNextEvaluationAt, Hr as ReleaseId, Ht as PersonAvatar, I as EvidenceVerifier, In as deriveEnvironmentReadinessVerdict, Ir as PluginConnectionId, It as deriveReleaseRelay, J as evidenceRetentionEligibilityAt, Jn as readinessFactResult, Jt as BuildReadinessStage, K as ResolvedDeliveryNode, Kn as readinessDefinitionsShapeIsV1, Kr as WorkspaceId, Kt as RoleScope, L as LedgerActor, Ln as deriveReadinessFindings, Lr as ProviderAccountId, Lt as Actor, M as EvidenceItem, Mn as ReleaseReadinessCandidateIdentity, Mr as GovernedActionTransitionId, Mt as ReleaseRelayNoun, N as EvidencePredicate, Nn as ReleaseReadinessRollupInput, Nr as GraphNodeId, Nt as ReleaseRelayProjection, O as DeliveryNode, On as ReadinessSourceSummary, Or as FollowedResourceId, Ot as RELEASE_RELAY_V1_NOUNS, P as EvidenceRetention, Pn as VerifyReadinessStage, Pr as JobId, Pt as ReleaseRelaySymbolIndex, Q as MAXIMUM_NORMALIZED_ISSUE_FIX_VERSIONS, Qn as readinessObservationIsCurrent, Qt as EnvironmentReadinessSummary, R as LedgerRevision, Rn as deriveReadinessNextEvaluationAt, Rr as ReadinessAssessmentId, Rt as AgentActor, S as RelationshipRepairReviewDecision, Sn as ReadinessProgress, Sr as DomainEventId, St as ReleaseLifecycle, T as DeliveryEntityProjection, Tn as ReadinessRuleReference, Tr as EventCursor, Tt as RELEASE_RELAY_ALGORITHM, U as RelationshipLifecycle, Un as deriveReleaseReadinessSourceSummaries, Ur as RoleAssignmentId, Ut as PersonSourceIdentity, V as RelationshipEndpointKind, Vn as deriveReleaseReadinessFindings, Vr as RelationshipRepairReviewId, Vt as Person, W as RelationshipProvenance, Wn as deriveReleaseReadinessStages, Wr as SessionId, Wt as Role, X as MAXIMUM_NORMALIZED_ISSUE_COMMENTS, Xn as readinessFindingKey, Xt as EnvironmentReadinessCandidateIdentity, Y as MAXIMUM_NORMALIZED_ISSUE_COLLABORATORS, Yn as readinessFailureCode, Yt as EnvironmentReadinessAssessment, Z as MAXIMUM_NORMALIZED_ISSUE_COMPONENTS, Zn as readinessNonPositiveCode, Zt as EnvironmentReadinessEvaluationInput, _ as RelationshipRepairDisposition, _n as ReadinessFactResult, _r as SourceUrl, _t as PluginConfigurationFieldV1, a as PortfolioInvalidatedPayloadV1, an as ReadinessAssessment, ar as MaximumPluginPayloadBytes, at as NormalizedIssueComment, b as RelationshipRepairRationale, bn as ReadinessFindingCode, br as AgentId, bt as SemanticVersion, c as TimelineAgentJobDetail, cn as ReadinessDerivationVersion, cr as hasMaximumPluginJsonBytes, ct as NormalizedIssueHistoryEntry, d as TimelineEventDetail, dn as ReadinessFactDefinition, dr as PluginHealth, dt as NormalizedIssueTruncatedField, en as MAX_READINESS_FINDINGS, er as readinessObservationIsPositive, et as MAXIMUM_NORMALIZED_ISSUE_HISTORY_CHANGES, f as TimelineEventIdentifiers, fn as ReadinessFactEvaluation, fr as evaluateFreshnessAt, ft as NormalizedRelatedIssue, g as RelationshipRepairApplication, gn as ReadinessFactRequirement, gr as SourceRevision, gt as PluginCapabilityOfferV1, h as TimelineSourceKind, hn as ReadinessFactObservation, hr as Revision, ht as PluginCapabilityId, i as PortfolioInvalidatedEventV1, in as ReadinessArtifactRevision, ir as MaximumPluginDescriptorBytes, it as NormalizedIssueCollaborator, j as EvidenceClaim, jn as ReleaseReadinessAssessment, jr as GovernedActionId, jt as ReleaseRelayCodename, k as DeliveryRelationship, kn as ReadinessStages, kr as GovernedActionAttemptId, kt as ReleaseRelayAdjective, l as TimelineCursor, ln as ReadinessEvidenceReference, lr as Freshness, lt as NormalizedIssueNamedValue, m as TimelineService, mn as ReadinessFactKind, mr as ProviderId, mt as NegotiatedPluginDescriptorV1, n as DomainEventMetadataV1, nn as READINESS_DERIVATION_VERSION_V1, nr as readinessStagesAreEqual, nt as MAXIMUM_NORMALIZED_ISSUE_SUBTASKS, o as PortfolioInvalidationReason, on as ReadinessCandidateDigest, or as MaximumPluginSyncPageBytes, ot as NormalizedIssueFixVersion, p as TimelinePage, pn as ReadinessFactId, pr as NormalizationSchemaVersion, pt as NegotiatedPluginCapabilityV1, q as evidenceFreshnessAt, qn as readinessEvidenceIsCurrent, qt as derivePersonInitials, r as MaximumDomainEventPayloadBytes, rn as READINESS_RULE_VERSION_V1, rr as sortedReadinessUnique, rt as NormalizedIssueAttributes, s as TimelineActorKind, sn as ReadinessCandidateIdentity, sr as PluginPayloadJson, st as NormalizedIssueHistoryChange, t as DomainEventCorrelationId, tn as ProductionReadinessStage, tr as readinessPolicyShapeIsV1, tt as MAXIMUM_NORMALIZED_ISSUE_LABELS, u as TimelineEvent, un as ReadinessEvidenceSource, ur as PluginFailureClass, ut as NormalizedIssueProject, v as RelationshipRepairProposal, vn as ReadinessFactState, vr as VendorImmutableId, vt as PluginDescriptorV1, w as DeliveryEntityKind, wn as ReadinessRuleId, wr as EnvironmentId, wt as ReleaseVersion, x as RelationshipRepairReview, xn as ReadinessFindingSubject, xr as AgentThreadId, xt as Release, y as RelationshipRepairProposalOrigin, yn as ReadinessFinding, yr as UtcTimestamp, yt as PluginId, z as RELATIONSHIP_ENDPOINT_MATRIX_V1, zn as deriveReadinessSourceSummaries, zr as RelationshipId, zt as AssignmentLifecycle } from "../assets/domainEvent-x7yeq-gU.js";
+import { $ as GovernedActionProposalOrigin, A as GovernedActionAuthorizationBindingInput, At as PluginSyncPageV1, B as GovernedActionEnvelopeMaterialV1, C as GovernedActionTransitionMaterialV1, Ct as PluginCheckpointV1, D as reduceGovernedActionState, Dt as PluginEventId, E as isGovernedActionTerminalState, Et as PluginEntityType, F as GovernedActionAttemptDigest, Ft as AuthorizedShareTarget, G as GovernedActionIdempotencyKey, H as GovernedActionEvidenceReference, I as GovernedActionAttemptV1, J as GovernedActionPolicyBinding, K as GovernedActionPluginConnectionAuthorityDigest, L as GovernedActionAuthorizationDigest, M as governedActionAuthorizationMatchesTransition, Mt as ReadPluginEntityRequestV1, N as governedActionAuthorizationMismatches, Nt as ReadPluginEntityResultV1, O as GovernedActionAuthorityBindingInput, Ot as PluginPageCursorV1, P as governedActionPermissionGrants, Pt as AuthorizedShareGrant, Q as GovernedActionPolicyId, R as GovernedActionAuthorizationV1, S as GovernedActionTransitionDigest, St as NormalizedPluginEventV1, T as GovernedActionUnknownOutcome, Tt as PluginEntityReferenceV1, U as GovernedActionEvidenceSet, V as GovernedActionEnvelopeV1, W as GovernedActionEvidenceSetDigest, X as GovernedActionPolicyEvaluationDigest, Y as GovernedActionPolicyDigest, Z as GovernedActionPolicyEvaluationV1, _ as GovernedActionDenialReason, _t as ReadyPluginActionPreflightV1, a as ReleaseReadinessCandidateMaterial, at as PluginActionCancellationResultV1, b as GovernedActionTransitionCause, bt as DiffInventoryPageRequestV1, c as normalizeReadinessRuleMaterial, ct as PluginActionPreflightV1, d as PluginDiscoveryV1, dt as PluginActionReconciliationRequestV1, et as GovernedActionTargetSnapshotV1, f as GovernedActionLifecycleHeadV1, ft as PluginActionReconciliationResultV1, g as GovernedActionCommandId, gt as ProposePluginActionRequestV1, h as GovernedActionCommandDigest, ht as PluginTerminalProviderReceiptV1, i as ReadinessRuleMaterial, it as PluginActionCancellationRequestV1, j as governedActionAuthorityMismatches, jt as PluginSyncRequestV1, k as GovernedActionAuthorityMismatch, kt as PluginRelativePathV1, l as normalizeReleaseReadinessCandidateMaterial, lt as PluginActionProposalV1, m as advanceGovernedActionLifecycle, mt as PluginProviderReceiptV1, n as summarizeEnvironmentReadiness, nt as BlockedPluginActionPreflightV1, o as ReleaseReadinessChildMaterial, ot as PluginActionDispatchResultV1, p as GovernedActionProviderLineage, pt as PluginProviderOperationId, q as GovernedActionPluginConnectionRevision, r as EnvironmentReadinessCandidateMaterial, rt as PluginAcceptedProviderReceiptV1, s as normalizeEnvironmentReadinessCandidateMaterial, st as PluginActionPayloadDigest, t as rollUpReleaseReadiness, tt as AuthorizedPluginActionV1, u as PluginDiscoveryEndpointV1, ut as PluginActionReconciliationKey, v as GovernedActionOutcomeSource, vt as DiffContentRangeRequestV1, w as GovernedActionTransitionV1, wt as PluginDiffInventoryEntryV1, x as GovernedActionTransitionCommand, xt as DiffInventoryPageV1, y as GovernedActionState, yt as DiffContentRangeV1, z as GovernedActionEnvelopeDigest } from "../assets/readiness-CzU3vjYQ.js";
+import { n as firstPartyServiceIdentities, r as firstPartyServiceIdentityByProvider, t as FirstPartyServiceIdentity } from "../assets/firstPartyServices-Y41P8uke.js";
+//#region src/domain/readiness/evaluate.ts
+var evidenceIds = (observation) => observation === null ? [] : sortedReadinessUnique(observation.evidence.map(({ evidenceId }) => evidenceId));
+var evaluateFact = (definition, observation) => ({
+	definition,
+	observation,
+	result: readinessFactResult(definition, observation),
+	evidenceIds: evidenceIds(observation)
+});
+/** Pure V1 derivation of one immutable environment readiness assessment. */
+var assessEnvironmentReadiness = (input) => {
+	const observations = input.observations.map((observation) => ({
+		...observation,
+		evidence: observation.evidence.slice().sort((left, right) => compareReadinessText(left.evidenceId, right.evidenceId))
+	}));
+	const observationsById = new Map(observations.map((observation) => [observation.factId, observation]));
+	const facts = input.definitions.slice().sort((left, right) => compareReadinessText(left.factId, right.factId)).map((definition) => evaluateFact(definition, observationsById.get(definition.factId) ?? null));
+	const { blockers, gaps, warnings } = deriveReadinessFindings(facts, input.complete);
+	const stages = deriveReadinessStages(facts);
+	return {
+		_tag: "environment",
+		assessmentId: input.assessmentId,
+		previousAssessmentId: input.previousAssessmentId,
+		candidate: input.candidate,
+		rule: input.rule,
+		derivationVersion: input.derivationVersion,
+		evaluatedAt: input.evaluatedAt,
+		nextEvaluationAt: deriveReadinessNextEvaluationAt(facts),
+		inputComplete: input.complete,
+		verdict: deriveEnvironmentReadinessVerdict({
+			blockers,
+			facts,
+			gaps,
+			stages
+		}),
+		stages,
+		facts,
+		requiredFactIds: sortedReadinessUnique(input.definitions.filter(({ requirement }) => requirement === "required").map(({ factId }) => factId)),
+		verifiedFactIds: sortedReadinessUnique(facts.filter(({ result }) => result === "verified").map(({ definition }) => definition.factId)),
+		blockers,
+		warnings,
+		gaps,
+		sourceFreshness: deriveReadinessSourceSummaries(facts),
+		evidenceIds: sortedReadinessUnique(observations.flatMap(({ evidence }) => evidence.map(({ evidenceId }) => evidenceId)))
+	};
+};
+//#endregion
+export { Actor, AgentActor, AgentId, AgentThreadId, AssignmentLifecycle, AuthorizedPluginActionV1, AuthorizedShareGrant, AuthorizedShareTarget, BlockedPluginActionPreflightV1, BuildReadinessStage, DeliveryEntityDetails, DeliveryEntityKind, DeliveryEntityProjection, DeliveryEntityService, DeliveryEntityStatusGroup, DeliveryNode, DeliveryRelationship, DiffContentRangeRequestV1, DiffContentRangeV1, DiffInventoryPageRequestV1, DiffInventoryPageV1, DomainEventCorrelationId, DomainEventId, DomainEventMetadataV1, EntityId, EnvironmentId, EnvironmentReadinessAssessment, EnvironmentReadinessCandidateIdentity, EnvironmentReadinessCandidateMaterial, EnvironmentReadinessEvaluationInput, EnvironmentReadinessSummary, EventCursor, EvidenceAttribution, EvidenceClaim, EvidenceClaimId, EvidenceId, EvidenceItem, EvidencePredicate, EvidenceRetention, EvidenceValue, EvidenceVerifier, FirstPartyServiceIdentity, FollowedResourceId, Freshness, GovernedActionAttemptDigest, GovernedActionAttemptId, GovernedActionAttemptV1, GovernedActionAuthorityBindingInput, GovernedActionAuthorityMismatch, GovernedActionAuthorizationBindingInput, GovernedActionAuthorizationDigest, GovernedActionAuthorizationId, GovernedActionAuthorizationV1, GovernedActionCommandDigest, GovernedActionCommandId, GovernedActionDenialReason, GovernedActionEnvelopeDigest, GovernedActionEnvelopeMaterialV1, GovernedActionEnvelopeV1, GovernedActionEvidenceReference, GovernedActionEvidenceSet, GovernedActionEvidenceSetDigest, GovernedActionId, GovernedActionIdempotencyKey, GovernedActionLifecycleHeadV1, GovernedActionOutcomeSource, GovernedActionPluginConnectionAuthorityDigest, GovernedActionPluginConnectionRevision, GovernedActionPolicyBinding, GovernedActionPolicyDigest, GovernedActionPolicyEvaluationDigest, GovernedActionPolicyEvaluationV1, GovernedActionPolicyId, GovernedActionProposalOrigin, GovernedActionProviderLineage, GovernedActionState, GovernedActionTargetSnapshotV1, GovernedActionTransitionCause, GovernedActionTransitionCommand, GovernedActionTransitionDigest, GovernedActionTransitionId, GovernedActionTransitionMaterialV1, GovernedActionTransitionV1, GovernedActionUnknownOutcome, GraphNodeId, HumanActor, JobId, LedgerActor, LedgerRevision, MAXIMUM_NORMALIZED_ISSUE_COLLABORATORS, MAXIMUM_NORMALIZED_ISSUE_COMMENTS, MAXIMUM_NORMALIZED_ISSUE_COMPONENTS, MAXIMUM_NORMALIZED_ISSUE_FIX_VERSIONS, MAXIMUM_NORMALIZED_ISSUE_HISTORY, MAXIMUM_NORMALIZED_ISSUE_HISTORY_CHANGES, MAXIMUM_NORMALIZED_ISSUE_LABELS, MAXIMUM_NORMALIZED_ISSUE_SUBTASKS, MAX_READINESS_EVIDENCE_REFERENCES, MAX_READINESS_FINDINGS, MaximumDomainEventPayloadBytes, MaximumPluginDescriptorBytes, MaximumPluginPayloadBytes, MaximumPluginSyncPageBytes, NegotiatedPluginCapabilityV1, NegotiatedPluginDescriptorV1, NormalizationSchemaVersion, NormalizedIssueAttributes, NormalizedIssueCollaborator, NormalizedIssueComment, NormalizedIssueFixVersion, NormalizedIssueHistoryChange, NormalizedIssueHistoryEntry, NormalizedIssueNamedValue, NormalizedIssueProject, NormalizedIssueTruncatedField, NormalizedPluginEventV1, NormalizedRelatedIssue, Person, PersonAvatar, PersonId, PersonSourceIdentity, PluginAcceptedProviderReceiptV1, PluginActionCancellationRequestV1, PluginActionCancellationResultV1, PluginActionDispatchResultV1, PluginActionPayloadDigest, PluginActionPreflightV1, PluginActionProposalV1, PluginActionReconciliationKey, PluginActionReconciliationRequestV1, PluginActionReconciliationResultV1, PluginCapabilityId, PluginCapabilityOfferV1, PluginCheckpointV1, PluginConfigurationFieldV1, PluginConnectionId, PluginDescriptorV1, PluginDiffInventoryEntryV1, PluginDiscoveryEndpointV1, PluginDiscoveryV1, PluginEntityReferenceV1, PluginEntityType, PluginEventId, PluginFailureClass, PluginHealth, PluginId, PluginPageCursorV1, PluginPayloadJson, PluginProviderOperationId, PluginProviderReceiptV1, PluginRelativePathV1, PluginSyncPageV1, PluginSyncRequestV1, PluginTerminalProviderReceiptV1, PortfolioInvalidatedEventV1, PortfolioInvalidatedPayloadV1, PortfolioInvalidationReason, ProductionReadinessStage, ProposePluginActionRequestV1, ProviderAccountId, ProviderId, READINESS_DERIVATION_VERSION_V1, READINESS_RULE_VERSION_V1, RELATIONSHIP_ENDPOINT_MATRIX_V1, RELEASE_RELAY_ALGORITHM, RELEASE_RELAY_V1_ADJECTIVES, RELEASE_RELAY_V1_ALGORITHM, RELEASE_RELAY_V1_NOUNS, ReadPluginEntityRequestV1, ReadPluginEntityResultV1, ReadinessArtifactRevision, ReadinessAssessment, ReadinessAssessmentId, ReadinessCandidateDigest, ReadinessCandidateIdentity, ReadinessDerivationVersion, ReadinessEvidenceReference, ReadinessEvidenceSource, ReadinessFactDefinition, ReadinessFactEvaluation, ReadinessFactId, ReadinessFactKind, ReadinessFactObservation, ReadinessFactRequirement, ReadinessFactResult, ReadinessFactState, ReadinessFinding, ReadinessFindingCode, ReadinessFindingSubject, ReadinessProgress, ReadinessReleaseRevision, ReadinessRuleId, ReadinessRuleMaterial, ReadinessRuleReference, ReadinessRuleVersion, ReadinessScope, ReadinessSourceSummary, ReadinessStages, ReadinessVerdict, ReadyPluginActionPreflightV1, RelationshipConfidence, RelationshipEndpointKind, RelationshipId, RelationshipKind, RelationshipLifecycle, RelationshipProvenance, RelationshipRepairApplication, RelationshipRepairDisposition, RelationshipRepairProposal, RelationshipRepairProposalId, RelationshipRepairProposalOrigin, RelationshipRepairRationale, RelationshipRepairReview, RelationshipRepairReviewDecision, RelationshipRepairReviewId, RelationshipScope, Release, ReleaseId, ReleaseLifecycle, ReleaseReadinessAssessment, ReleaseReadinessCandidateIdentity, ReleaseReadinessCandidateMaterial, ReleaseReadinessChildMaterial, ReleaseReadinessRollupInput, ReleaseRelayAdjective, ReleaseRelayAlgorithm, ReleaseRelayCodename, ReleaseRelayNoun, ReleaseRelayProjection, ReleaseRelaySymbolIndex, ReleaseRelaySymbolIndices, ReleaseServiceName, ReleaseVersion, ResolvedDeliveryNode, Revision, Role, RoleAssignment, RoleAssignmentId, RoleScope, SemanticVersion, SessionId, ShareId, SourceRevision, SourceUrl, TimelineActorKind, TimelineAgentJobDetail, TimelineCursor, TimelineEvent, TimelineEventDetail, TimelineEventIdentifiers, TimelinePage, TimelineService, TimelineSourceKind, UtcTimestamp, VendorImmutableId, VerifyReadinessStage, WorkspaceId, advanceGovernedActionLifecycle, assessEnvironmentReadiness, compareReadinessText, deriveEnvironmentReadinessVerdict, derivePersonInitials, deriveReadinessFindings, deriveReadinessNextEvaluationAt, deriveReadinessSourceSummaries, deriveReadinessStages, deriveReleaseReadinessFindings, deriveReleaseReadinessNextEvaluationAt, deriveReleaseReadinessSourceSummaries, deriveReleaseReadinessStages, deriveReleaseReadinessVerdict, deriveReleaseRelay, evaluateFreshnessAt, evidenceFreshnessAt, evidenceRetentionEligibilityAt, firstPartyServiceIdentities, firstPartyServiceIdentityByProvider, governedActionAuthorityMismatches, governedActionAuthorizationMatchesTransition, governedActionAuthorizationMismatches, governedActionPermissionGrants, hasMaximumPluginJsonBytes, isGovernedActionTerminalState, normalizeEnvironmentReadinessCandidateMaterial, normalizeReadinessRuleMaterial, normalizeReleaseReadinessCandidateMaterial, readinessDefinitionsShapeIsV1, readinessEvidenceIsCurrent, readinessFactResult, readinessFailureCode, readinessFindingKey, readinessNonPositiveCode, readinessObservationIsCurrent, readinessObservationIsDeliveryActivity, readinessObservationIsPositive, readinessPolicyShapeIsV1, readinessStagesAreEqual, reduceGovernedActionState, rollUpReleaseReadiness, sortedReadinessUnique, summarizeEnvironmentReadiness };
+
+//# sourceMappingURL=index.js.map

package/dist/server/domain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/domain/readiness/evaluate.ts"],"sourcesContent":["import type { EvidenceId } from \"../identifiers.js\"\nimport type {\n  EnvironmentReadinessAssessment,\n  EnvironmentReadinessEvaluationInput,\n  ReadinessFactDefinition,\n  ReadinessFactEvaluation,\n  ReadinessFactObservation\n} from \"./model.js\"\nimport {\n  compareReadinessText,\n  deriveEnvironmentReadinessVerdict,\n  deriveReadinessFindings,\n  deriveReadinessNextEvaluationAt,\n  deriveReadinessSourceSummaries,\n  deriveReadinessStages,\n  readinessFactResult,\n  sortedReadinessUnique\n} from \"./policy.js\"\n\nconst evidenceIds = (observation: ReadinessFactObservation | null): Array<EvidenceId> =>\n  observation === null\n    ? []\n    : sortedReadinessUnique(observation.evidence.map(({ evidenceId }) => evidenceId))\n\nconst evaluateFact = (\n  definition: ReadinessFactDefinition,\n  observation: ReadinessFactObservation | null\n): ReadinessFactEvaluation => ({\n  definition,\n  observation,\n  result: readinessFactResult(definition, observation),\n  evidenceIds: evidenceIds(observation)\n})\n\n/** Pure V1 derivation of one immutable environment readiness assessment. */\nexport const assessEnvironmentReadiness = (\n  input: EnvironmentReadinessEvaluationInput\n): EnvironmentReadinessAssessment => {\n  const observations = input.observations.map((observation): ReadinessFactObservation => ({\n    ...observation,\n    evidence: observation.evidence.slice().sort((left, right) =>\n      compareReadinessText(left.evidenceId, right.evidenceId)\n    )\n  }))\n  const observationsById = new Map(observations.map((observation) => [observation.factId, observation]))\n  const facts = input.definitions\n    .slice()\n    .sort((left, right) => compareReadinessText(left.factId, right.factId))\n    .map((definition) => evaluateFact(definition, observationsById.get(definition.factId) ?? null))\n  const { blockers, gaps, warnings } = deriveReadinessFindings(facts, input.complete)\n  const stages = deriveReadinessStages(facts)\n\n  return {\n    _tag: \"environment\",\n    assessmentId: input.assessmentId,\n    previousAssessmentId: input.previousAssessmentId,\n    candidate: input.candidate,\n    rule: input.rule,\n    derivationVersion: input.derivationVersion,\n    evaluatedAt: input.evaluatedAt,\n    nextEvaluationAt: deriveReadinessNextEvaluationAt(facts),\n    inputComplete: input.complete,\n    verdict: deriveEnvironmentReadinessVerdict({ blockers, facts, gaps, stages }),\n    stages,\n    facts,\n    requiredFactIds: sortedReadinessUnique(\n      input.definitions\n        .filter(({ requirement }) => requirement === \"required\")\n        .map(({ factId }) => factId)\n    ),\n    verifiedFactIds: sortedReadinessUnique(\n      facts\n        .filter(({ result }) => result === \"verified\")\n        .map(({ definition }) => definition.factId)\n    ),\n    blockers,\n    warnings,\n    gaps,\n    sourceFreshness: deriveReadinessSourceSummaries(facts),\n    evidenceIds: sortedReadinessUnique(\n      observations.flatMap(({ evidence }) => evidence.map(({ evidenceId }) => evidenceId))\n    )\n  }\n}\n"],"mappings":";;;;AAmBA,IAAM,eAAe,gBACnB,gBAAgB,OACZ,CAAC,IACD,sBAAsB,YAAY,SAAS,KAAK,EAAE,iBAAiB,UAAU,CAAC;AAEpF,IAAM,gBACJ,YACA,iBAC6B;CAC7B;CACA;CACA,QAAQ,oBAAoB,YAAY,WAAW;CACnD,aAAa,YAAY,WAAW;AACtC;;AAGA,IAAa,8BACX,UACmC;CACnC,MAAM,eAAe,MAAM,aAAa,KAAK,iBAA2C;EACtF,GAAG;EACH,UAAU,YAAY,SAAS,MAAM,CAAC,CAAC,MAAM,MAAM,UACjD,qBAAqB,KAAK,YAAY,MAAM,UAAU,CACxD;CACF,EAAE;CACF,MAAM,mBAAmB,IAAI,IAAI,aAAa,KAAK,gBAAgB,CAAC,YAAY,QAAQ,WAAW,CAAC,CAAC;CACrG,MAAM,QAAQ,MAAM,YACjB,MAAM,CAAC,CACP,MAAM,MAAM,UAAU,qBAAqB,KAAK,QAAQ,MAAM,MAAM,CAAC,CAAC,CACtE,KAAK,eAAe,aAAa,YAAY,iBAAiB,IAAI,WAAW,MAAM,KAAK,IAAI,CAAC;CAChG,MAAM,EAAE,UAAU,MAAM,aAAa,wBAAwB,OAAO,MAAM,QAAQ;CAClF,MAAM,SAAS,sBAAsB,KAAK;CAE1C,OAAO;EACL,MAAM;EACN,cAAc,MAAM;EACpB,sBAAsB,MAAM;EAC5B,WAAW,MAAM;EACjB,MAAM,MAAM;EACZ,mBAAmB,MAAM;EACzB,aAAa,MAAM;EACnB,kBAAkB,gCAAgC,KAAK;EACvD,eAAe,MAAM;EACrB,SAAS,kCAAkC;GAAE;GAAU;GAAO;GAAM;EAAO,CAAC;EAC5E;EACA;EACA,iBAAiB,sBACf,MAAM,YACH,QAAQ,EAAE,kBAAkB,gBAAgB,UAAU,CAAC,CACvD,KAAK,EAAE,aAAa,MAAM,CAC/B;EACA,iBAAiB,sBACf,MACG,QAAQ,EAAE,aAAa,WAAW,UAAU,CAAC,CAC7C,KAAK,EAAE,iBAAiB,WAAW,MAAM,CAC9C;EACA;EACA;EACA;EACA,iBAAiB,+BAA+B,KAAK;EACrD,aAAa,sBACX,aAAa,SAAS,EAAE,eAAe,SAAS,KAAK,EAAE,iBAAiB,UAAU,CAAC,CACrF;CACF;AACF"}

package/dist/server/domain/normalizedIssue.d.ts

@@ -0,0 +1,223 @@
+import * as Schema from "effect/Schema";
+export declare const MAXIMUM_NORMALIZED_ISSUE_LABELS = 200;
+export declare const MAXIMUM_NORMALIZED_ISSUE_COMPONENTS = 100;
+export declare const MAXIMUM_NORMALIZED_ISSUE_FIX_VERSIONS = 99;
+export declare const MAXIMUM_NORMALIZED_ISSUE_SUBTASKS = 200;
+export declare const MAXIMUM_NORMALIZED_ISSUE_COLLABORATORS = 200;
+export declare const MAXIMUM_NORMALIZED_ISSUE_COMMENTS = 200;
+export declare const MAXIMUM_NORMALIZED_ISSUE_HISTORY = 200;
+export declare const MAXIMUM_NORMALIZED_ISSUE_HISTORY_CHANGES = 100;
+/** Provider-neutral named source object retained with a bounded source identity. */
+export declare const NormalizedIssueNamedValue: Schema.Struct<{
+    readonly sourceId: Schema.NullOr<Schema.String>;
+    readonly name: Schema.NullOr<Schema.String>;
+}>;
+/** Provider-neutral project identity and presentation retained from an issue source. */
+export declare const NormalizedIssueProject: Schema.Struct<{
+    readonly sourceId: Schema.NullOr<Schema.String>;
+    readonly key: Schema.NullOr<Schema.String>;
+    readonly name: Schema.NullOr<Schema.String>;
+}>;
+/** Provider-neutral release/version reference retained from an issue source. */
+export declare const NormalizedIssueFixVersion: Schema.Struct<{
+    readonly sourceId: Schema.NullOr<Schema.String>;
+    readonly name: Schema.NullOr<Schema.String>;
+    readonly released: Schema.Boolean;
+    readonly releaseDate: Schema.NullOr<Schema.String>;
+}>;
+/** Provider-neutral parent or subtask reference retained from an issue source. */
+export declare const NormalizedRelatedIssue: Schema.Struct<{
+    readonly sourceId: Schema.NullOr<Schema.String>;
+    readonly key: Schema.NullOr<Schema.String>;
+    readonly summary: Schema.NullOr<Schema.String>;
+    readonly status: Schema.NullOr<Schema.Struct<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>>;
+}>;
+/** Bounded source collaborator used for attribution without provider response types. */
+export declare const NormalizedIssueCollaborator: Schema.Struct<{
+    readonly sourcePersonId: Schema.String;
+    readonly displayName: Schema.String;
+    readonly avatarUrl: Schema.NullOr<Schema.String>;
+    readonly active: Schema.Boolean;
+    readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+}>;
+/** Bounded provider-neutral issue comment. */
+export declare const NormalizedIssueComment: Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+    readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+    readonly body: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.NullOr<Schema.String>;
+}>;
+/** One bounded provider-neutral field transition. */
+export declare const NormalizedIssueHistoryChange: Schema.Struct<{
+    readonly field: Schema.String;
+    readonly from: Schema.NullOr<Schema.String>;
+    readonly to: Schema.NullOr<Schema.String>;
+}>;
+/** Bounded provider-neutral issue history entry. */
+export declare const NormalizedIssueHistoryEntry: Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.NullOr<Schema.String>;
+    readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly field: Schema.String;
+        readonly from: Schema.NullOr<Schema.String>;
+        readonly to: Schema.NullOr<Schema.String>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly field: Schema.String;
+        readonly from: Schema.NullOr<Schema.String>;
+        readonly to: Schema.NullOr<Schema.String>;
+    }, "Encoded">, never, never>>;
+}>;
+/** Fields whose source material may be deliberately reduced to remain within synchronization bounds. */
+export declare const NormalizedIssueTruncatedField: Schema.Literals<readonly ["acceptanceCriteria", "collaborators", "comments", "components", "description", "environment", "fixVersions", "history", "issueType", "key", "labels", "parent", "priority", "project", "resolution", "summary", "status", "subtasks", "updatedAt", "createdAt", "dueDate", "resolvedAt"]>;
+/**
+ * Shared provider-neutral issue detail accepted from normalized plugins.
+ *
+ * The original compact key/status/priority/estimate fields remain required.
+ * Rich fields are optional so older normalized plugins and persisted projections
+ * remain valid; first-party Jira synchronization always supplies every rich field.
+ */
+export declare const NormalizedIssueAttributes: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly status: Schema.String;
+    readonly priority: Schema.NullOr<Schema.String>;
+    readonly estimatePoints: Schema.NullOr<Schema.Number>;
+    readonly summary: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>>>;
+    readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly key: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>>>;
+    readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>>>;
+    readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+    readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }, "Encoded">, never, never>>>;
+    readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+        readonly released: Schema.Boolean;
+        readonly releaseDate: Schema.NullOr<Schema.String>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+        readonly released: Schema.Boolean;
+        readonly releaseDate: Schema.NullOr<Schema.String>;
+    }, "Encoded">, never, never>>>;
+    readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly key: Schema.NullOr<Schema.String>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly status: Schema.NullOr<Schema.Struct<{
+            readonly sourceId: Schema.NullOr<Schema.String>;
+            readonly name: Schema.NullOr<Schema.String>;
+        }>>;
+    }>>>;
+    readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly key: Schema.NullOr<Schema.String>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly status: Schema.NullOr<Schema.Struct<{
+            readonly sourceId: Schema.NullOr<Schema.String>;
+            readonly name: Schema.NullOr<Schema.String>;
+        }>>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.NullOr<Schema.String>;
+        readonly key: Schema.NullOr<Schema.String>;
+        readonly summary: Schema.NullOr<Schema.String>;
+        readonly status: Schema.NullOr<Schema.Struct<{
+            readonly sourceId: Schema.NullOr<Schema.String>;
+            readonly name: Schema.NullOr<Schema.String>;
+        }>>;
+    }, "Encoded">, never, never>>>;
+    readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourcePersonId: Schema.String;
+        readonly displayName: Schema.String;
+        readonly avatarUrl: Schema.NullOr<Schema.String>;
+        readonly active: Schema.Boolean;
+        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourcePersonId: Schema.String;
+        readonly displayName: Schema.String;
+        readonly avatarUrl: Schema.NullOr<Schema.String>;
+        readonly active: Schema.Boolean;
+        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+    }, "Encoded">, never, never>>>;
+    readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.String;
+        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly body: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.NullOr<Schema.String>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.String;
+        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly body: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.NullOr<Schema.String>;
+    }, "Encoded">, never, never>>>;
+    readonly commentTotal: Schema.optionalKey<Schema.Int>;
+    readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+    readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+    readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.String;
+        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.NullOr<Schema.String>;
+        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+            readonly field: Schema.String;
+            readonly from: Schema.NullOr<Schema.String>;
+            readonly to: Schema.NullOr<Schema.String>;
+        }, "Type">, Schema.Struct.ReadonlySide<{
+            readonly field: Schema.String;
+            readonly from: Schema.NullOr<Schema.String>;
+            readonly to: Schema.NullOr<Schema.String>;
+        }, "Encoded">, never, never>>;
+    }, "Type">, Schema.Struct.ReadonlySide<{
+        readonly sourceId: Schema.String;
+        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.NullOr<Schema.String>;
+        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+            readonly field: Schema.String;
+            readonly from: Schema.NullOr<Schema.String>;
+            readonly to: Schema.NullOr<Schema.String>;
+        }, "Type">, Schema.Struct.ReadonlySide<{
+            readonly field: Schema.String;
+            readonly from: Schema.NullOr<Schema.String>;
+            readonly to: Schema.NullOr<Schema.String>;
+        }, "Encoded">, never, never>>;
+    }, "Encoded">, never, never>>>;
+    readonly historyTotal: Schema.optionalKey<Schema.Int>;
+    readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+    readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+}>;
+/** Decoded provider-neutral normalized issue detail. */
+export type NormalizedIssueAttributes = typeof NormalizedIssueAttributes.Type;
+//# sourceMappingURL=normalizedIssue.d.ts.map

package/dist/server/domain/normalizedIssue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizedIssue.d.ts","sourceRoot":"","sources":["../../../src/domain/normalizedIssue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAavC,eAAO,MAAM,+BAA+B,MAAM,CAAA;AAClD,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD,eAAO,MAAM,qCAAqC,KAAK,CAAA;AACvD,eAAO,MAAM,iCAAiC,MAAM,CAAA;AACpD,eAAO,MAAM,sCAAsC,MAAM,CAAA;AACzD,eAAO,MAAM,iCAAiC,MAAM,CAAA;AACpD,eAAO,MAAM,gCAAgC,MAAM,CAAA;AACnD,eAAO,MAAM,wCAAwC,MAAM,CAAA;AAa3D,oFAAoF;AACpF,eAAO,MAAM,yBAAyB;;;EAGkB,CAAA;AAExD,wFAAwF;AACxF,eAAO,MAAM,sBAAsB;;;;EAIkB,CAAA;AAErD,gFAAgF;AAChF,eAAO,MAAM,yBAAyB;;;;;EAKkB,CAAA;AAExD,kFAAkF;AAClF,eAAO,MAAM,sBAAsB;;;;;;;;EAKkB,CAAA;AAErD,wFAAwF;AACxF,eAAO,MAAM,2BAA2B;;;;;;EAMkB,CAAA;AAE1D,8CAA8C;AAC9C,eAAO,MAAM,sBAAsB;;;;;;;EAOkB,CAAA;AAErD,qDAAqD;AACrD,eAAO,MAAM,4BAA4B;;;;EAIkB,CAAA;AAE3D,oDAAoD;AACpD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;EAKkB,CAAA;AAE1D,wGAAwG;AACxG,eAAO,MAAM,6BAA6B,sTAuBxC,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCkB,CAAA;AAExD,wDAAwD;AACxD,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA"}

package/dist/server/domain/plugins/actions.d.ts

@@ -0,0 +1,246 @@
+import * as Schema from "effect/Schema";
+/** Lowercase SHA-256 digest of a canonical governed-action payload. */
+export declare const PluginActionPayloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+/** Decoded canonical payload digest. */
+export type PluginActionPayloadDigest = typeof PluginActionPayloadDigest.Type;
+/** Opaque provider locator used to reconcile a mutation without replaying it. */
+export declare const PluginActionReconciliationKey: Schema.brand<Schema.String, string>;
+/** Decoded provider reconciliation locator. */
+export type PluginActionReconciliationKey = typeof PluginActionReconciliationKey.Type;
+/** Opaque provider identity of one accepted or completed mutation. */
+export declare const PluginProviderOperationId: Schema.brand<Schema.String, string>;
+/** Decoded provider mutation identity. */
+export type PluginProviderOperationId = typeof PluginProviderOperationId.Type;
+/** Request for a provider-neutral action proposal; it cannot authorize execution. */
+export declare const ProposePluginActionRequestV1: Schema.Struct<{
+    readonly actionKind: Schema.brand<Schema.String, string>;
+    readonly target: Schema.Struct<{
+        entityType: Schema.brand<Schema.String, string>;
+        vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+    }>;
+    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+}>;
+/** Proposal returned to the host for later policy and human authorization. */
+export declare const PluginActionProposalV1: Schema.Struct<{
+    readonly proposalKey: Schema.brand<Schema.String, string>;
+    readonly capabilityVersion: Schema.Int;
+    readonly request: Schema.Struct<{
+        readonly actionKind: Schema.brand<Schema.String, string>;
+        readonly target: Schema.Struct<{
+            entityType: Schema.brand<Schema.String, string>;
+            vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>;
+        readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+        readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+    }>;
+    readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+    readonly summary: Schema.String;
+    readonly impact: Schema.Struct<{
+        readonly level: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+        readonly summary: Schema.String;
+    }>;
+    readonly proposedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Host-authorized request accepted only by the sealed internal executor. */
+export declare const AuthorizedPluginActionV1: Schema.Struct<{
+    readonly proposal: Schema.Struct<{
+        readonly proposalKey: Schema.brand<Schema.String, string>;
+        readonly capabilityVersion: Schema.Int;
+        readonly request: Schema.Struct<{
+            readonly actionKind: Schema.brand<Schema.String, string>;
+            readonly target: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+        }>;
+        readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+        readonly summary: Schema.String;
+        readonly impact: Schema.Struct<{
+            readonly level: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+            readonly summary: Schema.String;
+        }>;
+        readonly proposedAt: Schema.DateTimeUtcFromString;
+    }>;
+    readonly idempotencyKey: Schema.brand<Schema.String, string>;
+    readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+    readonly authorizationId: Schema.brand<Schema.String, string>;
+    readonly authorizedAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>;
+/** Accepted provider work that remains unresolved and can be reconciled safely. */
+export declare const PluginAcceptedProviderReceiptV1: Schema.Struct<{
+    readonly status: Schema.Literal<"accepted">;
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly providerOperationId: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Terminal provider receipt safe to persist and display without raw response data. */
+export declare const PluginTerminalProviderReceiptV1: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+    readonly providerOperationId: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Provider receipt that never represents accepted asynchronous work as terminal. */
+export declare const PluginProviderReceiptV1: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"accepted">;
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly providerOperationId: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>, Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+    readonly providerOperationId: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>]>;
+/** Provider preflight that confirms the exact revision is ready for dispatch. */
+export declare const ReadyPluginActionPreflightV1: Schema.TaggedStruct<"ready", {
+    readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Provider preflight that blocks dispatch with bounded safe reasons. */
+export declare const BlockedPluginActionPreflightV1: Schema.TaggedStruct<"blocked", {
+    readonly reasons: Schema.$Array<Schema.String>;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Result of the final provider preflight before dispatch. */
+export declare const PluginActionPreflightV1: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"ready", {
+    readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>, Schema.TaggedStruct<"blocked", {
+    readonly reasons: Schema.$Array<Schema.String>;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>]>;
+/** Truthful immediate outcome of one authorized provider dispatch. */
+export declare const PluginActionDispatchResultV1: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"confirmed", {
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.TaggedStruct<"unknown", {
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>]>;
+/** Request to cancel an action after its durable lifecycle permits cancellation. */
+export declare const PluginActionCancellationRequestV1: Schema.Struct<{
+    readonly idempotencyKey: Schema.brand<Schema.String, string>;
+    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+}>;
+/** Truthful cancellation response; provider completion may win the race. */
+export declare const PluginActionCancellationResultV1: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"cancelled">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"completed">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.TaggedStruct<"unknown", {
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>]>;
+/** Request to reconcile without replay; null locates the mutation by its durable idempotency key. */
+export declare const PluginActionReconciliationRequestV1: Schema.Struct<{
+    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly idempotencyKey: Schema.brand<Schema.String, string>;
+    readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+}>;
+/** Reconciled provider state. Cancelled means the mutation provably did not occur. */
+export declare const PluginActionReconciliationResultV1: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"pending", {
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"succeeded">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"failed">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"cancelled">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>]>;
+export type ProposePluginActionRequestV1 = typeof ProposePluginActionRequestV1.Type;
+export type PluginActionProposalV1 = typeof PluginActionProposalV1.Type;
+export type AuthorizedPluginActionV1 = typeof AuthorizedPluginActionV1.Type;
+export type PluginAcceptedProviderReceiptV1 = typeof PluginAcceptedProviderReceiptV1.Type;
+export type PluginTerminalProviderReceiptV1 = typeof PluginTerminalProviderReceiptV1.Type;
+export type PluginProviderReceiptV1 = typeof PluginProviderReceiptV1.Type;
+export type ReadyPluginActionPreflightV1 = typeof ReadyPluginActionPreflightV1.Type;
+export type BlockedPluginActionPreflightV1 = typeof BlockedPluginActionPreflightV1.Type;
+export type PluginActionPreflightV1 = typeof PluginActionPreflightV1.Type;
+export type PluginActionDispatchResultV1 = typeof PluginActionDispatchResultV1.Type;
+export type PluginActionCancellationRequestV1 = typeof PluginActionCancellationRequestV1.Type;
+export type PluginActionCancellationResultV1 = typeof PluginActionCancellationResultV1.Type;
+export type PluginActionReconciliationRequestV1 = typeof PluginActionReconciliationRequestV1.Type;
+export type PluginActionReconciliationResultV1 = typeof PluginActionReconciliationResultV1.Type;
+//# sourceMappingURL=actions.d.ts.map

package/dist/server/domain/plugins/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../src/domain/plugins/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAavC,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,0DAEW,CAAA;AAEjD,wCAAwC;AACxC,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,qCAAsD,CAAA;AAEhG,+CAA+C;AAC/C,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAC,IAAI,CAAA;AAErF,sEAAsE;AACtE,eAAO,MAAM,yBAAyB,qCAAkD,CAAA;AAExF,0CAA0C;AAC1C,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,qFAAqF;AACrF,eAAO,MAAM,4BAA4B;;;;;;;;;EAWvC,CAAA;AAEF,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;EAWjC,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpC,CAAA;AAQD,mFAAmF;AACnF,eAAO,MAAM,+BAA+B;;;;;;EAI1C,CAAA;AAEF,uFAAuF;AACvF,eAAO,MAAM,+BAA+B;;;;;EAG1C,CAAA;AAEF,qFAAqF;AACrF,eAAO,MAAM,uBAAuB;;;;;;;;;;;IAGlC,CAAA;AAEF,iFAAiF;AACjF,eAAO,MAAM,4BAA4B;;;EAGvC,CAAA;AAEF,yEAAyE;AACzE,eAAO,MAAM,8BAA8B;;;EAQzC,CAAA;AAEF,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB;;;;;;IAKnC,CAAA;AAWD,sEAAsE;AACtE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;IAExC,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,iCAAiC;;;;EAS7C,CAAA;AAED,4EAA4E;AAC5E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAaR,CAAA;AAErC,qGAAqG;AACrG,eAAO,MAAM,mCAAmC;;;;EAI9C,CAAA;AAEF,sFAAsF;AACtF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWV,CAAA;AAErC,MAAM,MAAM,4BAA4B,GAAG,OAAO,4BAA4B,CAAC,IAAI,CAAA;AACnF,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAA;AACvE,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAA;AAC3E,MAAM,MAAM,+BAA+B,GAAG,OAAO,+BAA+B,CAAC,IAAI,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,OAAO,+BAA+B,CAAC,IAAI,CAAA;AACzF,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AACzE,MAAM,MAAM,4BAA4B,GAAG,OAAO,4BAA4B,CAAC,IAAI,CAAA;AACnF,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AACvF,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AACzE,MAAM,MAAM,4BAA4B,GAAG,OAAO,4BAA4B,CAAC,IAAI,CAAA;AACnF,MAAM,MAAM,iCAAiC,GAAG,OAAO,iCAAiC,CAAC,IAAI,CAAA;AAC7F,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAC,IAAI,CAAA;AAC3F,MAAM,MAAM,mCAAmC,GAAG,OAAO,mCAAmC,CAAC,IAAI,CAAA;AACjG,MAAM,MAAM,kCAAkC,GAAG,OAAO,kCAAkC,CAAC,IAAI,CAAA"}

package/dist/server/domain/plugins/bounds.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+/** Maximum persisted or dispatched JSON payload accepted from a plugin boundary. */
+export declare const MaximumPluginPayloadBytes = 262144;
+/** Maximum encoded size of one atomic normalized sync page. */
+export declare const MaximumPluginSyncPageBytes = 1048576;
+/** Maximum canonical descriptor JSON accepted before adapter construction. */
+export declare const MaximumPluginDescriptorBytes = 61440;
+/** Bounded JSON for normalized evidence and governed-action payloads. */
+export declare const PluginPayloadJson: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+/** Applies a deterministic upper bound to an already-decoded JSON-shaped value. */
+export declare const hasMaximumPluginJsonBytes: (maximumBytes: number) => import("effect/SchemaAST").Filter<unknown>;
+//# sourceMappingURL=bounds.d.ts.map

package/dist/server/domain/plugins/bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../../../src/domain/plugins/bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAavC,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,SAAU,CAAA;AAEhD,+DAA+D;AAC/D,eAAO,MAAM,0BAA0B,UAAY,CAAA;AAEnD,8EAA8E;AAC9E,eAAO,MAAM,4BAA4B,QAAS,CAAA;AAElD,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,sDAE5B,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,iBAxBK,MAAM,+CAwBW,CAAA"}